diff --git a/dianna/__init__.py b/dianna/__init__.py
index ed8e0fb8..e229f739 100644
--- a/dianna/__init__.py
+++ b/dianna/__init__.py
@@ -31,14 +31,13 @@
 __version__ = '1.2.0'
 
 
-def explain_timeseries(model_or_function, timeseries_data, method, labels,
-                       **kwargs):
+def explain_timeseries(model_or_function, input_timeseries, method, labels, **kwargs):
     """Explain timeseries data given a model and a chosen method.
 
     Args:
         model_or_function (callable or str): The function that runs the model to be explained _or_
                                              the path to a ONNX model on disk.
-        timeseries_data (np.ndarray): Timeseries data to be explained
+        input_timeseries (np.ndarray): Timeseries data to be explained
         method (string): One of the supported methods: RISE, LIME or KernelSHAP
         labels (Iterable(int)): Labels to be explained
         kwargs: key word arguments
@@ -49,18 +48,20 @@ def explain_timeseries(model_or_function, timeseries_data, method, labels,
     """
     explainer = _get_explainer(method, kwargs, modality='Timeseries')
     explain_timeseries_kwargs = utils.get_kwargs_applicable_to_function(
-        explainer.explain, kwargs)
-    return explainer.explain(model_or_function, timeseries_data, labels,
-                             **explain_timeseries_kwargs)
+        explainer.explain, kwargs
+    )
+    return explainer.explain(
+        model_or_function, input_timeseries, labels, **explain_timeseries_kwargs
+    )
 
 
-def explain_image(model_or_function, input_data, method, labels, **kwargs):
+def explain_image(model_or_function, input_image, method, labels, **kwargs):
     """Explain an image (input_data) given a model and a chosen method.
 
     Args:
         model_or_function (callable or str): The function that runs the model to be explained _or_
                                              the path to a ONNX model on disk.
-        input_data (np.ndarray): Image data to be explained
+        input_image (np.ndarray): Image data to be explained
         method (string): One of the supported methods: RISE, LIME or KernelSHAP
         labels (Iterable(int)): Labels to be explained
         kwargs: These keyword parameters are passed on
@@ -74,13 +75,14 @@ def explain_image(model_or_function, input_data, method, labels, **kwargs):
         from onnx_tf.backend import prepare  # noqa: F401
     explainer = _get_explainer(method, kwargs, modality='Image')
     explain_image_kwargs = utils.get_kwargs_applicable_to_function(
-        explainer.explain, kwargs)
-    return explainer.explain(model_or_function, input_data, labels,
-                             **explain_image_kwargs)
+        explainer.explain, kwargs
+    )
+    return explainer.explain(
+        model_or_function, input_image, labels, **explain_image_kwargs
+    )
 
 
-def explain_text(model_or_function, input_text, tokenizer, method, labels,
-                 **kwargs):
+def explain_text(model_or_function, input_text, tokenizer, method, labels, **kwargs):
     """Explain text (input_text) given a model and a chosen method.
 
     Args:
@@ -98,7 +100,8 @@ def explain_text(model_or_function, input_text, tokenizer, method, labels,
     """
     explainer = _get_explainer(method, kwargs, modality='Text')
     explain_text_kwargs = utils.get_kwargs_applicable_to_function(
-        explainer.explain, kwargs)
+        explainer.explain, kwargs
+    )
     return explainer.explain(
         model_or_function=model_or_function,
         input_text=input_text,
@@ -108,10 +111,36 @@ def explain_text(model_or_function, input_text, tokenizer, method, labels,
     )
 
 
+def explain_tabular(model_or_function, input_tabular, method, labels=(1, ), **kwargs):
+    """Explain tabular (input_text) given a model and a chosen method.
+
+    Args:
+        model_or_function (callable or str): The function that runs the model to be explained _or_
+                                             the path to a ONNX model on disk.
+        input_tabular (np.ndarray): Tabular data to be explained
+        method (string): One of the supported methods: RISE, LIME or KernelSHAP
+        labels (Iterable(int), optional): Labels to be explained
+        kwargs: These keyword parameters are passed on
+
+    Returns:
+        One heatmap (2D array) per class.
+    """
+    explainer = _get_explainer(method, kwargs, modality='Tabular')
+    explain_tabular_kwargs = utils.get_kwargs_applicable_to_function(
+        explainer.explain, kwargs
+    )
+    return explainer.explain(
+        model_or_function=model_or_function,
+        input_tabular=input_tabular,
+        labels=labels,
+        **explain_tabular_kwargs,
+    )
+
 def _get_explainer(method, kwargs, modality):
     try:
         method_submodule = importlib.import_module(
-            f'dianna.methods.{method.lower()}_{modality.lower()}')
+            f'dianna.methods.{method.lower()}_{modality.lower()}'
+        )
     except ImportError as err:
         raise ValueError(
             f'Method {method.lower()}_{modality.lower()} does not exist'
@@ -123,5 +152,6 @@ def _get_explainer(method, kwargs, modality):
             f'Data modality {modality} is not available for method {method.upper()}'
         ) from err
     method_kwargs = utils.get_kwargs_applicable_to_function(
-        method_class.__init__, kwargs)
+        method_class.__init__, kwargs
+    )
     return method_class(**method_kwargs)
diff --git a/dianna/dashboard/_models_ts.py b/dianna/dashboard/_models_ts.py
index 31670bcb..02ef27b4 100644
--- a/dianna/dashboard/_models_ts.py
+++ b/dianna/dashboard/_models_ts.py
@@ -27,7 +27,7 @@ def run_model(ts_data):
 
     explanation = dianna.explain_timeseries(
         run_model,
-        timeseries_data=ts_data[0],
+        input_timeseries=ts_data[0],
         method='RISE',
         **kwargs,
     )
diff --git a/dianna/methods/lime_tabular.py b/dianna/methods/lime_tabular.py
new file mode 100644
index 00000000..d72bbc22
--- /dev/null
+++ b/dianna/methods/lime_tabular.py
@@ -0,0 +1,135 @@
+"""LIME tabular explainer."""
+from typing import Iterable
+from typing import List
+from typing import Union
+import numpy as np
+from lime.lime_tabular import LimeTabularExplainer
+from dianna import utils
+
+
+class LIMETabular:
+    """Wrapper around the LIME explainer for tabular data."""
+
+    def __init__(
+        self,
+        training_data: np.array,
+        mode: str = "classification",
+        feature_names: List[int] = None,
+        categorical_features: List[int] = None,
+        kernel_width: int = 25,
+        kernel: callable = None,
+        verbose: bool = False,
+        class_names: List[str] = None,
+        feature_selection: str = "auto",
+        random_state: int = None,
+        **kwargs,
+    ) -> None:
+        """Initializes Lime explainer.
+
+        For numerical features, perturb them by sampling from a Normal(0,1) and
+        doing the inverse operation of mean-centering and scaling, according to the
+        means and stds in the training data.
+
+        For categorical features, perturb by sampling according to the training
+        distribution, and making a binary feature that is 1 when the value is the
+        same as the instance being explained.
+
+        More information can be found in the API guide:
+        https://lime-ml.readthedocs.io/en/latest/lime.html#module-lime.lime_tabular
+
+        Args:
+            training_data (np.array): numpy 2d array
+            mode (str, optional): "classification" or "regression"
+            feature_names (list(str), optional): list of names corresponding to the columns
+                           in the training data.
+            categorical_features (list(int), optional): list of indices corresponding to the
+                                                   categorical columns. Values in these
+                                                   columns MUST be integers.
+            kernel_width (int, optional): kernel width
+            kernel (callable, optional): kernel
+            verbose (bool, optional): verbose
+            class_names (str, optional): list of class names, ordered according to whatever
+                                         the classifier is using. If not present, class names
+                                         will be '0', '1', ...
+            feature_selection (str, optional): feature selection
+            random_state (int or np.RandomState, optional): seed or random state
+            kwargs: These parameters are passed on
+
+        """
+        self.mode = mode
+        init_instance_kwargs = utils.get_kwargs_applicable_to_function(
+            LimeTabularExplainer, kwargs
+        )
+
+        # temporary solution for setting num_features and top_labels
+        self.num_features = len(feature_names)
+        self.top_labels = len(class_names)
+
+        self.explainer = LimeTabularExplainer(
+            training_data,
+            mode=self.mode,
+            feature_names=feature_names,
+            categorical_features=categorical_features,
+            kernel_width=kernel_width,
+            kernel=kernel,
+            verbose=verbose,
+            class_names=class_names,
+            feature_selection=feature_selection,
+            random_state=random_state,
+            **init_instance_kwargs,
+        )
+
+    def explain(
+        self,
+        model_or_function: Union[str, callable],
+        input_tabular: np.array,
+        labels: Iterable[int] = (1,),
+        num_samples: int = 5000,
+        **kwargs,
+    ) -> np.array:
+        """Run the LIME explainer.
+
+        Args:
+            model_or_function (callable or str): The function that runs the model to be explained
+                                                 or the path to a ONNX model on disk.
+            input_tabular (np.ndarray): Data to be explained.
+            labels (Iterable(int), optional): Indices of classes to be explained.
+            num_samples (int, optional): Number of samples
+            kwargs: These parameters are passed on
+
+        Other keyword arguments: see the documentation for LimeTabularExplainer.explain_instance:
+        https://lime-ml.readthedocs.io/en/latest/lime.html#lime.lime_tabular.LimeTabularExplainer.explain_instance
+
+        Returns:
+            explanation: An Explanation object containing the LIME explanations for each class.
+        """
+        # run the explanation.
+        explain_instance_kwargs = utils.get_kwargs_applicable_to_function(
+            self.explainer.explain_instance, kwargs
+        )
+        runner = utils.get_function(model_or_function)
+
+        explanation = self.explainer.explain_instance(
+            input_tabular,
+            runner,
+            labels=labels,
+            top_labels=self.top_labels,
+            num_features=self.num_features,
+            num_samples=num_samples,
+            **explain_instance_kwargs,
+        )
+
+        if self.mode == "regression":
+            local_exp = sorted(explanation.local_exp[1])
+            saliency = [i[1] for i in local_exp]
+
+        elif self.mode == "classification":
+            # extract scores from lime explainer
+            saliency = []
+            for i in range(self.top_labels):
+                local_exp = sorted(explanation.local_exp[i])
+                # shape of local_exp [(index, saliency)]
+                selected_saliency = [x[1] for x in local_exp]
+                saliency.append(selected_saliency[:])
+
+        return np.array(saliency)
diff --git a/setup.cfg b/setup.cfg
index f09ccab2..f1506575 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -104,6 +104,7 @@ notebooks =
     scipy
     skl2onnx
     spacy
+    seaborn
     tf2onnx
     torch
     torchtext
diff --git a/tests/methods/test_lime_tabular.py b/tests/methods/test_lime_tabular.py
new file mode 100644
index 00000000..3627712e
--- /dev/null
+++ b/tests/methods/test_lime_tabular.py
@@ -0,0 +1,36 @@
+"""Test LIME tabular method."""
+from unittest import TestCase
+import numpy as np
+import dianna
+from dianna.methods.lime_tabular import LIMETabular
+from tests.utils import run_model
+
+
+class LIMEOnTabular(TestCase):
+    """Suite of LIME tests for the tabular case."""
+
+    def test_lime_tabular_classification_correct_output_shape(self):
+        """Test the output of explainer."""
+        training_data = np.random.random((10, 2))
+        input_data = np.random.random(2)
+        feature_names = ["feature_1", "feature_2"]
+        explainer = LIMETabular(training_data,
+                                mode ='classification',
+                                feature_names=feature_names,
+                                class_names = ["class_1", "class_2"])
+        exp = explainer.explain(
+            run_model,
+            input_data,
+        )
+        assert len(exp[0]) == len(feature_names)
+
+    def test_lime_tabular_regression_correct_output_shape(self):
+        """Test the output of explainer."""
+        training_data = np.random.random((10, 2))
+        input_data = np.random.random(2)
+        feature_names = ["feature_1", "feature_2"]
+        exp = dianna.explain_tabular(run_model, input_tabular=input_data, method='lime',
+                             mode ='regression', training_data = training_data,
+                             feature_names=feature_names, class_names=['class_1'])
+
+        assert len(exp) == len(feature_names)
diff --git a/tests/methods/test_rise_timeseries.py b/tests/methods/test_rise_timeseries.py
index d34800bc..ae4aeeb3 100644
--- a/tests/methods/test_rise_timeseries.py
+++ b/tests/methods/test_rise_timeseries.py
@@ -25,7 +25,7 @@ def test_rise_timeseries_with_expert_model_for_correct_max_and_min():
     temperature_timeseries = average_temperature_timeseries_with_1_cold_and_1_hot_day(cold_day_index, hot_day_index)
 
     summer_explanation, winter_explanation = dianna.explain_timeseries(run_expert_model,
-                                                                       timeseries_data=temperature_timeseries,
+                                                                       input_timeseries=temperature_timeseries,
                                                                        method='rise',
                                                                        labels=[0, 1],
                                                                        p_keep=0.1, n_masks=10000,
diff --git a/tutorials/lime_tabular_penguin.ipynb b/tutorials/lime_tabular_penguin.ipynb
new file mode 100644
index 00000000..6c1049c2
--- /dev/null
+++ b/tutorials/lime_tabular_penguin.ipynb
@@ -0,0 +1,444 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\n",
+    "\n",
+    "### Model Interpretation using LIME for penguin dataset classifier\n",
+    "This notebook demonstrates the use of DIANNA with the LIME tabular method on the penguins dataset.\n",
+    "\n",
+    "LIME (Local Interpretable Model-agnostic Explanations) is an explainable-AI method that aims to create an interpretable model that locally represents the classifier. For more details see the [LIME paper](https://arxiv.org/abs/1602.04938)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Colab setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "running_in_colab = 'google.colab' in str(get_ipython())\n",
+    "if running_in_colab:\n",
+    "  # install dianna\n",
+    "  !python3 -m pip install dianna[notebooks]\n",
+    "  \n",
+    "  # download data used in this demo\n",
+    "  import os \n",
+    "  base_url = 'https://raw.githubusercontent.com/dianna-ai/dianna/main/tutorials/'\n",
+    "  paths_to_download = ['models/penguin_model.onnx']\n",
+    "  for path in paths_to_download:\n",
+    "      !wget {base_url + path} -P {os.path.dirname(path)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dianna\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from dianna.utils.onnx_runner import SimpleModelRunner"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1 - Loading the data\n",
+    "Load penguins dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "penguins = sns.load_dataset('penguins')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Prepare the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "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>bill_length_mm</th>\n",
+       "      <th>bill_depth_mm</th>\n",
+       "      <th>flipper_length_mm</th>\n",
+       "      <th>body_mass_g</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>39.1</td>\n",
+       "      <td>18.7</td>\n",
+       "      <td>181.0</td>\n",
+       "      <td>3750.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>39.5</td>\n",
+       "      <td>17.4</td>\n",
+       "      <td>186.0</td>\n",
+       "      <td>3800.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>40.3</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>195.0</td>\n",
+       "      <td>3250.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>36.7</td>\n",
+       "      <td>19.3</td>\n",
+       "      <td>193.0</td>\n",
+       "      <td>3450.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>39.3</td>\n",
+       "      <td>20.6</td>\n",
+       "      <td>190.0</td>\n",
+       "      <td>3650.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>338</th>\n",
+       "      <td>47.2</td>\n",
+       "      <td>13.7</td>\n",
+       "      <td>214.0</td>\n",
+       "      <td>4925.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>340</th>\n",
+       "      <td>46.8</td>\n",
+       "      <td>14.3</td>\n",
+       "      <td>215.0</td>\n",
+       "      <td>4850.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>341</th>\n",
+       "      <td>50.4</td>\n",
+       "      <td>15.7</td>\n",
+       "      <td>222.0</td>\n",
+       "      <td>5750.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>342</th>\n",
+       "      <td>45.2</td>\n",
+       "      <td>14.8</td>\n",
+       "      <td>212.0</td>\n",
+       "      <td>5200.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>343</th>\n",
+       "      <td>49.9</td>\n",
+       "      <td>16.1</td>\n",
+       "      <td>213.0</td>\n",
+       "      <td>5400.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>342 rows × 4 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     bill_length_mm  bill_depth_mm  flipper_length_mm  body_mass_g\n",
+       "0              39.1           18.7              181.0       3750.0\n",
+       "1              39.5           17.4              186.0       3800.0\n",
+       "2              40.3           18.0              195.0       3250.0\n",
+       "4              36.7           19.3              193.0       3450.0\n",
+       "5              39.3           20.6              190.0       3650.0\n",
+       "..              ...            ...                ...          ...\n",
+       "338            47.2           13.7              214.0       4925.0\n",
+       "340            46.8           14.3              215.0       4850.0\n",
+       "341            50.4           15.7              222.0       5750.0\n",
+       "342            45.2           14.8              212.0       5200.0\n",
+       "343            49.9           16.1              213.0       5400.0\n",
+       "\n",
+       "[342 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Remove categorial columns and NaN values\n",
+    "penguins_filtered = penguins.drop(columns=['island', 'sex']).dropna()\n",
+    "\n",
+    "# Get the species\n",
+    "species = penguins['species'].unique()\n",
+    "\n",
+    "# Extract inputs and target\n",
+    "input_features = penguins_filtered.drop(columns=['species'])\n",
+    "target = pd.get_dummies(penguins_filtered['species'])\n",
+    "\n",
+    "# Let's explore the features of the dataset\n",
+    "input_features"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data-set currently has four features that were used to train the model: bill length, bill depth, flipper length, and body mass. These features were used to classify the different species."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training, validation, and test data split."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(input_features, target, test_size=0.2,\n",
+    "                                                    random_state=0, shuffle=True, stratify=target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get an instance to explain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get an instance from test data\n",
+    "data_instance = X_test.iloc[10].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. Loading ONNX model\n",
+    "DIANNA supports ONNX models. Here we demonstrate the use of LIME explainer for tabular data with a pre-trained ONNX model, which is a MLP classifier for the penguins dataset. <br>\n",
+    "\n",
+    "The model is trained following this notebook: <br>\n",
+    "https://github.com/dianna-ai/dianna-exploration/blob/main/example_data/model_generation/penguin_species/generate_model.ipynb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Gentoo'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# load onnx model and check the prediction with it\n",
+    "model_path = './models/penguin_model.onnx'\n",
+    "loaded_model = SimpleModelRunner(model_path)\n",
+    "predictions = loaded_model(data_instance.reshape(1,-1).astype(np.float32))\n",
+    "species[np.argmax(predictions)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A runner function is created to prepare data for the ONNX inference session."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import onnxruntime as ort\n",
+    "\n",
+    "def run_model(data):\n",
+    "    # get ONNX predictions\n",
+    "    sess = ort.InferenceSession(model_path)\n",
+    "    input_name = sess.get_inputs()[0].name\n",
+    "    output_name = sess.get_outputs()[0].name\n",
+    "\n",
+    "    onnx_input = {input_name: data.astype(np.float32)}\n",
+    "    pred_onnx = sess.run([output_name], onnx_input)[0]\n",
+    "    pred_onnx\n",
+    "    \n",
+    "    return pred_onnx"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Applying LIME with DIANNA\n",
+    "The simplest way to run DIANNA on image data is with `dianna.explain_tabular`.\n",
+    "\n",
+    "DIANNA requires input in numpy format, so the input data is converted into a numpy array.\n",
+    "\n",
+    "Note that the training data is also required since LIME needs it to generate proper perturbation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "explanation = dianna.explain_tabular(run_model, input_tabular=data_instance, method='lime',\n",
+    "                                     mode ='classification', training_data = X_train.to_numpy(),\n",
+    "                                     feature_names=input_features.columns, class_names=species,\n",
+    "                                     discretize_continuous=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Visualization\n",
+    "(TODO:) The output can be visualized with the DIANNA built-in visualization function. It shows the importance of each feature contributing to the prediction.\n",
+    "\n",
+    "The prediction is \"Gentoo\", so let's visualize the feature importance scores for \"Gentoo\".\n",
+    "\n",
+    "It can be noticed that the body mass feature has the biggest weight in the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get the scores for the target class\n",
+    "explanation = explanation[np.argmax(predictions)]\n",
+    "\n",
+    "# rank the results based on the absolute values\n",
+    "# and pick up the top 10 of them\n",
+    "num_features = 10\n",
+    "abs_values = [abs(i) for i in explanation]\n",
+    "top_values = [x for _, x in sorted(zip(abs_values, explanation), reverse=True)][:num_features]\n",
+    "top_features = [x for _, x in sorted(zip(abs_values, X_test.columns), reverse=True)][:num_features]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "colors = ['b' if x >= 0 else 'r' for x in top_values]\n",
+    "\n",
+    "plt.barh(top_features, top_values, color=colors)\n",
+    "plt.xlabel(\"Features\")\n",
+    "plt.ylabel(\"Importance scores\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dianna",
+   "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/lime_tabular_weather.ipynb b/tutorials/lime_tabular_weather.ipynb
new file mode 100644
index 00000000..b597f25f
--- /dev/null
+++ b/tutorials/lime_tabular_weather.ipynb
@@ -0,0 +1,287 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img width=\"150\" alt=\"Logo_ER10\" src=\"https://user-images.githubusercontent.com/3244249/151994514-b584b984-a148-4ade-80ee-0f88b0aefa45.png\">\n",
+    "\n",
+    "### Model Interpretation using LIME for weather prediction regressor\n",
+    "This notebook demonstrates the use of DIANNA with the LIME tabular method on the weather dataset.\n",
+    "\n",
+    "LIME (Local Interpretable Model-agnostic Explanations) is an explainable-AI method that aims to create an interpretable model that locally represents the classifier. For more details see the [LIME paper](https://arxiv.org/abs/1602.04938)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Colab setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "running_in_colab = 'google.colab' in str(get_ipython())\n",
+    "if running_in_colab:\n",
+    "  # install dianna\n",
+    "  !python3 -m pip install dianna[notebooks]\n",
+    "  \n",
+    "  # download data used in this demo\n",
+    "  import os\n",
+    "  base_url = 'https://raw.githubusercontent.com/dianna-ai/dianna/main/tutorials/'\n",
+    "  paths_to_download = ['models/sunshine_hours_regression_model.onnx']\n",
+    "  for path in paths_to_download:\n",
+    "      !wget {base_url + path} -P {os.path.dirname(path)}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dianna\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from dianna.utils.onnx_runner import SimpleModelRunner"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1 - Loading the data\n",
+    "Load weather prediction dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = pd.read_csv(\"https://zenodo.org/record/5071376/files/weather_prediction_dataset_light.csv?download=1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Prepare the data\n",
+    "As the target, the sunshine hours for the next day in the data-set will be used. Therefore, we will remove the last data point as this has no target. A tabular regression model will be trained which does not require time-based data, therefore DATE and MONTH can be removed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_data = data.drop(columns=['DATE', 'MONTH'])[:-1]\n",
+    "y_data = data.loc[1:][\"BASEL_sunshine\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training, validation, and test data split."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_holdout, y_train, y_holdout = train_test_split(X_data, y_data, test_size=0.3, random_state=0)\n",
+    "X_val, X_test, y_val, y_test = train_test_split(X_holdout, y_holdout, test_size=0.5, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Get an instance to explain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get an instance from test data\n",
+    "data_instance = X_test.iloc[10].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. Loading ONNX model\n",
+    "DIANNA supports ONNX models. Here we demonstrate the use of LIME explainer for tabular data with a pre-trained ONNX model, which is a MLP regressor for the weather dataset. <br>\n",
+    "\n",
+    "The model is trained following this notebook: <br>\n",
+    "https://github.com/dianna-ai/dianna-exploration/blob/main/example_data/model_generation/sunshine_prediction/generate_model.ipynb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[3.0719438]], dtype=float32)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# load onnx model and check the prediction with it\n",
+    "model_path = './models/sunshine_hours_regression_model.onnx'\n",
+    "loaded_model = SimpleModelRunner(model_path)\n",
+    "predictions = loaded_model(data_instance.reshape(1,-1).astype(np.float32))\n",
+    "predictions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A runner function is created to prepare data for the ONNX inference session."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import onnxruntime as ort\n",
+    "\n",
+    "def run_model(data):\n",
+    "    # get ONNX predictions\n",
+    "    sess = ort.InferenceSession(model_path)\n",
+    "    input_name = sess.get_inputs()[0].name\n",
+    "    output_name = sess.get_outputs()[0].name\n",
+    "\n",
+    "    onnx_input = {input_name: data.astype(np.float32)}\n",
+    "    pred_onnx = sess.run([output_name], onnx_input)[0]\n",
+    "    pred_onnx\n",
+    "    \n",
+    "    return pred_onnx"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Applying LIME with DIANNA\n",
+    "The simplest way to run DIANNA on image data is with `dianna.explain_tabular`.\n",
+    "\n",
+    "DIANNA requires input in numpy format, so the input data is converted into a numpy array.\n",
+    "\n",
+    "Note that the training data is also required since LIME needs it to generate proper perturbation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "explanation = dianna.explain_tabular(run_model, input_tabular=data_instance, method='lime',\n",
+    "                                     mode ='regression', training_data = X_train.to_numpy(),\n",
+    "                                     feature_names=X_test.columns, class_names=['sunshine_hours'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Visualization\n",
+    "(TODO:) The output can be visualized with the DIANNA built-in visualization function. It shows the top 10 importance of each feature contributing to the prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# rank the results based on the absolute values\n",
+    "# and pick up the top 10 of them\n",
+    "num_features = 10\n",
+    "abs_values = [abs(i) for i in explanation]\n",
+    "top_values = [x for _, x in sorted(zip(abs_values, explanation), reverse=True)][:num_features]\n",
+    "top_features = [x for _, x in sorted(zip(abs_values, X_test.columns), reverse=True)][:num_features]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "colors = ['b' if x >= 0 else 'r' for x in top_values]\n",
+    "\n",
+    "plt.barh(top_features, top_values, color=colors)\n",
+    "plt.xlabel(\"Importance scores\")\n",
+    "plt.ylabel(\"Features\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dianna",
+   "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/lime_text.ipynb b/tutorials/lime_text.ipynb
index 1865b0b9..c2fc688c 100644
--- a/tutorials/lime_text.ipynb
+++ b/tutorials/lime_text.ipynb
@@ -59,14 +59,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "34b556d8-5337-44dc-8efe-14d1dff6f011",
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-11-21 16:35:38.025595: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2023-11-21 16:35:39.445116: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import matplotlib.pyplot as plt\n",
@@ -84,7 +94,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "c616916c-78ef-48d0-a744-b25b37b62a3f",
    "metadata": {
     "pycharm": {
@@ -115,7 +125,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "id": "486540bd-2676-4dfa-bbe8-ee8aa289acd3",
    "metadata": {
     "pycharm": {
@@ -128,42 +138,50 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Collecting en-core-web-sm==3.2.0\n",
-      "  Downloading https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.2.0/en_core_web_sm-3.2.0-py3-none-any.whl (13.9 MB)\n",
-      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 13.9/13.9 MB 3.6 MB/s eta 0:00:00\n",
-      "Requirement already satisfied: spacy<3.3.0,>=3.2.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from en-core-web-sm==3.2.0) (3.2.4)\n",
-      "Requirement already satisfied: click<8.1.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (8.0.4)\n",
-      "Requirement already satisfied: packaging>=20.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (21.3)\n",
-      "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.8 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.0.9)\n",
-      "Requirement already satisfied: srsly<3.0.0,>=2.4.1 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.4.3)\n",
-      "Requirement already satisfied: numpy>=1.15.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (1.21.6)\n",
-      "Requirement already satisfied: thinc<8.1.0,>=8.0.12 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (8.0.15)\n",
-      "Requirement already satisfied: pathy>=0.3.5 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (0.6.1)\n",
-      "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.9.0,>=1.7.4 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (1.8.2)\n",
-      "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.3.0)\n",
-      "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (0.4.1)\n",
-      "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (4.64.0)\n",
-      "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (1.0.6)\n",
-      "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.0.6)\n",
-      "Requirement already satisfied: blis<0.8.0,>=0.4.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (0.7.7)\n",
-      "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.0.6)\n",
-      "Requirement already satisfied: jinja2 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.1.1)\n",
-      "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (1.0.2)\n",
-      "Requirement already satisfied: setuptools in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (62.1.0)\n",
-      "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.0.7)\n",
-      "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.27.1)\n",
-      "Requirement already satisfied: wasabi<1.1.0,>=0.8.1 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (0.9.1)\n",
-      "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from packaging>=20.0->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.0.8)\n",
-      "Requirement already satisfied: smart-open<6.0.0,>=5.0.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from pathy>=0.3.5->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (5.2.1)\n",
-      "Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from pydantic!=1.8,!=1.8.1,<1.9.0,>=1.7.4->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (4.1.1)\n",
-      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (1.26.9)\n",
-      "Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.0.12)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (3.3)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2021.10.8)\n",
-      "Requirement already satisfied: MarkupSafe>=2.0 in /opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/site-packages (from jinja2->spacy<3.3.0,>=3.2.0->en-core-web-sm==3.2.0) (2.1.1)\n",
+      "Collecting en-core-web-sm==3.5.0\n",
+      "  Downloading https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.5.0/en_core_web_sm-3.5.0-py3-none-any.whl (12.8 MB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
+      "\u001b[?25hRequirement already satisfied: spacy<3.6.0,>=3.5.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from en-core-web-sm==3.5.0) (3.5.4)\n",
+      "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.11 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.0.12)\n",
+      "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.0.4)\n",
+      "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.0.9)\n",
+      "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.0.7)\n",
+      "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.0.8)\n",
+      "Requirement already satisfied: thinc<8.2.0,>=8.1.8 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (8.1.10)\n",
+      "Requirement already satisfied: wasabi<1.2.0,>=0.9.1 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.1.2)\n",
+      "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.4.6)\n",
+      "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.0.8)\n",
+      "Requirement already satisfied: typer<0.10.0,>=0.3.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.9.0)\n",
+      "Requirement already satisfied: pathy>=0.10.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.10.2)\n",
+      "Requirement already satisfied: smart-open<7.0.0,>=5.2.1 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (6.3.0)\n",
+      "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (4.65.0)\n",
+      "Requirement already satisfied: numpy>=1.15.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.23.5)\n",
+      "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.31.0)\n",
+      "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.11.0,>=1.7.4 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.10.10)\n",
+      "Requirement already satisfied: jinja2 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.1.2)\n",
+      "Requirement already satisfied: setuptools in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (65.5.0)\n",
+      "Requirement already satisfied: packaging>=20.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (23.1)\n",
+      "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.3.0)\n",
+      "Requirement already satisfied: typing-extensions>=4.2.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from pydantic!=1.8,!=1.8.1,<1.11.0,>=1.7.4->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (4.6.3)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.1.0)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.4)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.26.16)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2023.5.7)\n",
+      "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from thinc<8.2.0,>=8.1.8->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.7.9)\n",
+      "Requirement already satisfied: confection<1.0.0,>=0.0.1 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from thinc<8.2.0,>=8.1.8->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.1.0)\n",
+      "Requirement already satisfied: click<9.0.0,>=7.1.1 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from typer<0.10.0,>=0.3.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (8.1.3)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /home/yangliu/venv/dianna/lib/python3.10/site-packages (from jinja2->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.1.3)\n",
       "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n",
       "You can now load the package via spacy.load('en_core_web_sm')\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33mWARNING: There was an error checking the latest version of pip.\u001b[0m\u001b[33m\n",
+      "\u001b[0m"
+     ]
     }
    ],
    "source": [
@@ -173,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 4,
    "id": "555842c5-3f82-4f63-93bb-696645d4b447",
    "metadata": {
     "pycharm": {
@@ -220,7 +238,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "443e8a99-6fa3-4a73-9311-2fbe0251c2b1",
    "metadata": {
     "pycharm": {
@@ -254,7 +272,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "id": "7fc6ebcb-2328-4c06-ae67-c5590032eb69",
    "metadata": {
     "pycharm": {
@@ -268,7 +286,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 7,
    "id": "7c0bfd7d-df1d-4981-b714-496bc16b9347",
    "metadata": {
     "pycharm": {
@@ -277,36 +295,30 @@
    },
    "outputs": [
     {
-     "ename": "ValueError",
-     "evalue": "Method LIME does not exist",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
-      "File \u001b[0;32m~/Dropbox/eScience/projects/dianna-project/dianna/dianna/__init__.py:109\u001b[0m, in \u001b[0;36m_get_explainer\u001b[0;34m(method, kwargs, modality)\u001b[0m\n\u001b[1;32m    108\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 109\u001b[0m     method_submodule \u001b[39m=\u001b[39m importlib\u001b[39m.\u001b[39;49mimport_module(\u001b[39mf\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mdianna.methods.\u001b[39;49m\u001b[39m{\u001b[39;49;00mmethod\u001b[39m.\u001b[39;49mlower()\u001b[39m}\u001b[39;49;00m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m    110\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mImportError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n",
-      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/dianna/lib/python3.9/importlib/__init__.py:127\u001b[0m, in \u001b[0;36mimport_module\u001b[0;34m(name, package)\u001b[0m\n\u001b[1;32m    126\u001b[0m         level \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m--> 127\u001b[0m \u001b[39mreturn\u001b[39;00m _bootstrap\u001b[39m.\u001b[39;49m_gcd_import(name[level:], package, level)\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap>:1030\u001b[0m, in \u001b[0;36m_gcd_import\u001b[0;34m(name, package, level)\u001b[0m\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap>:1007\u001b[0m, in \u001b[0;36m_find_and_load\u001b[0;34m(name, import_)\u001b[0m\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap>:986\u001b[0m, in \u001b[0;36m_find_and_load_unlocked\u001b[0;34m(name, import_)\u001b[0m\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap>:680\u001b[0m, in \u001b[0;36m_load_unlocked\u001b[0;34m(spec)\u001b[0m\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap_external>:850\u001b[0m, in \u001b[0;36mexec_module\u001b[0;34m(self, module)\u001b[0m\n",
-      "File \u001b[0;32m<frozen importlib._bootstrap>:228\u001b[0m, in \u001b[0;36m_call_with_frames_removed\u001b[0;34m(f, *args, **kwds)\u001b[0m\n",
-      "File \u001b[0;32m~/Dropbox/eScience/projects/dianna-project/dianna/dianna/methods/lime.py:7\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[39m# To Do: remove this import when the method for different input type is splitted\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mdianna\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmethods\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlime_timeseries\u001b[39;00m \u001b[39mimport\u001b[39;00m LIMETimeseries  \u001b[39m# noqa: F401 ignore unused import\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mLIMEText\u001b[39;00m:\n",
-      "File \u001b[0;32m~/Dropbox/eScience/projects/dianna-project/dianna/dianna/methods/lime_timeseries.py:3\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msklearn\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfastdtw\u001b[39;00m \u001b[39mimport\u001b[39;00m fastdtw\n\u001b[1;32m      4\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mlime\u001b[39;00m \u001b[39mimport\u001b[39;00m explanation\n",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'fastdtw'",
-      "\nThe above exception was the direct cause of the following exception:\n",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[1;32m/Users/aronjansen/Dropbox/eScience/projects/dianna-project/dianna/tutorials/lime_text.ipynb Cell 13\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/aronjansen/Dropbox/eScience/projects/dianna-project/dianna/tutorials/lime_text.ipynb#X13sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# We're getting the explanation for the 'positive' class only, but dianna supports explaining for multiple labels in one\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/aronjansen/Dropbox/eScience/projects/dianna-project/dianna/tutorials/lime_text.ipynb#X13sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39m# go. It therefore always outputs a list of saliency maps. We want the first and only saliency map from this list here.\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/aronjansen/Dropbox/eScience/projects/dianna-project/dianna/tutorials/lime_text.ipynb#X13sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m explanation_relevance \u001b[39m=\u001b[39m dianna\u001b[39m.\u001b[39;49mexplain_text(model_runner, review, model_runner\u001b[39m.\u001b[39;49mtokenizer, \u001b[39m'\u001b[39;49m\u001b[39mLIME\u001b[39;49m\u001b[39m'\u001b[39;49m, labels\u001b[39m=\u001b[39;49m[labels\u001b[39m.\u001b[39;49mindex(\u001b[39m'\u001b[39;49m\u001b[39mpositive\u001b[39;49m\u001b[39m'\u001b[39;49m)])[\u001b[39m0\u001b[39m]\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/aronjansen/Dropbox/eScience/projects/dianna-project/dianna/tutorials/lime_text.ipynb#X13sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m explanation_relevance\n",
-      "File \u001b[0;32m~/Dropbox/eScience/projects/dianna-project/dianna/dianna/__init__.py:97\u001b[0m, in \u001b[0;36mexplain_text\u001b[0;34m(model_or_function, input_text, tokenizer, method, labels, **kwargs)\u001b[0m\n\u001b[1;32m     81\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mexplain_text\u001b[39m(model_or_function, input_text, tokenizer, method, labels, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m     82\u001b[0m     \u001b[39m\"\"\"Explain text (input_text) given a model and a chosen method.\u001b[39;00m\n\u001b[1;32m     83\u001b[0m \n\u001b[1;32m     84\u001b[0m \u001b[39m    Args:\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     95\u001b[0m \n\u001b[1;32m     96\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m---> 97\u001b[0m     explainer \u001b[39m=\u001b[39m _get_explainer(method, kwargs, modality\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mText\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m     98\u001b[0m     explain_text_kwargs \u001b[39m=\u001b[39m utils\u001b[39m.\u001b[39mget_kwargs_applicable_to_function(explainer\u001b[39m.\u001b[39mexplain, kwargs)\n\u001b[1;32m     99\u001b[0m     \u001b[39mreturn\u001b[39;00m explainer\u001b[39m.\u001b[39mexplain(\n\u001b[1;32m    100\u001b[0m         model_or_function\u001b[39m=\u001b[39mmodel_or_function,\n\u001b[1;32m    101\u001b[0m         input_text\u001b[39m=\u001b[39minput_text,\n\u001b[1;32m    102\u001b[0m         labels\u001b[39m=\u001b[39mlabels,\n\u001b[1;32m    103\u001b[0m         tokenizer\u001b[39m=\u001b[39mtokenizer,\n\u001b[1;32m    104\u001b[0m         \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mexplain_text_kwargs)\n",
-      "File \u001b[0;32m~/Dropbox/eScience/projects/dianna-project/dianna/dianna/__init__.py:111\u001b[0m, in \u001b[0;36m_get_explainer\u001b[0;34m(method, kwargs, modality)\u001b[0m\n\u001b[1;32m    109\u001b[0m     method_submodule \u001b[39m=\u001b[39m importlib\u001b[39m.\u001b[39mimport_module(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mdianna.methods.\u001b[39m\u001b[39m{\u001b[39;00mmethod\u001b[39m.\u001b[39mlower()\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m)\n\u001b[1;32m    110\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mImportError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[0;32m--> 111\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mMethod \u001b[39m\u001b[39m{\u001b[39;00mmethod\u001b[39m}\u001b[39;00m\u001b[39m does not exist\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m    112\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m    113\u001b[0m     method_class \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(method_submodule, \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00mmethod\u001b[39m.\u001b[39mupper()\u001b[39m}\u001b[39;00m\u001b[39m{\u001b[39;00mmodality\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n",
-      "\u001b[0;31mValueError\u001b[0m: Method LIME does not exist"
-     ]
+     "data": {
+      "text/plain": [
+       "[('intriguing', 3, 0.1542104335885818),\n",
+       " ('delectable', 1, 0.06238614802957715),\n",
+       " ('thriller', 4, 0.060795676689237396),\n",
+       " ('A', 0, 0.021020044831623636),\n",
+       " ('and', 2, 0.018838286814627653),\n",
+       " ('filled', 5, -0.013061654174455994),\n",
+       " ('with', 6, 0.012917500384050744),\n",
+       " ('surprises', 7, 0.006322756636057935)]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "# We're getting the explanation for the 'positive' class only, but dianna supports explaining for multiple labels in one\n",
-    "# go. It therefore always outputs a list of saliency maps. We want the first and only saliency map from this list here.\n",
-    "explanation_relevance = dianna.explain_text(model_runner, review, model_runner.tokenizer, 'LIME', labels=[labels.index('positive')])[0]\n",
+    "# We're getting the explanation for the 'positive' class only,\n",
+    "# but dianna supports explaining for multiple labels in one go.\n",
+    "# It therefore always outputs a list of saliency maps. We want\n",
+    "# the first and only saliency map from this list here.\n",
+    "explanation_relevance = dianna.explain_text(model_runner, review, model_runner.tokenizer,\n",
+    "                                            'LIME', labels=[labels.index('positive')])[0]\n",
     "explanation_relevance"
    ]
   },
@@ -326,7 +338,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "0136005d-a22f-43a0-80da-4ec1f283f870",
    "metadata": {
     "pycharm": {
@@ -337,7 +349,7 @@
     {
      "data": {
       "text/html": [
-       "<html><body><span style=\"background:rgba(255, 0, 0, 0.11)\">A</span> <span style=\"background:rgba(255, 0, 0, 0.32)\">delectable</span> <span style=\"background:rgba(255, 0, 0, 0.10)\">and</span> <span style=\"background:rgba(255, 0, 0, 0.80)\">intriguing</span> <span style=\"background:rgba(255, 0, 0, 0.33)\">thriller</span> <span style=\"background:rgba(0, 0, 255, 0.054493)\">filled</span> <span style=\"background:rgba(255, 0, 0, 0.05)\">with</span> <span style=\"background:rgba(255, 0, 0, 0.02)\">surprises</span></body></html>"
+       "<mark style=\"background-color: hsl(0, 100%, 94%, 0.8); line-height:1.75\">A</mark> <mark style=\"background-color: hsl(0, 100%, 80%, 0.8); line-height:1.75\">delectable</mark> <mark style=\"background-color: hsl(0, 100%, 94%, 0.8); line-height:1.75\">and</mark> <mark style=\"background-color: hsl(0, 100%, 50%, 0.8); line-height:1.75\">intriguing</mark> <mark style=\"background-color: hsl(0, 100%, 81%, 0.8); line-height:1.75\">thriller</mark> <mark style=\"background-color: hsl(240, 100%, 96%, 0.8); line-height:1.75\">filled</mark> <mark style=\"background-color: hsl(0, 100%, 96%, 0.8); line-height:1.75\">with</mark> <mark style=\"background-color: hsl(0, 100%, 98%, 0.8); line-height:1.75\">surprises</mark>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -380,7 +392,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/lime_timeseries_coffee.ipynb b/tutorials/lime_timeseries_coffee.ipynb
index b8615787..edeb7807 100644
--- a/tutorials/lime_timeseries_coffee.ipynb
+++ b/tutorials/lime_timeseries_coffee.ipynb
@@ -28,8 +28,8 @@
    "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:42.646323Z",
-     "end_time": "2023-05-31T09:48:42.651335Z"
+     "end_time": "2023-05-31T09:48:42.651335Z",
+     "start_time": "2023-05-31T09:48:42.646323Z"
     }
    },
    "outputs": [],
@@ -52,7 +52,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Libraries"
+    "### Import libraries"
    ]
   },
   {
@@ -60,8 +60,8 @@
    "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:42.653341Z",
-     "end_time": "2023-05-31T09:48:43.874520Z"
+     "end_time": "2023-05-31T09:48:43.874520Z",
+     "start_time": "2023-05-31T09:48:42.653341Z"
     }
    },
    "outputs": [],
@@ -88,8 +88,8 @@
    "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:43.878877Z",
-     "end_time": "2023-05-31T09:48:43.909870Z"
+     "end_time": "2023-05-31T09:48:43.909870Z",
+     "start_time": "2023-05-31T09:48:43.878877Z"
     }
    },
    "outputs": [],
@@ -120,8 +120,8 @@
    "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:43.909870Z",
-     "end_time": "2023-05-31T09:48:43.996106Z"
+     "end_time": "2023-05-31T09:48:43.996106Z",
+     "start_time": "2023-05-31T09:48:43.909870Z"
     }
    },
    "outputs": [
@@ -153,14 +153,16 @@
    "execution_count": 5,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:43.999815Z",
-     "end_time": "2023-05-31T09:48:44.015023Z"
+     "end_time": "2023-05-31T09:48:44.015023Z",
+     "start_time": "2023-05-31T09:48:43.999815Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "text/plain": "(286,)"
+      "text/plain": [
+       "(286,)"
+      ]
      },
      "execution_count": 5,
      "metadata": {},
@@ -192,8 +194,8 @@
    "execution_count": 6,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:44.013016Z",
-     "end_time": "2023-05-31T09:48:44.069544Z"
+     "end_time": "2023-05-31T09:48:44.069544Z",
+     "start_time": "2023-05-31T09:48:44.013016Z"
     }
    },
    "outputs": [],
@@ -226,8 +228,8 @@
    "execution_count": 7,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:44.043890Z",
-     "end_time": "2023-05-31T09:48:46.604782Z"
+     "end_time": "2023-05-31T09:48:46.604782Z",
+     "start_time": "2023-05-31T09:48:44.043890Z"
     }
    },
    "outputs": [
@@ -240,7 +242,7 @@
     }
    ],
    "source": [
-    "exp = dianna.explain_timeseries(run_model, timeseries_data=data_instance, method='lime',\n",
+    "exp = dianna.explain_timeseries(run_model, input_timeseries=data_instance, method='lime',\n",
     "                                labels=[0,1], class_names=class_names, num_features=num_features,\n",
     "                                num_samples=500, num_slices=num_slices, distance_method='cosine')"
    ]
@@ -258,23 +260,27 @@
    "execution_count": 8,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:46.604500Z",
-     "end_time": "2023-05-31T09:48:47.575864Z"
+     "end_time": "2023-05-31T09:48:47.575864Z",
+     "start_time": "2023-05-31T09:48:46.604500Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 640x480 with 2 Axes>",
-      "image/png": "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"
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "text/plain": "<Figure size 640x480 with 2 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAG2CAYAAAC04mh6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACVKklEQVR4nOzdeZwU1bk//s+ppffu2VcZ2QWJLAoRIUYxEBn15mriz0hCLuo1GI0kKi6BXAXBhWiMEg0JiRt6I+o1cUlMvkSCojEiRhRXIIDAsMwCs/X0Xsv5/VHdPdPMwvS+zPN+veql01NVfWro7nr6Oc85h3HOOQghhBBCSNyEbDeAEEIIISRfUSBFCCGEEJIgCqQIIYQQQhJEgRQhhBBCSIIokCKEEEIISRAFUoQQQgghCaJAihBCCCEkQRRIEUIIIYQkiAIpQgghhJAEUSBFCCGEEJIgCqQIIYQQckJvvfUWvvGNb6C2thaMMbz88ssnPGbz5s0444wzYDabMWbMGKxbt67XPmvWrMGIESNgsVgwffp0vPfee6lvfBrlTSC1atUqfPnLX4bT6URlZSUuueQS7Nq164THvfDCCxg/fjwsFgsmTpyIv/71rxloLSGEEFJYvF4vJk+ejDVr1gxq/3379uGiiy7Ceeedh+3bt+PGG2/E97//ffztb3+L7vP8889j8eLFWL58OT744ANMnjwZc+fORUtLS7ouI+VYvixaXF9fj3nz5uHLX/4yVFXFT3/6U3z66af4/PPPYbfb+zzmnXfewTnnnINVq1bhP/7jP7B+/Xrcd999+OCDD3Daaadl+AoIIYSQwsAYw0svvYRLLrmk331+8pOf4C9/+Qs+/fTT6GPz5s1DR0cHNmzYAACYPn06vvzlL+NXv/oVAEDXddTV1eFHP/oRlixZktZrSJW8CaSOd/ToUVRWVuLNN9/EOeec0+c+l19+ObxeL1599dXoY2eddRamTJmCtWvXDup5dF3HkSNH4HQ6wRhLSdsJIYQUJs45urq6UFtbC0FIX6dPIBBAKBRK+jyc8173NrPZDLPZPOBxgwmkzjnnHJxxxhlYvXp19LEnn3wSN954Izo7OxEKhWCz2fCHP/wh5jxXXHEFOjo68MorryRySRknZbsBiers7AQAlJaW9rvPli1bsHjx4pjH5s6dO2C/bjAYRDAYjP58+PBhTJgwIbnGEkIIGVIOHjyIYcOGpeXcgUAAI4c70NSiJX0uh8MBj8cT89jy5ctx5513Jn3upqYmVFVVxTxWVVUFt9sNv9+P9vZ2aJrW5z47d+5M+vkzJS8DKV3XceONN+IrX/nKgF10/f0jNjU19XvMqlWrsGLFil6PHzx4EC6XK+E2H/V7cN/7b+DThhYwu4axFSXY6z0KTecotoUw2laJzxu6YC/qQkeXA0HFhLGlZdjja4bmZzAdFcFtAk4ZVoQ2YT/cR23wCQJkp46xxWXY7T4GgWkosXnhD1kxzFqDnU0dUD0CzH4RYytLsV86BD9j4DoDC0kYV1KGJu0gvG0mhBiDyWPCKaVlOGg5gJIiN1o6XAgELBhbXI59/maEQoAocjCvCWPsldjd2grVqkDURZziKsfuljaoNgWcAZIiYWxpGXYHmqGFACgCRCZgbHkpdvuboYGDa8x4rLgc/25vhc5UQBEgqcax//YchSZqEEWGU4rLsNfbAiUE8JAAs51jTFEZ/n20HbqkAQEBJruOsWWl+MLdghKbBx0eK8xmYGxRGQ54m2GX/WjudCKomXFKcRkO+JoQVAVwXcQYZyV2tx2D5hGgC4Bk4RhbZFyTJqngmgDZL2Nscbmxn6RB9DKgWMeYsjIc2NMBsR0IlHIws4AxZWXY5TkKTdQhiAxjS8qwx30UWghgkg4GEWOLyrGntRWaqAGMQVJE42/RaVw3UwQIsnHtexrboZo0MJFhbHEZ9nQeA/cBLCTAFBJwSmk59jYfg6ZycAEwhQSMri7DTvcxKBKHbuFgZmb8/d1HoYsaRFkH88sY7arAv91HoYND5ALGlpRjd9dR6KIKQeJgqogxrgrs7jwGzjTIZg1clTDGVYH9vmYEfQzcI0MwAWNLy/DFwXaojhAEhwaEZHyppBiy/WMEGIPCLRhhr0Rr4AAOdTlgNWkoNodQa63BtqNd8GkiBKaj1BrCSFsVPu9sA9N1tDc7ERIkjC0rx253CyDo0IICBBZub6fxtxWYaPytO433FnQBstV4j+zqOGa8FsEgcuPvv7utFZquAyLv8Vo8Bh06IACyRceY4nL8u60VmsohCuHj2sPn1wSIJuCU0lLs8zdDEFUEgzJMMjDWWYYdzR3QRA0WqwKzzDHaUYH9viaUmL1odTtQ5vRjcqkLxeL7MLMQzrB4UGyqQ2NwDywsiCJmwmdKMQLCqXi33YdPjlaho90B01ETxjkq0LS9GebDAXBRBOwSho2pwI5AO0IyR6gI4A5gbHkp9jW0w9yow+phGF1din0HjsFvVmH7uBFmuwsnn1aH3W2daB3HEKjUIZoYxpaWYa+nBaKsQhA1gEsY4yzHQX8jBFGFxDScZPfhZHs1PmrrgFuRoWsyxrrKEeC7YZKC0DUBDR0VqLbUYre7FYpPAEQdghB+TR1rhabpEL2C8b4pL8W/O1qhcx2yImJMSRn+3XUUzMOM17AUfi8dawUPAVzgsPhEjC0tx073MagWDeYWBmYWMfKkMuzytIB1ARAYeKmOMaVl2L+nHSoHmJVhTFkZvjjSCs3GcVpNFZbMPAcVdkfCn/MA4Ha7UVdXB6fTmdR5BhIKhdDUouHAthFwORPPerm7dAyfur/X/e1E2SgSKy8Dqeuvvx6ffvop3n777ZSfe+nSpTFZrMibwuVyJRVIBWQBJrsNktUKZtNgd7og8S4wnUO2C7A7HZBsCmS7AkmzQFPMcDidkOAGYwySRQS3CnA6XeiCBZLHAkkUIdk0Yz/VA4FpkO0aFNkCu90JyR0ENAESRDhcTkiwQIoEUpIMh9MJWbFACpihMwZJMxmPyRbI9iCkkAWSYDWOZZ3QJQZR1MF0M+wuJySfD7BKEHXRuJ4uP2CToDNACklGuwQ3mAhAMgIph9MFibnBwKFrDBITjP2Cvu5ASgkfq3vAwoGU3emExN3gEgOXBEg2DrvLBckbgC6pgBD+WzgckDQ3ZJsKSbdAtgB2lxMyOmGSdUiKBZpmNs7HOqApArguweF0QAp4wbRwIGXlxnV7/GCSCl0TIEE29vN7wSQNosYAqw6n0wnJEoRoNo5j5vC/p+YBE3UIEoPT5YCkesCk7kDK6XRC8vvAIoFUSITD4YSkGNfNQgIEU/jaOwKASQOTGJwuJyTFC84BJgqQBAF2hxNSpxcsHEhFHwt5weXuQMrhMF4rRiClgTFT9PUTCaQcLqPtRiClg6mS8XdVvOBMhWTWwFU5/PrshAYBXJMhmGE8pzUA2EQINhWQTHC4nIDFDF1gYLrxuvZIZsi6BbJJhcnCYLc7IfsUSJoIkekwWQXYnU7Iqg9M1yHZLNCF8N9f7QIEDUwUITDBeEzxABIgMjH6MwsHUpJVN9oa8gISwMKBlMPlhBTwgWk6IBmBlMPlgBT0Qodu/B0t4WMDPrBwIOVwOiAFw+cPB1LG66kTgqhCE2VIsvG6k7qCYKIKySpCMnHjtcg6YDKrkFULTHYdDqcDVkGGReBwWiS4zA50BSRYmQonk2BXZMiiA2ZFg+yzQApaIVlNcDgdkE1uyDKMQMokw+lwQuIB6CYO3QJwK2C3uyBZA5DMOuQQg93hhGzyQjWpkCUzZMn4vJA9IUgWBsmqQzSz8HuwC6KsQJA0QJeM6xTaIYYDKZNDg9NhhxwMQFZkaJoMh8sBXTPDLAGaJkBWLHDYnJBULzjEaCDlcBifIUzTIepGIBX5LNC4DkkSjb+h6gHTugMph9MFyesDF41AStJF43WneAGLBsliBFJ2hwOS1gWmwAikbOF/S0sACAdSdqcTktUHZuUw2W1wulxwJRlIRWSiFMThZHA4E38eHcaxyd7f+lNdXY3m5uaYx5qbm+FyuWC1WiGKIkRR7HOf6urqlLcnXfJm1F7EokWL8Oqrr+KNN944Ydq0v3/Egf6BzGZz9EWVrhcXIYQQkiyN60lv6TRjxgxs2rQp5rGNGzdixowZAACTyYSpU6fG7KPrOjZt2hTdJx/kTSDFOceiRYvw0ksv4fXXX8fIkSNPeMyJ/hEJIYSQfKWDJ73Fw+PxYPv27di+fTsAY3qD7du3o6GhAYDRo7NgwYLo/tdeey2++OIL3Hbbbdi5cyd+/etf4//+7/9w0003RfdZvHgxHn30UTz11FPYsWMHrrvuOni9Xlx11VXJ/4EyJG+69q6//nqsX78er7zyCpxOZ7TOqaioCFarFQCwYMECnHTSSVi1ahUA4IYbbsC5556LX/ziF7jooovw3HPP4f3338fvfve7rF0HIYQQko/ef/99nHfeedGfI2UwV1xxBdatW4fGxsZoUAUAI0eOxF/+8hfcdNNN+OUvf4lhw4bhsccew9y5c6P7XH755Th69CiWLVuGpqYmTJkyBRs2bOhV35zL8iaQ+s1vfgMAmDVrVszjTz75JK688koAQENDQ8xw05kzZ2L9+vW4/fbb8dOf/hRjx47Fyy+/THNIEUIIyXu6MSwiqePjMWvWLAw0Y1Jfs5bPmjULH3744YDnXbRoERYtWhRXW3JJ3gRSg5nuavPmzb0eu+yyy3DZZZeloUWEEEJI9micQ0tiKshkjiXd8qZGihBCCCEk1+RNRooQQggh3RIpGD/+eJI8CqQIIYSQPKSDQ6NAKuuoa48QQgghJEGUkSKEEELyEHXt5QYKpAghhJA8RKP2cgN17RFCCCGEJIgyUoQQkmc4B3RKJgx5enhL5niSPAqkCCEkj3AOHG6pxNFjAsZmuzEkq7QkR+0lcyzpRoEUIYTkEV0ToKgyFAB+QYYF/mw3iWSJxo0tmeNJ8qhGihBC8oiudn9s+wU5iy0hhACUkSKEkLzCNTH6/37BlMWWkGyjGqncQIEUIYTkEcpIkQgdDBpYUseT5FHXHiGE5BFd6xFIiTKVCxOSZZSRIoSQPKKr3V17GhMRkiSYaGLFIUlPchoMmkIjNSiQIoSQPNIzIwUAPrMZpkAgS60h2aQl2bWXzLGkG3XtEUJIHulZIwUAiiT2sychJBMoI0UIIXlE12IDJ0Wij/GhijJSuYHegYQQkkciGSmLxBFQGRSRMlJDlc4ZdJ7EqL0kjiXdqGuPEELySCQj5TAbP1MgRUh2UUaKEELySCQj5TRxHPMyqpEawqhrLzdQIEUIIXkkMmovkpFSRfoYH6o0CNCS6FjSUtiWoYzegYQQkic4B3g4kHKajUmAKCM1dPEka6Q41UilBNVIEUJIntBUEQh3xzjCy+wpokizmxOSRZSRIoSQPKEpRvaJMR2WyDJ7jEEVBNCqe0MP1UjlBgqkCCEkT0QCKVHQITAGkWvQmAhFEimQGoI0LkDjSdRIUSozJahrjxBCcgjnQEjtu+5JU4zvvoKgAwAkbvxXpSkQCMkaCqQIISSH3PqnM3Dluh+i2V3U63dK0Mg7ieFASubGuCuaS2po0sGgQ0hio669VKBAihBCcsim3TVwB2xY+8+v9/qdGjQyUpJoBFCRjBQFUkNTpEYqmY0kjwIpQgjJIl9AwMd7R0DTGXyh7kqnfx0YA1U7boHiSEYqEkjpxn+pa4+Q7KFic0IIyRJVEfHYH05GSBkBgXPU1u2L/s6vmPH2/tEoO/lY9LFIINUrIyWJQCiDDSc5Iflic6o2TwXKSBFCSJbs+mgEQorxMdzQXIFWrz3m9x81Dov5WT0+I0U1UkOaUSOV3EaSR4EUIYRkga4xHGssif7c1uXEMY8jZp+GjpKYn4/v2pOpRoqQrKOuPUIIyYKAxwL0yAgc7SzGMa8RSJXYPGj3OdDQXhr9vaax6PQHUnT6A6qRGsr0JNfa02lO/JSgjBQhhGSBv8sKADipMgAA6PA4cLijGAAw8aQGAMDBzhLouhFs+f3hVYqZ3mseKcpIDU2RGqlktkSsWbMGI0aMgMViwfTp0/Hee+/1u++sWbPAGOu1XXTRRdF9rrzyyl6/r6+vT6ht2ZBXgdRbb72Fb3zjG6itrQVjDC+//PKA+2/evLnPf8CmpqbMNJgQQvrh9xiB1IiTfLCZjWBq+2GjJmpcVSNkUYWqi9HuPp/fAgAQZQ0snMiKZKQ0UYSeycaTnJDcHFLGFq/nn38eixcvxvLly/HBBx9g8uTJmDt3LlpaWvrc/8UXX0RjY2N0+/TTTyGKIi677LKY/err62P2e/bZZxP6m2RDXgVSXq8XkydPxpo1a+I6bteuXTH/QJWVlWlqISGEDE6gywiMqsqDKC92AwCOdBYDAModbpxU1AYAaO4oxjG3GXv3ngTACKQiRHCw8MgrRaCsFEm/Bx98EAsXLsRVV12FCRMmYO3atbDZbHjiiSf63L+0tBTV1dXRbePGjbDZbL0CKbPZHLNfSUlJn+fLRXlVI3XBBRfgggsuiPu4yspKFBcXp75BhBCSAFUVEPQZXXVVZUGUFaloaO7+glfm8GBYcSv2t1Xi9c8mYMfhOgTD6+wJUncgxQBIqgZFlqAKefW9mKSAxhk0nsSixeFj3W53zONmsxlms7nX/qFQCNu2bcPSpUujjwmCgDlz5mDLli2Des7HH38c8+bNg90eO0J18+bNqKysRElJCb72ta/h7rvvRllZWbyXlBVD4p03ZcoU1NTU4Otf/zr++c9/DrhvMBiE2+2O2QghJJW6OhwAGMyWIOxWHeVFnTG/L7V34aRiIyO1ff+IaBAFAJJJjdlX1oyfqU5q6NHCxebJbABQV1eHoqKi6LZq1ao+n+/YsWPQNA1VVVUxj1dVVQ2qZOa9997Dp59+iu9///sxj9fX1+Ppp5/Gpk2bcN999+HNN9/EBRdcAE3T+jlTbsmrjFS8ampqsHbtWkybNg3BYBCPPfYYZs2aha1bt+KMM87o85hVq1ZhxYoVGW4pIWQocbcZdU+uUg8A4EsjD2Djv6ZGf19q86KupHsizjlTGqEXH8b7n4+BpcwDuLuzELIankuKuvZIgg4ePAiXyxX9ua9sVCo8/vjjmDhxIs4888yYx+fNmxf9/4kTJ2LSpEkYPXo0Nm/ejNmzZ6elLalU0IHUuHHjMG7cuOjPM2fOxN69e/HQQw/hf//3f/s8ZunSpVi8eHH0Z7fbjbq6urS3lRAydLjbnQAAV4kRSJU4vVh0ySt4esP5GF3ugyTq+OroHfh34wicdFILpoxz4a3WTpwsNqC9zQm4TdFzyeFv7dS1N/ToXICexMzmeri+zuVyxQRS/SkvL4coimhubo55vLm5GdXV1QMe6/V68dxzz2HlypUnfJ5Ro0ahvLwce/bsyYtAasi9884880zs2bOn39+bzeboi2qwLy5CCBkszrszUkXhjBQA1FUcw/NXPYZHv/0uAMBhDmLZnP+HM8d8MeD5ol17lJEaclLVtTdYJpMJU6dOxaZNm6KP6bqOTZs2YcaMGQMe+8ILLyAYDOJ73/veCZ/n0KFDaG1tRU1NTVzty5YhF0ht3749b/5xCCGFJ+g1QVVkMEGH3eWP+Z1Z0iDG+aksRbv2htzHOcmCxYsX49FHH8VTTz2FHTt24LrrroPX68VVV10FAFiwYEFMMXrE448/jksuuaRXAbnH48Gtt96Kd999F/v378emTZtw8cUXY8yYMZg7d25GrilZedW15/F4YrJJ+/btw/bt21FaWoqTTz4ZS5cuxeHDh/H0008DAFavXo2RI0fiS1/6EgKBAB577DG8/vrreO2117J1CYSQIc7XYYxWsjr9EITkZ5aOdO1RRmro0YGkRu0lMvfY5ZdfjqNHj2LZsmVoamrClClTsGHDhmgBekNDA4Tjgvpdu3bh7bff7vPeK4oiPv74Yzz11FPo6OhAbW0tzj//fNx1111pq9VKtbwKpN5//32cd9550Z8jtUxXXHEF1q1bh8bGRjQ0NER/HwqFcPPNN+Pw4cOw2WyYNGkS/v73v8ecgxBCMsnbbgMA2Fy+lJwvWmxOo/aGnEQn1ex5fCIWLVqERYsW9fm7zZs393ps3Lhx4LzvLw1WqxV/+9vfEmpHrsirQGrWrFn9/mMAwLp162J+vu2223DbbbeluVWEEDI4nAPeNiMjZS/2puScUqTYnAkArZ1GSMblVSBFCCH5zOtlUAImMKbDVpSajFQkkNIEAUB+zLtDUiOZ9fIix5PkUSBFCCEZcuyo8ZHrLPFAEFOTPZL07kBK5xRIDSU6GHQkUyOV+LGkGwVShBCSIUfDgVRxWepWTJC07pLhEPXsDSmUkcoN9FckhJAM8XiMj1xHUWrqowBjvT0x3L1HgRQhmUcZKUIIyZBAwAikTBYFSgq7VSRdhyaKCCUxFJ7kn0Qm1Tz+eJI8CqQIISQDOAcCASPQMVsUKIrpBEcMnqjpgAwEKSM1pOicQU9mHikKvFOCwlFCCMkAXRWg68aNy2QOpfTckYLzUJwzLHLQhAmEJIsyUoQQkgFq0Pi4FSQtZSP2IiIF5/F07QWZjJ0zZqDmWBvGprQ1JFP0JLv2kpnMk3SjQIoQQjJADRkft7JZSfm5oxmpOOIzt2SDLopoKiuFzgMpbxNJP50L0JMYeZfMsaQb/RUJISQDIhkpyaym/NxiOCMVT42UXzTWMdMkES10KyAkYZSRIoSQDEhnINWza88yiP05AL/QvSDsQS7BlvJWkXTTwKAlMfozmWNJNwqkCCEkA7q79tIQSPXo2htMIKUIIjSh++P/EESckvJWkXSjrr3cQH9FQgjJgO6MVBpqpCJde4McteeVjKkXTAGjNsoNAXEO+COEhFFGihBCMiCSkZJMaaiRimakGAbTWxMJpJydnWi1GDksnQmgyRDyi4bkuudoZcbUoECKEEIyIJKRSkvXXrRGanD7B0QZAGDv6kJbRQW4IEBjDBRI5Rfq2ssNFEgRQkgGpLXYvEeNFB9ELBQQjbZY/H6Iug5VEKAzKjzON7RocW6gvyIhhKQZ1wFdFQGkp2svkpHSwcBP0NWjcyAo9AikwsdqjG4HhCSCMlKEEJJmkSAK4BDl1FemCJyDcQ7OTjwc3qsDYAyM65BDIYh6OAijjFTe4WDQk6iROlHQTQaHAilCCEkzLRxIyTJHOuIVBhhddKIIDQKEAcqI3Vp4vT9djR4HUEYqH1HXXm6gvyIhhKSZrhiBlMmUvmJukUe69wb+WO+KLJzMjWkYRM0IuigjRUhiKCNFCCFppmUgkJJ0HUEAGmcDfrB3hZNVJt0IpIQeGSn6Zp1fdM6gx7FQdV/Hk+RRIEUIIWkWqZFKb0bKOPeJMlKRrj2zHslIdddIUSCVXzQI0JL4V0vmWNKN/oqEEJJmmmJ81Gama2/gLEO0ay8SSFGNFCFJoYwUIYSkWTQjZU5v1x4wcJZBB4Ovn0CKaqTyD3Xt5QYKpAghJM2iNVJyGjNSkYBogJtjUBDD+2oQw6vrRYrNKSOVf3QIJ+zKPdHxJHn0VySEkDTLZI3UQBmpIAtPxKmp0Q5AykgRkhzKSBFCSJpFpz8wcwTS9BzRgGiAGqlAeEZzs949u7pANVJ5S+MMWhLdc8kcS7pRIEUIIWkWmZDTJKcvkJL4iWukokvDaN2BVM9ReyS/UI1UbqCvIKQgcR1o2VONzmZntptC+tDW6kTDZ3UI+EzZbkpGZHRCzgFmq44EUmZN6T4umpGim2q+4VyAnsTGaWbzlKCMFClIXe0OdDaWwt/hAE71ZLs5pIeOThHv/GMSVEVCwGNF1ezt2W5S2mlqePoDMwfSFEtFA6IBuvZiMlLhT//umc3ppkpIIuidQwpSKGBkOpSABJ6+JACJU8Av46+byqAqxl3c0+HAvt0nZblV6cV1gGuZmdkc6H8klsYZVGa0w9yza48yUnlLA0t6I8mjQIoUJCUoAzBS36EQfVjkAk0TsP3t8XB7JNjsflSPbgQANB4qz3LL0ksPB1EAh5zO6Q+iM5v3/XoPwPhyYRc4xB5pse5Re3Q7yDc6766TSmzL9hUUBnrnkIIUCaQAwO+nl3kuONZUAp/HCqtFw9mzPkJJdTsAwOO2FnTWUA9364myhnQmfcQeGam+/p7+cCBVLsX+MlJsrjFW0P8OhKQL1UiRgqQEu1/afr8A2LPYGAIAONpYBgAYM9IPmy0IcygIMA5VleD1iSc4On9FCs0FSU/r80SKzYFIVio2Kgr0E0hFpj8AY+DU1ZNXIkXjyRxPkpdXf8W33noL3/jGN1BbWwvGGF5++eUTHrN582acccYZMJvNGDNmDNatW5f2dpLsC8VkpOjmkG2cA0ebSgEAw4cZEwAIAofVbvx/e2fhfqdTA8Zr0WQLpfV5BCDaZXf8DZJzwA8zgD4yUrreYz96r+QTHSzpLRFr1qzBiBEjYLFYMH36dLz33nv97rtu3TowxmI2i8USsw/nHMuWLUNNTQ2sVivmzJmD3bt3J9S2bMirQMrr9WLy5MlYs2bNoPbft28fLrroIpx33nnYvn07brzxRnz/+9/H3/72tzS3lGSbEugRSAXy6mVekNrbnQgFTRAlFTWV3QGFzeEHALR1yP0dmvdUv5EJMtuDaX8uU/i+eHzBuaJK0CGAcR0lYmwgxQBI0QCMAikysOeffx6LFy/G8uXL8cEHH2Dy5MmYO3cuWlpa+j3G5XKhsbExuh04cCDm9/fffz8efvhhrF27Flu3boXdbsfcuXMRCKRr1rXUyquvgRdccAEuuOCCQe+/du1ajBw5Er/4xS8AAKeeeirefvttPPTQQ5g7d266mklywPE1UkNjtqLco4ZEdHkYDjdWAADKqjoh9ujFszr9QJMRSFlKs9TINFMigZQjiHR/5MoM8IcLkHt2loZCxvvBpisQ+igql8ChgtG8QnkmGzObP/jgg1i4cCGuuuoqAMZ99i9/+QueeOIJLFmypM9jGGOorq7u83ecc6xevRq33347Lr74YgDA008/jaqqKrz88suYN29e3G3MtIJ+12zZsgVz5syJeWzu3LnYsmVLv8cEg0G43e6YjeQXXWPQ1ONqpEhWHN1VhU3/sOHA/hoAQFVda8zvbY5w195QyEg5MpGR6rtrTw2PHOy5NExPkb8+ZaTySzKTcSZSXxUKhbBt27aY+6ogCJgzZ86A91WPx4Phw4ejrq4OF198MT777LPo7/bt24empqaYcxYVFWH69OkDnjOXFPQdpqmpCVVVVTGPVVVVwe12w+/393nMqlWrUFRUFN3q6uoy0VSSQloo9ls/BVLZoSkC1HBmUFUlyCYFZVWdMftYncb7sLVdhq4V3k1cUwXo4TmzTPb01kgBRkYK6L1MjKYbP8u874J3Ody1Rxmpoen45EEw2HfQf+zYMWia1ud9tampqc9jxo0bhyeeeAKvvPIKfv/730PXdcycOROHDh0CgOhx8Zwz19C75jhLly5FZ2dndDt48GC2m0TipIZiR4BRsXl2qIHYLFP1sKMQhNj6HJvTD4s1iJAi4GhDYc0ntX+/hCMfGV/EJLMCMc2j9gDAHP5E144LiLRwRkriWp/HRd4xlJHKLzqSmUOqu9i8rq4uJoGwatWqlLVxxowZWLBgAaZMmYJzzz0XL774IioqKvDb3/42Zc+RbXlVIxWv6upqNDc3xzzW3NwMl8sFq9Xa5zFmsxlmszkTzSNpEslISeYQ1KAJgUDf8+qQ9OoZSJWVdWLEKYd67SMIHONOO4CP/nUKmvZWYWRNJ0RT+gOOTNi7p/v6JWv6s1EAYOmna0/TBs5IRacMpUAqr/AkRt5FjgeAgwcPwuVyRR/v7x5YXl4OURT7vK/2VwN1PFmWcfrpp2PPnj0AED2uubkZNTU1MeecMmXKoK8lmwo6IzVjxgxs2rQp5rGNGzdixowZWWoRyYRIIGWMkuLgnEENFfR3hpykhpfpOfkkBV89Zzts9r5H4Awb3oLS4hA0VURXs6vPffKRonTf4Kwl3ow8p6W/jJQ+cEYqMmqP5pHKL8nNas6iGUiXyxWz9RdImUwmTJ06Nea+qus6Nm3aNOj7qqZp+OSTT6JB08iRI1FdXR1zTrfbja1bt+bNvTqvAimPx4Pt27dj+/btAIwite3bt6OhoQGA0S23YMGC6P7XXnstvvjiC9x2223YuXMnfv3rX+P//u//cNNNN2Wj+SRDlEAkI6VANhvFtUEfjdvLtEhGym4bOB3IGDButA8A0NVclPZ2ZUpkeqaSsY0ormvLyHOawxkpjcd2b0czUjplpEhyFi9ejEcffRRPPfUUduzYgeuuuw5erzc6im/BggVYunRpdP+VK1fitddewxdffIEPPvgA3/ve93DgwAF8//vfB2CM6Lvxxhtx9913409/+hM++eQTLFiwALW1tbjkkkuycYlxy6uv6e+//z7OO++86M+LFy8GAFxxxRVYt24dGhsbo0EVYES6f/nLX3DTTTfhl7/8JYYNG4bHHnuMpj4ocCGv8W3KZA9C8ZuhBGWE/BRIZVo0kLKfuKtu9HAftmwrhq/dbtS49d3znjd0jUELF8+bnYG0Lg3Tk6WPYnNN7y4iP2FGigKpvJKNmc0vv/xyHD16FMuWLUNTUxOmTJmCDRs2RIvFGxoaIAjd521vb8fChQvR1NSEkpISTJ06Fe+88w4mTJgQ3ee2226D1+vFNddcg46ODpx99tnYsGFDr4k7c1VeBVKzZs0CH6DYpa9Zy2fNmoUPP/wwja0iuSboMd58ZnsAitcKXwcQ9Bfu8PpcFQmkHCfISAFAkUuD1eWD321DV0sRqor6HlWbLyLr6wEcTMxczVdfXXuhcHkWQ+xixT11L6tMgVQ+6dk9l+jxiVi0aBEWLVrU5+82b94c8/NDDz2Ehx56aMDzMcawcuVKrFy5MqH2ZFtede0R0h/OjS0YZOEaKQ6zPQBTuMg36KMBBJmkayw67N9mG1wgUVRhzNnma8//hRG1HuvrZSobBfTs2uv+aA8qxn9FaP2GSZFv1DRqj5D45VVGipDjaaqAjoYK+I454axywz3SuIGYbUEIIofJatxFQkMoI6VzlvVRipH5owRRg2mQf3p7sVEn5e+0patZGdO9UHHfXWnpEslIcQjQdQYGjmDICI4k9B/QitS1l5eSWS8vcjxJHgVSJK91NbngO2qM9OpqdqGjxMhA2VxG11B3Rmpo1Ej5VROaPeVwSn58KYvtCHQZwZApjtm87UVGIBXymaEcNxdYvtHCXXuZmDuqJwlGFx4Hg64LEKEh1CMj1e9xDACnQCrfZKtrj8Sirj2S13ouTgzOsH9/eE0xp3FTjmakAib0M4VOwdA5cMxXAg4Gt2pDexbLjALhrJK1xDfoYySTBtlqBF6ejvzu3stWRoqx7oApMpt5MFwjJQ0QSIk0/QEhCaNAiuQ1NWgkVSM3rMhyMJFuIsmsGrNpc4b3Xp8Cb1t+36D7wzlwzFsEVe9OMr97iKGxvQy6nrmbo6IA7k47lIAZAIc1zqJxS3j/rjyvk+pZI5VpkS48PTx3VEg5cdde5FVDGan8kqp5pEhyKJAieYtzQAsHUvbSrujjJnsAReVG4TJjQGQkbsBnQdvBwlqGBAD8QRM+PMjgDtgBcJTaOozaGI0hoJgRCGRuCPGnuyS0txUDAMxFfohyfIFEJPBqbSyG2vf6unkhMmovG4GUyIznjGSkAuHe1YG69mgeqfxEgVRuoECK5K1gIDI/DoetzBN9vGzUsZiRUtVVSvT/QwU2ek/TBDS1leFQu3HBpdZOuCxenGw9Bim8rp2qZabeiHOgNdwOJmooqmuN+xyOCjeYqMHTacemt4qzXjSfKC1LXXtAz4yU8fHuCxj/Jib0H5lG5pGiGysh8aNAiuQtry9c0GtWIZlUlI08iglfCsBWGrscx5TTfThpXCMAQFMk6Grh3CxUxSgvNkkcta5WFJmNazeLKsaUhgMpNTNjStSgBFVlYExHzYQGmF19LwkzENmqYPgZ+8CYjkNHLHk72lJXjUAq08XmACD2CKQ4B3zh3lV5gECK5pHKT5SRyg0USJG8wjkQcFuhKQJ83nDth9nIOLlq3BgzRuk1b4/DrqN61FGYzEbVrVJAs5yr4bmaiiyAzRQ7Qs4WjkG0DAVSkWyfydz73yAethIf7OEuPm+eFp1rSrhrL4OTcUZIzMiCBUNmaKoYvllyyAON2qPpD/ISR/cUCIlseZrwzTkUSJG8EuywoWN/FZo+rYHPFw6kLMoJjjLYnMbNWSmgqRAi2SZ7Hz2W9nAglamuvcgUE+ZwwJoMZ3iRX29Hfs4pla1RewDgYn4w6AgpJnQeM6YGkSV1wOC2u0aKbgn5hDJSuYHeNSSv+NsdAAA1YELrsXD3ySADKbsrMk9R4QRSmhIJpHp/t7SHL1PTxIzUGkUyUmZLKgIpo+YtXwMpTc3eqD2Z6SiVjcEX/vB8XtIJArroqD3q2iMkbhRIkbwS+aYPAB0d4YVYzYMMpAo4I2Xr45LMIsCYDoBFA6500TUWnc08FRkpVzgj5XNbMzp9QypwHeBa9kbtAUCR5IEgdAdPsjTwEEiRis3zEmWkcgMFUiRvcN47CBJNKsyDnKsoMklnyGsy1uXzmHDkg+HwtDhS3tZM4Ly7Rqqvrj3GAFk0bqZqmgMpJWj8u1gtHGIK6oIs9iDMJh1cF+DJszmlIoXmAM9KjRRg/NvbLN3vixMHUgaqkcovFEjlBgqkSN5QgxJ4uN6HiTpMJo6Ksc0QxMH1WzmLvGBMh65I8HoZDn4wHIrXjLbdlelsdtpwXYjWtNj7SbJJonEDVdX01kkpAaMBLmdq+hAZA04eZhTP7/t4BNQ8WjJGD2ejZBkZXbD4eHZr96zyJ+7ai/y7ZX+dRkLyDQVSJG+EPEbaRbYGcdLpB3HurABky+BnbRREDkt4Db49u+UemQNA1yMZnhPfsAN+E1r2V8OfwYku+6KGjCyTKGgQ+3knRzJS6e7aC4UDqSJn6jIwZ01zw+LwQwnKaG8uTdl50y0yGacsZzcikWUFZmsAZhOH2TRwd2vPVz3Ps67UoYwyUrmBAimSNxSvEUhJ1hBEWYecQKmTrdiovTl0MHZ+Iq+XoauxCC17ToK/s/8CZ0UFjjaWQw3JaO8sjr8BKRTprhuo2yaakQqldz4mJVwflaqMFACYTBx1px4BAHg77XmTKYkE6NkOpBgDyoe1YtaXNWOZpAHEhNl0c80bnLOkN5I8CqRI3lDDCxQPtri8L9ai7u4OJuoQTca53G4BnqNGrZR/gLmL/n2w+4NH0yRoavbeQpHgaKBASo4EUmnMSOmqAE0x2lKUwkAKAJxlHoiyCl2VohnJXMcjGakcGNPA2OC6FxkDWDhSpYwUIfGhQIrkjeiyG3Lic/NEuvYAoGzEMVjLjAzVkcMitHBWJeQ193szOdoZ+7jfbU24LcmKjJIbKJAyhX+nqSJ4muqeg11GF6doUiCnOPHFBKC4ohMA4M+TqRAiGSlTljNS8RI4TcqZb5KZjDOykeRRIEXyRirWLxMEjvJxTRg3PoSSk9tgshsFzUeP9qgS4QKCXb2zH5wDvvCqJ7ai2Hl6skEJZ6RMUv8ZOoHp0SkQIjVVqeYNT/podQ1u9GS8iquMQCqQxaA1HrlSIxUvIRxpU0Yqf1CNVG6gQIrkDS0UWb8sudmi7eVejD3FWMbE5IhdD46Fi7P9Hb1v2krIWNeOCTrs4VqroM8MPQsj3HW9e24o0wAZKca6M1bpCKQUv4yg2waAw9Fj4ehUshcZf2s1KEHL/EThcYuO2jPlWSAVXSaGbguExIPeMSQv6DqiUx+kctkNkyMIW7kHFguHbAuiqKodAOA96kTDQSGmwDkSiMiyCsmkgDFjnqMub+a/1akBI6gTBA2CMHAkJ0UCqWDqA6muFicAwGwLQDKlJ8qRzSoEUQPA4M3C3zpe3cXmWW5InASqkco7VGyeGyiQInkhGFmPl3GwFE5yyBhQPq4FX5sdQPVpjbC6fLCVdAFg+OxzGUf3VURvLJGuNNlkZLMiQ8rbOzP7YaSqQKDTyJhJ8sBrqBn7GF1/ShpG7kUKwC3HZfZSiTHAFF52psuT+x/8+du1RzVS+Ya69nIDBVIkL4RCxhtekLS0TnLIGOCsaYertgOCwBHyWhAIT4eghLvSJNnI8JhMRnTX3pG5txHnwNb3JXQ1FQMwgroTiXTtKYHUB1JBjzE0TUrBsjADiQRSHk/uf2RFRu3lW7E5jdrLP5SRyg25/6lECIBg0HjDi0mM2BssxgBXbSdOOsnIfEWWpVEiXXsmIzDpzkhl7m0UdFvQ1SOYMFtOnAkymUIAONSgDI83dW0JhQCtR5YuneRIINWV+x/8ergLOm9rpCiQIiQu6Z3umJAUiWakMhBIRbicOgARit9Ym69njRQAmGQjQAkEGRRVhIj0t81z1KhJspV1we7wQIYGhAYO5ERRh9kWQNBnxZFmAUjRJOFut/G8okkZ9DI9iTJZjexfl4ehLK3PlLzurj0AwYH3zSWRrj2akDN/8CS75ygjlRqUkSJ5IVIjJciDXxImWS6XcWNR/WaofhMABknk0VGDgsBhthkN8wbSPzRfDUoIeSxgjMNZ7YZsVgbdzRlZsPlIU2wBfTLcbuPJZVt6u/WA7q49v19AyJsDM132g/Pcmdk8XlRsnn84jNdcwlu2L6BAUCBF8kKkay+VI/ZOxOngADh0VUQwPIdRkSN2pmirywhQvBlYdy/QZbShtITHPULOYvODMR2BIIvOEJ+srq5w5sWa/rSLKOnRyVSP7awOj1rMPVxn0YyOKd+69qLF5nRbICQe9I4heSHStZeJGqkIUQRki1H742s1utSK7bE3R1v45h5UzFDSfAMKhgOpivL4Ry0yAZCtxrWEfKnJ6HjCI+hka/ozUgBQOvIoXC4duiqisyE3O/i6F8LmEE+8/nVOoYxU/qGZzXMDBVIkL0QzUhkMpIDuQCoyh1WxIzaQEmUNJUVGYOPV0te9p2sMofCizYkEUgBgCgc8kfMkK9PBrSByTJqoAODwtzpzcu09PbqMkZ7W0aXpQDOb5x8atZcbKJAieSFaI5XBrj0gdpFjwOjaO151pXED6tLTE0h1dDIcPVwGgEE0K7AnuCqNyRYJpFKTkQqFE1EZ7W51ctjKjRnUI1nCXBJZxDrZ2fezQQwHUrpOtwVC4kHvGJLz1KAIn08AwCFlqBspwuoKxNQAWfqIQaorjJtmgJugaal/S+3+QkQoYGRf7GWJz18QyUipARm6mtw3Ua4DmhapW8vsGjlmpzHlQyT7k0sUv/ECyXTmNBXESNdeGl7DJD1oQs7cQO8YkvMC7UYKxuwKQJQzv7BdyehmmBx+lFR09Pl7qwUwyyEADH5/6rNSnvCyKCXDW+Co7Er4PKKkw2rhABhC3uSK43vWAqVypvnBiAQpWg4GUr5jRpbMWpyeBZzTSaSuvbyT1Ii98EaSR4EUyXn+cCBlSyIbkwxR1lAyqgWO47r5erJbjBunL8XTIOgqi9aHmWzJj44rKzVulv7WPvoo4xDpwhKkzNcCRWqyuoO53KCrLPpatZdn57WajGhGirr2CIkLvWNITtMVIVpUbC31ZLk1/YsEUsGgOaXde0rQmKpAlLSUTHpZV2sEUoF2OzQl8XZGutUyOYoyQugRSOXSN2p/hw2cCxAtoYzMrZVq0Rop6trLG1RsnhvoHUNymtEFxeBw6JDMuVt3IksazCzcvZdkt1lPkTmfpBQtwVLkDM/7xBl8R10Jn0fvkZHKtGj3Lmc5Vc8TWUjaUuzLuxF7AHXt5SMKpHJD7nwKDdKaNWswYsQIWCwWTJ8+He+9916/+65btw6MsZjNYkn/xIkkdSLZqJKSzN+w4+UQwt17aQikIuv7pUKkizRSe5aISCCVjYwUEziYGK6TUnPnIyz6b5WH2SgAEHTq2ss3VGyeG/LqHfP8889j8eLFWL58OT744ANMnjwZc+fORUtLS7/HuFwuNDY2RrcDBw5ksMUkWUp4zqPi4nwIpIzRZAG/GaEUreGrBCILJaduUeDIqLdglwV6gtmHSH1SpqejiIjWSeVQwXkkkBLNmVvGKJW6M1KpW0aIFKZ4EhqPPvoovvrVr6KkpAQlJSWYM2dOr/2vvPLKXkmP+vr6dF9GyuRVIPXggw9i4cKFuOqqqzBhwgSsXbsWNpsNTzzxRL/HMMZQXV0d3aqqqjLYYpIMrgOKL5KRyv1PdpOgQpaM7r2W9tR804tmOVJ4c5bMqrFmIU983brofElZGEUJ5N7IPc6NtRABQDKnLujNpEggBQBco0xFPsjGqL14ExqbN2/Gd77zHbzxxhvYsmUL6urqcP755+Pw4cMx+9XX18ckPZ599tlE/iRZkTeBVCgUwrZt2zBnzpzoY4IgYM6cOdiyZUu/x3k8HgwfPhx1dXW4+OKL8dlnnw34PMFgEG63O2Yj2RHymQDOIEgarNbcD6QAwGo1uveaWpO/Eekag6akPiPFWI+slCexbsjoDN7ZzkjlyMg9RYl0iXGIKeyGzSTjZmC8z2hSzvxgBEPJ1EjF/5zxJjSeeeYZ/PCHP8SUKVMwfvx4PPbYY9B1HZs2bYrZz2w2xyQ9SkpKEvmTZEXevFuOHTsGTdN6ZZSqqqrQ1NTU5zHjxo3DE088gVdeeQW///3voes6Zs6ciUOHDvX7PKtWrUJRUVF0q6urS+l1kMGL3ORNzkDeFO/awoHUsU4GPclv9UrAyBZZrTwlI/Z6MoXXCAwkGkhlsUYKgJFRQ+507fn94eVyTCpY3nyq9iawcPdeDhXxk/Q7PnkQDPY91UqiCY2efD4fFEVBaWlpzOObN29GZWUlxo0bh+uuuw6tra2JX1CGFfS7ZcaMGViwYAGmTJmCc889Fy+++CIqKirw29/+tt9jli5dis7Ozuh28ODBDLaY9BRwh0dBFeXP5IayrEKSFXDOEEyy6DwyS7bLmfpsnCmckQp5TVATSKDkSo1UrhSbRwIpyZKf3XoRAgtnpKhrLy+katReXV1dTAJh1apVfT5fIgmN4/3kJz9BbW1tTDBWX1+Pp59+Gps2bcJ9992HN998ExdccAE0LXdHavckZbsBg1VeXg5RFNHc3BzzeHNzM6qrqwd1DlmWcfrpp2PPnj397mM2m2E2595iqENNIBgJJDgsxX4AyU0gmUlWWxBdnTICHgtMJYlPzBjJSLmcOgKpalyYZFYhmhVoQRntnSzur1RZr5Ey5VaxeSSQkvM+kKKMVD7hiHTGJn48ABw8eBAuV/d0KOm6B/7sZz/Dc889h82bN8eMoJ83b170/ydOnIhJkyZh9OjR2Lx5M2bPnp2WtqRS3rxbTCYTpk6dGtOvGulnnTFjxqDOoWkaPvnkE9TU1KSrmSRFWsI1RrI9mLWbdaKstvDoPY8lqdFP3YFUeurDzOHuvbYECuOznpGSIhmp3Aqk8j0jxRgtXDwUuVyumK2/QCqZhMYDDzyAn/3sZ3jttdcwadKkAfcdNWoUysvLB0x65JKE3i2qquLvf/87fvvb36Kry1j768iRI/B40jvz9OLFi/Hoo4/iqaeewo4dO3DdddfB6/XiqquuAgAsWLAAS5cuje6/cuVKvPbaa/jiiy/wwQcf4Hvf+x4OHDiA73//+2ltJ0kO58CBI8ZL05xH3XoRZksIosCha2J01F28dI1BCxnHpiuQsoSXvGntiC+Q4jwHaqRyNCOV74FUpGuPRu3lh0xPyJloQuP+++/HXXfdhQ0bNmDatGknfJ5Dhw6htbU1b5IecXftHThwAPX19WhoaEAwGMTXv/51OJ1O3HfffQgGg1i7dm062gkAuPzyy3H06FEsW7YMTU1NmDJlCjZs2BDtr21oaIAgdMeG7e3tWLhwIZqamlBSUoKpU6finXfewYQJE9LWRpK8rlYnPD5jtJ6tPPFFerOFMaC8iKO5nSHYZYXZGf81qOH6KEFWYU5shoITigSp7i4Gm8oAaXABm64KQPgDWJB0aFm46UZGxmkhEZxnf5RcNJDK06kPIgSBlonJK6nq24vD4sWLccUVV2DatGk488wzsXr16l4JjZNOOilaZ3Xfffdh2bJlWL9+PUaMGBGtpXI4HHA4HPB4PFixYgUuvfRSVFdXY+/evbjtttswZswYzJ07N4mLy5y4A6kbbrgB06ZNw0cffYSysrLo49/85jexcOHClDauL4sWLcKiRYv6/N3mzZtjfn7ooYfw0EMPpb1NJHU4B7rajHqootqO8BIk+fftuKKEo7kdCHZZASQQSIW79Yyam/RkXUSTBtGkQgtJUPwmyM7BVWJFsmwmU2Q0YbYCKeO5+xlglDGc96iRsirIr47oWN0ZKQqk8kKyy7wkcGy8CY3f/OY3CIVC+P/+v/8v5jzLly/HnXfeCVEU8fHHH+Opp55CR0cHamtrcf755+Ouu+7Km3rluAOpf/zjH3jnnXdgMsV+TR4xYkSvCbYIiZeuiOC6AMY4rEW+vL0plRcbNyTFb0poZFl0Is40BlIAYLKG4I83kApny+z27M3txRjCQaAcDWKyRVeFcFaOQzIrCCmJdefmgu4aqfz78kIyJ56Exv79+wc8l9Vqxd/+9rcUtSw74v6E13W9zyGJhw4dgtPpTEmjyNAVKbC2W5HX8/FYzYBkNmY5D7rjnwYhulhxmmtuZKuxLpziH/zNXwm3zWbLbpgb6d7LdiAVmdFcNOf3HFIAjdrLN9mY2Zz0Fve75fzzz8fq1aujPzPG4PF4sHz5clx44YWpbBsZgtSgcZN2ZjHbkSoWh5Hh8bfboh9YXGfwHnVG19DrT7Rrz5reQMoUPn9kzqrBUMNBVzYzUkCPQCqQ3UBKC0WWhsl+rVayqNg8v2S62Jz0Le6uvQceeAD19fWYMGECAoEAvvvd72L37t0oLy/Pq7VxSG6KZGKcdo7EZ2DKDbYiHzxtTgS7rDh8RIEmC2j7ohKK3wzZHgRq+z5OU4Xo9ALpvjlHMlJqUAYfZDlaz669zjS27UQigVQgy4FUJCOV73NIAd0ZKZr+gJDBizuQqqurw0cffYTnn38eH330ETweD66++mrMnz8fVqs1HW0kQ0gkE+OwI+8DKdmswlHRCU9LMT79XAYwDJFIRfGaoaihPo+LBJOirKZ8aZjjibIGSeJQVQY1IEOynng6g+6uvdwIpPx+hmyWpGqRxYoLIJBiVGyeXzhLqGA85niStLgCKUVRMH78eLz66quYP38+5s+fn652kSGI8x5dezaO5r7jjLxir3BDVyX42+3gnEGyBKEGjNt+ez/zNynhv0EmhtIzBrgcHG0dDIrPDIvVN+D+uipADy+kbLdzIIvTfEUzUlkOpNQCCqSiGalw8TzJbcnWOVGNVGrE9bVDlmUEAqlerIIQgxaQAc7AmA5rcsvU5QzGgOKT2/G1c0OoOu0Qysc2wVbmBgC0tff99ovUK8mWzESSZSXGp2mg0xYegdb/vpGgQZBVSFleYKpnjVQ2bwjRGilLIdVIUUaKkMGK+91y/fXX47777oOayEqnhAxAjWZiVLACyzjLMiCZjQglsmBwa1vfFxnyRQrNMxNIVVcaWYhQlxWNn52Ere9L/QYmgXZ7uG3Zz76I4dnNNY1lbQJJzo1JQYECy0hRjVR+4CnYSNLi/k75r3/9C5s2bcJrr72GiRMnwm63x/z+xRdfTFnjyNASrTWRVQBpms47B5gcfgAcXR4BtqAEZutOASlqd0ApWzMz06TdBkiWULQ+zd0lwOQxQy6O/bKkBkV4GosBAM5qN4CijLSvP0zgECQNuipCC0kQpMz3BRvZKAZB4FlbLieVmBCZ/iC7WT4yOMmOvKNRe6kRdyBVXFyMSy+9NB1tIUNcNCNlKuxASpR1mF0BBN1WeFodcNq6A6bOLuODTTQpEDM4q7ut1Av3ke6/ua/VjqLi2HL/rsPFABdgLvLBWupDtgMpwCjI11URekiEkIWuxki3ns3GCyKLGunaA9iAXbyEkG5xf/Q8+eST6WgHIdCigVThf4Lby7sQdFvha7dDtAVhKTGKvDuM8inItsyue2Iv7wJEHZLA0XagHP52G5waiwYnXi+Dr9XIPpeMPJYzQYNo0qD4je41yZb559fCiyZbrYWRvmHR/h4Gqt7IE4Xx0strWS4XJaRbdDZvufA/wc2uAGxWDp9fgPtgObRgJ0wVXWgNj+ST7ZkNpJgA2Mo8EHQBNhuHzycg2GEDivxo/fwkHAr/25iLvDA7A+BqbiyDEulO05TsfJRFMlIFE0gxgIk6uCZCVXMkWib9oq693BD3p8/IkSPBBvg6+sUXXyTVIDI0cZ1Fh9VLpsIPpBgDzpis4INdCnztdvg77LBaQ2jrFABwmF3ZmVeAMaP4/Iv9InwtLnQdLjFGUwIA43Ce1J6VdvVHiBSch9K3HuFAenbtFcp4ZiZwcA1GRorus7kt2YLxwoj/sy7uQOrGG2+M+VlRFHz44YfYsGEDbr311lS1iwwxatC4ETJBhyDm61LF8XHYgaLadvg7rdBDEo4dqAAA2Ms8xozmoeyMnKoKB1KhLmOCXdGs4MuTdewLHIVoyWym7ETEcPYyEtBkmtojI1UogZQg6NABqBqoz4KQQYj7bXLDDTf0+fiaNWvw/vvvJ90gMjRFCs1Fs5Iz9TeZIAgcJqcfwc7wtAISh7PSndU2uZyxX1PLT2lBcXEZpHYt577ARqdAULKfkcqtXF3iWPiLjKoyCqRyHkNyacMh9GGbRin7ynvBBRfgj3/8Y6pOR4aY6NQHQ6Bb73iWHqPjzviSFh6tlz2MAc7aDgAcxaObc2LOqP5Ea6Sy0LWnawxcK6xic8Do2gNAxeb5gOaRSprb7cbLL7+MHTt2JHyOlAVSf/jDH1BaWpqq05EhJjJjtmjK3Zt2uliKfXCe1IaKkS0ozf6MAgCMeaKqztgPe1VXtpsyoMjs5lwTwbXMfruOjDIVJC3rs7ynkiD0yEgRUmC+/e1v41e/+hUAwO/3Y9q0afj2t7+NSZMmJZwMivvtf/rpp8cUm3PO0dTUhKNHj+LXv/51Qo0gJLpemXnofQ1mDLBXdkHKUsF0XxhD2hdMTgVB5BBFDk1j0FQRkpS5Nke69cQCy6JGuva0wrqswkTF5nF766238D//8z8AgJdeegmcc3R0dOCpp57C3XffndA8mXEHUhdffHFMICUIAioqKjBr1iyMHz8+7gYQAnR37Q3FjBRJjsXC4fUy6CEJyOAyLdE19swqgNwJgpPFohmpLDeEnBhnxpbM8UNMZ2dntPdsw4YNuPTSS2Gz2XDRRRclPGAu7kDqzjvvTOiJCOmPpnXPAySZVYDTOl9k8CxmDq83UnCe+UBKLLBASojWSA29mywpfHV1ddiyZQtKS0uxYcMGPPfccwCA9vZ2WCyWhM4Z9x1LFEW0tLT0ery1tRWiWDgfJiRzfH7jA5uJWrRbgZDBMoc/+/QMT8qpFugAie5Re1luCDkhzpPfhpobb7wR8+fPx7Bhw1BbW4tZs2YBMLr8Jk6cmNA54/7k4f385YPBIEymwl0fjaSPz1gdBaJZHVJTH5DUsFiMz6RMT4EQm5EqHNGuPY1mP8h5VCMVtx/+8IeYPn06Ghoa8PWvfx2CYOSTRo0ahXvuuSehcw76ffLwww8DABhjeOyxx+BwOKK/0zQNb731FtVIkYT4fEb0JJmpPorEz2I27gZ6BgMpzgEtFF7SqMACKeraI4Vs5cqVuOWWWzB16tSYx7/2ta/h5z//OWbOnBn3OQcdSD300EMAjIzU2rVrY7rxTCYTRowYgbVr18bdAEK84UBKpECKJKA7I5W5/ImuiOFCXR6dFLRQUNdeHqFi87itWLEC1157LWy22FXOfT4fVqxYgWXLlsV9zkF/8uzbtw8AcN555+HFF19ESUlJ3E9GSF+8XspIkcSZs5CRiiwNI8pawXVHM5pHKm8wbmzJHD/UcM77XC/4o48+SnguzLi/wr3xxhsJPREhfeEccHeFAylbKMutIfkokpHSVTFjxbPd03UUXtpGoJnN8wfVSA1aSUkJGGNgjOGUU06JCaY0TYPH48G1116b0LkTyoUfOnQIf/rTn9DQ0IBQKPbm9+CDDybUEDI0qUEJmsbAmA7JogAqTX1A4mMywfhqzVnGslJqgU7GCcR27Q3FUV2kMK1evRqcc/z3f/83VqxYgaKi7mUkIuVJM2bMSOjccQdSmzZtwn/+539i1KhR2LlzJ0477TTs378fnHOcccYZCTWCDF2KzxjpKdmG1mLFJHUYM7rYtJCUsZF7hZyRinTt8WTrb0j6UY3UoF1xxRUAgJEjR2LmzJmQZTll5447kFq6dCluueUWrFixAk6nE3/84x9RWVmJ+fPno76+PmUNI0NDKBxImazUrUcSJ8pqRgOpgs5ICd1pKD3D6xeSOFHXXtzOPfdc6LqOf//732hpaYGux85deM4558R9zrgDqR07duDZZ581DpYk+P1+OBwOrFy5EhdffDGuu+66uBtBhq5IRkq2UaE5SZxo0gBv5uaSKuiMFDOyUlwXoGvU1U4Ky7vvvovvfve7OHDgQK95MRlj0LT4R+HG/S6x2+3Ruqiamhrs3bs3+rtjx47F3QAydHHeM5CijBRJnBAOaLQMLPys690BWyEGUkB3nRSnQCq38RRsQ8y1116LadOm4dNPP0VbWxva29ujW1tbW0LnjDsjddZZZ+Htt9/GqaeeigsvvBA333wzPvnkE7z44os466yzEmoEGZq4JoDrxge1ZFaH4nuapEhkLqdMFJv7/QwAAxN0CAW6pJEgcugKoNPgj9xGXXtx2717N/7whz9gzJgxKTtn3IHUgw8+CI/HA8CY2Mrj8eD555/H2LFjacQeiUvkW70sczCBD8X3NEkRUTYCqUx07fn84ec0Fe6SRtGCc8pIkQIzffp07NmzJ3uBlKZpOHToECZNmgTA6Oaj2cxJovRwwW5kiQ9CEhXpYjNmN0/vTOP+8CLbhdqtByCaaaNi8xxHo/YG5eOPP47+/49+9CPcfPPNaGpqwsSJE3uN3ovEN/GIK5ASRRHnn38+duzYgeLi4rifLBXWrFmDn//852hqasLkyZPxyCOP4Mwzz+x3/xdeeAF33HEH9u/fj7Fjx+K+++7DhRdemMEWk/5EsgcWS5YbQvJepGtPU0Rwnt5AKrI2ZCEHUkwMT3JKGamcRjObD86UKVPAGIspLv/v//7v6P9HfpdosXncXXunnXYavvjiC4wcOTLuJ0vW888/j8WLF2Pt2rWYPn06Vq9ejblz52LXrl2orKzstf8777yD73znO1i1ahX+4z/+A+vXr8cll1yCDz74AKeddlrG209i6Up3RqqwVisjmSbK4aCGMyhpHgAazUgV8JJGAhWbkwISWeIuXeJ+l9x999245ZZb8Oqrr6KxsRFutztmS6cHH3wQCxcuxFVXXYUJEyZg7dq1sNlseOKJJ/rc/5e//CXq6+tx66234tRTT8Vdd92FM844A7/61a/S2k4yOJERVpElPghJFBMAJhnheCCY3u6KodC1F6mRooxUjsvSqL01a9ZgxIgRsFgsmD59Ot57770B93/hhRcwfvx4WCwWTJw4EX/9619jL4NzLFu2DDU1NbBarZgzZw52796dWOP6MHz48EFviYg7IxXpFvvP//zPmLVqkkmLDUYoFMK2bduwdOnS6GOCIGDOnDnYsmVLn8ds2bIFixcvjnls7ty5ePnll9PSRhKfSEbKbAG8WW4LyX+ipEJVRQSDLIGviIPnGwKBlBDu2qOMFDleOnqG7r//fjz88MN46qmnMHLkSNxxxx2YO3cuPv/8c1hSXPvxpz/9qc/HGWOwWCwYM2ZM3D1uebNo8bFjx6BpGqqqqmIer6qqws6dO/s8pqmpqc/9m5qa+n2eYDCIYDAY/TndWbahLFojZeZDchguSS1B1oAAEAgAsKXnOXSVQVV7BlKFWazLqNg8LzAkWSOVwDE9e4YAYO3atfjLX/6CJ554AkuWLOm1f8+eIQC46667sHHjRvzqV7/C2rVrwTnH6tWrcfvtt+Piiy8GADz99NOoqqrCyy+/jHnz5iV8fX255JJLetVLAbF1UmeffTZefvlllJSUDOqccX/dOPfccwfc8t2qVatQVFQU3erq6rLdpIIVHbVHXXskBSIF58E0du2p4RnNBUmLZm0KEdVIDS3Hl+j0TCb0FOkZmjNnTvSxwfQM9dwfMHqGIvvv27cPTU1NMfsUFRVh+vTp/Z4zGRs3bsSXv/xlbNy4EZ2dnejs7MTGjRsxffp0vPrqq3jrrbfQ2tqKW265ZdDnTOhd8o9//APf+973MHPmTBw+fBgA8L//+794++23EzndoJSXl0MURTQ3N8c83tzcjOrq6j6Pqa6ujmt/wFhLMPLH7ezsxMGDB5NvPOlF11h0Mk6LOcuNIQVBCBecp7NGKro0jLlwu/WA7vX2qEYqx0WmP0hmA1BXVxeTQFi1alWfTzdQz1B/PT0n6hmK/Dfe3qNE3XDDDXjwwQcxe/ZsOJ1OOJ1OzJ49Gz//+c9x66234itf+QpWr16NjRs3Dvqccb9L/vjHP2Lu3LmwWq344IMPopFrZ2cn7r333nhPN2gmkwlTp07Fpk2boo/puo5NmzZhxowZfR4zY8aMmP0BIxrtb38AMJvNcLlcMRtJPS2cjWKiDinuDmZCeotMypnOQCqyWLFUwPVRQM95pCiQymkpKjY/ePBgTAKhZy1yodm7d2+f93WXy4UvvvgCADB27Ni4lrxLaNTe2rVr8eijj8ZMZPWVr3wFH3zwQbyni8vixYvx6KOP4qmnnsKOHTtw3XXXwev1RvtqFyxYEPMCuOGGG7Bhwwb84he/wM6dO3HnnXfi/fffx6JFi9LaTnJikW696LB1QpIUyUgFA+l7jkhGSir0jBQVmw8pxycPzOa+uwnS0TMU+W+8vUeJmjp1Km699VYcPXo0+tjRo0dx22234ctf/jIAYxmZeMp64n6X7Nq1C+ecc06vx4uKitDR0RHv6eJy+eWX44EHHsCyZcswZcoUbN++HRs2bIimBBsaGtDY2Bjdf+bMmVi/fj1+97vfYfLkyfjDH/6Al19+meaQygGRjFSkroWQZGUkIxXp2jMV7hxSACAIVGyeFzI8/UE6eoZGjhyJ6urqmH3cbje2bt06YO9Roh5//HHs27cPw4YNw5gxYzBmzBgMGzYM+/fvx2OPPQYA8Hg8uP322wd9zrg7Vaqrq7Fnzx6MGDEi5vG3334bo0aNivd0cVu0aFG/GaXNmzf3euyyyy7DZZddluZWkXipMd/s078+Gil8QngeKVVl4GlaS1gdMhkpKjbPB9mY2Xzx4sW44oorMG3aNJx55plYvXp1r56hk046KVpndcMNN+Dcc8/FL37xC1x00UV47rnn8P777+N3v/ud0QbGcOONN+Luu+/G2LFjo9Mf1NbW4pJLLkn84voxbtw4fP7553jttdfw73//O/rY17/+dQiC8XqP93njDqQWLlyIG264AU888QQYYzhy5Ai2bNmCW265BXfccUe8pyNDVHdGSgVA1eYkeUzUjTsDZ9BUEUxKbbDD+fGv28IVnUdKF9IWlJL8dPnll+Po0aNYtmwZmpqaMGXKlF49Q5GABOjuGbr99tvx05/+FGPHju3VM3TbbbfB6/XimmuuQUdHB84++2xs2LAh5XNIRQiCgPr6etTX16fkfHEHUkuWLIGu65g9ezZ8Ph/OOeccmM1m3HLLLfjRj36UkkaRwhetNSnwGxLJHMYAUdKgKRJ0RYSY4kBKV0SAMzDGIZo06IU7+0E0IwUYBeciLeKUm5KYnTx6fAJS3TPEGMPKlSuxcuXKxBp0Ag8//DCuueYaWCwWPPzwwwPu++Mf/zju88cdSDHG8D//8z+49dZbsWfPHng8HkyYMAEOhyPuJydDF9VIkXQQZCOQ0hQRojW151Z8RubUbudgDAU9iSxjgCBw6DqjkXu5LEuBVL556KGHMH/+fFgsFjz00EP97scYy0wgFWEymaJzMFAQReLB9e7lYQq9i4RkliCFi6TVxOru9jUIaNpfA4vLB3ttR8zvFI8RSBUX8yFx/5EkIBSiOimS/3ouWpyOBYzjfoeoqoo77rgDRUVFGDFiBEaMGIGioiLcfvvtUNK97DopCJG5eCDo0RsfIakQGbkXWX4oHlwH9u4ToSsSfK0ueI7ELg8R8hn1GsVFQ+M1K0nhSTlVCqRyVaTYPJltqAqFQti1axdUNfkv83G/Q370ox/hd7/7He6//358+OGH+PDDD3H//ffj8ccfTyglRoaengW7jEZXkxSKjNzTEwikAm5rdB09AAh1dRe6ch1QvCYARkZqKIhMlKtrNKo2Z6VoZvOhxOfz4eqrr4bNZsOXvvQlNDQ0ADBim5/97GcJnTPuQGr9+vVYt24dfvCDH2DSpEmYNGkSfvCDH+Dxxx/H+vXrE2oEGVqiy2xQtx5JMVE2skWJZKS8bXYAgL2sCwCHFpKhhYzzKH4TwAUwUYfdNsQCKcpI5a4MzyNVCJYuXYqPPvoImzdvjhkVOGfOHDz//PMJnTPuGimz2dxrDinAmFTLZDIl1AgytIT8xuuEAimSatGMVJw3f00REQxnoGxlHgS9ZqgBE4JdZqAGCLTbAAAmexCMDY3AQo507VGNFCkgL7/8Mp5//nmcddZZYD26RL70pS9h7969CZ0z7nfIokWLcNddd8WsDh0MBnHPPffQ0ivkhDgH/OGbktnlz3JrSKFJtEbK3+YAwFBSrEO2qDDZjXVmgl0WBAKAp8lYm8te4Ulpe3MZZaRyH9VIxe/o0aOorKzs9bjX640JrOIRd0bqww8/xKZNmzBs2DBMnjwZAPDRRx8hFAph9uzZ+Na3vhXd98UXX0yoUaRwtXUw6IoIJmowOf1IIJYnpF/dGSkRnAOD+VjkHPC1GSOP607ScQyAbA8CrUCg04o9uwVwXYBsD8BS7AcwNBYyl+TwpJwJjoAkGUDTH8Rt2rRp+Mtf/hKd9zISPD322GMJL0kTdyBVXFyMSy+9NOaxeBb3I0Nb41HjRWsp9mGI9JCQDIqMAjVm5GaDGswQ8lqgKxIEUUN1pY5jrYDZEQATdKh+Ew4atahwntQ2pAZHyJSRIgXo3nvvxQUXXIDPP/8cqqril7/8JT7//HO88847ePPNNxM6Z9yB1JNPPpnQExECAO0d4UCqxJfllpBCJIgcosihaUbmUzCdeKqCgNvoarYW+yEIRv2eIOmwVbjhbS4GYAT+JkcQQ2ldyO5RexRI5axku+eGYEbq7LPPxkcffYRVq1Zh4sSJeO2113DGGWdgy5YtmDhxYkLnTHhCTkLixTngDZdFSdZQdhtDCpbFwuH1MmghCZJp4NcZ50Cgy5gC3VLkA9A9YMZW6Uag3QGuinANa09nk3NSpGsv0clNSQZQ117cFixYgPPOOw9LlizB6NGjU3LOuL9qtLa24vrrr8eECRNQXl6O0tLSmI2Q/miKCM4ZwDiN2CNpE5meQA3KJ9w35DWDa0bNntkRjPmdIHJUTTyMr54bhGwbepMNU9ceKUQmkwmrVq3CKaecgrq6Onzve9/DY489ht27dyd8zrgzUv/1X/+FPXv24Oqrr0ZVVVXCVe5k6FHCE3FKFgWMDckvQyQDHHaOlqOAGjAB8A64byC87IvF5e+z/kmUddhs/ESnKUg0s3keoIxU3B577DEAwOHDh/HWW2/hzTffxC9+8Qv84Ac/QE1NDQ4dOhT3OeMOpP7xj3/g7bffjo7YI2SwIkvDyJah9+2eZI7dHs5IBU6ckYpkrairuTc5/Oejmc1zV7JTGAzF6Q8iSkpKUFZWhpKSEhQXF0OSJFRUVCR0rri/aowfPx5+P83/Q+KnhsI3LTMFUiR9IoGUNoiuPTU8yz69JnujjBQpRD/96U8xc+ZMlJWVYcmSJQgEAliyZAmamprw4YcfJnTOuDNSv/71r7FkyRIsW7YMp512GmQ59sPK5Roac6yQ+Kk9uvYISZdIjZSuiuEgoO+Re5x3vyZFM9XsHS8yas+YSmJwc3IRkut+9rOfoaKiAsuXL8e3vvUtnHLKKUmfM6F5pNxuN772ta/FPM45B2MMmqYl3ShSmBQKpEgGSBIgyio0RYIalGB29h0k+QMwFm1lHKKsgiaHjSX1uDvoqgiRxnjnHqqRituHH36IN998E5s3b8YvfvELmEwmnHvuuZg1axZmzZqVUGAV91tj/vz5kGUZ69evp2JzMmiaKkSHUcsWdSi+f0kGSRbFCKQCMoBAn/v4fMZnlyirQ2qizcESBICJOrgmQFcFiBK9a3MN1UjFb/LkyZg8eTJ+/OMfAzBWZnnooYdw/fXXQ9f1hJJBcQdSn376KT788EOMGzcu7icjQ1fQa8zV43JwCJIOyluSdJKtIQS7rFD8/S+k7g0HUlQf1T9B1KFpkS9B1P1J8h/nHB9++CE2b96MzZs34+2334bb7cakSZNw7rnnJnTOuAOpadOm4eDBgxRIkbgEPRYAQGUZ7yc/QEjqmBxBoAVQfOZ+9/GFJ9eXaE6zfgmi8aWHCs5z2BDMKiWjtLQUHo8HkydPxrnnnouFCxfiq1/9KoqLixM+Z9yB1I9+9CPccMMNuPXWWzFx4sRexeaTJk1KuDGkMHEdCPqMQKqiTMfBLLeHFD6T3ZhcUw3I/QYBXn+4a89EGan+sPDahRrNbp6bqEYqbr///e/x1a9+NaUD4+IOpC6//HIAwH//939HH2OMUbE56RPngLu5BFwXIIgaipzAwSE4uSHJLFHWIZoUaCEZQY8ZqOq9jy8aSFFGqj+CaARSlJEiheKiiy5K+TnjDqT27duX8kaQwuU+UgxfqxH5u8q7wJgjyy0iQ4VsD0ILyQh19e7e4xwIhPuYjRF7pC+CFAmkKCOVi6jYPDfEHUgNHz48He0gBSikAJ4WJwCgqLoVjuIAAAqkSGaY7AEE2h1GRuo4uipA1xkADlGmLHp/KCOV46hrLyck9O743//9X3zlK19BbW0tDhw4AABYvXo1XnnllZQ2juS3/YcEcF2AZAnC6vJluzlkiJHDdVIhjxn6cXNyauE5zQRJo6kPBsBEykgRciJxB1K/+c1vsHjxYlx44YXo6OiI1kQVFxdj9erVqW4fyVNcBxoajTuUs7KTblYk4ySLYsyDpAtwu2NfgJpiBAaSibJRA4l27WmUkcpFka69ZDaSvLjfHY888ggeffRR/M///A9EsftbyrRp0/DJJ5+ktHEkf/m6bFBUBtGkwuyktRlJ5jEGmGxGVqq9PfajLro0DHXrDUigjFRu4ynYSNLiDqT27duH008/vdfjZrMZXi8NxyIGb7sdAGAv76JsFMmaSPdeR0fsR50WMgIDGrE3sGhGSqGMFCH9ifvdMXLkSGzfvr3X4xs2bMCpp56aijaRPKcGJIQCJjDGYS/3ZLs5ZAiTwxmptjYRusYQ6LBB11i0RkqijNSAohkpjTJSOYkyUjlh0KP2Vq5ciVtuuQWLFy/G9ddfj0AgAM453nvvPTz77LNYtWoVHnvssXS2leSJQKcNAFBezCHKOrRglhtEhiyTLQRB0hAMimj+aBh0RYIgadGuKpFqpAbEaNReTqPpD3LDoAOpFStW4Nprr8X3v/99WK1W3H777fD5fPjud7+L2tpa/PKXv8S8efPS2VaSBzgHgp1Gt15VBUdHdptDhjgmcLhO6kDHgTLoivFx17Peh+aQGhjNI5XjaPqDnDDoQIrz7r/4/PnzMX/+fPh8Png8HlRWVqalcSS/eLqsaP+iNvwTR1UZR0coq00iBI7KLqitJfB4BLhOPgo1YIKvpQiCwCGaNHC6mfRLEI2Mna4K9HcipB9xTcjJjqsattlssNlsKW0QyV+ecCYKACz2AEyyDFAgRbKMCcBZZwXxcVMbmBwCA4PVEcLIohI0qhy0qlX/BCkSPTFwmgIh91BGKifE9c445ZRTUFpaOuCWLm1tbZg/fz5cLheKi4tx9dVXw+MZuJB51qxZYIzFbNdee23a2jiUBYKAEjIBAFzDjqGktiO7DSKkB5MJkO3dUb3FFUB5Kd1FToQJHGCRhYspkMo1NI9UbogrI7VixQoUFRWlqy0Dmj9/PhobG7Fx40YoioKrrroK11xzDdavXz/gcQsXLsTKlSujP1MGLT2OthvZStkahLXUCzEU9+pDhJAcJEg6dEWggnNC+hHX3W7evHlZqYfasWMHNmzYgH/961+YNm0aAGNi0AsvvBAPPPAAamtr+z3WZrOhuro6U00dsiKBFE2+SUhhMQIpGrmXk3K4a6+trQ0/+tGP8Oc//xmCIODSSy/FL3/5Szgcfa+32tbWhuXLl+O1115DQ0MDKioqcMkll+Cuu+6KSeAcX2IEAM8++2xWB7sN+p3RV+MzZcuWLSguLo4GUQAwZ84cCIKArVu3DnjsM888g/Lycpx22mlYunQpfL6B13wLBoNwu90xGzmx9vCfiQIpQgqLIEUKzmnkXq7J5a69+fPn47PPPsPGjRvx6quv4q233sI111zT7/5HjhzBkSNH8MADD+DTTz/FunXrsGHDBlx99dW99n3yySfR2NgY3S655JL0XcggJDRqL9Oampp6ZcIkSUJpaSmampr6Pe673/0uhg8fjtraWnz88cf4yU9+gl27duHFF1/s95hVq1ZhxYoVKWv7UKBrDCHFCLQls5Ll1hBCUql7Uk7KSJHBSaQX6bTTTsMf//jH6M+jR4/GPffcg+9973tQVRWS1B2uFBcX51RP06DfGbqup7xbb8mSJb2KwY/fdu7cmfD5r7nmGsydOxcTJ07E/Pnz8fTTT+Oll17C3r17+z1m6dKl6OzsjG4HDx5M+PmHisi6ZYKoQRCpepGQQtI9lxQFUjknRTObH98LEwwmN4tyMr1IPXV2dsLlcsUEUQBw/fXXo7y8HGeeeSaeeOKJrCZ6gDhrpFLt5ptvxpVXXjngPqNGjUJ1dTVaWlpiHldVFW1tbXFFpdOnTwcA7NmzB6NHj+5zH7PZDLPZPOhzku5ASqbJDQkpONS1l8NSVCNVV1cX8/Dy5ctx5513JnzaRHuRejp27BjuuuuuXt2BK1euxNe+9jXYbDa89tpr+OEPfwiPx4Mf//jHCbc3WVkNpCoqKlBRUXHC/WbMmIGOjg5s27YNU6dOBQC8/vrr0HU9GhwNRmSNwJqamoTaS/qmRtcto0CKkEJDGanCd/DgQbhcrujP/SUTlixZgvvuu2/Ac+3YsSPp9rjdblx00UWYMGFCr4DujjvuiP7/6aefDq/Xi5///OdDN5AarFNPPRX19fVYuHAh1q5dC0VRsGjRIsybNy/a13r48GHMnj0bTz/9NM4880zs3bsX69evx4UXXoiysjJ8/PHHuOmmm3DOOedg0qRJWb6iwqLSArCEFCyB1tvLWSy8JXM8ALhcrphAqj+Z6EXq6upCfX09nE4nXnrpJciyPOD+06dPx1133YVgMJi13qS8CKQAY/TdokWLMHv27OhQyocffjj6e0VRsGvXruioPJPJhL///e9YvXo1vF4v6urqcOmll+L222/P1iUULCVovNAliTJShBSa7q49CqRyToanP0h3L5Lb7cbcuXNhNpvxpz/9CRaL5YTPtX37dpSUlGS1JCdvAqnS0tIBJ98cMWJETMFZXV0d3nzzzUw0bUjjnLr2CClksQsX69ltDImR7BQG6Zr+IJFeJLfbjfPPPx8+nw+///3vY6YfqqiogCiK+POf/4zm5macddZZsFgs2LhxI+69917ccsst6bmQQcqbQIrkJq4J4LrxTVWSNfqYJaTAxE5/QO9wMjjx9iJ98MEH0RF9Y8aMiTnXvn37MGLECMiyjDVr1uCmm24C5xxjxozBgw8+iIULF2buwvpAgRRJSqRbz2LmEAROH7OEFJhI156mUNdezsnhmc3j7UWaNWvWCacxqK+vR319fcramCoUSJGkqAEjkHLSEoaEFCTRFAmkJAChgXcmmUdT92UdfcXIAk0VEAhkuxWpoQZMAACnnd7NhBQiMTwal2sCVCqDJKQXykhlEOdAe0sRutqdaBKBmjMkMFN+L6kS6dpz2oA2+pAlpOAwUQcTdHBdQDCYvTVXSW+5Wmw+1FBGKoP27RfQ1eYCOIOqMnQ1n3jejlzGOWWkCCl0jAGiyfiWRIFUjknREjEkORRIZcjhdj927jaWWDDZjHWMPE0uZHmJoKRoqhgescdht2a7NYSQdIkGUgEKpAg5HgVSGfLbN/ZD1xnMtgCqxjVBkjjUoIxgZ/5GIEpkjT2zAoFeSYQUrEjBOWWkckukay+ZjSSPbn8ZcuuFYzH8ZA2l1e0QRI7KyvAHU1f+BlKhcH2UbMnvOi9CyMC6u/bolpFTqGsvJ9C7IkOcFgkTJ2iQwx9Idocx41Jk+oB8FAoa9VEmKw2JJqSQUY0UIf2jUXtZYrMZXwXyNZDiHAgFKJAiZCiQetRI0ZRxuYNG7eUGCqSyJN8DKV8A0HUBYJy69ggpcFQjlaNyeGbzoYQCqSyx242uPS0oQdfz78Opo8tos2wNguVf8wkhcRBl6trLSRRI5QSqkcoSkwlggg6AQfHnX1aqo8v4L3XrEVL4RDMFUoT0hwKpLGEMkKxGl1jQZ8pya+LX2hHOSNkKZK0bQki/IhkpTWPQVQqmcgVNf5AbKJDKokhtUcifX4GUGhLhDTAAHGYHBVKEFDpB4uEMOqCGqCIkZ9D0BzmBAqksyteMlD8895XZEoIg0juRkKEgMgUCBVKExKJ3RBZFMlJBrxlA/ox883ssAABLeKkbQkjhE00a1ACgBum2kSsY52BJrDOWzLGkG70jsshkNwKRgCd/AimuRwI/wEL1UYQMGZEpECgjlUNo1F5OoK69LDLZjRFvSsCEYCg/CjhDPjM4FyBLPDpLOyGk8EUm5dQokCIkBr0jskiQdIjmELSgCR0dYrabMyiRtQFLnKD5owgZQkSZMlK5hmY2zw2UkcqySFaqozM/AqlQl1EfVeKidyAhQ0l3sXl+fFYNCTRqLydQIJVlcrhOqqMz97/lcd4jI1VE70BChpJojRQVmxMSgwKpLDNFA6nc/5anBmToqgjGdBTZs90aQkgmRbr2qEYqd9CEnLmBAqksi2SkOjtFcD3LjTmBUHjaA5MtBIFeOYQMKT3nkaJR8zmCuvZyAt0Os0yyKBBlFbrOEAzk9sSckfooM80fRciQE+na47oAXaNbRy6gjFRuoHdDljEG2Fx+AIDfa8lyawYWook4CRmyBJFDkow7L9VJEdKNAqkcYCsyAqlAeKLLXKQGRWghGQCHyRrKdnMIIVlgNocDKaqTyg3UtZcT6N2QA6yRQMqXuxmpgNsYrSfbg7S+HiFDlNnM4fUCalDOdlNIGHXPZR9lpHJAJCMVCsjQ1Nz8Jwm6w/VRTloWhpChymwxRsQo1LVHSBS9G3KAbFZhs2nw+UT4umxADs6EEMlImZ3+LLeEEJItVquR/lD8uT0wZsjgHEkNoaThlymRm+mPIaisxBgR43XbstyS3kKh7g9OCqQIGbqigVSAuvZyAY3ayw0USOWI0lJjjpa+Aik9y9197R3G80uWEEQ5xye7IoSkjdUa7tqjQIqQKOrayxGlJUYg5XPbUNrjcffhIrgPlcJu8aDU1pmVtrW3G6sTmxxUH0XIUNadkaKuvZyQ7Mg7ykilBAVSOcIIpDhCQROUoITO5iJ81CzC3WSEVd6AA+wYA0Zmtl2cA0ePGRkpExWaEzKkRQIpNSjl/EoMQwHTjS2Z40ny8qZr75577sHMmTNhs9lQXFw8qGM451i2bBlqampgtVoxZ84c7N69O70NTZAsAyaLAgA4+MkIeFpcaGwyqs5Fs/G412OFqmW2XYrfBI9HAJgOS5Evs09OCMkpJjMHE3QADCHKShECII8CqVAohMsuuwzXXXfdoI+5//778fDDD2Pt2rXYunUr7HY75s6di0AgNzMrNkd3ITcTdTgcOgRJQ+nwZoiCCs4FHG3L7D+Zr9VYndhW6oMg0dcXQoYyxgDJbJQhUJ1UDqAJOXNC3gRSK1aswE033YSJEycOan/OOVavXo3bb78dF198MSZNmoSnn34aR44cwcsvv5zexiao/KRWjDj1AMpOPorKU5pw9lkqas5ogGRRYbMYQVZji5CxEatcB3xtRiDlqOjKzJMSQnKaHM6cU51U9uXyqL22tjbMnz8fLpcLxcXFuPrqq+HxeAY8ZtasWWCMxWzXXnttzD4NDQ246KKLYLPZUFlZiVtvvRWqqqbvQgahYGuk9u3bh6amJsyZMyf6WFFREaZPn44tW7Zg3rx5fR4XDAYRDHavJed2u9Pe1ghR5CiqaYfgVhBUjOVimFHnDZvZjy6fE4ebRTS1nora4Y2APb39fJ5jLuiqCLOZw1rsg6KytD4fIST3RQIp6trLATk8j9T8+fPR2NiIjRs3QlEUXHXVVbjmmmuwfv36AY9buHAhVq5cGf3ZZuseya5pGi666CJUV1fjnXfeQWNjIxYsWABZlnHvvfem7VpOJG8yUvFqamoCAFRVVcU8XlVVFf1dX1atWoWioqLoVldXl9Z2DpZZDsJsMQI8TZVwtLE8ofeAFhJxbGcNPMccJ9y3o7EEAHBynQZWsK8UQkg8pHDNZshPXXukbzt27MCGDRvw2GOPYfr06Tj77LPxyCOP4LnnnsORI0cGPNZms6G6ujq6uVyu6O9ee+01fP755/j973+PKVOm4IILLsBdd92FNWvWIBTK3hqwWb09LlmypFca7/ht586dGW3T0qVL0dnZGd0OHjyY0efvD2NAVe0xzJ4RhCDoCPis8HfY4z6P+1AJgp02dBwsxa49/U+h7m5zIOixAoyjbliGK9wJITlLtlLXXq5IVdee2+2O2Xr2yiRiy5YtKC4uxrRp06KPzZkzB4IgYOvWrQMe+8wzz6C8vBynnXYali5dCp+ve5DTli1bMHHixJgEydy5c+F2u/HZZ58l1eZkZLVr7+abb8aVV1454D6jRo1K6NzV1dUAgObmZtTU1EQfb25uxpQpU/o9zmw2w2w2J/ScmWCzAtUjWnDki2p4WorgqjO6HkMeE1r/XYmGkARHhQcjz+h9rKYI8B3tju737BMxrrr3S4BzYN/nwwEA9jIPzGYTkL1gnxCSQ0zhQCroy93PySEjRfNIHd/zsnz5ctx5550Jn7apqQmVlZUxj0mShNLS0gF7hL773e9i+PDhqK2txccff4yf/OQn2LVrF1588cXoefvqZYr8LluyGkhVVFSgoqIiLeceOXIkqqursWnTpmjg5Ha7sXXr1rhG/uWiymGtaNxfCTVoQqDTCpQDHQ2lCHmNhYU7jxTjE0kBL489rrOlCFwXINuCYAwIec3obHHBYvPG7NfeWAxPhwNM0OCq7QAQ+4YghAxdssX4VhXym2iptgJx8ODBmC60/pIJS5YswX333TfguXbs2JFwO6655pro/0+cOBE1NTWYPXs29u7di9GjRyd83nTLm2LzhoYGtLW1oaGhAZqmYfv27QCAMWPGwOEw6n3Gjx+PVatW4Zvf/CYYY7jxxhtx9913Y+zYsRg5ciTuuOMO1NbW4pJLLsnehaSAKOlwFbvR2VaMzoMl8Ndw+FuNgrzaUw7jyL9rcbBBhqWjEkWVrQCMLFNncxEAwFHTAR6UuwOpEd2BVMNRhqYvjAi/tK6VloQhhMSQLQrAOLguIBgwAc5st2joSnbkXeRYl8sVE0j1Z7C9SNXV1WhpaYl5XFVVtLW1RXuLBmP69OkAgD179mD06NGorq7Ge++9F7NPc3MzAMR13lTLm0Bq2bJleOqpp6I/n3766QCAN954A7NmzQIA7Nq1C52d3cuo3HbbbfB6vbjmmmvQ0dGBs88+Gxs2bIDFYslo29OhuKwT7nYXgm4r3nnHmCDPUuRDzehmMBNH446TEHBbwXgJrMWdaOlgUEMSBEmDtdQL7jeh41AJ/F1WBLxmMFsIXW4b9rcKABiqhzfBflIHgkFrti+VEJJDmGBkpRS/GT6vGUhPpwIZjAyP2htsL9KMGTPQ0dGBbdu2YerUqQCA119/HbquR4OjwYgkTCLlOTNmzMA999yDlpaWaNfhxo0b4XK5MGHChLiuJZXyZizWunXrwDnvtUWCKMCYO6pntMwYw8qVK9HU1IRAIIC///3vOOWUUzLf+DSQTSqK644BAPw+45/RVdtu/LeqC9PPCgDg8HfZ0eWx4otGY+oCW4UbTOAQZR01VUa2qXlfDZo+H47W1hIADMXV7Rh12oHo1AuEENKTyWp07/m8+f+llKTeqaeeivr6eixcuBDvvfce/vnPf2LRokWYN28eamtrAQCHDx/G+PHjoxmmvXv34q677sK2bduwf/9+/OlPf8KCBQtwzjnnYNKkSQCA888/HxMmTMB//dd/4aOPPsLf/vY33H777bj++uuzWtucNxkp0pu12AfR0owSlKDTdBS2ku7JzsrKdLhqOuFuLEZruzGNARiHvap7XqxJX1LRGQjA12kHOCCKGsZUA8KIZgqiCCH9MllD8CISSFGhVLakqmsvHZ555hksWrQIs2fPhiAIuPTSS/Hwww9Hf68oCnbt2hUdlWcymfD3v/8dq1evhtfrRV1dHS699FLcfvvt0WNEUcSrr76K6667DjNmzIDdbscVV1wRM+9UNlAglefsFR6MK3Pgk3Z/r+DHVdMJ1SfB1+kAA0fVmCZIVgVcN3aURGDE5IM41lAEbtJgCzGMq6rCHgqiCCEDMNl6ZqT8A+9M0idFo/bSobS0dMDJN0eMGAHeo2uxrq4Ob7755gnPO3z4cPz1r39NSRtThQKpAsYY4Kpsh0MO4ZRqF5odHvgRGyUJAofN6UeIMTCF5oUhhJyYbKVAipCIvKmRIolhDLBZAyg58UTmhBAyKJEaKa+HaqSyKZfX2htKKCNFCCEkLmZHEABHMGCG10/fx7NG58aWzPEkafQOIIQQEhdR0mG2G8uIHG2lGc6zhqdgI0mjQIoQQkjcbC5jtFVLG9VWkqGNAilCCCFxs7qMIvPmVgqksoUhyRqpbF9AgaAaKUIIIXGzRjJSrSZajTNbMjyzOekbZaQIIYTELZKRcntkKCExy60hJHsokCKEEBI3SdbgcBpZqc5jtHJxNtD0B7mBAilCCCEJqaw21vdsbynObkOGKhq1lxMokCKEEJKQypo2AEB7i4vKbciQRcXmhBBCElJa7obZpCEYkuHrsMHiUrLdpCGFcQ6WRASbzLGkG2WkCCGEJEQQOEYOM4rOWw+UZ7k1Q5Cego0kjQIpQgghCfvyxE4AHO7mYvg7ae09MvRQIEUIISRh5SUKKoa1AgAad9RAVbPcoCEk0rWXzEaSR4EUIYSQpAwffwSSSUHQY8G779qhqnRryQgatZcT6NVOCCEkKSaLgpOnHABjOo40mvDuG5Nx5GAFjeRLt8jM5slsJGkUSBFCCEmarcSHk89ogMWsw9Nlw7+2TMSencOz3SxC0o4CKUIIISlhK/Fj7lw3Row5DADYvXM4Al5a1DhdaGbz3ECBFCGEkJQxmznGTdyPqppj0HUBTXuqst2kwkVdezmBAilCCCEpxRhw2pTdAICuVgcCAZblFhGSPhRIEUIISTmH04+S0k4ADEeOiNluTkFievIbSR4FUoQQQtLipJObAQCHDtFqZGlBXXs5gQIpQgghaVFb1wKAw+0WoQYpK0UKEwVShBBC0sJkUmFxBgAAQbc1y60pQDQhZ06gQIoQQkja2It9AICAm9bhSzVaIiY3UCBFCCEkbexFRiAVpECKFCiqACSEEJI2kYyU4jNDVwUIIg0VS5lkC8YpI5USlJEihBCSNpJJg8NhBE8hrznLrSkwHICexEZxVEpQIEUIISStios1AEDIR4FUKlGNVG6gQIoQQkhaFRUZGSnFR+vukcJDNVKEEELSigKpNOFIskYqZS0Z0vImI3XPPfdg5syZsNlsKC4uHtQxV155JRhjMVt9fX16G0oIISSGEUhx6KoELUQTc6YMzWyeE/ImkAqFQrjssstw3XXXxXVcfX09Ghsbo9uzzz6bphYSQgjpiygCsi0EwBi9R0ghyZuuvRUrVgAA1q1bF9dxZrMZ1dXVaWgRIYSQwTI5glB8ZoS8ZthKg9luTmHQAbAkjydJy5uMVKI2b96MyspKjBs3Dtdddx1aW1sH3D8YDMLtdsdshBBCkmOyGxkp1U91UqmSy6P22traMH/+fLhcLhQXF+Pqq6+Gx+Ppd//9+/f3KsWJbC+88EL3Nffx++eeey5t1zEYBR1I1dfX4+mnn8amTZtw33334c0338QFF1wATdP6PWbVqlUoKiqKbnV1dRlsMSGEFKZo1x4FUkPC/Pnz8dlnn2Hjxo149dVX8dZbb+Gaa67pd/+6urqYMpzGxkasWLECDocDF1xwQcy+Tz75ZMx+l1xySZqvZmBZ7dpbsmQJ7rvvvgH32bFjB8aPH5/Q+efNmxf9/4kTJ2LSpEkYPXo0Nm/ejNmzZ/d5zNKlS7F48eLoz263m4IpQghJkikcSGlBCbqWTH8UicrRmc137NiBDRs24F//+hemTZsGAHjkkUdw4YUX4oEHHkBtbW2vY0RR7FWG89JLL+Hb3/42HA5HzOPFxcU5VbKT1YzUzTffjB07dgy4jRo1KmXPN2rUKJSXl2PPnj397mM2m+FyuWI2QgghyRFkDYKkAWBQA3K2m1MYcnTU3pYtW1BcXBwNogBgzpw5EAQBW7duHdQ5tm3bhu3bt+Pqq6/u9bvrr78e5eXlOPPMM/HEE0+AZ3n0YVYzUhUVFaioqMjY8x06dAitra2oqanJ2HMSQggBGAMkSwghjxWKjwKpXHJ8LbDZbIbZnPjoyqamJlRWVsY8JkkSSktL0dTUNKhzPP744zj11FMxc+bMmMdXrlyJr33ta7DZbHjttdfwwx/+EB6PBz/+8Y8Tbm+y8qZGqqGhAdu3b0dDQwM0TcP27duxffv2mOK18ePH46WXXgIAeDwe3HrrrXj33Xexf/9+bNq0CRdffDHGjBmDuXPnZusyCCFkyJKtCgBA8VMglRIpykjV1dXF1AavWrWqz6dbsmRJvwXhkW3nzp1JX5bf78f69ev7zEbdcccd+MpXvoLTTz8dP/nJT3Dbbbfh5z//edLPmYy8mf5g2bJleOqpp6I/n3766QCAN954A7NmzQIA7Nq1C52dnQCM/taPP/4YTz31FDo6OlBbW4vzzz8fd911V1KRNiGEkMRIFio4T6kUTX9w8ODBmDKW/u6RN998M6688soBTzlq1ChUV1ejpaUl5nFVVdHW1jao2qY//OEP8Pl8WLBgwQn3nT59Ou666y4Eg8Gs3dvzJpBat27dCeeQ6tlParVa8be//S3NrSKEEDJYsjUcSHlN4Lz/0dNkcJKdwiBy7GDrgQdbjjNjxgx0dHRg27ZtmDp1KgDg9ddfh67rmD59+gmPf/zxx/Gf//mfg3qu7du3o6SkJKsJkrwJpAghhOQ32aoAjENXRQQCFEgVqlNPPRX19fVYuHAh1q5dC0VRsGjRIsybNy86Yu/w4cOYPXs2nn76aZx55pnRY/fs2YO33noLf/3rX3ud989//jOam5tx1llnwWKxYOPGjbj33ntxyy23ZOza+kKBFCGEkIxgAodsDUHxmdHZyfKoSjdH5ej0BwDwzDPPYNGiRZg9ezYEQcCll16Khx9+OPp7RVGwa9cu+Hy+mOOeeOIJDBs2DOeff36vc8qyjDVr1uCmm24C5xxjxozBgw8+iIULF6btOgaDAilCCCEZI9sDUHxmdHQKQEm2W5PndA6wJIIhPX2BVGlpKdavX9/v70eMGNHntAX33nsv7r333j6Pqa+vR319fcramCr0fYAQQkjGmOzGOnudbpqUkxQGykgRQgjJGDkcSLndDNbszqOY/3K4a28ooUCKEEJIxkgWBUzUoWkCFL8M0RzMdpPyWLKzk1MglQrUtUcIISRjGAPMzgAAIOixZLk1hCSPAilCCCEZ1R1I0eTIScnRtfaGGuraI4QQklFmlxFIhTxmupcnQ+dIqnsujaP2hhLKSBFCCMko2aZAljm4LkDx0XIxJL9RIEUIISSjGAPKyoyF3gJue5Zbk8e4nvxGkkaBFCGEkIyrqQ4HUh026t5LFNVI5QSqkSKEEJJxFeUcTNSgqxKCATOsFiXbTco/VCOVEygjRQghJOMEAbAW+wEAvi5HlltDSOIokCKEEJIVjnIPAMDvtUIJUgdJ3KhrLydQIEUIISQrZKsCs9MHgKGr1Znt5uQfjiQDqWxfQGGgQIoQQkjWOKo6AQA+tw3H2mghY5J/KJAihBCSNbI1BLurCwDw6S4RakjMcovyCHXt5QTqlCaEEJJVrpJOBP1WBIISQl9UoGhYK0wmNdvNyn26DiCJuaB0mkcqFSgjRQghJKsEgaP85KOw2zh0VUL7/iq0NRdBpViK5AEKpAghhGSdJOs46wwVthJjJJ+304E3/iWi/XApfF4rdI3qp3qhrr2cQF17hBBCcoIsAcUndcBc5EXX4VKoigxfpx0+2IE2DosjgMMag6qIELiW7eZmX7LBEAVSKUGBFCGEkJxisgdRPaIFtZYqfH7Eh0CnFaoqI9BlxSe7AKAGAIcoaZCYBr+PwaO7IDv9kHiIbmwko+j1RgghJOcwBpQWAUVaJ4psboQECQGvDSzghNsDAAyaKkGDhEYFAByAx4E2cIheHa0+AYpYAllXYDKpkNRgdi8oHWiJmJxAgRQhhJCcxhggmxWY7G5MrLDhk8YmaH4RiiZA9MmoshVjX6cfgZAJqiJD00V0eAHA3n2SNqBlNwdDJQRBg+TRsSvA0OWzQWQheP1AV0BFpb2/VuQeznVwnvjIu2SOJd0okCKEEJJXGANESYNgUmHRNYwsB9xiJ1SLBrFRhC7JqCwtxZ4OLxSvDEWVoWoiVJUBkAHICIaALzwAUAx0AC2HAE/zZ/jDtV/J5qXFh/PkskpUI5USFEgRQggpGJKgg8kqakqBo6IbTAYgMGilHCMdldiz242QJkAXJRSZHGhuD0HRJEAX4bLQLZHEj141hBBCCp4gcDjtgNUchMwBZmOYUGUHE9ug2TgmnVSNO86ekO1mxocnWSNFGamUoECKEEIIASCwPJurStcBlkSdE9VIpQRNyEkIIYQQkiDKSBFCCCH5iLr2cgIFUoQQQkge4roOnkTXHk1/kBrUtUcIIYQQkiDKSBFCCCH5iLr2cgIFUoQQQkg+0jnAKJDKtrzo2tu/fz+uvvpqjBw5ElarFaNHj8by5csRCoUGPC4QCOD6669HWVkZHA4HLr30UjQ3N2eo1YQQQggpdHkRSO3cuRO6ruO3v/0tPvvsMzz00ENYu3YtfvrTnw543E033YQ///nPeOGFF/Dmm2/iyJEj+Na3vpWhVhNCCCFpxLkxF1TCG2WkUiEvuvbq6+tRX18f/XnUqFHYtWsXfvOb3+CBBx7o85jOzk48/vjjWL9+Pb72ta8BAJ588kmceuqpePfdd3HWWWdlpO2EEEJIOnCdgyfRtccpkEqJvMhI9aWzsxOlpaX9/n7btm1QFAVz5syJPjZ+/HicfPLJ2LJlS7/HBYNBuN3umI0QQgjJOUllo3Sa2TxF8jKQ2rNnDx555BH84Ac/6HefpqYmmEwmFBcXxzxeVVWFpqamfo9btWoVioqKoltdXV2qmk0IIYQMCffccw9mzpwJm83W6z7cH845li1bhpqaGlitVsyZMwe7d++O2aetrQ3z58+Hy+VCcXExrr76ang8njRcweBlNZBasmQJGGMDbjt37ow55vDhw6ivr8dll12GhQsXprxNS5cuRWdnZ3Q7ePBgyp+DEEIISRbXedJbuoRCIVx22WW47rrrBn3M/fffj4cffhhr167F1q1bYbfbMXfuXAQCgeg+8+fPx2effYaNGzfi1VdfxVtvvYVrrrkmHZcwaFmtkbr55ptx5ZVXDrjPqFGjov9/5MgRnHfeeZg5cyZ+97vfDXhcdXU1QqEQOjo6YqLh5uZmVFdX93uc2WyG2WweVPsJIYSQrOE6gNxctHjFihUAgHXr1g2uKZxj9erVuP3223HxxRcDAJ5++mlUVVXh5Zdfxrx587Bjxw5s2LAB//rXvzBt2jQAwCOPPIILL7wQDzzwAGpra9NyLSeS1UCqoqICFRUVg9r38OHDOO+88zB16lQ8+eSTEISBk2lTp06FLMvYtGkTLr30UgDArl270NDQgBkzZgy6jZFivGRrpbr8HoS8Pqh+P5igwdvlhuoLQNM5FITg5R6ovgAUOQDVJ0FVdHi6uqD6/ND8DEJABBcEdHW5oQgBqH4BqiCAiTo8pi6ovgAEpkFBAGqIwasbx6p+AaJfhMfdBVUKQGUMXGdgIRWeri4oWgCqT4fKGAS/ZjxmCUCRg1B9AagBGMf6A1BDABc5mF+HV+iC6vdDhQKui8b1+P1QmQLOAKZIRvsDfmghAIoAzgR4wvtp4OAaA5gQbr8fOlMBRQBUqfvaRQ1cZPCGr1ENATwkQGQcXtltHCdpQECAwHR4PB6o3gAUHoDqY1A0wCt1QfEGEIpck8a7z6cK4LoIj+gJ/60F6AIAzuGRw22QVHBNgOpX4enyGO2XNPAAA/w6usLXyYOA6udgugBvZD9RhyAydLnD5w8BTNLBIKJL7r5GMAYoIjye7seYIkBQw9fu90PVNDCRoctt7MP9AAsJEEICvJ7w31rl4AJiHlNVDp1zMJ1Fz6+LGrisg/k1eKTwY+DgXIAn3FZdVCFIHEwV4ZGMxzjTwDQNXFXDxxl/Z+5XIWgwntPvhyqGIAgaENLgcXdB1oIIMQaFM3jQhWAgCMUrQ1I0hNQQvJrxb6RqInSmI6SH4OXGY0zXofpkqEL47+/zA4IOLShAYEL0MS0EcCZ2/6xzQBfAuB59jWkhAGDgXOz+99V1QOTG6zNy7dABAVD1HseqHFwQ4ZF7nF8TwFXA22W8RwRRhRrUIMiAV+z+t1S5AlHh8LIuKL4AQmoQik9GSAzCY/ZAEhXoTEGXokIMeuAJqlCZBoGp8CoKAoIHQU/Q+Bv5JOO9KnqghPwQlAC4LgIhFV2eLqhBP1SdQzUDXAK8XuM9JwZ1KCEGr6cLSsgPhalQ1CAENQCv13hMDTCofh1cY9H3IJdVCKIGcMm4Jn8AuqiCMw0hBNHFvVC8ASiKBl0z2hXiQUAKQtcEKN4APFrktSIAog5BEKOvO03Twf0CmC4Yz+n3Q+c6VEWE1238zPzMeA1LLPoZwkMAFzjUgNj9uuMaxAAD4yK8HuM9yAIABAbu06OfSSoHGGPhfzc/NMYR8vrQ5XbDoiUXXETuFZko5FahJDUfpwoFQO/7WzYSCvv27UNTU1NMXXNRURGmT5+OLVu2YN68ediyZQuKi4ujQRQAzJkzB4IgYOvWrfjmN7+Z0TZH8Txw6NAhPmbMGD579mx+6NAh3tjYGN167jNu3Di+devW6GPXXnstP/nkk/nrr7/O33//fT5jxgw+Y8aMuJ774MGDkaljaaONNtpoo21Q28GDB1N2Dzye3+/n1dXVKWmnw+Ho9djy5ctT1tYnn3ySFxUVnXC/f/7znxwAP3LkSMzjl112Gf/2t7/NOef8nnvu4aecckqvYysqKvivf/3rlLQ3EXkx/cHGjRuxZ88e7NmzB8OGDYv5HQ9H/YqiYNeuXfD5fNHfPfTQQxAEAZdeeimCwSDmzp2LX//613E9d21tLQ4ePAin0wnGWFLX4Xa7UVdXh4MHD8LlciV1rnxD107XTtc+dAzla+eco6urK63dTBaLBfv27TvhpNSDwTnvdW/rLxu1ZMkS3HfffQOeb8eOHRg/fnzS7coneRFIXXnllSespRoxYkSvVKrFYsGaNWuwZs2ahJ9bEIRewVuyXC7XkPtwiaBrp2sfaujah961FxUVpf05LBYLLBZL2p+np3jrmuMRqV1ubm5GTU1N9PHm5mZMmTIluk9LS0vMcaqqoq2tbcDa53TLi0CKEEIIIdkVT11zvEaOHInq6mps2rQpGji53W5s3bo1OvJvxowZ6OjowLZt2zB16lQAwOuvvw5d1zF9+vS0tGsw8nIeKUIIIYTkroaGBmzfvh0NDQ3QNA3bt2/H9u3bY+Z8Gj9+PF566SUARvH/jTfeiLvvvht/+tOf8Mknn2DBggWora3FJZdcAgA49dRTUV9fj4ULF+K9997DP//5TyxatAjz5s3L2og9gDJSGWU2m7F8+fIhOb0CXTtd+1BD1z40r50Yli1bhqeeeir68+mnnw4AeOONNzBr1iwAxkj6zs7O6D633XYbvF4vrrnmGnR0dODss8/Ghg0bYrown3nmGSxatAizZ8+O1kA//PDDmbmofjB+fGERIYQQQggZFOraI4QQQghJEAVShBBCCCEJokCKEEIIISRBFEgRQgghhCSIAqkMWbNmDUaMGAGLxYLp06fjvffey3aTUu7OO+8EYyxm6znDbSAQwPXXX4+ysjI4HA5ceumlaG5uzmKLE/fWW2/hG9/4Bmpra8EYw8svvxzze845li1bhpqaGlitVsyZMwe7d++O2aetrQ3z58+Hy+VCcXExrr766pihwbnqRNd+5ZVX9nod1NfXx+yTr9e+atUqfPnLX4bT6URlZSUuueQS7Nq1K2afwbzOGxoacNFFF8Fms6GyshK33norVFXN5KXEbTDXPmvWrF7/9tdee23MPvl47YQMhAKpDHj++eexePFiLF++HB988AEmT56MuXPn9pqhtRB86UtfQmNjY3R7++23o7+76aab8Oc//xkvvPAC3nzzTRw5cgTf+ta3stjaxHm9XkyePLnfWfPvv/9+PPzww1i7di22bt0Ku92OuXPnIhAIRPeZP38+PvvsM2zcuBGvvvoq3nrrLVxzzTWZuoSEnejaAaC+vj7mdfDss8/G/D5fr/3NN9/E9ddfj3fffRcbN26Eoig4//zz4fV6o/uc6HWuaRouuugihEIhvPPOO3jqqaewbt06LFu2LBuXNGiDuXYAWLhwYcy//f333x/9Xb5eOyEDytoqf0PImWeeya+//vroz5qm8draWr5q1aostir1li9fzidPntzn7zo6Orgsy/yFF16IPrZjxw4OgG/ZsiVDLUwPAPyll16K/qzrOq+uruY///nPo491dHRws9nMn332Wc45559//jkHwP/1r39F9/l//+//ccYYP3z4cMbanqzjr51zzq+44gp+8cUX93tMoVw755y3tLRwAPzNN9/knA/udf7Xv/6VC4LAm5qaovv85je/4S6XiweDwcxeQBKOv3bOOT/33HP5DTfc0O8xhXLthPREGak0C4VC2LZtG+bMmRN9TBAEzJkzB1u2bMliy9Jj9+7dqK2txahRozB//nw0NDQAALZt2wZFUWL+DuPHj8fJJ59ccH+Hffv2oampKeZai4qKMH369Oi1btmyBcXFxZg2bVp0nzlz5kAQBGzdujXjbU61zZs3o7KyEuPGjcN1112H1tbW6O8K6dojkwmWlpYCGNzrfMuWLZg4cSKqqqqi+8ydOxdutxufffZZBlufnOOvPeKZZ55BeXk5TjvtNCxdujRmIflCuXZCeqKZzdPs2LFj0DQt5oMDAKqqqrBz584stSo9pk+fjnXr1mHcuHFobGzEihUr8NWvfhWffvopmpqaYDKZUFxcHHNMVVUVmpqastPgNIlcT1//5pHfNTU1obKyMub3kiShtLQ07/8e9fX1+Na3voWRI0di7969+OlPf4oLLrgAW7ZsgSiKBXPtuq7jxhtvxFe+8hWcdtppADCo13lTU1Ofr43I7/JBX9cOAN/97ncxfPhw1NbW4uOPP8ZPfvIT7Nq1Cy+++CKAwrh2Qo5HgRRJmQsuuCD6/5MmTcL06dMxfPhw/N///R+sVmsWW0Yyad68edH/nzhxIiZNmoTRo0dj8+bNmD17dhZbllrXX389Pv3005g6wKGiv2vvWec2ceJE1NTUYPbs2di7dy9Gjx6d6WYSkhHUtZdm5eXlEEWx16id5uZmVFdXZ6lVmVFcXIxTTjkFe/bsQXV1NUKhEDo6OmL2KcS/Q+R6Bvo3r66u7jXYQFVVtLW1FdzfY9SoUSgvL8eePXsAFMa1L1q0CK+++ireeOMNDBs2LPr4YF7n1dXVfb42Ir/Ldf1de1+mT58OADH/9vl87YT0hQKpNDOZTJg6dSo2bdoUfUzXdWzatAkzZszIYsvSz+PxYO/evaipqcHUqVMhy3LM32HXrl1oaGgouL/DyJEjUV1dHXOtbrcbW7dujV7rjBkz0NHRgW3btkX3ef3116HrevTmUygOHTqE1tZW1NTUAMjva+ecY9GiRXjppZfw+uuvY+TIkTG/H8zrfMaMGfjkk09igsmNGzfC5XJhwoQJmbmQBJzo2vuyfft2AIj5t8/HaydkQNmudh8KnnvuOW42m/m6dev4559/zq+55hpeXFwcM3KlENx888188+bNfN++ffyf//wnnzNnDi8vL+ctLS2cc86vvfZafvLJJ/PXX3+dv//++3zGjBl8xowZWW51Yrq6uviHH37IP/zwQw6AP/jgg/zDDz/kBw4c4Jxz/rOf/YwXFxfzV155hX/88cf84osv5iNHjuR+vz96jvr6en766afzrVu38rfffpuPHTuWf+c738nWJQ3aQNfe1dXFb7nlFr5lyxa+b98+/ve//52fccYZfOzYsTwQCETPka/Xft111/GioiK+efNm3tjYGN18Pl90nxO9zlVV5aeddho///zz+fbt2/mGDRt4RUUFX7p0aTYuadBOdO179uzhK1eu5O+//z7ft28ff+WVV/ioUaP4OeecEz1Hvl47IQOhQCpDHnnkEX7yySdzk8nEzzzzTP7uu+9mu0kpd/nll/OamhpuMpn4SSedxC+//HK+Z8+e6O/9fj//4Q9/yEtKSrjNZuPf/OY3eWNjYxZbnLg33niDA+i1XXHFFZxzYwqEO+64g1dVVXGz2cxnz57Nd+3aFXOO1tZW/p3vfIc7HA7ucrn4VVddxbu6urJwNfEZ6Np9Ph8///zzeUVFBZdlmQ8fPpwvXLiw15eGfL32vq4bAH/yySej+wzmdb5//35+wQUXcKvVysvLy///9u4nJKp3j+P4Z36T1eSIpoJNkQiJEmFkLQZCU8rEAmk29gfT/ENBpDRgs2hRBi36R4ug3ASZRFBBoWBYLUoXIWkJlYtUhqgIaZj+qpHW9NzV79w7119dPZZ25f2CgXme5/B8n3MWhw/nnDlj6urqzNevX6d5bybnf+37y5cvzbp160xiYqKZN2+eSU9PN4FAwHz8+DFqnv/HfQd+xmGMMdN3/QsAAGD24BkpAAAAmwhSAAAANhGkAAAAbCJIAQAA2ESQAgAAsIkgBQAAYBNBCgAAwCaCFDALVFRUyOfzTXvdixcvKiEhYcrz5Ofny+/3T3keAJhuc2Z6AQB+zuFw/HS8vr5eZ86c0Uy8W3fbtm3avHnztNcFgD8FQQr4ww0ODlrfr169qsOHD6uvr8/qc7vdcrvdM7E0uVwuuVyuGakNAH8Cbu0Bf7hFixZZn/j4eDkcjqg+t9s97tZefn6+amtr5ff7tXDhQqWkpOj8+fMaGRlRZWWl4uLilJ6erra2tqhavb292rRpk9xut1JSUlRWVqZwOPzDtf33rb0jR45o1apVunTpktLS0hQfH6/t27draGjI2mZkZETl5eVyu93yeDw6ffr0uHlHR0d14MABLVmyRLGxsfJ6vWpvb5ckffnyRStWrNCePXus7YPBoOLi4nThwoVJHl0AmBqCFDBLNTU1KTk5WV1dXaqtrdXevXtVUlKitWvXqqenR4WFhSorK9Pnz58lSR8+fND69euVnZ2thw8f6tatW3rz5o22bt06qbrBYFDNzc1qbW1Va2urOjo6dPz4cWs8EAioo6NDLS0tunPnjtrb29XT0xM1R01NjTo7O3XlyhU9efJEJSUlKioq0sDAgObPn6/Lly+rqalJLS0tikQi2rlzpzZu3KiqqqqpHzgAmIwZ/tNkAJPQ2Nho4uPjx/Xv2rXLbNmyxWrn5eWZnJwcq/3t2zcTGxtrysrKrL7BwUEjyXR2dhpjjDl69KgpLCyMmvfVq1dGkunr65vQeurr682CBQvMp0+frL5AIGC8Xq8xxpihoSEzd+5cc+3aNWv87du3xuVymf379xtjjHnx4oVxOp3m9evXUbU2bNhgDh48aLVPnjxpkpOTTU1NjfF4PCYcDv/jGgHgd+IZKWCWWrlypfXd6XQqKSlJWVlZVl9KSookKRQKSZIeP36se/fu/ePzVsFgUBkZGROqm5aWpri4OKvt8XisGsFgUGNjY/J6vdZ4YmKiMjMzrfbTp08ViUTG1RsdHVVSUpLVrqurU3Nzs86ePau2traoMQCYLgQpYJaKiYmJajscjqi+v38N+P37d0nS8PCwiouLdeLEiXFzeTyeKdX9u8ZEDA8Py+l06tGjR3I6nVFj/xnyQqGQ+vv75XQ6NTAwoKKiognXAIBfhSAFQJK0evVqXb9+XWlpaZoz5/ecGpYtW6aYmBg9ePBAqampkqT379+rv79feXl5kqTs7GxFIhGFQiHl5ub+cK6qqiplZWWpurpau3fvVkFBgZYvX/5b1g0AP8LD5gAkSfv27dO7d++0Y8cOdXd3KxgM6vbt26qsrFQkEvklNdxut6qrqxUIBHT37l319vaqoqJCf/3171NRRkaGSktLVV5erhs3buj58+fq6urSsWPHdPPmTUnSuXPn1NnZqaamJpWWlsrn86m0tFRjY2O/ZJ0AMFEEKQCSpMWLF+v+/fuKRCIqLCxUVlaW/H6/EhISooLOVJ06dUq5ubkqLi5WQUGBcnJytGbNmqhtGhsbVV5errq6OmVmZsrn86m7u1upqal69uyZAoGAGhoatHTpUklSQ0ODwuGwDh069MvWCQAT4TBmBl6HDAAAMAtwRQoAAMAmghQAAIBNBCkAAACbCFIAAAA2EaQAAABsIkgBAADYRJACAACwiSAFAABgE0EKAADAJoIUAACATQQpAAAAmwhSAAAANv0Lv5k6pU9e+1sAAAAASUVORK5CYII="
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
      },
      "execution_count": 8,
      "metadata": {},
@@ -319,8 +325,8 @@
    "execution_count": 9,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:47.578872Z",
-     "end_time": "2023-05-31T09:48:47.637503Z"
+     "end_time": "2023-05-31T09:48:47.637503Z",
+     "start_time": "2023-05-31T09:48:47.578872Z"
     }
    },
    "outputs": [],
@@ -345,8 +351,8 @@
    "execution_count": 10,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:47.593279Z",
-     "end_time": "2023-05-31T09:48:47.638506Z"
+     "end_time": "2023-05-31T09:48:47.638506Z",
+     "start_time": "2023-05-31T09:48:47.593279Z"
     }
    },
    "outputs": [],
@@ -383,8 +389,8 @@
    "execution_count": 11,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:47.613369Z",
-     "end_time": "2023-05-31T09:48:49.417332Z"
+     "end_time": "2023-05-31T09:48:49.417332Z",
+     "start_time": "2023-05-31T09:48:47.613369Z"
     }
    },
    "outputs": [
@@ -397,7 +403,7 @@
     }
    ],
    "source": [
-    "exp = dianna.explain_timeseries(run_model, timeseries_data=data_instance, method='lime',\n",
+    "exp = dianna.explain_timeseries(run_model, input_timeseries=data_instance, method='lime',\n",
     "                                labels=[0], class_names=class_names, num_features=num_features,\n",
     "                                num_samples=500, num_slices=num_slices, batch_size=1, distance_method='cosine')"
    ]
@@ -407,8 +413,8 @@
    "execution_count": 12,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2023-05-31T09:48:49.419338Z",
-     "end_time": "2023-05-31T09:48:50.058148Z"
+     "end_time": "2023-05-31T09:48:50.058148Z",
+     "start_time": "2023-05-31T09:48:49.419338Z"
     }
    },
    "outputs": [
@@ -422,16 +428,20 @@
     },
     {
      "data": {
-      "text/plain": "<Figure size 640x480 with 2 Axes>",
-      "image/png": "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"
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
     },
     {
      "data": {
-      "text/plain": "<Figure size 640x480 with 2 Axes>",
-      "image/png": "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"
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
      },
      "execution_count": 12,
      "metadata": {},
@@ -480,7 +490,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.10.13"
   },
   "orig_nbformat": 4
  },
diff --git a/tutorials/lime_timeseries_weather.ipynb b/tutorials/lime_timeseries_weather.ipynb
index 88dfe1b6..ab2bbd3c 100644
--- a/tutorials/lime_timeseries_weather.ipynb
+++ b/tutorials/lime_timeseries_weather.ipynb
@@ -171,7 +171,7 @@
     }
    ],
    "source": [
-    "exp = dianna.explain_timeseries(run_expert_model, timeseries_data=data_extreme,\n",
+    "exp = dianna.explain_timeseries(run_expert_model, input_timeseries=data_extreme,\n",
     "                                method='lime', labels=[0,1], class_names=[\"summer\", \"winter\"],\n",
     "                                num_features=len(data_extreme), num_samples=10000,\n",
     "                                num_slices=len(data_extreme), distance_method='euclidean',\n",
@@ -893,7 +893,7 @@
     }
    ],
    "source": [
-    "exp = dianna.explain_timeseries(run_model, timeseries_data=data_instance[0], method='lime',\n",
+    "exp = dianna.explain_timeseries(run_model, input_timeseries=data_instance[0], method='lime',\n",
     "                                labels=[0,1], class_names=classes, num_features=num_features,\n",
     "                                num_samples=2000, num_slices=num_slices, distance_method='dtw')"
    ]
diff --git a/tutorials/models/penguin_model.onnx b/tutorials/models/penguin_model.onnx
new file mode 100644
index 00000000..5d5cc4c9
Binary files /dev/null and b/tutorials/models/penguin_model.onnx differ
diff --git a/tutorials/models/sunshine_hours_regression_model.onnx b/tutorials/models/sunshine_hours_regression_model.onnx
new file mode 100644
index 00000000..bd7f4182
Binary files /dev/null and b/tutorials/models/sunshine_hours_regression_model.onnx differ
diff --git a/tutorials/rise_timeseries_weather.ipynb b/tutorials/rise_timeseries_weather.ipynb
index 77a25782..1d6a3fd3 100644
--- a/tutorials/rise_timeseries_weather.ipynb
+++ b/tutorials/rise_timeseries_weather.ipynb
@@ -261,7 +261,7 @@
    ],
    "source": [
     "# call the explainer\n",
-    "explanation = dianna.explain_timeseries(run_expert_model, timeseries_data=data_extreme,\n",
+    "explanation = dianna.explain_timeseries(run_expert_model, input_timeseries=data_extreme,\n",
     "                                        method='rise', labels=[0,1], p_keep=0.1,\n",
     "                                        n_masks=10000, mask_type=input_train_mean)"
    ]
@@ -1087,7 +1087,7 @@
    ],
    "source": [
     "# call the explainer\n",
-    "explanation = dianna.explain_timeseries(run_model, timeseries_data=data_instance[0],\n",
+    "explanation = dianna.explain_timeseries(run_model, input_timeseries=data_instance[0],\n",
     "                                        method='rise', labels=[0,1], p_keep=0.1,\n",
     "                                        n_masks=10000)"
    ]