From fdec9aa4430ca15a5b1ae33a649a1d026a00d81a Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Wed, 23 Oct 2024 17:03:45 +0200
Subject: [PATCH 01/11] integrates the SI graph plot and streamlines the plots

---
 shapiq/interaction_values.py           | 38 ++++++++++++++++++--------
 shapiq/plot/__init__.py                |  4 +++
 shapiq/plot/force.py                   | 37 +++++++++----------------
 shapiq/plot/network.py                 | 11 ++++++--
 shapiq/plot/si_graph.py                | 38 +++++++++++++++++++-------
 shapiq/plot/stacked_bar.py             |  6 +++-
 shapiq/plot/utils.py                   | 17 +++++++++++-
 tests/tests_plots/test_bar.py          |  5 ++++
 tests/tests_plots/test_force.py        |  5 ++++
 tests/tests_plots/test_network_plot.py |  5 ++++
 tests/tests_plots/test_si_graph.py     | 25 +++++++++--------
 tests/tests_plots/test_stacked_bar.py  |  9 ++++++
 tests/tests_plots/test_waterfall.py    |  5 ++++
 13 files changed, 142 insertions(+), 63 deletions(-)

diff --git a/shapiq/interaction_values.py b/shapiq/interaction_values.py
index 33de3498..6ea1b45c 100644
--- a/shapiq/interaction_values.py
+++ b/shapiq/interaction_values.py
@@ -579,20 +579,21 @@ def to_dict(self) -> dict:
             "baseline_value": self.baseline_value,
         }
 
-    def plot_network(self, **kwargs) -> tuple[plt.Figure, plt.Axes]:
+    def plot_network(self, show: bool = True, **kwargs) -> Optional[tuple[plt.Figure, plt.Axes]]:
         """Visualize InteractionValues on a graph.
 
         For arguments, see shapiq.plots.network_plot().
 
         Returns:
-            matplotlib.pyplot.Figure, matplotlib.pyplot.Axes
+
         """
-        from shapiq import network_plot
+        from shapiq.plot.network import network_plot
 
         if self.max_order > 1:
             return network_plot(
                 first_order_values=self.get_n_order_values(1),
                 second_order_values=self.get_n_order_values(2),
+                show=show,
                 **kwargs,
             )
         else:
@@ -601,22 +602,32 @@ def plot_network(self, **kwargs) -> tuple[plt.Figure, plt.Axes]:
                 "but requires also 2-order values for the network plot."
             )
 
-    def plot_stacked_bar(self, **kwargs) -> tuple[plt.Figure, plt.Axes]:
+    def plot_si_graph(self, show: bool = True, **kwargs) -> Optional[tuple[plt.Figure, plt.Axes]]:
+        """Visualize InteractionValues as a SI graph.
+
+        For arguments, see shapiq.plots.si_graph_plot().
+
+        Returns:
+            The SI graph as a tuple containing the figure and the axes.
+        """
+
+        from shapiq.plot.si_graph import si_graph_plot
+
+        return si_graph_plot(self, show=show, **kwargs)
+
+    def plot_stacked_bar(
+        self, show: bool = True, **kwargs
+    ) -> Optional[tuple[plt.Figure, plt.Axes]]:
         """Visualize InteractionValues on a graph.
 
         For arguments, see shapiq.plots.stacked_bar_plot().
 
         Returns:
-            matplotlib.pyplot.Figure, matplotlib.pyplot.Axes
+            The stacked bar plot as a tuple containing the figure and the axes.
         """
         from shapiq import stacked_bar_plot
 
-        ret = stacked_bar_plot(
-            self,
-            **kwargs,
-        )
-
-        return ret
+        return stacked_bar_plot(self, show=show, **kwargs)
 
     def plot_force(
         self,
@@ -639,6 +650,9 @@ def plot_force(
             matplotlib: Whether to return a ``matplotlib`` figure. Defaults to ``True``.
             show: Whether to show the plot. Defaults to ``False``.
             **kwargs: Keyword arguments passed to ``shap.plots.force()``.
+
+        Returns:
+            The force plot as a matplotlib figure (if show is ``False``).
         """
         from shapiq import force_plot
 
@@ -655,7 +669,7 @@ def plot_waterfall(
         self,
         feature_names: Optional[np.ndarray] = None,
         feature_values: Optional[np.ndarray] = None,
-        show: bool = False,
+        show: bool = True,
         max_display: int = 10,
     ) -> Optional[plt.Axes]:
         """Draws interaction values on a waterfall plot.
diff --git a/shapiq/plot/__init__.py b/shapiq/plot/__init__.py
index 6f10b964..404a8c7f 100644
--- a/shapiq/plot/__init__.py
+++ b/shapiq/plot/__init__.py
@@ -5,6 +5,7 @@
 from .network import network_plot
 from .si_graph import si_graph_plot
 from .stacked_bar import stacked_bar_plot
+from .utils import abbreviate_feature_names, get_interaction_values_and_feature_names
 from .watefall import waterfall_plot
 
 __all__ = [
@@ -14,4 +15,7 @@
     "force_plot",
     "bar_plot",
     "waterfall_plot",
+    # utils
+    "abbreviate_feature_names",
+    "get_interaction_values_and_feature_names",
 ]
diff --git a/shapiq/plot/force.py b/shapiq/plot/force.py
index afc4e7ef..38f48cf7 100644
--- a/shapiq/plot/force.py
+++ b/shapiq/plot/force.py
@@ -18,7 +18,7 @@ def force_plot(
     feature_names: Optional[np.ndarray] = None,
     feature_values: Optional[np.ndarray] = None,
     matplotlib: bool = True,
-    show: bool = True,
+    show: bool = False,
     **kwargs,
 ) -> Optional[plt.Figure]:
     """Draws interaction values on a force plot.
@@ -37,26 +37,15 @@ def force_plot(
     check_import_module("shap")
     import shap
 
-    if interaction_values.max_order == 1:
-        return shap.plots.force(
-            base_value=np.array([interaction_values.baseline_value], dtype=float),  # must be array
-            shap_values=interaction_values.get_n_order_values(1),
-            features=feature_values,
-            feature_names=feature_names,
-            matplotlib=matplotlib,
-            show=show,
-            **kwargs,
-        )
-    else:
-        _shap_values, _labels = get_interaction_values_and_feature_names(
-            interaction_values, feature_names, feature_values
-        )
-
-        return shap.plots.force(
-            base_value=np.array([interaction_values.baseline_value], dtype=float),  # must be array
-            shap_values=np.array(_shap_values),
-            feature_names=_labels,
-            matplotlib=matplotlib,
-            show=show,
-            **kwargs,
-        )
+    _shap_values, _labels = get_interaction_values_and_feature_names(
+        interaction_values, feature_names, feature_values
+    )
+
+    return shap.plots.force(
+        base_value=np.array([interaction_values.baseline_value], dtype=float),  # must be array
+        shap_values=np.array(_shap_values),
+        feature_names=_labels,
+        matplotlib=matplotlib,
+        show=show,
+        **kwargs,
+    )
diff --git a/shapiq/plot/network.py b/shapiq/plot/network.py
index 7f814c2c..c0e2c246 100644
--- a/shapiq/plot/network.py
+++ b/shapiq/plot/network.py
@@ -29,7 +29,8 @@ def network_plot(
     center_image_size: Optional[float] = 0.6,
     draw_legend: bool = True,
     center_text: Optional[str] = None,
-) -> tuple[plt.Figure, plt.Axes]:
+    show: bool = False,
+) -> Optional[tuple[plt.Figure, plt.Axes]]:
     """Draws the interaction network.
 
     An interaction network is a graph where the nodes represent the features and the edges represent
@@ -59,9 +60,11 @@ def network_plot(
         center_image_size: The size of the center image. Defaults to ``0.6``.
         draw_legend: Whether to draw the legend. Defaults to ``True``.
         center_text: The text to be displayed in the center of the network. Defaults to ``None``.
+        show: Whether to show the plot. Defaults to ``False``. If ``False``, the figure and the axis
+            containing the plot are returned, otherwise ``None``.
 
     Returns:
-        The figure and the axis containing the plot.
+        The figure and the axis containing the plot if ``show=False``.
     """
     fig, axis = plt.subplots(figsize=(6, 6))
     axis.axis("off")
@@ -175,7 +178,9 @@ def network_plot(
     if draw_legend:
         _add_legend_to_axis(axis)
 
-    return fig, axis
+    if not show:
+        return fig, axis
+    plt.show()
 
 
 def _add_weight_to_edges_in_graph(
diff --git a/shapiq/plot/si_graph.py b/shapiq/plot/si_graph.py
index daaec3d7..2f2c4489 100644
--- a/shapiq/plot/si_graph.py
+++ b/shapiq/plot/si_graph.py
@@ -18,6 +18,9 @@
 ADJUST_NODE_ALPHA = True
 
 
+__all__ = ["si_graph_plot"]
+
+
 def _normalize_value(
     value: float, max_value: float, base_value: float, cubic_scaling: bool = False
 ) -> float:
@@ -310,14 +313,14 @@ def _adjust_position(
 
 def si_graph_plot(
     interaction_values: InteractionValues,
-    graph: Union[list[tuple], nx.Graph],
+    graph: Optional[Union[list[tuple], nx.Graph]] = None,
     n_interactions: Optional[int] = None,
     draw_threshold: float = 0.0,
     random_seed: int = 42,
     size_factor: float = 1.0,
     plot_explanation: bool = True,
-    compactness: float = 1.0,
-    label_mapping: Optional[dict] = None,
+    compactness: float = 1e10,
+    feature_names: Optional[list] = None,
     cubic_scaling: bool = False,
     pos: Optional[dict] = None,
     node_size_scaling: float = 1.0,
@@ -326,7 +329,8 @@ def si_graph_plot(
     spring_k: Optional[float] = None,
     interaction_direction: Optional[str] = None,
     node_area_scaling: bool = False,
-) -> tuple[plt.figure, plt.axis]:
+    show: bool = False,
+) -> Optional[tuple[plt.figure, plt.axis]]:
     """Plots the interaction values as an explanation graph.
 
     An explanation graph is an undirected graph where the nodes represent players and the edges
@@ -338,7 +342,8 @@ def si_graph_plot(
         interaction_values: The interaction values to plot.
         graph: The underlying graph structure as a list of edge tuples or a networkx graph. If a
             networkx graph is provided, the nodes are used as the players and the edges are used as
-            the connections between the players.
+            the connections between the players. Defaults to ``None``, which creates a graph with
+            all nodes from the interaction values without any edges between them.
         n_interactions: The number of interactions to plot. If ``None``, all interactions are plotted
             according to the draw_threshold.
         draw_threshold: The threshold to draw an edge (i.e. only draw explanations with an
@@ -351,8 +356,8 @@ def si_graph_plot(
         compactness: A scaling factor for the underlying spring layout. A higher compactness value
             will move the interactions closer to the graph nodes. If your graph looks weird, try
             adjusting this value, e.g. ``[0.1, 1.0, 10.0, 100.0, 1000.0]``. Defaults to ``1.0``.
-        label_mapping: A mapping from the player/node indices to the player label. If ``None``, the
-            player indices are used as labels. Defaults to ``None``.
+        feature_names: A list of feature names to use for the nodes in the graph. If ``None``,
+            the feature indices are used instead. Defaults to ``None``.
         cubic_scaling: Whether to scale the size of explanations cubically (``True``) or linearly
             (``False``, default). Cubic scaling puts more emphasis on larger interactions in the plot.
             Defaults to ``False``.
@@ -372,14 +377,19 @@ def si_graph_plot(
             interactions are plotted. Possible values are ``"positive"`` and
             ``"negative"``. Defaults to ``None``.
         node_area_scaling: TODO add docstring.
+        show: Whether to show or return the plot. Defaults to ``False``.
 
     Returns:
-        The figure and axis of the plot.
+        The figure and axis of the plot if ``show`` is ``True``. Otherwise, ``None``.
     """
 
     normal_node_size = NORMAL_NODE_SIZE * node_size_scaling
     base_size = BASE_SIZE * node_size_scaling
 
+    label_mapping = None
+    if feature_names is not None:
+        label_mapping = {i: feature_names[i] for i in range(len(feature_names))}
+
     # fill the original graph with the edges and nodes
     if isinstance(graph, nx.Graph):
         original_graph = graph
@@ -389,7 +399,7 @@ def si_graph_plot(
             for node in graph_nodes:
                 node_label = label_mapping.get(node, node) if label_mapping is not None else node
                 original_graph.nodes[node]["label"] = node_label
-    else:
+    elif isinstance(graph, list):
         original_graph, graph_nodes = nx.Graph(), []
         for edge in graph:
             original_graph.add_edge(*edge)
@@ -399,6 +409,12 @@ def si_graph_plot(
             original_graph.add_node(edge[0], label=nodel_labels[0])
             original_graph.add_node(edge[1], label=nodel_labels[1])
             graph_nodes.extend([edge[0], edge[1]])
+    else:  # graph is considered None
+        original_graph = nx.Graph()
+        graph_nodes = list(range(interaction_values.n_players))
+        for node in graph_nodes:
+            node_label = label_mapping.get(node, node) if label_mapping is not None else node
+            original_graph.add_node(node, label=node_label)
 
     if n_interactions is not None:
         # get the top n interactions
@@ -500,4 +516,6 @@ def si_graph_plot(
     ax.set_aspect("equal", adjustable="datalim")  # make y- and x-axis scales equal
     ax.axis("off")  # remove axis
 
-    return fig, ax
+    if not show:
+        return fig, ax
+    plt.show()
diff --git a/shapiq/plot/stacked_bar.py b/shapiq/plot/stacked_bar.py
index 374c60f5..a782030d 100644
--- a/shapiq/plot/stacked_bar.py
+++ b/shapiq/plot/stacked_bar.py
@@ -21,6 +21,7 @@ def stacked_bar_plot(
     title: Optional[str] = None,
     xlabel: Optional[str] = None,
     ylabel: Optional[str] = None,
+    show: bool = False,
 ):
     """Plot the n-SII values for a given instance.
 
@@ -43,6 +44,7 @@ def stacked_bar_plot(
         title (str): The title of the plot.
         xlabel (str): The label of the x-axis.
         ylabel (str): The label of the y-axis.
+        show (bool): Whether to show the plot. Defaults to ``False``.
 
     Returns:
         tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]: A tuple containing the figure and
@@ -147,4 +149,6 @@ def stacked_bar_plot(
 
     plt.tight_layout()
 
-    return fig, axis
+    if not show:
+        return fig, axis
+    plt.show()
diff --git a/shapiq/plot/utils.py b/shapiq/plot/utils.py
index aee0f0cd..4e750ae2 100644
--- a/shapiq/plot/utils.py
+++ b/shapiq/plot/utils.py
@@ -7,7 +7,7 @@
 from shapiq.interaction_values import InteractionValues
 from shapiq.utils import powerset
 
-__all__ = ["get_interaction_values_and_feature_names"]
+__all__ = ["get_interaction_values_and_feature_names", "abbreviate_feature_names"]
 
 
 def get_interaction_values_and_feature_names(
@@ -49,3 +49,18 @@ def get_interaction_values_and_feature_names(
     _shap_values = np.array(_shap_values)
     _labels = np.array(_labels)
     return _shap_values, _labels
+
+
+def abbreviate_feature_names(feature_names: list[str]) -> list[str]:
+    """A rudimentary function to abbreviate feature names for plotting.
+
+    Args:
+        feature_names: The feature names to be abbreviated.
+
+    Returns:
+        list[str]: The abbreviated feature names.
+    """
+    abbreviated_names = []
+    for name in feature_names:
+        abbreviated_names.append(name.strip()[0:3] + ".")
+    return abbreviated_names
diff --git a/tests/tests_plots/test_bar.py b/tests/tests_plots/test_bar.py
index 589e0566..4e980045 100644
--- a/tests/tests_plots/test_bar.py
+++ b/tests/tests_plots/test_bar.py
@@ -22,3 +22,8 @@ def test_bar_plot(interaction_values_list: list[InteractionValues]):
     axis = bar_plot(interaction_values_list, show=True)
     assert axis is None
     plt.close()
+
+    # test show=True
+    output = bar_plot(interaction_values_list, show=True)
+    assert output is None
+    plt.close("all")
diff --git a/tests/tests_plots/test_force.py b/tests/tests_plots/test_force.py
index b105077c..c5b8dd44 100644
--- a/tests/tests_plots/test_force.py
+++ b/tests/tests_plots/test_force.py
@@ -36,3 +36,8 @@ def test_force_plot(interaction_values_list: list[InteractionValues]):
     fp = iv.plot_force(show=False)
     assert isinstance(fp, plt.Figure)
     plt.close()
+
+    # test show=True
+    output = iv.plot_force(show=True)
+    assert output is None
+    plt.close("all")
diff --git a/tests/tests_plots/test_network_plot.py b/tests/tests_plots/test_network_plot.py
index f5eff0b3..7e3e1037 100644
--- a/tests/tests_plots/test_network_plot.py
+++ b/tests/tests_plots/test_network_plot.py
@@ -53,6 +53,11 @@ def test_network_plot():
     with pytest.raises(ValueError):
         network_plot()
 
+    # test show=True
+    output = network_plot(interaction_values=iv, show=True)
+    assert output is None
+    plt.close("all")
+
     assert True
 
 
diff --git a/tests/tests_plots/test_si_graph.py b/tests/tests_plots/test_si_graph.py
index 181f742e..6b9baa1e 100644
--- a/tests/tests_plots/test_si_graph.py
+++ b/tests/tests_plots/test_si_graph.py
@@ -67,6 +67,17 @@ def test_si_graph_plot(
     )
     graph_tuple = [(1, 2), (2, 3), (3, 4), (2, 4), (1, 4)]
 
+    # test without graph and from interaction values
+    fig, ax = example_values.plot_si_graph(show=False)
+    assert isinstance(fig, plt.Figure)
+    assert isinstance(ax, plt.Axes)
+    plt.close(fig)
+
+    # test with show=True
+    output = example_values.plot_si_graph(show=True)
+    assert output is None
+    plt.close("all")
+
     fig, ax = si_graph_plot(
         example_values,
         graph_tuple,
@@ -106,12 +117,7 @@ def test_si_graph_plot(
         plot_explanation=True,
         n_interactions=n_interactions,
         compactness=compactness,
-        label_mapping={
-            0: "A",
-            1: "B",
-            2: "C",
-            3: "D",
-        },
+        feature_names=["A", "B", "C", "D"],
     )
 
     assert isinstance(fig, plt.Figure)
@@ -149,12 +155,7 @@ def test_si_graph_plot(
         adjust_node_pos=True,
         interaction_direction="negative",
         min_max_interactions=(-0.5, 0.5),
-        label_mapping={
-            0: "A",
-            1: "B",
-            2: "C",
-            3: "D",
-        },
+        feature_names=["A", "B", "C", "D"],
     )
 
     assert isinstance(fig, plt.Figure)
diff --git a/tests/tests_plots/test_stacked_bar.py b/tests/tests_plots/test_stacked_bar.py
index bfef22c6..77af99af 100644
--- a/tests/tests_plots/test_stacked_bar.py
+++ b/tests/tests_plots/test_stacked_bar.py
@@ -50,3 +50,12 @@ def test_stacked_bar_plot():
     assert isinstance(fig, plt.Figure)
     assert isinstance(axes, plt.Axes)
     plt.close()
+
+    # test show=True
+    output = stacked_bar_plot(
+        interaction_values=interaction_values,
+        feature_names=feature_names,
+        show=True,
+    )
+    assert output is None
+    plt.close("all")
diff --git a/tests/tests_plots/test_waterfall.py b/tests/tests_plots/test_waterfall.py
index 2213c4ca..bedc047e 100644
--- a/tests/tests_plots/test_waterfall.py
+++ b/tests/tests_plots/test_waterfall.py
@@ -36,3 +36,8 @@ def test_waterfall_plot(interaction_values_list: list[InteractionValues]):
     wp = iv.plot_waterfall(show=False)
     assert isinstance(wp, plt.Axes)
     plt.close()
+
+    # test show=True
+    output = iv.plot_waterfall(show=True)
+    assert output is None
+    plt.close("all")

From 461daaafd3b3695d10501da0658cb6ab222f21f1 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Wed, 23 Oct 2024 17:04:11 +0200
Subject: [PATCH 02/11] adds first draft of visualization notebook

---
 .../visualizing_shapley_interactions.ipynb    | 551 ++++++++++++++++++
 1 file changed, 551 insertions(+)
 create mode 100644 docs/source/notebooks/visualizing_shapley_interactions.ipynb

diff --git a/docs/source/notebooks/visualizing_shapley_interactions.ipynb b/docs/source/notebooks/visualizing_shapley_interactions.ipynb
new file mode 100644
index 00000000..fe3f1a9d
--- /dev/null
+++ b/docs/source/notebooks/visualizing_shapley_interactions.ipynb
@@ -0,0 +1,551 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Visualizing Shapley Interactions\n",
+    "\n",
+    "This notebook shows how to visualize Shapley interactions in different ways using the `shapiq` package.\n",
+    "This notebook we will compute Shapley interactions of different orders with the `TreeExplainer` for a `RandomForestRegressor` trained on the `california_housing` dataset.\n",
+    "We will then visualize the Shapley interactions with different visualization techniques from the `shapiq` package."
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Import Modules\n",
+    "First, import all necessary modules."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:33.397609Z",
+     "start_time": "2024-10-23T14:47:32.122515Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from tqdm.asyncio import tqdm\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "from sklearn.ensemble import RandomForestRegressor\n",
+    "\n",
+    "import shapiq\n",
+    "\n",
+    "shapiq.__version__"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'1.0.1.9001'"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 1
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Load Data and Train Model\n",
+    "First, we load the `california_housing` dataset and train an `XGBoost` model on it."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:34.410817Z",
+     "start_time": "2024-10-23T14:47:33.398610Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# get the data\n",
+    "x_data, y_data = shapiq.datasets.load_california_housing(to_numpy=False)\n",
+    "feature_names = list(x_data.columns)  # get the feature names\n",
+    "n_features = len(feature_names)\n",
+    "x_data, y_data = x_data.values, y_data.values  # transform to numpy arrays\n",
+    "print(\"Features in the dataset:\", feature_names)\n",
+    "\n",
+    "x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# train an XGBoost model\n",
+    "model = RandomForestRegressor(random_state=42, max_depth=10, n_estimators=15)\n",
+    "model.fit(x_train, y_train)\n",
+    "\n",
+    "# evaluate the model\n",
+    "mse = mean_squared_error(y_test, model.predict(x_test))\n",
+    "r2 = r2_score(y_test, model.predict(x_test))\n",
+    "print(f\"Mean Squared Error: {mse}\")\n",
+    "print(f\"R2 Score: {r2}\")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Features in the dataset: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']\n",
+      "Mean Squared Error: 0.3007068550571449\n",
+      "R2 Score: 0.7705244240154585\n"
+     ]
+    }
+   ],
+   "execution_count": 2
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "With these hyperparameters the model achieves a reasonable $R^2$ score of about 78%."
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Compute Shapley Interactions\n",
+    "Now, let's compute Shapley interactions of different order. \n",
+    "To do so, we will rely on the `TreeExplainer`. \n",
+    "Note that any other explainer (also the `ExactComputer`) that supports Shapley interactions can be used as well."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:34.426812Z",
+     "start_time": "2024-10-23T14:47:34.412807Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# select a local instance to be explained\n",
+    "instance_id = 7\n",
+    "x_explain = x_test[instance_id]\n",
+    "y_true = y_test[instance_id]\n",
+    "y_pred = model.predict(x_explain.reshape(1, -1))[0]\n",
+    "print(f\"Instance {instance_id}, True Value: {y_true}, Predicted Value: {y_pred}\")\n",
+    "for i, feature in enumerate(feature_names):\n",
+    "    print(f\"{feature}: {x_explain[i]}\")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Instance 7, True Value: 1.575, Predicted Value: 1.692269408153201\n",
+      "MedInc: 3.6908\n",
+      "HouseAge: 38.0\n",
+      "AveRooms: 4.962825278810409\n",
+      "AveBedrms: 1.0483271375464684\n",
+      "Population: 1011.0\n",
+      "AveOccup: 3.758364312267658\n",
+      "Latitude: 33.92\n",
+      "Longitude: -118.08\n"
+     ]
+    }
+   ],
+   "execution_count": 3
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Now, let's compute $k$-SII scores of **different orders**.\n",
+    "Here, we will start with Shapley interactions of order 1 (which corresponds to the Shapley values) and increase the order up to the number of features (for $k$-SII, this corresponds to the Moebius transform)."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:56.223853Z",
+     "start_time": "2024-10-23T14:47:34.428806Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# create explanations for different orders\n",
+    "si_order: dict[int, shapiq.InteractionValues] = {}\n",
+    "for order in tqdm([1, 2, n_features]):\n",
+    "    index = \"k-SII\" if order > 1 else \"SV\"  # will also be set automatically by the explainer\n",
+    "    explainer = shapiq.TreeExplainer(model=model, max_order=order, index=index)\n",
+    "    si_order[order] = explainer.explain(x=x_explain)\n",
+    "si_order"
+   ],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 3/3 [00:21<00:00,  7.26s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{1: InteractionValues(\n",
+       "     index=SV, max_order=1, min_order=0, estimated=False, estimation_budget=None,\n",
+       "     n_players=8, baseline_value=2.0718777703488365\n",
+       " ),\n",
+       " 2: InteractionValues(\n",
+       "     index=k-SII, max_order=2, min_order=0, estimated=False, estimation_budget=None,\n",
+       "     n_players=8, baseline_value=2.0718777703488365\n",
+       " ),\n",
+       " 8: InteractionValues(\n",
+       "     index=k-SII, max_order=8, min_order=0, estimated=False, estimation_budget=None,\n",
+       "     n_players=8, baseline_value=2.0718777703488365\n",
+       " )}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Visualize the Shapley Interactions\n",
+    "Now that we have some explanations to visualize, let's use different visualization techniques from the `shapiq` package."
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Force Plot\n",
+    "First, we consider the classical force plot popularized by [`shap`](https://github.com/shap/shap/tree/master).\n",
+    "Similar to how Shapley values are drawn on the force plot, Shapley interactions can be visualized as well.\n",
+    "Positive interactions are shown in red, negative interactions in blue. \n",
+    "All interactions **force** the prediction of the model *away* from the base value and *toward* the predicted value by the model considering all features.\n",
+    "The following cell plots the force plot for the SV, 2-SII, and Moebius transform."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:58.542089Z",
+     "start_time": "2024-10-23T14:47:56.226785Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "sv = si_order[1]  # get the SV\n",
+    "si = si_order[2]  # get the 2-SII\n",
+    "mi = si_order[n_features]  # get the Moebius transform\n",
+    "\n",
+    "sv.plot_force(feature_names=feature_names, feature_values=x_explain, show=True)\n",
+    "si.plot_force(feature_names=feature_names, feature_values=x_explain, show=True)\n",
+    "mi.plot_force(feature_names=feature_names, feature_values=x_explain, show=True)"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 2000x300 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 2000x300 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 2000x300 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 5
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Notice how for an increasing order, more interaction terms are being displayed.\n",
+    "This is to be expected as with an increasing order more interactions are part of each explanation. Formally, the number of interactions scales with $\\mathcal{O}\\left(\\binom{n}{k}\\right)$, where $n$ is the number of features and $k$ is the order of the Shapley interactions.\n",
+    "\n",
+    "Plotting this with force plots can become quite messy quite quickly. This problem is exacerbated when the number of features is large In this example, only 8 features are being considered which typically is not a lot.\n",
+    "To solve this other plots can be helpful.\n",
+    "For example the waterfall plot."
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Waterfall Plot\n",
+    "Like the force plot, the waterfall plot is also a popular visualization technique for Shapley values.\n",
+    "It, too, was established with `shap`.\n",
+    "Similarly to the force plot, the waterfall plot breaks down the explanation into interactions influencing the prediction positively or negatively.\n",
+    "The benefit for the waterfall plot is the automatic grouping of low-magnitude interactions (interactions with low value) into an *other* group."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:59.559132Z",
+     "start_time": "2024-10-23T14:47:58.543082Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "sv.plot_waterfall(feature_names=feature_names, feature_values=x_explain, show=True)\n",
+    "si.plot_waterfall(feature_names=feature_names, feature_values=x_explain, show=True)\n",
+    "mi.plot_waterfall(feature_names=feature_names, feature_values=x_explain, show=True)"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x550 with 3 Axes>"
+      ],
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAILCAYAAAA5aweuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC4v0lEQVR4nOzdd1xTV/8H8M/NYO8hGwEBQUER92gdddXZWrVaO+yyttqn7dM+1l9b+3Tv9VRta5e1te5Rq3Vrsc46ERFkCQIie8+Q5P7+SInGBAgKJuDn/Xrxkpyce+83QfF+c875HkEURRFERERERESkQ2LqAIiIiIiIiMwRkyUiIiIiIiIDmCwREREREREZwGSJiIiIiIjIACZLREREREREBjBZIiIiIiIiMoDJEhERERERkQFMloiIiIiIiAxgskRERERERGQAkyUiIiIiIiIDmCwREREREREZwGSJiNqcWq3GO++8gy5dukAul6NLly746KOPEBYWBrVa3eLzffPNN/D390ddXV0bREtERESkIYiiKJo6CCLq2JYsWYJ//etfePHFF9GjRw84Ojri0UcfxSeffIJHH320xeerra1FQEAAXnnlFfzrX/9qg4j11dfX4+zZs8jPz0dBQQHq6uowdOhQdO3atUXnKSwsxMmTJ5GXlwelUgkHBweEh4cjIiJC26egoAAnTpxAXl4eAKBTp07o378/3NzcdM6Vn5+P5ORkXLlyBRUVFbC0tISHhwf69OkDJyenm37NREREtzuOLBFRm1u+fDlGjRqFjz/+GA899BAuXrwIpVKJmTNn3tD5rKys8Mgjj+Czzz7Drfq8p7a2FqdPn0ZpaSlcXFxu6BzZ2dn47bffUFtbi169emHQoEHw9/dHZWWltk9hYSF+//13VFRUoHfv3oiOjkZ5eTm2bt2K0tJSnfOdPXsW6enp8Pb2xqBBgxAeHo4rV65g06ZNKC4uvpmXS0RERODIEhG1sdraWtjZ2eHNN9/Eq6++CgDo2bMnevTogV9++eWGz3vq1Cn06dMH+/btw4gRI1or3EapVCrU1dXBxsYGBQUF2Lx5c4tGlhQKBdauXQsPDw+MGjUKgiAY7Ldjxw7k5+fj/vvvh5WVFQCguroaa9euhY+PD0aPHq3tm5ubC3d3d0ilUm1bWVkZNmzYgMDAwFvyvhAREXVkHFkiojbz+OOPw9raGiqVCq+99hoEQYCXlxfi4uIwcuRIvf6XL1+GlZUVHnvsMZ32vXv3Qi6X44UXXtC29e7dGy4uLtiyZUubvw4AkEqlsLGxueHjU1NTUVNTg759+0IQBNTX1xscFcvNzYWPj482UQIAGxsbeHl5ITMzE/X19dp2T09PnUQJABwdHeHs7Kw3CkVEREQtJzN1AETUcc2aNQtyuRzLli3D//73P7i4uCAtLQ1vvPEGoqOj9fr7+PjgiSeewLfffov//ve/6Ny5My5cuIBp06bh7rvvxqeffqrTPzo6GocPH242DrVaDYVCYVTMlpaWjY763IzLly9DLpejqqoKu3fvRllZGWQyGUJCQjBw4EDIZJpfxyqVSi8BAgCZTAa1Wo3i4mJ4eHg0eh1RFFFTUwNnZ+dWfw1ERES3GyZLRNRmRowYgX379sHW1hbz58+HRCLBokWLAACBgYEGj/m///s/fP/99/jwww/x9ttvY8KECQgICMDq1ashkegOhgcFBRk1lS83Nxfbtm0zKuaZM2fC3t7eqL4tUVZWBlEUsXv3bnTt2hX9+vVDTk4Ozp8/D4VCgbvuugsA4OTkhPz8fKjVau3rValUyM/PBwBUVVU1eZ3U1FRUVVWhd+/erf4aiIiIbjdMloioTcXFxaF79+7aG/+ioiLIZDLY2dkZ7O/j44Mnn3wS3333HU6fPo2amhocOHAAtra2en2dnZ1RU1OD6urqJqfIubq6Yty4cUbFa21tbVS/lqqvr4dSqUR4eDgGDx4MQJMwqtVqJCYmok+fPnB0dES3bt1w6NAh/PXXX+jZsydEUcTp06dRXV0NQJM4Naa0tBSHDh2Ch4cHQkND2+R1EBER3U6YLBFRmzp79izGjBnTomNeeuklLFmyBHFxcTh48CB8fHwM9mtY89PctDlLS0v4+vq2KIbW1jDNLjg4WKc9ODgYiYmJyMvL0yZLlZWViIuLQ3JyMgDA3d0dPXv2xJkzZyCXyw2ev7q6Gjt27ICFhQVGjhypNwpHRERELcdkiYjaTGlpKbKyshAZGaltc3V1hVKpREVFRaPT3d59910AgFKpbLJMd0lJCWxsbJodDWqoZGcMKyurNkk0bGxsUFJSohdrw+Nr4+vXrx969uyJkpISWFhYwMXFBcePHwegKeBwPYVCgR07dkChUGDSpEkGR+GIiIio5ZgsEVGbiYuLAwD06NFD2xYWFgYASE9P12lv8PHHH+P777/HkiVL8J///Afvvvsuvv/+e4PnT09PR3h4eLNx5OXlmXzNkru7Oy5fvoyqqiqdDWMb1iBdn0RZWlrC09NT+/jy5cuwtbXV22xWqVRi586dKCsrw/jx41nYgYiIqBUxWSKiNnP27FkAusnSwIEDAQAnT57US5Z+++03LFy4EG+//TbmzZuHlJQUfPXVV3j11VcNFoQ4ffo0Zs2a1Wwct3LNklKpRGVlJaysrHTKfwcFBSE2NhZJSUk60wovXLigLanemLS0NBQUFGDAgAE6Uw7VajX27duHvLw8jBkzpskqeURERNRyTJaIqM3ExcXBx8dHZypdUFAQIiIisHfvXp39lE6dOoVZs2Zh1qxZ2s1rFyxYgG+++cbg6NKpU6dQXFyMyZMnNxtHa61Zio+Ph0Kh0BZbuHTpknZkKCIiAhYWFsjPz8e2bdsQHR2NPn36aI91c3ND165dkZSUBLVaDS8vL1y5cgUXL15EVFSUdurclStXcPr0ae1eS/n5+UhKSoKfnx8iIiJ04jl27BguXboEf39/1NXVISUlRef5kJCQm37NREREtzMmS0TUZuLi4gxOtXvsscfw+uuvo6amBtbW1sjOzsbEiRPRq1cvfPfdd9p+3t7eeOyxx/D999/rjS6tX78e/v7+GDFixC15LYDm9VRWVmofZ2RkICMjA4AmMbGwsGjy+DvuuAN2dnZISkpCRkYG7OzsMHDgQJ01Xba2thAEAXFxcaivr4e9vT369u2LyMhIvbVURUVFAIDMzExkZmbqXY/JEhER0c0RRENbyBMRtaGysjIEBQXho48+wuOPP97i4+vq6hAQEICFCxfiueeea4MIiYiIiADWliWiW87R0RELFizAxx9/DLVa3eLjly9fDrlcjrlz57ZBdEREREQaHFkiIiIiIiIygCNLREREREREBjBZIiIiIiIiMoDJEhERERERkQFMloiIiIiIiAxgskRERERERGQAkyUiMgvl5eUYNmwYysvLTR0KEREREQAmS0RkJsrLy3HgwAEmS0RERGQ2mCwREREREREZwGSJiIiIiIjIACZLREREREREBjBZIiKz4ODggIEDB8LBwcHUoRAREREBAARRFEVTB0FEBACVlZWws7MzdRhEREREADiyRERmpLCw0NQhEBEREWkxWSIis1FaWmrqEIiIiIi0mCwRkdmQyWSmDoGIiIhIi2uWiIiIiIiIDODIEhGZjbNnz5o6BCIiIiItJktEZDY40E1ERETmhMkSEZkNV1dXU4dAREREpMVkiYjMBjekJSIiInPCZImIzEZ6erqpQyAiIiLSYrJERERERERkAEuHE5HZKC8v51Q8IiIiMhscWSIis1FaWmrqEIiIiIi0mCwRkdkoLi42dQhEREREWkyWiMhsSCT8lURERETmg2uWiIiIiIiIDODHuERkNs6dO2fqEIiIiIi0ZKYOgIiogUqlavS5ohoR5wo4EE5ERNQg3FWAh61g6jA6NCZLRGQ2nJ2dG33u3WNqfH6KyRIREVGDYAclUuZYmTqMDo3T8IjIbLi6uhpsr6kX8cM5JkpERETXKqyTmjqEDo/JEhGZjdTUVIPtG5JFlCtucTBERERmTq1WmzqEDo/JEhGZvSVn1JBwSjYREZEO1rRue1yzRERmIyAgQK/tXIGI47m3PhYiIiJzx88R2x5HlojIbFRWVuq1fXNWDRn/NyAiItIjkXLNUltjskREZqOwsFDncaVCxE/xIpScZkBERKSnqS03qHUwWSIis7XmgohqpamjICIiotsVkyUiMhtRUVE6j5eeUfOXFBERUSMkAueptzXehxCR2Th//rz2+5O5ImILABZFJSIiagSTpTbHZImIzEZ9fb32exZ2ICIiahr3WWp7TJaIyGw4OjoCAMrqRPyayMIOREREZFpMlojIbHh4eAAAfk0QUcfCDkRERE2SSnkr39b4DhOR2UhOToYoilhyhtMKiEzJ0RJYNkqC/GekqHxOiv3TJejVqeXnkUmA849KIb4kw4t9OK+WqLWp1ZyC0daYLBGRWTmaAyQWA/z1T2QaAoA/pkjxQLiAJWfUWHBAjU42AmLulyLYqWXneraXAH/7toiSiABAFPm/ZVuTmToAQ0pLS3H69GkUFhaiqqoKarUadnZ28Pf3R8+ePWFjY9PsOXJycrBt27Ym+0yaNAmenp7N9vf398fYsWN12kRRRFpaGs6fP4/S0lJtjEFBQYiMjISFhYWRr7Zt/PHHH5gwYQIEQcDWrVsxfvz4W3r9vLw8vPrqq9i9ezfy8vIgCAI8PT0xbNgw/Pe//0VgYOAtjYfaB39/fzx/TFPYgeuViExjalcBg30ETP1dhY3Jmn+I65JUSH5cijcHSzDrD+NGft1tgNcHSvDhcTXeHiJty5CJblscr217ZpksVVVVobq6GgEBAbC1tYVEIkFxcTESExORlpaG++67D9bW1k2ew8nJCcOHD9drV6lUOHjwIKysrNCpk/6cgrCwMHh5eem02dra6vU7ceIEYmNj4e3tjd69e0MikSAnJwenTp1CVlYWJk+eDMGE5RyXLl0KZ2dnVFRUYPny5Rg3btwti+fgwYOYMGECqqqqMHToUDzyyCMQBAGHDx/Gzz//jG3btuHnn3/GuHHjbkk81H5cKavDmgss7EBkSlNDBeRWidiUfPUfYmENsC5JxIPdBFhIAYWq+fN8cIcESSXAykQRbw9pw4CJbmMSKT+IaGtmmSz5+PjAx8dHr93Lywt79+5FUlKS3uaV17OxsUFISIhee2pqKkRRREhICCQS/VmIHh4eBo+7llqtRnx8PNzc3DB+/HhtEtKtWzfs378fqampKCoqgpubW5PnaSsFBQXYs2cP7r33XpSXlyMmJgY5OTkG39PWlpubi0mTJqG+vh7ff/89Zs+erfP8b7/9hqlTp+Kxxx7DwYMHm32v6fayPE4JJZcrEZlUr04CTueJelNhj18R8VRPCUKdgfjCps/R1xN4pLuAIatV4CwhorajUqlgprfzHUa7WrNkZ2cHAFAoFDd8jgsXLgDQjCA1pr6+Hkpl46W41Go1lEolrK2t9UZrGqYIyuXyG47xZv3www9QqVR46KGHMHfuXBQVFWHVqlXa5xMTEyEIAsaOHWuwPv/kyZMhk8lw4MABbVtOTg5mzJgBd3d3yGQyODk5YcyYMYiLi9M59q233kJpaSkeeughPPLII3rnvueee/DMM88gLy8PH374oc5zCoUCr732Grp06QJLS0vY2NggKCgIzz33HGpra7X9ysvL8cwzz8DPzw9yuRx2dnYICwvDm2+++c8vDaBfv35wc3NDTk6OzjUyMjIgCALuu+8+bVtMTAwEQcDzzz+P999/Hz4+PpDL5fD09MSzzz6LmpoaY952ukmiKGJttgvXKhGZmJctcKVKv72hzduu+VkKi++SYm2SiGNXWjk4IqJbzKxTUaVSqf0qLS3F33//DQDw8/O7ofOVl5cjJycHnp6ecHJyMtjnyJEj2iTB0dER3bp1Q0REhE5SJJPJ4OXlhezsbMTGxiIwMFA7DS8hIQHBwcHa/WKaolAojN5MTCaTQSYz7sf1/fffIyQkBMOGDYO1tTWcnZ2xYcMGPPfcc7CwsEB4eDgiIiJw9OhRZGRkICgoSHtseXk5du3ahYiICPTr1w8AkJmZiejoaNTV1WH8+PEICwvDpUuXsHbtWowaNQp79uxBjx49AGhGjmQyGebOndvotL9nn30WixcvxsGDB1FRUQF7e3soFAoMGTIEJ06cQGRkJObOnQt7e3skJCRg//79qKyshJWVFUpLS9G7d29cvHgRAwYMwIwZMyCVShEXF4c9e/Zg4cKFkN7gkPTvv/+OkpIS3HvvvXB3d8fvv/+OJUuWIC8vD6tWrTL6/acbcyBLRHaNpanDIOpQBAAWRv5KrPtnap217Or316pVXn2+KbMjBES6AVN/5zAxUVuTmHDJx+3CrO/+Lly4gCNHjmgf29vbY/jw4XprioyVlJQEwPCokkQiQefOneHn5wdbW1tUVVUhKSkJR48eRVFREYYNG6bTf8SIEYiJicHx48dx/PhxbXuvXr3Qp08fo+LZtWsXrlwx7mO36Ohoo877999/Iy0tDc899xzs7TUliKZPn44ff/wRp06dwsCBAwEAjz/+OF544QWsXr0ar776qvb41atXo66uDhMnTtSuC3v88cehUCjw+++/66wDe/rppzFw4EC8+eab2LBhAyorK3HlyhX4+Pg0mdCGhITAxsYGly9fRnFxMezt7fHhhx/ixIkTuOeee7BmzRpYWl69aVar1drE64UXXsDFixcxb948fPHFFzoJjEqlMji10lg5OTnYunUrRo0aBQB4++23ER0djY0bN2Lfvn0YM2aMUecpLi6Gra2t9jVUVlZCFEXtz0OhUKCiogKurq7aY65cuaLz9/r6x7m5ufDw8NC+Dx3xGqmlRr29RNQCd/ppqtgZI+xHJZKKgRolYGngEKt/ft3WNLEHmr0F8P4dEnx8QkR2xQ0ETEQtIwhm9/95e7qGMQTRjGsOVlZWorS0FEqlEoWFhbh06RJCQ0MRGRnZ4nOp1WqsXr0aCoUCDz30kFGjBKIoYseOHcjOztapnAcAtbW1OH78OFQqlTYxSE9PR3p6Ovr06YPo6Ohmz19QUIC6ujqj4ndwcICDg0Oz/R588EFs2LABR44c0cZw9uxZREVF4cknn8S3334LQPMXztPTE1FRUTh48KD2L17fvn2RmJiIkydPIiwsDGVlZXBxccHgwYPx66+/6o0WDRkyBFKpFKdOnUJVVRV8fX0RHByMU6dONRmvh4cHCgsLceHCBYSEhKBr167Izs7GiRMn0K1bN4PHqNVqODk5wc7ODrGxsQYLdDTo168fLl68iLi4OHh7e2vbMzIyEBgYiClTpmDjxo0ANNPwhg8fjmHDhmHv3r06I1O//vorHnzwQcyZMwfLli1r6q2nm1ShEOG+pB516nY1O5jIrHnYAGMDjfvkeXOKiHIFkPy4FCklIsZv0h0ZeixCwA9jpYj8SdnomqU3B0swP0rAkDUqVNdr2nztgUMzZXj3mBrfxamRUwnUc9CJqFXYy1Qof56zMtqSWY8s2dnZadcpBQQEIDAwEJs3b4ZSqUSvXr1adK7s7GxUVVUhPDzc6OlUgiAgKioK2dnZyMzM1CZLSqUSW7ZsgaurK0aOHKntHxwcjL179+LUqVMICgpqdKpfA3d39xa9huZUVVVh8+bNCA0NhVKpxJkzZ7TP+fr6YufOnSgqKoKrqytcXFxw1113Yd++fYiLi0Pfvn2RkZGBU6dOYfjw4drCC0lJSVCr1Th48CD8/f0NXtfNzQ01NTXa5KimpqbZdWWVlZWwtrbWlli/dOkSfHx8dBKb6xUWFqKiogJhYWFwcXFp0XtjjMDAQL0pfBEREQCArKysVr8e6bK3EHCvfxU2XLJnNTyiVpJXDaw437J/ULH5Iu7wFSBAd7+z/l4CqupFJJc0fqy/PeBiLSDhUf3/Z18dIMGrAySIWqHE2YIWhUREZDJmnSxdz9XVFW5ubkhISGhxsmRMYQdDGob2ri0wcPHiRZSVlaFv3756/YOCgnDx4kXk5uY2myzV1tYavWZJLpc3WzRizZo1qK6uxrlz59C/f3+DfbZu3aqtUDdnzhzs3LkTK1asQN++ffHDDz9AFEXcf//92qShYeBx0KBBmD9/vsFzWllZwcXFBZaWlvD09EReXh6ysrIarQaYmpqK6upqhIaG3lDSIwhCs2XQG3u+qcIdZHrP9bfGmgxTR0F0e9uQLGJaVwmmhArafZZcrYFpXQVsTRN1yoYH/bM892KZ5s8vT6vxW6puctbJBvh2tBTL49XYkioivexWvAqi24P0JpYfkHHaVbIEaG52jZ261qCmpgaZmZlwdXVt8WhOWZnmt/q1+zpVVWlKAhmawdjQZkwStGfPnlZds/T111/DyckJr7zyit7GvfX19XjxxRexcuVKPPTQQ5BKpZgwYQKcnJywa9culJeX4+eff4anpyfuuece7XHBwcEQBAEKhQJTp05tNmGbPHkyli1bhmXLluHrr782mLQsWbIEAHDHHXdok9GAgABkZWUhJyen0STTzc0N9vb2yMrKQlFRUZPT8FxcXBAXF6f3d+XixYuNHpOeng6VSqUzuhQfHw/gxouKUMtYFV1Ab48InMkH1BxdIjKJDckijuaIWD5Wgm6uahTWAM9ESSAVgP8e1v2/bd90ze/LwO80GdSZfOBMvu4/3s7/zMg+XyhiSyr/YRO1JrX5rqbpMMwyWaqurta72Qc0C/BLSkr0FmZVV1dDoVDAzs7O4BS75ORkqNVqdO3atdFr1tbWwsrKSqdNpVLh1KlTAIDOnTtr252dnbXn7dKli961ADR5I99gwIABLVqz1JTk5GScOnUKI0eOxIsvvmiw0MHq1atx7NgxJCcnIzw8HHK5HNOmTcP333+PL7/8EpmZmZg5c6ZO7K6urhg2bBgOHDiAH3/8EU899ZTOOUVRRGZmpvb9ef3117F69Wr88ssvGDJkCB588EGd/lu3bsXSpUvh4eGBl19+Wdv+4IMPYtGiRVi0aBFWr16tnZ7XcA1AU4Rj6tSpWL58Od5991189tlnOolNQz9BEBAWFoadO3diz549mDNnDgBNAvvuu+82+h4ePXoU+/fv1xZ4UCgUeP/99yGRSHQSSGpb86IkeGwXFzQQmYpaBMZtVOHjoRL8q5cE1nLgRC4we4eqySl4RHTrmXHpgQ7DLAs87N69G9XV1fD29oadnR1UKhUKCwuRlpYGmUyGCRMm6EzxiomJQXJyMiZMmGBwzcu6detQUVGBBx98UKfK2rU2b94MGxsbuLm5aavhpaamoqysDN27d8fgwYO1fdVqNbZs2YKCggJ4enoiMDAQgGZkIjc3F0FBQTprmW6F559/Hv/73//w+eef4/nnnzfY54svvsALL7yABQsWaPc4On36NHr37g1ra2vU1tZi+/btGDt2rM5xWVlZ6Nu3LwoLCzF8+HD07t0bUqkU6enp2L9/PwYPHqwtlgAAf/75JyZPnoyamhoMHToUAwcOhEQiweHDh7F//364uLhgxYoVGD9+vPYYhUKBQYMG4dSpU+jRoweGDx8OBwcHXLhwARcuXMD+/fvh5uaGkpIS9OrVC5cuXcLAgQMxZMgQyGQyxMXFoaysDHv37oWlpSXS09MRGhoKOzs7zJgxA46Ojti+fTuqq6uRlpZmsMBDYGAgSkpKMGXKFLi7u2PLli24cOEC7rvvPqxevdqke2fdLgoLC2Hj6AqPr1SorDd1NEREROaNBR7anlkmS2lpaUhJSUFRUZF2rZCdnR18fX3Rs2dPbdGHBk0lS7m5ufj9998RHByMESNGNHrN2NhYZGRkoLy8HHV1dZDL5XB1dUV4eDiCg4P1+isUCsTGxiI9PR0VFRUQBAEODg4ICQlBjx49bqqEdUupVCp4enqirq4OZ8+e1SZv17t8+TL8/PwQFhaG48ePa9/HkJAQpKamIjw8XKf9WoWFhXj55Zexc+dO5Ofna9+fPn364KmnntJLsHJycvDaa69hz549yM/PhyAI8PDwwPDhw/H666/r7O3UoLa2Fq+//jrWrl2LnJwcyOVyeHl5YdKkSXj//fe1I3+lpaX4z3/+g23btqGgoABWVlbw9fXFrFmz8Morr2hHmzZt2oT//Oc/yMzMhK2tLUaNGoX//Oc/6N+/v8Fk6bnnnkOnTp2wZMkSFBQUwMXFBVOnTsXHH39scKSTWl9ubi48PT3xr30qfBUrQmV2v52IiIjMh5MlUPKsWU4U6zDMMlkiupWuTZa++OILU4dzW4uNjUVUVBQSCkV0/8nArphERESkxZGltscSGkRkdrq5CRjkDUi4MTkRERGZEJMlIjIbDftaAcC8XhJWxCMiImpCc1up0M1jskREZiMtLU37/X0hApw4s4CIiKhREiZLbY4rwui2N2zYMJbeNBM1NTXa7y1lAp7sIeCzkyz0QEREZIjKiH096eZwZImIzIatra3O4zk9JEyUiIiIyGSYLBGR2fD399d5HOwsYLgfIOUsAyIiIj23cqua2xXfYSIyG4mJiXpt83pxdImIiMgQLiNoe0yWiMisTeoiwM3a1FEQERGZHyZLbY/JEhGZDW9vb702uVTAUz0FTsUjIiKiW47JEhGZvScjuecSERHR9aRSqalD6PBYOpyIzEZOTg46deqk197ZUcDYQGBXBsABJiIiIkAUAbVKBd7Oty2+u0TULrzSX4pONtxPgoiIqEE3yWUAQaYOo0MTRK4MIyIzUVdXB0tLS1OHQURE1C5kZGQgICDA1GF0aFyzRERmIzMz09QhEBERtRtubm6mDqHDY7JERGajqqrK1CEQERG1G6mpqaYOocNjskREZsPamhsqERERkfngmiUiMhtKpRIyGevOEBERGaO0tBROTk6mDqND48gSEZmN+Ph4U4dARETUbnD6ettjskRERERE1A4VFBSYOoQOj8kSEZkNT09PU4dAREREpMU1S0RkNgoLC1kGlYhuzHsbgP/9YeooiFpXQCfg2AeAIBh8WhRFCI08R62DK6mJyGxkZ2czWSKiG7P+KJBfZuooiFpXfhlw4DwwLMLg04mJiejWrdstDur2wml4RERERETmSCoBvtrZ6NMKheIWBnN7YrJERGYjLCzM1CEQERGZD5Ua2HwMyC81+LSDg8Otjec2xGSJiMzG5cuXTR0CERGReVGLwPL9Bp9iYaS2x2SJiMxGRUWFqUMgIiIyL2oRWLoDUKv1nkpOTjZBQLcXJktEZDYsLS1NHQIREZH5ySoC9pw1dRS3JSZLRGQ2QkNDTR0CERGR+ZFKgK/1Cz34+/ubIJjbC5MlIjIb586dM3UIRERE5kelBraeBC4X6TTX1dWZKKDbB5MlIiIiIiKzJwA/7NNpycvLM1Estw8mS0RkNjp16mTqEIiIiMyTWq2ZiqdUmTqS2wqTJSIyG1ZWVqYOgYiIyHzllgI7TmsfRkZGmi6W2wSTJSIyG5mZmaYOgYiIyHxJJZoy4v9ISUkxYTC3B5mpAyAiIiIiM+VoA3z0MHBvf8DGEjieAry4Ajhzsflj+wYDs0cA/UOAHp0BuQwQpjTev5Mj8NZMYEJvwNVeM4qyLw544qtWezntnkoN7I4FMvKBgE6ora01dUQdHkeWyGSeeuopCIKAmJiYW3rdiRMnQhAEZGRk3NLrUvNYOpyIyIwIAvDHa8ADdwBLdgALftYkNDFvAcFezR8/rjfwxF2AKAIXmylE4OsKnPgIuLsX8M1u4Jlvge/3Au6OrfNaOhKJRPPeALC3tzdxMB1fhxtZKi0txenTp1FYWIiqqiqo1WrY2dnB398fPXv2hI2NjU7/uLg4XLp0CaWlpairq4OlpSWcnJwQERGBwMBAo69bWFiIU6dOITc3F0qlEg4ODggLC0P37t0hkVzNSevq6pCcnIzMzEyUlpaitrYWdnZ28PLyQnR0NOzs7FrtvWipiRMnYtu2bThx4gT69OnTKudctmwZEhMT8cYbb8DJyanZ/uvXr8eBAwfw0ksvISAgoFVioPYjLy+vRf/uiIjoJvz5lmaE4tElhp+fOhAYHAZM/RjYeFTTtu4IkLwEePN+YNYXTZ//653Ah5uBWgWw+Amgq0/jfZfN1RQu6LsAKK68oZdz21CpgW92Af+dDh+fJt5TahUdbmSpqqoK1dXVCAgIQL9+/TBo0CD4+voiMTERmzZtQk1NjU7//Px82NvbIzIyEkOGDEGPHj2gVCqxZ88enD59upGr6Lpy5Qq2bNmC/Px8REREYMCAAXB0dMTRo0dx6NAhvesdO3YMgiCge/fuGDx4MPz8/JCSkoINGzagpKSk1d4Lc7Bt2zb873//Q2lpqd5zixcvRmVlJe68805t2969e7F06VKO+tymysrKTB0CERE1mDoQyC0BNh272lZYrkmYJvcDLJr5zD2/TJMoNaerj2YU6uMtmkTJUg7IpDcXe0dXVAFsOY4LFy6YOpIOr8ONLPn4+BjMsr28vLB3714kJSUhKipK2z5y5Ei9vpGRkdi0aRPOnj2LqKgonZEhQ44cOQIAmDx5MhwcHAAA3bt3x19//YULFy4gNDQUnp6eAAAnJyfcf//92n4N/P39sX37dpw8eRKjRo1q0WturywsLGBhYWHqMMiMyOVyU4dAREQNegUCpy9qptFd63gK8NRoINQbiG+Fwjwje2j+zCsF9r4B3NVDM8q05yzw9DLgUsHNX6OjaSj08Pl9po6kw+twI0uNaZjeplA0/wmHRCKBra0t6uvroVarm+xbV1eHoqIieHl56SVAXbt2BQAkJSVp2+zt7fX6AYCvry8sLS1RXFzcbHymtnXrVowfPx6+vr6wsrKCpaUlQkNDsWTJ1WH8iooKDBo0CNu2bQMABAYGQhAECIKAN954A4D+mqWJEyfi22+/BQAMHz5c23/WrFna5w2tNUpKSoKbmxsGDRqk015YWIjZs2fD3d0dcrkcgYGBWL58eaOv6+jRo7j77rvh6uoKmUwGFxcXzJgxA/n5+TfzdlELdO/e3dQhEBFRAy9n4IqBGS8Nbd4urXOdkH/WP337NKBQAtM/ARauBIaEa5Ina36wqkelBmLOw7+OHzK2tQ43stRAqVRqv0pLS/H3338DAPz8/Az2r62thSiKqK2txcWLF5GVlQVvb2/IZE2/RSqVZmMwQ/0a2oy52VYoFKivr4eLi3G/eOrr67XXbo5UKm3VT+x/++03JCQkYNSoUfD390dxcTG2b9+OZ599FiUlJVi0aBGsrKzw/PPPo6amBrGxsXjllVfg7OwMABg9erTB886ZMweVlZWIiYnB3Llz0aVLFwBA//79WxxjeXk5HnjgAezZswe9evXCE088gfT0dMyfPx+urq56/bdu3YqHH34YarUaU6dOhZ+fH86dO4ctW7bg6NGjiIuLg6MjF5m2tdjYWJ2RXyIiaiUyqaay3bXkMs2UN9frigQUV2pGk6wtgDql/rkapta1VhJj988ee7mlwPh3r45kZRcCa14EHrgT+GFv61yrI5FKYLniANCfHzS2pQ6bLF24cEE7PQ7QjOgMHz4cXl6Gq7esXbsWdXV1AABBEBAYGIghQ4Y0ex1ra2tYWVkhPz8fSqVSJ2nKyckBAFRWNr9Q8fTp01Cr1QgJCWm2LwAcPnwYycnJRvUNDQ3FsGHDjOprjE8//VSvWMOCBQswcuRIfPTRR1i4cCHkcjmmT5+OX375BbGxsXjyySebLdjQUGAiJiYG999//03FvGnTJuzduxeDBw/GgQMHIJVKIYoivvrqKzz77LM6fQsLC7Fo0SIIgoDz58/D19dX+9zixYvx/PPP45NPPsHbb799w/EQERGZ1OAwIMbA/2ODw4CZd+i2BTylmfpWowAsDdwqWv2TJNUYsR7JGA3nWXdYd8rf+qPAL0pgUFcmS4ao1JBvOg589YypI+nQOuw0vICAAIwbNw6jR49GdHQ0LCwsmqxFP3r0aIwbNw5Dhw6Fr68vVCoV6uvrm72OIAiIjIxEdXU19uzZg/z8fJSXlyMxMREnT56EIAhQKg18KnONixcvIi4uDn5+ftqpe83p2bMnxo0bZ9RXz549jTqnsRoSJVEUUV5ejsuXL2vfh8rKSpMvNhRFEdu3b4coivi///s/SKWaRaKCIGDq1KkIDw/X6X/mzBnExcVhwoQJAIDs7GztV58+feDu7o4dO3boXacxxcXF2sQb0CTLFRUV2scKhQJFRUU6x1y5cqXJx7m5uRCv+Q+ko17D3t6+Q7wOXoPX4DVu/TXUYtPT5m97ZzOAkW/ofp3NAHad0W/PLdUcc6VEMxXveg1tOa20dCDnn2l9edcV+VGrNYUMnE1XKdisSSUouzPUbP4NtsdrGKPDjizZ2dlp1ykFBAQgMDAQmzdvhlKpRK9evfT6Xzvi1LVrV+zbtw9btmzB9OnTYWlp2eS1oqKioFQqERcXh6ysLACaheoDBgzAiRMndH7Q18vMzMT+/fvh7u6Ou+66C4IgGPX6nJ2dtdPabrXk5GS8/PLL+OuvvwyusTJ1Rb+amhrk5Wn2cwgLC9N5ztnZGV5eXkhISNC2nT9/HqIo4pdffsEvv/xi8JwtKURx/VTK68vBW1hY6E0FvH7E8/rHDQVCOvo1XF1ddfaMaK+vg9fgNXgNE1xD6LCf/7aO0irNBq/XKqnUJETXtzeIzQDuCNfst3TtvUz/EKCqFkjOaZ3YTqVp/vS5bimCXAa4OQAFrJRqkEoNp5enQ24u/wbb4TWM0WGTpeu5urrCzc0NCQkJBpOl64WGhiItLQ3p6el6N9zXEwQBffv2RVRUlDZ5cHV1hSiKOHjwIDw8PAwel5WVhT179sDZ2Rnjxo1r0Q25QqFodsSqgUwma7Wqc/n5+Zg2bRrOnTuHqVOnYvDgwXB1dYVUKsWKFSuwa9euZotitDZRFI1ev9XY8QBw7733Ytq0aQb7dOrU6YbPT8bLyMjgmiUiInOx4SgwbRAwZcDVfZZc7TVtW09qijE0CPrnXqe5zWcNiYnXVMKbdSfw3kag7p+ZPbOHa9Za7Tl7Uy+jQ5IIQJ9gpNurwe3c29ZtkywBmqIP1w7fNdcXgNH9Ac1o0rWJ0cWLFwEYLiqRlZWF3bt3w8nJCePHj2929Op6R44cMcmapTNnzuDcuXOYMWMGVq1apW2vr6/Hzz//fNPnb6pMe0OBheLiYp31TwUFBTr781hZWWl/DhcuXNAWigA0o17XD8F27doVgiBAFEXMnDnzpl8DERFRh7DhKHA0CVg+H+jmCxRWAM+M1ZSt/u8a3b773tT8GTj3apu/O/DQUM33fYI1f746VfPnpQJg5QHN9wol8J+fgZ//Bfz1DvDLAcDfDXhuPPDXeWDT3233GtsrtQjMG4vq6mpTR9Lhdbhkqbq6GjY2NnrtOTk5KCkp0Rl+a1iTdH2lOLVarZ2mde2IglqtRnl5OWQymd7Q3/Vqa2tx4sQJWFlZoVu3bjrPZWdnY/fu3XB0dMT48eNhZWXVshcJzZql4OBgo/ra2tq2+PyNaShgcf3Uwj179uDgwYN6/Rt+FtcnOI25tv/1GpKe3bt3Izo6GoAmmV28eLFOPBKJBHfffTc2bNiA999/H2PHjtUWeNiwYQMSExN1ztunTx9ERERg69atOHLkiF4J8oaNjt3d3ZuNn26OsX+niYjoFlCrgXHvAB8/AvxrvKb63YlUYPZi46bgBXYC3nlAt63hcUz81WQJAH6JART1wMIpwMcPa6YNLtsDvLJSEwfpcrAGpg2CbXYr7HNFTepwydKhQ4dQXV0Nb29v2NnZQaVSobCwEGlpadp1RA3KysqwdetWBAUFwdHREVZWVqiqqkJqairKysoQGhqqk1xVVVVh3bp18PLywsSJE7XtmZmZOHv2LHx9fWFtba0tclBXV4cxY8boJEMFBQXYtWsXAM2IRsMap2sZUxGvLdcsffjhhwYTg7vvvht9+/ZFt27dsHbtWtTX1yMyMhJJSUn4448/0KlTJ6Snp+sc06dPH6xbtw7PPPMM7r33XlhaWmLkyJGIiIgweO0BAwZAEAS8+uqrSEpKgrW1Nfr27YvBgwdj5syZWLZsGV5//XWkpKTAw8MDf/31F9LS0vSS1/vuuw+//vor9u3bh759+2LMmDFIT0/H1q1b4evrq/O+d+rUCe+//z4efvhh3HnnnZgwYQIiIyNRV1eH1NRUHDx4EPPmzdPuD0Vtp6ioqNkPIoiIqJUMf735PqVVwJNfab6acu2IUoMD5wFhivHxrD2s+aKmSSXAY3cB1pbo3LmzqaPp8DpcstSlSxekpKQgJSVFW/3Ozs4O4eHh6Nmzp86NmJ2dHUJCQpCbm4uMjAwoFApYWFjAzc0N0dHRRn/KbW9vD5lMhvj4eNTV1cHKygre3t6Ijo7WK7FdXFysXV9z9OhRg+cztnx4W9mwYYPBdoVCgYkTJ+Lnn3/GggULsHfvXmzZsgW+vr545513EB8fr91UtsGcOXOQkJCAbdu24ZVXXoFarcZ///vfRpOlCRMm4MUXX8SqVauwaNEiqFQqPPDAAxg8eDDCwsLw7bffYtGiRVi5ciVkMhnuvPNOrF27FlOm6P4ydnBwwJo1a/Dvf/8bf/zxBz755BP4+vpiyZIl2LRpk16SOn78eOzbtw9vv/02Dh8+jD/++AMWFhZwd3fH2LFjMX369Jt4R8lYJSUl/MVPRETUFJUamDsGAJCQkMC1vm1MEJsq1UZEdAudO3cOkZGRpg6DiNqjXi8CsenN9yNqzySCZm+sv94FwM3cbwXW2SQis8FEiYiIqAlqEZh3t/aht7e3CYO5PTBZIiKzERfXyF4fREREBDjbAvf21z40dn9OunFMlojIbNzqPbqIiIjaDakEeGoMYHG1ivPly5dNGNDtgckSEZmN63fnJiIion+o1MCTI00dxW2nw1XDI6L26/rqkURERATNqNLwCCDIU6c5PDzcRAHdPjiyRERm4+LFi6YOgYiIyPyo1DqFHRoY2q+TWheTJSIiIiIic9bJEZjQR6+5srLSBMHcXpgsEZHZCAwMNHUIRERE5kUq0WxCK5PqPWVlZWWCgG4vTJaIyGyUl5ebOgQiIiLzohaBJwwXdggODr7Fwdx+mCwRkdkoKioydQhERETmQyoBxvcG/NwMPh0fH3+LA7r9MFkiIrPBzfWIiIiuoVIDT48xdRS3NZYOJyKz0bNnT1OHQETt1V2REOMywI9cqEPxdQPGRDX6tKenZ6PPUesQRFEUTR0EERGgmU4QERFh6jCIqJ2KjY1FVFSUqcMgog6E0/CIyGwolUpTh0BE7Rg3tiai1sZkiYjMBm90iOhmuLkZXgRPRHSjmCwRkdngjQ4R3YzU1FRTh0BEHQyTJSIyG7zRISIiInPCZImIiIg6hICAAFOHQEQdDJMlIjIbvNEhoptRVVVl6hCIqINhskREZoM3OkR0MwoKCkwdAhF1MNyUlojMRkFBAXx8fEwdBhF1QCsT1Igv5NaSZB66OAl4IlKAIHAbZXPHZImIiIg6hJ49expsr1KImLtHjVolIOG9KZmYKAJKUcQQHynCXU0dDTWHyRIRmY3GbnSIiIyRmJiIbt266bWvSRJRVa/5XsXBJTITKrWpIyBjcM0SEZmNxMREU4dARO2YQqEw2L7ktJo3PER0QziyRERmo7EbHSIiYzg4OOi1ncwVEcu6D0R0g/hBCxGZDUM3OkRExvL09NRr++asGjKuUyKiG8RkiYjMhqEbHSIiYyUnJ+s8LqsT8WuiCCXXKRHRDWKyRERm4/obHSKim/Frgog6pamjIKL2jMkSERERdQj+/v7a70VRxJIzLDdGRDeHBR6IyGxce6NDRNRSdXV12u+PXQESi00YDBF1CBxZIiKzce2NDhFRS+Xl5Wm//zqWhR2I6OYxWSIis3HtjQ4R0Y0qrhGx5gILOxDRzWOyRERERB1CZGQkAGDFeRFKLlciolbANUtEZDYabnSIiG5ESkoKunbtiqWxanBQqXmOlsBHd0pwb4gAGzlw/IqIF2PUOJPf/LF9PYHZERL09xTQwx2QSwUInxguPSi+ZPh2c+FfKnx4nD8pMm8cWaJ258UXX4QgCNi3b5+pQ6FWlpKSYuoQiKgdq62txYEsEWmlpo7E/AkA/pgixQPhApacUWPBATU62QiIuV+KYKfmjx8XJMETkQJEABfLmu+/O0ONB/9Q6XxtTWOiRObvth1ZKi0txenTp1FYWIiqqiqo1WrY2dnB398fPXv2hI2NjdHnUqvVSEhIQFJSEsrKyiAIAhwcHBAeHo5u3brp9L18+TJiY2ORn58PtVoNZ2dnREREIDQ0VO+8CQkJyM3NRUFBAcrLyyGKIubMmXPTr/1mvPjii/jss88AAG+99RYWLVqk12fNmjWYOXMmAGDGjBlYvXr1LYvr119/xQMPPNDm16O2UVtba+oQiKgds7e3x/tnRcgEcL1SM6Z2FTDYR8DU31XYmKx5s9YlqZD8uBRvDpZg1h9Nz2P8OlaND48DtUpg8V0SdHVpuppGcgnwayJ/KNT+3LbJUlVVFaqrqxEQEABbW1tIJBIUFxcjMTERaWlpuO+++2Btbd3seVQqFXbt2oWcnBwEBwejW7duUKvVKCsrQ2VlpU7f1NRU7N+/H/b29ujVqxdkMhnS09MRExODqqoq9OrVS6d/bGws6urq4OrqCqVSiaqqqlZ9D26GXC7Hhg0b8Morr0Aqleo89/XXX0Mul6O+vt5E0VF7ZW9vb+oQiKgdkzv7YFMyCzsYY2qogNwqEZuSr75ZhTXAuiQRD3YTYCEFFKrGj8+vbvk1rWSAKAJ1TZyXyNzctsmSj48PfHx89Nq9vLywd+9eJCUlISoqqtnznD59GpcvX8b48ePh7e3daD+1Wo0jR47A2toaU6ZMgaWlJQCge/fu2LlzJ06dOoUuXbrAwcFBe8zEiRNhZ2cHQRCwc+dOs0qWhgwZggMHDuD48eMYOHCgtj03NxeHDx/GnXfeiT///NOEEVJ7ZOjfJBGRsT79qxBq0dPUYbQLvToJOJ0n6q3tOn5FxFM9JQh1BuILW+96s7sLeCZKCokgIKFIxDtH1Vh9gVktmT+uWbqOnZ0dAEChUDTbt76+HvHx8ejcuTO8vb0himKjxxUXF6O2thYBAQHaRAkABEFASEgI1Go1UlNTdY6xt7eHIJjnJhFTpkyBIAj47rvvdNq/+uorAMDDDz/c6LHfffcdIiIiYG1tDUtLSwQHB+Ojjz6CWq075K9Wq7FgwQJ4eHhALpfDz88Pb7/9NkTRuF+u33zzDQRBwNdff41XX30Vnp6ekMvl8PT0xKJFi/SuBwBbt27FgAEDYG9vD7lcjk6dOmHMmDG4cOGCUdekm8P3mYhulFoUsTbLBSyCZxwvW+CKgc9gG9q87Vrv/uPwZRGvHlLjnt/UmLtHBZUaWDVBirk9zfMeh+hat+3IUgOlUqn9Ki0txd9//w0A8PPza/bY3Nxc1NfXw93dHUeOHEFSUhLq6+thZWWFsLAw9OnTBxKJJh9VqTRjzjKZ/lve0NYWe8zU1dUZnVzI5XK9KXWNcXFxwdChQ7F9+3ZUVVXB1tYWALBixQpERUXprdVq8Oyzz2LJkiWIiorCvHnzYGFhgR07duDll19GVlYWFi9erO37+OOP46effkJYWBgeeeQRlJSU4IMPPoCHh4dRMTb4/PPPUVtbi+nTp8PW1hYrV67EO++8g6CgIDz66KPafp988gkWLFgAJycnTJkyBUFBQcjOzsa+ffsQHx+PsLCwFl2XiIhunT0ZIvLqLEwdhkkIACyM++9bOwXOWmZ4Olyt8urzrWXIat0L/XhOhVMPSfHeHRL8dF6lvSaRObrtk6ULFy7gyJEj2sf29vYYPnw4vLy8mj22tLQUAHDu3DlIpVL0798flpaWSE1NRWxsLKqqqjB8+HAAgJOTEwRBQE5ODkRR1BkxysnJAYA2mWa3ceNGvbVTjRk6dCi6du1q9LmfeeYZTJ06FevXr8fs2bPx119/ITMzE88++6w2SbzW8ePHsWTJEkydOhVr167V9nnvvfcwYsQIfP/993j22WcRGhqKxMRErFixAuHh4Thx4oQ2GXviiSd0pv0Zo7a2FmfOnIGrqysAYN68eQgMDMS3336rTZaysrLwf//3f/D09MShQ4cQFBSkc46GZJfalq+vr6lDIKJ26puzakgFESrx9hutuNNPU8XOGGE/KpFUDNQoAUsDh1j9c2dY04YJTL0aWHJGjWWjpejtARy+3HbXIrpZt/00vICAAIwbNw6jR49GdHQ0LCwsjK7I1VDAoK6uDuPHj0e3bt3QpUsXjBkzBl5eXkhJSUFJSQkAwNLSEl27dkVRURFiYmJQVFSEsrIyxMbGaqceKZWt/5tpxIgRGDdunFFfxoymXWvy5MlwcXHBL7/8AgBYsmQJHB0dMXv2bIP9v/vuOwiCgMceeww5OTnIzs7Wfk2ZMgW1tbXYuXMnAGD16tUQRRGPP/64NlECgP79+6N///4tinPatGnaRAnQ3JD7+/sjJydH+zNcsWIFlEol5syZo5coATB6xA3QTLmsq6vTPq6srERFRYX2sUKhQFFRkc4xV65cafJxbm6uzghhR71GVVVVh3gdvAavwWvc+ms4Wdy+E/AuFImYvUNl1NeVfz4/vVKlmYp3vYa2nMq2XU+U9c9fARer2y+5vVZH+jfYHq9hjNt+ZMnOzk67TikgIACBgYHYvHkzlEqlXnW66zVMn+vUqROcnJx0ngsNDcWVK1dw5coVODs7AwAGDRoEAEhKStLuJ2NlZYU777wT+/fvh1wub82XBgDw9Gy7ha4ymQzTpk3DihUrEB8fj23btmHMmDFwc3NDRkaGXv/ExESIoohx48Y1es6GqYgN74+hTUq7deuGY8eOGR2noeTHyckJly5dQm1tLeRyORITEwGgxYmYIS4uLjqPG/5+NbCwsNBJ3gDojWRe//j6n2NHvUZJSQk6d+7c7l8Hr8Fr8Bq3/hrzo0X8lHB7zgLIqwZWnG9ZchObL+IOXwECoFPkob+XgKp6EcklrRqiniAnzZ8F1bd3kYeO9G+wPV7DGLd9snQ9V1dXuLm5ISEhodlkqWHEw9CeTA1t12bAMpkMd955J/r374+SkhJIJBK4urqivLwcAPQSrtZQU1Nj9JolCwsLg2uqmvKvf/0Ly5Ytw8MPP4yamho88cQTjfZtmH64dOnSRl+rMRUIW6qlr4mIiNqf3p4CeriJOFco6FV4I30bkkVM6yrBlFBBu8+SqzUwrauArWmiTtnwIEfNn8ZsPns9N2tNSfJr2cmB56MlKKgWcar1l2sTtSreRRqgVCp1kpzGuLu7AzC81qihzdBeTZaWljrZcmZmJgDA39//huJtyubNm9tszRKgGeWJjIzEmTNn0KVLF4waNarRviEhIThy5Ah8fX0xceLEJs8bEhICQLMebPTo0TrPJSQktChGY4SHhwMATpw4gbvvvrvVz0/G6d69u6lDIKJ2bLpPIeIK3U0dRruwIVnE0RwRy8dK0M1VjcIa4JkoCaQC8N/DulMa903XTEUP/O5qBuXvADzUTTOFro+H5s9XB2j+vFQOrEzQJGDzeklwT7AmAcssF+FlBzwWIdEcv12N+tt39iS1E7dtslRdXW1wRCgnJwclJSV6w3TV1dVQKBSws7PTjlQ4ODjAw8MDeXl5KCwshJubGwBNyevExEQIgtDsgvXy8nKcPXsWjo6OBqeL3awRI0YYvRbq+uFNY3300UfYtGkThg4dCguLxisRPfXUU1ixYgXeeustjBgxQmctEgBcvnwZ7u7usLCwwIwZM/DOO+/ghx9+wNy5c7V9//77b23Fwtb0yCOP4M0339SOkgUEBOg8r1arDRatoNaVnp6O0NBQU4dBRO3UcOcC2MrdUcU90ZulFoFxG1X4eKgE/+olgbUcOJELzN6hMmoKXqCjgHeG6K7nbXgckyVi5T9TIg9fFjHIG3giUoCrtYCqes1eTo/tFPFnFscAyfzdtsnSoUOHUF1dDW9vb9jZ2UGlUqGwsBBpaWmQy+UYMGCATv/jx48jOTkZEyZM0Nl8dvDgwfj999/xxx9/oHv37rCyskJaWhoKCgoQHR2tM58yISEBmZmZ8PT0hJWVFUpLS3HhwgVIJBKMHDlSr4jApUuXtAvVyso0Y9+nT58GoJkyFxER0ezrbMs1Sw3Gjh2LsWPHNttv4MCBeOGFF/D5558jLCwMd999N/z8/JCbm4uzZ8/i2LFjyMzMhLe3N7p164YHH3wQv/zyC/r06YOJEyeipKQEq1atQkBAANLT01v1Nfj5+eHdd9/FwoUL0bt3b0ycOBFdunRBTk4O9uzZgw8++ABTp05t1WuSvurqG9gSnojoH+6O1niku4Bvz4pQ8j68WaV1wJO71Xhyd9P9rh1RanAgS4TwSfMfxu69JGLvJf4wqP26bZOlLl26ICUlBSkpKdrqd3Z2dggPD0fPnj31Fo01xs3NDZMnT8aJEycQHx8PlUoFJycng1PanJ2dkZaWhri4OCgUCtjY2CA4OBi9evXSG2UBNJ+yJycn67SdPHlSG6sxyZK5+eyzz9CvXz98+umnWLVqFerq6uDg4ICAgAAsWLBAZ3Trp59+QqdOnbBixQp8/vnn8PT0xMKFC1FSUoLPP/+81WNbsGABgoOD8e6772LdunWor6+Hs7MzevfujR49erT69UifoX8HRETG6ty5M+Y6SfBV7O1Z6IGIWp8gGrv6n4iojSkUiianchIRNSU2NhZRUVHov1KJk3maqWZE5urcI1JEuN/epdPbAy7CICKz0RbFO4jo9jO/l4SJEhG1CiZLRERE1CE0rCmeGirAgYPURNQKmCwRkdm4tngKEVFLCYJmSpO1XMBjkQKknOFERDeJyRIRmY2GGx0iohtx+fJl7fdze0qg4lQ8IrpJTJaIyGxce6NDRHQzuroIuNMXHF0iopvCZImIiIg6hPDwcJ3Hz0RxdImIbg6TJSIyG9ff6BARtURWVpbO43tDBDhbmSgYIuoQmCwRkdm4/kaHiKglKisrdR5bSAU81YOFHojoxjFZIiKzcf2NDhFRS1hZ6Q8jPdmDey4R0Y1jskREZsPQjQ4RkbGCg4P12oKcBNzVmYUeiOjGMFkiIrNh6EaHiMhY8fHxBtvnsdADEd0gJktEZDYau9EhIroZE7oI6GRj6iiIrpJAhK3c1FGQMWSmDoCIiIioNXh6ehpsl0kEbLlHioxyDi+ReajNTUGgU1dTh0FGEERR5G8OIjILubm5jd7sEBERdRQZGRkICAgwdRhkBE7DIyKzIZdzTgIREXV8bm5upg6BjMRkiYjMBvdZIiKi20FqaqqpQyAjMVkiIiIiIiIygGuWiMhs1NTUwNra2tRhEBERtanS0lI4OTmZOgwyAkeWiMhsXLlyxdQhEBERtbmqqipTh0BGYrJERGajvLzc1CEQERG1uYKCAlOHQEbiPktEZDYsLS1NHQIREbVH9UrgwmVTR6Erwh8QBFNHQTeJa5aIyGyo1WpIJBzwJiKiFnr2e2DJdlNHoevo+8AAwxvPiqIIgYlUu8C7EiIyG3FxcaYOgYiI2qOLuaaOQJdMAnyzu9GnExMTb2EwdDOYLBERERERtSalGlh9ECipNPi0QqG4xQHRjWKyRERmo1OnTqYOgYiIqHXUq4CfYww+5eDgcGtjoRvGZImIzAb3WCIioo5D1KyjMlAewNPT0wTx0I1gskREZuPSpUumDoGIiKh1iABSc4GDCXpPJScn3/p46IYwWSIiIiIiagsyCfD1TlNHQTeByRIRmY2QkBBTh0BERNR6lGpgw1GgoEyn2d/f30QBUUsxWSIis8EdzYmIqMNRi8BPf+o01dXVmSgYaikmS0RkNkpLS00dAhERUetSi8DSHYBarW3Ky8szYUDUEkyWiMhsyOVyU4dARETU+i4VAPu48Xp7xGSJiMxG9+7dTR0CERFR65NKgK+uFnqIjIw0YTDUEkyWiMhsnD171tQhEBERtT6VGvj9BJBTDABISUkxcUBkLCZLRGQ2RAMb9xEREXUYP+4DANTW1rbdNUqrgDlfA+6zAduZwPDXgdNpxh+fmA2MfQuwewBweRh46H961fz0/HoAEKZojulgmCwRkdlwc3MzdQhERERtQy1qpuKpVLC3t2+ja6iB8e8Aqw4C8+8GPnoYyC8Dhr0OpOQ0f3x2IXDna5rNdN+bBbw0CfjjFDDqTUBRb/iYyhpgwS+ArVXrvhYzITN1AKZWWlqK06dPo7CwEFVVVVCr1bCzs4O/vz969uwJGxsbvWPy8vJw5swZFBUVoba2FjY2NvDx8UFUVBQcHBxu+Wt444038Oabb+L999/HwoUL9Z6PiYnB8OHDcd9992HlypWwsmq/f5lVKhV8fHyQl5eHSZMm4ddff4WdnZ2pw6JW0mb/eRAREZmDKyXAzjPwuSvixo4ftggI6AT89Kzh5zccBY4kAetfAqYO0rRNHwSEzgf+uxZY9ULT539vI1BVC5z6GPB317T1C9EkSz/9CcwZrX/MOxsAe2tgeATw2/Ebe11m7LYfWaqqqkJ1dTUCAgLQr18/DBo0CL6+vkhMTMSmTZtQU1Oj0z8rKwu///47ysrK0L17dwwePBidO3dGamoqNm/ejKqqKhO9ktvDjh07kJeXh06dOuHo0aO4cOGCqUOiVpSenm7qEIiIiNrOP4Ue2uz+ZcNRwMMJmDLgapu7oyZh2nIcqGtkdKjBxmPAhD5XEyUAGNkTCPUG1h3R75+SA3y+FfhsNiCTtsYrMDu3fbLk4+ODCRMmoF+/fujevTvCw8MxePBgDBs2DNXV1UhKStLpf+7cOQiCgMmTJyMqKgphYWEYNGgQBg0ahLq6Oly8eNFEr+T28O2338Ld3R0LFy5EQUEBfvvtN65zISIiovZBpQZ2nIY8p7Rtzn8mHYgOAiTX3eL3CwGq64DkJqbiXS7STNnr00X/uX4hwBkD97jP/6gZURrX++biNmO3fbLUmIapXQqFQqddoVBAKpXCwsJCp71hup5M1n5mNiqVSrz11lvo3LkzLCwsYGdnh759+2LVqlVQKpXafjExMRAEAbNnz9Y7x+zZsyEIAmJiYrRt58+fx9ixY+Hq6gq5XA5HR0d0794d7733ns5IXV1dHV5//XUEBATAwsICNjY2iI6OxooVK1Bfr//JR15eHnbs2IEBAwZg9uzZcHV1xZ49e3D58mWDr+/LL7+Ev78/5HI5PDw8MHfuXCxevBiCIOC1117T6VtWVoZnn30W3t7ekMvlsLe3x+DBg/H7779Dfc0mctS2unQx8AuaiIioI5FIELivBQUXWuJKCeDlrN/e0PZPNb5Gj7227/XHF1fqjkz9cRLYfRb47NEbj7cdaD939m1MqVRqv0pLS/H3338DAPz8/HT6+fr6Ij8/HzExMejZsyesrKxQXFyMY8eOwcnJyaibvYbrGEMikeglZo2pqqpCdna2XntBQYHB/vfffz82bdqEbt26Yd68eaiqqsKqVavw2GOPIT8/H//6178guf6TiWYUFRVh6NChUCgUGDduHLp3746ysjKcPXsWZ86cQU1NDaytrVFfX4+77roLf//9N4YMGYIZM2ZAoVBg7dq1mDNnDgoLC/HCCy/oXP/nn3+GSqXCpEmT4OzsjIceeghfffUVTp06BV9fX5043n//fbzyyivw9/fHk08+CZlMhnXr1mHXrl16MZeVlaFv377IzMzEiBEjEB0djdLSUqxatQqzZs3C119/jQcffLBF7wPdmJKSEq5bIiKijk2lhuWKA8AHjwDyJm7F65VAWbV+W109UFiu2+5ipxlNqlEAlgbOafXPvWSNQv+5Bg3PWRrYIN5KfrWPpVxT7OGF5cDc0UA3P/3+HQhHlv5x4cIF/Pzzz1i1ahW2b98OhUKB4cOHw8vLS6dfr1690K1bN6Snp2Pjxo349ddfsWPHDtjb2+Oee+4xKrGJjY3Fzz//bNSXoZv7xrzzzjvw8/PT+5o+fbpe3z179mDTpk3o3bs3tm/fjs8//xzffvstDh8+DKVSiaVLlyI5Odnoazc4fPgwioqKMGvWLKxatQqLFi3CJ598gj179mD9+vVwcXEBACxZsgSHDx/Gf/7zH+zatQsffPABPvvsMyQmJsLV1RXffvut3h4E3333HUJCQnDHHXcA0IxqKRQKrF+/HnV1ddp+xcXFePPNN+Hj44M1a9bgq6++wpdffonY2FgUFhbqxfzaa68hIyMDH374IbZt24Z33nkHS5YswZkzZyCKIr766ivk5BhRQeaa618bT2VlJSoqKrSPFQoFioqKdI65cuVKk49zc3N1pht21GsUFBR0iNfBa/AavAavwWvc2msoVSq0J9KiSiCvtOn36vAFTfnva7+OJAFrDum3Z/5zf2NtgerScr33qr6iSvt8oz8P63/uYevq9d7/ysIS7fEAUPHWaoiFFcCbM7TXUF3zM2gvf6+MwZGlfwQEBMDJyQlKpRKFhYW4dOmSwRr4giBoq98FBATA0tISeXl5iI+Px759+zBmzJhmR2NCQ0Ph6elpVFyWlpZGv4ZHH30Uo0aN0mtPSEjAO++8o9O2adMmAMDMmTPRuXNnbXvPnj0xbtw4bN26FbGxsQgLCzP6+gDg6OgIAIiLi8P58+cREREBQRD0+q1YsQKenp646667kJ+fr/PcqFGjsHLlSqSlpaFr164AgCNHjiAlJQWPPvoogoKCtLFGRkbi0KFDSE1NRffu3QFoEsG6ujoMHToUffr00Z7X09MTDz74IL755httmyiK+PXXXxESEoL+/fvrJEVSqRT9+vXD6dOnkZ2dDW9vb6Peg4aEsMH11fosLCzg6uqq03Z9Un794+v/vnTUa1hYWOiMLLXX18Fr8Bq8Bq/Ba9zaa8ik7ai4gFSCimh/2Pu6weW6p3Teq54BwJ7/6nZ48SfA0xn4z2Tddk8nzZ9ezrAprQOuufdycXEBCis1D7xdGv95NNz2XinRe//tKuo1o1eWcqCsCvb/2wk8MxYorwHKazSvo0YBiCKQkQ87Gwugk5P+Na5hDn+vjMFk6R92dnbaNz0gIACBgYHYvHkzlEolevXqpe0XExODvLw8TJs2Tbs+KTAwEA4ODjh06BCSk5ObTTAcHBzapMR4aGgoZs6cqdceExOjlyylpaVBEARERkbq9e/Rowe2bt16Q8Uqhg4dihkzZmDNmjXo1asXAgMD0b9/f8yYMQOjR4/WjrwlJSWhtrYWI0eObPRceXl52u+/++47SKVS9O7dG/Hx8dr2u+66C1988QV27typTZYaKqp17twZcrnuUPL1P5uCggKUlJSgpKQEAwcONBiHIAh6VRGpbRj6+0hERNShqNSwfmlK8/2c7TSV6K5v83LWb28QFQAcTNTst3Tth/d/pwA2lpqqdo3xcQXcHYCTBtZTHU8BogI135dUAZW1wEe/ab6uFzgXmNwP+E1/O5v2iMlSI1xdXeHm5oaEhARtslRZWakdwbi+kENQUBAOHTqEnJycZpOl+vp6gwUMDJFIJCbfF8nQyFADQ69j9erVWLhwIdauXYuDBw9i48aNWL16NR588EEsXrwYDg4OEEURPj4+WLBgAdzd3Q2cGRgyZAgAzfu+bt06qFQqzJ8/32Df7du345FHHmnxpqYNw7vh4eF47rnnGk1ie/To0aLz0o05d+4cEyYiIurY3B1wsbsrQtvi3FMHasqHbzp2dZ+lwnJg/RFgYh/d9UhpuZo/u1wzgnPfQGDFn0BWIeD3zz3VvjhNFb0XJmoed3IENr+sf+0v/wCOJgOrXzBcJKKdYrLUBKVSqTM3smEPJUOlqhsqphlTxvrs2bM4ffq0UTF4eXlh4sSJRvVtieDgYOzZswfnzp3D6NG6G4w1jNw0THdrGPasqqpCbW2tTvJ2/bqiBj179kTPnppPPUpLS9G7d2+sXbsWTzzxBO644w506dIF2dnZ6Nu3b6MjOg3WrVuH6upqTJs2DUOHDtV7/qeffsLff/+N+Ph4DBs2DAEBAQCAS5cuob6+Xmd06fp9Ddzd3eHg4ICamhrccccd6NatW5OxUNtStbM550RERC0ilQBzx6C6vq75vjdi6kBgQCjw6BIgIRtwswe+2qkpWf7P+iKtu/6Z4pex7GrbK/dpEqvhrwPPjdeMIH28BYjsDDw6QtPHxhK4p7/+tX87DhxPNfxcO3bbJ0vV1dXast/XysnJQUmJ7pxNR0dHCIKAjIwM9O3bV2c9UUMxhMZGSa7VVmuWWuLee+/F119/jbVr12LatGnw9/cHoEmUtm3bhuDgYERFRQHQTDOUyWS4cOECLl++rK34d+TIEZw8eVLnvMXFxbCystJ5T52cnBAUFIT09HTtQrzZs2djwYIF+OKLL9C9e3e9EZ0rV67A2dkZVlZWWLZsGWxtbTFv3jyDyZKdnR1mz56N9evX44477sCoUaNgYWGBAwcO4OTJk9pkLDc3FytXrtQ5ViKRaCveLVu2DB9++KHeSF5OTg7c3NyMrkpIN+76+chEREQdiloEnhgJ27rStjm/VApsfw34zwrNSE+NAugbDPz0LNDVp/nj/dyAA28D//4JWLgSsJAB43sDn842XCXvNnDbJ0uHDh1CdXU1vL29YWdnB5VKhcLCQqSlpUEul2PAgKs7IFtZWSEyMhJxcXHYtGkTwsLCYGlpidzcXKSmpsLBwcGogghttWapJUaNGoUpU6Zg06ZNGDduHMaMGYPKykqsWrUKMpkM8+bNQ2ioZoDYzs4ODz/8MH788UfMmjULI0aMQE5ODjZt2oTOnTsjIyNDe96ff/4Z7777LgYNGoSuXbvC1tYWx44dw969e9G7d29EREQAAJ5//nls374d69atQ2JiIu644w64u7sjJycHR44cgVqtxubNmyGKIo4fP46BAwciJCTE4GuZNGkSZDIZYmJikJ6ejuDgYLz++ut47bXXMGPGDEyYMAEymQxr166Fu7s7KisrdYpwvP/++/jrr7+wePFi/P333xg4cCDs7e2RlZWFAwcOwNvbG+vWrTO6wAPdOGfnjjNsT0REpEMqAcZEAf7u6KxwvLFzxLzdfB9nO+D7eZqvplw7onSt7v7ArtdbHttPz2q+OpjbPlnq0qULUlJSkJKSoq1+Z2dnh/DwcPTs2VOv0kb//v3h6OiICxcu4MyZM1CpVLC1tUW3bt3Qu3fvdjX6sHbtWrz77rv48ccf8eWXX8LCwgLh4eH497//jenTp+skFP/73/9QW1uLrVu34syZMwgICMAHH3yAo0eP6iRLw4YNQ0xMDI4fP46dO3dCIpHA3d0dTzzxhHbfIwCQy+XYs2cPPvvsMyxfvhw//PADRFGEs7MzQkNDMXXqVPj4+OCNN94AoHnfG6tg4uzsjKFDh2L//v04dOgQgoOD8eqrr8LGxgafffYZvv32W7i4uODee+9F586d8corr+iMHjk6OuL48eN45513sGbNGixduhQSiQQuLi6IiIjArFmzOOJxi6SlpWlHNImIiDoUlVpTQQ6aSsX8/659EERjFtkQdRDz58/H0qVL8csvv3CjWTMUGxvL/zyIiKjlxr8DbDduPbjJeDsDmd8CUin/v2tHuCktdUi1tbVQKpU6bVeuXMGKFSvg7e3N6nZmKjAw0NQhEBERtT6JADw9VrOmCODU/nbktp+GRx1TTEwMnnnmGQwePBhBQUG4cuUK1q9fj6qqKjz99NMt3myXbo2KigrtxsZEREQdyuN3ab9talsWMi9MlqhDCg4ORlBQEP744w9UVFRAJpMhKCgIixYtwty5c9vV2rLbSWFhIXx9fU0dBhERUeuRSYCJfQGvq+ufL1++bFQFZTI9JkvUIQUHB2Pv3r2mDoNaiJ+0ERFRh6NUA0+PMXUUdIO4ZomIzEbDRsZEREQdRmd34C7dtdLh4eEmCoZaiskSEZmN8+fPmzoEIiKi1iMRgHl3AxLdW+6srCwTBUQtxWSJiMxGfX29qUMgIiJqPRIJMHu4XnNlZaUJgqEbwWSJiMyGk5OTqUMgIiJqHTIJMHUA4K5f5dXKysoEAdGNYLJERGaDlYGIiKjDUKo1eysZEBwcfIuDoRvFZImIzEZKSoqpQyAiIrp5AoAQL+CObgafjo+Pv7Xx0A1jskRERERE1KoEYP44gFtitHvcZ4mIzEbnzp1NHQIREbVHL05CWXkFHB3sTR2JhiAADw1t9GlPT89bGAzdDEEURdHUQRARAUBOTg68vb1NHQYREbVDGRkZCAgIMHUY1MFwGh4RmY38/HxTh0BERO2Um5ubqUOgDojJEhERERG1e6mpqaYOgTogJktEZDZ69Ohh6hCIiIiItJgsEZHZSEpKMnUIRETUTnG9ErUFJktEZDbq6upMHQIREbVTVVVVpg6BOiAmS0RkNhwcHEwdAhERtVMFBQWmDoE6ICZLRGQ2vLy8TB0CERERkRb3WSIisxEbG4uoqChTh0FERO2QKIoQBMHgcwv/UmFLqulueXu4C1g5TgK51HB8ZL5kpg6AiIiIiOhmJSYmolu3bnrtZXUi/ndKRK3KBEH940KxiC+GA152pouBbgyn4RGR2fDz8zN1CERE1E4pFAqD7SsTRNSZMFGi9o3JEhGZjfr6elOHQERE7ZShIkGiKGLJGbUJoqGOgskSEZmN3NxcU4dARETtlKenp17b0RzgQjHABfp0o5gsEREREVG7l5ycrNf2dawaMtZUoJvAZImIzEZERISpQyAiog6iqEbE2iQRSg4r0U1gskREZiM1NdXUIRARUTvl7++v83jFeRFKLleim8RkiYjMRm1tralDICKidqqurk77vSiKWHpGzbVKdNOYLBGR2bCz4wYURER0Y/Ly8rTfx2SJuFhmwmCow2CyRERmg/ssERFRa/g6VmRhB2oVTJaIyGwkJiaaOgQiImqnIiMjAQB5VSI2p7CwA7UOJktERERE1O6lpKQAAJbHi2BdB2otMlMHQETUwMfHx9QhEBHRdUprRSz4S43NKSKq64F+XgI+HSZBtIdx89wSi0S88Kcahy6LsJAC44MEfDZMAnebq8fnVIpYcECNE7kicioBqQQIdQbmRUnwcHcBgtD8tWpra6H+p7CDmqNK1EqYLBGR2RBF/u9GRGRO1KKI8ZtUOFsA/KevBG7WwFexagxbq8Kph6QIcW46icmuEHHnGhUcLYH37pCgUgF8clKNcwUqHH9QCgup5vjCGk3fqaEC/B0E1KuAPZdEzN6pRlKJgPfukDYbq729PXZniMiubJWXTgQAEEQzvDtRKpVYv349Kioq0K1bNwwZMsSo49RqNc6ePYuUlBSUl5dDLpfDy8sL/fr1g5OTk8FjSkpKcPr0aeTk5KCurg7W1tZwd3fHkCFDYGNjAwCoqanB33//jcLCQlRVVUGpVMLW1hZeXl6IioqCo6Nja730G/bHH39gwoQJEAQBW7duxfjx42/JdX/66Sc8+uij2seCIMDKygp+fn6YOnUqFi1aBCsrq1sSC7V/sbGxiIqKMnUYRET0j3UX1Lh/mxrrJ0owtatm9UZBtYjQH1S4O1DAqglNJzHP7FHhp/MiLjwmhb+DJjHae0mNUevVWDZKgjk9m14RMnGTCn9miSh7VgqppOnErLa2FvfvkOGPi4DK7O5ugZy5UnjZsepEe2OWI0snT55s8X4roihi165dyMrKQkBAALp3747a2lokJCTgt99+w+TJk+Hs7KxzTFZWFnbv3g0HBwdERETA2toatbW1yMvLQ319vbZfXV0dysrK4OvrCzs7O8hkMpSVlSEpKQkXL17EPffco3fuW23p0qVwdnZGRUUFli9fjnHjxhk1ZN1axo0bh+HDh0OtViM7Oxvr1q3De++9h4sXL2LlypWQSpv/RIiIiIjMy4ZkER42wJTQq/cU7jYCpncVsDJBRJ1ShGUTZec2poiYECRoEyUAGNlZglBnNdYliZjTs+nrBzgC1RcBhQqwbmal/YHYVGy7GMYpeNSqzC5ZKiwsxLlz59C/f38cO3bM6OMuXbqErKwshIWF4c4779S2h4SEYP369Thy5IjOaEtNTQ32798Pb29vjBkzBhJJ4/8CnZycMHnyZL32wMBA/Pbbbzh//rzRo19toaCgAHv27MG9996L8vJyxMTEICcn55au/4iKisJLL72kfbxw4UJ06dIFW7ZswcWLFxESEnLLYqH2q1u3bqYOgYiIrnEmX0S0hwDJdR/A9vMS8G2ciOQSINLd8LGXK0TkVwN9PPWTqX5eArZf1M9qaupFVNUDlfXAgSwRy+NFDPQGrOXNfwD8W45pP7imjsmsquGp1Wr89ddf8PPzQ2BgYIuOzcnJAQB07dpVp93BwQFeXl64fPkyKiuvTmJNSEhAXV0d+vfvD4lEAqVSCbW6ZbVT7O3tAejuGG0KP/zwA1QqFR566CHMnTsXRUVFWLVqlfb5xMRECIKAsWPHGnyNkydPhkwmw4EDB7RtOTk5mDFjBtzd3SGTyeDk5IQxY8YgLi7OqJi8vb3RpUsX1NTU4NKlSzrP7d27F3379oWNjQ0sLCwQEBCAhQsXGhxNNLZvv3794ObmhmPHjmH48OGwtbWFra0tRowYgYsXL0KtVmPhwoXw8PCAXC5HQEAAfvzxR51zqNVqvPXWWwgMDIS1tTWsra3h5eWFMWPGIDs726jXTTfn+r8rRERkWleqAC9b/faGtpzKxodxrlTp9r3++OJaoO66+t7/Oy3C/SsVAr9TYfZONQZ4CVjTzFQ/AFCqRWzMceeoErU6sxpZOnfuHEpLSzFq1KgWH6tSqQAAMpn+S2poy8/Ph52dHQDNFDy5XI66ujps3LgRRUVFEAQBHh4eGDBgADp16qR3HrVaDYVCAbVajbKyMpw6dQqA8RtpNhxrDJlMZvC1GPL9998jJCQEw4YNg7W1NZydnbFhwwY899xzsLCwQHh4OCIiInD06FFkZGQgKChIe2x5eTl27dqFiIgI9OvXDwCQmZmJ6Oho1NXVYfz48QgLC8OlS5ewdu1ajBo1Cnv27EGPHj2ajKm+vh45OTkQBAFubm7a9k2bNmHatGlwcHDQJmNbt27Fhx9+iOTkZKxZswYWFhYt7gtoktZ77rkH3bp1wwsvvID4+Hhs2bIFM2fORGhoKA4dOoSZM2dCIpHghx9+wLPPPotevXqhV69eAIBFixbhvffeQ3R0NGbMmAErKytkZGRg3759uHLlCnx9fY36edCNq6qqMnUIREQdlloUoVAZ19dSqlmHXKPUfH89q39uUWqUjZ+j4TmDx0uv9rG85nZnZpiAPp4SFFQD2y6KyKtq+hoNtl8UUVBrVmMA1EGYTbJUXl6OU6dOITo6Gvb29qioqGjR8Q1rhnJycuDq6qptVyqVyM/PBwCdkaXS0lKIoogdO3YgKCgIvXr1QmVlJU6fPo1t27bhnnvugYuLi841srKysGvXLu1ja2trDBgwAKGhoUbFuGvXLly5csWovtHR0ejTp0+z/f7++2+kpaXhueee0450TZ8+HT/++CNOnTqFgQMHAgAef/xxvPDCC1i9ejVeffVV7fGrV69GXV0dJk6cCGtra21fhUKB33//HcOHD9f2ffrppzFw4EC8+eab2LBhg86aqOrqamRnZ0OtViM9PR3vvfceSkpK0KdPH+1on0qlwrx582BpaYlNmzZpz/3222+jf//++O2337B161bcd999LerboLKyEvfeey+WL1+uXSM1duxY7N69G3l5eThy5Ai8vb0BAHfeeSfuvfdefPvtt/j6668BAJs3b4aXlxd27NhhMFmmttdQVIWIiFrfX1kihq8z7kPbxEelCHMFrGVAnYEEq/afBMa6iTvJhucMHq8yfHxnRwGdHTX3FzPDgTm7VRi5XoWkx6RNTsVbnShCAhFqsIACtS6zScEPHToEe3v7ZkcsGhMSEgJra2ucPHkSiYmJKC8vR35+Pvbs2aOdsqVUXv1oor6+HkqlEgEBARg2bBiCgoLQo0cPjB49GkqlEqdPn9a7hoeHB8aNG4cxY8agX79+sLGxQV1dndGjRQMGDMC4ceOM+jI2AVu8eDEsLS3x8MMPa9uefvpp1NfXY/ny5dq2hx9+GHK5HFu2bNGZNvj999/D1tYWs2bNAgCUlZVh//79iIqKQnBwMLKzs7Vf3t7e8PPzQ2xsLMrKynTi+OKLL+Dn54fOnTtj2LBh2LNnD0aOHIl169Zpk7BTp04hNzcXd955J4YOHao91sLCAq+//jpEUcRvv/3W4r4NJBIJ/v3vf+sUk7jrrrsgiiImTJigTZQAaM+ZkZGhbbO3t0dJSQl+++03nb8rLVVcXKzzHldWVuok/wqFAkVFRTrHXJ9EX/84NzdXp6x2R71Gp06dOsTr4DV4DV6D1zDHa4S5Clh8Rw2+HanG8rESLB8rwdfD6vH1MIX28Xcj1Vg8pBpemok48LIFMopr9a7RMMXO205o9HU0TL/LKK7Tex0ZxXVwsYK2OERjr2NqqICsCuC3c8VNvlcDPRTtYiPajvj3qj1fwxhmUTo8JSUFf/75JyZNmgRPT08AQEVFBVavXt2i0uHFxcX4888/dd4oLy8veHp64syZMxg0aBAiIiIAAMuXL0d9fT3GjRunN71q1apV2jVATamqqsKGDRsQGBioU1TiVqmqqkKnTp3QpUsXfP/995DL5drnJk2aBEEQcObMGe1I29133419+/bh8OHD6Nu3r3ZK3vDhw7F7925IpVIcP34c/fv3b/K6bm5uiIuLg5eXl7Z0+PTp03HPPfdAoVDg+PHj+O6779C9e3f88ccf2iRl7dq1mDFjBubPn4/FixfrnDM1NVU7lfDPP/9sUV9As2YpNTUV586d0yls0RDfxx9/rFOAAtBMLxg4cCCOHDkCQJOwT5w4EaWlpXByckLPnj0xZswYzJkzR2e0ktoOS4cTEZmXab+rcDBbRM7TUp0iD3N2q/Brgoji+dImq+F1WqrEMD8B6ybpzsXr+oMSvvYC9k1vej3SllQ17vlNjbUTJJge1vhn/BUKER5fKVGjNN+RJZYOb59MPg1PpVLh6NGj8Pf3h7W1tXbEomHtgkKhQFlZGaysrGBpadnkuVxcXHDfffehrKwM1dXVsLGxgaOjo7aq3rV7Ldna2qK0tNTgtB8bGxsUFhY2G7utrS18fHyQlJSEwYMHN1seu7a21uhRKLlcrpP8GLJmzRpUV1drqwcasnXrVsyePRsAMGfOHOzcuRMrVqxA37598cMPP0AURdx///3a2Bty50GDBmH+/PkGz2llZaU3RTE4OBgzZ84EADzyyCPo378/HnnkEcydOxebNm0yev3VzZBIJI2WSzfm+kOGDEFWVhbWrVuHXbt24dixY3jllVewePFi/PHHH9q1TURERLeLqaECNiSL2JQsYmrXfzaQrRaxPknExC6CTqKUVqq5h+jidLXtvlABK86LyCoX4fdP+fB9l9RILgFe6H21X0G1CHcb/f/DfzgnQgAQ7dF0kmFvIWCSTwU2ZjpAafJhAOpITJ4sKZVK1NbWIjMzE5mZmXrPp6amIjU1Ff3790fPns0U4/+Ho6OjzkaxDcUcPDw8tG3u7u4oLS1FVVWV3o1/VVWVdupYc1QqFURRhEKhaPaYPXv2tOqapa+//hpOTk545ZVX9JK++vp6vPjii1i5ciUeeughSKVSTJgwAU5OTti1axfKy8vx888/w9PTE/fcc4/2uODgYAiCAIVCgalTpzabsDXm4YcfxpIlS7Bjxw7s2rUL48eP1xaWSElJgVqt1inXHh8fDwDaUb6W9G1NdnZ2eOyxx/DYY48BAD7//HP8+9//xmeffYZffvml1a9Hury8vEwdAhERXWNqqIABXsCjO9VIKALcrIGvYtVQicCbg3VHeu5ap1mIlDHn6u3lK/0lWJ+swvB1KjwXLUFlPfDxCTUi3YBHI64mQO8eU+PwZRFjAzV7MhXXABtT1DiRCzzbS0Cwc/MjMvd45GPtJYdWeuVEGiZPluRyOUaOHKnXXltbi0OHDsHPzw9du3bVSWiqq6uhUCi0G8Q2JT4+HiUlJYiOjta58Q8JCUFKSgoSEhJ0qtldunQJVVVVCAsL07meoRGokpISXL58GQ4ODkYlVwMGDDC6zLiDQ9P/2JOTk3Hq1CmMHDkSL774osF9olavXo1jx44hOTkZ4eHhkMvlmDZtGr7//nt8+eWXyMzMxMyZM3WKGbi6umLYsGE4cOAAfvzxRzz11FM65xRFEZmZmejcuXOzr+H999/HyJEj8dFHH2HUqFGIjo6Gp6cnDh48iIMHD2rXDdXX1+Ptt9+GIAjaxK0lfVtLdna2XgI2YMAAAJqCINT2uHkxEZF5kUoEbL9Piv8cUOPLM2rU1AN9PYGf7paiq0vzCYyfg4AD90vx7xg1Fv6lhoUUGB8k4NNhEp1RqfFBAtJKgR/jRRRUi7CSAT3cgeVjJXiku3FT13p7SRHdCTiTD3BwiVqLyZMliUSiU8q6QcOCLXt7e73njx8/juTkZL1F+zt27IC9vT2cnZ0hCAKys7ORkZEBf39/REdH65zD19cXXbp0QVpaGnbs2AF/f39UVlYiPj4eNjY26N27t7ZvbGwsLl++DD8/P23FueLiYu2ox+DBg416re7ujezadgO++uorAMD48eMb3VB35syZeOGFF/DTTz/hww8/BADMnTsX3333Hd577z0IgqBTGKJBwzS9efPmYcOGDejduzekUinS09Oxf/9+DB48GBs3bmw2xrvuugvR0dE4dOgQdu7ciUmTJmHp0qWYNm0a7r33Xtx7773acuAJCQm45557MHHiRACam2Zj+7aWyMhIBAUFoU+fPvDz80N+fj7WrFkDmUyG+++/v1WvRYZlZ2frlJonIiLTc7YS8P0YKb4f03S/a0eUrtXdTcCuqU1/GDYqQIJRATcY4D86d+6M+bUSPLarPZR6oPbC5MlSa/Lw8EBaWhqSk5MBaMqJDx48GOHh4QYTiuHDh8PV1RVJSUk4evQoLCwsEBQUhL59+8LW9uoOav7+/qiqqsLFixdRU1MDURRha2urraB3/TS+tqZSqfDrr7/C3t4ekydPbrTftGnT8O9//xtbt27FokWLYGdnh+joaAQHByM1NRXh4eEGi2f4+fkhPj4eL7/8Mnbu3ImYmBjI5XK4urpi4MCBePLJJ42O9Z133sG4cePw8ccfY+zYsZgyZQp27NiBV199FatWrYJSqYSPjw9efvllvPHGGzr7JrWkb2t4+umnsW3bNu1aMAcHB3Tt2hUvvvgipkyZ0qrXIiIiotaVkJCA+7v3xL/2A5X1po6GOgqzqIZHRARopt9aWVmZOgwiImqHGiqqPrtPha9jRajM7A6X1fDaJ7PZZ4mI6PLly6YOgYiI2qmGpRlze0rMLlGi9ovJEhGZjWs3lyMiImqJhu1DursJGOQNSDiIQ62AyRIRmQ1OwSMioht17eyEeb0kUHN0iVoBkyUiMhshISGmDoGIiDqA+0IEOFqaOgrqCJgsEZHZOHfunKlDICKidio8PFz7vaVMwJORAqScikc3ickSEREREbV7WVlZOo/nsNADtQImS0RkNjw8PEwdAhERtVOVlZU6j0OcBQzzA0eX6KYwWSIis2FpyQnmRER0YwwVCZoXxdElujlMlojIbGRmZpo6BCIiaqeCg4P12iYHC3CzNkEw1GEwWSIiIiKidi8+Pl6vTS4V8FRPFnqgG8dkiYjMRmhoqKlDICKiDubJSO65RDeOyRIRmY3c3FxTh0BERO2Up6enwfbOjgLGBNzaWK7nbw84WJg2BroxMlMHQETUoLy83NQhEBFRO9VYsgQAm++RolZ5C4O5jrVMs/cTtT9MlojIbFhY8GM3IiJqfVYyAVa866UbIIiiyFmcRGQWRFGEIPCTNyIiIjIPXLNERGbj7Nmzpg6BiIiISIvJEhERERERkQFMlojIbLi7u5s6BCIiIiItJktEZDZsbW1NHQIRERGRFpMlIjIbGRkZpg6BiIiISIvJEhERERHRzTqbDsSmmzoKamUsHU5EZqOyshJ2dnamDoOIiKjlhCmAmz1QsMLUkVAr4sgSEZmNwsJCU4dARER04worgJo6U0dBrYjJEhGZjdLSUlOHQEREdHN2nDF1BNSKmCwRkdmQyWSmDoGIiOjG+Lpq/lx32LRxUKtiskREZiMiIsLUIRAREd2cLSc4Fa8DYbJERGbj7Nmzpg6BiIjo5tQqgJ2citdRMFkiIrPB4pxERNTuySTAWk7F6yiYLBGR2XB1dTV1CERERDdHqeZUvA6EyRIRmQ0HBwdTh0BERHTzOBWvw2CyRERmIz2dO58TEVEHIJOwKl4HwWSJiIiIiKg1cSpeh8FkiYjMRlBQkKlDICIiah01CmBXrKmjoJvEZImIzEZpaampQyAiImodMgmw9pCpo6CbxGSJiMxGcXGxqUMgIiJqHbdqKl5pFTDna8B9NmA7Exj+OnA6zfjjE7OBsW8Bdg8ALg8DD/0PKCjT7/fuBmDSe4DHo4AwBXhjTau9BHPGZIlMIiMjA4Ig4L777rul142JiYEgCHj++edv6XXJOBIJfyUREVEH0tZT8dRqYPw7wKqDwPy7gY8eBvLLgGGvAyk5zR+fXQjc+RqQmgu8Nwt4aRLwxylg1JuAol6372urgBOpQK/AtnktZkp2Ky+WkJCA3NxcFBQUoLy8HKIoYs6cOQb75ufnIyUlBYWFhSgqKoJSqcTQoUPRtWtXg/1ra2sRGxuLS5cuobKyEhYWFnB2dkZERAQCAgKMik8URZw7dw6JiYmorKyElZUVgoKC0KdPH8jlcr2+aWlpOH/+PEpLS6FWq2FnZ4egoCBERkbCwsKiRe9Na/i///s/fPDBB/juu+/wxBNP3PLr36zS0lK89tpriI6OxmOPPWbqcMgEevToYeoQiIiIWk9DVbx7+t/Y8cMWAQGdgJ+eNfz8hqPAkSRg/UvA1EGatumDgND5wH/XAqteaPr8720EqmqBUx8D/u6atn4hmmTppz+BOaOv9k3/RhNLYblmFOs2cUs/xm1IZqytrWFjY9Nk38zMTCQkJEChUDS7UaVSqcSWLVtw/vx5+Pr6YvDgwYiMjER1dTV2796NhIQEo+I7evQojh07BmdnZwwaNAhBQUGIj4/Hrl27IIqiTt8TJ05g//79kEql6N27N/r37w9nZ2ecOnUK27dv1+tPujp37ozKykqsWrVK21ZaWoqlS5fijz/+MGFkZErnzp0zdQhEREStR6kGfjvedlPxNhwFPJyAKQOutrk7ahKmLceBuvpGDwUAbDwGTOhzNVECgJE9gVBvYN0R3b4BnVot7Pbklo4sTZw4EXZ2dhAEATt37kRVVVWjfbt164aePXtCLpfj4sWLyMvLa7RvRkYGysrKMHDgQERGRmrbw8PD8euvvyIxMRHdunVrMrbi4mLEx8cjICAAo0dfzaLt7e1x5MgRpKWlITg4GACgVqsRHx8PNzc3jB8/HoIgaGPev38/UlNTUVRUBDc3N6Pel9uRIAiwtbU1dRhkZlQqlalDICIial0NU/FudHSpKWfSgegg4Ppp7P1CgG/3AMk5QGRnw8deLtJM2evTRf+5fiHA9lOtH287dEtHluzt7bWJRXNsbGz0pr41RqFQAIDezbeFhQXkcjlksuZzwrQ0zUK4a5MtAAgLC4NMJkNKSoq2Ta1WQ6lUwtraWu/1NIyYGRu7qXzxxRcICQmBhYUFbGxs0LNnTyxfvhxqtVqnnyAIGDRoEP766y9ERUXB0tISdnZ2GDVqlMENRPfs2YPu3bvDwsICjo6OmDRpEg4dOqS3Pun6NUsxMTEIDNTMgd20aRMEQYAgCHBzc0NOTk6Ta42mT58OQRCQlJSk075mzRoEBwdDLpfDxcUFDzzwQKPV1urq6vDyyy+jc+fOkMvlsLGxQZ8+fbBx48aWvK10k5ydnU0dAhERUetqyw1qr5QAXgb+72xoy2micNKVEt2+1x9fXNn8yNRt4JaOLLUVHx8fCIKA48ePQyaTwcXFBQqFAnFxcairq0OvXr2aPUdBQQEEQUCnTrpDjDKZDK6urigoKNBp8/LyQnZ2NmJjYxEYGAiJRIKcnBwkJCQgODgYjo6OzV5ToVDoJSeNkclkRiV9xnj22WexZMkSBAUFYd68eVAoFFi7di2eeOIJ5Obm4v/+7/90+mdlZWH8+PEYPXo0Jk2ahL///hu7d+/Go48+it27d2vXZx04cADjxo2DjY0NZs2aBU9PT2zbtg0PPfRQszGFh4dj0aJFePvtt9G7d2/MmDEDgCb5dHJyavFrXLduHR544AG4urri0Ucfhb29PdavX48jR47o9a2vr8edd96J06dPY9iwYXjwwQdRXV2NtWvXYubMmVi2bBkeffTRFsdALdfclFsiIqJ2p2EqXq0CsGpiTXu9Eiir1m+rq9esE7qWi51mNKlGAVgauD9suE6NovHrNTxnaeADfiv51T6Gnr+NdIjSU46Ojhg5ciRUKhV27tyJVatWYcOGDcjKysKECRPg7+/f7DmqqqpgZWUFqVSq95ytrS1qa2t1pgiNGDEC3t7eOH78ONauXYvVq1fjwIEDiIyMxPDhw42Ke9euXfj555+N+oqNjTX6/WhKUlISli5dii5duuDQoUP4/PPPsXTpUpw9exbW1tb49NNPkZmZqXPM5cuX8cknn2Djxo146623sGvXLgwbNgwHDx7E2bNntf3mz58PAPjll1+wfPlyvP/++zh9+rRRyY6Hh4e2qEPnzp3x0ksv4aWXXsIzzzzT7Pq266lUKvzrX/+CjY0Ntm7dim+//Raffvopzp07h9raWr3+n332GY4fP463334be/bswbvvvovPP/8cFy5cgIuLCz744AOUl5cbuJJhxcXFqKu7Oje5srISFRUV2scKhQJFRUU6x1y5cqXJx7m5uTrr4DrqNZKSkjrE6+A1eA1eg9fgNW7PazRKIgCC0PQ1Dl/QFE649utIErDmkH57ZqHmGGsLVJfo3qPk5uZCbFgjZW3R+Ouw1iRUyqoavddRWViiPR7Qf68A4Nrl+eb682juGsZo0VBFXV1dixZgR0REwMrKqsVB3QgLCwu4uLggLCwMrq6uqKqqQlxcHHbt2oUJEyYYVSSisbLFDQmUUqnUfi+VSmFvb4+QkBD4+fkBANLT03HmzBlIpVJER0c3G/OAAQN0fuhNcXBwMKpfczZs2ABRFPHQQw/By8tL2+7j44MHH3wQy5Ytw+7du3Wq6QUFBWlHehqMGTMGMTExSE5ORt++fZGXl4f4+Hj06dMHd999t7afXC7Hyy+/jJkzZ7ZK/MY4deoU8vLycPfdd6Nfv37adkdHRzz99NN44403dPqvWLECnp6eGD9+PLKzs3WeGzZsGNavX4+0tDSjRigBwMXFReexnZ2dzmMLCwu9v4/X/iwMPfb09LwtrtHw76q9vw5eg9fgNXgNXuP2vIZBMqmmAIOlvOlr9AwA9vxX99gXfwI8nYH/TNZt93T650U4w6ZM917S09MTyI3XPPB2afx1eGlGlmQFFXqvw66iXjN69c+o0vXvFQBcuxLFXH8ezV3DGC1KlhQKBU6fPm10/5CQkFuSLGVlZWHnzp0YO3asNnEBgMDAQKxbtw6HDh3C5MmTmziDZpqboVEH4Oqi84ZpcA3V91xdXTFy5Ehtv+DgYOzduxenTp1CUFBQsyMq7u7uTT7fFhrWXhkq0dyQ4DWs32rg5uamcwMLXP0L3DA9sWH9kq+vr956rfDw8FaI3HgXL14EAHTp0kUvAY6KijLYv66ursmy1VeuXDE6WaIbZ2yZfyIionZDqQKmD26+n7OdphLd9W1ezvrtDaICgIOJmv2Wrr3n+TsFsLHUVLVrjI8r4O4AnDSwge3xFCDq9tpPqTEtSpbs7e0b3RfJlM6ePQuZTKaTKAGa9S6enp7IysqCSqUyOMWuga2tLUpLSw32u36K3sWLF1FWVoa+ffvqnScoKAgXL15Ebm5us8lSbW2t0WuW5HK5yYpGSCQSk28W2lRhEKVSeVPnFkURPj4+eOedd2BpaWmwT58+fW7qGmScysrKG1qjRkREZLZsLYFRjSQ7N2vqQE358E3Hru6zVFgOrD8CTOyju94oLVfzZ5drRmzuGwis+BPIKgT8/qnivC9OU0XvhYltE3M70yEKPFRVVUEURYiiqHdT3dDe3L5H7u7uyM7ORn5+vs4QnVKpRFFRkU5bQ8lzQ+dsaDMmCdqzZ4/Rcyejo6Nb5YY9NDQUABAXF4d7771X57kzZ84A0IzItFTDiEB2djbq6+t1ErvExESjztFUQtQw9FpSUqL33PVV+YKCggBoRsjUarVOomdo7Vfnzp2Rl5eHYcOGcWTDxAoLC+Hr62vqMIiIiFqHTArc27/tiiRMHQgMCAUeXQIkZANu9sBXOwGVGnhTdwkF7vpnil/Gsqttr9ynSayGvw48Nx6orAU+3qIpN/7oCN3jf4kBLhUA1f9M+/srAXhnveb7h4YCnTvmPkwdIllydnZGWVkZLl68qHOjX15ejitXrsDFxUWnklx5eTnUarXOJ9hdunTBmTNncO7cOZ3E6MKFC1Aqldo9lhquBwDJycl6iUVycjIA6FXVM8QUa5buu+8+vPbaa1i5ciXmzp0LDw8PAEBOTg5WrlwJV1dXnX2mjOXp6Ynu3bsjNjYWO3bswKRJkwBoKs19+OGHRp2jYe5pWVmZXuIbGBgIqVSK06dPo6qqSlsm/voiEwDQu3dvdOrUCX/99ReOHz+OAQM0G7WVl5fj66+/1rvuI488gtdeew3//e9/8cMPP+hVHczKyoK3t3eTI5NEREREeoydgnejpFJg+2vAf1YAX/6hqV7XNxj46Vmgq0/zx/u5AQfeBv79E7BwJWAhA8b3Bj6drZ/g/bAPOHD+6uM/4zVfADAknMlSa7h06ZK2SkVZWRkAaNdAWVhYICIiQtu3oqJCu76mYTTh0qVL2lGdkJAQ7TqaqKgoZGVl4c8//8SVK1e0BR4SEhKgUqn0pstt27YNlZWVOlMKXVxc0L17d5w/fx67d++Gv78/SkpKEB8fDy8vL51kyd/fH+7u7sjKysLvv/+u3R8oPT0dubm5CAoKMmpD2rZas7Rx40aDa8u6deuG+fPnY968eViyZAkGDx6MSZMmaUuHV1dX45VXXjGqeqAhX375JUaPHo2HHnoIU6ZM0ZYOb/iZNbfHlqurK/z8/HD8+HE8//zzCAgIgI2NDR5++GHY2dnh/vvvx6pVqzB69GjcdddduHTpEjZt2oTOnTsjIyNDex6pVIovvvgCs2bNwsSJEzFlyhTY29tj3bp1BtfQLViwADt27MDPP/+Ms2fPYujQoXB1dUVmZiaOHDkCtVqNEydO6K3botZnaE0ZERFRu2VrCYyOuvHjY95uvo+zHfD9PM1XU64dUbpWd39g1+utE0sHdEuTpfT0dO3IS4OTJ08C0IwqXJ8sNTzXICMjQ3tT7Onpqb157dSpEyZPnowzZ84gPT0diYmJkMvl6NSpE6KiouDt3cTitmsMHDgQ9vb2SExMRGZmJqysrBAREYE+ffro3OhLJBKMHz8esbGxSE9Px99//w1BEODg4IB+/fo1WSjgVti5c6fB9qFDh2L+/PlYvHgxgoKCsHTpUixevBgymQwhISH48MMPMXv27Bu+7ogRI7B161a8+OKLWLlyJWxsbDB06FDMmzcPY8eObXQ90LXWrFmDp556Ct988w0UCgVcXV0xceJEWFtbY9myZVAoFNi5cydOnjyJwMBALF68GNu3b9dJlgBg5syZUKvVeP311/Hjjz/C3t4eY8eOxfTp0/WmH8rlcsTExOCDDz7AL7/8gm+++QaAZgQxLCwMM2bMgLW19Q2/L2S88+fPo3v37qYOg4iI6ObJJG07BY9uCUFsbjEP0U1av349pk+fjgULFhg9JY9uT7GxsRxdIiKi9snvSSD7un2Xfv8/YKJ+QTBqPzrEprRkHkRRRGVlpU5bfX093nvvPUgkEowZM8ZEkVF74ejoaOoQiIiIWsfNTsEjs9AhCjyQeairq4Ofnx9GjBiBbt26oby8HNu2bcPFixcxadIkDBkyxNQhkplrKDhCRETUrskkwD2cgtcRMFmiViOXyzFixAgcPnwY27ZtgyiK8PLywvPPP493330XFhYWpg6RzFxycjKn4RERUfunVAPTB5k6CmoFTJao1UilUmzcuNHUYRARERGZFqfgdRhcs0REZuNGy9YTERGZjYYpeFacUdMRMFkiIrNRW1tr6hCIiIhuDqfgdShMlojIbOTn55s6BCIioptjwyl4HQmTJSIiIiKi1nJPP07B60CYLBGR2YiMjDR1CERERDemYUPa+webNg5qVUyWiMhsJCcnmzoEIiKim8MpeB0KS4cTkdmoq6szdQhEREQ3RiYFvJw4Ba+DYbJERGbD3t7e1CEQERHdmLjPAZXK1FFQKxNEURRNHQQREaApHW5lZWXqMIiIiIgAcM0SEZmRCxcumDoEIiIiIi0mS0RERERERAYwWSIis+Hr62vqEIiIiIi0mCwRkdlQKpWmDoGIiIhIi8kSEZmN3NxcU4dAREREpMVkiYiIiIiIyACWDicis6FUKiGTcfs3IiJq/xQqEfUqwNZCMHUodBM4skREZiMtLc3UIRAREbWK7+JEhC9XQaHiuER7xmSJiMxGTU2NqUMgIiJqFW8fVSOrAlCoTB0J3QwmS0RkNmxtbU0dAhERUavIqzZ1BNQamCwRkdnw9/c3dQhEREQ3rVLBqXcdBZMlIjIbiYmJpg6BiIjopp3IZbLUUTBZIiIiIiJqRYcvmzoCai1MlojIbHh7e5s6BCIiopt2MFtt6hColTBZIiIiIiJqJWpRxJEcU0dBrYXJEhGZjZwc/u9CRETtW0IhUFlv6iiotTBZIiIiIiJqJUdyRAimDoJaDZMlIjIb4eHhpg6BiIjophy+LELKbKnDYLJERGYjMzPT1CEQERHdlJgsEUpWDu8wmCwRkdmoqqoydQhEREQ3LK9KRGaFqaOg1iQzdQBERA2sra1NHQIREd3GSmtFLPhLjc0pIqrrgX5eAj4dJkG0h3Hz6o7kcEipo+HIEt0Sn3/+OQRBwM8//9zq587IyIAgCJg9e3arn5turS5dupg6BCIiuk2pRRHjN6mwKlHE/F4SfDRUgvxqEcPWqpBSYlwSdOSyCBnvrjsUsx5ZOnPmDAoLC1FYWIiKigrY2dnhgQceaLR/fn4+Tpw4gfz8fACAh4cH+vXrBzc3N51+paWluHDhgvbcCoUC0dHR6NOnT6vEcSvMnz8fS5cu1T4WBAE2NjYIDg7G008/jaeeesqE0bW+pKQkfPrpp5g6dSpGjx5t6nCojcTHxyMqKsrUYRAR0W1oQ5Jmf6T1EyWY2lWT8UzvKiD0BxX+e1iNVROkzZ7jQLYIJfej7VDMOlk6ceIELC0t4ebmBoVC0WTfvLw8bNu2DTY2NujduzcA4Pz589i6dSsmT54MFxcXnb5xcXFwcHCAm5tbs3u7tCSOW+2JJ55A165doVQqkZycjPXr12Pu3LkoKirCK6+8YurwWk1aWhq+++47eHl56SVLnTt3RkVFBSwsLEwUHREREbV3G5JFeNgAU0KvTrlztxEwvauAlQki6pQiLGWNT8erVYo4k38rIqVbyayTpRkzZsDBwQEAsH79etTXN77D15EjRyCRSDBp0iTY2toC0EzpWbduHY4ePYrx48dr+3bu3BmPPPIILC0tUVBQgM2bN7daHLfa+PHjcc8992gfP/roo7jzzjuxdOlSLFy4EBJJxx8LFgQBdnZ2pg6DWoGnp6epQyAiotvUmXwR0R4CJIJuQtTPS8C3cSKSS4BI98aPP5UHjir9f3t3Hh/Tuf8B/DPJTPbIvglBJAhKLNFYKqiS9tbSH4rrUnsXfrctLb2laivK75Yu2sS1VmkjiqpaekuqvRSxZaxZCEnIYssyWWcmz++PdOYaM4mJjMxMfN6v17yY5zznOd8zRzvnO89yGiCLvpPWJCgPU1BQgFu3biE4OFibKAGAs7MzgoODcePGDZSUlGjLHRwcYG9vb/I4LMEzzzwDV1dX5OXloaysDACQnZ2N4cOHw8vLC1KpFF5eXhg6dCiuXbums69mXtGGDRvwxhtvwMfHBzKZDM2aNcOKFSv0jiWRSPDss8/qlRs7P6mwsBCTJ09Gq1at4OrqCplMBj8/P4wZMwZ3797VaU+T7C5cuBASiQQSiQRt27YFUP2cJZVKhZkzZ6Jp06aQyWRwcXFB9+7dkZCQoFPv/v03b96M0NBQyGQyuLu7Y9SoUSgtLa3xPMh0pFKL/v2GiIgasOxiIMBZv1xTdlNR87ylIzcEbPh8pQanQdyZ3Lp1C0DVHKUH+fr6Ijk5Gbdv30ZQUFB9h6alSVyMYWdn98g9Qrm5uVAoFHBzc4OdnR3u3buHrl27Ijs7GwMHDkTXrl2RlJSE3bt348SJEzh16hQCAgJ02li8eDFKS0sxatQo2NraYvv27Zg1axaKi4sxf/78R4rLkIyMDMTHx6Nfv3546aWXIJPJcOTIEXz77be4cOECTp06BVtbWwwYMACTJ0/G2rVr8cILL6Bv374ADF/v+0VHR+PgwYPo2LEjxowZg7y8PMTFxeH555/Hjh078MILL+jUP3LkCHbs2IHhw4dj9OjR2LdvH+Li4uDq6op//etfJjtvql5WVpbeHEMiIqLaqhQCFWrj6trbVv0AXKqq+vuDHP68Wy5V1dzO71nsVmqILLpnyViaXiMnJye9bZqeJnM/v+Xrr782+pWTk2N0u/n5+cjKykJ6ejp++OEH9OvXD0IIREdHQyqV4r333sPNmzcxc+ZM7Nu3D4sWLcLu3buxYMECZGdnY9asWXptFhQUIDExEZ9//jlWrVoFuVwOb29vrFixQpuYmkJoaChycnKwc+dOfPzxx1i8eDESEhLw6quvIikpCT/88AMAoF27dnjppZcAAF27dsU777yDd955B2PHjq227Z07d+LgwYPo2bMnTp48iWXLlmH9+vU4ePAglEolZsyYgcpK3f+pZWRk4NChQ1i/fj0WLlyIEydOoFmzZti2bVuthl7evXsX5eXl2vcKhQJFRf996EJFRQXu3Lmjs092dnaN73NyciDEf3/RaqjHUKvVDeI8eAweg8fgMXgM8x7jYLoSjqvURr2S/xzM4mArUHZfgqU5RpkmSVKV1XgeaflA5UMWzbPEz+pJPoZRhJXYtm2b2LJli8Ftp06dErGxsSIrK0tvW1ZWloiNjRVyudzgvnl5eSI2NlYkJibWOY6aZGZmGv0qKyt7aHvTpk0TAPRednZ2YsSIEaKkpEQIIUTTpk2Fq6urUCgUOvsrlUrRqFEjERgYKCorK4UQQnzyyScCgJg6dare8WbOnCkAiJiYGG0ZANGvXz+9upp2Nm3aVGPZ/crLy0V2drbIzMwUP/30kwAg3n77be12Tdm8efP09k1PTxcAxCuvvKItGzFihAAg9u7dq1e/d+/eAoC4ePGizv69e/fWqztq1CgBQFy/ft1g3GRapaWl5g6BiIgagGxFpdhwTm3UK7+s6j4o5F9K8fx2lV5ba+VqgRVKIc+rrPGY4/eqhPT/lAIrdF9F5TXvR5atQQzD08xzUKv1+1s1ZeaeC9GkSZPH0u6sWbMQHh4OW1tbeHp6IiIiAm5ubtrtOTk5aNGihc5cLqDq8wgKCkJycjLKysp0Hgbarl07veN07NgRAJCammrS+BcsWIANGzYgIyND59cDALh3794jt5uRkQGJRIJu3brpbQsLC8Nvv/2GS5cuISwsTFtuaJiml5cXgKrP0ZzDOJ8UN27c4LOWiIiozvydJRjfvnYTiMJ9Jfg9S6BSCJ1FHo5nCzhJgVYeNe/fq4kEGy/wobQNTYNIljTD7+5fxEFDM/zuwWShvhmKrTr29vawtX34Wv4A0L17d53V8CyBSvWQQb1/mjNnDpYsWYLw8HBMnDgRQUFBsLe3R3Z2NmbOnKmXPD1uNX3m9R3Lk+r+7nQiIqL6NLyVBNtTBHakCAxvXZUs3S4RiE8WGNRSUuOy4QDQozFXd2iIGkSy5ONTtY5jbm4u2rRpo7NN84Bac08a/+abb4yu++KLL6Jx48YmOW5AQACys7NRXFyskzCqVCpkZGTA19cXDg4OOvtcuHBBr52kpCQAVfOMNFxcXFBQUKBX19jep7i4OHh7e+P48eM6z0javn27Xl2JpHb/A2rWrBmOHz+OEydO4Pnnn9fZdvnyZQDQ6VUiy1CbVSqJiIhMaXgrCSIDgAn7K3HxDuDtCHx5thJqASzo+fBp/q09gUZ2QKFlPZKT6qhBJEtubm7w8fHB1atX0bVrV51FHa5evYrAwECDiz/UpwdXXquJZuiXKURHR2PNmjVYuHAhPv74Y235xx9/jMLCQgwePFgvEfn+++8xb948BAYGAqiaULdp0yY4OTlpF1oAgKZNmyI5ORm3bt3SJqy3b99GfHy8UbFpVvy7f6EFpVKJxYsX69XVDC28f0nxmowaNQrbtm3D0qVLMWDAAG2vUWJiIn7//Xe0bt0arVu3Nqotqj+tWrUydwhERPSEsrWRYO8wW7x7uBKfnalEqRKI8Ac2Pm+L1p4P/9HWRiJBr0BgX3rVRHJqGCw6WUpJSYFCoQBQtfS2Wq3G6dOnAVT1atx/Y9W9e3fs2bMHu3fvRvv27QEA58+fhxACkZGROu1WVFTg/PnzAP47PC4nJ0fbdrNmzXQSltrEUZ3HNWfpYZYtW4Y9e/ZgxYoVOH/+PDp37gy5XI4ff/wRAQEBWL58ud4+bm5uiIiIwPDhw2Fra4v4+Hjcvn0bc+fOha+vr7betGnTMH36dPTo0QMvv/wyCgoKsG3bNvj6+iI/P/+hsQ0ZMgT/93//h8jISAwePBhFRUX44YcfDC6b3qlTJzg6OmLbtm1wd3eHl5cX/Pz8MHr0aINtv/TSS3j22Wdx8OBBREREIDo6Gnl5efj2228hk8nwySefPBEP7LU2586dQ3h4uLnDICKiJ5SHgwRrB9pi7cBH279XExscuFbVG0UNg0UnS8nJyXpL/J08eRJA1fCy+5MUf39/DBo0CImJiUhMTIREIoGfnx+ee+45vZ6a8vJybTsaN2/exM2bNwFUzW+6f5/axGFpPDw8kJiYiL///e9ISEjAgQMH0KhRIwwaNAiffvqp3jOWAGDu3Lk4ceIEtm7dioKCAgQEBGDp0qV47733dOpNmzYN169fx4YNG7B8+XL4+vrijTfegJubG2bMmPHQ2JYtWwaVSoVvv/0WS5cuhZubG5577jnMnj0bnTp10qnr6OiItWvX4oMPPtDuFxYWVm2yBAD79+/H7NmzERcXhxUrVsDe3h4dOnTARx99hH79+hn5CRIREREZp2djCROlBkYiOHOd/rRy5UrMmDEDmzZtwrhx48wdDj2Bbt68abL5ekRERPWtVCng+plaJ2Eq+rstXOy4+IO14jgkIrIYDy42QkREZE0cZRJ09DF3FGRKTJaIyGJkZGSYOwQiIqI6iWoqgYx32A0GLyURERERkYn0aCyBsvLh9cg6cM4SEVmMkpISsy/zT0REVBfZCoHGMWrte85Zsm7sWSIii5Gbm2vuEIiIiOokwEWCJi7mjoJMhckSEVmMgoICc4dARERUZ72bsiepoWCyREQWQyaTmTsEIiKiOusVyGSpoWCyREQWo127duYOgYiIqM56NGay1FAwWSIii3H27Flzh0BERFRn7b3NHQGZCpMlIiIiIiITsrVhz1JDwWSJiCyGtzd/iiMiooahk2/Vn3xGj3WTmjsAIiINFxeutUpERA3D58/a4rvLlXDm2kVWjQ+lJSKLcfbsWYSHh5s7DCIiIiIAHIZHRERERERkEHuWiMhiKBQKDsUjIiIii8GeJSKyGHfu3DF3CERERERaTJaIyGLcu3fP3CEQERERaTFZIiKLYWtra+4QiIiIiLQ4Z4mIiIiIiMgA9iwRkcWQy+XmDoGIiIhIi8kSEVmMyspKc4dARERkMl9fUONMLgdxWTOpuQMgItLw9PQ0dwhEREQm88o+AVuJGqqZvOW2VuxZIiKL4e7ubu4QiIiITErNjiWrxmSJiCzG1atXzR0CERERkRaTJSIiIiIiIgOYLBGRxWjRooW5QyAiIiLSYrJERBajsLDQ3CEQERGZlMTcAVCdMFkiIotx584dc4dARERkEkJUrexgZ8MVHqwZkyUishgSCX9/IyKihkH556MDZTZ8hqA1Y7JERBajY8eO5g6BiIjIJCrUVX86ymzNGwjVCZMlIrIY58+fN3cIREREJlH+Z7JkI5TmDYTqhMkSEVkMlUpl7hCIiIhMQpMs2Uk4DM+aMVkiIovh7u5u7hCIiIhMovzP3//spbzdtmZScwdARKTh7e1t7hCIiIh05JcJzPqtEjtTBUqUQLcACf7Zxwad/WpelEjTs+RkxzlL1oypLlmk6Ohoroz2BEpLSzN3CERERFqVQuAvO9TYeklgeicbLI+yQV6JQJ84NVLv1bwkuCZZEsqyeoiUHpd661k6c+YMbt++jdu3b6OoqAguLi7461//Wut2UlJScO7cOeTn58POzg5BQUHo1q0bHB0da9zv+PHjSEpKglQqxcSJE/W2l5WV4ezZs7h+/ToUCgXs7Ozg4eGB9u3bo3nz5rWO09Q2bdqE8ePHQyKR4MKFCwgLC6uX4y5duhTvv/++TpmdnR08PT3Rq1cvLFq0CG3atKmXWIiIiIjq0/ZkgaM3gfhBNhjeuqqP4eXWErRap8aHRyqx9cXqe400q+HJ+Jwlq1ZvyVJiYiLs7e3h7e2NioqKR2pDLpfj2LFjCAgIQI8ePVBcXAy5XI68vDwMHToUMpnM4H63b9+GXC6HTCbTPiDsfiqVCj/88AMUCgXatGkDLy8vlJWVISUlBT///DN69eqFtm3bPlLMprJ27Vp4eXmhoKAAq1atQmxsbL0ef8SIEejWrRsAoLCwEImJifj+++9x6NAhpKSkwMvLq17joYbJEn6YICIi0tieIuDnBPxPq/+OdvFxkuDl1hJ8c1GgXCVgLzU8EkbTs+TmbF8fodJjUm/J0qhRo9CoUSMAQHx8PJTK2i2jWFZWhpMnT8LHxwd/+ctfYGNTld37+PjgwIEDOH/+PDp16qS3X2VlJX7//Xc0bdoUSqUSt27d0qtz7do1FBQUoHv37njqqae05WFhYdiyZQsuXbpk1mQpIyMDf/zxB6ZMmYJz585h586d+Oqrr7SfQX2IiorCtGnTdMpGjRqFuLg4xMfH47XXXqu3WO53584dJmoNSHFxMRd5ICIii3EmT6CznwQ2D0wN6BYgwRq5QMo94Ckfw/uWq6t+oLcR6scdJj1G9Xa3rUmUHtW1a9egUqnQrl07nSShWbNmcHV1RWpqqsH9zp8/j3v37qFnz57Vtq3p6XJ2dtYpt7Ozg0wmg1Rq3nUwPvvsM1RWVmLatGl45ZVXcOvWLcTFxWm3Hzt2DBKJBKNGjTK4f79+/SCVSpGRkaEtu3LlCoYOHQpvb29IpVJ4eHhg0KBBuH79utFxNW7cGABgb6/7i0llZSXmzZuHli1bwt7eHg4ODujQoQPi4+P12lAoFBgzZgw8PDxgZ2eH0NBQbNmyxeDxnnrqKfj4+CApKQnPPPMMXFxctAsCaOY43bhxA9HR0XB1dYWDgwN69OiBq1evAgAWLFiAwMBAyGQyBAYGYs2aNXrHWL58OUJDQ+Hk5AR7e3v4+vqif//+Op8dPT6GfswgIiIyl+xiIMBZv1xTdlNR/RA7zllqGKxmNby8vDwAgJ+fn942Pz8/pKWlQalU6gzFKyoqwsmTJ9G5c2e4urpW23ZgYCAkEglOnDgBqVQKT09PVFRUQC6Xo7y83GCP1YOEECgvLzf6fOzt7Y1ewGDbtm1o37492rdvj1atWuGdd97Bv/71L4wePRoAEBkZiZCQEOzfv1/vM7h9+zaOHDmCiIgIBAUFAQAuXbqEnj17QqVSYejQoQgJCUFqaiq2b9+OyMhIyOVy+Pjo/kxSUFCArKwsAEB+fj4OHz6MdevWwd/fH8OHD9epO2DAABw6dAi9e/fGyJEjUV5ejp07d2LUqFHIz8/HlClTtHUHDhyIo0eP4umnn0b//v2RlpaGSZMmwdfX1+BnUVZWhn79+qFDhw6YMWMGcnNzdbZHRUXBz88Pb731FlJTUxEfH4/nn38eL7zwAr777juMGDECDg4O2LhxI15//XVERkaiQ4cOAKoSpdmzZ6Nt27Z488034ejoiIyMDPz666/IysrSfn5ERERkfSqF0M4jehh7W0AikaBUVfX3Bzn8eQddWsPjAbXPWeKcJatmNclSSUkJAP3eHwBwcnICoD+E5z//+Q8aNWqkvRmujpubG/r374+jR49i//792nJHR0e8+OKL8Pf3f2h8CoUC3377rTGnAgAYPXp0jQmcxr59+5CZmYnXX38dQFVvV3R0NHbu3ImcnBxtbCNHjsRHH32ELVu2YPz48dr9Y2JiUFFRgXHjxmnLJk6cCJVKhcTERLRu3VpbPm7cOERHR2POnDl6vS5z5szBnDlzdMrCwsKwZ88enfOIiYnBwYMHMX/+fHz44Yfa8qVLl6Jt27aYM2cOJk2aBBsbG2zZsgVHjx7FwIEDdT73NWvW4NVXXzX4eSgUCkyYMAHr1683uL1Dhw7YsWOHTllcXBzu3LmDy5cva3uiXnzxRURFReGf//wnNm3aBADYvXs3HBwccObMGdjZ2Rlsnx6vjh07mjsEIiJqoH7LFOi7zbgHxF6aYIs2XoCj9L9Jz/3K/kySHGu4k9YkZn7eHrWMlCyJ1SwdrlJV/au0tdVP7zXD5DR1gKoliDMzM9GrVy+j5vZoVnjr0qULBgwYgJ49e0IqleLAgQO4c+fOQ/d3dHTECy+8YPTrYav3aXz55Zewt7fXmRP0xhtvQKlU4osvvtApk0ql2ht/je+++w7Ozs7aBOrWrVs4fvw4nnnmGTg7OyMrK0v7CgsLg7+/P3777Te9OCZPnoytW7di69atiI2NxeTJk5Geno7nnnsOOTk52nrffPMNHBwcMH78eJ228/Ly8Oyzz+LWrVs4ffo0AGD79u0AgHnz5ukca+rUqdohfoYsXbq02m1z587Ved+nTx8AwODBg3We4dO7d284Ojpqh+gBgKurKyoqKrBx40ZUVj7607bv3r2r08uoUChQVFSkfV9RUaH3byo7O7vG9zk5OTqLkzTUY8jl8gZxHjwGj8Fj8Bg8huUdw0OVhw3RNtrXyshCnferuhdh/UAJNkTbIMCl6hj+TgLZxfrH0JQ5qQqqjVvzLNq79/5bx1o+qyflGEYRZrBt2zaxZcuWWu2zb98+ERsbK5RKpd62P/74Q8TGxop79+4JIYQoLS0VX3/9tTh8+LBOvd27d4t169bp7Z+RkSHWrFkjMjIydMqLi4vFhg0bxK5du2oVq6ncu3dPODg4iG7duonTp0/rvPz9/UWLFi106vfs2VPIZDJx69YtIYQQ586dExKJRLz00kvaOvv27RMAanz5+vpq6y9ZskQAEF988YVefJ9++qkAIMaOHastCwwMfGj7O3fuFEII0blzZyGRSERZWZle2z169BAP/vNs3769cHV1NfhZDRw4UAAQFRUVOuXx8fECgFi0aJHePt7e3uKpp57Svj916pTw9fUVAISLi4vo2bOnWLhwobh9+7bBY5LpnTlzxtwhEBERaQ3/QSX8ViuFurJSp3zKAZVwWqkUZcrKavYUYneaWmCFUjy3ifcR1sxqhuHdP9TOzc1NZ9uDQ/ROnz4NpVKJNm3aoKDgv9m8puepoKAAtra2cHFxAQDt85eaNm2qd0x/f39kZmZCrVYb7NXSqKysRFmZ8RP4HBwcHtrj9dVXX6GsrAwnTpxA586dDdZJSEhA3759AVQNozty5Ai++uorfPDBB1i9ejWEEJg6daq2vvgzQ+/fv7/B500Bhoc6GjJy5Ei8+eab+OOPP3Tad3V1rXFp88jISKPaN+TBxSQeVN3y8dVdO3HfLxadO3dGeno6tm3bhgMHDiAxMRHz5s3DypUrcejQIYSHhz9y3GScui4EQ0REZErDW0mwPUVgR4rA8NZVc81vlwjEJwsMaimpdtlw4L9znYSt4XsTsg5Wkyz5+vri8uXLyM3N1UuWcnNz4e7urr1RLioqgkqlwq5duwy2FRcXBw8PD4wYMQJAVQImhIAQQm/RBU35/TfVhhQXF5t8ztI333wDDw8PLFq0SG9beXk53n33XaxevVqbLL3yyit455138N133+GDDz7Arl270LhxY0RHR2v369ChAyQSCZRKpXaBiEel6QrVJKsA0LRpU5w4cQLR0dHw8Kh5jG5QUBBOnz6NU6dOoUePHjrbrl27VqfYHpWTkxPGjx+vHba4ceNGTJgwAQsXLtSbC0WmZ8z8QCIiovoyvJUEkQHAhP2VuHgH8HYEvjxbCbUAFvSs+Udve9s/7ymlDvUQKT0uFpksKRQKqFQqNGrUSNv70qxZM9ja2uLChQsICQnRll+/fh1FRUXo2rWrdv/w8HCEhobqtXvq1CkUFhaib9++OhP4PTw8UFBQgKtXr6Jly5ba8sLCQmRnZ8PT0/Ohy4dr5iwZ62Fzlk6ePImLFy9i+PDhes830ti4cSP279+PkpIS7VLX0dHR2L59Oz755BPk5OTgf//3f3X2CQwMREREBH7//Xfs3btXL+bKykqjV37buHEjgKqFHjTGjh2L48ePY8qUKdo5SfdLT09HixYtAADDhg3Drl27sHDhQr0FHm7evPnQ45taVlYWmjRpolPWu3dvAFUrANLjl5KSwh48IiKyGLY2EuwdZot3D1fiszOVKFUCEf7Axudt0dqz5lWNNT1L+YoSAFw4ylrVW7KUkpIChUIBoGr5Z7VarZ3o7+LiglatWmnrJiQkIDs7W6f3xdHRERERETh27Bh++uknhISEoLi4GHK5HO7u7joPkzW0vDgAXLhwAUVFRQgODtYpDw8PR2Zmpva4Xl5eKC4uxsWLF6FWqxEREfHQ85NKpXo32nXx2WefAUC1z04CqlZ0W7p0KdasWYO33noLAPDqq68iPj4ec+fOhUQiMZhobdq0Cb169cLgwYMxcOBAdOrUCWq1GlevXkVCQgKGDh2qtxre4cOHUVpaCqCqF+3UqVPYu3cvHB0dsXjxYm29adOmYc+ePfj+++8RFhaG/v37w8fHB5mZmTh16pR2sQcA+Nvf/oYvvvgCBw4cQGRkJJ577jmkpaVh586daNq0KTIzM+v0GdZW79694erqim7duiEoKAj37t3D9u3bIZFIdFYTJCIioieHh4MEawfaYu3A2u2nSZaUlcY9KoYsU70lS8nJyXorUJw8eRIAEBAQoJMsVadDhw6wt7fHuXPncPToUchkMgQHB+Ppp5+udq6KMXx9fTFkyBCcOXMG6enpuHTpEmQyGXx9fREeHl7jymyPg1KpxI8//ghXV1cMHTq02noTJkzAsmXL8PXXX2uTpWeffVabaISHh+ssDa7Rpk0bnD17FrNnz8ahQ4fw888/QyaTwdvbG3369MGECRP09omPj9c+VNbGxgZubm7o27cvli5dqtOrB1Qtd758+XJs2rQJa9euhUqlgru7O1q3bq23Wt2///1vTJ06Ffv27cPp06fRrFkzrFu3Dps3b673ZGn8+PHYuXMn4uPjoVAo4OLigtDQUPzzn//UDtmkx4vPsiIiooZC+3wmDsOzahLxsMk4RET1JDs7GwEBAeYOg4iIqM7S7gmErlOjjZsKl6YwYbJWVvOcJSJq+HJzc80dAhERkUloepZKlAaeaktWg8kSEREREZGJcc5Sw8BkiYgsxv0LtRAREVkz+z9XBhA2XAnPmjFZIiKLkZqaau4QiIiITELTs1TKYXhWjckSEVmMsrIyc4dARERkEnZ/Jkvlag7Ds2ZMlojIYmieq0ZERGTtbCRVSZJSMFmyZkyWiMhiBAYGmjsEIiIik1IzWbJqTJaIyGJcvnzZ3CEQERERaTFZIiIiIiIiMoDJEhFZjCZNmpg7BCIiIiItJktEZDHUai6vSkRERJaDyRIRWYzs7Gxzh0BERGQy3QOAyS3yzB0G1YHU3AEQERERETVEh0fZ4rw8D0Bjc4dCj0gihBDmDoKICACUSiVkMpm5wyAiIjIZfrdZNw7DIyKLkZ6ebu4QiIiITIrfbdaNyRIRWYySkhJzh0BERGRS/G6zbkyWiMhiODs7mzsEIiIik+J3m3XjnCUishgVFRWws7MzdxhEREQmw+8268aeJSKyGBcvXjR3CERERCbF7zbrxmSJiIiIiIjIACZLRGQxGjfmcyiIiKhh4XebdWOyREQWQyKRmDsEIiIik+J3m3VjskREFuPGjRvmDoGIiMik+N1m3ZgsERERERERGcClw4nIYpSXl8Pe3t7cYRAREZkMv9usG3uWiMhiZGZmmjsEIiIik+J3m3VjskREFkOhUJg7BCIiIpPid5t1Y7JERBbDwcHB3CEQERGZFL/brBvnLBGRxVCpVJBKpeYOg4iIyGT43Wbd2LNERBbj/Pnz5g6BiIjIpPjdZt2Y5hKZkFqtRkpKirnDsFpXr17likFERNSg8LvNcrVq1Qq2trY11mGyRGRCKSkpaNu2rbnDICIiIqKHuHjxIsLCwmqswzlLRCbEnqXHS6FQoFu3bjhx4gRcXFzMHQ7VEa9nw8Fr2bDweppOTk4O+vXrh0OHDsHf37/ej89rWTNjepaYLBGR1SgsLISbmxsKCgrQqFEjc4dDdcTr2XDwWjYsvJ6mk5WVhaZNmyIzMxNNmjSp9+PzWtYdF3ggIiIiIiIygMkSERERERGRAUyWiMhq2Nvb48MPP+SqQg0Er2fDwWvZsPB6mk6jRo0QFRVltiFwvJZ1xzlLREREREREBrBniYiIiIiIyAAmS0RERERERAYwWSIiIiIiIjKAyRIREREREZEBTJaIyKyWLl2KESNGIDg4GBKJBM2bN6/V/hs3boREIqnxdePGjccTPOmo67UEAKVSiS+//BJdunSBu7s73N3d0blzZ3z66aeoqKgwfdBULVNcT4VCgVmzZqFly5awt7eHv78/JkyYwP8m61lKSgrmzZuHyMhI+Pj4wNXVFeHh4fjoo49QXFxsdDt79+5Fjx494OzsDE9PT4wYMQLp6emPMXJ6kCmu5bZt2zBhwgR07NgRMpkMEokE165de7yBWzGuhkdEZiWRSODp6YnOnTvj1KlTaNSoUa3+p3316lUcPXpUrzw7OxuzZs1Cp06dcPr0aRNGTNWp67UEgDFjxmDr1q0YNmwYnn32WajVavz444/4+eef8fLLLyMuLu7xBE966no9S0tL0atXL5w5cwbjxo1D9+7dkZ6ejtWrV8PDwwMnTpyAv7//4zsB0nrvvfewevVqDB48GJGRkZDJZEhISMC2bdvQoUMHHDt2DI6OjjW2sWPHDgwfPhwdO3bElClTUFBQgFWrVsHW1hYnT55E48aN6+lsnmymuJZ9+vTB8ePH0bFjR+Tn5yM5ORnp6emP9IPIE0EQEZnRlStXtH9v166daNasmUnaXbJkiQAgvvjiC5O0Rw9X12t548YNAUAMHTpUp7yyslL06tVLSCQScffuXVOESkao6/VcuXKlACCWLFmiU37kyBEhkUjEpEmTTBEmGSExMVHk5+frlc+ZM0cAEJ9//nmN+1dUVIjGjRuLoKAgUVRUpC0/c+aMsLGxEVOmTDF5zGRYXa+lEEJcv35dKJVKIYQQ06ZNEwBEenq6qUNtMDgMj4jMKjg42ORtCiGwfv16ODo6YsyYMSZvnwyr67UsKioCAL1fqCUSCQICAmBjYwMHB4c6HYOMV9frmZCQAACYMGGCTnmPHj0QGhqK7777DmVlZXU6Bhmna9eucHNz0ysfOXIkAOD8+fM17n/48GHcvHkTkydPhouLi7Y8PDwcffr0QVxcHJRKpWmDJoPqei0BICgoCFKp1OSxNVRMloiowTl8+DDS0tIwbNgwuLu7mzscMlLLli3RsmVLrF+/HmvXrsW1a9dw5coVfPLJJ9ixYwf+8Y9/PHR4CVmO8vJyAICTk5PeNicnJxQXF+PcuXP1HRbdJysrCwDg5+dXY73ExEQAQPfu3fW2RUZGorCwECkpKaYPkIxm7LWk2mOyREQNzrp16wAAkydPNnMkVBtSqRS7d+9G+/btMWXKFLRo0QIhISF477338Pnnn2PRokXmDpFqoV27dgCAQ4cO6ZRnZ2fj8uXLAIDMzMx6j4uqqNVqLFq0CFKpFH/9619rrHvz5k0AQGBgoN42TRkX7TCf2lxLqj32wRFRg5Kfn4/vv/8eISEhiIqKMnc4VEuOjo4IDQ1FREQE+vXrh5KSEmzatAnTp0+Hs7Mzxo0bZ+4QyUivv/46YmJi8Prrr6O8vByRkZG4fv063n33XajVagBASUmJmaN8cr311lv4448/sGTJErRu3brGuprrZG9vr7dNMzSW19J8anMtqfbYs0REDcrWrVtRWlqKSZMmmTsUqqWcnBxEREQgKCgIX375JYYPH45x48bh3//+N7p164bp06fj3r175g6TjBQSEoKffvoJzs7OGDVqFJo3b46oqCg0adJE2+vbqFEjM0f5ZPrggw/wxRdfYOrUqfjHP/7x0PqaoZSaoZX308w7MzTckh6/2l5Lqj0mS0TUoKxbtw5SqRTjx483dyhUS2vWrMGdO3cwYsQInXIbGxsMHz4cRUVFXAbeyvTp0wepqam4cOECDh8+jIyMDHz//fe4ffs2AKBNmzZmjvDJM3/+fCxevBgTJkxATEyMUftoFl0xNNROU2ZoiB49Xo9yLan2OAyPiBqMs2fP4vTp0xgyZAif32KFNDddmiFa91OpVDp/kvWQSCRo27at9n15eTkOHTqEkJAQtGrVyoyRPXnmz5+PBQsW4JVXXsHatWshkUiM2i8iIgIA8Mcff6B///46244dO4ZGjRrxWtazR72WVHvsWSIiq5GRkYHLly9Xu0Tt2rVrAYBD8KyAoWupuaHeuHGjTl2lUomtW7dCKpWiU6dO9RkmGelh/23e7/3338edO3cwZ86ceoiMNBYuXIgFCxZg7NixWL9+PWxsDN8CahbguH8OUlRUFAICArB27VooFApteVJSEn799VeMGDECMpnssZ8DVanLtaTakwghhLmDIKIn1+bNm3H9+nUAwOeff46KigrMnDkTANCsWTOMHTtWW7dPnz44fPiwwSeNl5WVISAgAE5OTsjIyICtrW29nQNVqeu1LCwsRHh4ONLT0zFo0CAMHDgQJSUl+OabbyCXy/Huu+9i+fLl9X5eTypT/LfZpUsX9O3bF6GhoSgvL8euXbuQkJCAqVOnIjY2tl7P50m2evVqTJ8+HUFBQVi0aJHezbWfnx+ee+45AMD48eOxadMmJCQkoE+fPto68fHxGDlyJDp27IgpU6agsLAQK1euhEQiwalTpzgMr56Y4lr+9ttv+O233wAAe/bswfHjxzFz5kztozbmzp1bL+diNcz8UFwiesJFRUUJAAZfUVFRBusaetL4li1bBADx/vvv10/gpMcU1zI3N1dMmzZNNG/eXMhkMuHk5CQiIiLEmjVrRGVlZf2dDJnkek6bNk2EhoYKR0dH4erqKp555hmxdevW+jsJEkII8corr1R7LR+8npq6CQkJeu38+OOP4umnnxaOjo7C3d1dDBs2TKSlpdXfiZBJruWHH35YYxukiz1LREREREREBnDOEhERERERkQFMloiIiIiIiAxgskRERERERGQAkyUiIiIiIiIDmCwREREREREZwGSJiIiIiIjIACZLREREREREBjBZIiIiIiIiMkBq7gCIiIiIiCzV+PHjsWnTJgBAu3btcP78eZ3tlZWVWLJkCTZs2ICMjAwEBQXhypUrWL58OdavX4+LFy/Cxqb2/RMxMTFYsmQJUlNTYW9vr7Nt1apVePvtt7Xvb926BW9v70c4u9rLy8tDSkoKsrOzUVRUBHt7e/j5+aFr165wd3c3qg21Wo2TJ08iNTUV5eXl8PT0REREBJo0aaKt8+uvvyIlJaXaNsaMGQNnZ2eTxVQd9iwRERER0RPpwIEDkEgk1b6+/vprAIC3tzc2b96MZcuW6bXx5ZdfYt68efif//kfrF+/HrGxsSgsLMTHH3+M2bNn6yVKCxYsgI2NDS5duqTX1sSJE2Fra4uffvoJ48ePR0VFBWJjY/XqRUdHY/PmzXjppZdM9EkYLykpCenp6WjcuDF69OiBsLAwZGdnY8eOHbh7965Rbfz666+Qy+UICQlBjx49YGNjg3379iEnJ0dbJywsDH379tV59enTB1KpFB4eHtpEyVQxVUcihBB1aoGIiIiIyAotX74cs2fPxmeffQYPDw+97QMHDsS7776LX3/9FdeuXTPYRpcuXeDt7Y0DBw5oy1atWoUPP/wQubm5cHBw0Kmfl5eHZs2aYdy4cTqJ0Oeff46///3vWLx4MebMmQMAmD17NuLi4pCeng6JRKJ37Pnz52PBggX12rOUk5MDHx8f2NraassKCgqwfft2tGjRAv369atx/7y8POzatQtPP/00OnbsCABQqVTYvn07HB0dMWTIkBqPvXv3bkRERKBTp04mi6kmHIZHRERERE8kuVwONzc3TJ8+3WAy8jBlZWVISkrCggULdMo3bNiAwYMH6yVKAODr64sxY8Zg8+bN+Oijj+Dt7Y3Dhw9jxowZGDZsmDZRAoCXX34Zy5cvR0JCQp1u+E3J399fr8zNzQ0eHh7Iz89/6P5Xr16FRCJBWFiYtkwqlaJ169ZITEyEQqGAi4uLwX3T0tIAACEhISaNqSYchkdERERET6SkpCR06tTpkRKlSZMmwdHREWq1GnPnzoVEIkH37t2Rnp4OuVyO/v37V7vv22+/jdLSUsTExCAzMxMvv/wy2rRpg40bN+rU69KlCzw9PfHDDz/UOj5DKisrUVZWZtSrNoPPhBAoLS01mBw+6M6dO3Bzc4OdnZ1Oua+vr3Z7dbFfuXIFfn5+cHV1NWlMNWHPEhERERE9cSoqKpCcnIxevXrh9u3betvd3Nwgk8mq3X/MmDGQyWSIjY3Fp59+Ck9PTzRr1gxHjx4FAHTu3Lnafdu1a4cBAwZg9erV2LVrF5RKJXbt2mWwR6Vz5844cuTII5yhvpycHOzZs8eouqNHjzYqKQGqenyKi4vRpUuXh9YtKSmBk5OTXrmmrLi42OB+mZmZKC8vR2hoqMljqgmTJSIiIiJ64ly8eBFKpRIxMTGIiYnR256cnIxWrVpVu3+/fv1w8OBBODs7Y/r06dqFHD744AMAQIsWLWo8/owZMxAdHY28vDzs3bsXLVu2NFgvODgYmzdvNva0auTl5YUXXnjBqLqOjo5G1cvPz8d//vMf+Pn51fh5aahUKp25RRqaMrVabXC/tLQ02NjYIDg42OQx1YTJEhERERE9ceRyOQBg48aNCAwM1NtuTA+GXC5Hu3btdFa8u3PnDqRSabXzbjQ0q+EFBwdj4MCB1dbz8PBAaWlptT0ytWFvb6+zPHddlZSUYN++fbCzs0P//v2NWiJdKpUaTIg0ZYYSKaVSievXr6NJkyYPHVb3KDHVGG+d9iYiIiIiskJJSUmQSqUYPXq03vyZ2rRRU6JTnV9++QXvvPMOQkNDkZqaip9//hkDBgwwWFczd+hR5lU9SK1Wo7y83Ki6Dg4ONSYaFRUV2LdvHyoqKjB48GCdpbxr4uTkZHCoXUlJCQAYbOfatWtQqVR6CzuYKqaaMFkiIiIioieOXC5HixYtHjlRys/PR2ZmJp566imdci8vL6hUKhQVFRmc83P16lWMHDkSnTp1wi+//IJWrVph5cqV1SZL9+7dg5OTk9HD4mqSm5trkjlLKpUK+/fvR0FBAf7yl78YXHa9Ol5eXrh58yYqKip0Pvu8vDzt9gelpaVBJpOhefPm1bZbl5hqwmSJiIiIiJ44crkckZGRddofADp06KBT3qZNGwBAenq63jaFQoEhQ4ZAJpNh586dcHNzwxtvvIEFCxbg0qVLOstpa6SnpxssfxSmmLNUWVmJgwcPIjc3FwMHDoSfn5/BeiqVCgqFAg4ODjpD54KDgyGXy3Hp0iXtc5bUajWSk5Ph6+urN3yxtLQUWVlZCAkJgVRqOHUxNqZHwWSJiIiIiJ4oOTk5yMvL0yY2jyIpKQmAfrLUvXt3AMDJkyd1tgkhMHbsWCQnJyMhIUE7d+iNN97AsmXLsGrVKp2H1GqcPn0aY8aMeeQ472eKOUvHjh3D9evXERQUhPLycqSmpups18z1ysvLw549e9C5c2d07dpVu93X1xfBwcE4ceIESktL4ebmhpSUFBQVFSEqKkrveFeuXIEQosYheMbG9CiYLBERERHRE0WT6Ny6dQvffPON3vaOHTvqDa97kFwuR2BgIDw9PXXKg4OD0b59e/zyyy+YOHGitnz+/PnYtWsXYmNj0bNnT225j48P/va3v2Hz5s1YsmSJzjC0U6dO4e7duxgyZMgjnefjoHkOUkZGBjIyMvS2G5OY9OnTBy4uLkhNTUVFRQU8PT0RHR2NgIAAvbppaWlwdHQ0uAiHKWOqDpMlIiIiInqiaIbQbdiwARs2bNDb/vXXXxuVLD3Yq6QxceJEzJs3D6WlpXB0dMTOnTuxaNEivPbaa5g6dape/bfffhvr1q1DTEwM5syZoy2Pj49HUFAQ+vXrV5vTe6wGDRpkVL3GjRsbPFegakW8yMhIo4ZBDh061GQxPQqJqM3jeYmIiIiIniDjx4/HoUOHcPr0aUilUri7uz90n4KCAgQHB2P58uWYNGnSIx23vLwczZs3x3vvvYc333xTZ1tZWRkUCgWWL1+OFStW4NatW/D29n6k41DN6rbwOBERERFRA5eZmQkfHx/06tXLqPpubm6YNWsWVqxYgcrKykc65oYNGyCTyfDaa6/pbYuJiYGPjw9WrFjxSG2T8dizRERERERUjYsXL+LmzZsAABcXlzqtoGcqmZmZSE5O1r6PioqCTCYzY0QNF5MlIiIiIiIiAzgMj4iIiIiIyAAmS0RERERERAYwWSIiIiIiIjKAyRIREREREZEBTJaIiIiIiIgMYLJERERERERkAJMlIiIiIiIiA5gsERERERERGcBkiYiIiIiIyID/B6ktHH3zv2rHAAAAAElFTkSuQmCC"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x650 with 3 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x650 with 3 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 6
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "With the waterfall plot, similar tendencies can be visualized and interpreted from the Shapley interactions like with the force plot. However, with all remaining features being put into the *other* group, the plot also hides some potentially important insights.\n",
+    "\n",
+    "To circumvent this, and to get a more holistic view over the Shapley interactions of potentially high interaction order, we proposed the `network` and `graph` plots."
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Network Plot\n",
+    "The network plot visualizes all first- and second-order interactions of computed Shapley Interactions. While the `network` plot **does not plot higher-order interactions** it does plot all second order interactions."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:47:59.843694Z",
+     "start_time": "2024-10-23T14:47:59.560132Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "si.plot_network(feature_names=feature_names, show=True)\n",
+    "mi.plot_network(feature_names=feature_names, show=True)"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 7
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### SI Graph Plot\n",
+    "The SI graph plot can be considered the big brother of the network plot in that it too can plot second order interactions, but also all higher-order interactions."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:48:05.172742Z",
+     "start_time": "2024-10-23T14:47:59.844686Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# we abbreviate the feature names since, they are plotted inside the nodes\n",
+    "abbrev_feature_names = shapiq.plot.utils.abbreviate_feature_names(feature_names)\n",
+    "sv.plot_si_graph(\n",
+    "    feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5\n",
+    ")\n",
+    "si.plot_si_graph(\n",
+    "    feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5\n",
+    ")\n",
+    "mi.plot_si_graph(\n",
+    "    feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5\n",
+    ")"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 700x700 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 700x700 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 700x700 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 8
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Bar Plot\n",
+    "While all of the previous plot can theoretically be drawn for global explanations as well, the bar plot is specifically designed for global explanations.\n",
+    "The bar plot from `shap`, shows the mean absolute value of the Shapley values for each feature.\n",
+    "In `shapiq` this is similar in that the bar plot shows the mean absolute value of the Shapley interactions for each interaction of features."
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:52:18.032596Z",
+     "start_time": "2024-10-23T14:51:24.028508Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "explanations = []\n",
+    "explainer = shapiq.TreeExplainer(model=model, max_order=2, index=\"k-SII\")\n",
+    "for instance_id in tqdm(range(20)):\n",
+    "    x_explain = x_test[instance_id]\n",
+    "    si = explainer.explain(x=x_explain)\n",
+    "    explanations.append(si)"
+   ],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 20/20 [00:52<00:00,  2.64s/it]\n"
+     ]
+    }
+   ],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-23T14:52:18.302568Z",
+     "start_time": "2024-10-23T14:52:18.034635Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "shapiq.plot.bar_plot(explanations, feature_names=feature_names, show=True)",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 800x650 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 10
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "shapiq2",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 529fcef6a1cd214b82b8704b3f88cdce65ff89cf Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Wed, 23 Oct 2024 17:10:43 +0200
Subject: [PATCH 03/11] adds notebook to docs

---
 docs/source/index.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/source/index.rst b/docs/source/index.rst
index 68ade3ad..4aeb4953 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -32,6 +32,7 @@ Contents
 
    notebooks/shapiq_scikit_learn
    notebooks/treeshapiq_lightgbm
+   notebooks/visualizing_shapley_interactions
    notebooks/language_model_game
    notebooks/vision_transformer
    notebooks/conditional_imputer

From 1c5a0fcc688b76321f7a4c210a3e48ef5f2004d3 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Thu, 24 Oct 2024 15:33:20 +0200
Subject: [PATCH 04/11] updates abbreviate function

---
 shapiq/plot/utils.py | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/shapiq/plot/utils.py b/shapiq/plot/utils.py
index 4e750ae2..4eecfce4 100644
--- a/shapiq/plot/utils.py
+++ b/shapiq/plot/utils.py
@@ -1,5 +1,7 @@
 """This utility module contains helper functions for plotting."""
 
+import copy
+from collections.abc import Iterable
 from typing import Optional
 
 import numpy as np
@@ -26,6 +28,8 @@ def get_interaction_values_and_feature_names(
     Returns:
         A tuple containing the SHAP values and the corresponding labels.
     """
+    feature_names = copy.deepcopy(feature_names)
+    feature_names = abbreviate_feature_names(feature_names)
     _values_dict = {}
     for i in range(1, interaction_values.max_order + 1):
         _values_dict[i] = interaction_values.get_n_order_values(i)
@@ -39,7 +43,7 @@ def get_interaction_values_and_feature_names(
         _values = _values_dict[_order]
         _shap_values.append(_values[interaction])
         if feature_names is not None:
-            _name = " x ".join(f"{feature_names[i]}".strip()[0:4] + "." for i in interaction)
+            _name = " x ".join(str(feature_names[i]) for i in interaction)
         else:
             _name = " x ".join(f"{feature}" for feature in interaction)
         if feature_values is not None:
@@ -51,7 +55,7 @@ def get_interaction_values_and_feature_names(
     return _shap_values, _labels
 
 
-def abbreviate_feature_names(feature_names: list[str]) -> list[str]:
+def abbreviate_feature_names(feature_names: Iterable[str]) -> list[str]:
     """A rudimentary function to abbreviate feature names for plotting.
 
     Args:
@@ -62,5 +66,23 @@ def abbreviate_feature_names(feature_names: list[str]) -> list[str]:
     """
     abbreviated_names = []
     for name in feature_names:
-        abbreviated_names.append(name.strip()[0:3] + ".")
+        name = str(name)
+        name = name.strip()
+        capital_letters = sum(1 for c in name if c.isupper())
+        seperator_chars = (" ", "_", "-", ".")
+        is_seperator_in_name = any([c in seperator_chars for c in name[:-1]])
+        if is_seperator_in_name:
+            for seperator in seperator_chars:
+                name = name.replace(seperator, ".")
+            name_parts = name.split(".")
+            new_name = ""
+            for part in name_parts:
+                if part:
+                    new_name += part[0].upper()
+            abbreviated_names.append(new_name)
+        elif capital_letters > 1:
+            new_name = "".join([c for c in name if c.isupper()])
+            abbreviated_names.append(new_name[0:3])
+        else:
+            abbreviated_names.append(name.strip()[0:3] + ".")
     return abbreviated_names

From 7fe32407091df949a0763b36bcf465c282f0eae0 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Thu, 24 Oct 2024 15:33:33 +0200
Subject: [PATCH 05/11] updates notebook

---
 docs/source/notebooks/2-SII_network.pdf       | Bin 0 -> 13806 bytes
 docs/source/notebooks/2-SII_si_graph.pdf      | Bin 0 -> 24073 bytes
 docs/source/notebooks/Moebius_network.pdf     | Bin 0 -> 13823 bytes
 docs/source/notebooks/Moebius_si_graph.pdf    | Bin 0 -> 294325 bytes
 docs/source/notebooks/SV_si_graph.pdf         | Bin 0 -> 10674 bytes
 .../visualizing_shapley_interactions.ipynb    | 150 +++++++++++-------
 6 files changed, 96 insertions(+), 54 deletions(-)
 create mode 100644 docs/source/notebooks/2-SII_network.pdf
 create mode 100644 docs/source/notebooks/2-SII_si_graph.pdf
 create mode 100644 docs/source/notebooks/Moebius_network.pdf
 create mode 100644 docs/source/notebooks/Moebius_si_graph.pdf
 create mode 100644 docs/source/notebooks/SV_si_graph.pdf

diff --git a/docs/source/notebooks/2-SII_network.pdf b/docs/source/notebooks/2-SII_network.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c87dc9ca09d01dae310e1bba41498da4845c2f26
GIT binary patch
literal 13806
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

literal 0
HcmV?d00001

diff --git a/docs/source/notebooks/2-SII_si_graph.pdf b/docs/source/notebooks/2-SII_si_graph.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..04afab8b4fb6eaf1871d27ad809db1ceb65a109e
GIT binary patch
literal 24073
zcma&O1yCH(wl$mtcXv&2cXtmOAOyEz7~I{0ySux)I|PTp2`(YP;2PZRC-2_-*Zc0f
zRqxHzR9E+$uD$l^-Q8#JbJn3!mXu~<W9CGps$3<nXh&otXC=2avOp9RBxg}`w*!&0
zNC2DwR<@?(EXn{=kRv(!TLV>cVPQm&jq%@xy#MV4X<Hj7a*qFMz@quZ$N~g(BIo(X
zu9TaT%vUFX6NsGi9|x2HPEH^P8*;9{yNE1b%>c&cHm2m<|NPg%7Wft9M6UB@R#N&6
z3dqfgoJH394TAVTw-W!{%988-H#ltn(}BOZ|DtyQy`lRDd=^!Zqph<8@XepU_*KbS
z6hX%30C8KlH;b%qUoKY8|N7}6vPir+^>(HsIp058irLuMzU{I7ZT8=Z`1|+2m{S1R
zm^zt}v;EVWw7J!rujDM!R&NAIf`GQhpudnEog6>_YecuqAKzsgs>bZ+pPs^n8exgQ
zts^rLzJLF|8K>9RP*m3{K%%}*aie=mTT9R6`=i{Rkdt+YxX00V8dvUbT7N&?PZ~b=
zKCg={-A|VWuZPzxubW#bdpTXtTOmHrC@+_bEVmCtPkTA~FV~h&do?1&F9)t<%T!Od
zwmaSTIqM(DUY|uogkKJ~P7SEK99|R-a5^3tYnE0@ENgu3#uk0tpHGfbd=TYc?;LX0
z7URpusvu+zy05noVI5oMn+?bB&roT1*SFo?dImmTlm@~&)_j2)pZ_%65CY#Xjx0{0
zTb8P9NjhHExrlilS0OGLx$wQe%IN}UUK|m9R*t2{7Tm75LoxdJpbV?o5tFCM>Gg1|
zYn|ZV$59&eGUL=wqX|aSrrs=ZEplU_#0H;p;Nq>s0_E|<csalH$>9+_Q}d5@EqeGI
zTQXB=_1$BQo>Z+{ZBMCcU*XN(bA%vkMY$2Gwe!}hW`6Q?s&r$$Q6?taB3VvMTSp1E
z#jnk~n@SZ&zLVDwW`G{YX9}#iMAa6yqlL^C9qZuM?(FMeb6!d7waLLWDV)Qb4&%Y0
zI`5`#Z_P9?=>0rYZ4*Tf!UWzX1onM}7Y<7KxGHQ(_mQh#>eZ?1HkLYU!r^t`ZkR-S
zZsz)n85n%WUcN+YF4}@0-n3N1)&l%8kLi+Ax3h9N0c&E1yyn{P_=kMekwIEGg4EjV
zsZ<F=U0dA>KZ7_s={eC2JZBp`h|fZv<rp5|V1=K8&yqTuyC_PrdzQv(%{B;>HJ;sS
zkpP3s?pSv}ACVHqP7{kCR*#4MmQ(T`=hOfI@8&ew2N0tJ$RsTgo`|ua3p%mQs7<_d
zEfj#{gFm5sV9NXL$cfh1IG%O*k3>A5#av1DtA&WG#%x+we0@UAJ+|4uUx80wx3~Ib
z#uuP*pU2=ds}=}9sljPT1F|@Hr}g<6Db18n`ccgu8SUhsu*)5}K%;vU(uNhkVS07w
z?(kUhsd#GNbBa2$8a0{?Jo#_-71o^x8jPT*;*VZwOw#nj2q}NDS5{^Ox(%vJco3X#
z6p|>uvX8!zwmr3>_jz&gfa77j&6qaeyIVKDjc}i7NQites5M@>y`%7J>2y$E(k`lA
zk?~+4TbPm7@|Um@t7jWy!A{2yN!k|Zx5%~{Y>mj#pzGNH%O~pTKSas&{!E5akP>B?
zsu7qptOE`}UpoXMF<`ujESCvZ(uFPwcNLe&8xkYxbX6uZupK3F{0$)C^m3yw1ViFc
zr?MX`CE_W_l-<}_tcb0NofK@JR72$F4f+jCzQE-o?A^$gpl9rSU|mpXRqJ;MmO(7)
zAu>B>EPra~i#g=nDKHrfW*dcQ5uAN4v3>(OoC;wHR=dz0N_WJ32P>(i$;r`&?eQgY
zwy#cuEr)oK<LM~dk-!mVtJ#zVYuHm|=nOqF{2>+RefJW>YH7{g*jzlBBsmwXLyssk
z{$*LWvGu!^0_3R3p!yh45#@MZ{nhKneFZ81OPrw79_P4bN9{Yn`H=R}el7x!8!{Bs
z06SKjKGc=w>BGA^-yQy*Q0Lfiib&B|U<m7Yv;oc1U<U?r>bq1HywrU$>h~}_sJ!yn
z*q$tSP;6uG2z`7~qb7RWepG7K&1$n$_#+^`kI{O$TbRCXilA2r`MKHqUOFyf!Y-l~
z7bwWZlswoB%h=ge6iWJo9<~t$y8)~(R|#C+qjlp2GCC_Q_+v1DaS7%bGHEH=<6*<g
zNThXPqCH5?wZWZHdb;>_3MInbHpm)7i$b@_!4(LpA}@ZVwpMnZcNZ5U*p(~e^0b6~
z7dBLNIdK=4D#W_oy?#(ZA3~<moyCYqIP?3-D{mL=j>^^pp_)H62`=}%8i(4monUNg
z_#l-k7obLw?O2aWPiMr8F-DjJ`<Zg;ZXKN}?Xf;dRM1hnpc8ZJqGAe~i^3!EAWab-
zjhV7|@}sewY#3ww*k+r7JU(Ui5WHCO;T~T<5YMqGJMbF+^yLT&rSz*6`1E0Osu!!D
z@WN3O^}cRN0Fc4IgGy!fyw2z|Pf{WhFEGRy{JmDnkDeUE2%52G)iRN7IU^WhNRxvS
zr_qSoSgfwxPG|Ug7+4%{e=2k@yY?8K^pkijwE<qB!=+{AI11o*kWm5_=+zt2)JVE{
zlph&8*Gohs+}a}6x=0f>!S&%|DkfVAE~`=2H3=D!wbfOI8NwK-=Vkwa@Xyko6#_72
z*>bS@)TjUeI#uol5neVfk{d9*M=75JoK*=*xHD*<1IF`P)uq)i=>xinNNk@tm-<K9
zpPf+S+^K`GV7^R7)f`}t*>UCKmE=f&CYa5{b3%2u>BT^cHk=Qd*=<2l_*lxepERfJ
z_8DGmOdc!P#tTj$IAjRj_E-rStgJaPf%e)^WC?%TO49!QO0vX}(Qd!jdqPc=u1sq*
zTE#n6N&6fk%z*2Vf;?-7U>9|{#gr|U#ExC9Rszq!#lYPti#;{uts@LP+8fpc!cvq@
z3d;2j`BDUHA+=I^kr4%~2fw?=0SmLT^{e!LW#Ws8i$42gXEwTIT{X`)2&Is*nHkpR
z*S+p7X+;c4pdzlxuG7tpy^|Ubn(27@bOYnGWMn@u!LbuW6-D~^OQ*W~u;>zPLfml?
zEoK%;Ph}@N1u9_#wKj&O4Ur^MAR-cH4JnnN&(JiB81H2Ptb03gJ<KLStb2u9V%meb
ze8z>0%C9*-$W}6N67c~*_Yx?X01N&Q8iXUEfmQ8SXUe7U&N8+usSPikcro-@j?{=4
z;%jtmWlkxYOpp4Ycp+w23V%2O);z#q2fFhF0){uyPgiv*sU-$vZK5e$*S~+ZH=ZqB
z2<(el!PY7Q3<lPP7-?ypel9tAvQg`lb+VIka;M^FRWzQl&6I_@LpK<@At0I?_Tu?D
zgXzjCX?Zpt8_g(XtUota%rS}wEw7}|IA-$$MAHTe(hoxo0t!`7Xw)AVRdZk1ww|rF
z?d?A*I5B1ml~@zR6W{xO!p4tJl>|$g=0n-*SnnPo_lqs5BZG1$r-KNYYo~|&*`fIa
zp`54f14;)Paz`C$pUjl7*5uX%@jYq1o35j+R%T9z29+eY;C_vtO3D_)u8R-_Sd42(
zf(LPmThsD3+M)``zT{MgsLHIMyyTS8Og7CxR;9BG!pP24r0EK*&nvo&5PY{OKfuMn
zv|^7q7UBv8Bt*B(0dWBzLZnN@mTXAaZnW8Li@OhN$IzUYSl_GLSye(91o5&rzk+H}
zI-wasurw<hFz7Yt)=ONiw6y9c8#1J`Y;jZ&P!bdIhmg2+Nph`&I&@OQ9|?2p^Q!1V
zYqSfU)B^EHw%K&ADS453r**#@tlXB>M&AdR5V{#l8?*j^hDL0llrEJcfg|Cp4SamG
z<P~7-51m5>MYABcx?QTYDj1ulF|YCr99Mb4ep_L^TgduUc~!Z@s?MjNL&W^P>PJq&
zmSQc5YBkVx%#PF50EHRO7T&<*9SNK5;ZoquMm?FQ1EYs-y-BHV?|rUcmAcYaCq^Dg
z=TImC)>I^;N6;@sG{yMSV0Lkhz^@#Ft6n`o*0^NT)TXvzTVH|H<$Wdq@E9@S_xoE(
z(;gC5<(e9d&c0=CdCg7qoXrW?)ep%Eu51%K#B%WJq5<i?o?CM6;q|JGoBgRftkzbo
zI~+IO(a}3y975OR`i>}CLyCK6{-6A}qaYDK0#{>OobD<#&c=a-!h6Uc%=kunho#AN
zrH2)3-hII+so5tHYYAM9@*Gu%O^QT8YH5r1LG<6k>$UmZ9{>c6+S8)<swAK6cy@Ik
z_8*~LLzG3fhju@9pLHmlMK*Z#&;hLHS$hw?dXw{27?dXUI2P$oH)d+@&qB9{An>zN
zsK6|<0Zf`BA@x77h;if#T6{iShW)!mgR+KwSr8|~NqH3*d`~n%bYWztLjoNtg8LAy
zo+fS&GAi62Y9erfFU)z&mZ?l`TEs(ih)Z^ufg;+uOD`c-&AN$d5S&Kvmuzhu6X8Zl
zqQ)6ZH%p7J^ZdVw@vm)7nu?m07mCpyyX|N2=c}v7xpsx}KSs%~<;^MYim4C%B*W_4
zsgI{w;%pRtW_Sua?awphF2<Ob9#7%Cq+BxFF`OQgVjxDPnk<i(YMCZxgYAcY0u_~{
zPC7dxlR$iSF$8Q5_@BQ!YoHnyII`%~&0F4BRu5{@l@~>hkXYn6!-k_l2mBNbOE!<p
z2o*}i_yQafV$nQMR1u<AXMDTgf|Je@?S_6%0qO#dLTNpAEw%k9a5em|;j5E=0pPy!
z4%BDz2^v_8`@50O6%Hg^^8I031@W^w9sMG}=2h}*m~xnrA-rRd+zo&g|H0eLo!6n3
zHafJqDp6&RLV2tV=elH9=+x+H|NL!z)!R;7GV5GM(kjk-+toirnd9~aj)qVV4}RvF
zJ<lJ<(zmF-5^&swr8Wl!v)<5tqrIZEMrW$tu>+PYi1m+;B-eRrs1fO^z~dqP=J3eG
z#%=h~C;b8{><dPE)$OcuT-qNe-yR*Wy(jF?O^)?1LY|8-XiXg!RJq06p^x?x&tuj;
zKrUAUoR@J+xG^l%=8XeV)ti5PAfylpfiB6RTLfaZa_C$N^a?D-6x!n|wejtRCTlGo
z=pAa2QyZz~aH)4GpttXD)sziT&WE8gC{E&)%HeVm=c`>4r>7>7>UX9apsi+Y>p_|b
zP|nPQ4%8^Hl^?<?jO+^vb}^J>!cUGD=VLDT<O$-ckIr`kI%xPTI2E8KqB6)Svc!_;
zk-M&oX&G=Bgd@4I7k}Bw34=CWp^Q*)#yRjxZd9d-r@jkFV|O-5jz@>^L`EBgG6`!n
z`H4t#Ud!4Nf;$J86OZD@=>|SKx4~9sdrzJ$6%9dk5vrwP@BK;8s-k{L>Bc`7lfQ@{
zaBQ9EJwOM3ad#jM892RvDX;k>GN<ti@!cOT)of>SoP7LL!!P}fm<>h3qr9Cgd1$qp
zH5c^#zKgU_e^yaOS_D@})?rD_u8HQH$q|F8WJbUr30v7J@SyA_uTBdhw^)fVSY&?$
z#?wnDH~j{YLlOJL2yJZX3_$(XkWb7L^L!G#v}d2@s)#mSS{p57qv{H7DaW2Jn7e$`
zehr@mGEgPd9|EBT1sewPD^t_6mu26F_rajdKORujrjdHXepH1B2h#4Asv)C_z?Z=y
z#K3?Qp7fzA@}QA5eO936m1MV;j;d>L0NKe&87Nkv0g1U<*%FbJfvp1pQtVKU6_H`6
zm`q^8r!7mXQ(z|@k6Vg<jum;SN!HLHr+2JOPKqz#{Nc|#mF(iq>$j(`w2A@)7XACA
zrW_zJhVa-~XC0AFl`ASr8tfHkKlG_fm-yM)xKWgT&I7#33u{cWk?QWA{Ouzvq;86^
z#G#p&cANSMQu1|&+5L&oyLz;yD7Z)DOEp{9?5=h^?Wy}qdBDvd1}So~?iZ*WT`6)+
zn%tmWQ;blgr1@k-yvB#)eo<hoAjT1$?si;9ZqTF;>4Z@flKIST5kjw<wg4h7``pG1
z)I1kCBA6Ss`?-A|_bx{(BEPkVnm&ltoHm;QR+FfSR!+Eb=|}NmQB+uTUl^(TioMV8
zp?VYAhMPu_<#)suo93Y=>3cq*n&~({bBkdmx8&V}FVq@L#I*+OI!{ase>Hpau&)J9
z-Tj~hnzV8sTh<SScv^W&>;9l{DC4l{wMy0J{~UK53FuYNOz0d&AmW)?dvxyy*Lm;y
z9g=Hr2?4R5+V^L$b{rfrHthRcW+F^Uxr*kBQ}i#+sU<fayxNMwCJ|8aVppEI<nc^6
zt7!vr)Q%Ej5UWn+jT}(sqO|##@}#0t)bD1p^8~N0T9vs~1R0R%?<4<SmB@7ZqykWt
zWR=On3e8^bk!~7|X^|sv4lyLfoFF^fQ0`0`$LN_2jP+#<)ZCM`$I+5nKyc|lq6|AD
z7-=OWTSpdV7!#YeEhec=jE1`n2V}YQAWU{K&{*0?5P-Tcc^vb80P9P0!o8#sQD-~7
zDvi<zj=47sX<1>^AvU;Fe^&9+ZT3z3<RaUtqefnVCY5*yE*~&Ub|XW=o(``9JN5e=
zEEp>5z~|dd&29|Oib=IyOp>8hppbEi?ZxeN7m$MNQHU$JD(D&mxh{pFk!Tc{hNVq0
zi)EXqys|KUaZolVCJaof^5)-%I+({bh&qx$4U|{nO=DWjB?b`dntxGIPgnQC@1U(t
z!bu7o-LwURPx=eg2pY2oLoS7-lJidkXx2qA?#7(MhQsTI&X~^48k<IE0Li-pX$*3L
z1%ol{S0IuvK@@$^TSeK}x%YUdpPS+7en>Sf&hTQ1QZ@8xt4N1_gG?QSVUva33P9S1
zo+tX9jW&I0Dp{BSM$cM^8vMq7m#B1~Oc2PYS~wL_`cM^<rLE35c(8O$k3zlB#z?y`
z@<7MZf>DHc)n^6#Qd(tN=YYt!q=H)QgN0)^5ixM-3>Qhgin$&y`^iK$gtb#C%~ees
z(iS%-Df7iN5@su?D20x!Ee)qbazOPmsg1tIf&sT~juJ+BJQW&O^y5l&XFwWNB|<!c
zDF)Z<$1XQn|EAAUiNaPAXd?om8=Zz#!x9g!UOvkaJ_pg88u`|GH=-g_K719T^|~zT
zwQ5SWyuwos0kM~~I6a7gAZy}LlR%1&2mklKX(f7!spOWmcM$h;4fEllsi+%E={;F_
z^U-Y(Sw`)?cIG>sPXp<{$1f=~XojaW8fXh=CmMn-T~UT5;lh5#W8*H@2+5~BD&qJ4
zV8O#;{9)JRHpbT9GI{as?ZK~z5Zc$Wiwr8-=?`KXF<Hj9i!hCRCMK}Wx3*%<I&FaX
z_J3fXoxn<&vokwl7GTi&j=y;OeeXWe7@;m?Ddo8ibx|D-)n2A_JYv#X+VA6llOOex
zuw7}ADSR-!{Jfsh;6;x$qKmXU)ek(dm<L)R!6nN<D;wfVmudHO(uou3=AE(u9(0}K
z(GR+QQx1(RTjB64sNq2eJvTCjiD*O}@qlzq9f*!=_{DU+QGco=TNQFCwAzq259dN|
zZ~cCspq#Hug4ML{wm2kh%Q1Uip|eV<25xGEK}R3415l!}1f3H$Ex3!c(A6x2l0VD(
zgz5EtYFsxKF#(8=T(~J0iv!yo8r!Dg_Vg)Id2g3#h+nlzaNjuHn*h>#oAP{>VngrU
z`{gLXTm8gnJ5cMOm#BE2K~vOjxyTFZHF|++m@z&fKkzV3oX{D!&c%uydcsI4S&Lk~
zM{~=asmtja_Dfknu-0s>jLOKz6%4lKd>^uO2lSd6@t6??z~_Bwt^UODL0nX#0k<R%
z1v_-#9H3O^GcJ(=>4H`{szI}xeNTaOFjKIOua#7MlrACX4k@Dk!;D&t5e-xd0(H%T
z_E&n#MKHcw%8Te3&Y_%-;n;G;5X?y^tf?w=$5E1-;l##@s(?W<htoupyHoHI?PBBP
z<F-D#iq}bB)XLX^0Jvl=#Sjl#xHd1Ndqe*GTW5#nv}7aSG%JJ65p%Lr<hA7(zsX~`
z58$*Hb%V?1*YOFf_A`gUYdEB$WW%<kfG*7+N#nUg1Por5iqpRzzA@rk(z+y_B$^FP
zPN~$zpa)2bZ1HklmUDlt^n(Ng1E<{;YmKS7HT(O72A66sKh5GtL@!D|rz%)UH9W~0
zR}stbdh(rh@zPP^`nu-D*8Mhas^s+a3)S~Vne_9!sr7MkG(Rj*I{oG9_EJywGJ`Y7
zatH8K!cK+N<Qe*EK4Piavn!!#ID&O-leH$Lzn<m(om8X-iWRxQUR4HMFS;)7;k#El
z-lGd;z%xJYseuQVnfz!BvCG&n+pSxQLwfC6*BGMVMd(p@KDRcj5-Rm*^SRj&rT#U+
z<R#OwGm|^x7u?dtIbWqU=-2GOsjhWATx8`L12tJyF;vi)teXZBIlB|mh(b$DQbam&
zD3F<(yzKD1sY4@hy9UhcNAr-=XkQfi)lSUQl$ZM;qvFlzqm62^J_f|-yEg%+d37(V
z@AK^`2j;4ttKHM~^C4;RZeC10pKV6t^nA0eL@$L!Qir&`Q-ny~bCu8Mofily-qSwR
z0;(L`7Ptj3%stl&wjwjqlgqJ)gbbGg-!1+j(xbTq(OuyFFdd6rp<<cT7Jb?fWFKd4
zZ!DHG_f!_(ujOM1r(}bT!sJGw<}aLrTiCAmiBTj>zLEajq?>v0f*cre!1B2L1XM!i
zFb>}uQ05o6Z~NAon}wGEn+i0;I?f9Wa|uJ)Q9zykoI$oY0JZGL{*oR7sHS?AoDa(z
zs#ATqYNy5HJ#hb_Qm3M8!CW)jHQ@+BSQDfa*u?oWPX-r^l|@P4taNhDm2rLr2dW&Z
z?gCH%iL%HPOl^>=d~xS#f?;z;ITBm)QOLmb!RFR|6uHeeK&wv2xk$_Cf<NAEb$&?c
zj@qd8eHi1yN}V5<X|yw^EcI&_C(?JT8B==lcbcFRyLA1<qfBSqPRGPZM^irl_=fvs
zcDTl*Hd*z)?=nTmi>CTlEigMPIPrZ}mlo~{F8}VWjEb2mv;?oZVRw0~m3|ZZr9hhq
zQKMZTu_+skXn{V&+`9h_$t}?7*gn86k0s+0UV{0PbnvdMMgDRti|No+q!q*Bs79&P
z2G-?Uxy$0A71qTO5OYlFItd=wirQKChEKw58-P#BcE6+SPAycE@{ap~pM1u~L^Nyy
z`Q^IwQeVUDLup_=*-zZ8GI>3ZRrAe&(zVUroE1#6#@mEw&A4;C*_Ukof!#bI#NA!-
zoAwm^+9<8FantwBFzo5Xf<3dkQhwA1H#DtkZlcj3x@Ct;l{$;$-#DkNdJS_$dLQ~`
zlkD_x*7tLJ4>xfC)L@8=xd#^M)?zT+kH9^WU1ykcC)iITnoSp=2H5VH_vuUpBY|-G
zFWK@izi2)3aj)GS1~OSxRV0&!RuJMfx`_M$j519kx>sV+MY1w=@Y_fs>L2C$rY$~K
z2D|b#A9&V*rgr?&{T~7Xs?qurtlKMTD|nDrKbNp0&<1<PDn3%_?v-hFkjzS&%6?DE
zZd_c17hZJ=%5d0)n`p^E+o;|pm|`mC==K$8m?4-`pJVVcpG05N=C;C*pe=qIw(uQY
zn2M_#iqr&I3qF-g8lHUKma?iOp6O<fbniumM&r~;n4qz|EfIjXo<xG45Sxk+K36Mr
zrn4V^za~SV7S5;{cRSN|Jd9>!)Y^)piR;OTw-_)|`wS9!2A&e>n~Ik?Q*RHMe^gua
z4~Ahp)@7TltCdK1ZPE(on@nG7S*rQUe_VVd7%;jz6KF5DC!Z1aoj1!JpcU{?sSF7k
zDeDdT6v-<%=Vq@WcLE@xq)m2r?3}EC=<rw0Q>~T&p@^YB=`a=^{YqtcJkeK!P-%24
z_e%^UcRXYO-27Q%gcI!$xypauEo6MERC`MhVBZpiBf9&>BC`I?sI6TR`Las9Oez-H
zEq^2LaXaSAO2>9b={`rFs8*Yfuy<3edRAef*2Rkh$#YY@CEM;DvH>fO44G0k_TJy&
zHIPFHXz01=Kb4+z;>;#ZxEE&#e=y1yIekU88*Hw1?C5f?y7%}BvfMjhLqQ8w(jMUf
zM|a$~$(JY>AVt{@()G!K!%={7{SE9n@k$vFY^;;9=K$%4Cmwgs2ip4it#aI@D!f-L
zn`XSWE_NN}GkT>{M^S&NZa8Dz%TMkLd8Y>l0RxMLGo}UWAN<@_DMU2=SG^OuwmTi`
z>UAA;q=AD88Xe0o_3JNnt{5jH7%YQ>&TjkL+%wWJNTI4bqIJ=j@<w!3P|S>>1!#DH
zbik_j5FQ{C3)V_IfmoLdIZM+<nT(V^H7nU5nYI&?#Yr311959(>|zB8X+~e2c1<j5
zho3KFLr`EmyJPz3m$G(ys1Zj;G#?jK^;nVE7$Xq_GHkRO;w+-_naaY)@;MKDR_dir
zQXolMw2JLz_vNHj($5svU6XcmFJAuQGjOFVBY%#~bP*0+gZc7B<y(zUNno&3m+x`z
z3$~^H6xy8IUI2$Fr_U*RH6xS-9^O)LNEgixAgu_~8l>Coc9k?m@+#@N+snc{xflv#
z>8>2icchKPN!B^2|7)UAqP6aB>4NTOyJ-;F{2TcbZ{%YSHrD52D(gJ5ao?2k@c{TF
zG7HPKz@xu-?5eFQrad4+G7H^7`&vmmOMz9xFjxdd(SG%jtE}Zl;O#+Jpi&pRJ~TRE
z7|hQAX=^19LCCEKBn-!g1$62fZ>^`bJJgoNbz|}{_NVPNSB;CMza**rk1#b#3~`-&
zLxb7ml6Q?@gVT8$fnv*PGcW0vN-LheaakzhIaw$Q5U3W%!eJf}{6Y9}fNpe<?cDS7
zy+9=C4c?-%yBr5eC(J-IYoLsSOFn}}l+R&Ijn?NKvcLu>k`~?C3N2F~mVS=u)sB`6
zt+~Q-oGvF*T3aDY?nD*jsb7K8UDkhGfdL$U_^q6{<iJ#Xrz4L}u047e{leoE3a7uV
zJoVBb#Q48*#sl)SFRf@vYxklWWO<JpqeX!u2e8-f75<KzAsyis=c;x<eA;7jo>%>I
zZO2r-(ImB|4w;BQ2&f-A`F@|;o?}g{tFdj3CA>cqsfnW3*JG);eTb9u(}qG6UQtzx
z(MN+?fev2;GEvRf9RZOmd*gKMEU}%+)~~Dj<~hVonb>g!NTV(s5Ijw5HPg8E#OOnJ
zA*%Wsza5Be!Q(*OZX5q|DO{7tAjDv&KLLnpBRe4?!)w2!yzA-#kIFj86HHL{%i4p8
zcvA-6SvxV#(`Rx#A57EDi}QQ+Zwc|RE8NrFx6_M$rqbSJw*3q=q^cgE+vF?Wg*iPY
zX6>4kojgzFcDO8D%ICi?Ki72oeUd+(hDqjiHW<`yPF(H&lQkz@1=A>n?2-acXgV#z
z=3*Co?Odgr=dKbQ?ymd1QQ)tUVpDB-ST>|19%b>}?8)r^&Hh$4W6sa7z}Zcl=J!B8
z(QmbGUCMidPWs1$4f*yd93ejT_7jLEMjAlh@maw86q*Ao{2Gjt5Zq*l+4IpSb-nNy
zG8^XOgI0IsV}6mb$Y$0`vZ-69djut(<FeZ$ou{Sa&$*?aTr9u964xx>M`*c8w0MDW
z<pbJPeEnPUIp+($4EilRL)4cKhKrCNSYHTnvLbG_{cPc<v)o$qDBDhZ>L=n?y}}S2
zQ_b7<Th|$EvN1rCWsb!F)6>yxp>d8#bN|plEu@iYU|R0hZWK06OwY)v`<g33w?^4J
zl|fqf<e<sA>#LSqMxSMjM>0n^D(ANF?)p)tDaMllnP_eo15+dRB5f0Ko-@+qT;=4-
zGm2*<m}-qQuNa1!<F@RmC$p$JVdV_XHC~_qk8LdR=rQfq)&yK-)=ay2e(SDtDf^|G
zjCgC&%=&gRjNZsj=AMq~;gM$M@pnd0DPP;ob^xBwuL({T{@oB?#HJBY5ZMk%pWIY9
z5)fywp*}DE%dbZ^{<T(sO}WNw@^22~T=vPj592KE?d)q?5Wqy{@1)cHPLna5=B~_3
zqVr|5DS!B~YIu)pvFY4D%lRAi4-vHGe%G6LP}7%$yXlD;%lJ^9_*!M?y6tqy7Ax#M
z2V*X?sh3QG#^(q5hxD@@XsE<wl;+7=#|KN_`s9klPNH!B#~|yHCwyfd#O)M>39mvL
zc&3m&LiglGLUqP{7aBXekFNJ=EPICvCt5oDz6J`Nk;M|XuhU)eV{v|=3}zXtG_5#Q
z2R&TvIPh)&UfR2k!-4dO)r<uTtoQxF@L_E2F2<SSCpD4|;uf=CkKzpo4!0H#7lag=
zHQ3qF6T)ZO-Oajgm9VN*PQf<PLf?_Iys|5e*pf8f`2dsdbnd4Uo2->g|Jbpc0aaG2
zwLCLn?fUcd$z^Ol>q@TcV$g<L85bY5`R4K0rW?;|etOaI-rKOUS~yP&zDk{e1D*1b
zXs?Vx_~CTrrl=0Yu7as~XQufFxHrQJ8h7Z~j8Ny&17!>~2c*LQ4Ro&ZZJI+cdZYmv
zZEhM(A|<23eMp{eFNr`>Jb-mZuiO}a;j4+D7hgHHMO}(C4w4Ahak0pdx|696@Af$!
zg5!mP9O`s;2VHn|mcjB>y4!8+h>b+(<aiyn=pxSXE1ylL<a=;d@cvX+UL}p7Ym2rf
z+cHE!=WaLXZFQZAgpo+>P@4MrnHSNarso`mWA}C`Ft4GMzp}Rj)(KywKXajzjEfpa
z9sc0^_JOtg`OqbSRtjRy`F0HqwaPZw-w6u0fvh5=b@flcZ<dbVcT)>W0aPm42hVBw
zh7q@=8|Q=!V|8$$tckZiT7CW?jtL9CWbtE*HhNnfB>l~$`OBoHh09e08XHQRIkho5
zVjHS)85QiEnWg8mU8r+K4clRxYAwitN%9u_@J&eBn!rWa<g<#Md)GsL*HC@e1x>hv
z$p<Qt`(Z;7>@hCfM`8XKhWA`%7g%s><s8N>=_pvEw81;p;uLFjH$Y>%8$EO5=J7ZQ
zp^>o^e3NjG%>ti^(J_k38hh^QKFN%#Qllh!m`hN>bhHd1YtZPTF0}QrqR2%E^X-M?
zHAX<+SgVqYO0_weAgyqE0@%U?t9rsI0oEbKt%^q4D21Jx-!Vf8w&1xn=&dv1v|}C1
zucJaoO1NIO=@$=4jp3roo+Ug$wm`+_?BaZTRWT6>Cn_S({_@xEvOaR907epIFK@dW
z_lt*eYF~ODjIEZL374v-F(u5l&bYG#o_@cyanERr@IBd153n9UqS%r~-Qxwpx{)62
z3`C-YQ6^(YSseVKg5E`ocSuiq);gSoTNiG>PF@Q*ViEXrHKk3La?hfnL?NJ2KV-_M
zon7Nu*jHS}LH54Pq(6joX3g(2#eAn+b6=(V$Qg$FpC*ip#w$@prL7IB2ku+JaQ0wZ
zg`M4iqHyz*O`OG~n&l~KLK$)7>$BCtFHR;OHUi(`aF-#Bc`dQPbufvB3_hmfh-Xo7
z|6nIsIZv95P-Nw6Vp1^<*${KMB}j@YulWw>)p@=S@BiSIBBKQ8xbqJ{8m+oH4o?+8
z^MJNy+m?lL*tzB;VS(O0NOTvnzTw~ITNHFtP@QxxD2CeXMQS;2KwHTh$1Hc2_PX<p
zsQf;)+V6bbc6HHCSsB;TPey_c*REtrQ3F~vxU?JB8TIm&DnDlyUP@$Tm*dgp=?YHP
zt;ZysYZg`eTg2_;vc6MxVbir`AVg>xT#t(3au^<Ie?Pb(rv7p$vOEC)(qtlxmvymk
zHl#+xBJ9%TM5Kk!Um|wUAdT&5mJ{6(3&cp{{yjn^u1Z%nh9a7$YC-trm@9dB{yxIF
zQ<)wLTyx|mw5^`_f$5jQ&6ZE4PN0Ts5Pec~!)H{1q&Uvhvr=8laS9CM*WTqDe<3;<
z78EO`hZTF7E~5pRbDWf#<xc@ZHZpN|eYidW9#cMsrArfqy?Nn3lZD>lz;z~`YI$`Z
z9S7?4c|F@wYX$2<e{@mQh>1d|W^b6&>+EvAwEL|rrPjL^#RC`p^%s%NvU?_8^IP?(
zQHUGW>&m&5enJV=hC#umYOq*$p*hC>Y>2Jlsk>@1OfQlOJL=0KUWv}<PHa{R?J1&c
z#|ydTB?|_fi%9(g{8clAqkHT_r%!Pw7o?^3<8XTbiL{14%FM^<TDHQeu1vq!$f_B{
zHwdyA5HKc^F5qcs+O=ovF~**`bPY1chKg60Mk=ap(a4S&bWB55Cpg77hBOGOd||n~
zwcg79>1PWK5OJ-+vrcQX?O!+EJp9c%E&zjTDNW@;CK;L-t&xHd0*=t@0(d_y{uC@*
zHdg7<&Jf{Zn1p$Xk6}F}MJGBA1fV=kT3w=@@l}P|?%CXrRIv`ynsr01=eX2l;}wox
zXTMk5#s%EhkAJzgzSL{Hn0j^84&ST9^Ptn`q%k{8?Qdv`$ykeFHiE}D!-l@Q8pFvy
zF&=$;ayzZ5>m}-#gi7HVUZM*ybIG<R&FLQ#w6cNa>Ma}+`W~7YOE>D5hrrPk97BHE
zUCf!yDWDKCz+Siy#tN4g%@sU8x~c05h>o_mx<9F@;i!R3#P9$Dp?Xo0QHahHV93}A
ziv2EXS#;iWSr{D!FznEc%1wu(0h9Z${^r^`kH44jgDT2z&F&TAmZ$F}*-puZU%qcy
zA&$5O-|G0X|IjyqBko#Y^Z0qeo{4=>r(xBX|5f@f)Gnv$dnc#H<pnn-Szt`m^BSjz
zh-#<()P*jeu6iN^^{21zmd|=k1HQ{yC*F}(TgG2>3NrUHBM{W}CZ5yVE$^2mf%s~-
zGv*f4g!<Atxf3C>oe>RiRhtyD1rOTDi*cYy1xq3XE(=TxIF0{t-*=p|NuxI4C?N)Z
zCOHb2x>Q2MrRjnmpf2#!iX(Sbtz8<Hr(qr@@fXCN8s~J4B3|w^pp@53Xw1FhgNy?g
z3EaslcuGHUv?F+_BwM?=(G`vKZ&dPHDXP2ZS3)Efv>XI8E%}`AiZQaSe3nBN$<VbL
z0xKLgB8S_l!PW6_yFkE3yfe!?&+BnzbmJew_%@2F2HuiM7yEE5a;!WH?mTJuzs+OG
z1?9eMBdLk)1a}Cw;$D)ohJH9|0%u>Hjyb>JUWC%|)c9J0x&u<;%cr>gceA>nCPQA(
z)mQ`7*QMP_e4FIL>4~o39z@386NwIC^xK+<g<p?Me{K@1c#mRh&6KZQ^>|wa!(FqY
ztwV3U$OGJfB=Ti(1k6AZmzi0)qp$|0-G{8Ku!v>$PC`)}GY`<)WY}~8&SlKEkmdXD
z?bprqSVBAp{Pv<pe%ODs)>rz;>)>Z2g6J0u(Xf)DxObML?4{ZHsugxeze6)+y2&j4
zImGFjjuS_zb9uA|^cN&o6pihopX`!1D2&&DK=tz7srPn~aSD0TXmA>G0!~fdG)P03
zAzIeWRLRY!9n-8svL*!=v0#_LL0_tI9hzgSo~@2iSD0-@+u{_<L`Y<8W)rsGwH@&?
zyx0&QPbAl*0`HEy$suU6!Dm)Mr6F?goSwnlaDUWj5Lq@Jj$p@!>Y%h2qql=kt8s*K
z!^-<C`hZ1X;|7YjHicW!p4U+LSG1W<zt<TXn|go-h|R5R=3ceBuWmlJvzU24d<$k`
z;FsM`8raXV12b+Fb#~Jb1sa2C-<4P5RMglC4>!7Uy_>yGL_7TbJF0<P_eP@CaTj5=
zy$qt5uS#{bf&A1}m2hhtPQKN0Omp|#vdHtAIZmb2s4~cOWADg*K@xuIpQp3mS|D#F
zD#LO9E4Od=S=ZdCEw5?{nsNEg0c-48z6Ems1`>u^UnbO;B;y%pLN;*U!YJOebdb7$
zWCDc7<WB?_AW-u4u4XfO`jc==!MuZ$YShO5c6E~|xP?*Exh@PvcEu?9K-v;oxFP9_
zuIyck&zDh+Elv?fzM$|Fjzf7Q{Pg3<Bj=>=1&*&`1>YXIbh_j<IHgjA)z$UJq(E7=
zge6cRrleldE?8U_=4zG_5INWI`k98!eofG2C1Yu!z}wIW>rm(ja&*MiooH-0{-}I6
zmljn#C*mO4)f#9UXk^@c-^0T1URF9BrR~1SP*0tif}vaG-L^U2JVRWR^|4;}-8NJm
zJoA!rymO=CK(rOYm|BwSg;&q&VZ%^#3xm))u#BzPyo+Ycz-2(>{95ewf#zwi<o8cu
zmdj5Un*ye*D3`q^!lO8Ma(;anp>@(E=mS+(PxW`b`IRuIwG2~*17e&mrp}#11bOWn
zg+C<ByxPGrG7zXEhoYoh>1(1v#M@2*f}Qgo39U8uGfnGwBZ|5Nas&DV$$4Y^NkWPq
z$2_%oz&2Znb2pjKPYla3iQ5scEcccGnb=_V^`6p#rgngT)DjpeF@1|ND$31K;U5Jm
zvI&w=?XeIv%Y^<W?u|HQorjaw4aTRtd5vJ3r%`LVSGJ)evTzC~8GzL{3>^1^-Ch}G
zelmj_Lc9pWT1R>GJ7`W|4tCZm3?NckWK?Nt#+cOedB}zDEia#eL_!6eW1T)vfknOc
zkPZmBPLjALWyF`P9*gM4`cjv&l`rG&H{mT~WF^?LcEoasFXfSjU9Rx?*18y-f1dLq
zW~zk4rogpGB)%`F6>zsK8kr8+q^Qr!aAg-oTO`)iG;y%h77w8Ruax`izXn`mFp_*n
z*KB3LU+~LC&Ozll5YTmzOA0#nS)4PSVqluKDMnP^cOw~Wuzbead06rg&6uEg^(v9h
z-B~#bXT}ha?c#yY6LEBOB{Q%oJ0_>WJ8v|6VlwKuH(%Lt#9%AR9h!Oq8-ia1r0(dV
z<2KV>i@=v1=;v$@*Ka4FzrTB@9?HDJ@B+6}J$TuyyjO*N&1KL&;^1El-@t}Qb~uiQ
zr!U=_BCQc(dgFJi;-V%ah+?5ft84zRdFHg)Nia!Xqbs)Hp)dGd26R2I<t5*mnw$(W
zzv357o<})zpD)vD!7QrigN<H;XcZ}q7r4tjlGOq(3uH4Be!(|I?;awPQMF$RT70g@
zH*xO|g_0^L@6+5$3;TY6n+I=dbJTH#plXE;&Y0Yi!kFO9Nw`_fv^>yMmySwBB87Xp
z>5am{Dup!>#&$_z+RhI@k=W?SoObv*1odwGC#efjLg@@>7rvOa3L3>WiY{NKE&RPT
z!r&2GM!d!H?S$wZg2V+4F3l@)OnHn@+74v4*@1Ra4_2q0P<K=wldR+2s0NHhN>6gK
zDbqN^#fVTKulF$-#VnU<N<1d=Cl=umtnjEHA<;6Gwxco?N5o3|$}h}g39xV7Zz-UP
z2d9_eJ1+NMUh~0<)dY>7%+4-He$W9RWx5+<r`lw2JCjWIjv5~I1`!lh%jlC<(P>$o
zd*#c9CVZC&(EW{thVsek^)jMS7S6P~bZ=#v@V7zw2IAr*lsCrz5i>m^b)OTU?o8De
z$FS_WMiT<EwFqve7zp?Hb?dr6wuDVF^)W7anl!6SX(=aTjF(I;3uW0d$tJyX?fJI0
zn19mtxJ{b#?Sm|84YtKhHQ`<x+G9l*C&+!ddW4{SvtZ1`vN3c<mxFX5hwavbQej3#
zCi!C#TF_e;?PH`9+qA)@nB*>6e%`TrR{l9<-vwlu9v5K6t_utj?HqLx(*9dvdJC5S
zUSWy}T=_e{;BT;$DLz_!&Yfk8Zuy~wr}QNP1Q#cFrLxs0XHp_N(hgnR%^I$0Fk#v9
zZS&)lXNzjv3P*<OwQx4>{@pa_+w!JFM%u}{rD4eeYM!F=KIip@RvndS{p|JDyPk`X
z4RoMf=QSjKkGhh0n^pvqI{RB;@(JIoShs8wuqLVI_OJ$tY;q(|XB1y5izQ{v%Q#u=
zoWP{tc^As7THby;PPssv4DsJPL-lvR&d;%6kG?Q2-}A{<Cj^*`V*ZgiWN9TaaqTV!
z3^^l=LaFRVFLej27z0H}a2dWGUqcCek#iaG8GS5+3>Mm$d@1iqaY$hN4F5hHs8{{o
z8TX|Jzxu)#&l1F=GEFn4)v)`{6P=JLya>DFO7*7<%hsx~oU|ne&x%4&o_Ly0e1W*R
zRZW*t<Rhl1o#klQv{eG3Q-4S!TCx&;`cdj#<TpRWBwskr(YNyU>PJsbFHP1V-Y5Eg
zlIg^-b(D}CLgL~0*N3KwT$hCa4Q9geT>oGOrvgNoyTL7ObB#4ENxY>t*_p&7zJxe1
zQc+|^h!;-svvfk|ykg#k+5VIOTbukt;bl@a(tMgk&|?o#Sc9Mk#;!d@GoqE4!&0o|
zj+=94fEC9?q*_&h>jDP)=H+k5Wbz08xONq4vWiZEwD$XSqHF}xJ}r;fZ72J<!Y*pp
ze)d_^&R<^}oe&#k)q=<dN!sPW8E}@d6E)3i7!#TgzgzE?`^Syj5FZ^)WIvvd>`m(B
ziYH`V)~2LT&etMKkGN>8$#0NQ3(G`;6w`58Dbmt%_SreU14|$S$XP%UyJg|_As%I9
z3#?p3Q%3|ozPUh-AI|$-_{{7qYsuXDsb2*-D1-=8$PU;oRUPY=r%<97i-^9=7Q8I5
z{br^@OfTJf-yw)=qh%L=R(^2}NL}=D-2XjXELs%`#ZX08FVh<iXN^2qTb~)PsC9o5
zdbbQUzMa=9RX`D|7zX^sgCY)>O2fC4=4<Z9lEw}-Ea0j8Vc3qjKpu-D7`}anOAVS5
zM?b{CG#QUuy_BsbxF>b;a{;$lnH@J(xng}t2z#QYLtJ`eKkQso9QBLL<v3D<@=K`!
z)^a{})Rl!Nh|Eb)6O97Sz39aYh2nhk#p;=>ELg#H*{Gfvx=Zy>#@v{d%{@Jb4z>$L
zs&o?}c6DMgJOc~^b0i=3*r=PFAZWh@xM_;UmZ5g286cr^F9oJ4;$$A-2TO3ue%pax
z^A9Y`dan0Zs2k|~mP#P)UTG}IKO#`<Fn6pq^2dneo?Wuo>Z*8}p}*Dc!5us^lv1o9
zb6Vf2ly^t#b=Va1OF7*Vc9Aif*zY_Z{k;w;PnK1*y*~wbsk6~XnDx@7^QSV`vNV#T
ztC_nQF{<on9BO|Qg(-K?T0Py_D7%fD<=bpiM0H{_OIn+lgG62MsBOr=6saNg=~vKt
zyt?|&bE==E_U;ROBbT+~v;bG;+x7co8(`jthA&Ae1)z{&rDHLDxBwb}376~zT6&_u
zYS_1inOm^}S2?>auh{tpo<M5dLJ2@@{artd4%GQ|rwXcrCbQ}pHCq8@&Dk-EH$)D>
z#;FimAR;#6c_rd2Fs~~=GmT}kAYS9L7gJ3E=l;QN0&!foup={Gxj;k74kG6nexcH6
zBtax~?uA@B@U_`nfc-@TcPt?fvP`fW?!*wU`k-1!y0<azQO8i2F=FUqgfK%_IKZto
z=N`RXh#O?7H)PaPbI)pHAN`V2Vh=E}!ph*K9j2^6O)s^g*5;C3+ct9$_{Q;5aD9bo
z>l@sl%~r$`+f+j*mG+k3ty}K-J|LjMU$~xH;X5Hei>ZftIBj{TE`QGBH6EJZyh*m6
zKPOoCpeG%>gY<y2oGb6FfKy7-T%!(Pm6xiXEU-yO(M^IWvYvF%h&bgyn6Dz+;f@h*
zdDB~F!sj(!&ko1~%x=-zzHgfD&aCm%zyp8m2BQNUT+|q(nk#fW635}g@HG4O9jlZx
zT)y(|9+*{B&^4?fh{>>7k)J_yWWAG@n6g2qIlH2|o9AiN$0v^Le8mBiM8Z#<X*F6n
zneDcESj>#!5I_JZzt*(2lhOH(Nw*A<>}fvVd~R-tM7QkZ=Ql$2zZ3q0ldco(MrUln
zgHu!brMmFcYW_U<RPCH;dj#Wt1nzDwVv#KBI!Ux>K9`6eJ?&*o%+Ljj&fC8OC`g2P
z$zhzce^JYN8y3NDxz+O>cPG484Eq!8nJ8y@v&gTe^#gBtR?e}9H-ZIC&iNXWoL0Un
zdQ!BVf1{aZR3l64gstG-9&XW<Y)!r%@-q-C5=X$+nUFgE3TQZ8ZIo*HZOAZ8yAf)o
za>*}d6!lxtYQG=b07RYO1ipCu(T29vZ%1FD>t%va;At<W`}OSZ)CZ!!H6`#uX(Yk~
zBVCK=h6r!ey88NOOQZY#Zl@b?_53hl@SXQ*+4cnt_WAxi;`8L%?e^TVX#4UE?tYm7
z=a~D~<Jn9$Z4;B>hgJ3%R)q9ehOX1x*}h&0KrbT8ptC+k8oTiA&-fm9Y`<JhbxWXP
zRTw@FdVDay)}e%(K_WZ6`+ntpP2yp%2F+T;^jxB879cheKqI_(rRV>8kH-SLOq#*<
z;^Xl=vi^KJbz1Iwq=ih%U`#Y^Wc2#u6I#m?X|d1wMbZQp_;qhF=c(jW_I-Rcu9eCx
zZw~+p&W(*mBcbaR=@rubnsds=^ex)UJpEh$!TiQY3eN^vpTu>E^WMw#=c@ZKk;glq
z-n{a_zpCMX%3lAeAO0_m>|fn18y71t=f70N|D~?|dsK&9@BcscS4#YE3R^z5H&yNb
zqORqN>_F*Zg_ra!ZpFCc^}P+t$G&;74rRhy6*>sJv@$f#3ZZD+!mTg1`>LR-RO*Us
zQN%+cuunDd%sJx0On8N6e~r_e0Tr)885bg%GL~ezW8fu>Y)fqPADsE`YUqE8fZ4e@
z|96Z+s%>#lY{+9Rh{-($szP0D_J+4Pq&-3cY;5uv@5F9xRQQNQtf|Igo|ZtSvfIhG
zxz-o$`G>G&8RU*5_9Hk($rr7dl(<YF>IKvCfD3yR3!JVqEDo&MkFo=p4yrMqDr0H_
z7O#m{4R{Wo2nooXtdu?E<12F2`nwz&F$Izj^#YCqiZf;oIcBSmeT&Y6E9VN8d`Pal
zDH!_-*FH<ZeZ=ja9V4k{EF_-$)#eQa(L3?i{8A-&jBdWB?jesezB>-BKwvFU>D#0Q
z>{CNH!=3mzryV+u$6pnCzr8x$%lXZn@Ke8PP{4^$0hjJRA*Ou)z3dS5Zui+k<*>ES
z>pMF$)As*B=zmaE^YH!ed~)z`sj@29Hon6&DW*o;l}<*a3)U4C4ow;ZnVF-S?D%R?
z55bBimzB|BB7H)dMFRA08#dO3@y$U)BT>RNbHkbFplZNs5WZVTBu4(9u-N~KzyB>1
zx&9BK$WhPv?H{m$lXw3gSTI;)?;DVPIW^5u6{P-Qx;qj@{Xdxg?*jLKh8Xw%#WWX}
z#y?CK7fb&?rvJqV?vN<#XM#+?yTaadM?(*XR`%AJcVjr{<NpD~Ut#;d`OnAtzh4%i
z=&`@IqQt2}FFfSyhex$<Xd^F+!CoG{Xgb5K2)M{(1uH>GP`3VcG|q;4`cOFHxCF-A
zzXb3i<V<k8)2Yj_W+?5~B=ZCm<+9KkXMb%3?Ll21kR1O9gnySI_&0>?Y+V04L@s6d
zYA81NUwhbHqD7*Z@Ox?H9vN#skF2E;7z-O@=SQi$!6}S)n0M-(ptspRU%kMpOoc9n
zN21OU-9e6R#Ay9c#pA{e-R3sg!fJAfPjVE$93)bd8|nC|d~DNo+UZ(o6w_^HM|<YR
zVjCzz@#SFUm1mpG`tnc8?y@c-yZIyVyuqjpPOFgFuNc=t{ied9@;`=dN|)0l+gXNV
zXVc{o6giitPlvH51$hc%C&|TBb^R?tvCju71yGo*Y%PqUE*klnROaBBZVtDZJu-l<
zTGW5w=kGEM|Hcm+&;R8T#>!*%lOs#qW{S(ad-c6+oIUVg_0btia|*x)j<HB;I2|X2
zfQJ&JZq0yS0-1DooCuY^62wGwnCRt>0oZ44JJZ{G)Bthw$N3NVoq3m)CLuN7IM@Pt
z(l7}P>0KSruCGgYPkzP6T4?}&W)T)Pu#U$)388;={OK4P_e5dfU<vq{wu^_yR6$S$
zQkXsllv^<&A4Z9}j$Y4sR9~`UoL)k$iwPV52bcdYHSupQvvaWj?;#-+EAIgP@t-dH
zKm@boCi3@QehvRgvx+V6xxlg~#xlJOg)bz2ssxxQV|9iENz5Ax<R0~yiYjdoGCR@P
z6|4k0dS&%zAf~s5fUTN7S7z-fd^}{OmbKcK9p;`ibJ)sUEmvDpu>3K!nc?8tF>1Mz
z-1j47^nrIvjjw{<GL9P~P0Es}SDN&=cB-JlY)p%Ol_yeB4=brZWAKmG?~%>$(;D5a
zdB)!H+y0hrVls{2`}E+Y(ZFTZgxwjw>zd^02fN0IAP<O)C-rAL=L+&~MGKQFUp=0`
zu2MccLtXW1ko*V2{w~JxZ-jBM^86nNi<h@~dz<}#ty~LKRMi@`FpW{sBDI%z&`XE}
zbKVck2QO0*A}A8QS|iNBD9+F@biG=s<l_>Fj|8oor68@;%tw}2w6e5(m5;R4M6NeO
z(Qc-eQdWAuea@UY!^2anb%(XrKIcFC+yCDG{`TJg-mLW}HVv8;+ily`W3T?OqF?Qj
z`f0}_BhEg5@39`q6Dn&*W@m=Y=U<#T?d*lZ^-C`eDA@0CoE%-XxU^x>nFHO&pRaoQ
z*r!9sW=DQ}Zl)t{Q{%%*&yHg1s@GQEUvnaMa>$YUULAAgw!vEuEDJj<#0E>=$Exj7
ze9o$0rhPv3*B9866Go0L$XGqK_XFdS9&K#w_+V+DoW(uQoQe-VJL04K(f_FUTXInR
z`AZx3ObtGNyne#24INi5**74{vF=-MMy#vnoba$+m)^M0P<?b_!v3GuMMwNN?C5OH
z6L~)WlhcQHeLeqL{oM8`^WMr2|Ka3X*O#$RY|V^I9-o`$dDB_;Xj)VH9fvk=f3I`5
z%LU1aQAG>BIQRJWeVry&7W9}r;_5A7)hF&t3CTKk{Ef8l*F13SKvVD0N4&k;uzefO
z4kL2EZ~Nr=18xrjS*NBg@B35Vph5c`Y?RpK&N*6;vF*?(>bWhUC5OK%DQzs7^KQh6
zTfSe@J}>9jv!YA5{hRj1)3a8b%3qZ6%;t}s72b>aVo`LbHKDy6AyXDr-?gk;T=)9#
zs=o2OetzH2iG`ORzx=`Y6UskJXYAh7>(<ZCW!C*H4ydZF-F<Dv&bl{`JRAMrM{UmR
zl)b^5mTqwj39idjzFIwSaBoZ8l{Wg?me<6{zu(t^>6_=ahu1WA*4?AFP5EwRUXQYr
z*RTIL?B^?e4)#dS=r6pqFv?oIC?Y$vKJMwt9U*_8-Qda<Bl;&>UtAZ_bii`)nbOmD
zG@baO^6f-^alZ0wC$9ghdwLy85nnFsA6mPtZaa6i%Or15)|{~QW2gfwo;dO@<=NTw
z&dwjc6k67&^N7?A*WdEYdu?3VJ%hGiOuS>k!jRL#^-;fFD(bQ}b6(^Em;3#%$Gx&L
zB<Qw#7rwl;@7Pi6V{gCBDa5Dl-!?jC`j$=OuHCb-Z*AuxS4ww0`Eo}2@((5!*6g=7
zL}ngs!$fWPK`i$N9HG?o-IHLVU$$5TdRybYTf#b)J+R@oX^DG+7cS0E`Fi=KMPn-W
z*qiz)?%lNwiF48_oR?e&K3lu~T6O1}pSqs@NVhc+>qmV0*Uw$+`Qg@M+vT~7C%#jD
zX64kG+0~OToH}|aYR1`t?1zrG-&5$-1NVi@Py5#=YtJ1TQ1O?b(%ShyB-B{G4LclB
zH81-3l8mKkF%5Sveywrp)8*|3eq2Ad?%>Y7Jzp65PRttzCsfE?>CnuB6;G~SFk?|@
zhs3-GALBdK?AkLWLHKB{vizm@wiiATwD;|qD{9tcZ0%~lsqyBqU&Wo`N0gMe`{>{O
zUbuX<!>V7$Nv-Y1{aHs%+?Y<M(>&dA;n3MbDi@R{JRjb3Si2pcHk1UPo}S%d$lX<P
z$G7gA6a8Ftmv;Zz*kwr@s@rhX819eE;CU$_?Za<PYI>!reA~|6XP#uw&MLb8-Snld
z(42v@9+|PZWck3@i9t)d_YS}7-HV%6R+cAc4|-%uMpoC|C+EER$=>j~W%pkw8Qy<(
zczW5AyBEaRU7MyK7rSiOP?1?vzOJmAo_A$qLHDr7tH$&xUO4!<9sR9!r)qocs`+wD
zeO1}}(^lNX1h?)DTqk2M&;moL(Vnacwj#UlDfQupld__d>=SHR#hEr&5t+cAB5z{8
z%>%G?q|Nut3WCK-FiG~J9FMcm>-JELFDz7M@p!Kqc8chLvC?dl5WFd&Wz`x!K?~Rv
z!_X{4#qd}j8A;(0b_r%43++&mYV&%WYE-9KnkFNHKmQYn?u5prBiIxII;o+jEY@Tf
z;xmy@R7MCaU1YH)IUNo=0!fj`QDZ1xq^yN@kJFt?iEu6B(NIc)Lop1YsVE5_M<TEk
zMb0Y^ApjL6<5LEuU<0*L3{JRK7iD#$1`7k-RxeJv2nuC=%$e)WM{~3|T1KEP)k6Ai
zY>YsF4b=|cz+kXOfi16y;@CfAy7;0T5-m$%(RQMNyu`2^nwe-T9A<as<$EdGVjZPF
zqQi(1=FEwA<rUb;U}t*mld{M|s%^5`BXo#o0|RyG4*D2Mr0M@hvi#Y4IP5h%$ia&=
zC37+*a-u~MXiAc4ij@S4!_kH$0qrE;NqG)uE;Z*QQr;|C^zR(Xl0@pzlfW?uB}NP&
z^GK*jktqp|xCqZwfO3f>fu&eQupohGA|(i@1Z<ahl$Fr{8qXvr-#H{iL6d+dbt<xg
zT$7Pp?F=VbNKP6-Iz^HQ!V#>1j%#(GEcB|+91latY7#(a@~lW`FXSS_qJx@V9(n~#
zMNT0&L{LL6!&oF&6HCg8su4&|^s9qL42U+spcbN207f;6-Z+x0{2`in@<J06k!F*w
zksL`K528*>7Qr`W{;ISGG*GL8MUMd!NUP9t0w*-khfB{fWY|14E2%Z`5(?qoiZq|_
zz+XQpMT9DuP!oCg*FqXa(-!rcuL4C>C_ND(XdECsXr5GCgBOGo0ZHWp;e?)4uJ|}X
z_z;*#yVQ5oLAaqO(sPj(FotL=;XoTn!OErb0=s}1kaSMyIWY>x-J<5?IUuQHt$inD
z{E6^_j4H{EtG>XKM?6+_tRxv^b%hbtr(qQ13&%H{QZHlhbtHw6RllZEtS|E3Llg!X
zG7FYp*0;rEP#AEvoQ-1DMW3w1tWSrVVtqOaVOOo3Z;e--2~>p`hngZ|an=_zvS$nh
zBQyoZ_rTM3JQKLJ_~Rm46XVI&B+INQF|vfcFUQtgKz4_C)&$J53Qx0=L^dN893W7^
zoC%l)jaiXVcpV%dP{F(znCC@N;%RaTrZw9Ts9?ba%rYWFD>O@Ef7F_72vo3W0;UCy
z6F8Z{66n)x2vo3S1{Og(PDTTCupv;vvKg4AWrgQ?EXY31hCl@?W?&k9W@OxX>tI8m
zg5e(oI3O)q!Z57J(j4ZvPqiV?&}JOtaB^S-8S_B{8}Ay{jAAs$@B&XR9JOKAUp1sT
zzj#RyVJ&@>X~r+m(53{VX^xde9#hw+*$`-GGls$S6KNUT_LIaAXlPT4F%mj0GLm6!
zzd%Eqa*P(S_A#tr==KXVv?<AG5t9;AQ6DVY5NK#~mcbR4C0R6B<`<}Fteqw-qv5g%
zoH1bjcMWUCF*H+P;HwC5AT_2K0u61-GAsu0#uzN<I@&ML(56gd!3~DNwARsvKtr1|
zP2mJgY#bzX-F|_FHf0*aN<4@P@5qNX1RC0mX{-op@aVRV4iIQ)Go~?Qs5wFM>kbfT
zXfvi^*_3EW5U_P>Ee{ZAXfvj9@E>?u5_x@&1PD|#HqRR~jpZcxu!00<PSYJA(9mXF
zV|hj-%Q(DZAKDOTXmhUdtf*iqHkj%cXlPTeaWFX}vc|e(2sHGKxu(&RA%`MsJY1j~
z+lLGd9BWb3x0(QfhBjrDB69f2ijHOt!Jt6_XR?4ZK5F&-gEqhwGlT)RlZG(xpF-LJ
zRSOwyO>yRu<1#!=;&$O=p6D*dfl}?cPYXO!<9;C#agoWTKtG(`3k%%d0_S+@DK1uy
z<?pBRz23s2IIDG%|5L2nlNSXC&*RQ5&Ow;vKvZF_gBowknFuYu8c<TL-syHFk#N-g
zlH%Za@VG+YaXTZ^Y&6YA(sX20fL$hg><$ag7n}trHQx^hF#%)dp!_m&fk1wg%O_*8
z2(^;YGH%dYl%r)_<+YG;aBN!3FtuBi!vUbV3~%rNTgo`%zLKB6eT*QGA!#Oq4+xi}
zxr`Bb93orD6s$9?WT0tFnXKS2(;Umv<gn3PhPDu=n*0LVCt?w9A;UV+s+@?mzEwFG
zu$7F*A*f}2<OtYOCd;kLNla_K5|4vx3#=r!8goX*<ZW3F>wL@cWn^%wRXGWV?dCeb
zD_k!5WnPcXSz!05A=@*ZQ|#a=?wQ<fGQrei&TyB*jf)@k1+%rtYx8(jO2Zcbrz0Yg
I9~x@;AHJz)@&Et;

literal 0
HcmV?d00001

diff --git a/docs/source/notebooks/Moebius_network.pdf b/docs/source/notebooks/Moebius_network.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..f3d0364ef7f91d7ec2d7671adde284cffb32e6e8
GIT binary patch
literal 13823
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
RXre*zU=d<s8ityP{{tsx-zNY7

literal 0
HcmV?d00001

diff --git a/docs/source/notebooks/Moebius_si_graph.pdf b/docs/source/notebooks/Moebius_si_graph.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..68c9cdc6ac7063f9a9b8f7c00b9e0f7df50e0ead
GIT binary patch
literal 294325
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

literal 0
HcmV?d00001

diff --git a/docs/source/notebooks/SV_si_graph.pdf b/docs/source/notebooks/SV_si_graph.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a585aa478d1fe6d3ff0d70d7b9f5476a79d32714
GIT binary patch
literal 10674
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
KiK*;Yh5bLXPxZC{

literal 0
HcmV?d00001

diff --git a/docs/source/notebooks/visualizing_shapley_interactions.ipynb b/docs/source/notebooks/visualizing_shapley_interactions.ipynb
index fe3f1a9d..b356f014 100644
--- a/docs/source/notebooks/visualizing_shapley_interactions.ipynb
+++ b/docs/source/notebooks/visualizing_shapley_interactions.ipynb
@@ -22,8 +22,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:33.397609Z",
-     "start_time": "2024-10-23T14:47:32.122515Z"
+     "end_time": "2024-10-24T12:22:45.017956Z",
+     "start_time": "2024-10-24T12:22:43.699244Z"
     }
    },
    "cell_type": "code",
@@ -56,14 +56,14 @@
    "cell_type": "markdown",
    "source": [
     "## Load Data and Train Model\n",
-    "First, we load the `california_housing` dataset and train an `XGBoost` model on it."
+    "First, we load the `california_housing` dataset and train a `RandomForest` model."
    ]
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:34.410817Z",
-     "start_time": "2024-10-23T14:47:33.398610Z"
+     "end_time": "2024-10-24T12:22:46.343969Z",
+     "start_time": "2024-10-24T12:22:45.018894Z"
     }
    },
    "cell_type": "code",
@@ -78,7 +78,7 @@
     "x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, random_state=42)\n",
     "\n",
     "# train an XGBoost model\n",
-    "model = RandomForestRegressor(random_state=42, max_depth=10, n_estimators=15)\n",
+    "model = RandomForestRegressor(random_state=42, max_depth=15, n_estimators=15)\n",
     "model.fit(x_train, y_train)\n",
     "\n",
     "# evaluate the model\n",
@@ -93,8 +93,8 @@
      "output_type": "stream",
      "text": [
       "Features in the dataset: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']\n",
-      "Mean Squared Error: 0.3007068550571449\n",
-      "R2 Score: 0.7705244240154585\n"
+      "Mean Squared Error: 0.2731205827334615\n",
+      "R2 Score: 0.7915760748983114\n"
      ]
     }
    ],
@@ -103,7 +103,7 @@
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": "With these hyperparameters the model achieves a reasonable $R^2$ score of about 78%."
+   "source": "With these hyperparameters the model achieves a reasonable $R^2$ score of about 80%."
   },
   {
    "metadata": {},
@@ -118,8 +118,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:34.426812Z",
-     "start_time": "2024-10-23T14:47:34.412807Z"
+     "end_time": "2024-10-24T12:22:46.360063Z",
+     "start_time": "2024-10-24T12:22:46.344975Z"
     }
    },
    "cell_type": "code",
@@ -138,7 +138,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Instance 7, True Value: 1.575, Predicted Value: 1.692269408153201\n",
+      "Instance 7, True Value: 1.575, Predicted Value: 1.6279253275277228\n",
       "MedInc: 3.6908\n",
       "HouseAge: 38.0\n",
       "AveRooms: 4.962825278810409\n",
@@ -152,6 +152,15 @@
    ],
    "execution_count": 3
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "For the instance with `instance_id=7`, the model predicts a property value of about 1.62 (in 100,000 USD).\n",
+    "The ground truth value is 1.575 (in 100,000 USD).\n",
+    "So, the model is off by a bit but not too much."
+   ]
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
@@ -163,8 +172,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:56.223853Z",
-     "start_time": "2024-10-23T14:47:34.428806Z"
+     "end_time": "2024-10-24T12:25:24.261892Z",
+     "start_time": "2024-10-24T12:22:46.362063Z"
     }
    },
    "cell_type": "code",
@@ -182,7 +191,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 3/3 [00:21<00:00,  7.26s/it]\n"
+      "100%|██████████| 3/3 [02:37<00:00, 52.63s/it]\n"
      ]
     },
     {
@@ -190,15 +199,15 @@
       "text/plain": [
        "{1: InteractionValues(\n",
        "     index=SV, max_order=1, min_order=0, estimated=False, estimation_budget=None,\n",
-       "     n_players=8, baseline_value=2.0718777703488365\n",
+       "     n_players=8, baseline_value=2.0718777703488374\n",
        " ),\n",
        " 2: InteractionValues(\n",
        "     index=k-SII, max_order=2, min_order=0, estimated=False, estimation_budget=None,\n",
-       "     n_players=8, baseline_value=2.0718777703488365\n",
+       "     n_players=8, baseline_value=2.0718777703488374\n",
        " ),\n",
        " 8: InteractionValues(\n",
        "     index=k-SII, max_order=8, min_order=0, estimated=False, estimation_budget=None,\n",
-       "     n_players=8, baseline_value=2.0718777703488365\n",
+       "     n_players=8, baseline_value=2.0718777703488374\n",
        " )}"
       ]
      },
@@ -214,7 +223,13 @@
    "cell_type": "markdown",
    "source": [
     "## Visualize the Shapley Interactions\n",
-    "Now that we have some explanations to visualize, let's use different visualization techniques from the `shapiq` package."
+    "Now that we have some explanations to visualize, let's use different visualization techniques from the `shapiq` package.\n",
+    "We will showcase the following visualization techniques:\n",
+    "- Force Plot\n",
+    "- Waterfall Plot\n",
+    "- Network Plot\n",
+    "- SI Graph Plot\n",
+    "- Bar Plot (for global explanations)"
    ]
   },
   {
@@ -225,15 +240,15 @@
     "First, we consider the classical force plot popularized by [`shap`](https://github.com/shap/shap/tree/master).\n",
     "Similar to how Shapley values are drawn on the force plot, Shapley interactions can be visualized as well.\n",
     "Positive interactions are shown in red, negative interactions in blue. \n",
-    "All interactions **force** the prediction of the model *away* from the base value and *toward* the predicted value by the model considering all features.\n",
+    "All interactions **force** the prediction of the model *away* from the base value and *towards* the predicted value by the model considering all features.\n",
     "The following cell plots the force plot for the SV, 2-SII, and Moebius transform."
    ]
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:58.542089Z",
-     "start_time": "2024-10-23T14:47:56.226785Z"
+     "end_time": "2024-10-24T12:25:27.045889Z",
+     "start_time": "2024-10-24T12:25:24.265880Z"
     }
    },
    "cell_type": "code",
@@ -252,7 +267,7 @@
       "text/plain": [
        "<Figure size 2000x300 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -262,7 +277,7 @@
       "text/plain": [
        "<Figure size 2000x300 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -272,7 +287,7 @@
       "text/plain": [
        "<Figure size 2000x300 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -284,12 +299,9 @@
    "metadata": {},
    "cell_type": "markdown",
    "source": [
-    "Notice how for an increasing order, more interaction terms are being displayed.\n",
-    "This is to be expected as with an increasing order more interactions are part of each explanation. Formally, the number of interactions scales with $\\mathcal{O}\\left(\\binom{n}{k}\\right)$, where $n$ is the number of features and $k$ is the order of the Shapley interactions.\n",
+    "The first order force plots shows that the prediction is **negatively influenced** by the *AveOccup* (AO), *MedianIncome* (MI), and *AveRooms* (AR) features and **positively influenced** by the *Latitude* (Lat.) and *HouseAge* (HA) features. Ultimately, the prediction is less than the base value of the model (which is about 2.07). The higher-order force plots show also the interactions. This reveals that the exact location of the property, encoded in the interaction between *Latitude* (Lat.) and *Longitude* (Long.), increases the predicted value of the property. Notably, the interaction between the *HouseAge* (HA) and *AvgOccup* (AO) features has a notable negative influence on the prediction.\n",
     "\n",
-    "Plotting this with force plots can become quite messy quite quickly. This problem is exacerbated when the number of features is large In this example, only 8 features are being considered which typically is not a lot.\n",
-    "To solve this other plots can be helpful.\n",
-    "For example the waterfall plot."
+    "Notice how for an increasing order, more interaction terms are being displayed. This is to be expected as with an increasing order more interactions are part of each explanation. Formally, the number of interactions scales with $\\mathcal{O}\\binom{n}{k}$, where $n$ is the number of features and $k$ is the order of the Shapley interactions. Plotting this with force plots can become quite messy quite quickly. This problem is exacerbated when the number of features is large In this example, only 8 features are being considered which typically is not a lot. To solve this other plots can be helpful. For example the waterfall plot."
    ]
   },
   {
@@ -306,8 +318,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:59.559132Z",
-     "start_time": "2024-10-23T14:47:58.543082Z"
+     "end_time": "2024-10-24T12:25:28.367703Z",
+     "start_time": "2024-10-24T12:25:27.047881Z"
     }
    },
    "cell_type": "code",
@@ -322,7 +334,7 @@
       "text/plain": [
        "<Figure size 800x550 with 3 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAILCAYAAAA5aweuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC+LklEQVR4nOzdeVxU5f4H8M+ZGfZ9U3YBAUElEfelXHLLtdzStLLNvFm3+tW1fbttt7otN7Uy27RyXyrNXcM0dxQRQTZBQHZkkW2GmTm/PyZGxxlgKOCM8Hm/XrxknnnOOd8ZFc53nuf5PoIoiiKIiIiIiIjIgEzqAIiIiIiIiCwRkyUiIiIiIiITmCwRERERERGZwGSJiIiIiIjIBCZLREREREREJjBZIiIiIiIiMoHJEhERERERkQlMloiIiIiIiExgskRERERERGQCkyUiIiIiIiITmCwRERERERGZwGSJiNqcVqvFW2+9he7du8PKygrdu3fH+++/j4iICGi12haf74svvkBgYCCUSmUbREtERESkI4iiKEodBBF1bMuWLcM///lPPPPMM7jlllvg4uKCBx54AP/973/xwAMPtPh8dXV1CAoKwosvvoh//vOfbRCxsfr6epw9exZFRUUoLi6GUqnEiBEj0KNHjxadp6SkBKdOnUJhYSHUajWcnZ0RGRmJ3r17AwCKioqQmpqK/Px8XL16FTY2NujatSv69+8PV1dXo/NVVFTg5MmTKCwsRF1dHRwdHREaGoo+ffpAoVC0xksnIiLqtJgsEVGb69evHzw9PbF7924AwCeffILXXnsNhYWFsLW1/UvnfO6557B+/XpkZmZCEITWDNekq1evYu3atXB0dISTkxPy8/NbnCzl5uZi165d8PT0REhICKysrFBZWQlRFDF48GAAwN69e1FQUICQkBB4eHigpqYG58+fR319Pe688064u7vrz1dVVYVNmzbB2toaPXv2hI2NDQoLC5Gamopu3bph/Pjxrf4+EBERdSb82JGI2lRdXR3Onj2LN954Q9/27bffYurUqX85UQKA2bNn4/3338dvv/2G0aNHt0aoTbK3t8f8+fNhb2+P4uJibN26tUXHq1Qq/PbbbwgMDMTYsWMbTfCioqIwevRoyOVyfVv37t2xadMmxMfHG7zWtLQ0qFQqTJ06VZ9ERUZGQhRFpKWlQalUwsbG5i+8WiIiIgK4ZomI2tBDDz0EOzs7aDQavPzyyxAEAT4+PkhISMCYMWOM+l++fBm2trZ48MEHDdr37dsHKysrPP300/q2fv36wd3dHT///HObvw4AkMvlsLe3/8vHp6eno7a2FgMGDIAgCKivr4epgX1vb2+DRAkAXFxc4ObmhvLycoN2lUoFAEZx2dvbQxAEyGT8EU9ERPR3cGSJiNrMvHnzYGVlhRUrVuB///sf3N3dkZGRgddffx0xMTFG/f38/PDwww/jyy+/xGuvvYZu3brhwoULmDVrFu644w58+OGHBv1jYmLwxx9/NBuHVqvVJxbNsbGxaZNpfZcvX4aVlRWqq6uxZ88eVFRUQKFQICwsDEOGDGlyfZEoiqitrYWbm5tBu6+vL86ePYuDBw+iX79+sLW1RWFhIZKSktCrVy9YWVm1+usgIiLqTJgsEVGbGT16NPbv3w8HBwc8/vjjkMlkeOWVVwAAwcHBJo954YUX8NVXX+G9997Dm2++icmTJyMoKAhr1641GikJCQnB999/32wcBQUF2L59u1kxz507F05OTmb1bYmKigqIoog9e/agR48eGDhwIPLy8nD+/HmoVCrcfvvtjR6bnp6O6upq9OvXz6A9ICAA/fv3x5kzZ3Dp0iV9e9++fTFgwIBWfw1ERESdDZMlImpTCQkJ6NWrlz7RKS0thUKhgKOjo8n+fn5+eOSRR7By5UqcPn0atbW1OHjwIBwcHIz6urm5oba2FjU1NU1OkfPw8MDEiRPNitfOzs6sfi1VX18PtVqNyMhIDBs2DIAuYdRqtUhOTkb//v3h4uJidFx5eTkOHz6Mrl27Ijw83Oh5Jycn+Pj4IDg4GLa2tsjOzsaZM2dgZ2enr7BHREREfw2TJSJqU2fPnm1xVbZnn30Wy5YtQ0JCAg4dOgQ/Pz+T/RrW/DQ3bc7Gxgb+/v4tiqG1NUyzCw0NNWgPDQ1FcnIyCgsLjZKlmpoa7Ny5E9bW1hgzZozRyFp6ejp+//133H333frkMzg4GKIo4sSJEwgNDf1bRTSIiIg6O67+JaI2U15ejpycHERFRenbPDw8oFarcfXq1UaPe/vttwEAarXaoFT2jcrKymBvb9/saJBGo0FNTY1ZX39lk1xzNIx83Rhrw+MbN9hVqVTYuXMnVCoVJk6caHJkLSkpCZ6enkajdN26dYNarUZJSUlrvgQiIqJOhyNLRNRmEhISAAC33HKLvi0iIgIAkJmZadDe4IMPPsBXX32FZcuW4V//+hfefvttfPXVVybPn5mZicjIyGbjKCwslHzNkpeXFy5fvozq6mqDzWWrq6sBGCZRarUau3btQkVFBSZNmmRU2KFBbW2tydLgDQkft9EjIiL6e5gsEVGbOXv2LADDZGnIkCEAgFOnThklSz/99BOef/55vPnmm1i8eDHS0tLw2Wef4aWXXjJZEOL06dOYN29es3G055oltVqNqqoq2NraGkyBCwkJQXx8PFJSUgymFV64cEFfUh3QJTr79+9HYWEhxo8fj65duzZ6LRcXF+Tm5qK8vNwgAcvIyIAgCE2OyhEREVHzBJEfPRJRG3nkkUewc+dO5ObmGrRHRUUhKioKa9as0bfFxcXhtttuw4wZM7B69WoAQF5eHkJCQjB//nyj0aW4uDj0798f+/bta7KSXGtKTEyESqVCTU0NkpKSEBQUBE9PTwBA7969YW1tjby8PGzfvh0xMTHo37+/wfEHDx5ESkoKQkJC4OPjg/z8fFy8eBHR0dEYOHAgAODIkSNITExEYGAgunfvbhRDWFiY/vv8/Hxs374dtra26NWrF2xsbJCdnY2cnBxERETgtttua8N3g4iIqOPjyBIRtZmEhASTU+0efPBBvPrqq6itrYWdnR1yc3MxZcoU9O3bFytXrtT38/X1xYMPPoivvvrKaHRp48aNCAwMxOjRo9vltQC611NVVaV/nJWVhaysLAC6JMba2rrJ42+99VY4OjoiJSUFWVlZcHR0xJAhQwzWdJWWlgIAsrOzkZ2dbXSO65MlHx8fTJs2DXFxcTh//jyUSiWcnJwwYMAA9OnT5++8VCIiIgJHlohIAhUVFQgJCcH777+Phx56qMXHK5VKBAUF4fnnn8eTTz7ZBhESERERsRoeEUnAxcUFS5YswQcffPCXqs99++23sLKywqJFi9ogOiIiIiIdjiwRERERERGZwJElIiIiIiIiE5gsERERERERmcBkiYiIiIiIyAQmS0RERERERCYwWSIiIiIiIjKByRIRWYTKykqMHDkSlZWVUodCREREBIDJEhFZiMrKShw8eJDJEhEREVkMJktEREREREQmMFkiIiIiIiIygckSERERERGRCUyWiMgiODs7Y8iQIXB2dpY6FCIiIiIAgCCKoih1EEREAFBVVQVHR0epwyAiIiICwJElIrIgJSUlUodAREREpMdkiYgsRnl5udQhEBEREekxWSIii6FQKKQOgYiIiEiPa5aIiIiIiIhM4MgSEVmMs2fPSh0CERERkR6TJSKyGBzoJiIiIkvCZImILIaHh4fUIRARERHpMVkiIovBDWmJiIjIkjBZIiKLkZmZKXUIRERERHpMloiIiIiIiExg6XAishiVlZWcikdEREQWgyNLRGQxysvLpQ6BiIiISI/JEhFZjCtXrkgdAhEREZEekyUishgyGX8kERERkeXgmiUiIiIiIiIT+DEuEVmMc+fOSR0CERERkZ5C6gCIiBpoNJpGnyutFXGumAPhREQknR7uAnwcBanDoHbEZImILIabm1ujz719TIuP45gsERGRdPzsNch9zEbqMKgdcRoeEVkMDw8Pk+219SK+PsdEiYiIpFWi5K1zZ8O/cSKyGOnp6SbbN6WKqFS1czBEREQ3YFm0zofJEhFZvGVntJBxijgREUmO2VJnwzVLRGQxgoKCjNrOFYs4UdD+sRARERFxZImILEZVVZVR2xdntVBwVImIiCyAIPDWubPh3zgRWYySkhKDx1UqEd8lilBz1gMREVkAUdRKHQK1MyZLRGSx1l0QUaOWOgoiIiLqrJgsEZHFiI6ONni8/IyWP6SIiMhiCOC88M6G9yFEZDHOnz+v//5UgYj4YoATHoiIyGIwV+p0mCwRkcWor6/Xf8/CDkREZGlEbrTU6TBZIiKL4eLiAgCoUIr4MZmFHYiIiEhaTJaIyGJ07doVAPBjkgglCzsQEZGFEQROeehsmCwRkcVITU2FKIpYdoYrlYia42IDrBgrQ9FjclQ9KceB2TL07dLy8yhkwPkH5BCfVeCZ/oY3gj4OwPcTZbjwoByV/5Sj7HE5js+T475evGGkzomz8DofhdQBEBFd72gekHxF6iiILJsA4NfpcvTxAj44qUVJLfBYtAyxd8vR73sN0svNP9cTfQUEOpl+ztMO8HcSsClVRHalCCs5MLabgFV3yNHDTYuXDvODDepsmC11NoJogSvVysvLcfr0aZSUlKC6uhparRaOjo4IDAxEnz59YG9v3+w58vLysH379ib7TJ06Fd7e3s32DwwMxIQJEwzaRFFERkYGzp8/j/Lycn2MISEhiIqKgrW1tZmvtm38+uuvmDx5MgRBwLZt2zBp0qR2vX5hYSFeeukl7NmzB4WFhRAEAd7e3hg5ciRee+01BAcHt2s8dHO4cuUKnjrmgrVcr0TUpFk9BGyYIsfMXzTYnKr7z+JpB6Q+JMfOTBHzfjUvifGyB1IflOPDU1q8OVyOZ2M1+PBU8//5frlLhlEBAlyWaqDl/1XqRKxlWij/T9p7PGpfFjmyVF1djZqaGgQFBcHBwQEymQxXrlxBcnIyMjIyMGPGDNjZ2TV5DldXV4waNcqoXaPR4NChQ7C1tUWXLsbzFSIiIuDj42PQ5uDgYNTv5MmTiI+Ph6+vL/r16weZTIa8vDzExcUhJycH06ZNk3Re6/Lly+Hm5oarV6/i22+/xcSJE9stnkOHDmHy5Mmorq7GiBEjcP/990MQBPzxxx9YvXo1tm/fjtWrV2PixIntEg/dPPIrlFh3gYkSUXNmhgsoqBaxJfXaf5aSWmBDioj5PQVYywGVpvnz/OdWGVLKgB+SRbw53PzrZ1UA9iGAtRyo4/pC6kRkAlewdDYWmSz5+fnBz8/PqN3Hxwf79u1DSkqK0eaVN7K3t0dYWJhRe3p6OkRRRFhYGGQy43/wXbt2NXnc9bRaLRITE+Hp6YlJkybpk5CePXviwIEDSE9PR2lpKTw9PZs8T1spLi7G3r17cdddd6GyshKxsbHIy8sz+Z62toKCAkydOhX19fX46quvsGDBAoPnf/rpJ8ycORMPPvggDh061Ox7TZ3LtwlqqDmrh6hZfbsIOF0oGk0IOpEv4tE+MoS7AYklTZ9jgDdwfy8Bw9dqml2HYasAHKwARytgRICAB3oLOJrHRIk6H63IX1KdzU2VHjs6OgIAVCrVXz7HhQsXAOhGkBpTX18Ptbrx3wBarRZqtRp2dnZGozUNUwStrKz+cox/19dffw2NRoN7770XixYtQmlpKdasWaN/Pjk5GYIgYMKECdBqjf/TT5s2DQqFAgcPHtS35eXlYc6cOfDy8oJCoYCrqyvGjx+PhIQEg2P//e9/o7y8HPfeey/uv/9+o3PfeeedeOyxx1BYWIj33nvP4DmVSoWXX34Z3bt3h42NDezt7RESEoInn3wSdXV1+n6VlZV47LHHEBAQACsrKzg6OiIiIgJvvPEGNBrdR6kDBw6Ep6cn8vLyDK6RlZUFQRAwY8YMfVtsbCwEQcBTTz2Fd999F35+frCysoK3tzeeeOIJ1NbWmvO2098kiiLW57pzNjiRGXwcgPxq4/aGNl/H5mcSLL1djvUpIo7lN3+9J2MElCxWIGuhAqvukONYvog5280YuiIiuslZ5MhSA7Varf8qLy/H8ePHAQABAQF/6XyVlZXIy8uDt7c3XF1dTfY5cuSIPklwcXFBz5490bt3b4OkSKFQwMfHB7m5uYiPj0dwcLB+Gl5SUhJCQ0P1+8U0RaVSmUxWTFEoFFAozPvr+uqrrxAWFoaRI0fCzs4Obm5u2LRpE5588klYW1sjMjISvXv3xtGjR5GVlYWQkBD9sZWVldi9ezd69+6NgQMHAgCys7MRExMDpVKJSZMmISIiApcuXcL69esxduxY7N27F7fccgsA3ciRQqHAokWLGp3298QTT2Dp0qU4dOgQrl69CicnJ6hUKgwfPhwnT55EVFQUFi1aBCcnJyQlJeHAgQOoqqqCra0tysvL0a9fP1y8eBGDBw/GnDlzIJfLkZCQgL179+L555+HXC4363260S+//IKysjLcdddd8PLywi+//IJly5ahsLAQa9asMfv9p7/mYI6I3FobqcMgancCdNPZzKH8Mz+xU1z7/noNIz12zfy4WtBbQJQnMPMX834Hrb0g4lSBBl72wOQQAV0dmr8GUUckgJUgOxuL/lF34cIFHDlyRP/YyckJo0aNMlpTZK6UlBQApkeVZDIZunXrhoCAADg4OKC6uhopKSk4evQoSktLMXLkSIP+o0ePRmxsLE6cOIETJ07o2/v27Yv+/fubFc/u3buRn2/GR3oAYmJizDrv8ePHkZGRgSeffBJOTrryRrNnz8Y333yDuLg4DBkyBADw0EMP4emnn8batWvx0ksv6Y9fu3YtlEolpkyZol8X9tBDD0GlUuGXX34xWAf2j3/8A0OGDMEbb7yBTZs2oaqqCvn5+fDz82syoQ0LC4O9vT0uX76MK1euwMnJCe+99x5OnjyJO++8E+vWrYONzbWbZq1Wq0+8nn76aVy8eBGLFy/GJ598YpDAaDQak1MrzZWXl4dt27Zh7NixAIA333wTMTEx2Lx5M/bv34/x48ebdZ4rV67AwcFB/xqqqqogiqL+70OlUuHq1avw8PDQH5Ofn2/w7/rGxwUFBejatav+feiI12hJ9S6ijuS2AAGxd5uXLUV8o0bKFaBWDdiYOMT2zx+JtU1Mj3OyBt69VYYPTorIvWpejNmVQHalbtx33QURK8bKsG+WHD2+0XAqHnVaN+PvWl4jv8V5hEVWw2tQVVWF8vJyqNVqlJSU4NKlSwgPD0dUVFSLz6XVarF27VqoVCrce++9Zo0SiKKInTt3Ijc316ByHgDU1dXhxIkT0Gg0+sQgMzMTmZmZ6N+/P2JiYpo9f3FxMZRKpVnxOzs7w9nZudl+8+fPx6ZNm3DkyBF9DGfPnkV0dDQeeeQRfPnllwB0/+C8vb0RHR2NQ4cO6f/hDRgwAMnJyTh16hQiIiJQUVEBd3d3DBs2DD/++KPRaNHw4cMhl8sRFxeH6upq+Pv7IzQ0FHFxcU3G27VrV5SUlODChQsICwtDjx49kJubi5MnT6Jnz54mj9FqtXB1dYWjoyPi4+NNFuhoMHDgQFy8eBEJCQnw9fXVt2dlZSE4OBjTp0/H5s2bAeim4Y0aNQojR47Evn37DEamfvzxR8yfPx8LFy7EihUrmnrr6W+6qhLhtaweSu1NNTuY6G/rag9MCDbv0+qtaSIqVbqqd2llIiZtMRwZerC3gK8nyBH1nbrRNUtvDJPh8WgBw9dpUFOva/N3Ag7PVeDtY1qsTNAirwqob2LQaWw3AXtmyTF+kwZ7siz2NoKo1bEaXudj0SNLjo6O+nVKQUFBCA4OxtatW6FWq9G3b98WnSs3NxfV1dWIjIw0ezqVIAiIjo5Gbm4usrOz9cmSWq3Gzz//DA8PD4wZM0bfPzQ0FPv27UNcXBxCQkIanerXwMvLq0WvoTnV1dXYunUrwsPDoVarcebMGf1z/v7+2LVrF0pLS+Hh4QF3d3fcfvvt2L9/PxISEjBgwABkZWUhLi4Oo0aN0hdeSElJgVarxaFDhxAYGGjyup6enqitrdUnR7W1tc2uK6uqqoKdnZ2+xPqlS5fg5+dnkNjcqKSkBFevXkVERATc3d1b9N6YIzg42GgKX+/evQEAOTk5rX49MuRkLeCuwGpsuuTEanjUqRTWAKvOt+wffXyRiFv9dROCrj9ykI+A6noRqWWNHxvoBLjbCUh6wPh34UuDZXhpsAzRq9Q4W9z4ORqm4Llw5iwRdXAWnSzdyMPDA56enkhKSmpxsmROYQdTGob2ri8wcPHiRVRUVGDAgAFG/UNCQnDx4kUUFBQ0myzV1dWZvWbJysqq2aIR69atQ01NDc6dO4dBgwaZ7LNt2zZ9hbqFCxdi165dWLVqFQYMGICvv/4aoiji7rvv1icNDQOPQ4cOxeOPP27ynLa2tnB3d4eNjQ28vb1RWFiInJycRqsBpqeno6amBuHh4X8p6REEodky6I0931ThDpLek4PssC5L6iiILN+mVBGzesgwPVzQ77PkYafbf2lbhmhQNjzkzyW0Fyt0f356Wouf0g2Tsy72wJfj5Pg2UYuf00Vk/tnX005XkvxGD0UJ0IoiThfykw3qXKTcFoakcVMlS4DuZtfcqWsNamtrkZ2dDQ8PjxaP5lRU6H5jXL+vU3W1rtyQqRmMDW3mJEF79+5t1TVLn3/+OVxdXfHiiy8abdxbX1+PZ555Bj/88APuvfdeyOVyTJ48Ga6urti9ezcqKyuxevVqeHt7484779QfFxoaCkEQoFKpMHPmzGYTtmnTpmHFihVYsWIFPv/8c5M/VJYtWwYAuPXWW/XJaFBQEHJycpCXl9dokunp6QknJyfk5OSgtLS0yWl47u7uSEhIMPq3cvHixUaPyczMhEajMRhdSkxMBPDXi4pQy9iWXkC/rr1xpgjc6JKoCZtSRRzNE/HtBBl6emhRUgs8Fi2DXABe+8Pw98/+2bqfacErdRnUmSLgTJHhf7Buf86aPl8i4ufrEqmXBsswzE/ArkwR2ZUi3O2AGWEyDPQR8OlpLTLK2+41Elkk/m7qdCwyWaqpqTG62Qd0C/DLysqMFmbV1NRApVLB0dHR5BS71NRUaLVa9OjRo9Fr1tXVwdbW1qBNo9EgLi4OANCtWzd9u5ubm/683bt3N7oWgCZv5BsMHjy4RWuWmpKamoq4uDiMGTMGzzzzjMlCB2vXrsWxY8eQmpqKyMhIWFlZYdasWfjqq6/w6aefIjs7G3PnzjWI3cPDAyNHjsTBgwfxzTff4NFHHzU4pyiKyM7O1r8/r776KtauXYvvv/8ew4cPx/z58w36b9u2DcuXL0fXrl3x3HPP6dvnz5+PV155Ba+88grWrl2rn57XcA1AV4Rj5syZ+Pbbb/H222/jo48+MkhsGvoJgoCIiAjs2rULe/fuxcKFCwHoEti333670ffw6NGjOHDggL7Ag0qlwrvvvguZTGaQQFLbWhwtw4O7uY8FUVO0IjBxswYfjJDhn31lsLMCThYAC3ZqmpyC11K/XhTR3VW3FsrLXkCdGkgo1l2npVMHiToC493NqKOzyAIPe/bsQU1NDXx9feHo6AiNRoOSkhJkZGRAoVBg8uTJBlO8YmNjkZqaismTJ5tc87JhwwZcvXoV8+fPN6iydr2tW7fC3t4enp6e+mp46enpqKioQK9evTBs2DB9X61Wi59//hnFxcXw9vZGcHAwAN3IREFBAUJCQgzWMrWHp556Cv/73//w8ccf46mnnjLZ55NPPsHTTz+NJUuW6Pc4On36NPr16wc7OzvU1dVhx44dmDBhgsFxOTk5GDBgAEpKSjBq1Cj069cPcrkcmZmZOHDgAIYNG6YvlgAAv/32G6ZNm4ba2lqMGDECQ4YMgUwmwx9//IEDBw7A3d0dq1atwqRJk/THqFQqDB06FHFxcbjlllswatQoODs748KFC7hw4QIOHDgAT09PlJWVoW/fvrh06RKGDBmC4cOHQ6FQICEhARUVFdi3bx9sbGyQmZmJ8PBwODo6Ys6cOXBxccGOHTtQU1ODjIwMkwUegoODUVZWhunTp8PLyws///wzLly4gBkzZmDt2rWS7p3VWZSUlMDexQNdP9Ogql7qaIiIiAyxwEPnY5HJUkZGBtLS0lBaWqpfK+To6Ah/f3/06dNHX/ShQVPJUkFBAX755ReEhoZi9OjRjV4zPj4eWVlZqKyshFKphJWVFTw8PBAZGYnQ0FCj/iqVCvHx8cjMzMTVq1chCAKcnZ0RFhaGW2655W+VsG4pjUYDb29vKJVKnD17Vp+83ejy5csICAhAREQETpw4oX8fw8LCkJ6ejsjISIP265WUlOC5557Drl27UFRUpH9/+vfvj0cffdQowcrLy8PLL7+MvXv3oqioCIIgoGvXrhg1ahReffVVg72dGtTV1eHVV1/F+vXrkZeXBysrK/j4+GDq1Kl499139SN/5eXl+Ne//oXt27ejuLgYtra28Pf3x7x58/Diiy/qR5u2bNmCf/3rX8jOzoaDgwPGjh2Lf/3rXxg0aJDJZOnJJ59Ely5dsGzZMhQXF8Pd3R0zZ87EBx98YHKkk1pfQUEBvL298c/9GnwWL0JjcT+diIioM7OVA7VPW+TELGojFpksEbWn65OlTz75ROpwOrX4+HhER0cjqUREr+9M7LhJREQkIY4sdT7c0ISILE5PTwFDfQEZiw4RERGRhJgsEZHFaNjXCgAW95WxIh4REVkU3e5m1JkwWSIii5GRkaH/fkaYAFdueElERJaEuVKnwxVq1OmNHDnS5J5Z1P5qa6/tfmmjEPDILQI+OsVCD0REZBl4v9D5cGSJiCyGg4ODweOFt8iYKBEREZFkmCwRkcUIDAw0eBzqJmBUACDntAciIrIAgsBfSJ0NkyUishjJyclGbYv7cnSJiIgsBH8fdTpMlojIok3tLsDTTuooiIiIAJHZUqfDZImILIavr69Rm5VcwKN9BE7FIyIionbHZImILN4jUdxziYiIpCcTeOvc2bB0OBFZjLy8PHTp0sWovZuLgAnBwO4sbnFBRETSEAFoRa3UYVA7Y7JERDeFFwfJ0cWev6SIiEg6ocgDECR1GNSOBJG7axGRhVAqlbCxsZE6DCIiIpOysrIQFBQkdRjUjjjxkogsRnZ2ttQhEBERNcrT01PqEKidMVkiIotRXV0tdQhERESNSk9PlzoEamdMlojIYtjZcUMlIiIishxcs0REFkOtVkOhYN0ZIiKyTOXl5XB1dZU6DGpHHFkiIouRmJgodQhERESN4nTxzofJEhERERGRGYqLi6UOgdoZkyUishje3t5Sh0BERESkxzVLRGQxSkpKWJaViNrG97HAs6ukjoIsnY8bEPcBIJebfFoURQiC0M5BkZS4kpqILEZubi6TJSJqGz+fgFhUAd7mUpOKKoBdZ4BJ/U0+nZycjJ49e7ZzUCQlTsMjIiKizoGZEjVHLgM+29Xo0yqVqh2DIUvAZImILEZERITUIRARUWem0QI7zwDZpgs5ODs7t3NAJDUmS0RkMS5fvix1CERE1NnJBOCrfSafYiGizofJEhFZjKtXr0odAhERdXYaLfDFbqBebfRUamqqBAGRlJgsEZHFsLGxkToEIiIioLgS2HZK6ijIAjBZIiKLER4eLnUIREREfxZ62GnUHBgYKEEwJCUmS0RkMc6dOyd1CERERLqpePvPARkFBs1KpVKigEgqTJaIiIiIiG4klwFf7jFoKiwslCgYkgqTJSKyGF26dJE6BCIiIh2NFli5F1DWSx0JSYjJEhFZDFtbW6lDICIiuqasGth6XP8wKipKwmBICkyWiMhiZGdnSx0CERHRNTIZsHyH/mFaWpqEwZAUFFIHQERERERtzMUeeP8+4K5BgL0NcCINeGYVcOZi88cOCAUWjAYGhQG3dAOsFIAw3XRfcYvp9ue/B97b+tfjl4pWCxy+ACTnApH+qKurkzoiamccWSLJPProoxAEAbGxse163SlTpkAQBGRlZbXrdal5LB1ORNQGBAH49WXgnluBZTuBJauBLi5A7L+BUJ/mj5/YD3j4dkAUgYtmFDjYEw/M/8Tw62bes0ghA1boCj04OTlJHAy1tw43slReXo7Tp0+jpKQE1dXV0Gq1cHR0RGBgIPr06QN7e3uD/gkJCbh06RLKy8uhVCphY2MDV1dX9O7dG8HBwWZft6SkBHFxcSgoKIBarYazszMiIiLQq1cvyGTXclKlUonU1FRkZ2ejvLwcdXV1cHR0hI+PD2JiYuDo6Nhq70VLTZkyBdu3b8fJkyfRv3//VjnnihUrkJycjNdffx2urq7N9t+4cSMOHjyIZ599FkFBQa0SA908CgsLW/T/joiIAPz2byCrCHhgmennZw4BhkUAMz8ANh/VtW04AqQuA964G5j3SdPn/3yXblSoTgUsfRjo4dd0/9Q84MffW/wyLJZaC3yzD3h3Hvz8mnnt1OF0uJGl6upq1NTUICgoCAMHDsTQoUPh7++P5ORkbNmyBbW1tQb9i4qK4OTkhKioKAwfPhy33HIL1Go19u7di9OnT5t1zfz8fPz8888oKipC7969MXjwYLi4uODo0aM4fPiw0fWOHTsGQRDQq1cvDBs2DAEBAUhLS8OmTZtQVlbWau+FJdi+fTv+97//oby83Oi5pUuXoqqqCrfddpu+bd++fVi+fDlHfTqpiooKqUMgIup4Zg4BCsqALceutZVU6hKmaQMB62Y+Oy+q0CVKLWFrDdhYtTxWS3W1DthwBBcuXJA6EmpnHW5kyc/Pz2TW7+Pjg3379iElJQXR0dH69jFjxhj1jYqKwpYtW3D27FlER0cbjAyZcuTIEQDAtGnT4OzsDADo1asXfv/9d1y4cAHh4eHw9vYGALi6uuLuu+/W92sQGBiIHTt24NSpUxg7dmyLXvPNytraGtbW1lKHQRbEyqoD/WIlIosjSB2AVPoGA6cv6qbRXe9EGvDoOCDcF0hsxQI7C0YBj03QFUdIygHe2gSsPdR655eCTACW7QBWzpM6EmpnHW5kqTEN09tUquY/GZHJZHBwcEB9fT20Wm2TfZVKJUpLS+Hj42OUAPXo0QMAkJKSom9zcnIy6gcA/v7+sLGxwZUrV5qNT2rbtm3DpEmT4O/vD1tbW9jY2CA8PBzLll0b/r969SqGDh2K7du3AwCCg4MhCAIEQcDrr78OwHjN0pQpU/Dll18CAEaNGqXvP2/ePP3zptYapaSkwNPTE0OHDjVoLykpwYIFC+Dl5QUrKysEBwfj22+/bfR1HT16FHfccQc8PDygUCjg7u6OOXPmoKio6O+8XdQCvXr1kjoEIurAxOa7dEw+bkC+iZkrDW2+7q13rT8uAC+tAe58D1j0hW6vojVPA4vGt941pKAVgVMZ6Fbeaf8VdVodbmSpgVqt1n+Vl5fj+HFdjfyAgACT/evq6iCKIurq6nDx4kXk5OTA19cXCkXTb5FGowEAk/0a2sy52VapVKivr4e7u3k/sOrr6/XXbo5cLm/VT+x/+uknJCUlYezYsQgMDMSVK1ewY8cOPPHEEygrK8Mrr7wCW1tbPPXUU6itrUV8fDxefPFFuLm5AQDGjRtn8rwLFy5EVVUVYmNjsWjRInTv3h0AMGjQoBbHWFlZiXvuuQd79+5F37598fDDDyMzMxOPP/44PDw8jPpv27YN9913H7RaLWbOnImAgACcO3cOP//8M44ePYqEhAS4uLi0OA5qmfj4eIORXyIiuoFCrqtsdz0rhW7Km8cNxQeuVOlGk+ysAaXa+FwNU+vsWnGWx/AXDR9/cwCI+wB4Zx7w3W8tn85nSRQy2HwXC4zsK3Uk1I46bLJ04cIF/fQ4QDeiM2rUKPj4mK76sn79eiiVSgCAIAgIDg7G8OHDm72OnZ0dbG1tUVRUBLVabZA05eXlAQCqqqqaPc/p06eh1WoRFhbWbF8A+OOPP5CammpW3/DwcIwcOdKsvub48MMPjYo1LFmyBGPGjMH777+P559/HlZWVpg9eza+//57xMfH45FHHmm2YENDgYnY2FjcfffdfyvmLVu2YN++fRg2bBgOHjwIuVwOURTx2Wef4YknnjDoW1JSgldeeQWCIOD8+fPw9/fXP7d06VI89dRT+O9//4s333zzL8dDRETUKoZFALEmfh8NiwDm3mrYFvQocKkYqFUBNiZu+Wz/TJJq2zCBqVfrKvCtWAT0C9GNPN2s1FpY/3RKl4AKnXZSZ6fTYafhBQUFYeLEiRg3bhxiYmJgbW3dZG38cePGYeLEiRgxYgT8/f2h0WhQX1/f7HUEQUBUVBRqamqwd+9eFBUVobKyEsnJyTh16hQEQYBabeLTnOtcvHgRCQkJCAgI0E/da06fPn0wceJEs7769Olj1jnN1ZAoiaKIyspKXL58Wf8+VFVVSb74URRF7NixA6Io4oUXXoBcLgeg+7uaOXMmIiMjDfqfOXMGCQkJmDx5MgAgNzdX/9W/f394eXlh586dZl//ypUr+sQb0CXLV69e1T9WqVQoLS01OCY/P7/JxwUFBRCvm2veUa/h5OTUIV4Hr8Fr8BqWdw2lGdPwbwpns4Axrxt+nc0Cdp8xbi8o1x2TX6abinejhra8Nl4CkFOi+9P95i67LSpkqLg1TJ8odaT/H531GubosCNLjo6O+nVKQUFBCA4OxtatW6FWq9G3r/Hw6fUjTj169MD+/fvx888/Y/bs2bCxsWnyWtHR0VCr1UhISEBOTg4A3UL1wYMH4+TJkwZ/0TfKzs7GgQMH4OXlhdtvvx2CmZ9UuLm56ae1tbfU1FQ899xz+P33302usZK6ol9tbS0KC3X7QERERBg85+bmBh8fHyQlJenbzp8/D1EU8f333+P77783ec6WFKK4cSrljeXgra2tjaYC3jjieePjhgIhHf0aHh4eBntY3Kyvg9fgNXgNy7sGrK07xpql8mpgf4JhW1mVLiG6sb1BfBZwa6TuJv/6e5JBYUB1na7Ud1sK6ar7s/jmrngqqLVweW6W/nFH+v/RWa9hjg6bLN3Iw8MDnp6eSEpKMpks3Sg8PBwZGRnIzMw0uuG+kSAIGDBgAKKjo/XJg4eHB0RRxKFDh9C1a1eTx+Xk5GDv3r1wc3PDxIkTW3RDrlKpmh2xaqBQKFqt6lxRURFmzZqFc+fOYebMmRg2bBg8PDwgl8uxatUq7N69u9miGK1NFEWz1281djwA3HXXXZg1a5bJPl26dPnL5yfzZWVlcc0SEVFr23QUmDUUmD742j5LHk66tm2nANV19xMNiY05m8/eyNNZV5L8eo62wFOTdYlS3MW/Fr8lEAD0DMBFLwW4fXrn0mmSJUBX9OH64bvm+gIwuz+gG026PjG6eFH3Q8FUUYmcnBzs2bMHrq6umDRpUrOjVzc6cuSIJGuWzpw5g3PnzmHOnDlYs2aNvr2+vh6rV6/+2+dvqkx7Q4GFK1euGKx/Ki4uNtifx9bWVv/3cOHCBX2hCEA36nXjEGyPHj0gCAJEUcTcuXP/9msgIiKyKJuOAkdTgG8fB3r6AyVXdaW95TLgtXWGffe/ofszeNG1tkAv4N4Ruu/7h+r+fGmm7s9LxcAPB3XfL74DuHOgLgHLLtZN83vwdiDQE7j3U936pZvZ4jtQc8N+ndTxdbhkqaamBvb29kbteXl5KCsrMxh+a1iTdGOlOK1Wq5+mdf2IglarRWVlJRQKhdHQ343q6upw8uRJ2NraomfPngbP5ebmYs+ePXBxccGkSZNga2vbshcJ3Zql0NBQs/o6ODi0+PyNaShgcePUwr179+LQIeM9FBr+Lm5McBpzff8bNSQ9e/bsQUxMDABdMrt06VKDeGQyGe644w5s2rQJ7777LiZMmKAv8LBp0yYkJycbnLd///7o3bs3tm3bhiNHjhiVIG/Y6NjLy6vZ+OnvMfffNBERtYBWC0x8C/jgfuCfk3TV706mAwuWmjcFL7gL8NY9hm0Nj2MTryVLf1wAhvYAHh4DeDgC1UrdXk4PLgN+S2zd19TebKyBebfBofCy1JFQO+twydLhw4dRU1MDX19fODo6QqPRoKSkBBkZGfp1RA0qKiqwbds2hISEwMXFBba2tqiurkZ6ejoqKioQHh5ukFxVV1djw4YN8PHxwZQpU/Tt2dnZOHv2LPz9/WFnZ6cvcqBUKjF+/HiDZKi4uBi7d+8GoBvRaFjjdD1zKuK15Zql9957z2RicMcdd2DAgAHo2bMn1q9fj/r6ekRFRSElJQW//vorunTpgszMTINj+vfvjw0bNuCxxx7DXXfdBRsbG4wZMwa9e/c2ee3BgwdDEAS89NJLSElJgZ2dHQYMGIBhw4Zh7ty5WLFiBV599VWkpaWha9eu+P3335GRkWGUvM6YMQM//vgj9u/fjwEDBmD8+PHIzMzEtm3b4O/vb/C+d+nSBe+++y7uu+8+3HbbbZg8eTKioqKgVCqRnp6OQ4cOYfHixfr9oajtlJaWNvtBBBER3WDUq833Ka8GHvlM99WU60eUGhw8DwjTm7/GvrO6r45GIdONrDnbo5ttN6mjoXbW4ZKl7t27Iy0tDWlpafrqd46OjoiMjESfPn0MbsQcHR0RFhaGgoICZGVlQaVSwdraGp6enoiJiTH7U24nJycoFAokJiZCqVTC1tYWvr6+iImJMSqxfeXKFf36mqNHj5o8n7nlw9vKpk2bTLarVCpMmTIFq1evxpIlS7Bv3z78/PPP8Pf3x1tvvYXExET9prINFi5ciKSkJGzfvh0vvvgitFotXnvttUaTpcmTJ+OZZ57BmjVr8Morr0Cj0eCee+7BsGHDEBERgS+//BKvvPIKfvjhBygUCtx2221Yv349pk83/CHu7OyMdevW4f/+7//w66+/4r///S/8/f2xbNkybNmyxShJnTRpEvbv348333wTf/zxB3799VdYW1vDy8sLEyZMwOzZs//GO0rmKisrQ7du/EVEREQWRK0F/qHbVDcpKYlrazsZQWyqVBsRUTs6d+4coqKipA6DiDqime8DW46hY5TEo3YjE4A+QcDpDwFw8/TOqMPus0RENx8mSkTUlpgnUYtpReDxifqHvr6+EgZDUmCyREQWIyGhkT1CiIiIpOBoC9w9TP/Q3P0wqeNgskREFqO99+giIiJqlEIGLBgNOFwr1HX5MqvhdTZMlojIYty4OzcREZFk1Fpg0TipoyCJdbhqeER087qxeiQREZEkZAIwKAzoFWjQHBkZKVFAJBWOLBGRxbh48aLUIRAREekKOyy+w6jZ1P6Y1LExWSIiIiIiup6LPTBjiFFzVVWVBMGQlJgsEZHFCA4OljoEIiLq7OQy4OExgK210VO2trYmDqCOjMkSEVmMyspKqUMgIqLOTqMFFpou7BAaGtrOwZDUmCwRkcUoLS2VOgQiIurM5DJgZC8g3PTms4mJie0cEEmNyRIRWQxu9kdEbUkQpY6ALJ5GCzxmXNiBOi+WDicii9GnTx+pQyCijmpkb4hbj4MfyVCTurgA0wY0+rS3t3c7BkOWQBBFkZ+zEJFFSExMRO/evaUOg4g6qPj4eERHR0sdBhHdRDgNj4gshlqtljoEIurAuPE1EbUUkyUishi8kSGituTp6Sl1CER0k2GyREQWgzcyRNSW0tPTpQ6BiG4yTJaIyGLwRoaIiIgsCZMlIiIi6hSCgoKkDoGIbjJMlojIYvBGhojaUnV1tdQhENFNhskSEVkM3sgQUVsqLi6WOgQiuslwU1oishjFxcXw8/OTOgwi6oS2Z2hx+DK3niTgNn8BE0M4nkA63JSWiCwGN4wkorYkiiIEQTBq14oigr/U4HIVIDN+mjoRrQgoBBF1/2cldShkITiyREQWo0+fPlKHQEQdWHJyMnr27GnUvv+SiOyruu81/Ai502PCTNfjGCMRWYzk5GSpQyCiDkylUpls/yxeCzlvkOlPnHNF1+PIEhFZjMZuZIiIWoOzs7NRW16ViF8ydNOviIhuxJElIrIYpm5kiIhai7e3t1Hb1+eYJRFR45gsEZHFMHUjQ0TUWlJTUw0ea7QiPo/XclSJDJgqAkKdF5MlIrIYN97IEBG1pZ2ZIvK5vRvdgIWi6XpMloiIiKhTCAwMNHi8/AwLOxBR01jggYgsxo03MkRErUmpVOq/v1QhYncWwDEEuhFn4dH1OLJERBbj+hsZIqLWVlhYqP/+q3Na7qdDRM1iskREFuP6GxkiorZSrxHxxVmRG9CSSVyyRNdjskRERESdQlRUFADglwwRJbUSB0NENwUmS0RkMRpuZIiI2kJaWhoA4LNOUtjBxQZYMVaGosfkqHpSjgOzZejbxbxjB3gDy8fIcGq+HKqn5RCfNW+Z+zA/QHxWAfFZBTzs/kbwEuKaJboekyW66TzzzDMQBAH79++XOhRqZQ03MkREbaGurg7pZSIO5KDDT8ETAPw6XY57IgUsO6PFkoNadLEXEHu3HKGuzR8/MUSGh6MEiAAuVph/zaWj5ahS3eRv7k0ePrWuTlsNr7y8HKdPn0ZJSQmqq6uh1Wrh6OiIwMBA9OnTB/b29mafS6vVIikpCSkpKaioqIAgCHB2dkZkZCR69uxp0Pfy5cuIj49HUVERtFot3Nzc0Lt3b4SHhxudNykpCQUFBSguLkZlZSVEUcTChQv/9mv/O5555hl89NFHAIB///vfeOWVV4z6rFu3DnPnzgUAzJkzB2vXrm23uH788Ufcc889bX49aht1dXVSh0BEHZiTkxNWJOhGlTp6sjSzh4BhfgJm/qLB5lTdi92QokHqQ3K8MUyGeb9qmzz+83gt3jsB1KmBpbfL0MO9+eGWhX0EBDgBX50T8VS/m3d4poP/06AW6rTJUnV1NWpqahAUFAQHBwfIZDJcuXIFycnJyMjIwIwZM2Bn1/z4sUajwe7du5GXl4fQ0FD07NkTWq0WFRUVqKqqMuibnp6OAwcOwMnJCX379oVCoUBmZiZiY2NRXV2Nvn37GvSPj4+HUqmEh4cH1Go1qqstZ+c8KysrbNq0CS+++CLkcrnBc59//jmsrKxQX18vUXR0s3JycpI6BCLqwDy9/bByR+co7DAzXEBBtYgtqddebEktsCFFxPyeAqzlgErT+PFFNS27npst8NYwGV49ohvBIuooOm2y5OfnBz8/P6N2Hx8f7Nu3DykpKYiOjm72PKdPn8bly5cxadIk+Pr6NtpPq9XiyJEjsLOzw/Tp02FjYwMA6NWrF3bt2oW4uDh0794dzs7O+mOmTJkCR0dHCIKAXbt2WVSyNHz4cBw8eBAnTpzAkCFD9O0FBQX4448/cNttt+G3336TMEK6GZn6P0lE1Fo+O5SPcmWA1GG0i75dBJwuFI1GSU7ki3i0jwzhbkBiSetd781hMhTUACvOinhlyM2dLAlctETX4ZqlGzg6OgIAVCpVs33r6+uRmJiIbt26wdfXF6IoNnrclStXUFdXh6CgIH2iBOj+Q4aFhUGr1SI9Pd3gGCcnJ4v9Dzt9+nQIgoCVK1catH/22WcAgPvuu6/RY1euXInevXvDzs4ONjY2CA0Nxfvvvw+t1nBKgFarxZIlS9C1a1dYWVkhICAAb775JkQza3p+8cUXEAQBn3/+OV566SV4e3vDysoK3t7eeOWVV4yuBwDbtm3D4MGD4eTkBCsrK3Tp0gXjx4/HhQsXzLom/T18n4moLa3Pce80eyv5OAD5Jj5jbWjzdWy9NyLKE3i0j4D/+00LbQcYtTP3PoM6h047stRArVbrv8rLy3H8+HEAQEBA8588FRQUoL6+Hl5eXjhy5AhSUlJQX18PW1tbREREoH///pDJdPmoRqMb61YojN/yhra22GNGqVSa/Z/eysrKaEpdY9zd3TFixAjs2LED1dXVcHBwAACsWrUK0dHRRmu1GjzxxBNYtmwZoqOjsXjxYlhbW2Pnzp147rnnkJOTg6VLl+r7PvTQQ/juu+8QERGB+++/H2VlZfjPf/6Drl27mhVjg48//hh1dXWYPXs2HBwc8MMPP+Ctt95CSEgIHnjgAX2///73v1iyZAlcXV0xffp0hISEIDc3F/v370diYiIiIiJadF0iIrIcSSUizlY4SB3GXyIAsDbv1zOUf06ts1Nc+/56deprz7eWT2+XY2emiL2XmGRQx9Ppk6ULFy7gyJEj+sdOTk4YNWoUfHx8mj22vLwcAHDu3DnI5XIMGjQINjY2SE9PR3x8PKqrqzFq1CgAgKurKwRBQF5eHkRRNBgxysvLA4A2mWa3efNmo7VTjRkxYgR69Ohh9rkfe+wxzJw5Exs3bsSCBQvw+++/Izs7G0888YQ+SbzeiRMnsGzZMsycORPr16/X93nnnXcwevRofPXVV3jiiScQHh6O5ORkrFq1CpGRkTh58qQ+GXv44YcNpv2Zo66uDmfOnIGHhwcAYPHixQgODsaXX36pT5ZycnLwwgsvwNvbG4cPH0ZISIjBORqSXWpb/v7+UodARB3UynNayAURGvHmG1q6LUBXxc4cEd+okXIFqFUDNiYOsf3zzq9W3Tqxze4hYKgv0Pu7pgtG3Exuvn8h1JY6/TS8oKAgTJw4EePGjUNMTAysra3NrsjVUMBAqVRi0qRJ6NmzJ7p3747x48fDx8cHaWlpKCsrAwDY2NigR48eKC0tRWxsLEpLS1FRUYH4+Hj91CO1upV+cl1n9OjRmDhxollf5oymXW/atGlwd3fH999/DwBYtmwZXFxcsGDBApP9V65cCUEQ8OCDDyIvLw+5ubn6r+nTp6Ourg67du0CAKxduxaiKOKhhx7SJ0oAMGjQIAwaNKhFcc6aNUufKAG6G/LAwEDk5eXp/w5XrVoFtVqNhQsXGiVKAMwecQN0Uy6VSqX+cVVVFa5evap/rFKpUFpaanBMfn5+k48LCgoMRgg76jWqq6s7xOvgNXgNXsPyrmGrrcXNOrvqQqmIBTs1Zn3l//n5aH61birejRra8qpa5834YIQMG1NEqDRAN2fdl+ufqw0CnEzHYPH+zJYs5d8ur9F21zBHpx9ZcnR01K9TCgoKQnBwMLZu3Qq1Wm1Une5GDdPnunTpAldXV4PnwsPDkZ+fj/z8fLi5uQEAhg4dCgBISUnR7ydja2uL2267DQcOHICVlVVrvjQAgLe3d6ufs4FCocCsWbOwatUqJCYmYvv27Rg/fjw8PT2RlZVl1D85ORmiKGLixImNnrNhKmLD+2Nqk9KePXvi2LFjZsdpKvlxdXXFpUuXUFdXBysrKyQnJwNAixMxU9zd3Q0eN/z7amBtbW2QvAEwGsm88fGNf48d9RplZWXo1q3bTf86eA1eg9ewvGs8McgK759p/Q8l20NhDbDqfMuSm/giEbf6CxBgWAp7kI+A6noRqWWtE1ugs4B5PQXM62n8+fuZ+xSILxLRd/XNNTuj4f7cUv7t8hptdw1zdPpk6UYeHh7w9PREUlJSs8lSw4iHqT2ZGtquz4AVCgVuu+02DBo0CGVlZZDJZPDw8EBlZSUAGCVcraG2ttbsNUvW1tYm11Q15Z///CdWrFiB++67D7W1tXj44Ycb7dsw/XD58uWNvlZzKhC2VEtfExERdTy+jgImhQA7Mjv+HksAsClVxKweMkwPF/T7LHnYAbN6CNiWIRqUDQ9x0f1p7uaz17vzJ+NEaE6EgDkRMty7Q4PcqyYOIrqJ8C7SBLVabZDkNMbLywuA6bVGDW2m9mqysbExyJazs7MBAIGBgX8p3qZs3bq1zdYsAbpRnqioKJw5cwbdu3fH2LFjG+0bFhaGI0eOwN/fH1OmTGnyvGFhYQB068HGjRtn8FxSUlKLYjRHZGQkAODkyZO44447Wv38ZJ5evXpJHQIRdWB3dinAtost/2T5ZrQpVcTRPBHfTpChp4cWJbXAY9EyyAXgtT8M1xftn62bah688lriE+gM3NtTNx+tf1fdny8N1v15qRL4IUmXgP2cbpx5RnfR9duZKaK0tpVfWDuw0ELEJJFOmyzV1NSYHBHKy8tDWVmZ0TBdTU0NVCoVHB0d9SMVzs7O6Nq1KwoLC1FSUgJPT08AupLXycnJEASh2QXrlZWVOHv2LFxcXExOF/u7Ro8ebfZaqBuHN831/vvvY8uWLRgxYgSsra0b7ffoo49i1apV+Pe//43Ro0cbrEUCgMuXL8PLywvW1taYM2cO3nrrLXz99ddYtGiRvu/x48f1FQtb0/3334833nhDP0oWFBRk8LxWqzVZtIJaV2ZmJsLDw6UOg4g6qGiHUgQ6+SC7E4x2aEVg4mYNPhghwz/7ymBnBZwsABbs1Jg1BS/YRcBbww3X6zY8js0R8UPSzTW1rkU6wcgjma/TJkuHDx9GTU0NfH194ejoCI1Gg5KSEmRkZMDKygqDBw826H/ixAmkpqZi8uTJBpvPDhs2DL/88gt+/fVX9OrVC7a2tsjIyEBxcTFiYmIM5lMmJSUhOzsb3t7esLW1RXl5OS5cuACZTIYxY8YYFRG4dOmSfqFaRYVubPz06dMAdFPmevfu3ezrbMs1Sw0mTJiACRMmNNtvyJAhePrpp/Hxxx8jIiICd9xxBwICAlBQUICzZ8/i2LFjyM7Ohq+vL3r27In58+fj+++/R//+/TFlyhSUlZVhzZo1CAoKQmZmZqu+hoCAALz99tt4/vnn0a9fP0yZMgXdu3dHXl4e9u7di//85z+YOXNmq16TjNXUtHDLeCKiFnBydMDivjK88LsWHad2W+PKlcAje7R4ZE/T/a4fUWpwMEeE8N+/tsbrjSNavHHk5n2HmSvR9TptstS9e3ekpaUhLS1NX/3O0dERkZGR6NOnj9GiscZ4enpi2rRpOHnyJBITE6HRaODq6mpySpubmxsyMjKQkJAAlUoFe3t7hIaGom/fvkajLIDuU/bU1FSDtlOnTuljNSdZsjQfffQRBg4ciA8//BBr1qyBUqmEs7MzgoKCsGTJEoPRre+++w5dunTBqlWr8PHHH8Pb2xvPP/88ysrK8PHHH7d6bEuWLEFoaCjefvttbNiwAfX19XBzc0O/fv1wyy23tPr1yJip/wdERK2lW7duWOAr4KVD6BCbpxJR2xNEblNMRBZCpVI1OZWTiOjviI+PR3R0NOZs02Bzqgg174DIBCsZoPq/TjueQDfgIgwishhtUbyDiOhG/4iWMVGiRnEcga7HZImIiIg6hYY1x7f5A6Gu0sZCRDcHJktEZDGuL55CRNTahD9rQguCgMV9ZWCFaDKF/y7oekyWiMhiCNzcgoja0OXLl/Xf39dTgBXvgsgU/iqi6/DHBBFZjOtvZIiI2pK7nYA5EQIUvDGmG3DJEl2PyRIRERF1CpGRkQaPF7HQAxE1g8kSEVmMG29kiIhaU05OjsHjwT5ATw/OuiJDnBFO12OyREQW48YbGSKi1lRVVWXwWBAEPN6Xt0J0A4420nX4E4KILMaNNzJERK3J1tbWqG1epAAb7j9K12GuRNdjskREFsPUjQwRUWsJDQ01anO2ETA/koUeiMg0JktEZDFM3cgQEbWWxMREk+2L+rDQA13DbSzoekyWiMhiNHYjQ0TUlvp5C+jbReooyFLYyzVSh0AWhLN0iYiIqFPw9vZu9Lnv7pAjqZTDSwTYlKYC6Cl1GGQhBFHk1ltEZBkKCgqavJkhIiJqa1lZWQgKCpI6DLIQnIZHRBbDyspK6hCIiKiT8/T0lDoEsiBMlojIYnCfJSIiklp6errUIZAFYbJERERERERkAtcsEZHFqK2thZ2dndRhEBFRJ1ZeXg5XV1epwyALwZElIrIY+fn5UodARESdXHV1tdQhkAVhskREFqOyslLqEIiIqJMrLi6WOgSyINxniYgsho2NjdQhEBERNapaJeJihdRRXNPNGXC2EaQOo0PjmiUishharRYyGQe8iYhIOqIoQhBMJyD/Oa7FC4e07RxR4/p2AU7fx7GPtsS7EiKyGAkJCVKHQEREnVxycrLJdq0o4rN4y0mUACDTgka5OiomS0REREREf1KpVCbb92aJyLnazsE0Q6vVSB1Ch8dkiYgsRpcuXaQOgYiIOjlnZ2eT7Z/FayG3sOVBXEzT9jjJkYgsBvdYIiIiqXl7exu1Xb4qYvtFQGthyYmF5W4dEkeWiMhiXLp0SeoQiIiok0tNTTVq+/qchWVJf5LJ5VKH0OExWSIiIiIiaoRaK+LzeK3FjSoBgEbDNUttjckSEVmMsLAwqUMgIqJOLjAw0ODxjosiCmokCoYkx2SJiCwGd00nIiKpKZVKg8eWWNihgayR/aCo9TBZIiKLUV5eLnUIRETUyRUWFuq/z6oQsScL0FjgFDwAAJOlNsdkiYgshpWVldQhEBER6a1M0EJmwfmIVmtZm+R2RIIoskI7ERERERGgK5ogl8tRrxHh87kGpXVSR9Q4J4UGlU/ZSB1Gh8aRJSKyGGfPnpU6BCIi6uTS0tIAAD+nixadKAGAXM5b+bbGd5iILAYHuomIOq7yOhEL92jgtVwNh0/UGLVeg9OF5v/cTy4VMWGTBo7/U8N9mRr37tCguKbp439M0kL4rxqO/1ObfZ26Ol2GtNyCCzs00FpiPfMORiF1AEREDTw9PaUOgYiI2oBWFDFpiwZni4F/DZDB005XZW7keg3i7pUjzK3prCT3qojb1mngYgO8c6sMVSrgv6e0OFeswYn5clibyGqqVCKW/K6FQwuXwzo5OSGtTERsTsuOkwI/ZGx7FpksqdVqbNy4EVevXkXPnj0xfPhws47TarU4e/Ys0tLSUFlZCSsrK/j4+GDgwIFwdXU1eUxZWRlOnz6NvLw8KJVK2NnZwcvLC8OHD4e9vT0AoLa2FsePH0dJSQmqq6uhVqvh4OAAHx8fREdHw8XFpbVe+l/266+/YvLkyRAEAdu2bcOkSZPa5brfffcdHnjgAf1jQRBga2uLgIAAzJw5E6+88gpsbW3bJRa6+Tk5OUkdAhERtYFNKSKO5AEbp8gws4duYtPsHgLCv9bgtT+0WDNZ3uTx7xzToroeiLtXjkBnXWI00AcYu1GL7xJFLOxjnCy9dUwLJ2tgVICAn9LNTyr8/PzwyjHdqJLFVsH7k4UPfHUIFpksnTp1Sj8Eai5RFLF7927k5OQgKCgIvXr1Ql1dHZKSkvDTTz9h2rRpcHNzMzgmJycHe/bsgbOzM3r37g07OzvU1dWhsLAQ9fX1+n5KpRIVFRXw9/eHo6MjFAoFKioqkJKSgosXL+LOO+80Ond7W758Odzc3HD16lV8++23mDhxIoR2LCc5ceJEjBo1ClqtFrm5udiwYQPeeecdXLx4ET/88APk8qZ/CBIBQGZmJqKjo6UOg4iIWtmmVBFd7YHp4dfuTbzsBczuIeCHJBFKtQgbReP3LZvTREwOEfSJEgCM6SZDuJsWG1JELOxj2D+tTMTHcSK2TpNhQ0rLMp6z51Ow8lwvi0+UAEDG+6s2Z3HJUklJCc6dO4dBgwbh2LFjZh936dIl5OTkICIiArfddpu+PSwsDBs3bsSRI0cMRltqa2tx4MAB+Pr6Yvz48ZDJGl++5erqimnTphm1BwcH46effsL58+fNHv1qC8XFxdi7dy/uuusuVFZWIjY2Fnl5efDz82u3GKKjo/Hss8/qHz///PPo3r07fv75Z1y8eBFhYWHtFgsRERFZljNFImK6CkabqA70EfBlgojUMiDKy/Sxl6+KKKoB+nsbJ1MDfQTsuGic1Tx1QItRAQImhsiwIUXTolj3FzmjQtl8P0ug0WhggbfzHYpFFXjQarX4/fffERAQgODg4BYdm5eXBwDo0aOHQbuzszN8fHxw+fJlVFVV6duTkpKgVCoxaNAgyGQyqNXqFteqb5gydONOz+3t66+/hkajwb333otFixahtLQUa9as0T+fnJwMQRAwYcIEk69x2rRpUCgUOHjwoL4tLy8Pc+bMgZeXFxQKBVxdXTF+/HgkJCSYFZOvry+6d++O2tpaXLp0yeC5ffv2YcCAAbC3t4e1tTWCgoLw/PPPmxxNNLfvwIED4enpiWPHjmHUqFFwcHCAg4MDRo8ejYsXL0Kr1eL5559H165dYWVlhaCgIHzzzTcG59Bqtfj3v/+N4OBg2NnZwc7ODj4+Phg/fjxyc3PNet3093Tv3l3qEIiIqA3kVwM+DsbtDW15VY0P4+RXG/a98fgrdYBSfe34XzO02HNJxEcj/9pt7tYiH4veW4nal0WloufOnUN5eTnGjh3b4mN1mTWgUBi/pIa2oqIiODo6AtBNwbOysoJSqcTmzZtRWloKQRDQtWtXDB48GF26dDE6j1arhUqlglarRUVFBeLi4gAAAQEBZsXYcKw5FAqFyddiyldffYWwsDCMHDkSdnZ2cHNzw6ZNm/Dkk0/C2toakZGR6N27N44ePYqsrCyEhIToj62srMTu3bvRu3dvDBw4EACQnZ2NmJgYKJVKTJo0CREREbh06RLWr1+PsWPHYu/evbjllluajKm+vh55eXkQBMFg0f6WLVswa9YsODs765Oxbdu24b333kNqairWrVsHa2vrFvcFdEnrnXfeiZ49e+Lpp59GYmIifv75Z8ydOxfh4eE4fPgw5s6dC5lMhq+//hpPPPEE+vbti759+wIAXnnlFbzzzjuIiYnBnDlzYGtri6ysLOzfvx/5+fnw9/c36++D/rqysjKuWyIisnBaUYTKzMEaG7luPXOtWvf9jWz/vNWpbaJYXcNzJo+XX+tjowBUGhFPx2qxqI+Anp4tz3jOl4g4VWxRt8dNunGkjlqfxYwsVVZWIi4uDjExMX/pZqlhzVDDCFMDtVqNoqIiADAYWSovL4coiti5cyc8PDwwZswYDBo0CFeuXMH27dtx5coVo2vk5ORg9erV+OGHH7Bt2zaUlZVh8ODBCA8PNyvG3bt3Y/Xq1WZ9xcfHm3XO48ePIyMjA3fccQecnJygUCgwe/ZsnDlzRp/MAcBDDz2EyspKrF271uD4tWvXQqlUYsqUKbCzs9P3ValU+OWXX7Bu3Tq8/vrr+PbbbxEbG4uSkhK88cYbRtVXampqkJubi+zsbBw8eBCTJ09GWVkZ+vXrpx/t02g0WLx4MWxsbLBlyxZ88803eO+99xAfH4/o6Gj89NNP2LZtW4v7NqiqqsK4ceOwd+9evPXWW/jpp58wfvx4nDx5EocOHcIff/yBTz75BB999BFWrVqFmpoafPnll/rjt27dCh8fH+zcuRPvvvsuXnvtNXz77bfIzs7GgAEDzPr7AIArV64YjDZWVVXh6tWr+scqlQqlpaUGx+Tn5zf5uKCgwOA976jXKC4u7hCvg9fgNXgNXqMjX2Pr2VLYfaIx6yvliu4adnIRSo3xNer+TIRqKw3vu66/pt2fuUudxvh11P15To2yGlevXsXHp0SU1AIvDdD8pfcqvqhls4wkJwgd5t+VFNcwhyBaSM3BHTt2oLq6GjNmzIBMJsPVq1exdu1as6vhKZVKbNiwAWq1GoMHD4afnx/q6uoQFxeHy5cvQ6vVon///oiJiQEArFy5EqIoIjQ0FKNHj9afJy8vD9u3b0dISAjGjBljcI26ujqUlJRAo9GgrKwMGRkZCAwMRL9+/Zpc89SguLjY7Cl7zs7OcHZ2brbf/PnzsWnTJhw5ckT/2s6ePYvo6Gg88sgj+mTgypUr8Pb2RnR0NA4dOgQbG91uzwMGDEBycjJOnTqFiIgIVFRUwN3dHcOGDcOPP/5oVCRi+PDhkMvliIuLg6urq1E1vAaCIOD222/Hl19+qZ9SeeLECQwaNAjjx4/Hjh07DN6zrVu3Yvr06Zg/fz6+//77FvUFdNPw4uLiEBcXZ1Ag4IMPPsCSJUuwePFiLFu2TN9eVlYGd3d3TJgwATt37gQADBo0CAkJCfjf//6HBx980OyRPWo9586dQ1RUlNRhEBFREwqqRezKNO/28a4wAS42AsK+UiPMTcCOGYbDQ1+f0+Lh3Vok3C9HlJfpUZLLV0X4r9DgvdtkWDLQ8H7r3h0a7LgoovRxBSqUIvy/0OCxaAH/iL7W79lYLXZmijj/gBz2CqCLQ+OjMTX1IjyXqVCruTkKJzgpNKh8ykbqMDo0i7gbTEtLQ25uLqZOnWpW0mGKjY0NJk2ahN9++w2HDh3St/v4+KBPnz44c+aMwZQthUKB+vp6o1EhX19fODo6msw8bW1t9VOxunXrhrCwMGzatAm1tbUGRSUa4+XVyMrFv6i6uhpbt25FeHg41Go1zpw5o3/O398fu3btQmlpKTw8PODu7o7bb78d+/fvR0JCAgYMGICsrCzExcVh1KhR+gIMKSkp0Gq1OHToEAIDA01e19PTE7W1tQbl2GfPno0777wTKpUKJ06cwMqVK1FSUqJPygBdpTNAV3Tjxr/nhhvkhrVBLenbwMXFxeg9bngcFBRk0N4wEllRUaFv+/DDDzFlyhQ8+uijeO6559CnTx+MHz8eCxcuhIeHh8n3gloXEyUiIsvn7SBgQe+WTf+K7iLgUK4IrSgaTB07ni/CXgGEN1FU2M9JgJcdcKrAOEE7kS8iuovufGV1QFU98P5JEe+fNJ4nGLxSg2mhAn66s/FEyN5KwAO9ZfgyAVBbxHACSU3yZEmj0eDo0aMIDAyEnZ2d/ua1ulq3mk+lUqGiogK2trYGN96muLu7Y8aMGaioqEBNTQ3s7e3h4uKir6p3/c29g4MDysvL9XspXc/e3h4lJSXNxu7g4AA/Pz+kpKRg2LBhzZbHrqurM3vNkpWVFaysmt5Fbd26daipqdFXDzRl27ZtWLBgAQBg4cKF2LVrF1atWoUBAwbg66+/hiiKuPvuu/WxNww0Dh06FI8//rjJc9ra2sLd3d2gLTQ0FHPnzgUA3H///Rg0aBDuv/9+LFq0CFu2bGmXURqZTNZouXRzrj98+HDk5ORgw4YN2L17N44dO4YXX3wRS5cuxa+//qpf20RthyNLREQd08xwAZtSRWxJFTGzh+53dUmNiI0pIqZ0FwzKhmeU6+5Furtea5sRLmDVeRE5lSIC/iwfvv+SFqllwNP9dI+72ANbpxl/6P7paRFH80WsnSSDj2PzSd5Et1x8Jpq3Hl1q8r84yEDmkzxZUqvVqKurQ3Z2NrKzs42eT09PR3p6OgYNGoQ+ffqYOIMxFxcXg41iG4o5dO3aVd/m5eWF8vJyVFdXG934V1dX69fvNEej0UAURahUqmaP2bt3r9lzJWNiYtC/f/8m+3z++edwdXXFiy++aJT01dfX45lnnsEPP/yAe++9F3K5HJMnT4arqyt2796NyspKrF69Gt7e3rjzzjv1x4WGhkIQBKhUKsycObPZhK0x9913H5YtW4adO3di9+7dmDRpkr6wRFpaGrRarcGIUWJiIgDoR+5a0rc1OTo64sEHH8SDDz4IAPj444/xf//3f/joo4/0U/6o7TQUaiEioo5lZriAwT7AA7u0SCoFPO2Az+K10IjAG8MMb/hv36D7XZC18Npt6ouDZNiYqsGoDRo8GSNDVT3wwUktojyBB/4c5bK3EnBnmHEy9FO6BicKgDvDzEss/BQVGOIbgOP5gNbCR5e0lrGapkOTPFmysrIyWhsE6EZhDh8+jICAAPTo0cMgoampqYFKpdJvENuUxMRElJWVISYmxuDGPywsDGlpaUhKSjKoZnfp0iVUV1cjIiLC4HqmRqDKyspw+fJlODs7m5VcDR48uEVrlpqSmpqKuLg4jBkzBs8884zJ6Ytr167FsWPHkJqaisjISFhZWWHWrFn46quv8OmnnyI7Oxtz5841qPzn4eGBkSNH4uDBg/jmm2/w6KOPGpxTFEVkZ2ejW7duzb6Gd999F2PGjMH777+PsWPHIiYmBt7e3jh06BAOHTqEESNGANAldm+++SYEQdAnbi3p21pyc3ONErDBgwcD0BUEobZ34wcXRETUMchluvVK/zqoxadntKitBwZ4A9/dIUcP9+ZHewKcBRy8W47/i9Xi+d+1sJYDk0IEfDhS1uRmtn+Fg4MDFkfLcDTP8os9WEjpgQ5N8mRJJpMZlLJu0FDdwsnJyej5EydOIDU1FZMnT4avr6++fefOnXBycoKbmxsEQUBubi6ysrIQGBioL37QwN/fH927d0dGRgZ27tyJwMBAVFVVITExEfb29ujXr5++b3x8PC5fvoyAgAB9pb4rV67oRz2GDRtm1mttzTVLn332GQBg0qRJja7zmjt3Lp5++ml89913eO+99wAAixYtwsqVK/HOO+9AEATcd999Rsc1TNNbvHgxNm3ahH79+kEulyMzMxMHDhzAsGHDsHnz5mZjvP322xETE4PDhw9j165dmDp1KpYvX45Zs2bhrrvuwl133aUvB56UlIQ777wTU6ZMAQDI5XKz+7aWqKgohISEoH///ggICEBRURHWrVsHhUKBu+++u1WvRaY1rCUjIqKOx81WwFfj5fhqfNP9rh9Rul4vTwG7Z7a88MJ3d8jx3R3m9+/WrRsCZAIW78dNszkttZ0ONdGxa9euyM/Px/Hjx3Hs2DFUV1dj2LBhGDdunMmEYtSoURg4cCAqKytx9OhRpKSkICQkBHfeeSccHK7tfBYYGAhXV1dcvHgRx44dw9GjR5Gbm4uQkBBMnz7d7H2WWotGo8GPP/4IJycnTJs2rdF+s2bNgiAI2LZtm75sekxMDEJDQ1FbW4uIiAiTlQYDAgKQmJiI+++/H0lJSfjwww/x8ccf49ChQxgyZAgeeeQRs2N96623oNVq8cEHH0ClUmH69OnYuXMnunfvjjVr1uDDDz9EdXU1nnvuOaxdu9agCEdL+raGf/zjH6ivr8e6devwxhtv4Mcff0RoaCjWrVuHefPmteq1yLSMjAypQyAiok4uKSkJtgoBj0QJkFv4NkbNrZenv89iSocTETXso0VERCSVht9FaWUiwr+27LW0LB3e9jrUyBIR3dwa9uQiIiKSSsMSjzA3ASMDYPGjS9S2mCwRkcW4fiduIiIiKVy/DcniaBk0FjwHq7EtU6j1MFkiIothzv5mREREbeny5cv676eFCvA0bzcZSciYLLU5JktEZDH4CRkREVkSK7mAhbdYbqEHjdbyy5vf7FjggYiIiIjoT0qlEjY214omZFWICFmpgSXeMLPAQ9vjyBIRWYzz589LHQIREXVyOTk5Bo+DXASMC7LMQg+N7bVJrYfvMBFZjPr6eqlDICKiTq5hb8rrLe5rmYUeOEGs7TFZIiKL4erqKnUIRETUydna2hq13REswNtegmCawWSp7TFZIiKL4eXlJXUIRETUyYWGhhq1KWQC/hEtg8wCp+JR22KyREQWIy0tTeoQiIiok0tMTDTZ/lCU5WVKcrlc6hA6PCZLRERERETN8HMSMKW7Zd08azQaqUPo8BRSB0BE1KBbt25Sh0BERJ2ct7d3o88901+Oeq3lJCjRVgUA+LuzLXGfJSKyGHl5efD19ZU6DCIioptCVlYWgoKCpA6jQ7OkkUQi6uSKioqkDoGIiOim4enpKXUIHR6TJSIiIiKim1B6errUIXR4TJaIyGLccsstUodAREREpMdkiYgsRkpKitQhEBER3TS4XqntMVkiIouhVCqlDoGIiOimUV1dLXUIHR6TJSKyGM7OzlKHQEREdNMoLi6WOoQOj8kSEVkMHx8fqUMgIiIi0uM+S0RkMeLj4xEdHS11GERERO3jYgEw+0Ogus708929gW0vAoJg8mlRFCE08hy1DoXUARARERERdUp7zgJxGY0/f+EycDwVGNzD5NPJycno2bNnGwVHAKfhEZEFCQgIkDoEIiKi9tXUwJBCBny+q9GnVSpV68dDBpgsEZHFqK+vlzoEIiIiy6HWAuv+AMqqTD7Nwkhtj8kSEVmMgoICqUMgIiKyLPUaYHWsyae8vb3bN5ZOiMkSEREREZGlEkVg2Q7dnzdITU2VIKDOhckSEVmM3r17Sx0CERGR5UkvAH5PkjqKTonJEhFZjPT0dKlDICIisjyNFHoIDAyUIJjOhckSEVmMurpG9pkgIiLqzNRaYPNRoKjcoFmpVEoTTyfCZImILIajo6PUIRAREVkmrQh895tBU2FhoUTBdB5MlojIYnCfJSIiokZoRWD5TkCrlTqSToXJEhFZjOTkZKlDICIislzZJcD+BP3DqKgoCYPpHJgsERERERHdDOQy4LNrhR7S0tIkDKZzUEgdABFRAz8/P6lDICIislwaLfDLSSDvCuDr3raFkcqrgSWrga3HgRolMDAM+PB+IKa7eccn5wJPfwMcvgBYK4BJ/YCPFgBeLtf6XMgFvjkA7IkHMgoAR1sgJgR4Yw7QP7QtXlWLcWSJiCyGaGLDPSIiIrrB1/sAAE5OTm1zfq0WmPQWsOYQ8PgdwPv3AUUVwMhXgbS85o/PLQFue1m3P9Q784BnpwK/xgFj3wBU9df6fbUPWLkX6N8d+HAB8H9TgZQ8YPDzwL6zbfPaWkgQO/ndSXl5OU6fPo2SkhJUV1dDq9XC0dERgYGB6NOnD+zt7Y2OKSwsxJkzZ1BaWoq6ujrY29vDz88P0dHRcHZ2bvfX8Prrr+ONN97Au+++i+eff97o+djYWIwaNQozZszADz/8AFtb23aPsbVoNBr4+fmhsLAQU6dOxY8//sgKah1IfHw8oqOjpQ6DiIiofXyxG3hsBdDSu3EfNyDnS9TV1/+1+7qRrwBBXYDvnjD9/IY/gLs/BDY+C8wcqmsrrgDCHwfuiAHWPN30+R9boavcd2EpEOila9t3VpcsrVgELByna4vLAHr4Ao52144tvQpEPgGE+wKH32n5a2tlnX5kqbq6GjU1NQgKCsLAgQMxdOhQ+Pv7Izk5GVu2bEFtba1B/5ycHPzyyy+oqKhAr169MGzYMHTr1g3p6enYunUrqqurJXolncPOnTtRWFiILl264OjRo7hw4YLUIRERERG1r/wyYOeZtrsP2nQU6OoKTB98rc3LBZg9FPj5BKCsb/RQAMDmY8Dk/tcSJQAY00eXAG04cq2tX3fDRAkAPJyAW3vqpvFZgE6fLPn5+WHy5MkYOHAgevXqhcjISAwbNgwjR45ETU0NUlJSDPqfO3cOgiBg2rRpiI6ORkREBIYOHYqhQ4dCqVTi4sWLEr2SzuHLL7+El5cXnn/+eRQXF+Onn37i1K0OpGfPnlKHQEREZPnkMl0Z8bZyJlO3dkh2Q6owMEy3fim1ial4l0t1U/b6m1jbNDAMOGPGvXJBGeDZ/rO1TOn0yVJjGqZ2qVQqg3aVSgW5XA5ra2uD9obpegrFzVMzQ61W49///je6desGa2trODo6YsCAAVizZg3UarW+X2xsLARBwIIFC4zOsWDBAgiCgNjYWH3b+fPnMWHCBHh4eMDKygouLi7o1asX3nnnHYOROqVSiVdffRVBQUGwtraGvb09YmJisGrVKtTXG39iUVhYiJ07d2Lw4MFYsGABPDw8sHfvXly+fNnk6/v0008RGBgIKysrdO3aFYsWLcLSpUshCAJefvllg74VFRV44okn4OvrCysrKzg5OWHYsGH45ZdfoOV+Bu3m0qVLUodARERk+TRaYPcZBIp2zff9K/LLdFP9btTQlnel6WOv73vj8Veqmh6ZOpQEHE0F7h5mfrxt6Oa5s29jarVa/1VeXo7jx48DMN4k09/fH0VFRYiNjUWfPn1ga2uLK1eu4NixY3B1dUX37s1XCGm4jjlkMplRYtaY6upq5OYaD1kWFxeb7H/33Xdjy5Yt6NmzJxYvXozq6mqsWbMGDz74IIqKivDPf/4Tshs/UWhGaWkpRowYAZVKhYkTJ6JXr16oqKjA2bNncebMGdTW1sLOzg719fW4/fbbcfz4cQwfPhxz5syBSqXC+vXrsXDhQpSUlODpp582uP7q1auh0WgwdepUuLm54d5778Vnn32GuLg4+Pv7G8Tx7rvv4sUXX0RgYCAeeeQRKBQKbNiwAbt37zaKuaKiAgMGDEB2djZGjx6NmJgYlJeXY82aNZg3bx4+//xzzJ8/v0XvA/01nMZKRERkJpkM1t//DvTt0XS/ejVQUWPcpqwHSioN290ddaNJtSrAxkSaYPvnPWmtyvi5Bg3P2ViZON7qWh9TzxeVA/d8DAR3AZbc2fg12hGTpT9duHABR45cm0Pp5OSEUaNGwcfHx6Bf3759UVdXh5SUFKSnp+vbAwICcPvtt5uV2MTHx+P06dNmxeXj44MpU6aY1fett97CW2+9ZVbfvXv3YsuWLejXrx82b96Mbt26AQAWL16Mfv36Yfny5ZgwYQIiIiLMOl+DP/74A6WlpVi0aBGWL1/eaLK1bNky/PHHH3jhhRfw+uuv69+3119/HREREfjyyy8xefJk9Ohx7QfAypUrERYWhltvvRWAblTrk08+wcaNGzFhwgTY2NgAAK5cuYI33ngDfn5+WLduHYYMGQIAePHFFxEWFmYUy8svv4ysrCx88MEHeOKJJ/Qx/+tf/0KvXr3w2WefYfTo0fD19W3Re0EtZ6qgChEREZmg0cJ67RHgo0ea7vfHBWDUq8btR1KAdYcN2zK/0BV+sLMGlCY+2K/7MxGya+J+t+E5U6NHdfWNH19dB0x+B7haCxx+23gtk0Q4De9PQUFBmDhxIsaNG4eYmBhYW1ubrF0vCIK++t1tt92GsWPH4pZbbsHly5exf/9+s6ZshYeHY+LEiWZ9DR48uNnzNXjggQewZs0ao68bp5wBwJYtWwAAc+fO1SdKANCnTx9MnDgR6enpiI+PN/vaDVxcdLXzExIScP78+UbXE61atQre3t64/fbbUVRUhNzcXOTm5qKyshJjx45Feno6MjIy9P2PHDmCtLQ0DBs2DCEhIfpYo6KicPjwYYPEde/evVAqlRgxYgT69++vb/f29jYaIRJFET/++CPCwsIwaNAg5OXl6WORy+UYOHAgkpKSTI7YNebKlStQKpX6x1VVVbh69ar+sUqlQmlpqcEx+fn5TT4uKCgweC876jW6dOnSIV4Hr8Fr8Bq8Bq/Ba5hzjerq6hYXwtNTyHB1UHCz1ygLdIHq1xeBva8Be19D7S9LoOkdAIyLBva+hvodL6Fy89O6571dAQDqLk7XptNd/zr+bCux1jb+Xv05/U6ZVaB/Xv9e5ZfpRq9srAzjVtVDOelNIOES8PMLQO9u7fL3YRaRTCopKRFXrlwpnj592qB9//794po1a8T6+nqD9vPnz4srVqwQk5OT2zNMURRF8bXXXhMBiO+++67J53/77TcRgDhjxgyxtrZWFEVRHDt2rCgIgrh7926j/i+99JIIQHz77bcNjr///vuN+t5///0iAPG3337Tt82ZM0cEIMrlcjE0NFScN2+euG3bNlGpVOr72NraitAVymz065tvvtH3X7BggSiXy8Vly5aJp0+f1n899dRTIgDxv//9r77vu+++KwIQX3jhBaN4P/nkExGA+NJLL4miKIqFhYXNxiEIghgbG9vE3wC1ljNnzkgdAhERUfv5fJcoCneJIv7aV/2RpL923REvi+L9nzb+/Mz3RbHrA6Ko0Ri2P/KZKNrPEcU6VdPn97pfFGd9YNwevlgUR79q2KbRiOLd/xVF+QxR3HzUrPDbE6fhNcLDwwOenp5ISkpC3759Aegy2PT0dPTq1cuokENISAgOHz6MvLy8Zqeu1dfXmyxgYIpMJpN8XyRBEBp9ztTrWLt2LZ5//nmsX78ehw4dwubNm7F27VrMnz8fS5cuhbOzM0RRhJ+fH5YsWQIvLy8TZwaGDx8OQPe+b9iwARqNBo8//rjJvjt27MD9998PT0/PFr028c9PLCIjI/Hkk082uk/WLbfc0qLzEhEREbUZQQCiAnHRXYbwtjj/zCG68uFbjl3bZ6mkEth4BJjS33C9UcafI0jdva+1zRgCrPoNyCkBAv68N9ufoKui9/QNy0ue+ApY/4du/6Xp5s+oai9MlpqgVqsNhvsaFp+L1w0JNmiYfmfquRudPXu2TdYstURoaCj27t2Lc+fOYdy4cQbPJSYmAoB+upu7uzsA3euvq6szSN7S0tJMnr9Pnz7o06cPAN3Gv/369cP69evx8MMP49Zbb0X37t2Rm5uLAQMG6NcUNWbDhg2oqanBrFmzMGLECKPnv/vuOxw/fhyJiYkYOXIkgoKCAOgqq9XX18PK6tp/6Bv3I/Dy8oKzszNqa2tx6623snS1xG5cI0hERESmiMDjE1Fzw36grWbmEGBwOPDAMiApF/B0Aj7bpavC98Ycw763v6b7M2vFtbYXZ+gSq1GvAk9OAqrqgA9+BqK6AQ+Mvtbvk2268w7pAdjbAD8cNDz3XYMAB2kHDTp9slRTU2NyUXleXh7KysoMbt5cXFwgCAKysrIwYMAAfUEBAEhNTQWARkdJrhceHg5vb+9m+wEwuEZruuuuu/D5559j/fr1mDVrFgIDAwHoEqXt27cjNDQU0dHRAIDg4GAoFApcuHABly9f1lf8O3LkCE6dOmVw3itXrsDW1tbgPXV1dUVISAgyMzP1c0sXLFiAJUuW4JNPPkGvXr2MRnTy8/Ph5uYGW1tbrFixAg4ODli8eLHJZMnR0RELFizAxo0bceutt2Ls2LGwtrbGwYMHcerUKX0yVlBQgB9++MHgWJlMpq94t2LFCrz33ntGI3l5eXnw9PQ0uyoh/XVyuVzqEIiIiCyfnQ0wdzgc8tto41a5HNjxMvCvVcCnv+qq1w0IBb57Aujh1/zxAZ7AwTeB//sOeP4HwFoBTOoHfLjAcFQqPkv359EU3deNMr9gsiS1w4cPo6amBr6+vnB0dIRGo0FJSQkyMjJgZWVlUGDB1tYWUVFRSEhIwJYtWxAREQEbGxsUFBQgPT0dzs7OZlWPc3Z2bnS6V3sZO3Yspk+fji1btmDixIkYP348qqqqsGbNGigUCixevBjh4bqBXUdHR9x333345ptvMG/ePIwePRp5eXnYsmULunXrhqysLP15V69ejbfffhtDhw5Fjx494ODggGPHjmHfvn3o168fevfuDQB46qmnsGPHDmzYsAHJycm49dZb4eXlhby8PBw5cgRarRZbt26FKIo4ceIEhgwZYrKSHQBMnToVCoUCsbGxyMzMRGhoKF599VW8/PLLmDNnDiZPngyFQoH169fDy8sLVVVVBlX63n33Xfz+++9YunQpjh8/jiFDhsDJyQk5OTk4ePAgfH19sWHDBlbDawe5ubktnkpJRETUqShkwH0jAUc7gyJdLRL7ZvN93ByBrxbrvppy/YjS9XoFArtNVOG73ndP6L4sWKdPlrp37460tDSkpaXpq985OjoiMjISffr00W9O22DQoEFwcXHBhQsXcObMGWg0Gjg4OKBnz57o16/fTTX6sH79erz99tv45ptv8Omnn8La2hqRkZH4v//7P8yePdsgofjf//6Huro6bNu2DWfOnEFQUBD+85//4OjRowbJ0siRIxEbG4sTJ05g165dkMlk8PLywsMPP6zf9wgArKyssHfvXnz00Uf49ttv8fXXX0MURbi5uSE8PBwzZ86En58fXn/9dQC6972xKVpubm4YMWIEDhw4gMOHDyM0NBQvvfQS7O3t8dFHH+HLL7+Eu7s77rrrLnTr1g0vvviiweiRi4sLTpw4gbfeegvr1q3Tlzx3d3dH7969MW/ePP1URCIiIiJJqbXAIt0SiqSkJP1MIGobgmjOIhuiDuLxxx/H8uXL8f3333OjWQt045o4IiKiDu2L3cBjK2B2/XCZAMSEACc/AKDbu5PJUtviPkvUIdXV1UGtNtxMLT8/H6tWrYKvry+r21moy5cvSx0CERGR5dLqCjs04BKBttfpp+FRxxQbG4vHHntMv4ltfn4+Nm7ciOrqavzjH/8wa20Ztb/rN5cjIiKiGzjZArOH6h82tb0LtQ4mS9QhhYaGIiQkBL/++iuuXr0KhUKBkJAQvPLKK1i0aNFNtbasM+EUPCIiokYoZMCDY3SV8P50+fJlsyox01/HZIk6pNDQUOzbt0/qMKiFGqt4SERE1OmptcCj45rvR62Ka5aIyGKcO3dO6hCIiIgsj0wGDI8AIv0NmiMjIyUKqPNgskREREREZMm0WmDxRKPmnJwcCYLpXJgsEZHF6Nq1q9QhEBERWR5XB+CuQUbNVVVVEgTTuTBZIiKLYWNj03wnIiKizkQuAxaOBWysjJ5iYaS2x2SJiCxGdna21CEQERFZFo0WWGi6sENoaGg7B9P5MFkiIiIiIrJEchlwexTQ3dvk04mJie0cUOfDZImILEZ4eLjUIRAREbUvsYnnNFrgsTvaLRQyxmSJiCxGQUGB1CEQERG1n96Bus1mG9PFBZjSv9Gnvb1NjzhR6xFEUWwqnyUiajfx8fGIjo6WOgwiIqL2U1Wr23DWFIUMcLRr33jIgELqAIiIGlhbW0sdAhERUftiMmTROLJERBZDFEUIgiB1GEREREQAuGaJiCzI2bNnpQ6BiIiISI/JEhERERERkQlMlojIYnh5eUkdAhEREZEekyUishgODg5Sh0BERESkx2SJiCxGVlaW1CEQERER6TFZIiIiIiJqS1otsOo3gEWobzpMlojIYoSGhkodAhERUev7YjewYClwNkvqSKiFmCwRkcUoKSmROgQiIqLWZ2Ol+/On49LGQS3GZImILEZ5ebnUIRAREbU+exvdnz+dkDYOajEmS0RkMRQKhdQhEBERtZ2zWUDpVamjoBZgskREFqN3795Sh0BERNS2dp6WOgJqASZLRGQxzp49K3UIREREbUcuA7adlDoKagEmS0RkMUSWVCUioo5MowV2nAbq1VJHQmZiskREFsPDw0PqEIiIiNpWVR1wKFnqKMhMTJaIyGI4OztLHQIREVHbUsg5Fe8mwmSJiCxGZmam1CEQERG1LbUG2HIc4NTzmwKTJSIiIiKi9pRdDFy4LHUUZAYmS0RkMUJCQqQOgYiIqO3JBE7Fu0kwWSIii1FeXi51CERERG1PFIGfjksdBZmByRIRWYwrV65IHQIREVHbEwEcSwNKr7btdcqrgYWfA14LAIe5wKhXgdMZ5h+fnAtM+DfgeA/gfh9w7/+A4grjfm9vAqa+A3R9ABCmA6+va7WXIDUmSySJrKwsCIKAGTNmtOt1Y2NjIQgCnnrqqXa9LplHJuOPJCIi6iREEdgR13bn12qBSW8Baw4Bj98BvH8fUFQBjHwVSMtr/vjcEuC2l4H0AuCdecCzU4Ff44CxbwCqesO+L68BTqYDfYPb5rVISNGeF0tKSkJBQQGKi4tRWVkJURSxcOFCk32LioqQlpaGkpISlJaWQq1WY8SIEejRo4fJ/nV1dYiPj8elS5dQVVUFa2truLm5oXfv3ggKCjIrPlEUce7cOSQnJ6Oqqgq2trYICQlB//79YWVlZdQ3IyMD58+fR3l5ObRaLRwdHRESEoKoqChYW1u36L1pDS+88AL+85//YOXKlXj44Yfb/fp/V3l5OV5++WXExMTgwQcflDocksAtt9widQhERETtQy4DfjkJ3Dvyrx0/8hUgqAvw3ROmn990FDiSAmx8Fpg5VNc2eygQ/jjw2npgzdNNn/+dzUB1HRD3ARDopWsbGKZLlr77DVg47lrfzC90sZRU6kaxOpB2/Ri3IZmxs7ODvb19k32zs7ORlJQElUrV7EaVarUaP//8M86fPw9/f38MGzYMUVFRqKmpwZ49e5CUlGRWfEePHsWxY8fg5uaGoUOHIiQkBImJidi9ezfEG8o7njx5EgcOHIBcLke/fv0waNAguLm5IS4uDjt27DDqT4a6deuGqqoqrFmzRt9WXl6O5cuX49dff5UwMpLSuXPnpA6BiIiofWi0wI7TxqM0rWXTUaCrKzB98LU2LxddwvTzCUDZzHU3HwMm97+WKAHAmD5AuC+w4Yhh36AurRa2pWnXkaUpU6bA0dERgiBg165dqK6ubrRvz5490adPH1hZWeHixYsoLCxstG9WVhYqKiowZMgQREVF6dsjIyPx448/Ijk5GT179mwytitXriAxMRFBQUEYN+5apuzk5IQjR44gIyMDoaGhAACtVovExER4enpi0qRJEARBH/OBAweQnp6O0tJSeHp6mvW+dEaCIMDBwUHqMMjCaDQaqUMgIiJqPzVK4PckXRLS2s5kAjEhwI1T3AeGAV/uBVLzgKhupo+9XKqbste/u/FzA8PadvqghWnXkSUnJyd9YtEce3t7o6lvjVGpVABgdPNtbW0NKysrKBTN54QZGbrFbtcnWwAQEREBhUKBtLQ0fZtWq4VarYadnZ3R62kYMTM3dql88sknCAsLg7W1Nezt7dGnTx98++230Gq1Bv0EQcDQoUPx+++/Izo6GjY2NnB0dMTYsWNNbiC6d+9e9OrVC9bW1nBxccHUqVNx+PBho/VJN65Zio2NRXCwbp7rli1bIAgCBEGAp6cn8vLymlxrNHv2bAiCgJSUFIP2devWITQ0FFZWVnB3d8c999zTaLU1pVKJ5557Dt26dYOVlRXs7e3Rv39/bN68uSVvK/1Nbm5uUodARETUfhRyYNuptjl3fhngY+L3akNbXhNFlfLLDPveePyVquZHpjqIdh1Zait+fn4QBAEnTpyAQqGAu7s7VCoVEhISoFQq0bdv32bPUVxcDEEQ0KWL4TCiQqGAh4cHiouLDdp8fHyQm5uL+Ph4BAcHQyaTIS8vD0lJSQgNDYWLi0uz11SpVEbJSWMUCoVZSZ85nnjiCSxbtgwhISFYvHgxVCoV1q9fj4cffhgFBQV44YUXDPrn5ORg0qRJGDduHKZOnYrjx49jz549eOCBB7Bnzx79+qyDBw9i4sSJsLe3x7x58+Dt7Y3t27fj3nvvbTamyMhIvPLKK3jzzTfRr18/zJkzB4Au+XR1dW3xa9ywYQPuueceeHh44IEHHoCTkxM2btyII0eOGPWtr6/HbbfdhtOnT2PkyJGYP38+ampqsH79esydOxcrVqzAAw880OIYqOWam3JLRETUoag1wJZjwCcPAk0NKNSrgYoa4zZlvW6d0PXcHXWjSbUqwMbEvaPtn+vqa1WNX6/hORsTH/7bWl3rY+r5DqZDlJ5ycXHBmDFjoNFosGvXLqxZswabNm1CTk4OJk+ejMDAwGbPUV1dDVtbW8jlcqPnHBwcUFdXZzBFaPTo0fD19cWJEyewfv16rF27FgcPHkRUVBRGjRplVty7d+/G6tWrzfqKj483+/1oSkpKCpYvX47u3bvj8OHD+Pjjj7F8+XKcPXsWdnZ2+PDDD5GdnW1wzOXLl/Hf//4Xmzdvxr///W/s3r0bI0eOxKFDh3D27Fl9v8cffxwA8P333+Pbb7/Fu+++i9OnT5uV7HTt2lVf1KFbt2549tln8eyzz+Kxxx5rdn3bjTQaDf75z3/C3t4e27Ztw5dffokPP/wQ586dQ11dnVH/jz76CCdOnMCbb76JvXv34u2338bHH3+MCxcuwN3dHf/5z39QWVlp4kqmXblyBUqlUv+4qqoKV69eKw2qUqlQWlpqcEx+fn6TjwsKCgzWwXXUa6SkpHSI18Fr8Bq8Bq/Ba/Aaph6bopVdS5IavcYfF3SFE67/OpICrDts1F4cl6x7HXbWgFJt9Dpqy/68p7GzbvR1lFT/2efP0SOD11GnaxNtryVKN15DpVLdtH8fN2rRUIVSqWzRAuzevXvD1ta2xUH9FdbW1nB3d0dERAQ8PDxQXV2NhIQE7N69G5MnTzarSERjZYsbEii1Wq3/Xi6Xw8nJCWFhYQgICAAAZGZm4syZM5DL5YiJiWk25sGDBxv8pTfF2dnZrH7N2bRpE0RRxL333gsfHx99u5+fH+bPn48VK1Zgz549BtX0QkJC9CM9DcaPH4/Y2FikpqZiwIABKCwsRGJiIvr374877rhD38/KygrPPfcc5s6d2yrxmyMuLg6FhYW44447MHDgQH27i4sL/vGPf+D111836L9q1Sp4e3tj0qRJyM3NNXhu5MiR2LhxIzIyMswaoQQAd3d3g8eOjo4Gj62trY3+PV7/d2Hqsbe3d6e4RsP/q5v9dfAavAavwWvwGryGqcdGFHLIZgzRjyo1eo0+NsDe1wyPfeY7wNsN+Nc0g2avqDDd+XzcgPwyo9dhV16r+8bXvdHX4RkVpvvmz+l4Bq8jvwxwd4Rge63ys/4aV5X6c1rfBL/PzdGiZEmlUuH06dNm9w8LC2uXZCknJwe7du3ChAkT9IkLAAQHB2PDhg04fPgwpk2b1sQZdNPcTI06ANcWnTdMg2uovufh4YExY8bo+4WGhmLfvn2Ii4tDSEhIsyMqXl5eTT7fFhrWXpkq0dyQ4DWs32rg6elpcAMLXPsH3DA9sWH9kr+/v9F6rcjIyFaI3HwXL14EAHTv3t0oAY6OjjbZX6lUNlm2Oj8/3+xkif46c8v8ExERdQhqDTClf/P93ByNi0C4OeoSosaKQ0QHAYeSdfstXX8/dDwNsLfRVbVrjJ8H4OUMnDKxge2JNCC64+2n1JgWJUtOTk6N7oskpbNnz0KhUBgkSoBuvYu3tzdycnKg0WhMTrFr4ODggPLycpP9bpyid/HiRVRUVGDAgAFG5wkJCcHFixdRUFDQbLJUV1dn9polKysryYpGyGQyyTcLbaowiFqt/lvnFkURfn5+eOutt2BjY2OyT//+Zvwgo7+tqqrqL61RIyIiuik52gLD2+hD5ZlDdOXDtxy7ts9SSSWw8YguQbt+vVFGge7P7teN5swYAqz6DcgpAQL+rPC8P0FXRe/pKW0TswXqEAUeqqurIYoiRFE0uqluaG9u3yMvLy/k5uaiqKjIYIhOrVajtLTUoK2h5Lmpcza0mZME7d271+y5kzExMa1ywx4eHg4ASEhIwF133WXw3JkzZwDoRmRaqmFEIDc3F/X19QaJXXJyslnnaCohahh6LSsrM3ruxqp8ISEhAHQjZFqt1iDRM7X2q1u3bigsLMTIkSM5siGxkpIS+Pv7Sx0GERFR25PLgEn9AKs2uh2fOQQYHA48sAxIygU8nYDPdun2d3rDcHkFbv9zil/WimttL87QJVajXgWenARU1QEf/KwrN/7AaMPjv48FLhXrSqEDunLob23UfX/vCKDbzbsPU4dIltzc3FBRUYGLFy8a3OhXVlYiPz8f7u7uBpXkKisrodVqDT7B7t69O86cOYNz584ZJEYXLlyAWq3W77HUcD0ASE1NNUosUlNTAcCoqp4pUqxZmjFjBl5++WX88MMPWLRoEbp27QoAyMvLww8//AAPDw+DfabM5e3tjV69eiE+Ph47d+7E1KlTAegqzb333ntmnaNh7mlFRYVR4hscHAy5XI7Tp0+jurpaXyb+xiITANCvXz906dIFv//+O06cOIHBg3WbsVVWVuLzzz83uu7999+Pl19+Ga+99hq+/vpro6qDOTk58PX1bXJkkoiIiKhFNFpgqvEspVYjlwM7Xgb+tQr49Fdd9boBocB3TwA9/Jo/PsATOPgm8H/fAc//AFgrdMndhwuMq+B9vR84eP7a498SdV+AbuSMyZJ5Ll26pK9SUVFRAQD6NVDW1tbo3bu3vu/Vq1f162saRhMuXbqkH9UJCwvTr6OJjo5GTk4OfvvtN+Tn5+sLPCQlJUGj0RhNl9u+fTuqqqoMphS6u7ujV69eOH/+PPbs2YPAwECUlZUhMTERPj4+BslSYGAgvLy8kJOTg19++UW/P1BmZiYKCgoQEhJi1oa0bbVmafPmzSbXlvXs2ROPP/44Fi9ejGXLlmHYsGGYOnWqvnR4TU0NXnzxRbOqB5ry6aefYty4cbj33nsxffp0fenwhr+z5vbY8vDwQEBAAE6cOIGnnnoKQUFBsLe3x3333QdHR0fcfffdWLNmDcaNG4fbb78dly5dwpYtW9CtWzdkZWXpzyOXy/HJJ59g3rx5mDJlCqZPnw4nJyds2LDB5Bq6JUuWYOfOnVi9ejXOnj2LESNGwMPDA9nZ2Thy5Ai0Wi1OnjxptG6LWp+pNWVEREQdkkwA7mi+IFijYt9svo+bI/DVYt1XU64fUbper0Bg96utE8tNql2TpczMTP3IS4NTp3QbcTk6OholSw3PNcjKytLfFHt7e+tvXrt06YJp06bhzJkzyMzMRHJyMqysrNClSxdER0fD17eJBWzXGTJkCJycnJCcnIzs7GzY2tqid+/e6N+/v8GNvkwmw6RJkxAfH4/MzEwcP34cgiDA2dkZAwcObLJQQHvYtWuXyfYRI0bg8ccfx9KlSxESEoLly5dj6dKlUCgUCAsLw3vvvYcFCxb85euOHj0a27ZtwzPPPIMffvgB9vb2GDFiBBYvXowJEyY0uh7oeuvWrcOjjz6KL774AiqVCh4eHpgyZQrs7OywYsUKqFQq7Nq1C6dOnUJwcDCWLl2KHTt2GCRLADB37lxotVq8+uqr+Oabb+Dk5IQJEyZg9uzZRtMPraysEBsbi//85z/4/vvv8cUXXwDQjSBGRERgzpw5sLOz+8vvC5nv/Pnz6NWrl9RhEBERtS1BAIb20CUzZNEEsbnFPER/08aNGzF79mwsWbLE7Cl51DnFx8dzdImIiDqetYeAez6+9lgmAO/fBzzTdLVmkl6H2JSWLIMoiqiqqjJoq6+vxzvvvAOZTIbx48dLFBndLFxcXKQOgYiIqO1pRWBKG65XolbTIQo8kGVQKpUICAjA6NGj0bNnT1RWVmL79u24ePEipk6diuHDh0sdIlm4hoIjREREHVpw16b3OSKLwWSJWo2VlRVGjx6NP/74A9u3b4coivDx8cFTTz2Ft99+G9bW1s2fhDq11NRUTsMjIqKOTSEDpg+SOgoyE5MlajVyuRybN2+WOgwiIiIiy6XWcgreTYRrlojIYvzVsvVEREQ3DSc7YFiE1FGQmZgsEZHFqKurkzoEIiKitiOXAZP7AQpudH+zYLJERBajqKhI6hCIiIjajoZT8G42TJaIiIiIiNrLhL5SR0AtwGSJiCxGVFSU1CEQERG1nX4hgJuj1FFQCzBZIiKLkZqaKnUIREREra/6zzW50wZKGwe1GJMlIrIYSqVS6hCIiIhan1bU/Xkn91e62XCfJSKyGE5OTlKHQERE1PoeGaubfhfVTepIqIUEURRFqYMgIgJ0pcNtbW2lDoOIiIgIAKfhEZEFuXDhgtQhEBEREekxWSIiIiIiIjKByRIRWQx/f3+pQyAiIiLSY7JERBZDrVZLHQIRERGRHpMlIrIYBQUFUodAREREpMdkiYiIiIiIyASWDicii6FWq6FQcPs3IiLq+ERRRKUKcLERpA6FmsCRJSKyGBkZGVKHQERE1C6O5wPen2mQXsZxC0vGZImILEZtba3UIRAREbWL785rUacBLlUyWbJkTJaIyGI4ODhIHQIREVG72HdJlyTZW3EaniVjskREFiMwMFDqEIiIiNqcWisio1zqKMgcTJaIyGIkJydLHQIREVGbO8WdMm4aTJaIiIiIiNrR/myuU7pZMFkiIovh6+srdQhERERtbk+WVuoQyExMloiIiIiI2klNvYgjeVJHQeZiskREFiMvj789iIioY/vjsgg1B5ZuGkyWiIiIiIjayf5sEQpWC79pMFkiIosRGRkpdQhERERtanemCDXrO9w0mCwRkcXIzs6WOgQiIqI2U1Yn4myx1FFQSzBZIiKLUV1dLXUIREREbSY2RwQHlW4uCqkDICJqYGdnJ3UIRER0kymvE7Hkdy22pomoqQcG+gj4cKQMMV3NWxiUXCri6d+0OHxZhLUcmBQi4KORMnjZGx7/9jEtjueLOJ4voqgGeG2IgNeHyVsU6/5LIhQysMDDTYQjS9QuPv74YwiCgNWrV7f6ubOysiAIAhYsWNDq56b21b17d6lDICKim4hWFDFpiwZrkkU83leG90fIUFQjYuR6DdLKmh/Dyb0q4rZ1GqSXi3jnVhme7S/DrxdFjN2ogUpjePzLh7U4WSCib5e/Xp1hZyYr4d1sLHpk6cyZMygpKUFJSQmuXr0KR0dH3HPPPY32LyoqwsmTJ1FUVAQA6Nq1KwYOHAhPT0+DfuXl5bhw4YL+3CqVCjExMejfv3+rxNEeHn/8cSxfvlz/WBAE2NvbIzQ0FP/4xz/w6KOPShhd60tJScGHH36ImTNnYty4/2/vvuOaOvc/gH8CCXtvREERVNQqDiyOugcdjl53rXu0Ve9tq7Z6q3VXrf5utcNesO7VClasWkdvFW3rRLRSF6CigIKgsneS8/uDJhITMGBCAnzer1deluc855zvydEmX57n+Z7+hg6H9OTq1asIDAw0dBhERFRL7I0re2ZRxEATDGteNgYworkIzTbJsOi0HLvfqHzkZ8U5OfJLgZixpvC2K0uCOnkC/SLk2HpVwLS2TxOjxKmmaGwvwqMCAa7fyqoc6/1cAXeyq7wbGZhRJ0vR0dEwNzeHi4sLSkpKKu378OFDHDp0CFZWVujQoQMA4Nq1azh48CAGDx4MJycnlb6xsbGws7ODi4vLc5/tUpU4atqUKVPQvHlzSKVSxMfHIyIiAu+++y4eP36MTz75xNDh6czt27fx3XffwdPTUy1Z8vHxQW5uLszMzAwUHRERERnC3ngB7lbAP5o9TWpcrUQY0VyEndcFFEsFmFdSp/vHBAFv+IqUiRIA9PUxQTNHOcLjBExr+7RvY/sXq/d9PImrlWojo06WRo0aBTs7OwBAREQESktLK+x75swZmJiYYNCgQbC2tgZQNqUnPDwcZ8+exeuvv67s6+Pjg/Hjx8Pc3BwZGRmIjIzUWRw17fXXX8eQIUOUP0+cOBHdu3fH+vXrMW/ePJiY1P2ZliKRCDY2NoYOg3TAw8PD0CEQEVEtcjldQHt3EUxEqolMJ08RNsQKiM8EXnLVvO/93LK1Rx091JOgTp4iHL6j2+Tm+L2y5yuxbHjtYtTfpBUJyvNkZ2cjIyMDvr6+ykQJAKytreHr64v79++joKBA2W5hYQFzc3Odx2EMXnnlFdja2iI9PR1FRUUAgNTUVAwbNgzOzs4Qi8VwdnbGkCFDcPfuXZV9FeuKtmzZgunTp8PV1RUSiQQ+Pj5Ys2aN2rlEIhH69Omj1q7t+qScnBxMmTIFzZo1g62tLSQSCdzd3TFmzBg8efJE5XiKZHfp0qUQiUQQiURo2bIlgIrXLEmlUsyePRuNGjWCRCKBjY0NOnfujKioKJV+5fffsWMH/P39IZFI4ODggFGjRqGwsLDS6yDdEYuN+vc3RERkZFLzAU9r9XZF24O8ijOT1HzVvs/u/6QIKNZRZiMIAo7e5fOVaqM68c0kI6OsYL27u7vaNjc3N8TFxeHRo0fw9vau6dCUFImLNszMzKo9IvTw4UPk5eXB3t4eZmZmyMzMRMeOHZGamooBAwagY8eOuHLlCg4cOIALFy4gJiYGnp6eKsdYvnw5CgsLMWrUKJiammLv3r34+OOPkZ+fj8WLF1crLk2SkpIQERGB3r17480334REIsHp06fx/fff49q1a4iJiYGpqSn69++PKVOmYOPGjXjttdfQq1cvAJrvd3khISE4fvw42rZtizFjxiA9PR179uzBq6++in379uG1115T6X/69Gns27cPw4YNw+jRo3HkyBHs2bMHtra2+O6773R23VSxlJQUtTWGRERUP8gFASVaLgUyNy37pW2htOy/n2Xx9zfcQmnFx1Bs07i/6dM+5jr4thyfCaQXPL8fGR+jHlnSlmLUyMrKSm2bYqTJ0M9v2b59u9avtLQ0rY+blZWFlJQUJCYm4qeffkLv3r0hCAJCQkIgFosxb948PHjwALNnz8aRI0ewbNkyHDhwAEuWLEFqaio+/vhjtWNmZ2cjOjoaX3/9NdatW4fY2Fi4uLhgzZo1ysRUF/z9/ZGWlobIyEh8/vnnWL58OaKiovDOO+/gypUr+OmnnwAArVq1wptvvgkA6NixI+bMmYM5c+Zg7NixFR47MjISx48fR9euXXHx4kWsWrUKmzdvxvHjx1FaWopZs2ZBLlctR5OUlIQTJ05g8+bNWLp0KS5cuAAfHx+Eh4dXaerlkydPUFxcrPw5Ly8Pubm5yp9LSkrw+PFjlX1SU1Mr/TktLQ2C8PTXUXX1HDKZrE5cB8/Bc/AcPAfPUfVz/JYswHKdTKvX+cRsFBcXw1IMFMvUz5FbVJYJWYpVz1FeftYjAGX7P3sdRX+3mcifrlV/9hwymVzr9yq+ksp85dfDG9P9qA/n0IpQS4SHhwu7du3SuC0mJkYICwsTUlJS1LalpKQIYWFhQmxsrMZ909PThbCwMCE6OvqF46hMcnKy1q+ioqLnHm/GjBkCALWXmZmZMHz4cKGgoEAQBEFo1KiRYGtrK+Tl5ansX1paKtjZ2QleXl6CXC4XBEEQvvjiCwGAMG3aNLXzzZ49WwAghIaGKtsACL1791brqzjOtm3bKm0rr7i4WEhNTRWSk5OFn3/+WQAgfPjhh8rtiraFCxeq7ZuYmCgAEMaPH69sGz58uABAOHz4sFr/7t27CwCE69evq+zfvXt3tb6jRo0SAAj37t3TGDfpVmFhoaFDICIiA0nNkwtb/pJp9coqKvvu4vddqfDqXqnasTbGygSsKRVi0+UVni8lRy5gTanw+XmZ2ra3f5YKTl+XatwvI79sv0V/qJ+3Iop9NL3O3K84RjK8OjENT7HOQSZTH7tVtBl6LUTDhg31ctyPP/4YgYGBMDU1hZOTE4KCgmBvb6/cnpaWhiZNmqis5QLK3g9vb2/ExcWhqKhI5WGgrVq1UjtP27Zl5WASEhJ0Gv+SJUuwZcsWJCUlqfz2AAAyMzOrfdykpCSIRCJ06tRJbVtAQAB+++033LhxAwEBAcp2TdM0nZ2dAZS9j4acxllf3L9/n89aIiKqpzysRZjQumoV5wLdRPg9RYBcEFSKPJxPFWAlBpo5Vryvl60IrpbAxTT1UZ8LqQICX+B5Ss9ysRKhtQtw9ZHODkk1pE4kS4rpd+WLOCgopt89myzUNE2xVcTc3Bympto9Ebpz584q1fCMgVRayQThcubPn48VK1YgMDAQkyZNgre3N8zNzZGamorZs2erJU/6Vtl7XtOx1Fflh9OJiIieZ1gzEfbGC9gXL2BY87Lk5lGBgIg4AQObilTKht/OKvssb+rwtG1oMxG2XROQnCOg0d/lw4/fkyM+E/iwg+6SJQAY0FiEm49Z5KG2qRPJkqtrWU3Ihw8fokWLFirbFA+oNfSi8Z07d2rd94033kCDBg10cl5PT0+kpqYiPz9fJWGUSqVISkqCm5sbLCwsVPa5du2a2nGuXLkCoGydkYKNjQ2ys9Wfrqbt6NOePXvg4uKC8+fPqzwjae/evWp9RaKq/Q/Lx8cH58+fx4ULF/Dqq6+qbLt58yYAqIwqkXGoSpVKIiKiYc1ECPYEJh6V4/pjwMUS+PZPOWQCsKSr6tL8PuFls43uTnv69feTl00QES9Dr3AZ3m9vgrxSYE20HC+5ABOfGeXacU2OezlAwd/Zzm8pwPKzZeufx7YUwec5z2Hq6yPCfy4yU6pt6kSyZG9vD1dXV9y5cwcdO3ZUKepw584deHl5aSz+UJOerbxWGcXUL10ICQnBhg0bsHTpUnz++efK9s8//xw5OTkYNGiQWiLy448/YuHChfDy8gJQtqBu27ZtsLKyUhZaAIBGjRohLi4OGRkZyoT10aNHiIiI0Co2RcW/8oUWSktLsXz5crW+iqmF5UuKV2bUqFEIDw/HypUr0b9/f+WoUXR0NH7//Xc0b94czZs31+pYVHOaNWtm6BCIiKgWMTUR4fBQU3x0So6vLstRWAoEeQBbXzVFc6fn/6K1kZ0Ip0aaYtZJOeb9JoeZKfC6rwj/6Wmi9jDbTX/JcSrl6c9RyQKiksuSn25eJs9Nll7xEvE5S7WQUSdL8fHxyMvLA1BWelsmk+HSpUsAykY1yn+x6ty5Mw4dOoQDBw6gdevWAICrV69CEAQEBwerHLekpARXr14F8HR6XFpamvLYPj4+KglLVeKoiL7WLD3PqlWrcOjQIaxZswZXr15F+/btERsbi4MHD8LT0xOrV69W28fe3h5BQUEYNmwYTE1NERERgUePHmHBggVwc3NT9psxYwZmzpyJLl26YMSIEcjOzkZ4eDjc3NyQlZX13NgGDx6M//u//0NwcDAGDRqE3Nxc/PTTTxrLprdr1w6WlpYIDw+Hg4MDnJ2d4e7ujtGjR2s89ptvvok+ffrg+PHjCAoKQkhICNLT0/H9999DIpHgiy++qBcP7K1t/vrrLwQGBho6DCIiqkUcLUTYOMAUGwdU3q/8iFJ5rVxEODbs+csfTo56sa/N1mYidPIEzjx4ocNQDTPqZCkuLk6txN/FixcBlE0vK5+keHh4YODAgYiOjkZ0dDREIhHc3d3Rr18/tZGa4uJi5XEUHjx4gAcPyv72Wltbq+xTlTiMjaOjI6Kjo/Gvf/0LUVFROHbsGOzs7DBw4EB8+eWXas9YAoAFCxbgwoUL2L17N7Kzs+Hp6YmVK1di3rx5Kv1mzJiBe/fuYcuWLVi9ejXc3Nwwffp02NvbY9asWc+NbdWqVZBKpfj++++xcuVK2Nvbo1+/fpg7dy7atWun0tfS0hIbN27Ep59+qtwvICCgwmQJAI4ePYq5c+diz549WLNmDczNzdGmTRt89tln6N27t5bvIBEREZFu9G9sgvOpZdMEqXYQCVy5Tn9bu3YtZs2ahW3btmHcuHGGDofqoQcPHuhsvR4REZGx+SNFwCs/qFZvPvOWKTo30G0xCdIdzkMiIqPxbLERIiKiuqSTJ2Bh1PO66FlMlojIaCQlJRk6BCIiIr0xMxWhZ0PAhANJtQaTJSIiIiKiGtKvMb9+1yZcs0RERqOgoMDgZf6JiIj06Uq6gMDtT9ctcc2ScWNqS0RG4+HDh4YOgYiISK9ecgUc+Az2WoPJEhEZjezsbEOHQEREpFcmIhH6+XAkqbZgskRERkMikRg6BCIiIr3r15jJUm3BZImIjEarVq0MHQIREZHe9fFmslRbMFkiIqPx559/GjoEIiIivfN1YLJUWzBZIiIiIiKqYZ09DR0BaYPJEhEZDRcXF0OHQEREVCP6/l3kIauIT/ExZmJDB0BEpGBjY2PoEIiIiGrE9HYmuPFEhlcackqeMeNDaYnIaPz5558IDAw0dBhEREREADgNj4iIiIiISCOOLBGR0cjLy+NUPCIiIjIaHFkiIqPx+PFjQ4dAREREpMRkiYiMRmZmpqFDICIiIlJiskRERsPU1NTQIRAREREpcc0SERERERGRBhxZIiKjERsba+gQiIiIiJSYLBGR0ZDL5YYOgYiISD8SHgBTvzV0FFRFTJaIyGg4OTkZOgQiIiL9mPpfYOOvQH6RoSOhKmCyRERGw8HBwdAhEBER6YeLbdmfF28bNg6qEiZLRGQ07ty5Y+gQiIiI9KNlo7I/z8UZNg6qEiZLRERERET6Zvr31+7TNw0bB1UJkyUiMhpNmjQxdAhERET6deYmwCf31BpMlojIaOTk5Bg6BCIiIv16nAfcyzB0FKQlJktEZDQeP35s6BCIiIj0RhD9/R/n4g0aB2mPyRIRGQ2RSPT8TkRERLWUYGoCSExZ5KEWYbJEREajbdu2hg6BiIhIb0xEIqBUBvx+w9ChkJaYLBGR0bh69aqhQyAiItIbQVHYIfYuUFRi0FhIO0yWiMhoSKVSQ4dARESkN8oaeFI5cDnRkKGQlpgsEZHRcHBwMHQIREREeiPC32tzTUQs8lBLMFkiIqPh4uJi6BCIiIj0R1HHSCQCzur54bRZ+cC0/wKuEwDr0UCvhcCl2/o9Zx3EZImMUkhICCuj1UO3bt0ydAhERER6o1yzJJMDf+gxWZLLgdeXA7t/B2a+CqweB6RnAz0XAgkP9HfeOkhcUye6fPkyHj16hEePHiE3Nxc2NjZ46623qnyc+Ph4/PXXX8jKyoKZmRm8vb3RqVMnWFpaVrrf+fPnceXKFYjFYkyaNElte1FREf7880/cu3cPeXl5MDMzg6OjI1q3bo3GjRtXOU5d27ZtGyZMmACRSIRr164hICCgRs67cuVKfPLJJyptZmZmcHJyQrdu3bBs2TK0aNGiRmIhIiIiqjNSM4EHT4AGTlXft+enQGM3YOs/NW/fexY4EwdEzAGGdSlrG9EFaDYTWLQH2P1h9eOuZ2osWYqOjoa5uTlcXFxQUlK96h+xsbE4d+4cPD090aVLF+Tn5yM2Nhbp6ekYMmQIJBKJxv0ePXqE2NhYSCSSpxl9OVKpFD/99BPy8vLQokULODs7o6ioCPHx8fjll1/QrVs3tGzZslox68rGjRvh7OyM7OxsrFu3DmFhYTV6/uHDh6NTp04AgJycHERHR+PHH3/EiRMnEB8fD2dn5xqNh+omY/jFBBERkb6ozZo5Fw/8I1j3J9p7FnB3UD22q31ZwrTzN6C4FDDX/L2ZVNXYNLxRo0Zh/PjxeP3112FlZVXl/YuKinDx4kW4urri9ddfR0BAADp27Ig+ffogMzOzwpLDcrkcv//+Oxo1alTheoi7d+8iOzsbnTp1QteuXdGiRQsEBgZi8ODBEIvFuHHDsLXwk5KScPbsWQwfPhwvv/wyIiMjIZfLazSGHj16YM6cOZgzZw6WLl2KI0eOYMSIEXjy5AkiIiJqNJbyHj9+bLBzk+7l5+cbOgQiIiL9Kf87e4mp/oo8XE4E2vsCJs981e/kDxQUA/GciqetGkuW7OzsXmj/u3fvQiqVolWrVjApd+N9fHxga2uLhIQEjftdvXoVmZmZ6Nq1a4XHVox0WVtbq7SbmZlBIpFALK6xATiNvvrqK8jlcsyYMQPjx49HRkYG9uzZo9x+7tw5iEQijBo1SuP+vXv3hlgsRlJSkrLt9u3bGDJkCFxcXCAWi+Ho6IiBAwfi3r17WsfVoEEDAIC5ublKu1wux8KFC9G0aVOYm5vDwsICbdq00ZhU5eXlYcyYMXB0dISZmRn8/f2xa9cujed76aWX4OrqiitXruCVV16BjY2NMgFWrHG6f/8+QkJCYGtrCwsLC3Tp0gV37twBACxZsgReXl6QSCTw8vLChg0b1M6xevVq+Pv7w8rKCubm5nBzc0Pfvn1V3jvSn4yMDEOHQEREpDdC+WypVAb8oadfyKdmAp6O6u2KtgdP9HPeOsiwWUAVpKenAwDc3d3Vtrm7u+PWrVsoLS1VmYqXm5uLixcvon379rC1ta3w2F5eXhCJRLhw4QLEYjGcnJxQUlKC2NhYFBcXo127ds+NTxAEFBcXa3095ubmWhcwCA8PR+vWrdG6dWs0a9YMc+bMwXfffYfRo0cDAIKDg+Hn54ejR4+qvQePHj3C6dOnERQUBG9vbwDAjRs30LVrV0ilUgwZMgR+fn5ISEjA3r17ERwcjNjYWLi6uqrEkJ2djZSUFABAVlYWTp06hU2bNsHDwwPDhg1T6du/f3+cOHEC3bt3x8iRI1FcXIzIyEiMGjUKWVlZmDp1qrLvgAEDcObMGbz88svo27cvbt26hcmTJ8PNzU3je1FUVITevXujTZs2mDVrFh4+fKiyvUePHnB3d8cHH3yAhIQERERE4NVXX8Vrr72GH374AcOHD4eFhQW2bt2K9957D8HBwWjTpg2AskRp7ty5aNmyJd5//31YWloiKSkJJ0+eREpKivL9IyIiItKJS7eBUikgqeQreakUyC5QbysuBR7lqLY72ZSNJhWWAOYajmlhVvZnIR+Iq61akywVFJT9JXl29AeAclpffn6+ynNa/vjjD9jZ2Sm/DFfE3t4effv2xZkzZ3D06FFlu6WlJd544w14eHg8N768vDx8//332lwKAGD06NGVJnAKR44cQXJyMt577z0AZaNdISEhiIyMRFpamjK2kSNH4rPPPsOuXbswYcIE5f6hoaEoKSnBuHHjlG2TJk2CVCpFdHQ0mjdvrmwfN24cQkJCMH/+fLVRl/nz52P+/PkqbQEBATh06JDKdYSGhuL48eNYvHgxFi1apGxfuXIlWrZsifnz52Py5MkwMTHBrl27cObMGQwYMEDlfd+wYQPeeecdje9HXl4eJk6ciM2bN2vc3qZNG+zbt0+lbc+ePXj8+DFu3rypHIl644030KNHD/znP//Btm3bAAAHDhyAhYUFLl++DDMzM43HJ/1q27atoUMgIiLSG7VflBdLgRspQJvGFe90+mZZ2e9nnYkDfvhDtS0xtKzwg6VZ2bGfVfR3kmTJ7znaqjWlw6XSshtuamqqtk0xTU7RBygrQZycnIxu3bqpTNuriKLCW4cOHdC/f3907doVYrEYx44d02pdjKWlJV577TWtX8+r3qfw7bffwtzcHO+++66ybfr06SgtLcU333yj0iYWi5Vf/BV++OEHWFtbKxOojIwMnD9/Hq+88gqsra2RkpKifAUEBMDDwwO//fabWhxTpkzB7t27sXv3boSFhWHKlClITExEv379kJaWpuy3c+dOWFhYYMKECSrHTk9PR58+fZCRkYFLly4BAPbu3QsAWLhQ9X8A06ZNU07x02TlypUVbluwYIHKzz179gQADBo0SGXNWvfu3WFpaamcogcAtra2KCkpwdatW19oTdiTJ09URhnz8vKQm5ur/LmkpETt71RqamqlP6elpakUJ6mr54iNja0T18Fz8Bw8B8/Bc/Acmn7WVGis2PXpL501neNJIzvgf4uUr8c//BNo4wP0D3z6s2K7h0PZdXg6lE3Fe/Y6/m7LtzdXOYcxvlc1cQ6tCAYQHh4u7Nq1q0r7HDlyRAgLCxNKS0vVtp09e1YICwsTMjMzBUEQhMLCQmH79u3CqVOnVPodOHBA2LRpk9r+SUlJwoYNG4SkpCSV9vz8fGHLli3C/v37qxSrrmRmZgoWFhZCp06dhEuXLqm8PDw8hCZNmqj079q1qyCRSISMjAxBEAThr7/+EkQikfDmm28q+xw5ckRA2fLCCl9ubm7K/itWrBAACN98841afF9++aUAQBg7dqyyzcvL67nHj4yMFARBENq3by+IRCKhqKhI7dhdunQRnv3r2bp1a8HW1lbjezVgwAABgFBSUqLSHhERIQAQli1bpraPi4uL8NJLLyl/jomJEdzc3AQAgo2NjdC1a1dh6dKlwqNHjzSek3Tv8uXLhg6BiIhIPxb/IMjEQwUBbz59+b5bvWP1WCAI47+qePuw1YLgPlEQZDLV9qnfCoLVKEEoKtG8H6mpNdPwyk+1s7e3V9n27BS9S5cuobS0FC1atEB2drayn2LkKTs7G6amprCxsQEA5fOXGjVqpHZODw8PJCcnQyaTaRzVUpDL5SgqKtL6eiwsLJ474vXf//4XRUVFuHDhAtq3b6+xT1RUFHr16gWgbBrd6dOn8d///heffvop1q9fD0EQMG3aNGV/4e8MvW/fvhqfNwVonuqoyciRI/H+++/j7NmzKse3tbWttLR5cHD1S2Q+W0ziWRWVj6/o3gnlfmPRvn17JCYmIjw8HMeOHUN0dDQWLlyItWvX4sSJEwgMDKx23KSdFy0EQ0REZMxUJuGJTYBX9PTczGGdy8qH7zv39DlLj3KAiDPAwI4sG14FtSZZcnNzw82bN/Hw4UO1ZOnhw4dwcHBQflHOzc2FVCrF/v37NR5rz549cHR0xPDhwwGUJWCCIEAQBLW5pIp2QcOwaXn5+fk6X7O0c+dOODo6YtmyZWrbiouL8dFHH2H9+vXKZGn8+PGYM2cOfvjhB3z66afYv38/GjRogJCQEOV+bdq0gUgkQmlpqbJARHUphkIVySoANGrUCBcuXEBISAgcHTVUYSnH29sbly5dQkxMDLp06aKy7e7duy8UW3VZWVlhwoQJymmLW7duxcSJE7F06VK1tVCke9qsDyQiIqq1yn/PlAlAcPOK+76IYZ2B4GbAxG+A6ymAiy3w7VFAJgeWaK6eTJoZZbKUl5cHqVQKOzs75eiLj48PTE1Nce3aNfj5+Snb7927h9zcXHTs2FG5f2BgIPz9/dWOGxMTg5ycHPTq1UtlAb+joyOys7Nx584dNG3aVNmek5OD1NRUODk5Pbd8uGLNkraet2bp4sWLuH79OoYNG4YZM2Zo7LN161YcPXoUBQUFylLXISEh2Lt3L7744gukpaXhn/9UfbKzl5cXgoKC8Pvvv+Pw4cNqMcvlcq0rv23duhVAWaEHhbFjx+L8+fOYOnWqck1SeYmJiWjSpAkAYOjQodi/fz+WLl2qVuDhwYOar/+fkpKChg0bqrR1794dQFkFQNK/+Ph4juAREVGdJQjC09ElQShLaPTB1BQ4vAD4aBvw1c9l1e+C/ICt/wSae+nnnHVUjSVL8fHxyMvLA1BW/lkmkykX+tvY2KBZs6d/WaKiopCamqoy+mJpaYmgoCCcO3cOP//8M/z8/JCfn4/Y2Fg4ODjgpZdeUu6vqbw4AFy7dg25ubnw9fVVaQ8MDERycrLyvM7OzsjPz8f169chk8kQFBT03OsTi8VqX7RfxFdffQUAFT47CSir6LZy5Ups2LABH3zwAQDgnXfeQUREBBYsWACRSKQx0dq2bRu6deuGQYMGYcCAAWjXrh1kMhnu3LmDqKgoDBkyRK0a3qlTp1BYWAigbBQtJiYGhw8fhqWlJZYvX67sN2PGDBw6dAg//vgjAgIC0LdvX7i6uiI5ORkxMTHKYg8A8Pbbb+Obb77BsWPHEBwcjH79+uHWrVuIjIxEo0aNkJyc/ELvYVV1794dtra26NSpE7y9vZGZmYm9e/dCJBKpVBMkIiIiemEWEqB1NR9LclJ91pEaRxtg44yyF1VbjSVLcXFxahUoLl68CADw9PRUSZYq0qZNG5ibm+Ovv/7CmTNnIJFI4Ovri5dffrnCtSracHNzw+DBg3H58mUkJibixo0bkEgkcHNzQ2BgYKWV2fShtLQUBw8ehK2tLYYMGVJhv4kTJ2LVqlXYvn27Mlnq06ePMtEIDAxUKQ2u0KJFC/z555+YO3cuTpw4gV9++QUSiQQuLi7o2bMnJk6cqLZPRESE8qGyJiYmsLe3R69evbBy5UqVUT2grNz56tWrsW3bNmzcuBFSqRQODg5o3ry5WrW6//3vf5g2bRqOHDmCS5cuwcfHB5s2bcKOHTtqPFmaMGECIiMjERERgby8PNjY2MDf3x//+c9/lFM2Sb/4LCsiIqrLVJZ7dPQDxBWvhyfjIBKetxiHiKiGpKamwtPT09BhEBER6d6SPRCW74VIKitLkuYMBla+beio6DlqzXOWiKjue/jwoaFDICIi0hsBf49RSGX6W69EOsVkiYiIiIiopr2sXoyMjA+TJSIyGuULtRAREdU1yjVLXk6AR+WPWCHjwGSJiIxGQkKCoUMgIiLSH0EATE2Abnp6GC3pHJMlIjIaRUVFhg6BiIhIfwSUJUyd9fQwWtI5o3woLRHVT4rnqhEREdVFIpm87D+YLNUaHFkiIqPh5cWnihMRUR0nMQUCGxs6CtISkyUiMho3b940dAhERET6FdgEMJMYOgrSEpMlIiIiIqKawuIOtQqTJSIyGg0bNjR0CERERPqRllX2Jx9GW6swWSIioyGTyQwdAhERkX5c+PvxGEyWahUmS0RkNFJTUw0dAhERkX68NwCCCEAjF0NHQlXA0uFERERERPo2pR+uNbFEa5HI0JFQFYgEQRAMHQQREQCUlpZCImGFICIiqpv4OVf7cBoeERmNxMREQ4dARESkN/ycq32YLBGR0SgoKDB0CERERHrDz7nah8kSERkNa2trQ4dARESkN/ycq324ZomIjEZJSQnMzMwMHQYREZFe8HOu9uHIEhEZjevXrxs6BCIiIr3h51ztw2SJiIiIiIhIAyZLRGQ0GjRoYOgQiIiI9Iafc7UPkyUiMhoiPqiPiIjqMH7O1T5MlojIaNy/f9/QIRAREekNP+dqHyZLREREREREGrB0OBEZjeLiYpibmxs6DCIiIr3g51ztw5ElIjIaycnJhg6BiIhIb/g5V/swWSIio5GXl2foEIiIiPSGn3O1D5MlIjIaFhYWhg6BiIhIb/g5V/twzRIRGQ2pVAqxWGzoMIiIiPSCn3O1D0eWiMhoXL161dAhEBER6Q0/52ofprZEOiSTyRAfH2/oMGqtO3fusEoQERHVWfycMy7NmjWDqalppX2YLBHpUHx8PFq2bGnoMIiIiIjoOa5fv46AgIBK+3DNEpEO1aWRpby8PHTq1AkXLlyAjY2NocOp93g/jAvvh/HgvTAuvB8VS0tLQ+/evXHixAl4eHjo/Xy8F8+nzcgSkyUi0ignJwf29vbIzs6GnZ2docOp93g/jAvvh/HgvTAuvB8VS0lJQaNGjZCcnIyGDRvq/Xy8F7rBAg9EREREREQaMFkiIiIiIiLSgMkSEWlkbm6ORYsWsWqPkeD9MC68H8aD98K48H5UzM7ODj169KixKXG8F7rBNUtEREREREQacGSJiIiIiIhIAyZLREREREREGjBZIiIiIiIi0oDJEhERERERkQZMlojqkZUrV2L48OHw9fWFSCRC48aNq3WcgoICLF26FK1atYKlpSWcnJzQuXNnREZG6jbgOu5F78fWrVshEokqfd2/f18/wdcxuvi3UVpaim+//RYdOnSAg4MDHBwc0L59e3z55ZcoKSnRfdB1mC7uR15eHj7++GM0bdoU5ubm8PDwwMSJE/lvoori4+OxcOFCBAcHw9XVFba2tggMDMRnn32G/Px8rY9z+PBhdOnSBdbW1nBycsLw4cORmJiox8jrHl3ci/DwcEycOBFt27aFRCKBSCTC3bt39Rt4LcdqeET1iEgkgpOTE9q3b4+YmBjY2dlV+X+SmZmZ6NOnDxISEpT/w83Pz8eNGzfQvHlzfPDBB3qJvS560ftx584dnDlzRq09NTUVH3/8Mdq1a4dLly7pMOK6Sxf/NsaMGYPdu3dj6NCh6NOnD2QyGQ4ePIhffvkFI0aMwJ49e/QTfB30ovejsLAQ3bp1w+XLlzFu3Dh07twZiYmJWL9+PRwdHXHhwgV4eHjo7wLqkHnz5mH9+vUYNGgQgoODIZFIEBUVhfDwcLRp0wbnzp2DpaVlpcfYt28fhg0bhrZt22Lq1KnIzs7GunXrYGpqiosXL6JBgwY1dDW1my7uRc+ePXH+/Hm0bdsWWVlZiIuLQ2JiYrV/eVovCERUb9y+fVv5361atRJ8fHyqfIy3335bsLW1Fa5du6bDyOonXdwPTVasWCEAEL755hudHK8+eNF7cf/+fQGAMGTIEJV2uVwudOvWTRCJRMKTJ090EWq98KL3Y+3atQIAYcWKFSrtp0+fFkQikTB58mRdhFkvREdHC1lZWWrt8+fPFwAIX3/9daX7l5SUCA0aNBC8vb2F3NxcZfvly5cFExMTYerUqTqPua560XshCIJw7949obS0VBAEQZgxY4YAQEhMTNR1qHUKp+ER1SO+vr4vtP/du3exe/duTJ06FS1btoRMJkNeXp6Ooqt/XvR+aCIIAjZv3gxLS0uMGTNG58evq170XuTm5gKA2m/IRSIRPD09YWJiAgsLixc6R33yovcjKioKADBx4kSV9i5dusDf3x8//PADioqKXugc9UXHjh1hb2+v1j5y5EgAwNWrVyvd/9SpU3jw4AGmTJkCGxsbZXtgYCB69uyJPXv2oLS0VLdB11Evei8AwNvbG2KxWOex1WVMlohIa0ePHoVcLkfLli0xduxYWFlZwdbWFg0bNsTatWsNHR6h7IvJrVu3MHToUDg4OBg6nHqjadOmaNq0KTZv3oyNGzfi7t27uH37Nr744gvs27cP//73v587PYZ0p7i4GABgZWWlts3Kygr5+fn466+/ajqsOiUlJQUA4O7uXmm/6OhoAEDnzp3VtgUHByMnJwfx8fG6D7Ae0fZeUPUwWSIircXFxQEA/v3vfyMmJgahoaHYuXMnmjRpglmzZmHRokUGjpA2bdoEAJgyZYqBI6lfxGIxDhw4gNatW2Pq1Klo0qQJ/Pz8MG/ePHz99ddYtmyZoUOsV1q1agUAOHHihEp7amoqbt68CQBITk6u8bjqCplMhmXLlkEsFuOtt96qtO+DBw8AAF5eXmrbFG0sulF9VbkXVD0chyMirSmmGpWUlOD333+Hs7MzAGDEiBFo2bIlVq9ejQ8++ACOjo6GDLPeysrKwo8//gg/Pz/06NHD0OHUO5aWlvD390dQUBB69+6NgoICbNu2DTNnzoS1tTXGjRtn6BDrjffeew+hoaF47733UFxcjODgYNy7dw8fffQRZDIZgLKqnlQ9H3zwAc6ePYsVK1agefPmlfZVvM/m5uZq2xRTU3kvqq8q94KqhyNLRKQ1xTSiN954Q5koAYBEIsFbb72FoqIinDt3zlDh1Xu7d+9GYWEhJk+ebOhQ6p20tDQEBQXB29sb3377LYYNG4Zx48bhf//7Hzp16oSZM2ciMzPT0GHWG35+fvj5559hbW2NUaNGoXHjxujRowcaNmyoHHW1s7MzcJS106effopvvvkG06ZNw7///e/n9ldMhVRMjSxPsW5M03RJer6q3guqHiZLRKS1hg0bAoDGkruenp4AwC+EBrRp0yaIxWJMmDDB0KHUOxs2bMDjx48xfPhwlXYTExMMGzYMubm5LONew3r27ImEhARcu3YNp06dQlJSEn788Uc8evQIANCiRQsDR1j7LF68GMuXL8fEiRMRGhqq1T6Koieaptop2jRN0aPKVedeUPVwGh4Raa1Tp04Ani4mLU/R5ubmVqMxUZk///wTly5dwuDBg/n8GANQfOlTTPEqTyqVqvxJNUckEqFly5bKn4uLi3HixAn4+fmhWbNmBoys9lm8eDGWLFmC8ePHY+PGjRCJRFrtFxQUBAA4e/Ys+vbtq7Lt3LlzsLOz472ooureC6oejiwRkUZJSUm4efOmSknX7t27w8fHBwcPHlT5LWF+fj62b98OBwcHjRWP6MVpuh/lbdy4EQA4Ba8GaLoXii/kW7duVelbWlqK3bt3QywWo127djUZZr3xvH8b5X3yySd4/Pgx5s+fXwOR1R1Lly7FkiVLMHbsWGzevBkmJpq/PioKaJRfg9SjRw94enpi48aNKo+auHLlCk6ePInhw4dDIpHo/Rrqihe5F1Q9IkEQBEMHQUQ1Y8eOHbh37x4A4Ouvv0ZJSQlmz54NAPDx8cHYsWOVfXv27IlTp06pPdn78OHDGDRoEBo0aIDp06fDzMwMW7ZswdWrV7Fp0yZMmjSpRq+pNtPF/QDK5v17enrCysoKSUlJMDU1rbFrqCte9F7k5OQgMDAQiYmJGDhwIAYMGICCggLs3LkTsbGx+Oijj7B69eoav67aShf/Njp06IBevXrB398fxcXF2L9/P6KiojBt2jSEhYXV6PXUZuvXr8fMmTPh7e2NZcuWqX05d3d3R79+/QAAEyZMwLZt2xAVFYWePXsq+0RERGDkyJFo27Ytpk6dipycHKxduxYikQgxMTGchqclXdyL3377Db/99hsA4NChQzh//jxmz56tfNTEggULauRaahUDPxSXiGpQjx49BAAaXz169NDYV9OTvU+ePCn06tVLsLGxESwtLYUuXboIBw4cqJmLqEN0dT927dolABA++eSTmgm8DtLFvXj48KEwY8YMoXHjxoJEIhGsrKyEoKAgYcOGDYJcLq+5i6kDdHE/ZsyYIfj7+wuWlpaCra2t8Morrwi7d++uuYuoI8aPH1/hvXj2fij6RkVFqR3n4MGDwssvvyxYWloKDg4OwtChQ4Vbt27V3IXUAbq4F4sWLar0GKSOI0tEREREREQacM0SERERERGRBkyWiIiIiIiINGCyREREREREpAGTJSIiIiIiIg2YLBEREREREWnAZImIiIiIiEgDJktEREREREQaMFkiIiIiIiLSQGzoAIiIiIiIaoMJEyZg27ZtAIBWrVrh6tWrKtvlcjlWrFiBLVu2ICkpCd7e3rh9+zZWr16NzZs34/r16zAxqfpYRWhoKFasWIGEhASYm5urbFu3bh0+/PBD5c8ZGRlwcXGpxtVVT3p6OuLj45Gamorc3FyYm5vD3d0dHTt2hIODg1bHkMlkuHjxIhISElBcXAwnJycEBQWhYcOGyj4nT55EfHx8hccYM2YMrK2tdRaTAkeWiIiIiKjeO3bsGEQiUYWv7du3AwBcXFywY8cOrFq1Su0Y3377LRYuXIh//OMf2Lx5M8LCwpCTk4PPP/8cc+fOVUuUlixZAhMTE9y4cUPtWJMmTYKpqSl+/vlnTJgwASUlJQgLC1PrFxISgh07duDNN9/U0TtRNVeuXEFiYiIaNGiALl26ICAgAKmpqdi3bx+ePHmi1TFOnjyJ2NhY+Pn5oUuXLjAxMcGRI0eQlpam7BMQEIBevXqpvHr27AmxWAxHR0dloqSrmBREgiAIVdqDiIiIiKiOWb16NebOnYuvvvoKjo6OatsHDBiAjz76CCdPnsTdu3c1HqNDhw5wcXHBsWPHlG3r1q3DokWL8PDhQ1hYWKj0T09Ph4+PD8aNG6eSCH399df417/+heXLl2P+/PkAgLlz52LPnj1ITEyESCRSO/fixYuxZMmSGh9ZSktLg6urK0xNTZVt2dnZ2Lt3L5o0aYLevXtXun96ejr279+Pl19+GW3btgUASKVS7N27F5aWlhg8eHCl5z5w4ACCgoLQrl07ncVUHqfhEREREVG9FxsbC3t7e8ycOVNjMvI8RUVFuHLlCpYsWaLSvmXLFgwaNEgtUQIANzc3jBkzBjt27MBnn30GFxcXnDp1CrNmzcLQoUOViRIAjBgxAqtXr0ZUVFSVvuzrm4eHh1qbvb09HB0dkZWV9dz979y5A5FIhICAAGWbWCxG8+bNER0djby8PNjY2Gjc99atWwAAPz8/ncZUHqfhEREREVG9d+XKFbRr165aidLkyZNhaWkJmUyGBQsWQCQSoXPnzkhMTERsbCz69u1b4b4ffvghCgsLERoaiuTkZIwYMQItWrTA1q1bVfp16NABTk5O+Omnn6ocX0XkcjmKioq0elVlMpogCCgsLNSYID7r8ePHsLe3h5mZmUq7m5ubcntFsd++fRvu7u6wtbXVaUzlcWSJiIiIiOq1kpISxMXFoVu3bnj06JHadnt7e0gkkgr3HzNmDCQSCcLCwvDll1/CyckJPj4+OHPmDACgffv2Fe7bqlUr9O/fH+vXr8f+/ftRWlqK/fv3axxNad++PU6fPl2NK9QsLS0Nhw4d0qrv6NGjtUpKgLIRn/z8fHTo0OG5fQsKCmBlZaXWrmjLz8/XuF9ycjKKi4vh7++v85jKY7JERERERPXa9evXUVpaitDQUISGhqptj4uLQ7NmzSrcv3fv3jh+/Disra0xc+ZMZSGHTz/9FADQpEmTSs8/a9YshISEID09HYcPH0bTpk019vP19cWOHTu0vazncnZ2xmuvvaZVX0tLS636ZWVl4Y8//oC7u3ul75mCVCpVWVukoGiTyWQa97t16xZMTEzg6+ur85jKY7JERERERPVabGwsAGDr1q3w8vJS267N6EVsbCxatWqlUvHu8ePHEIvFFa65UVBUw/P19cWAAQMq7Ofo6IjCwsIKR2OqytzcXKU894sqKCjAkSNHYGZmhr59+2pVJl0sFmtMiBRtmhKp0tJS3Lt3Dw0bNnzutLrqxKQSX5V6ExERERHVMVeuXIFYLMbo0aPV1s5U5RiVJToV+fXXXzFnzhz4+/sjISEBv/zyC/r376+xr2LdUHXWVWkik8lQXFysVV8LC4tKE42SkhIcOXIEJSUlGDRokEop78pYWVlpnGpXUFAAABqPc/fuXUilUrXCDrqKqTwmS0RERERUr8XGxqJJkybVTpSysrKQnJyMl156SaXd2dkZUqkUubm5Gtf73LlzByNHjkS7du3w66+/olmzZli7dm2FyVJmZiasrKy0nhL3PA8fPtTJmiWpVIqjR48iOzsbr7/+usbS6xVxdnbGgwcPUFJSovL+p6enK7c/69atW5BIJGjcuHGFx32RmMpjskRERERE9VpsbCyCg4NfaH8AaNOmjUp7ixYtAACJiYlq2/Ly8jB48GBIJBJERkbC3t4e06dPx5IlS3Djxg2VUtoKiYmJGturSxdrluRyOY4fP46HDx9iwIABcHd319hPKpUiLy8PFhYWKlPnfH19ERsbixs3biifsySTyRAXFwc3Nze1KYyFhYVISUmBn58fxGLNqYy2MWmDyRIRERER1VtpaWlIT09XJjbVceXKFQDqyVLnzp0BABcvXlTZJggCxo4di7i4OERFRSnXDU2fPh2rVq3CunXrVB5Sq3Dp0iWMGTOm2nE+Sxdrls6dO4d79+7B29sbxcXFSEhIUNmuWO+Vnp6OQ4cOoX379ujYsaNyu5ubG3x9fXHhwgUUFhbC3t4e8fHxyM3NRY8ePdTOd/v2bQiCUOkUPG1j0gaTJSIiIiKqtxSJTkZGBnbu3Km2vW3btmrT654VGxsLLy8vODk5qbT7+vqidevW+PXXXzFp0iRl++LFi7F//36EhYWha9euynZXV1e8/fbb2LFjB1asWKEyBS0mJgZPnjzB4MGDq3Wd+qJ4DlJSUhKSkpLUtmuTmPTs2RM2NjZISEhASUkJnJycEBISAk9PT7W+t27dgqWlpcZCHLqMSYHJEhERERHVW4opdFu2bMGWLVvUtm/fvl2rZOnZUSWFSZMmYeHChSgsLISlpSUiIyOxbNkyvPvuu5g2bZpa/w8//BCbNm1CaGgo5s+fr2yPiIiAt7c3evfuXZXL07uBAwdq1a9BgwYarxcoq4gXHBys1VTIIUOG6CwmbYiEqjyOl4iIiIionpowYQJOnDiBS5cuQSwWw8HB4bn7ZGdnw9fXF6tXr8bkyZOrdd7i4mI0btwY8+bNw/vvv6+yraioCHl5eVi9ejXWrFmDjIwMuLi4VOs8pK5qhcaJiIiIiOqx5ORkuLq6olu3blr1t7e3x8cff4w1a9ZALpdX65xbtmyBRCLBu+++q7YtNDQUrq6uWLNmTbWOTZXjyBIRERERkRauX7+OBw8eAABsbGxeqIKeriQnJyMuLk75c48ePSCRSAwYUd3CZImIiIiIiEgDTsMjIiIiIiLSgMkSERERERGRBkyWiIiIiIiINGCyREREREREpAGTJSIiIiIiIg2YLBEREREREWnAZImIiIiIiEgDJktEREREREQaMFkiIiIiIiLS4P8BfLcdJZqFJMIAAAAASUVORK5CYII="
      },
      "metadata": {},
      "output_type": "display_data"
@@ -332,7 +344,7 @@
       "text/plain": [
        "<Figure size 800x650 with 3 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -342,7 +354,7 @@
       "text/plain": [
        "<Figure size 800x650 with 3 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -364,20 +376,22 @@
    "cell_type": "markdown",
    "source": [
     "### Network Plot\n",
-    "The network plot visualizes all first- and second-order interactions of computed Shapley Interactions. While the `network` plot **does not plot higher-order interactions** it does plot all second order interactions."
+    "The network plot visualizes all first- and second-order interactions of computed Shapley Interactions. While the `network` plot **does not plot higher-order interactions** it does plot all second order interactions. Similar to the color scheme of `shap`, positive interactions are shown in red, negative interactions in blue. The strength of an interaction is encoded in the width of the edge connecting the two features. The strength of a first-order interaction is encoded in the size of the node for the respective feature. For clarity, second-order interactions are also plotted with a decreasing opacity depending on the strength of the interaction.\n",
+    "\n",
+    "The following code will plot the network plots for the 2-SII and Moebius transforms. Note that for the Möbius transform, the network plot will only show the first- and second-order interactions (not the higher-order interactions)."
    ]
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:47:59.843694Z",
-     "start_time": "2024-10-23T14:47:59.560132Z"
+     "end_time": "2024-10-24T12:25:28.556951Z",
+     "start_time": "2024-10-24T12:25:28.368699Z"
     }
    },
    "cell_type": "code",
    "source": [
-    "si.plot_network(feature_names=feature_names, show=True)\n",
-    "mi.plot_network(feature_names=feature_names, show=True)"
+    "si.plot_network(feature_names=feature_names, show=True, draw_legend=False)\n",
+    "mi.plot_network(feature_names=feature_names, show=True, draw_legend=False)"
    ],
    "outputs": [
     {
@@ -385,7 +399,7 @@
       "text/plain": [
        "<Figure size 600x600 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAHmCAYAAAD0hm11AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5fUlEQVR4nO3dd5wU9f0/8Ndsvc5x3HEccLSjS1dQiiJFsf40fi3RGEFN/GpijCZY8jUmJrZ8E02MMaYYpETz1UQiGiVRQUCaKCgoSu/l4Gh3x5Wt8/n9MbfL7t2Wmd3Z3Znd1/Px4AF3t2XY25197Xs+73lLQggBIiIiIpUsmd4AIiIiMheGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIiItKE4YGIiIg0YXggIiIiTRgeiIiISBOGByIKs3z5ckiShPr6+kxvChEZFMMDkcnMmjULkiThzjvv7PCz7373u5AkCbNmzdLt/hgmiKg9hgciE6qursarr76K1tbW4PdcLhf+9re/oVevXhncMiLKBQwPRCY0ZswYVFdX45///Gfwe//85z/Rq1cvjB49Ovg9WZbx1FNPoW/fvsjPz8fIkSPx+uuvh93W4sWLMXDgQOTn52PKlCnYu3dvzPueN28eSktL8e6772LIkCEoKirCJZdcgtra2rDLvfTSSzjrrLPgdDpRVVWFu+++O/n/OBEZAsMDkUnddtttmDt3bvDrl156CbfeemvYZZ566iksWLAAf/zjH/Hll1/ivvvuw80334wVK1YAAA4cOIBrrrkGV155JTZu3IhvfetbeOihh+Led0tLC55++mn89a9/xYcffoj9+/dj9uzZwZ//4Q9/wHe/+13ccccd+OKLL/DWW2+hf//+Ov3PiSjjBBGZysyZM8VVV10l6urqhNPpFHv37hV79+4VeXl54tixY+Kqq64SM2fOFC6XSxQUFIg1a9aEXf/2228XN954oxBCiB/96Edi6NChYT9/8MEHBQBx6tQpIYQQy5YtC/t67ty5AoDYuXNn8Dq///3vRWVlZfDr7t27i4cffjgF/3siMgJbhrMLESWooqICl19+OebNmwchBC6//HKUl5cHf75z5060tLTgoosuCruex+MJHtrYsmULzj333LCfjx8/Pu59FxQUoKamJvh1VVUV6urqAAB1dXU4fPgwpk2blvD/jYiMjeGByMRuu+224FqC3//+92E/a2pqAgC888476NGjR9jPnE5nUvdrt9vDvpYkCUIIAEB+fn5St01ExsfwQGRil1xyCTweDyRJwowZM8J+NnToUDidTuzfvx+TJ0+OeP0hQ4bgrbfeCvveRx99lNQ2FRcXo0+fPli6dCmmTJmS1G0RkTExPBCZmNVqxZYtW4L/DlVcXIzZs2fjvvvugyzLmDRpEhoaGrB69WqUlJRg5syZuPPOO/HMM8/g/vvvx7e+9S1s2LAB8+bNS3q7Hn30Udx5553o2rUrLr30Upw+fRqrV6/G9773vaRvm4gyj+GByORKSkqi/uyxxx5DRUUFnnrqKezevRulpaUYM2YM/ud//gcA0KtXLyxcuBD33Xcffve732HcuHF48skncdtttyW1TTNnzoTL5cJvfvMbzJ49G+Xl5bj22muTuk0iMg5JBA5UEhEREanA8zwQERGRJgwPREREpAnDAxEREWnC8EBERESaMDwQERGRJgwPREREpAnDAxEREWnC8EBERESaMDwQERGRJgwPREREpAlnWxDluM8Oe7Dg02as2OOG2yfQtciCG0YU4PrhBSgrsMa/ASLKOZxtQZSj/LLAj99rwN82tcBqAfzymZ9ZJCDPJuHFa8owqY8zcxtJRIbEwxZEOerJ5Y3426YWAOHBAQBkAbT6BG57/QQ2H/VmYOuIyMgYHohyUG2jHy+tb455GSEAnww8u6oxTVtFRGbB8ECUg179PHZwCPALYMlON2ob/SneIiIyE4YHohz0ea0XssrVTgLAl3U8dEFEZzA8EOUgv8Zl0n61SYOIcgLDA1GO8csCvUqtsErqr1PuaYXLxwBBRAqGB6Ic4fELnHbLaHDJuGpIvqrqgwUCwwu86HHgEOoPnEJdkx9NbhkyO7yJchrDA1EWk4WAyytQ3yqjyS3D6xewSBKGdbNjYm8HpDjVBxkS7qxsgSQAbD0E+VgDmjwCx5qUEOLRevyDiLICzzBJlIW8fgG3T4S9udutEpw2CQ6rBJ8sMGtMIeqa/Nhxwg8JysLIACsEZABP9GrCFWUeCAG0ykDLtoPwARDlndDqFWj1CtgsQIFdQr5dghQvjRBRVuAZJomyhBACbj/g9ongAkeLJMFhBZw2CVaL8sbukwVqG/3YeswLmwVYudeDd3e4cLBBace0SQJXlLpxW2UrRhb6OtyPRwCtg3rB1bkkLHBIAPLsEgrsEuxaFlQQkekwPBCZnE8OVBmUAAEANqsEp1UJDqHVAJ8s0OwR2HnCi1avgPKWr1yvyeWHxeXGBQMLkf/lPqCxNfqdSoB8Vi+0lnVCi1d0OEOl3QoU2i1w2sBqBFEWYnggMiEhlLDg9gv42g5NSCFVBpul4xu21y/Q4lUuv/WYFwLtLiPL6G33orpHkXJ+6k93xQ0QGNYbqCyFy6ccwnC368iQJOWQRoH9TOWDiMyP4YHIRPwhVYZAx4PVoqxlcFqjf8oPBAeLBJxq8WN/g9zhMpKQcU4nGc7SfMBiAbw+YNNeoD7G2SglAGf1Arp1Dm5fS9taiPanhnDalHUReTaGCCKzY3ggMgFP2wJIb8gCSEfbAsh46wtCg0OhHdhw2At3x6UMqMgHBuX7gaI8JTwAgM8PbNyjKUAAbesvfECLV4an3ZmtLYFqhEOChYc0iEyJ4YHIoGQh4PEBLp8IVhkskvLJ3WGDqjfe0OBQ5JBwokXG1mMRkgOA4V2t6OTzhIcHIZRDGBv3AKeaot+RBGBoNVBV1uFHvkA1wiMiLrDMtysdIERkHgwPRAYTr81Sy+2EBgdJkvDFEQ8aXB1f8gV2CWOqbECTKzw8ALoECOVmlMMZLV4BX7ujJmz3JDIXhgciA1DbZqlWpODQ4pHx6eHIA65qymyoKpKihwdJAvxy/AABAGdFDxABHr8SJFzeyNUItnsSGRtPEkWUQVraLNWKFBwAoPZ0x0WSAGC1AF2LLAg/TVSUC47qGz9AfHlAuanu0QOEw6pUUYqdZ6oRflm5WuDkU3arUo3Is7EaQWQ0rDwQpVkibZZqRQsOflng44OeDudjAICqYitqutgAWY5ceVA2GsFzWftlYNMe4GScCsTQ6pgBoj23T9l2tnsSGR8rD0RpkmibpVqB4GCVgEJH+Kf1uiY5YnAAgKpijSNurBZgZN/4AeKrA0ro6NFF1c06bcpj0b7dUwig2aOc3IrtnkTGwPBAlGLJtFmqFSs4AEDtaX/E63XKk1DgUBEeJCm8+qA2QGw5qPytMkAoNy2h2CmhyNGx3dPtUx5LtnsSZRbDA1EKyEK0vdG1qzJY1bdZqhUvODS4ZLR4Ix+drCq2Jn7HgTUQm/YCJ05Hv1wCAQJQKjF5diDPbj3T7ukVweaPppBqRIGD7Z5E6cTwQKQjvdostdxfrOAARK86OG1AlwKNhyzas1iAkX3UBQghgJ7lCd2NzSKhxCmh2CHg8imhwde2wNLlU77Hdk+i9GF4IEqS3m2WagXaHWMFB7dP4ERL5MUOlUVWbW+y7Q9dBAQCxOf7gOON0a+/9ZDyd4IBQtkEJRzk2zu2e/pkoNEtcNot2O5JlGIMD0QJSkWbpVpqggMAHG3yI1I/lSQp4UE3Fgswore6ACEAVCceIALY7kmUOQwPRBoE2ixdIVUGSZKCnQLJtFmqpTY4CCFwtCnyIYvyAguciXQsRKs+AOoDxLa2CoQOAQJQqjyFDgmFDqXS0upVDmMAgNcPNPgFGiWB/LZqRDp+R0TZjuGBSIVAm6U7pMqgZ5ulWmqDAwCcaJEjDsACgG7JLJSMJRAgvtgHHEtfgAiI1e7Z4hFoYbsnkS4YHohiSEebpZZtURscgOgLJQsdEjrlJbFQMlb1AVACxHCVAUIIoFdF4tsSBds9iVKL4YGonXS2WaqlNTg0e+SIA7CAJNsz1VIbILYfVv5OQYAAtLV75tulxA7lEOUghgeiNulus1RLa3AAgCMx5lhUFCbZnqmWxQKM6KMEiLqG6JfbflipQPTumtLNYbsnkX4YHiinZarNUq1EgoNPFqhrjnzIomuhVZ//U7xDF6GXC1QgYgWIHbXK3ykOEMomsd2TKFkMD5STMtlmqVYiwQEAjuk5x0IPWgKEANAn9QEigO2eRIlheKCcEavNMs8AVYZQgeAQKKNredNKeo6FWmqrD4HLDu8NbN4PHK2PfrmdbRWINAYIgO2eRFpl4GMIqbF3715IkoSNGzem5PYlScKiRYtScttG45cFWjwy6l0CzR4ZflnAalHeSEvzJBQ6LFkTHFI2x0IPkgQM6wVUlsa+3M5aYG9dWjYpEqdNQmm+BRWFFhQ6JASeGoF2z+PNMk61ysFwQZSLGB6imDVrFq6++uqM3X91dTVqa2sxbNgwAMDy5cshSRLq6+sztk1m4/ELnHbLaHApO3ohRFuJ2oJOeRZDlqEDn3oTCQ5AiudY6CEQILqVxr7czlpgz9G0bFI0SrunEiJK8yxwhGQvt0+gvlVGXZMfTW45WMkyk2j7OKPua1pbW1FWVoby8nK43e5Mb07O42ELg7JarejWrVumN8N0jNhmqZa73Yp/rcFB1zkWamk5dBF6nbN6Kf8+Uh/9cruOKLfdL7OvAzXtnk0egTy2e6bUwoULcdZZZ0EIgUWLFuGGG27I9CblNAN8FDGfFStWYNy4cXA6naiqqsJDDz0En+/MqfwuvPBC3HPPPXjggQdQVlaGbt264dFHHw27ja1bt2LSpEnIy8vD0KFDsWTJkrBDCaGHLfbu3YspU6YAADp37gxJkjBr1iwAQJ8+ffDss8+G3faoUaPC7m/Hjh244IILgvf1/vvvd/g/HThwANdffz1KS0tRVlaGq666Cnv37k32oUobr1+gyS2jvlVuO6uggN0qoShQZbAb+0RAyQYHII1zLPQQCBDxKhC7jwK7j6Rlk9RQ2j0t6FpoQac8CfaQh9XlEzjVKuNYsx8tHjkYXs0u8KbtdDrRp08fPPPMM2E/j3QItLS0FPPmzQMAeDwe3H333aiqqkJeXh569+6Np556KnjZ+vp6fOtb30JFRQVKSkowdepUbNq0qcN2zJkzBzfffDNuvvlmzJkzp8PP4+1TAfPv54yE4UGjQ4cO4bLLLsPYsWOxadMm/OEPf8CcOXPw+OOPh11u/vz5KCwsxLp16/DLX/4SP//5z4Nv2n6/H1dffTUKCgqwbt06/PnPf8bDDz8c9T6rq6uxcOFCAMC2bdtQW1uL3/72t6q2V5ZlXHPNNXA4HFi3bh3++Mc/4sEHHwy7jNfrxYwZM1BcXIyVK1di9erVKCoqwiWXXAKPx6Pl4UkrIZQWuwaXjNNuGR6/gKWtDa8034JipyWj52dQS4/gIITAkSiHLBKeY6FWoPqQyPXO6gVUdY59OYMFCCDQ7mlBlwIrygosynkh2n7mb2v3PNakHDILPTup2WzYsAHXX389vv71r+OLL77Ao48+ikceeSQYDNR47rnn8NZbb+Hvf/87tm3bhldeeQV9+vQJ/vy6665DXV0d/v3vf2PDhg0YM2YMpk2bhpMnTwYvs2vXLqxduxbXX389rr/+eqxcuRL79u0L/lzNPtWs+zmj4mELjV544QVUV1fj+eefhyRJGDx4MA4fPowHH3wQP/nJT2CxKHlsxIgR+OlPfwoAGDBgAJ5//nksXboUF110Ed5//33s2rULy5cvDx6aeOKJJ3DRRRdFvE+r1YqysjIAQNeuXVFaWqp6e5csWYKtW7fi3XffRffu3QEATz75JC699NLgZV577TXIsoy//OUvwTeuuXPnorS0FMuXL8fFF1+s7UFKsVhtlmYrGYcGh8IkOiGOt5w5/XJ7KZtjoQdJAoZWK/+uPRX9cruPKv2TNcY7lGfmds+3334bRUVFYd/z+888kX79619j2rRpeOSRRwAAAwcOxFdffYVf/epXwepnPPv378eAAQMwadIkSJKE3r17B3+2atUqfPzxx6irq4PT6QQAPP3001i0aBFef/113HHHHQCAl156CZdeeik6d1aC5owZMzB37txghVXNPtVs+zmjY+VBoy1btmD8+PFhO4CJEyeiqakJBw8eDH5vxIgRYderqqpCXZ2ygnzbtm2orq4OW9Mwbty4lG1vdXV1MDgAwPjx48Mus2nTJuzcuRPFxcUoKipCUVERysrK4HK5sGvXrpRsl1aibS1Dg0tGo0uGu22lu9OmzGkocab403UK6BUcAEStOiQ9x0KtRKsPgesOrQa6l8W+3J6jyjoIg1LaPS2oKLSic74lbPCW1w80uATqmmU0umX4DLLAcsqUKdi4cWPYn7/85S/Bn2/ZsgUTJ04Mu87EiROxY8eOsJARy6xZs7Bx40YMGjQI99xzD957773gzzZt2oSmpiZ06dIluO8pKirCnj17gvsev9+P+fPn4+abbw5e7+abb8a8efMgy8oaHzX7VDPs58yElYcUsdvtYV9LkhR8ouvJYrEEP30HeL1eTbfR1NSEs88+G6+88kqHn1VUpGbmgFpGmWapNz2DQ8bnWOhBkoAhPZV/Hz4Z/XKBDgwDViBChU73DFQjjDjds7CwEP379w/7XuiHIDUkSYq5DxozZgz27NmDf//731iyZAmuv/56TJ8+Ha+//jqamppQVVWF5cuXd7jdQIX13XffxaFDhzoskPT7/cFqrhpG3s+ZEcODRkOGDMHChQshhAi+ca1evRrFxcXo2bOnqtsYNGgQDhw4gKNHj6KyshIA8Mknn8S8jsPhAIAOab+iogK1tbXBrxsbG7Fnz56w7T1w4ABqa2tRVVUFAPjoo4/CbmPMmDF47bXX0LVrV5SUlKj6P6Sax6+8ufraTbPMy4IT9OgZHIDocyxs6ZxjoYdAgJAAHIoTIIQA+lelbdMSZbVIKHJKKFQx3TPfbqwTlQHK/mP16tVh31u9ejUGDhwIq1UJpu33QTt27EBLS0vYdUpKSnDDDTfghhtuwLXXXotLLrkEJ0+exJgxY3DkyBHYbLawdRCh5syZg69//esd1jA88cQTmDNnDi666CJV+1Qj7ufMzER7lvRraGjoUNK74447cODAAXzve9/D1q1b8eabb+KnP/0pfvCDHwTXO8Rz0UUXoaamBjNnzsTnn3+O1atX48c//jGA6J+ke/fuDUmS8Pbbb+PYsWNoamoCAEydOhV//etfsXLlSnzxxReYOXNm8EUNANOnT8fAgQMxc+ZMbNq0CStXruzwIvzGN76B8vJyXHXVVVi5ciX27NmD5cuX45577tH8KSQZshBo9SodE01uGT5/28mc7BaU5ltQ5LQwOLQTc45FkU5zLNRK5tBF6G0M7gn0iHMIY2/dmbNRmoDS7imhrMCK8kILChxSsLs10O55rFl57rsNdPKpH/7wh1i6dCkee+wxbN++HfPnz8fzzz+P2bNnBy8zdepUPP/88/jss8+wfv163HnnnWGV11//+tf4v//7P2zduhXbt2/HP/7xD3Tr1g2lpaWYPn06xo8fj6uvvhrvvfce9u7dizVr1uDhhx/G+vXrcezYMfzrX//CzJkzMWzYsLA/t9xyCxYtWoSTJ0+q2qcaZT+XLRgeYli+fDlGjx4d9uexxx7D4sWL8fHHH2PkyJG48847cfvttwefqGpYrVYsWrQITU1NGDt2LL71rW8F39Dz8vIiXqdHjx742c9+hoceegiVlZW4++67AQA/+tGPMHnyZFxxxRW4/PLLcfXVV6OmpiZ4PYvFgjfeeAOtra0YN24cvvWtb+GJJ54Iu+2CggJ8+OGH6NWrF6655hoMGTIEt99+O1wuV1oSutnbLNVy6RwcgNhzLLoVmfTlrSVA7Dicnm3Skdp2z2YDtHuOGTMGf//73/Hqq69i2LBh+MlPfoKf//znYYsln3nmGVRXV+P888/HTTfdhNmzZ6OgoCD48+LiYvzyl7/EOeecg7Fjx2Lv3r1YvHgxLBYLJEnC4sWLccEFF+DWW2/FwIED8fWvfx379u1DZWUlFixYgMLCQkybNq3Dtk2bNg35+fl4+eWXVe1TM72fyzaSaH+wijJi9erVmDRpEnbu3Bn25p+tlAWQgNsfPs3SaVOOF2dDWAjlaitR2y3Qdb7Ep4c8EU9H3SlPwvBuDm03JstAkwsoylPGaSdK60mjYt3OtkPAwROxL9e7AhjQPfZlDM7rV9ZFBKZ7BkgAp3smKNf2qenG8JAhb7zxBoqKijBgwADs3LkT3//+99G5c2esWrUq05uWUtnUZqlWqoJDg0vGF0ciL44dXGFDeaHGxZJGCw+B28qRAAEEDt2dafcMZdR2T6PI1X1qpnDBZIacPn0aDz74IPbv34/y8nJMnz69w5nbsoWZplnqLVXBATDBHAs9BA5hSBJw4Hj0y+07pvxt8gDB6Z6Jy6V9qhGw8kApk61tlmqlMji4fQLrD3kirk/sVWpFr9IEPhfoVXkA9K0+BGw7FDtAAECvcmBgD33vN8Pat3uGcliV51Ym2z0pN7HyQLpr32YpSVLWtFmqlcrgAMSeY2HoM0omY1BbKIgVIPa3/SyLAkSg3bPIqTyvWjxn2j09fsDTKhu63ZOyE8MD6cLM0yz1lurgIMeZY2GIeR6JTNtUY1APZRXh/jgBQuBM2MgieTYJeTZO96TMY3igpHj9gQWQZz4G29sWPxriTSzNUh0cAOCEWedY6CVQVYgVIALViSwMEECg3VNCsUOp8rV4Bbxtz4lAS7DVcqYakUvhndKD4YE0y7U2S7XSERwAA8yxUCtV1QdACRCSdGahZCRZHiCAwHRPCfn2ju2efhk47RZocgu2e5LuGB5ItVxss1QrXcEhK+ZY6CXQWREvQAjRdrgju5+jdquETiad7knmw/BAMQmhdEu427VZ5rUN/uHiLMDlFXD7Ux8cgOjtmaabY6EXNQEicI6IHAgQANs9KT0YHnLEoUYf/rPNhUa3jPJCKy4flIeyguifVHO9zVKtdAYHn6zMP4gk7XMs1ErloYsAtQFCiDPnjMgRaqZ7OqxAgV05DXxcqf5dkmnwPA9ZrtEt48F/1+Pf21yQJMAiKcdCrRbgplEFeGRqp7CFjZHaLO0W5FSbpVqB4OCwAvn21H/qr230Y9dJX8SfjeluTz686Hmeh1DpesPZcTh2gACUeRk5FiDaa9/uGRC13XPtVuD5d4D3PlN6Q4f2BO6YAdx8IWDn589cxfCQxVq9Mq595QS21Hnhj3ROAAAXD8jDC1eXwutHxDZLp41VhkjSHRyA6HMsSvMtGFZpj3ANjVIVHoD0BYidtcrArFgYIACgQ7tnqEC7p23BUlju+wskqwXwtVW9JAmAAKaNBF69H3AwQOSiHDxImgP+vgpYvB4vf1SPL49GDg6AspDq3R0u/GuLK2yaZXHINEsGh44yERwaXHLE4AAAVcV8GQf1rwL6Vsa+zKGTwJaDyY8PN7m40z0/3QfLfXMgCZwJDoDyuAkAH3wO/ObNdG82GQT3OtmmoQV4fyPE62swb8UJALF3kFYJ+PvnLci3SyjNt6DYaWE7VwyZCA5A7DkWZfl8GYep6RY/QBxmgAhQ2j0t6FJgRZcCC/LtyhqJ5hfehYj14UEWwJ/eBbyRD6VRdmO9Kdus+grwy2i02HHQXhj34n4BfHHUi/xAqyV3plGdCQ6S8nil6bFy+wRONEcOD5WFVkiAPtsiRPgfvcly+g4V9KtU/g97jka/zKETyjYNrc75QxgBdgtQaAc+OeDBOeu3wiJHXqAbdLxROUxk8oFkpB0/smQTvwws+yLTW5GVwoKDmlXpOjra5I9YP5KQI2eUTFRNNyVExFJ7CvjqAENzG58ssGKPG8eaBfMUxcTKQzbZtAc4eRoAUCJ70cPbjEO2gpifqqySwKhuDn7yisHlFXDLgMMmpfVQBdA2x6JJhhIVwpUXWuCw6bg9khT+R2/paNtsr6ZKub/dMSoQR+qVv8/qldOvAyU4eFDXpFQb6kYOQvHBo7D4Y1QfuhQDfbqmaQvJSFh5yCYffB78pwRg1qmdEd5ywvmFhFu+WAf8ewPQ4k7p5plRq1fOyBqHgJyfY6GHfioqEEfqgS/352wFwusXWLHbjbrTPsDnB3x+7Lj6QkgxgoOwSErLJts1cxLDQ7Y40lZ+DXFz/W4McTfAKiLvACQhcNHpQ5heuwtYuBZwedOxpabR6lXeuDMVHAATzbFQS0rfWpEw/bophzFiydEA4fXJWLGjBXWnPMoiSKsFsFnR0L8a639wMwBAtp55rglJWYbtv2AY8MOrM7PRlHEm3PtQRB90XOtQIPx49cAKTG+qhSQELEKGTfZDEgJWIeMb9bvxwuGPlCfB6H5AWVHaN9uojBAcOMdCZ30r1QWIzTkSIPwyvC0erNjWrJy51G5VgkPIoZudV0/BkucewOHzhgcDxOneVWj5xa2wLXyQ53jIYfzNZwO3F1izJeKPOsle/PnwWux3WfCfzr3QYHWgq68Vl3uOolz2nLngtBFp2ljjCwQHp1VSd8reFOEcixToW6m8Oe6sjX6Zo/XK38OycA2EEMrCap8fXhlYfsCH414LECOLHhs5EMdGDQKEgNMCTB1YgAJn2+lqKWcxPGSDj7bFXa/Qy9OEO458pXwhASgpOLN4rXtZVo8t1sIowcGUcyzUysTCyVCBBX65FCBkWTnRk18GbBZ4bDas2OPB8Vb1FRan3YJp/fPQKc8CvywghOBJ5HIYw4PZCZF8e+aU4dmxg0ySUYIDANQ1yYi2Vo1nlNRBn65KiN4RJ0AIAQzvbd7XR9viRwDKwkaHDZ62xZHHo5w7JBKnXcK0mrzgOhurRTmRFM8nl7u4FzK7nbXA/jjDgGJx2oEJQ/TbHpMyUnAAoi+ULM23ZGwNhq4ytXAyVO+uwICq2JepawC+2Jf5bdVClgGPD2htWwDpsAF5DsBqgccvsHy3S31wEAJOhyUsOBABDA/mF9KeqZkkAecNAvId+m2PCRktONS3co5F2vTuCgyMc3bEQICId7bFTPPLyvonj09Zj5DvUIJD25CzQHA4EeVwWCTtKw6hlAm9JgpVpCvuicysoQVYvzO525g6XJ9tMSmjBQcAONLEORZp1avCvAFCCGW2RKtHCQ92q1JlsIWvgPT4BZbt0hYc8mzAtP75USsOkiTFmZxD2Yx7IjNb+SWiHhhXY2APoLrCXCVZHRkxOLh9AidaIv9OuxVbs2uBmhEOXQSoCRDHGo0TIAJVhsC5WfLsYVWGUG6fEhxORnleRZJnl4KLI2OxSMpZUCn3MDyYlR5zLKa2tWfm4Iu/xWO84AC0zbGI8OuQJKCyiOd2SKleFfG7jo41Ap9nKEAIoSx+dHmUv21W5dCE3RZ1QafbJ7BsdwLBocaJkrz4zzeLJIFHLnITw4NZbdwDnGpK/PqdCoEx/ZR/G+kTYBq0eGR4ZeMFB1mIqAslywsscGTj0najPfeqy+MHiONpDhCBBZAur/JYOe3KH2vs3XcgOJxKoOJQ4lT/1iABEEb6HVJaMDyY1bIkFkoCwOSzzhwXNdoOPIWCwcFmrOAAcI6FYVSXA4MNECACVQaPTwkKcaoModw+gQ92aQsO+Q7twQEIHLrQdBXKAgwPZhRhjoUmFgtwwbDw72XTsfQowoKDzXj/36ybY6GWEcNrT5UBYtNefQNEjDZLtVxtwaG+VWNwqGkLDhpP4MWFk7kpi/dIWSzCHAtNhvbsOMdCkoyxECxFjB4cOMfCgHqWA0N6xr7MidP6BIg4bZZqudoWRyYSHIo1VhxCceFk7mF4MBuXB1j9VXK3ce6gyN/P0uqD0YMDwDkWhtWji7oAsXGP9s4nlW2WaiVScShwSJgeGhwSPG04F07mHu6VzGbddmVnk6iunZThQJEYsXycJDMEh6yeY6GWkZ97agLEySZgk8oAEagyuOO3WaoVCA4NGoPDtJo8FCVRcQjFhZO5heHBTIRI7oySADBuQOxPFln04jdDcAA4x8IUenQBhlbHvkysABGpzTJP/QLIWFxegaU7MxscAGXeBasPuYN7JjPZWQscOJ749Z12YFS/2Jcx8idADcwSHIDohyyyZo6FWkZ/7nUvUxcgQg9hJNhmqZbLK7B0lwuNLvXBobBtVkWH4JDJSadkOjm0Z8oCyVYdRvZRSqSxGH0HroKZgkN9q4xWzrEwj+5lwFlxAsSpJmDDTqDZBXj9mtss1Uo4OPR36lpxCMV5F7mDeyez0GOOxbkD1V3OxJ8+zBQcgOhVh5ydY2GG515VlAAhCyUsuL3AiSalndpm1a3KEKrVKyccHAodEbZHp6oD2zZzRw7unUzqw83JzbHoWwlUlqq7rEmrD80mCw4un8DJKMeps26OhRZmeO4FAoQE5XXp9SlrGSyScljCblUCfyJdGHG0emV8sMutOThMjxYcdMa2zdzA8GAGfhlYvjm52xinsuoQYLIXf7NHhk8G8kwSHADg6GnOsTAtIYDyEqCmm/Jvq1XpmGhfZTjVBHy2W7cA0eqVsXSntuBQ5FSCQ0G04KDzWge2beYGhgcz0GOOxVm9tF3HRNWH0ODgNElwkIXA0SijtyuydY6FWkZ+7rVvs+zdFRjVF4j1+6pvVgKEL8q5x1UKBIfTbm3BYVpNjOCQImzbzH4MD2aQ7ByLC4dpP+5q5B14CDMGByDOHIsSVh0MJXAyp2htlt06K+E81tMvyQDR4tEeHIozFBwAzrvIBQwPRld7Uoc5Fmcldl2DH3M3a3AAYs+x0DqYKCsZIbyGtlkCsdssu3UGhvWOHSAaWhIKEC0eZY2D5uAQ61BFQIraM7lwMvtxL2V0yc6xGNMP6FwU/3KRGHjehZmDA+dYGFzgZE5a2ywrS3UPEC0eGUsTDA6ZPkcIF05mN4YHI3N5gDVbkruNqSOSu77Bqg9CCFMHB4BzLAwp0jTLRE7mVFkKDNcnQASCQ5OG4FCSpyE4pPikUFw4md24pzKyj7YlN8eiexkwKM5Y4XiMUD5uI4RAi1eYOjhwjoUG6Xju6TTNMkzXUnUB4tPoAaLZI2PJTu3BYWpN5isOobhwMnsZ51lG4fSYYzFluD6fLAzw4s+G4ABwjoUh6DzNMiI1AaIxcoBoblsc2ezRWHGoyTNUcAA47yKbGeuZRmfsOAwcPJH49fMcwIQh+mxLhqsP2RIcAM6x0EzP515om6Uk6TLNMqaupcCIPpoCRJM78eCQZ9fwuuAcC0oS91ZGlexCyQmDlRKsHjIYHrIpOHCORQZEa7O0WdPz5lnRSV2A2LALTc0eLN3lSn1wSDPOu8hO3GMZUX2zMlgnGVOG67MtARn4lBIaHPLt5g4OAOdYJCyR556WNstUq+gEjOwbM0A01buwdOlBtLSqb+PslG/BtP4JBIc0Vx3YtpmduMcyopVfJnc620E9gB5d9NseIO3VB6Wr4kxwMPsZFznHIklqn3uJtlmmWnmJEiAiLIht8ktY2uBAS7MX2H9M1Wu/U74FU2vyTHMqdrZtZh+GB6PRY45Fsu2Z0aTpxR8IDn6RHcEBiD7HwsI5FsnTq80y1cpLlEMYIQHitF/CkgYHWvxt33PFDxClyQSHDK11YNtm9jHYq4uSnmNRWgSMqdFve0KlofqQjcEh1hyL8lyfY6FWpOeeX1aqDHq2WaZaeQkwsg9gkXC6reLQ6m/3+48RIErzLZhioopDKLZtZhcDv8pyVLLtmZPPSt0nrhSHh2wMDgBwvJlzLHTTvs3SYdO/zTLVupTg9JDeWNro7BgcAiIECDMHB4DzLrINw4ORHD4JbElijoU1iTkWaqWo5JmtwQFA1KpDEedYqOcPLID0pKfNMoUa3TKWnLSjtXt57D1wSIDoXKDDGocMt2dy4WR2Md8rL5stS7I9c3QScyzUSsG8i2wODpxjkYTQKkMm2ixToNEtY+lOF1xeARTmAT3jB4jOtXWY0tNm+m4jgAsnswnDg1HoMcdi2kh9tiUeHXfc2RwcgNhzLMo5xyKy9m2WeRlss9RRWHAIiBMgyuwypjia4Px8t/KYJMogJ4XiwsnsYe5XYzZZm+Qcix5dgIHd9dueWHRa+5DtwYFzLDRS02ZpoFkrWjS4IgSHgGCACH8+lNllTCnxwGkB0OQCPt2VXIAwCC6czA4MD0YgBLDMIHMs1EryxZ/twQHgHAtVzNJmmYQGl4wPdkUJDgGFeUD1mQARCA6O0IehyaWcPM7tTe0GpxjnXWSH7HmFmpkucywG67c9aiTxCTA0OBRkaXAQQnCORSzJtFmaqPrQ4JKxNF5wCChwAtXl6OIUHYNDQLNbqUBoCRAGOWRB2SXH92AGkewci4mDlQCRTgnuwNsHB3sWBgcAaHCJqHMsuudq1SEb2iw1CAQHt5rg0Ka8ogAXnt8DjljhMpEAYTCcd2F+OboXMxA95lhcqPMcC7U0fprJleAAxJ5j0TnX5likYpqlwT9JB9Y4aAoOhVZM7ueEo6IYGNU39qEbtQHCoFUHtm2aX47txQwo2TkWg3vqP8dCLQ3Vh1wKDpxjgfS0WRr00EUwOPi0BYcL+znPHMLrXKRfgDAotm2aG8NDJukxx0Lv6ZlaqXjxCyHQlCPBAcjxORZZ2mapVn2r9uBQUaQEhw6vC7UBYsNOZf1IewatOgSwbdPccuMVbVSf7TbuHAu14lQfAsFBzpHgkJNzLITIzDRLgy2cPNWqdFVoDQ6T+0YIDgGdi5STv8UKEC0epQIRKUAYHNs2zYvhIZOMPMdCrRg78FwLDkCOzbEIrTLIQqkw5FCVIdSpVhnLNAaHrvGCQ0BpoRIgbNkXIDjvwrxy71VuFIdPAlsPJn59qwWYPEy/7UlGhE+XuRgcAOBIlIWSWTXHIlqbZSZK5AaoPiRScehapCyOVP26KC0ERqkIEBvaAoTBD1kEcOGkeWXJ3syEkj0p1JgaZYdiBO3mXeRqcGhyy2h0Z+kcixxrs1TrZIsfH+xywaMlOBQrwcGm9QyjagJEa1uASOZstWnGhZPmxPCQCS4PsHprcrcxdYQ+26KXtk85uRocgCydY5GKNssscbLFj2W73dqDQ98EgkNAaSEwuiZOBcKtrKcySYDgwklz4h4gE9ZuS+7YZDrnWKglSRCynLPBIdYci0qzzbEw2zTLDBy6UCoO2oJDZbLBIaBTQfwA0dq2BsIkAYILJ82H4SHd9JhjMXWE4XbiQgg0ueWcDA6AMsci2qenbmY5o6QsK6EhR9ss1TrRFhy8fm3B4QI9gkNApwLl0GWWBAjOuzAf7hXSTY85FuMH6bc9OggeqoCEQjtyLjiYeo5F+zZLS5raLPWWpurDiRY/lmU6OASURAgQ7RdKtnqU80CYIECQuRh4r5alliZZdcjEHIsY5JA1DoVOC2wmer/RiynnWLDNUrPjzdqDQ7dUBYeAQICwx1i46vKaIkBw3oW5cE+RTvXNShkxGVOMs1BSbjvltCyAQoek7CDN9GlVJ6aaYxGoMhihzVJvKfw/HG/2Y/lubcGhqiTFwSGgpODMeSCiPQaBANHiTu22JIFtm+ZisD1blvtQhzkW3cv0254kRAwOgCH67tPJFHMsQhdAyiK72yxT8Nw71qx0VWgNDuf3caZvoazaCsSnuwwdINi2aR4MD+mSDXMs2kQNDgE59OI39BwLtlkm7VhbxcGnITh0T3dwAJTXXBYECLZtmgf3Iuny6S6g3uRzLKAiOAA5U30w5BwLs7VZ6k3H516iwWFSuoNDqOJ89Wsgml3p2y4N2LZpDgwP6bLsi+Suf+GwjC9mUxUcgJwJD4aaY5Hj0yz1VtekLI40VXAICAQIhy36Zdw+5QONAQME512YA/cs6aDHHIsLztJvexIQ1lURKzgE5MCn3IzPscjUNEujSzK81jUpFQctK/97dLLi/L4ZCg6R5liYOEBw4aQ5MDykg8nnWASCg1AbHIAO8y6yTUbnWIRWGQTbLPV0NIHg0LOTUnGwGC2wFeWZNkBw4aTxcW+TanrMsZiWufbMhIJDgNF2pjrKyByLSG2WuV5l0NHRJj9WJBAcJmYyOMSbnqk2QGzYBTQZJ0Bw4aTxMTykWrJzLHp2AQZkZo5FUsEByNq1D2mdY5FLbZZ60vjcO3pae3CoLrVlNjiopSZAeNoqEAYKEFw4aWwMD6kkBPBBkocspmRmjkXSwSEgC1/8R5v8qZ9jwTbLtDl62o8Ve7QHhwm9HcYPDgFFecDZ5goQnHdhbNwTpdL2w8Ah882x0C04AFlXfRBCoLYxctWhc7JzLHK9zVJvKp57R077sdyswSHeIYv2CtsChNM8AYKMi+EhlZZuSu76GZhjERocipINDkDWhYcGl4AryhjmqkSrDnJblYFtlml1pK3iIJsxOCSqsO0QhpoAcbo1fdsVBeddGBf3Tqlyqgn4bHdyt5HmORbtg4Nux+7NuqON4LBecyzat1narFwAmQpRHsvaRu3BoVdnAwUHrVWHUCYKEGzbNC6Gh1Qx2RyLlAUHIGuqDy6fwKlk51iwzTL92j33ahv9+HCv9uAwvpdBgoMeCvOAs/srVa5ovH5DBAi2bRoT91ipoMcci6npqzqkNDgEZMGLP6k5FmyzNITDCQSH3kYLDslUHUIVOJUKhMEDBNs2jYnhIRU+3QU0NCd+/c5FyojdNEhLcABMX32QhcARrXMs2GZpDG3PvcONfny4x2Xu4KA3LQGisSV929UO2zaNh+EhFUwyxyJtwQEwfXg43izDG2WORVX7ORZsszScQ40+fLjHpekp2KdMCQ6GGKueSmoDxGe7MxYgOO/CeLg309uhE8nPsTg/9XMs0hocAky8E441x6LYaenYZmlnm6VRHGr0YeVeD4SGd5++ZTacV23A4KDXIYv2Cpzq10BkIEBw4aTxMDzoLdmqw9n9Uz7HIiPBATDtvIuYcyyKpMhtlqwyGMKhRh9W7nFrqjj0LbPhXCMGh1TLdyj7n/wY7eE+ue2wbPoDBBdOGgv3cHpyeYA1Sc6xmDpcn22Jwi8LtHgzEBwCTLhD7jjHQgB+P2w+H8rtgm2WBnWwQXtw6NfFwMEhVVWHUPkO5RBGvADxWfoDBBdOGgvDg57WbDX0HAu/LNDqQ+aCA2C6tQ9hcyyErByS8PgAAJWdHbDmO9hmaUAHGnxYtbddcIjz3KvpYsO4ngYNDulk4ADBhZPGwb2eXgw+xyI0OBTYMxQcAkz04j/a5Ifs8wMer3LMVwLgsANWK6pKYpxkhzLmQIMPq9sHhzhqutgwlsHhjHyHciprNQGiPonOMo2sFgl+8+w+shrDg162HQIOn0z8+vmpm2OhBAflFVdgR2aDA2CO6oMQEB4vao+7AQFlAWRbaACUs0nm2flGYzT76+MEhwjPPVMEh3QcsmgvT2WA2Lg7rQHCwL+lnMLwoJdkqw4ThqRkjoVfVhZHAkC+zQDBATB2eAhps6x3Ay6Lta1jIvylkvAcC0qZ/fU+rN6nreLQv9wEwSGTAgGiwDgBgvMujIF7QD3oMsdC/4WSgeAgSUC+LcOHKtoz0s46SptlbSsQ6XOO5jkWlHKB4KCqn6/tude/3IZzepggOGSi6hAqr20NRLwA8Vl6AgTbNo2Be0A9JDvHYki17nMsQoNDYabXOERihOpDtGmWFgtcPoGTLZF/p1Vq51hQWmgKDm36d7FibE8nf49qqQkQ/rYAcaop5ZvDts3MY3hIlgHnWBg+OARk4sWvcprl0SgnhVI1x4LSZt8p7cFhQLkdY3s6U7dResp01SFUIEAUxnjs/DKwcU/KAwTbNjOP4SFZesyxGNVXt80JDQ4Za8dUK53VBw3TLGPOsSi0wB5pjgWl3d5TPqzZry04DKyw45yeDmNUvsxIS4A4mdoAwbbNzGJ4SFayCyV1nGPRPjgYfphPOnbgCUyzjDnHophVByPYe8qHtQkEh7N76L8oOec47eoCxKbUBgjOu8gshodkHDyutGgmSsc5FqYLDgGp2M4kp1nGnWNBGZVIcBgUKTgYvfpgpEMW7RkgQHDhZGZxT5gMg8yxMG1wAPSdd6HDNMuYcyzaT8+ktNtz0oe1Gtc4DKqwYwwrDvpz2pV9WAYDBBdOZg7DQ6JaPcDabcndhg5zLEwdHAKS2Wadp1l2nGOhsFmA8gK+XDJp90kfPtrv1nSdwV1NGhyMXHUI5bApAaIoL/pl/G3ngThxWve758LJzOHeMFFrtmR8jkVWBAcgsfKxP3qbZaK8/pA5Fu1UFlmNvfg0y+0+6cM6jcFhSFc7RnePExyMfujCDBw25RBGrAAhC6UCkYIAwYWTmcHwkAghkj9kMTW5ORZZExwC1Lz4Q9ssfdHbLBNV1+yP+imGCyUzZ9eJxILDqHjBgfSTwQDBeReZwfCQCD3mWJyX+BwLX7YFByD2J0ANbZaJEkKgtjFy1YFzLDJn1wkfPj6gLTgMrdQYHIxWfTDLIYv2AgGiWE2AaNT1rk34aJkew0MiMjjHwicLNGdbcAAi78ATaLNMVL1LwOWLslCScywyYucJr+bgcFalHSOrWHHIGIcNGK0mQOzVNUBw3kX6ca+o1ckm4NMk51gkuFAya4NDQCBAJNFmmahoCyU5xyIzdp7w4pMD2tYUnVVpx4hEg4NRXktmrTqEUl2B2Asc1ydAsG0z/bhX1OrDzcm1Fg6tBqq0z7HI+uDgDxya8CTcZpkozrEwlh3HtQeHYd2SCA4BRjp0YXZ2lQHi8726BQi2baYXw4MWfhlY8WVytzFF+xyLrA0OkdosnfaE2ywTFe2kUJxjkX7bj3ux/qD24DC8WxYcqsiGqkOoYIDIj34ZHQME2zbTi+FBiw3pn2ORlcEhVptlmhevyULgKOdYGML2415syGRwMNrCyWxgtwFj+sUPEJv26BIg2LaZPgwPWqR5jkUgOFiyITiobbNM8w6ccyyMYfuxDAcHSh01AUJACRDHGpK6K867SB+GB7UOHge2p2+ORWhwKDRzcEikzTKN/9doCyWLnZxjkS7bjnmx4ZC24DC8ypGa4JCp6kO2HbJoz24Dzq4BSgqiX0ZAOYSRRIDgwsn04d5RrTTOsciK4JBMm6We8y5iaHLLOB1ljkU3Vh3SYtsxLz7VGBxGVDkwrNKeoi2ilLFZlQqEmgBRV5/w3XDhZHowPKihxxyLaeoWSpo6OAihhAU92izT8P8+HKXqYLcCFYV8aaTa1gSDw1nZFhyyveoQSm2A+GJfwgGCCyfTg3tINZKdY1FdDvSvinsx0waH0GmWFp3aLFNcPvb6BY5HmWPRtdBqnsfepLYe8+IzjcFhZPc0BQcunEytQIDolLoAwYWTqcfwEE+a5liYLjiEtln65aSnWUa9jxThHIvM2VKnPTiM6u7A0K5ZVnHIZTYrMFplgDhar/nmOe8i9Rge4tFjjsW5A2NexFRdFZHaLFN1MqcUfQLkHIvM2VLnxcbD2oPDkHQHh3RVH3LpkEV7agPE5sQCRI4+qmnD8BDP0iTbMycOjTnHwusPDw6GPJthiqdZRpWiHTjnWGTGVwkEh9E9MhAcKH20BIgjpzTdNOddpBb3lLGcbAI+S90cC69foMVr4OCQhmmWcaXgMYnWnplnkzjHIkW+POrFJo3BYUwPBwZXZDA4pPr1mMtVh1CBABGrG00A+HK/pgDBts3U4p4yFj3mWHTrHPFHhg4OoW2WVkt6qgzR6Fx9cHmjz7HoVmwx1u8hS3x51IvPa7UHh0GZDA4BXHSXHikKEGzbTB2Gh2h8/pTNsTBkcIjWZpnOKkOsbdPJkSinouYci9TYnEBwONsowSGVWHXoyGpRAkTnouiXCQSIWnXr0Ni2mToGeGcwqGTnWJQVR5xjYbjgkIo2S73pVH3gHIv0+uKIB19oDQ49HRhopODAts30slqU/WbcAHFAdYBg22ZqGOgdwmCSbc+MMMfCMMEhHW2WetJpB36McyzS5osjHmw+4tV0nbN7OjCw3EDBgTJDTYAAVAcIzrtIDYaHSFIwx8IQwcHfdmjCnYY2S73p8HhFG73NORb6SiQ4nGPk4KB39YGHLOLTEiDitNJz4WRqcI8ZSbJVh3P6h7UeZTQ4BNos3R7A7wesbVWGTC2ATFSS8y5Oc45FWiQaHAYYNThQ5gQCRFmcAPFV/ADBhZP6Y3hor8UNrNma3G1MPbNQMhAcrOkODu3bLB1tVQYzH9dP4rGL1p7JORb6+bxWe3AYW51jwYFVB22sFmCkygBx6ETUH3PhpP6412xvzdYzZf1E9KoIzrEIDQ6F6QoORmqz1FuC5eNYcywqizjHQg+baj348qj24NC/i0mCAxdOZo7aALHlYMwAwYWT+mJ4CCUEsCzJM0pOGQ5IUnqDQ6DKYMQ2S70l8OKPNceiG9szk7ap1oOvNAaHcdVO8wQHyrxAgOhSHPtyMQIE513oKwvfXZKw9SBQq+0UqGEKnMB5g9IXHAJtlh6fclAv32GeBZCJ0vgJkHMsUmvjYe3B4dxeTtR0saVoi1Io2eoDD1kkx2oBRvZRFyAOHo/4I1Yf9JPF7zIJSHaOxYQh8NhsqQ0Osdosc4HGHXisORbdS3LkMUuRzw57sKVOe3DoV2bC4EDGYGkLEOUlsS+39VDEAMG2Tf0wPAScbAI27knqJjyTh6E1VcEhndMsjU7D4xprjkVpHj8FJuqzwx5s1RgczsuG4JDoa5pVB/1YLMCI3uoCxIHwAMG2Tf3k4DtPFCuSm2PhG1yN1i6l+gaHTE2zNDqV1QfOsUiNTw9pDA4SML63E33NHhwCWPbOPLUBYlvHAMG2TX0wPADKG/OHmxO+ul8ArguG6xccjDDN0uhUvPg5x0J/Gw55sO2YxuDQy4k+nbMkOCSCVYfU0BIg9h87czW2beqC70ZA2xyLloSu6heAr7QIGNEn+eCQzW2WeotTfeAcC/1tOOTBdgYHtm0aSSBAVMQJENsPhwUILpxMHsMDkPAZJf1C+SNfcBYK862JBYdcarPUU5wdOOdY6Gv9Qe3BYUI2BgcyHosFGK4tQHDhZPL4DpXgHItAcJCsFuRNGaY9OORim6XeYjzmnGOhn08OurHjuLbgMLG3E72zOTiorT7wkEV6WCzAiD5A106xL7f9MLCvjgsndcC96Afa2zODwQGA7dwBkEoL1V0x19ss9RZl3gXnWOjnk4Nu7DzuU3+FtuDQqzSLgwMZkyQpFYh4AWJHLbCvjgsnk5Tb4aHFDazdpukqYcHBAkhThqu4EtssUybCpzrOsUieEILBIVmsOqSfhgBh2XeMhy6SkNt7Uo1zLALBwYK24BAyx6IDtlmmR7vyMedYJE8IgfWHPJqCg5SLwYELJ40pECAqS2NfbmctpL11XDiZoBx6pbejcY5FaHCwWpTKQ2CORRhZBnyyUm2wWZQWS75hpVbIJ7yjTZxjkQyl4uDBrlPqz3kiScDEPk5Ud8rd3QkZjCQBw3op/z5aH/Vi1t1H4IOArV+39GxXFsl45aFPnz549tlnU3LbF154Ie69997IP9yifo5FxODQNsciiG2WmdP2CVAIgSOnI7/plRVwjkU8QghsOOzFrhMaKw65HByiVR94yCLzAgGiW2nsi+06ArH7SHq2KYtoCg+zZs3C1VdfndAdzZs3D6WlpR2+/8knn+COO+4Ifi1JEhYtWpTQfWgSulCysQX4bDfw3kbg3U+VwxlHTgFCRA4OADBhiHIQnW2Wmde2A481x4LtmbEJIfDxQQ/2nNQWHCblcnAg45Mk4KzYAWLdV5tgG9ADl02ZjlavrNthjL1790KSpOCfsrIyTJ48GStXrtTl9jMt4+9yFRUVKCgoSO+dnmxSwoIQwKY9SmjYfUQJEaddQO1JYNUWiA++gN/l7RgcBICJQ9hmaSSShMONnGORCCEE1h3wYLfGisOkPk70ZHDoWGFg1cFY4gSI377zFkZNuQX/WfMR+j+6EWc9ewQ/W9KA2ij7E62WLFmC2tpafPjhh+jevTuuuOIKHD16VJfbziTd3u1+/etfY/jw4SgsLER1dTW+853voKmpCQCwfPly3HrrrWhoaAimsEcffRRA+GGLPn36AAC+9rWvQZKk4NeRKh733nsvLrzwwuDXzc3NuOWWW1BUVISqqio888wzHbbR7XZj9uzZ6DGgLwoXzMa5//gFlm/ZpPwwNGwG/l3fBPuqr2AVshIchFDWMgzpCVR3YZulgbh8wKmWyC/2qhLOsYgmEBy0VhzO78vgEIaL7owtECCqOod9+8NjHvxjxbs4OupW5A+ehuYNf0ezR+BX98/CkAu/hp0nziyo93q9KC8vx4IFCwAAsizjqaeeQt++fZGfn4+RI0fi9ddf73DXXbp0Qbdu3TBs2DD8z//8DxobG7Fu3brgz1esWIFx48bB6XSiqqoKDz30EHy+M69Ht9uNe+65B127dkVeXh4mTZqETz75JPjz5cuXQ5IkvPvuuxg9ejTy8/MxdepU1NXV4d///jeGDBmCkpIS3HTTTWhpOXMm5ddffx3Dhw9Hfn4+unTpgunTp6O5uVn1Q6pbeLBYLHjuuefw5ZdfYv78+fjggw/wwAMPAAAmTJiAZ599FiUlJaitrUVtbS1mz57d4TYCD8jcuXNRW1sb9gDFc//992PFihV488038d5772H58uX49NNPwy5z9913Y+3atXj1hRfx+Q+fxXW+SlzSugI75NMRb1MSgNTQDOnA8TPnE7BagItGscpgMEea/BF34BYJ6FrIgBeJEAIfJRgcepQwOETEqoNxSRIwtDoYIDwy8M1FK2Dv2h/Wiv4oHH0Nmte/BiEECkZ9DY2b38e3Xz0YPIzx7rvvoqWlBV/72tcAAE899RQWLFiAP/7xj/jyyy9x33334eabb8aKFSsi3n1ra2sweDgcDgDAoUOHcNlll2Hs2LHYtGkT/vCHP2DOnDl4/PHHg9d74IEHsHDhQsyfPx+ffvop+vfvjxkzZuDkyZNht//oo4/i+eefx5o1a3DgwAFcf/31ePbZZ/G3v/0N77zzDt577z387ne/AwDU1tbixhtvxG233YYtW7Zg+fLluOaaazQdstFtDxC6MLFPnz54/PHHceedd+KFF16Aw+FAp06dIEkSunWLvqq1oqICAFBaWhrzcu01NTVhzpw5ePnllzFt2jQAwPz589GzZ8/gZfbv34+5c+di//796N69O3BwEWbnDcF/fEcw17sHTzpHRL+DXUeAPl2Vf5cVK2cyI8MIzrEILF4L2XlzjkVkgeCwV2NwuKBvHrqXMIx1wLZNcwgECAD/+bIFR9a9hoJR1wAA8gZOgez6Ady71yJvwIWQHAX44sN/Yf1V/42xPZ3429/+hv/3//4fiouL4Xa78eSTT2LJkiUYP348AKBfv35YtWoV/vSnP2Hy5MnBu5wwYQIsFgtaWloghMDZZ58dfJ964YUXUF1djeeffx6SJGHw4ME4fPgwHnzwQfzkJz9Ba2sr/vCHP2DevHm49NJLAQAvvvgi3n//fcyZMwf3339/8H4ef/xxTJw4EQBw++2340c/+hF27dqFfv36AQCuvfZaLFu2DA8++CBqa2vh8/lwzTXXoHfv3gCA4cNVnLMohG7hYcmSJXjqqaewdetWNDY2wufzweVyoaWlJeVrGnbt2gWPx4Nzzz03+L2ysjIMGnSmG+KLL76A3+/HwIEDlW+4vYBPhht+dJEcse+gIaSUM2U4F0QaTHCOReCMkyHhgQslOxJCYO1+D/adUh8cLBYJ5/dxMjiQ+bUFiP+89yE8Bzai4ptzlG9bbSgY8f/QtP7/kFczAQXDr0TLxjfwycFbMbSzD2+++SZeffVVAMDOnTvR0tKCiy66KOymPR4PRo8eHfa91157DYMHD8bmzZvxwAMPYN68ebDb7QCALVu2YPz48WGHVSdOnIimpiYcPHgQ9fX18Hq9wVAAAHa7HePGjcOWLVvC7mfEiDMfgCsrK1FQUBAMDoHvffzxxwCAkSNHYtq0aRg+fDhmzJiBiy++GNdeey06dw4/rBOLLuFh7969uOKKK3DXXXfhiSeeQFlZGVatWoXbb78dHo8n6fBgsVg6lFO8Xg3n2odSnbBardiwYQOsVitw/1xgySZACBSpfRhsVuD8oZrul1IvbI5FyIuQcyw6koXARwkEhwv6OFHF4EDZQpKwce1CQPbh0JNjznxfCEg2B+SrnkDh6K/h6J+uxemTx7Bo0Vrk5+fjkksuAYDger533nkHPXr0CLtpp9MZ9nV1dTUGDBiAAQMGwOfz4Wtf+xo2b97c4XLJCgQS5b8nhX0d+J7cdvjdarXi/fffx5o1a4KHMx5++GGsW7cOffv2VXV/uuxZN2zYAFmW8cwzz+C8887DwIEDcfjw4bDLOBwO+P3xV6/a7fYOl6uoqEBtbW3Y9zZu3Bj8d01NDex2e9gilFOnTmH79u3Br0ePHg2/34+6ujr0798f/SeNRX9rMfpbitHNkh91e4QEoFPb7Ipz+gMlae4MoZg6zLEImXfBORbh5AQrDgwOlG18Ph+2fPAaSi//Cbrd896ZP99/H9aSbmjeuAjO3mNhLe2OYxvexCuvvILrrrsu+IY8dOhQOJ1O7N+/X3k/CflTXV0d9X6vvfZa2Gw2vPDCCwCAIUOGYO3atWEfjlevXo3i4mL07NkTNTU1cDgcWL16dfDnXq8Xn3zyCYYOTe6DrCRJmDhxIn72s5/hs88+g8PhwBtvvKH6+porDw0NDWFv3ABQXl4Or9eL3/3ud7jyyiuxevVq/PGPfwy7TJ8+fdDU1ISlS5di5MiRKCgoiFiR6NOnD5YuXYqJEyfC6XSic+fOmDp1Kn71q19hwYIFGD9+PF5++WVs3rw5WB4qKirC7bffjvvvvx9dunRB165d8fDDD8MSsqhx4MCB+MY3voFbbrkFzzzzDEafX4Nj/pNY6qnFCGspLrd1j/j/lQRw+u7/h+JOTmBqjHURlBER51hIEudYtCMLgTX7PDhQry04TO7rZAhTI7DWhusejE+W8fZbb6HldD0GX/ANNKIo7Ky0+cMuQ/P6V1E6/hb0Gn8N/v3qX7B9+3YsW7YseJni4mLMnj0b9913H2RZxqRJk9DQ0IDVq1ejpKQEM2fOjHjXkiThnnvuwaOPPor//u//xne+8x08++yz+N73voe7774b27Ztw09/+lP84Ac/gMViQWFhIe666y7cf//9KCsrQ69evfDLX/4SLS0tuP322xN+CNatW4elS5fi4osvRteuXbFu3TocO3YMQ4YMUX0bmveuy5cvx+jRo8P+/PWvf8Wvf/1r/O///i+GDRuGV155BU899VTY9SZMmIA777wTN9xwAyoqKvDLX/4y4u0/88wzeP/991FdXR0MBzNmzMAjjzyCBx54AGPHjsXp06dxyy23hF3vV7/6Fc4//3xceeWVmD59OiZNmoSzzz477DJz587FLbfcgh/+8IcYNGksrpY+xifySfSSIlcTZKsFDYN6Ydd104A7ZkSfY0EZEXWOhSShstDCORZtGBzSiAHCmIRQKpJta6LmzJ2L6dOnY85NfeC0SghdU10w7DJ4Dm6C/cQWvPDwrfjqq6/Qo0ePsHUHAPDYY4/hkUcewVNPPYUhQ4bgkksuwTvvvBO37D9z5kx4vV48//zz6NGjBxYvXoyPP/4YI0eOxJ133onbb78dP/7xj4OX/8UvfoH/+q//wje/+U2MGTMGO3fuxLvvvqtpfUJ7JSUl+PDDD3HZZZdh4MCB+PGPf4xnnnkmuChTDUnk8lQQWQZ+/Arw/DuQrRZY/MobUeDf9UP74pPffB++sk6YUpOHPJuJ34y2HTrTbmqxAIN6xL68CRxs8GHvqciHws6psiHPyTc+TcFBlmFrdUMU5uGCmnwGBy1Cu3zYrmkcsqyct0dC1Pb63Sd9+PO603jjq1a4fEChQ8LXRxTg22OLeLguhtwODwHbDuH4c/+BY+0WWHx+NPWpwv5rLsTxc88C2hZrDii3Y2C5Pf5tGVWWhQchBDYc8kY8HXVZgQVDK9qOyOXwTlxzxUGW4XR7MHFoCSo7mfi5nm6RwgIDROYI0fYHyoleVP4eZCHg9gnk2SSeVE4FnukFAAb1gP2ZW7FqnzvijyVJwv56H/p3sbEUbhCnWuXYcywitG3mElkIrN7rxsEG9afYtVokTOrjQFdWHMiMhFBmDMWoMsRikSTkc3iealxR1qZTngWledEfDo8fOKLTuc4pebVRpmeGzbFgcFB9HatFwuR+Tp6NU6toFYYcfe5lhCwrYwMA5Rw8PPtvWvBRDtGrNPaO80CjX7eJa5Q4l1fgVGvk8BA2xyIHF6/JQmBVgsGhsojBQVc59txLq8CcIVlWwoLVwsCWZgwPIaqKrXDEOJXxiRYZTR7BAJFhEdszEWWORQ79rgLB4ZDG4HAhg0NiuK4h/VhlMAw+8iGsFgk9O8Xeie6v90OSJAaIDJGFQF1z5DfHiHMsLJacCBB+WWDlHm3BwWZVgkNXBofUyMHKV0qEVhkkiVUGg2B4aKdXnPBwqNEHr18wQGRIcI5FBN2jLfTL8t+TX1YqDoc1rMlhcCDDC1QZhDhTZWBoMAyGh3YKHJaYZyb0yQjupBkg0u9IlEMWxU4JRdHmWGTxJ0C/LLAyweBQwcWRiVN7yCKLn3sp0e5kTjw0YVz8rUTQuzR2B+u+kL55Boj06TDHIkTMExpl6Q48EBxqNQQHu1XCFAYHMprAoQkhlLDAKoPhMTxEUFFoQUGMft8mj8CJljM7bAaI9Ii2UFLVHIss2xH5ZYEP92gPDhf2c6KcwSE5XCipHy6ANC3+piKQJCl+9aHdaZEZIFIr6hwLAJVF1vgn78qi6oOvLThEO4QTid0qYUoNg0NGZNFzTxdss8wKDA9R9OhkRYyuTRxt8sPlDd8hMECkztEmf9jku1Dd1C76y4LfTTLBoUsBg0PSsuA5lDGsMmQV/vaicFgldI8xFEUA2N/QcWYAA4T+hBBRD1mUFViQp/aUsib/BBgIDkcZHDIrkU/JJn/uJYxtllmL4SGGXnEOXRxo8EOOsENggNDXqVYZ7iiznaq0zGEw8Q7cJwus0BgcHDYJUxkcKBPYZpn1GB5iiDfvwu0TOBplxgIDhH5UzbFQy4Q7sEBwqNMYHKb0c6KMwUE/yS6UNHF4VYVtljmFv9k44s272Bdj3DEDRPJUz7FQy2Q7cJ8ssGK39uAwtSaPwYHSg22WOYnhIY6qYiucMVZOnmyVcdod+c0NYIBIlqY5FmqZ5PcRDA5N2oND53y+tHXF9syOuAAyp/G3HYeaeRf76mPv3BkgEiMLgaNR3jgrIs2xUMsE8y68fu3BwcngYHwmq3x1wDZLasO9jArVccLD4bZ5F7EwQGh3rFmGL0pRR9NCyUgM/Lvw+tvWODA4kFGwykDt8BmgQoHDErNEHjrvIhYGCG2inT0x5hwLtQz6CdDrF1i+241jCQSHUgaH1ND7kIVBn3sdsM2SYuDeRqXenRNfOBmKAUKd024ZTZ7Ij1PSVQfAkDtwT1twOB5l5HgkTpuEaf0ZHEhHbLMkFbjHUam8QNu8i1gYIOKLNceiPN4cC7UMtEP0tK1x0BQc7Epw6BSjnZiSlCsLJdlmSRrx2aFSIvMu4t0eA0RkSc+xUMsg1Qel4uDSHhxqGBxMyyDPvbAqA9ssSQPueTRIZN5FLAwQkcWcY6HHIYtQGX78A8HhRJSwFAmDQ5pk82szEBpYZaAE8RmjQaLzLmJhgAgXd46FTedPRRn8BOjxCyzbpS045DE4pFcqP4Wn+7nHNkvSEfdAGiU67yIWBogzdJtjoVaGwkMgOJxs0RgcuMaBtGKbJaUAn0UaJTPvIhYGCIWucyzUSvOnL7cv8eBQkmyLKqmTroWSqQqvbLOkFOOeKAF6tW22l+sBQvc5Fmqlsfrg9gks260tOOQ7GBxIJbZZUppwb5SAbkXx5100xph3EUsuB4hYcywqi1I85CkNj7nbJ/DBLhdOaQ0ONQwOaWW29ky2WVIG8BmWADXzLvbHmXcRSy4GCL8ce46FzZLinXmK51242oJDfZTKSiSB4FDM4JDdEq18sc2SMoh7pQTFG9WtZt5FLLkWII6nco6FWil6vF1taxwYHEgXbLMkA+CzLkH5dn3mXcSSSwEi2iGLEj3mWKiVgrUPiVQcChwSpjM4ZEamDlnEe+6xzZIMhnunJKRq4WSoXAgQseZY6H5SqFh0Dg+B4NCgMThMq8lLX2AiY2ObJRkUn4lJKC+woFCneRexZHuAiDY9U9c5Fmrp9GnO5RVYupPBwVSMslCSbZZkAtxLJUGSpLgnjdIy7yLefWVjgPD4BY5H6T7opuccC7V0qD64vAJLd7nQ6FIfHAodFgaHXCcE4POzzZJMgXuqJOk97yKWbAwQ0eZYSBJQmc5DFqGSeIwTDg79nQwOmZSp1xXbLMmk+CxNUirmXcSSTQFCCIEjURZKds5PwRwLtRKsPrR65YSDQ6GDL8WMS+en/GhtlkaZtkkUB/dYOog776Je+7yLWLIlQKR9joVaCezAW70yPtjl1hwcpjM45Ba2WVKW4DNXB3HnXfgFjiQw7yKWbAgQGZljoZaGT6GJBIcipxIcChgcMi/VCyW1tlmy+kAmwD2XTuK1be7XoW2zPTMHiIzNsVBL5Q681Stj6U7twWFaDYND1mObJWUxPpt1UlWcunkXsQQChNlCREbnWKgV5zENBIfTGn6vxQwOxqJ31YFtlpQjuAfTiUVK7byLWAKf0s0SIDI+x0KtGPMuWjwJBgceqshOek+z5KELMjjuxXTUq9SKWLuLZOddxGKmAGGIORZqRXg8Wzwylu5KLDjk2/mSyxpss6Qcxme6jvLtFlSkeN5FLGYJEIaYY6FWu0+AgeDQpCE4lOQxOBhSoocs0jXNktUHMjDuzXSWjnkXsRg9QDQaZY6FWiE78GaPjCU7tQeHqTUMDlmBbZZEQXz260zNvIvjzamrPgDGDhBHolReHJmYY6GWJKG5bY1Ds0djxaEmj8HBiNRWHTjNkigi7tV0pmbeRaoWTrbfDsBYASLWHIvKTMyxUKnZK7B0hyuh4JAXI0iSgRmlzZKHLsigGB5SIJ3zLmIxWoAw5ByLOJrcbRUHt/rAx+BgcNFeD2yzJFKN4SEFVM27SPHah4AzASItdxeVYedYxNDkVmZVNHtk1Z8AO+VbMK0/g4PhhYYCvdss9cbqAxkQw0OKxJ130aDvvItYjBAgYs2x6G7AqkMgOLQEFneq2IF3yrdgak2eIYMQtcM2S6Kk8NWSIp3yLOicn955F7EEPkhlKkBEm2ORb5fQKdNzLNppcstYEhocAmJ8Gi1lcDAHvx+QRerbLPXG6gMZDMNDCvUqTf+8i1gyFSBavXLUORbdig0wxyLE6bbg0BqpnTTKDrw034IpDA7GFagysM2SSDd8BaVQpuZdxHImQKQvQUSrsBhqjgWU4LA0WnAIaPe4MTgYWGABZLDKIDE0EOmEr6QUUjPvYt+p9FYfgPQGCLPMsWhUExyAsHkXnQt4qMKQjNJmqTceuiADyZJXlXHFn3fhT9m8i1jS1cZphjkWjW4ZS3eqCA4BQqBzgQVT+uXByeBgDGyzJEorhocUy7db0DVGad4vgEMpnHcRSzoChNHnWASCg5bzbpQVWjGlr5PBwQjUtlnqPXo7U1h9IIPI/N47Bxht4WSoVAYIo8+xaHAlEBwKLJjSPx/OzG9+7mKbJVHG8RWXBkaYdxFLqgKEkedYNLhkfLArgeBQkweHVcqOT7Fmk+g0y2ypOhAZCMNDGkiShN6dY580al8a5l3EIkkSJEnSLUAYeY5Fg0tZHKklOHQpDAkOAMvH6cI2y4743CMDyPFXYfr0KIk976IuTfMu4tErQBh1jkUgOLg1PNblhVZc2C8kOARwB5467dssE10Ayd8RUUowPKSJ3UDzLuJJNkDEmmNRlsE5FoE1DlqDw+R+zo7BAeAnwFRIRZtlNh6y4HOPMozhIY2MNO8inmQCRKw5FplqzwwGB5/WikOU4ABwB64XtlkSmQ7DQxoZbd5FPIkGiMMGm2NR36o9OFQUKcHBHutYE8A3uWSkepplti+UZHilDGJ4SLN4bZv7DHLoIkBrgGj1yqiPMseiqtia9jkW9a1KV4XW4DC5r4rgAHAHrhXbLImyAl+1aRZv3sWpDMy7iEdLgIg2PdNqAboWpffpdiqB4NBVS3AIYHiIL9E2y0Rle9WBKMMYHtLMIkmoNuC8i3jUBAi/LFBnkDkWCQcHNYcq2guZd0Eh2GaZeqx8UYbwlZwB1QaddxFPvAARa45FtzROzwwEB4+W4FCsBIeEAw534Gfo1WZJRIbF8JABRp53EU+sAGGEORYnW/yJBYe+SQQHgJ8AAeNMs8y1QxZ87lEGMDxkSO94CydP+dIyMjsRkQKEEeZYKMHBrSk4VOoRHIDc3YGzzZIoJzE8ZEiXOPMumr0CJ6Kc3tkI2geITM+xONEWHLQc7qkstuICPYJDQC69aaa6zTJRuVZ1IMoQhocMMcO8i3gCASLTcyxOtPixLNPBAcj+6gPbLI0r2597ZDh85WeQmnkXrV7jVh8AJUAcOe3L2ByL483ag0O3VASHgGzcgae7zTJR2fjYExkUw0MGqZl3ccDg1QchBI42yRHXZ6R6jsXxZj+W79YWHKpKUhgcgOz5BGjWNksjhpp0yZbnHpmCCfYG2c1M8y4iOdk2xyLSIspUzrE41uzHsgSCw/l9nLCm8nwTZt+Bs82SiFRgeMgws827aC/0jJKhASKVcyyOtVUcfBqCQ/d0BIcAM77ZGqXNMlFcKKkwe3gl0zDZHiI79Y5TfTDavIuASHMsAgEiVXMsEg0Ok9IVHADz7MBD2yxZZSAiDRgeDKBbsSXuvIsGl/GqD9HmWNisEioK9X8TqmsyQXAIMHJ4iNRmaWasOhClncn3GtlBzbyL/QarPsSbY2G3WnQ9yVUiwaFHJyvO75uB4AAYb94F2yxzh1kqX2Rq3HsYhNnmXRyLMccisFBS6zjvaI62BQd/pH7QKHp2UioOqT7HRExG2IGbpc2SiEyF4cEgzDbvItoci055EgodZ55WyQaIo01+rEggOEzMdHAAMvcJ0KxtlongIYvIWH2gFMvSPYo5mWXeRaNbRnOUORaVEQJQogHi6GntwaG61GaM4ACkfwfONksiShOGBwMpL7SiyGH8eReJzLHQGiCOnvZjxR7twWFCb4cxgkNAOrbF7G2WiWLVgShjcmQvYx7xThqV6XkXHr/AsQTnWKgNEEeyJTgAqas+sM2S4uGhC0ohhgeDMfq8i6NN/oj7I7VzLOIFiKwKDgF67sCzrc0yUaw6EGVUju55jMvI8y6EEDgSZaGkljkW0QJEbaMSHGQNwaFXZ4MHByD5T4Bss6REsfpAKcI9kAHFG9WdqXkXgTkWkWidY9E+QNQ2+vHhXu3BYXwvgwcHIPEdONssicigGB4MqMQZf95FtFbJVIp2Rsl8u4TSGNsbTSBAHE4gOPQ2S3AIULududRmmSgestCG1QdKAe6VDCrevIv9aT50EWmORUAy0zNrT8tYsbs1u4MDEH8HzjZLIjIRhgeDMtq8i2hVB6sF6FqU2NPocKMfH+5xAVDfxtmnTAkOqRi6lXKR/o+52maZKFYdiAyBeyqDMtK8i3hzLGwJzI441OjDh3tcwfdTNW2cfctsOK/apMEBODPvgm2WlG48dEE6Y3gwsF6ltrjzLjxpmHehZo6FFocafVi5x91hXxYrQPQts+FcMwcHQAkLPj/bLInI9Lj3MrA8uxR33sXhNMy7UDvHQo2DDZGDQ0CkANGvi4mDQ/s2S5uVVYZE8ZBFclh9IB0xPBhcpuddNLiiz7HoprHqcLDBh1V7oweHgNAAUdPFhnE9TRgcorVZcgdORFmA4cHg1My7OJ7CeRfRTgrlsAJdCtQ/fQ6oDA4BkiShX5kVY80UHNS2WZrl/2MkrDoQGQrDgwnEnXdxKjWHLjz+6MGkW3HsORahDjT4sFpDcADaKg7VTvVXyCStbZasPlCm8LlHOmF4MIEeJVbYYvymjjWnZt5FrDkWsdZihNpfr63iAAD9y23BikOi47zTIpk2S6P+n4yIVQciw2F4MAFl3kX06oOA/ieN0mOOxf56H1bvcysbqJISHJxhhyoMFSD0arPkJ0DKFD73SAcMDybRK87CyYM6z7tIdo5FMsEhkowHCL1P5sQdOBGZGMODSZQ4LShL47yLZOZYJBIcBpTbowaHgLQHiEjTLPUsn7MUHx8PWaQGwyslieHBROItnNTr0EUycyz2ndIeHAZW2HFOT4eqy6YlQKRrmiV34ERkUgwPJpKueReJzrHYe8qHNfu1B4eze6gLDgEpCRCZmmbJ8BAdqw5EhsXwYCLpmHeR6ByLvad8WKsxOAxKIDgE6BYgMj3NMjDvgijdWPmiJDA8mEyq510kMsdiz0ntwWFwVzvGJBgcApIKEEaaZskdOBGZDMODyeTZJVTGmXdxqCHxtQ9a51jsPunDRwkEh9HdkwsOAZoChFGnWfITYEc8ZJEefO5RghgeTChe2+b++sTmXWidY7H7pA/r9rs13ccQHYNDQNwAYaQqQyTcgRORyRhsL0pqpGrehZY5FokEh6GVdozSOTgEdAgQqW6z1JuRty3dWHUgMjyGB5PqrfO8Cy1zLHadSCw4jKxKTXAIkCQJwu9PT5ul3lh9oEzhc48SwPBgUt11nndx5HT0ORahayx2nvDi4wPagsNZqQ4OIVUGyWKBsEjGOzShBnfgrDoQmYQJ97AE6DvvQgiBo1HaM7sUWOBsm2Ox84QXnxzwaNrOYd3sGJGq4NC+zbKtypDxU1knip8AKVP43CONGB5MTM28C78cf4cQa45Ft7aqw47jiQWH4d1SEBxULIA0ZYDgDpyITILhwcTUzLs4EqWiECraGSUL2uZYbD/uxfqDGQ4OCbRZmjZA5CoessgshlfSgOHB5JJdONniiT7HoluxFduPe7Ehk8EhyTZL0wUI7sCJyAQYHkyuMs68i3pX7HkXR5qiz7FoaPVnJjiEVhl0aLM0XYAw07bqhVUHIlNheDA5iyShWsVJoyKJNcei2S1jY61X07YMr3IkFxxCp1la9W2zNFWA4LwLyhRWvkglhocs0KuTinkXEQoM0eZYHGzw4aDGU1yPqHJgWKVd03UARD6ZU4raLE0VIMyynUSUkxgesoCqeRctHb8faY7FgQYfDtT7g+2ZaoyocuAsrcEhSptlqpkmQOTSJ0AesjCWXHruUcIYHrJE786xD13saw7fH0SaY3GgwYedx33olKd+Rz6yu8bgYIA5E6YIENyBE5GBMTxkiS4FseddtPiA4yEnhmw/x2J/vRIcrBagMMbthBrV3YGhXVUEBwNOszRNgMh2rDoQmRLDQxaJ27bZduii/RyL/fU+7DqhLKoscVrC5lhEM6q7A0PiBQcDVBliMXyAYPWBMoXPPYrDWHtzSkq8eRd1LqDVBxxvPjPHYl9IcACg6pDF6B4xgoPObZapZvgAYeRtSxarDkSmFfujKplKYN5F+9bMZo+Mz44BJ90S3q8FnJDQudmNyiILDoR0VRQ5JNgssXfmY3o4MKgiQnCQZWWghgQlMJhIIEBIRnwjC3wCNOK2UXbjc49iYHjIMr1LrcHwsL/ehxW73fj4oAc+GbBKUtsbvBX+Q02wW4BBFTYMqbCjU54FJXmx3/Q7BAchznwyliQgTvAwMsMGCEk6U8UhIjIIhocsU+y0oHOehL9+1oJ3trlgkQBlNpYEf6AC3va3Vwa+POrDl0d9uLCfA/27RH86nN3DgYGB4CCEcqMSDLeOIRmGDhDZhp9ozYHVB4oie/b8BEAZr/3Pza14Z5sLQCA4xLh8259luz1Yvc8d8TJn92wLDgZfAKkHQ66B4OI1IjKY7Nv757gFn7Xg75tbE7ruv7a6sPVY+Cmpz+5hx8DOVkO1WaaaIQOE0bYnGfwkS2R6DA9ZxO0TeGZlY8LXlwC8u0OpWEAInNPdjoHl9qytMsRiuADBeReUKax8UQS59Y6Q5f69vRUNrsRf5AJA7WkZB+p9OKfagQFdHTn9CdFwAcJI20JEOY3hIYvM29CcdMODRQJ2nPRhQHmSY7WzhKECRDZ8AuQhC3PKhuce6YrhIUu4vAKfHfbGXSAZjyyADYe0jeLOdoYJENyBUyYdPgls3JPprSCDYHjIEg2uCLO1E9Tk1u+2soWhAoRZsepgXq0e4Nz7gQt+BPx7Q6a3hgyA4YFIJUMECFYfKFMCx0RzbPE0RcaTRGWJTvn6vaCLndw5RGOIE0mZ8RO8GbeZzsh3AB8/DRxrBIb3zvTWkAHwXSJL5NkkjOluT3rBpNUCXNjPqc9GZamMVyBYfaBM6NaZwYGCGB6yyKyzC5NeMOmXgZtHF2S+PG9wGQ0QDA9ElGEMD1nkkoH5KFUxUjsaCcBZlXaM7u6ELACfLCDzTSqqjAcIs+AhC6Ksw/CQRZw2CfdfUJLUbTx4QTEAwGo5M57bJwv4ZcFqRAQZCxCsPhBRBjE8ZJmbRxfiW2MLE7ruYxd3wuR+eWHfs0hKiAhM52Q1oqOMBQgz/B5YdSDKSgwPWejHU0rww/PbKghx9ttWSfnzm8tL8c3R0UOHJEkRqxGkyEiA4LwLIsoQSbAWnbW21Hnx8mfN+MfmFrh9gM2irGsQAHwyUOKU8I1RhbhpVAF6lWrv2hVCBBdoWiRktn3RINLexhmYdqrXbTW5gKI8/W6TlQeirMTwkANOu2X8e5sLtaf9aPbIKHZa0KezDRcNyEOeTZ8du9wWJCyScqgjl6U1QARevnrcn97hgcGBKGsxPJCuWI1QpDVA6FV9YHggIpV4hknSlSRJwXUWgQ6NXKxGpPVMlEZ8bBkciLIaF0xSyuR6u2faFlGybZOI0ozhgVIul9s90xYgjPR4supAlPUYHihtorV7Zns1Ii0BgtUHymJ79+6FJEnYuHFjpjeF2jA8xLF27VpYrVZcfvnlKbn9+fPnY+zYsSgoKEBxcTEmT56Mt99+OyX3ZSTtqxHZHiJSHiAYHkilVO3TAm/wgT8OhwP9+/fH448/ntWv7VzF8BDHnDlz8L3vfQ8ffvghDh8+rOttz549G//93/+NG264AZ9//jk+/vhjTJo0CVdddRWef/55Xe/LqALVCKtFajv/RPYe0khLgMg0HrIwvFTu0wBgyZIlqK2txY4dO/Czn/0MTzzxBF566SXd7yeUEAI+ny+l90HtCIrq9OnToqioSGzdulXccMMN4oknnhBCCHHjjTeK66+/PuyyHo9HdOnSRcyfP18IIYTf7xdPPvmk6NOnj8jLyxMjRowQ//jHP4KXX7t2rQAgnnvuuQ73+4Mf/EDY7Xaxf//+4PdWrVolJk+eLPLz80Vpaam4+OKLxcmTJ4P39b//+7+ipqZGOBwOUV1dLR5//HEhhBDLli0TAMSpU6eCt/XZZ58JAGLPnj1CCCHmzp0rOnXqJN544w3Rv39/4XQ6xcUXXxx2/+kky7Lw+ZU/sixnZBtSKaX/J78/ues2NCd3G1n4+8omqdyn7dmzRwAQn332WdjtTJs2TXznO98J+96LL74oBg8eLJxOpxg0aJD4/e9/H/bzdevWiVGjRgmn0ynOPvts8c9//jPstgP7tcWLF4sxY8YIu90uli1bJiZPnizuvvtu8f3vf1+UlpaKrl27ij//+c+iqalJzJo1SxQVFYmamhqxePHi4H2dPHlS3HTTTaK8vFzk5eWJ/v37i5deeimpxzkXMDzEMGfOHHHOOecIIYT417/+JWpqaoQsy+Ltt98W+fn54vTp08HL/utf/xL5+fmisbFRCCHE448/LgYPHiz+85//iF27dom5c+cKp9Mpli9fLoQQ4p577hFFRUXC7XZ3uN9Dhw4JAOI3v/mNEEJ5s3c6neKuu+4SGzduFJs3bxa/+93vxLFjx4QQQjzwwAOic+fOYt68eWLnzp1i5cqV4sUXXxRCqA8PdrtdnHPOOWLNmjVi/fr1Yty4cWLChAm6Pp6J8Pll4fXLwp9lb0opCxCZDA9Z9jvKRqncp0UKD5988okoLS0NBhAhhHj55ZdFVVWVWLhwodi9e7dYuHChKCsrE/PmzRNCKAGnoqJC3HTTTWLz5s3iX//6l+jXr1/E8DBixAjx3nvviZ07d4oTJ06IyZMni+LiYvHYY4+J7du3i8cee0xYrVZx6aWXij//+c9i+/bt4q677hJdunQRzc3NQgghvvvd74pRo0aJTz75ROzZs0e8//774q233krZ7yBbMDzEMGHCBPHss88KIYTwer2ivLxcLFu2LPjvBQsWBC974403ihtuuEEIIYTL5RIFBQVizZo1Ybd3++23ixtvvFEIIcQll1wiRo4cGfW+S0pKxF133RW87YkTJ0a8XGNjo3A6ncGw0J7a8ABAfPTRR8HLbNmyRQAQ69ati7qN6eSXlRCRTdWIlP0/Er1dhoesl8p9WiA85Ofni8LCQmG32wUAcccdd4Rdp6amRvztb38L+95jjz0mxo8fL4QQ4k9/+pPo0qWLaG1tDf78D3/4Q8TwsGjRorDbmTx5spg0aVLwa5/PJwoLC8U3v/nN4Pdqa2sFALF27VohhBBXXnmluPXWW1U+ghTANQ9RbNu2DR9//DFuvPFGAIDNZsMNN9yAOXPmwGaz4frrr8crr7wCAGhubsabb76Jb3zjGwCAnTt3oqWlBRdddBGKioqCfxYsWIBdu3YF70OoPP69ceNGTJs2LeLPtmzZArfbHfXnatlsNowdOzb49eDBg1FaWootW7Ykdbt6ycZ2z5StgTD540KpkY59GgC89tpr2LhxIzZt2oS///3vePPNN/HQQw8Fb3fXrl24/fbbw27n8ccfD97Oli1bMGLECOTlnZnwO378+Ij/p3POOafD90aMGBH8t9VqRZcuXTB8+PDg9yorKwEAdXV1AIC77roLr776KkaNGoUHHngAa9as0fCo5i6eYTKKOXPmwOfzoXv37sHvCSHgdDrx/PPP4xvf+AYmT56Muro6vP/++8jPz8cll1wCAGhqagIAvPPOO+jRo0fY7TqdTgDAwIEDsWrVKng8HjgcjrDLHD58GI2NjRg4cCAAID8/P+p2xvoZAFjaTjMc+ibl9XpjXsfIQs9gKQsBnywgwbynwk7JmSgDnRfpfDy4UNLwUr1PC6iurkb//v0BAEOGDMGuXbvwyCOP4NFHHw3ezosvvohzzz037HpWq1Xz/6mwsOMkYLvdHva1JElh3wu81mRZBgBceuml2LdvHxYvXoz3338f06ZNw3e/+108/fTTmrcnl7DyEIHP58OCBQvwzDPPYOPGjcE/mzZtQvfu3fF///d/mDBhAqqrq/Haa6/hlVdewXXXXRd8gg4dOhROpxP79+9H//79w/5UV1cDAL7+9a+jqakJf/rTnzrc/9NPPw273Y7/+q//AqAk6aVLl0bc1gEDBiA/Pz/qzysqKgAAtbW1we9F6pX2+XxYv3598Ott27ahvr4eQ4YMUfGIZUa2tHvqXoFg2ya1k459WjRWqxU+nw8ejweVlZXo3r07du/e3eF2+vbtC0AJHJ9//jlcLlfwNj766KPUPThQ9pMzZ87Eyy+/jGeffRZ//vOfU3p/WSFzR0yM64033hAOh0PU19d3+NkDDzwQXHD08MMPi6FDhwqbzSZWrlwZdrmHH35YdOnSJbiIccOGDeK5554LLgoSQojvf//7wul0iqefflrs3LlTbNmyRTz88MPCYrGEdWFs27ZNOBwOcdddd4lNmzaJLVu2iBdeeCG4YPLRRx8VnTt3FvPnzxc7d+4Ua9euFX/5y1+EEMqK6erqanHdddeJ7du3i7ffflsMGjQo4oLJcePGiY8++kisX79enHfeeeK8887T9XFNh8DaCDMusNR1DUQit5XomgcTPta5Jh37tMCahyVLloja2lpx4MABsXjxYtGjRw8xZcqU4O28+OKLIj8/X/z2t78V27ZtE59//rl46aWXxDPPPCOEUBZMlpeXi5tvvll8+eWX4p133hH9+/ePuOYhdC2XEMqah+9///th3+vdu3dw8XkAAPHGG28IIYR45JFHxKJFi8SOHTvE5s2bxRVXXCHGjRun5eHNSQwPEVxxxRXisssui/izdevWCQBi06ZN4quvvhIARO/evTvs+GVZFs8++6wYNGiQsNvtoqKiQsyYMUOsWLEi7HJz5swRZ599tsjLyxOFhYXi/PPPj7jSd/ny5WLChAnC6XSK0tJSMWPGjOALx+/3i8cff1z07t1b2O120atXL/Hkk08Gr7tq1SoxfPhwkZeXJ84//3zxj3/8I2Kr5sKFC0W/fv2E0+kU06dPF/v27UviUcwss7Z7ZjRAMDxkrXTs0wLhIfDHarWKnj17im9/+9uirq4u7LZeeeUVMWrUKOFwOETnzp3FBRdcIP75z38Gf7527VoxcuRI4XA4xKhRo8TChQtTFh4ee+wxMWTIEJGfny/KysrEVVddJXbv3q3iUc1tHMlNmDdvHu69917U19dnelNSwi8LCMA00z2FXmsgtI7qTmQkN9c6EOUkrnmgrGe2eRq6rYHg2gciShGGB8oZZmr31CVAMDwQUYrwsAXlNFkIyAKGbfdM+hCGlsMKWg9b8JAFUc5i5YFymtHbPZOuQEiSEgqIiHTEk0QRoePJp/xtJ5+yWjL/yTolJ5JKFqsORDmN4YGoHYukVCJEW4hQvpfZQxpJBQiLhW/2RKQrhgeiKEKrEYHDGZls90wqQDA8EJGOGB6IVAgcvpAzXI1IOEDoOe+CQYQo53HBJJEGFkmCNcPtngktomTbJhHpiJUHogRkerpnQhUIVh2ISCesPBAlKdLJp9LR7qm5AsHqAxHphJUHIp1kot1TcwUimcoBqw5E1IbhgSgF0tnuqSlA6LlwkohyFg9bEKWQ1LbA0mqRUrrAUvUhDB66ICIdsPJAlCaBwxepqkaorkDwPBFElCRWHojSTEphu6eqCgTnXRBRklh5IMqQVLV76j4Lg1UHImqHlQciA4jU7plMNSJuBSIw74KIKAEMD0QGEjikYWtbH+GTz6yPSOS2YgYIhgciShAPWxAZlB7tnjEPYahp2+QhCyKKgJUHIoNLtt0zagWCbZtElCBWHohMJNF2z6gVCFYdiCgBrDwQmVAi7Z4RKxCsPhBRAlh5IDIxre2eESsQkSoMrDoQUQwMD0RZInSBpSyUvy2S8v1QHQIEqw9EpBEPWxBlGTXtnmGHMBgeiEgjhgeiLBZ68il/W4gIhIYOASKAhyyIKA4etiDKAe3XRvjlM4c0Aoc5Fn3RjMMnvbhwkAXDu1szu8FEZGiSUDXHl4iyTSA0AMAP3jmFRV+5lIWWAF6+oQsm9HZmdPuIyLh42IIoRwXWRjS6ZCz6ygVAafsUAF7+rDmzG0dEhsbwQJTj7FYJoSscJABOG9c8EFF0DA9EOa7IacHsC4pDvpbwnfOKMrhFRGR0XPNARACAr+q8qD3tx+gqO8oKuGCSiKJjeCAiIiJNeNiCiIiINGF4ICIiIk0YHoiIiEgThgciIiLShOGBiIiINGF4ICIiIk0YHoiIiEgThgciIiLShOGBiIiINGF4ICIiIk0YHoiIiEgThgciIiLShOGBiIiINGF4ICIiIk0YHoiIiEgThgciIiLShOGBiIiINGF4ICIiIk0YHogIF154Ie69917D3A4RGRvDA1GGzZo1C5IkQZIkOBwO9O/fHz//+c/h8/kyvWlRLV++HJIkob6+Puz7//znP/HYY49lZqOIKG1smd4AIgIuueQSzJ07F263G4sXL8Z3v/td2O12/OhHP8r0pmlSVlaW6U0gojRg5YHIAJxOJ7p164bevXvjrrvuwvTp0/HWW2/h1KlTuOWWW9C5c2cUFBTg0ksvxY4dO4LXmzdvHkpLS7Fo0SIMGDAAeXl5mDFjBg4cOBC8zKxZs3D11VeH3d+9996LCy+8MOr2/PWvf8U555yD4uJidOvWDTfddBPq6uoAAHv37sWUKVMAAJ07d4YkSZg1axaAjoct1G7/u+++iyFDhqCoqAiXXHIJamtrE3wkiSgdGB6IDCg/Px8ejwezZs3C+vXr8dZbb2Ht2rUQQuCyyy6D1+sNXralpQVPPPEEFixYgNWrV6O+vh5f//rXk7p/r9eLxx57DJs2bcKiRYuwd+/eYECorq7GwoULAQDbtm1DbW0tfvvb30a8HbXb//TTT+Ovf/0rPvzwQ+zfvx+zZ89OavuJKLV42ILIQIQQWLp0Kd59911ceumlWLRoEVavXo0JEyYAAF555RVUV1dj0aJFuO666wAob/TPP/88zj33XADA/PnzMWTIEHz88ccYN25cQttx2223Bf/dr18/PPfccxg7diyamppQVFQUPDzRtWtXlJaWRryNHTt24K233lK1/X/84x9RU1MDALj77rvx85//PKHtJqL0YOWByADefvttFBUVIS8vD5deeiluuOEGzJo1CzabLRgKAKBLly4YNGgQtmzZEvyezWbD2LFjg18PHjwYpaWlYZfRasOGDbjyyivRq1cvFBcXY/LkyQCA/fv3q76NLVu2qNr+goKCYHAAgKqqquAhEiIyJoYHIgOYMmUKNm7ciB07dqC1tRXz58+HJEm63LbFYoEQIux7oYcN2mtubsaMGTNQUlKCV155BZ988gneeOMNAIDH49Flm0LZ7fawryVJ6rC9RGQsDA9EBlBYWIj+/fujV69esNmUo4lDhgyBz+fDunXrgpc7ceIEtm3bhqFDhwa/5/P5sH79+uDX27ZtQ319PYYMGQIAqKio6LAAcePGjVG3ZevWrThx4gR+8Ytf4Pzzz8fgwYM7VAIcDgcAwO/3R70dtdtPRObD8EBkUAMGDMBVV12Fb3/721i1ahU2bdqEm2++GT169MBVV10VvJzdbsf3vvc9rFu3Dhs2bMCsWbNw3nnnBdc7TJ06FevXr8eCBQuwY8cO/PSnP8XmzZuj3m+vXr3gcDjwu9/9Drt378Zbb73V4dwNvXv3hiRJePvtt3Hs2DE0NTUlvP1EZD4MD0QGNnfuXJx99tm44oorMH78eAghsHjx4rBSf0FBAR588EHcdNNNmDhxIoqKivDaa68Ffz5jxgw88sgjeOCBBzB27FicPn0at9xyS9T7rKiowLx58/CPf/wDQ4cOxS9+8Qs8/fTTYZfp0aMHfvazn+Ghhx5CZWUl7r777oS3n4jMRxI8uEhkWvPmzcO9997b4UyPRESpxMoDERERacLwQERERJrwsAURERFpwsoDERERacLwQERERJowPBAREZEmDA9ERESkCcMDERERacLwQERERJowPBAREZEmDA9ERESkCcMDERERacLwQERERJowPBAREZEmDA9ERESkCcMDERERafL/AeNoaqEWG7oaAAAAAElFTkSuQmCC"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -395,7 +409,7 @@
       "text/plain": [
        "<Figure size 600x600 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -403,19 +417,31 @@
    ],
    "execution_count": 7
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "The network plots show like the force and waterfall plots what features interact with each other and how strong these interactions are. The network plot is particularly useful when the number of features is larger and the force plot does not contain enough information to be interpretable. Here, the network plot for the Möebius transform is slighlty different to the 2-SII plot. So the true functional decomposition of the game (i.e. explanation) is different than the aggregated representation in the second order Shapley interactions. This indicates that interactions higher than second order are important for the explanation of the model's prediction."
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
    "source": [
     "### SI Graph Plot\n",
-    "The SI graph plot can be considered the big brother of the network plot in that it too can plot second order interactions, but also all higher-order interactions."
+    "The SI graph plot can be considered the more general version of the network plot in that it can **visualize all higher-order interactions**.\n",
+    "The SI graph plot visualizes all interactions as a graph where the nodes are the features and the edges are the interactions between the features.\n",
+    "Interactions between **more than two features** are visualized as a **hyper-edge**.\n",
+    "Again, the color scheme is the same as for the network plot (red for positive interactions, blue for negative interactions).\n",
+    "The strength of an interaction is encoded in the width of the edge connecting the two features. The strength of a first-order interaction is encoded in the size of the node for the respective feature.\n",
+    "The transparency of the edge/node is used to encode the strength of the interaction/feature attribution.\n",
+    "\n",
+    "The following code will plot the SI graph plots for the SV, 2-SII, and Moebius transforms:"
    ]
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:48:05.172742Z",
-     "start_time": "2024-10-23T14:47:59.844686Z"
+     "end_time": "2024-10-24T12:25:34.899598Z",
+     "start_time": "2024-10-24T12:25:28.557957Z"
     }
    },
    "cell_type": "code",
@@ -438,7 +464,7 @@
       "text/plain": [
        "<Figure size 700x700 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -448,7 +474,7 @@
       "text/plain": [
        "<Figure size 700x700 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -458,7 +484,7 @@
       "text/plain": [
        "<Figure size 700x700 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -466,6 +492,22 @@
    ],
    "execution_count": 8
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "**Interpretation of the SI graph plots.**\n",
+    "The first graph plot shows the SV similarly as the force plots and waterfall plots (AveOccup) is the most influential and negative (large blue node size).\n",
+    "The *Latitude* (Lat.) feature is positive (red large-ish node). \n",
+    "In the 2-SII graph plot, again all interactions are plotted. This representation is the same as the network plot. Only the scaling can be a bit different as sizes are differently computed.\n",
+    "Notably, in the last graph plot for the Möbius transform (the full functional decomposition), all interactions are plotted. \n",
+    "Next to the first- and second-order interactions hyper-edges connecting various features can be seen.\n",
+    "For example, there is a sizable positive third order interaction between Longitude (Lon.), Latitude (Lat.), and MedianIncome (MI). \n",
+    "A positive fourth order interaction including the same three features exists with the HouseAge (HA) feature.\n",
+    "In summary, the Möbius graph plot shows how many interactions are necessary to fully explain the model's prediction at this point. \n",
+    "Still, it remains a challenge to interpret the graph plot in its entirety.\n"
+   ]
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
@@ -479,8 +521,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:52:18.032596Z",
-     "start_time": "2024-10-23T14:51:24.028508Z"
+     "end_time": "2024-10-24T12:32:19.966897Z",
+     "start_time": "2024-10-24T12:25:34.901599Z"
     }
    },
    "cell_type": "code",
@@ -497,7 +539,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 20/20 [00:52<00:00,  2.64s/it]\n"
+      "100%|██████████| 20/20 [06:39<00:00, 19.95s/it]\n"
      ]
     }
    ],
@@ -506,8 +548,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-10-23T14:52:18.302568Z",
-     "start_time": "2024-10-23T14:52:18.034635Z"
+     "end_time": "2024-10-24T12:32:20.139865Z",
+     "start_time": "2024-10-24T12:32:19.968887Z"
     }
    },
    "cell_type": "code",
@@ -518,7 +560,7 @@
       "text/plain": [
        "<Figure size 800x650 with 1 Axes>"
       ],
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"

From 6ece2f387955150c2ee07d008dc88e0c6df72cc5 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Thu, 24 Oct 2024 15:39:56 +0200
Subject: [PATCH 06/11] adds unit test for abbreviate features

---
 tests/tests_plots/test_plot_utils.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 tests/tests_plots/test_plot_utils.py

diff --git a/tests/tests_plots/test_plot_utils.py b/tests/tests_plots/test_plot_utils.py
new file mode 100644
index 00000000..591f28bb
--- /dev/null
+++ b/tests/tests_plots/test_plot_utils.py
@@ -0,0 +1,24 @@
+"""This module contains tests for the plot.utils module."""
+
+from shapiq.plot.utils import abbreviate_feature_names
+
+
+def test_abbreviate():
+    """Tests the abbreviate_feature_names function."""
+
+    # test with all cases
+    feature_names = [
+        # seperators
+        "feature_A",
+        "feature-B",
+        "feature.C",
+        "feature D",
+        # seperators with extra dot at the end should not be included
+        "feature E.",
+        # capital letters
+        "CapitalLetters",
+        # normal base case
+        "longlowercase",
+    ]
+    expected = ["FA", "FB", "FC", "FD", "FE", "CL", "lon."]
+    assert abbreviate_feature_names(feature_names) == expected

From e17a450cc2b6c0178de4397a8c77fcf76d503282 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Thu, 24 Oct 2024 16:09:22 +0200
Subject: [PATCH 07/11] fixed feature_names being None

---
 shapiq/plot/bar.py   | 15 ++++++---------
 shapiq/plot/utils.py |  3 ++-
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/shapiq/plot/bar.py b/shapiq/plot/bar.py
index 281440df..01ec8b78 100644
--- a/shapiq/plot/bar.py
+++ b/shapiq/plot/bar.py
@@ -15,9 +15,9 @@
 def bar_plot(
     list_of_interaction_values: list[InteractionValues],
     feature_names: Optional[np.ndarray] = None,
-    show: bool = True,
+    show: bool = False,
     **kwargs,
-) -> plt.Axes:
+) -> Optional[plt.Axes]:
     """Draws interaction values on a bar plot.
 
     Requires the ``shap`` Python package to be installed.
@@ -55,11 +55,8 @@ def bar_plot(
         feature_names=_labels,
     )
 
-    if show:
-        ax = shap.plots.bar(explanation, **kwargs, show=False)
-        ax.set_xlabel("mean(|Shapley Interaction value|)")
-        plt.show()
-    else:
-        ax = shap.plots.bar(explanation, **kwargs, show=False)
-        ax.set_xlabel("mean(|Shapley Interaction value|)")
+    ax = shap.plots.bar(explanation, **kwargs, show=False)
+    ax.set_xlabel("mean(|Shapley Interaction value|)")
+    if not show:
         return ax
+    plt.show()
diff --git a/shapiq/plot/utils.py b/shapiq/plot/utils.py
index 4eecfce4..0c7b10b0 100644
--- a/shapiq/plot/utils.py
+++ b/shapiq/plot/utils.py
@@ -29,7 +29,8 @@ def get_interaction_values_and_feature_names(
         A tuple containing the SHAP values and the corresponding labels.
     """
     feature_names = copy.deepcopy(feature_names)
-    feature_names = abbreviate_feature_names(feature_names)
+    if feature_names is not None:
+        feature_names = abbreviate_feature_names(feature_names)
     _values_dict = {}
     for i in range(1, interaction_values.max_order + 1):
         _values_dict[i] = interaction_values.get_n_order_values(i)

From 859d526c8c66a79faaeda74e9fc74011aa90e02d Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Thu, 24 Oct 2024 16:26:40 +0200
Subject: [PATCH 08/11] Delete .github/workflows/autoupdate.yml

---
 .github/workflows/autoupdate.yml | 33 --------------------------------
 1 file changed, 33 deletions(-)
 delete mode 100644 .github/workflows/autoupdate.yml

diff --git a/.github/workflows/autoupdate.yml b/.github/workflows/autoupdate.yml
deleted file mode 100644
index 6393c396..00000000
--- a/.github/workflows/autoupdate.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-# more information to be found here: https://github.com/marketplace/actions/auto-update
-name: autoupdate
-on:
-  push: {}
-jobs:
-  autoupdate:
-    name: autoupdate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: docker://chinthakagodawita/autoupdate-action:v1
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-
-          # if true potential actions are only logged. Good for testing purpose
-          DRY_RUN: "false"
-
-          # if only specific pull request should be updated. Values are: ["all", "labelled", "protected", "auto_merge"].
-          # "labelled" requires the PR_LABELS option, in which the labels are defined which should trigger autoupdates
-          PR_FILTER: "all"
-
-          # PR with thoose labels are not getting updated
-          EXCLUDED_LABELS: "dependencies,wontfix"
-
-          # which commit message should be displayed
-          MERGE_MSG: "Branch was auto-updated."
-
-          RETRY_COUNT: "1"
-
-          # time in ms
-          RETRY_SLEEP: "5000"
-
-          # what to do on merge conflict. if fail it is also reported. options: ["fail", "ignore"]
-          MERGE_CONFLICT_ACTION: "fail"

From b9baa1ef9c6a971aa55beb9c1340b416affee901 Mon Sep 17 00:00:00 2001
From: Theo <49311372+Advueu963@users.noreply.github.com>
Date: Fri, 25 Oct 2024 08:40:39 +0200
Subject: [PATCH 09/11] 190 add a tutorial notebook for data valuation (#243)

---
 docs/source/index.rst                      |   2 +
 docs/source/notebooks/data_valuation.ipynb | 792 +++++++++++++++++++++
 docs/source/notebooks/sv_calculation.ipynb |  84 +++
 3 files changed, 878 insertions(+)
 create mode 100644 docs/source/notebooks/data_valuation.ipynb
 create mode 100644 docs/source/notebooks/sv_calculation.ipynb

diff --git a/docs/source/index.rst b/docs/source/index.rst
index 4aeb4953..f437ef7f 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -30,6 +30,7 @@ Contents
    :maxdepth: 1
    :caption: TUTORIALS
 
+   notebooks/sv_calculation
    notebooks/shapiq_scikit_learn
    notebooks/treeshapiq_lightgbm
    notebooks/visualizing_shapley_interactions
@@ -38,6 +39,7 @@ Contents
    notebooks/conditional_imputer
    notebooks/parallel_computation
    notebooks/benchmark_approximators
+   notebooks/data_valuation
    notebooks/core
 
 .. toctree::
diff --git a/docs/source/notebooks/data_valuation.ipynb b/docs/source/notebooks/data_valuation.ipynb
new file mode 100644
index 00000000..e7b41a59
--- /dev/null
+++ b/docs/source/notebooks/data_valuation.ipynb
@@ -0,0 +1,792 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Shapiq for Data Valuation\n",
+    "On this page we demonstrate two examples for using Shapiq for Data valuation.\n",
+    "The first example demonstrates this for a synthetic dataset, and the second for a real dataset.\n",
+    "In data valuation we are interested given a training and testing dataset to evaluate the contribution of each training point to the model's performance on the test data."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import shapiq\n",
+    "from sklearn.inspection import DecisionBoundaryDisplay\n",
+    "\n",
+    "# Vector Graphics\n",
+    "%matplotlib inline\n",
+    "import matplotlib_inline\n",
+    "from shapiq.plot._config import COLORS_K_SII, RED\n",
+    "\n",
+    "matplotlib_inline.backend_inline.set_matplotlib_formats(\"svg\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:37.434604Z",
+     "start_time": "2024-10-22T16:04:35.731310Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Synthetic Data\n",
+    "In this example we generate a synthetic classification dataset with 2 features, and 22 samples.\n",
+    "The dataset consists of two classes, each with 11 samples.\n",
+    "The data is generated from two multivariate normal distributions with different means and covariances.\n",
+    "This is done in such a way that the two classes are linearly separable.\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:37.540707Z",
+     "start_time": "2024-10-22T16:04:37.438398Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"406.940312pt\" height=\"325.986375pt\" viewBox=\"0 0 406.940312 325.986375\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:37.516569</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 325.986375 \nL 406.940312 325.986375 \nL 406.940312 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \nL 399.740313 22.318125 \nL 42.620313 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_1\">\n    <defs>\n     <path id=\"C0_0_18b8d2132e\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"285.012041\" y=\"183.576191\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"300.652396\" y=\"260.71049\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"290.996996\" y=\"133.110688\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"383.507585\" y=\"256.816041\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"353.967763\" y=\"227.918158\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"156.217011\" y=\"259.737363\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"176.733801\" y=\"51.603542\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"58.85304\" y=\"141.740658\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"132.512735\" y=\"34.414125\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"131.354799\" y=\"46.4566\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"217.6578\" y=\"124.066344\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p3798281eee)\">\n     <use xlink:href=\"#C0_0_18b8d2132e\" x=\"134.80769\" y=\"51.760211\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_2\">\n    <path d=\"M 319.325658 279.334125 \nL 325.325658 273.334125 \nM 319.325658 273.334125 \nL 325.325658 279.334125 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 187.909036 157.352921 \nL 193.909036 151.352921 \nM 187.909036 151.352921 \nL 193.909036 157.352921 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 168.426437 118.632564 \nL 174.426437 112.632564 \nM 168.426437 112.632564 \nL 174.426437 118.632564 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 282.162323 121.123744 \nL 288.162323 115.123744 \nM 282.162323 115.123744 \nL 288.162323 121.123744 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 369.302346 173.719312 \nL 375.302346 167.719312 \nM 369.302346 167.719312 \nL 375.302346 173.719312 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 374.36899 240.271173 \nL 380.36899 234.271173 \nM 374.36899 234.271173 \nL 380.36899 240.271173 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 169.101651 185.469126 \nL 175.101651 179.469126 \nM 169.101651 179.469126 \nL 175.101651 185.469126 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 192.148023 239.679271 \nL 198.148023 233.679271 \nM 192.148023 233.679271 \nL 198.148023 239.679271 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 256.330835 156.764771 \nL 262.330835 150.764771 \nM 256.330835 150.764771 \nL 262.330835 156.764771 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 287.899506 84.323812 \nL 293.899506 78.323812 \nM 287.899506 78.323812 \nL 293.899506 84.323812 \n\" clip-path=\"url(#p3798281eee)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"m2139ea0160\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"53.397575\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- −8 -->\n      <g transform=\"translate(46.026481 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"100.7526\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- −6 -->\n      <g transform=\"translate(93.381506 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"148.107625\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- −4 -->\n      <g transform=\"translate(140.736531 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"195.46265\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- −2 -->\n      <g transform=\"translate(188.091556 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"242.817675\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0 -->\n      <g transform=\"translate(239.636425 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"290.1727\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 2 -->\n      <g transform=\"translate(286.99145 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"337.527725\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 4 -->\n      <g transform=\"translate(334.346475 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#m2139ea0160\" x=\"384.882751\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 6 -->\n      <g transform=\"translate(381.701501 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_9\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(197.520156 316.706687) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-46\" d=\"M 628 4666 \nL 3309 4666 \nL 3309 4134 \nL 1259 4134 \nL 1259 2759 \nL 3109 2759 \nL 3109 2228 \nL 1259 2228 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_9\">\n      <defs>\n       <path id=\"me4ee82c69a\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"283.045937\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- −3 -->\n      <g transform=\"translate(20.878125 286.845155) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"239.922642\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- −2 -->\n      <g transform=\"translate(20.878125 243.721861) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"196.799347\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- −1 -->\n      <g transform=\"translate(20.878125 200.598566) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"153.676052\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0 -->\n      <g transform=\"translate(29.257813 157.475271) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"110.552758\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 1 -->\n      <g transform=\"translate(29.257813 114.351976) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"67.429463\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 2 -->\n      <g transform=\"translate(29.257813 71.228682) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#me4ee82c69a\" x=\"42.620313\" y=\"24.306168\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 3 -->\n      <g transform=\"translate(29.257813 28.105387) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(14.798438 179.034281) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 42.620313 288.430125 \nL 42.620313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 399.740313 288.430125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 42.620313 22.318125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_18\">\n    <!-- Synthetic Classification Data -->\n    <g transform=\"translate(135.01375 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 4863 \nL 1159 4863 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \nL 4122 3641 \nQ 3803 3938 3442 4084 \nQ 3081 4231 2675 4231 \nQ 1875 4231 1450 3742 \nQ 1025 3253 1025 2328 \nQ 1025 1406 1450 917 \nQ 1875 428 2675 428 \nQ 3081 428 3442 575 \nQ 3803 722 4122 1019 \nL 4122 359 \nQ 3791 134 3420 21 \nQ 3050 -91 2638 -91 \nQ 1578 -91 968 557 \nQ 359 1206 359 2328 \nQ 359 3453 968 4101 \nQ 1578 4750 2638 4750 \nQ 3056 4750 3426 4639 \nQ 3797 4528 4122 4306 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-53\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"63.476562\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"122.65625\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"186.035156\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"225.244141\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"288.623047\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"350.146484\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"389.355469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"417.138672\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"472.119141\"/>\n     <use xlink:href=\"#DejaVuSans-43\" x=\"503.90625\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"573.730469\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"601.513672\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"662.792969\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"714.892578\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"766.992188\"/>\n     <use xlink:href=\"#DejaVuSans-66\" x=\"794.775391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"829.980469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"857.763672\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"912.744141\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"974.023438\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1013.232422\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"1041.015625\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1102.197266\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1165.576172\"/>\n     <use xlink:href=\"#DejaVuSans-44\" x=\"1197.363281\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1274.365234\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1335.644531\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1374.853516\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 289.923125 103.70875 \nL 392.740313 103.70875 \nQ 394.740313 103.70875 394.740313 101.70875 \nL 394.740313 29.318125 \nQ 394.740313 27.318125 392.740313 27.318125 \nL 289.923125 27.318125 \nQ 287.923125 27.318125 287.923125 29.318125 \nL 287.923125 101.70875 \nQ 287.923125 103.70875 289.923125 103.70875 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_19\">\n     <!-- Data Points -->\n     <g transform=\"translate(312.78875 38.916562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_16\">\n     <path d=\"M 291.923125 50.094688 \nL 301.923125 50.094688 \nL 311.923125 50.094688 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"mcafe58ed49\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#mcafe58ed49\" x=\"301.923125\" y=\"50.094688\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_20\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(319.923125 53.594688) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_17\">\n     <path d=\"M 291.923125 64.772813 \nL 301.923125 64.772813 \nL 311.923125 64.772813 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m76fe9359f6\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m76fe9359f6\" x=\"301.923125\" y=\"64.772813\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_21\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(319.923125 68.272813) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 291.923125 79.450938 \nL 301.923125 79.450938 \nL 311.923125 79.450938 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m823421d7d3\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #ffb000\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m823421d7d3\" x=\"301.923125\" y=\"79.450938\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_22\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(319.923125 82.950938) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 291.923125 94.129063 \nL 301.923125 94.129063 \nL 311.923125 94.129063 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m14057a9828\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #1e88e5\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m14057a9828\" x=\"301.923125\" y=\"94.129063\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(319.923125 97.629063) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p3798281eee\">\n   <rect x=\"42.620313\" y=\"22.318125\" width=\"357.12\" height=\"266.112\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_synthetic_data(ax, X_train, y_train, X_test, y_test, title):\n",
+    "    ax.set_title(title)\n",
+    "    ax.scatter(\n",
+    "        X_train[:, 0],\n",
+    "        X_train[:, 1],\n",
+    "        c=[COLORS_K_SII[i] for i in y_train],\n",
+    "        label=\"Training Points\",\n",
+    "        marker=\"o\",\n",
+    "    )\n",
+    "    ax.scatter(\n",
+    "        X_test[:, 0],\n",
+    "        X_test[:, 1],\n",
+    "        c=[COLORS_K_SII[i] for i in y_test],\n",
+    "        label=\"Test Points\",\n",
+    "        marker=\"x\",\n",
+    "    )\n",
+    "    # Manually create legend entries\n",
+    "    handles = [\n",
+    "        plt.Line2D(\n",
+    "            [0],\n",
+    "            [0],\n",
+    "            marker=\"o\",\n",
+    "            color=\"w\",\n",
+    "            markerfacecolor=COLORS_K_SII[i],\n",
+    "            markersize=10,\n",
+    "            label=f\"Class {i} (Train)\",\n",
+    "        )\n",
+    "        for i in [1, 2]\n",
+    "    ]\n",
+    "    handles += [\n",
+    "        plt.Line2D(\n",
+    "            [0],\n",
+    "            [0],\n",
+    "            marker=\"x\",\n",
+    "            linewidth=0,\n",
+    "            color=COLORS_K_SII[i],\n",
+    "            markerfacecolor=COLORS_K_SII[i],\n",
+    "            markersize=10,\n",
+    "            label=f\"Class {i} (Test)\",\n",
+    "        )\n",
+    "        for i in [1, 2]\n",
+    "    ]\n",
+    "\n",
+    "    ax.legend(handles=handles, loc=\"upper right\", title=\"Data Points\")\n",
+    "\n",
+    "    ax.set_xlabel(\"Feature 1\")\n",
+    "    ax.set_ylabel(\"Feature 2\")\n",
+    "\n",
+    "\n",
+    "# Meta information\n",
+    "n_samples = 11\n",
+    "n_classes = 2\n",
+    "classes = list(range(1, n_classes + 1))\n",
+    "random_state = 1337\n",
+    "np.random.seed(random_state)\n",
+    "\n",
+    "# parameters for toy data\n",
+    "means = [(3, 0), (-3, 0)]\n",
+    "covs = [np.diag([3, 2]), np.diag([3, 3.5])]\n",
+    "\n",
+    "# Construct the dataset\n",
+    "X = np.vstack(\n",
+    "    [np.random.multivariate_normal(mean, cov, n_samples) for mean, cov in zip(means, covs)]\n",
+    ")\n",
+    "y = np.hstack([np.full(n_samples, i) for i in classes])\n",
+    "\n",
+    "# Build training and test set\n",
+    "n_samples_to_select = 10\n",
+    "random_indices = np.random.choice(X.shape[0], n_samples_to_select, replace=False)\n",
+    "X_test, y_test = X[random_indices], y[random_indices]\n",
+    "X_train, y_train = np.delete(X, random_indices, axis=0), np.delete(y, random_indices, axis=0)\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "plot_synthetic_data(ax, X_train, y_train, X_test, y_test, \"Synthetic Classification Data\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "To apply `shapiq` approximators we need to reformulate the task of data valuation into a cooperative game $(N,\\nu)$.\n",
+    "We define $N$ as the set of training points $N = \\{1, \\ldots, n\\}$ and the characteristic function $$\\nu: 2^N \\rightarrow \\mathbb{R}$$ is then the accuracy the model achieves on the test points (cross) given the training points in $S$.\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "class SyntheticDataValuation(shapiq.Game):\n",
+    "    \"\"\"The synthetic data valuation tasked modeled as a cooperative game.\n",
+    "    Args:\n",
+    "        classifier: A classifier object that has the methods fit and score.\n",
+    "        n_players: The number of players in the game.\n",
+    "        X_test: The test data.\n",
+    "        y_test: The test labels.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, classifier, n_players, X_train, y_train, X_test, y_test):\n",
+    "        self.classifier = classifier\n",
+    "        self.X_train = X_train\n",
+    "        self.y_train = y_train\n",
+    "        self.X_test = X_test\n",
+    "        self.y_test = y_test\n",
+    "\n",
+    "        empty_coalition_value = np.zeros((1, n_players), dtype=bool)\n",
+    "        self.normalization_value = float(self.value_function(empty_coalition_value)[0])\n",
+    "        super().__init__(n_players, normalization_value=self.normalization_value)\n",
+    "\n",
+    "    def value_function(self, coalitions: np.ndarray) -> np.ndarray:\n",
+    "        \"\"\"Compute the value of the coalitions.\n",
+    "        Args:\n",
+    "            coalitions: A numpy matrix of shape (n_coalitions, n_players)\n",
+    "\n",
+    "        Returns:\n",
+    "            A vector of the value of the coalition\n",
+    "        \"\"\"\n",
+    "        values = []\n",
+    "        for coalition in coalitions:\n",
+    "            tmp_X_train = self.X_train[coalition]\n",
+    "            tmp_y_train = self.y_train[coalition]\n",
+    "            if len(tmp_X_train) == 0:\n",
+    "                # If the coalition is empty, the value is zero\n",
+    "                value = 0\n",
+    "            else:\n",
+    "                unique_targets = np.unique(tmp_y_train)\n",
+    "                if len(unique_targets) == 1:\n",
+    "                    # If we only have one class present in training data, we predict this class\n",
+    "                    value = np.mean((self.y_test == unique_targets[0]))\n",
+    "                else:\n",
+    "                    # We have at least two classes, we fit the classifier\n",
+    "                    self.classifier.fit(tmp_X_train, tmp_y_train)\n",
+    "                    value = self.classifier.score(self.X_test, self.y_test)\n",
+    "\n",
+    "            values.append(value)\n",
+    "\n",
+    "        return np.array(values, dtype=float)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:37.551682Z",
+     "start_time": "2024-10-22T16:04:37.549258Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "As our model we choose the `LinearSVC()`from `sklearn`.\n",
+    "To get first insights into the data valuation we can compute the value of the full and empty coalition."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Full coalition value:  1.0\n",
+      "Empty coalition value:  0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.svm import LinearSVC\n",
+    "\n",
+    "classifier = LinearSVC()\n",
+    "n_players = X_train.shape[0]\n",
+    "data_valuation_game = SyntheticDataValuation(\n",
+    "    classifier=classifier,\n",
+    "    n_players=n_players,\n",
+    "    X_train=X_train,\n",
+    "    y_train=y_train,\n",
+    "    X_test=X_test,\n",
+    "    y_test=y_test,\n",
+    ")\n",
+    "\n",
+    "full_coalition = np.ones((1, n_players), dtype=bool)\n",
+    "empty_coalition = np.zeros((1, n_players), dtype=bool)\n",
+    "print(\"Full coalition value: \", data_valuation_game(full_coalition)[0])\n",
+    "print(\"Empty coalition value: \", data_valuation_game(empty_coalition)[0])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:37.577065Z",
+     "start_time": "2024-10-22T16:04:37.554955Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The empty coalition value is $0.0$ as the model has no information about the data.\n",
+    "The full coalition value is $1.0$ as the model is trained on all data points, and they are linearly seperable.\n",
+    "For this we plot the decision boundary of the `LinearSVM` classifier for the training data and the corresponding test data."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"406.940312pt\" height=\"325.986375pt\" viewBox=\"0 0 406.940312 325.986375\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:37.637652</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 325.986375 \nL 406.940312 325.986375 \nL 406.940312 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \nL 399.740313 22.318125 \nL 42.620313 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_1\">\n    <defs>\n     <path id=\"C0_0_ec1338ee01\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"282.457195\" y=\"186.037835\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"297.47155\" y=\"251.713168\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"288.202605\" y=\"143.069419\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"377.010485\" y=\"248.397273\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"348.652986\" y=\"223.79242\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"158.817148\" y=\"250.884607\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"178.512759\" y=\"73.670863\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"65.35014\" y=\"150.417331\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"136.061628\" y=\"59.035082\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"134.950038\" y=\"69.288543\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"217.798787\" y=\"135.368689\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pad6a8996d1)\">\n     <use xlink:href=\"#C0_0_ec1338ee01\" x=\"138.264728\" y=\"73.804257\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_2\">\n    <path d=\"M 315.277346 268.015777 \nL 321.277346 262.015777 \nM 315.277346 262.015777 \nL 321.277346 268.015777 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 189.120635 164.155934 \nL 195.120635 158.155934 \nM 189.120635 158.155934 \nL 195.120635 164.155934 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 170.41782 131.18782 \nL 176.41782 125.18782 \nM 170.41782 125.18782 \nL 176.41782 131.18782 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 279.601462 133.308914 \nL 285.601462 127.308914 \nM 279.601462 127.308914 \nL 285.601462 133.308914 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 363.253733 178.090957 \nL 369.253733 172.090957 \nM 363.253733 172.090957 \nL 369.253733 178.090957 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 368.117586 234.755964 \nL 374.117586 228.755964 \nM 368.117586 228.755964 \nL 374.117586 234.755964 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 171.06601 188.095234 \nL 177.06601 182.095234 \nM 171.06601 182.095234 \nL 177.06601 188.095234 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 193.189957 234.251994 \nL 199.189957 228.251994 \nM 193.189957 228.251994 \nL 199.189957 234.251994 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 254.803872 163.655159 \nL 260.803872 157.655159 \nM 254.803872 157.655159 \nL 260.803872 163.655159 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 285.109016 101.97593 \nL 291.109016 95.97593 \nM 285.109016 95.97593 \nL 291.109016 101.97593 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"mfc28bd72dc\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"60.113028\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- −8 -->\n      <g transform=\"translate(52.741934 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"105.572683\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- −6 -->\n      <g transform=\"translate(98.201589 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"151.032337\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- −4 -->\n      <g transform=\"translate(143.661243 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"196.491992\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- −2 -->\n      <g transform=\"translate(189.120898 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"241.951646\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0 -->\n      <g transform=\"translate(238.770396 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"287.411301\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 2 -->\n      <g transform=\"translate(284.230051 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"332.870955\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 4 -->\n      <g transform=\"translate(329.689705 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#mfc28bd72dc\" x=\"378.33061\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 6 -->\n      <g transform=\"translate(375.14936 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_9\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(197.520156 316.706687) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-46\" d=\"M 628 4666 \nL 3309 4666 \nL 3309 4134 \nL 1259 4134 \nL 1259 2759 \nL 3109 2759 \nL 3109 2228 \nL 1259 2228 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_9\">\n      <defs>\n       <path id=\"me063bc93ff\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"270.730491\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- −3 -->\n      <g transform=\"translate(20.878125 274.52971) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"234.013534\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- −2 -->\n      <g transform=\"translate(20.878125 237.812753) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"197.296577\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- −1 -->\n      <g transform=\"translate(20.878125 201.095796) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"160.57962\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0 -->\n      <g transform=\"translate(29.257813 164.378839) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"123.862663\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 1 -->\n      <g transform=\"translate(29.257813 127.661882) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"87.145706\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 2 -->\n      <g transform=\"translate(29.257813 90.944925) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#me063bc93ff\" x=\"42.620313\" y=\"50.428749\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 3 -->\n      <g transform=\"translate(29.257813 54.227968) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(14.798438 179.034281) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"QuadContourSet_1\">\n    <path d=\"M 265.396244 288.430125 \nL 265.858498 285.742125 \nL 266.271222 283.342138 \nL 266.320751 283.054125 \nL 266.783005 280.366125 \nL 267.245258 277.678125 \nL 267.707511 274.990125 \nL 268.169765 272.302125 \nL 268.632018 269.614125 \nL 269.094272 266.926125 \nL 269.556525 264.238125 \nL 269.878494 262.365878 \nL 270.018779 261.550125 \nL 270.481032 258.862125 \nL 270.943286 256.174125 \nL 271.405539 253.486125 \nL 271.867793 250.798125 \nL 272.330046 248.110125 \nL 272.7923 245.422125 \nL 273.254553 242.734125 \nL 273.485767 241.389617 \nL 273.716806 240.046125 \nL 274.17906 237.358125 \nL 274.641313 234.670125 \nL 275.103567 231.982125 \nL 275.56582 229.294125 \nL 276.028074 226.606125 \nL 276.490327 223.918125 \nL 276.952581 221.230125 \nL 277.09304 220.413356 \nL 277.414834 218.542125 \nL 277.877088 215.854125 \nL 278.339341 213.166125 \nL 278.801594 210.478125 \nL 279.263848 207.790125 \nL 279.726101 205.102125 \nL 280.188355 202.414125 \nL 280.650608 199.726125 \nL 280.700313 199.437096 \nL 281.112862 197.038125 \nL 281.575115 194.350125 \nL 282.037369 191.662125 \nL 282.499622 188.974125 \nL 282.961876 186.286125 \nL 283.424129 183.598125 \nL 283.886383 180.910125 \nL 284.307585 178.460835 \nL 284.348636 178.222125 \nL 284.810889 175.534125 \nL 285.273143 172.846125 \nL 285.735396 170.158125 \nL 286.19765 167.470125 \nL 286.659903 164.782125 \nL 287.122157 162.094125 \nL 287.58441 159.406125 \nL 287.914858 157.484574 \nL 288.046664 156.718125 \nL 288.508917 154.030125 \nL 288.971171 151.342125 \nL 289.433424 148.654125 \nL 289.895678 145.966125 \nL 290.357931 143.278125 \nL 290.820184 140.590125 \nL 291.282438 137.902125 \nL 291.522131 136.508314 \nL 291.744691 135.214125 \nL 292.206945 132.526125 \nL 292.669198 129.838125 \nL 293.131452 127.150125 \nL 293.593705 124.462125 \nL 294.055959 121.774125 \nL 294.518212 119.086125 \nL 294.980466 116.398125 \nL 295.129403 115.532053 \nL 295.442719 113.710125 \nL 295.904973 111.022125 \nL 296.367226 108.334125 \nL 296.829479 105.646125 \nL 297.291733 102.958125 \nL 297.753986 100.270125 \nL 298.21624 97.582125 \nL 298.678493 94.894125 \nL 298.736676 94.555792 \nL 299.140747 92.206125 \nL 299.603 89.518125 \nL 300.065254 86.830125 \nL 300.527507 84.142125 \nL 300.989761 81.454125 \nL 301.452014 78.766125 \nL 301.914268 76.078125 \nL 302.343949 73.579531 \nL 302.376521 73.390125 \nL 302.838774 70.702125 \nL 303.301028 68.014125 \nL 303.763281 65.326125 \nL 304.225535 62.638125 \nL 304.687788 59.950125 \nL 305.150042 57.262125 \nL 305.612295 54.574125 \nL 305.951222 52.603271 \nL 306.074549 51.886125 \nL 306.536802 49.198125 \nL 306.999056 46.510125 \nL 307.461309 43.822125 \nL 307.923562 41.134125 \nL 308.385816 38.446125 \nL 308.848069 35.758125 \nL 309.310323 33.070125 \nL 309.558494 31.62701 \nL 309.772576 30.382125 \nL 310.23483 27.694125 \nL 310.697083 25.006125 \nL 311.159337 22.318125 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #ffb000; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 225.64787 288.430125 \nL 226.110123 285.742125 \nL 226.572377 283.054125 \nL 226.591222 282.944543 \nL 227.03463 280.366125 \nL 227.496884 277.678125 \nL 227.959137 274.990125 \nL 228.421391 272.302125 \nL 228.883644 269.614125 \nL 229.345898 266.926125 \nL 229.808151 264.238125 \nL 230.198494 261.968282 \nL 230.270405 261.550125 \nL 230.732658 258.862125 \nL 231.194911 256.174125 \nL 231.657165 253.486125 \nL 232.119418 250.798125 \nL 232.581672 248.110125 \nL 233.043925 245.422125 \nL 233.506179 242.734125 \nL 233.805767 240.992022 \nL 233.968432 240.046125 \nL 234.430686 237.358125 \nL 234.892939 234.670125 \nL 235.355193 231.982125 \nL 235.817446 229.294125 \nL 236.2797 226.606125 \nL 236.741953 223.918125 \nL 237.204206 221.230125 \nL 237.41304 220.015761 \nL 237.66646 218.542125 \nL 238.128713 215.854125 \nL 238.590967 213.166125 \nL 239.05322 210.478125 \nL 239.515474 207.790125 \nL 239.977727 205.102125 \nL 240.439981 202.414125 \nL 240.902234 199.726125 \nL 241.020313 199.0395 \nL 241.364488 197.038125 \nL 241.826741 194.350125 \nL 242.288994 191.662125 \nL 242.751248 188.974125 \nL 243.213501 186.286125 \nL 243.675755 183.598125 \nL 244.138008 180.910125 \nL 244.600262 178.222125 \nL 244.627585 178.063239 \nL 245.062515 175.534125 \nL 245.524769 172.846125 \nL 245.987022 170.158125 \nL 246.449276 167.470125 \nL 246.911529 164.782125 \nL 247.373783 162.094125 \nL 247.836036 159.406125 \nL 248.234858 157.086979 \nL 248.298289 156.718125 \nL 248.760543 154.030125 \nL 249.222796 151.342125 \nL 249.68505 148.654125 \nL 250.147303 145.966125 \nL 250.609557 143.278125 \nL 251.07181 140.590125 \nL 251.534064 137.902125 \nL 251.842131 136.110718 \nL 251.996317 135.214125 \nL 252.458571 132.526125 \nL 252.920824 129.838125 \nL 253.383078 127.150125 \nL 253.845331 124.462125 \nL 254.307584 121.774125 \nL 254.769838 119.086125 \nL 255.232091 116.398125 \nL 255.449403 115.134457 \nL 255.694345 113.710125 \nL 256.156598 111.022125 \nL 256.618852 108.334125 \nL 257.081105 105.646125 \nL 257.543359 102.958125 \nL 258.005612 100.270125 \nL 258.467866 97.582125 \nL 258.930119 94.894125 \nL 259.056676 94.158197 \nL 259.392373 92.206125 \nL 259.854626 89.518125 \nL 260.316879 86.830125 \nL 260.779133 84.142125 \nL 261.241386 81.454125 \nL 261.70364 78.766125 \nL 262.165893 76.078125 \nL 262.628147 73.390125 \nL 262.663949 73.181936 \nL 263.0904 70.702125 \nL 263.552654 68.014125 \nL 264.014907 65.326125 \nL 264.477161 62.638125 \nL 264.939414 59.950125 \nL 265.401668 57.262125 \nL 265.863921 54.574125 \nL 266.271222 52.205675 \nL 266.326174 51.886125 \nL 266.788428 49.198125 \nL 267.250681 46.510125 \nL 267.712935 43.822125 \nL 268.175188 41.134125 \nL 268.637442 38.446125 \nL 269.099695 35.758125 \nL 269.561949 33.070125 \nL 269.878494 31.229415 \nL 270.024202 30.382125 \nL 270.486456 27.694125 \nL 270.948709 25.006125 \nL 271.410962 22.318125 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: none; stroke: #ff0d57; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 185.899496 288.430125 \nL 186.361749 285.742125 \nL 186.824003 283.054125 \nL 186.911222 282.546947 \nL 187.286256 280.366125 \nL 187.74851 277.678125 \nL 188.210763 274.990125 \nL 188.673016 272.302125 \nL 189.13527 269.614125 \nL 189.597523 266.926125 \nL 190.059777 264.238125 \nL 190.518494 261.570687 \nL 190.52203 261.550125 \nL 190.984284 258.862125 \nL 191.446537 256.174125 \nL 191.908791 253.486125 \nL 192.371044 250.798125 \nL 192.833298 248.110125 \nL 193.295551 245.422125 \nL 193.757805 242.734125 \nL 194.125767 240.594426 \nL 194.220058 240.046125 \nL 194.682311 237.358125 \nL 195.144565 234.670125 \nL 195.606818 231.982125 \nL 196.069072 229.294125 \nL 196.531325 226.606125 \nL 196.993579 223.918125 \nL 197.455832 221.230125 \nL 197.73304 219.618165 \nL 197.918086 218.542125 \nL 198.380339 215.854125 \nL 198.842593 213.166125 \nL 199.304846 210.478125 \nL 199.7671 207.790125 \nL 200.229353 205.102125 \nL 200.691606 202.414125 \nL 201.15386 199.726125 \nL 201.340313 198.641905 \nL 201.616113 197.038125 \nL 202.078367 194.350125 \nL 202.54062 191.662125 \nL 203.002874 188.974125 \nL 203.465127 186.286125 \nL 203.927381 183.598125 \nL 204.389634 180.910125 \nL 204.851888 178.222125 \nL 204.947585 177.665644 \nL 205.314141 175.534125 \nL 205.776394 172.846125 \nL 206.238648 170.158125 \nL 206.700901 167.470125 \nL 207.163155 164.782125 \nL 207.625408 162.094125 \nL 208.087662 159.406125 \nL 208.549915 156.718125 \nL 208.554858 156.689383 \nL 209.012169 154.030125 \nL 209.474422 151.342125 \nL 209.936676 148.654125 \nL 210.398929 145.966125 \nL 210.861183 143.278125 \nL 211.323436 140.590125 \nL 211.785689 137.902125 \nL 212.162131 135.713123 \nL 212.247943 135.214125 \nL 212.710196 132.526125 \nL 213.17245 129.838125 \nL 213.634703 127.150125 \nL 214.096957 124.462125 \nL 214.55921 121.774125 \nL 215.021464 119.086125 \nL 215.483717 116.398125 \nL 215.769403 114.736862 \nL 215.945971 113.710125 \nL 216.408224 111.022125 \nL 216.870478 108.334125 \nL 217.332731 105.646125 \nL 217.794984 102.958125 \nL 218.257238 100.270125 \nL 218.719491 97.582125 \nL 219.181745 94.894125 \nL 219.376676 93.760601 \nL 219.643998 92.206125 \nL 220.106252 89.518125 \nL 220.568505 86.830125 \nL 221.030759 84.142125 \nL 221.493012 81.454125 \nL 221.955266 78.766125 \nL 222.417519 76.078125 \nL 222.879773 73.390125 \nL 222.983949 72.78434 \nL 223.342026 70.702125 \nL 223.804279 68.014125 \nL 224.266533 65.326125 \nL 224.728786 62.638125 \nL 225.19104 59.950125 \nL 225.653293 57.262125 \nL 226.115547 54.574125 \nL 226.5778 51.886125 \nL 226.591222 51.80808 \nL 227.040054 49.198125 \nL 227.502307 46.510125 \nL 227.964561 43.822125 \nL 228.426814 41.134125 \nL 228.889068 38.446125 \nL 229.351321 35.758125 \nL 229.813574 33.070125 \nL 230.198494 30.831819 \nL 230.275828 30.382125 \nL 230.738081 27.694125 \nL 231.200335 25.006125 \nL 231.662588 22.318125 \n\" clip-path=\"url(#pad6a8996d1)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #1e88e5; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 42.620313 288.430125 \nL 42.620313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 399.740313 288.430125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 42.620313 22.318125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_18\">\n    <!-- Decision Boundary -->\n    <g transform=\"translate(164.832813 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-42\" d=\"M 1259 2228 \nL 1259 519 \nL 2272 519 \nQ 2781 519 3026 730 \nQ 3272 941 3272 1375 \nQ 3272 1813 3026 2020 \nQ 2781 2228 2272 2228 \nL 1259 2228 \nz\nM 1259 4147 \nL 1259 2741 \nL 2194 2741 \nQ 2656 2741 2882 2914 \nQ 3109 3088 3109 3444 \nQ 3109 3797 2882 3972 \nQ 2656 4147 2194 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2241 4666 \nQ 2963 4666 3353 4366 \nQ 3744 4066 3744 3513 \nQ 3744 3084 3544 2831 \nQ 3344 2578 2956 2516 \nQ 3422 2416 3680 2098 \nQ 3938 1781 3938 1306 \nQ 3938 681 3513 340 \nQ 3088 0 2303 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-44\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"77.001953\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"138.525391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"193.505859\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"221.289062\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"273.388672\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"301.171875\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"362.353516\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"425.732422\"/>\n     <use xlink:href=\"#DejaVuSans-42\" x=\"457.519531\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"526.123047\"/>\n     <use xlink:href=\"#DejaVuSans-75\" x=\"587.304688\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"650.683594\"/>\n     <use xlink:href=\"#DejaVuSans-64\" x=\"714.0625\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"777.539062\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"838.818359\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"879.931641\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 289.923125 103.70875 \nL 392.740313 103.70875 \nQ 394.740313 103.70875 394.740313 101.70875 \nL 394.740313 29.318125 \nQ 394.740313 27.318125 392.740313 27.318125 \nL 289.923125 27.318125 \nQ 287.923125 27.318125 287.923125 29.318125 \nL 287.923125 101.70875 \nQ 287.923125 103.70875 289.923125 103.70875 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_19\">\n     <!-- Data Points -->\n     <g transform=\"translate(312.78875 38.916562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_16\">\n     <path d=\"M 291.923125 50.094688 \nL 301.923125 50.094688 \nL 311.923125 50.094688 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"ma700b5bf58\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#ma700b5bf58\" x=\"301.923125\" y=\"50.094688\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_20\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(319.923125 53.594688) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \nL 4122 3641 \nQ 3803 3938 3442 4084 \nQ 3081 4231 2675 4231 \nQ 1875 4231 1450 3742 \nQ 1025 3253 1025 2328 \nQ 1025 1406 1450 917 \nQ 1875 428 2675 428 \nQ 3081 428 3442 575 \nQ 3803 722 4122 1019 \nL 4122 359 \nQ 3791 134 3420 21 \nQ 3050 -91 2638 -91 \nQ 1578 -91 968 557 \nQ 359 1206 359 2328 \nQ 359 3453 968 4101 \nQ 1578 4750 2638 4750 \nQ 3056 4750 3426 4639 \nQ 3797 4528 4122 4306 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_17\">\n     <path d=\"M 291.923125 64.772813 \nL 301.923125 64.772813 \nL 311.923125 64.772813 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"mdaf81b7af7\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#mdaf81b7af7\" x=\"301.923125\" y=\"64.772813\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_21\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(319.923125 68.272813) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 291.923125 79.450938 \nL 301.923125 79.450938 \nL 311.923125 79.450938 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"mb6d92973d0\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #ffb000\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#mb6d92973d0\" x=\"301.923125\" y=\"79.450938\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_22\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(319.923125 82.950938) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 291.923125 94.129063 \nL 301.923125 94.129063 \nL 311.923125 94.129063 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m23f747122a\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #1e88e5\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m23f747122a\" x=\"301.923125\" y=\"94.129063\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(319.923125 97.629063) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"pad6a8996d1\">\n   <rect x=\"42.620313\" y=\"22.318125\" width=\"357.12\" height=\"266.112\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "classifier.fit(X_train, y_train)\n",
+    "plot_synthetic_data(ax, X_train, y_train, X_test, y_test, \"Synthetic Classification Data\")\n",
+    "\n",
+    "DecisionBoundaryDisplay.from_estimator(\n",
+    "    classifier,\n",
+    "    X_train,\n",
+    "    plot_method=\"contour\",\n",
+    "    ax=ax,\n",
+    "    levels=[-1, 0, 1],\n",
+    "    linestyles=[\"--\", \"-\", \"--\"],\n",
+    "    colors=[COLORS_K_SII[1], RED.hex, COLORS_K_SII[2]],\n",
+    "    alpha=0.5,\n",
+    ")\n",
+    "ax.set_xlabel(\"Feature 1\")\n",
+    "ax.set_ylabel(\"Feature 2\")\n",
+    "ax.set_title(\"Decision Boundary\")\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:37.657117Z",
+     "start_time": "2024-10-22T16:04:37.567430Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Computing Shapley Values\n",
+    "Now we can compute the Shapley values for the data valuation game.\n",
+    "Intuitively, the Shapley values should all be positive as each training point makes the model more aware of the natural boundarie between the two classes."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"453.23375pt\" height=\"336.713191pt\" viewBox=\"0 0 453.23375 336.713191\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:38.986904</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 336.713191 \nL 453.23375 336.713191 \nL 453.23375 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 50.14375 292.993664 \nL 446.03375 292.993664 \nL 446.03375 22.318125 \nL 50.14375 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 53.442833 288.892519 \nL 79.8355 288.892519 \nL 79.8355 83.835293 \nL 53.442833 83.835293 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 86.433667 288.892519 \nL 112.826333 288.892519 \nL 112.826333 122.493623 \nL 86.433667 122.493623 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 119.4245 288.892519 \nL 145.817167 288.892519 \nL 145.817167 83.835293 \nL 119.4245 83.835293 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 152.415333 288.892519 \nL 178.808 288.892519 \nL 178.808 112.408841 \nL 152.415333 112.408841 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_7\">\n    <path d=\"M 185.406167 288.892519 \nL 211.798833 288.892519 \nL 211.798833 112.408841 \nL 185.406167 112.408841 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_8\">\n    <path d=\"M 218.397 288.892519 \nL 244.789667 288.892519 \nL 244.789667 199.08994 \nL 218.397 199.08994 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_9\">\n    <path d=\"M 251.387833 288.892519 \nL 277.7805 288.892519 \nL 277.7805 199.08994 \nL 251.387833 199.08994 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_10\">\n    <path d=\"M 284.378667 288.892519 \nL 310.771333 288.892519 \nL 310.771333 204.132331 \nL 284.378667 204.132331 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_11\">\n    <path d=\"M 317.3695 288.892519 \nL 343.762167 288.892519 \nL 343.762167 204.132331 \nL 317.3695 204.132331 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_12\">\n    <path d=\"M 350.360333 288.892519 \nL 376.753 288.892519 \nL 376.753 204.132331 \nL 350.360333 204.132331 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_13\">\n    <path d=\"M 383.351167 288.892519 \nL 409.743833 288.892519 \nL 409.743833 224.301894 \nL 383.351167 224.301894 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_14\">\n    <path d=\"M 416.342 288.892519 \nL 442.734667 288.892519 \nL 442.734667 204.132331 \nL 416.342 204.132331 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_15\">\n    <path d=\"M 53.442833 288.892519 \nL 79.8355 288.892519 \nL 79.8355 288.892519 \nL 53.442833 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_16\">\n    <path d=\"M 86.433667 288.892519 \nL 112.826333 288.892519 \nL 112.826333 288.892519 \nL 86.433667 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_17\">\n    <path d=\"M 119.4245 288.892519 \nL 145.817167 288.892519 \nL 145.817167 288.892519 \nL 119.4245 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_18\">\n    <path d=\"M 152.415333 288.892519 \nL 178.808 288.892519 \nL 178.808 288.892519 \nL 152.415333 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_19\">\n    <path d=\"M 185.406167 288.892519 \nL 211.798833 288.892519 \nL 211.798833 288.892519 \nL 185.406167 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_20\">\n    <path d=\"M 218.397 288.892519 \nL 244.789667 288.892519 \nL 244.789667 288.892519 \nL 218.397 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_21\">\n    <path d=\"M 251.387833 288.892519 \nL 277.7805 288.892519 \nL 277.7805 288.892519 \nL 251.387833 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_22\">\n    <path d=\"M 284.378667 288.892519 \nL 310.771333 288.892519 \nL 310.771333 288.892519 \nL 284.378667 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_23\">\n    <path d=\"M 317.3695 288.892519 \nL 343.762167 288.892519 \nL 343.762167 288.892519 \nL 317.3695 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_24\">\n    <path d=\"M 350.360333 288.892519 \nL 376.753 288.892519 \nL 376.753 288.892519 \nL 350.360333 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_25\">\n    <path d=\"M 383.351167 288.892519 \nL 409.743833 288.892519 \nL 409.743833 288.892519 \nL 383.351167 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_26\">\n    <path d=\"M 416.342 288.892519 \nL 442.734667 288.892519 \nL 442.734667 288.892519 \nL 416.342 288.892519 \nz\n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"m76595860d4\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"66.639167\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- 1 -->\n      <g transform=\"translate(60.669639 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"99.63\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- 2 -->\n      <g transform=\"translate(93.660472 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"132.620833\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- 3 -->\n      <g transform=\"translate(126.651305 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"165.611667\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- 4 -->\n      <g transform=\"translate(159.642139 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"198.6025\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 5 -->\n      <g transform=\"translate(192.632972 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-35\" d=\"M 691 4666 \nL 3169 4666 \nL 3169 4134 \nL 1269 4134 \nL 1269 2991 \nQ 1406 3038 1543 3061 \nQ 1681 3084 1819 3084 \nQ 2600 3084 3056 2656 \nQ 3513 2228 3513 1497 \nQ 3513 744 3044 326 \nQ 2575 -91 1722 -91 \nQ 1428 -91 1123 -41 \nQ 819 9 494 109 \nL 494 744 \nQ 775 591 1075 516 \nQ 1375 441 1709 441 \nQ 2250 441 2565 725 \nQ 2881 1009 2881 1497 \nQ 2881 1984 2565 2268 \nQ 2250 2553 1709 2553 \nQ 1456 2553 1204 2497 \nQ 953 2441 691 2322 \nL 691 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-35\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"231.593333\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 6 -->\n      <g transform=\"translate(225.623805 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"264.584167\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 7 -->\n      <g transform=\"translate(258.614639 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-37\" d=\"M 525 4666 \nL 3525 4666 \nL 3525 4397 \nL 1831 0 \nL 1172 0 \nL 2766 4134 \nL 525 4134 \nL 525 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-37\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"297.575\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 8 -->\n      <g transform=\"translate(291.605472 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-38\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_9\">\n     <g id=\"line2d_9\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"330.565833\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_9\">\n      <!-- 9 -->\n      <g transform=\"translate(324.596305 309.865538) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-39\" d=\"M 703 97 \nL 703 672 \nQ 941 559 1184 500 \nQ 1428 441 1663 441 \nQ 2288 441 2617 861 \nQ 2947 1281 2994 2138 \nQ 2813 1869 2534 1725 \nQ 2256 1581 1919 1581 \nQ 1219 1581 811 2004 \nQ 403 2428 403 3163 \nQ 403 3881 828 4315 \nQ 1253 4750 1959 4750 \nQ 2769 4750 3195 4129 \nQ 3622 3509 3622 2328 \nQ 3622 1225 3098 567 \nQ 2575 -91 1691 -91 \nQ 1453 -91 1209 -44 \nQ 966 3 703 97 \nz\nM 1959 2075 \nQ 2384 2075 2632 2365 \nQ 2881 2656 2881 3163 \nQ 2881 3666 2632 3958 \nQ 2384 4250 1959 4250 \nQ 1534 4250 1286 3958 \nQ 1038 3666 1038 3163 \nQ 1038 2656 1286 2365 \nQ 1534 2075 1959 2075 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-39\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_10\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"363.556667\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- 10 -->\n      <g transform=\"translate(353.088172 314.364504) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_11\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"396.5475\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- 11 -->\n      <g transform=\"translate(386.079005 314.364504) rotate(-45) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_12\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#m76595860d4\" x=\"429.538333\" y=\"292.993664\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- 12 -->\n      <g transform=\"translate(419.069838 314.364504) rotate(-45) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_13\">\n     <!-- Data Point -->\n     <g transform=\"translate(222.150469 327.433503) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_13\">\n      <defs>\n       <path id=\"m07fa6206ea\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"288.892519\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 0.00 -->\n      <g transform=\"translate(20.878125 292.691738) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2e\" d=\"M 684 794 \nL 1344 794 \nL 1344 0 \nL 684 0 \nL 684 794 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"258.638175\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 0.02 -->\n      <g transform=\"translate(20.878125 262.437393) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"228.38383\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 0.04 -->\n      <g transform=\"translate(20.878125 232.183048) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_16\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"198.129485\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_17\">\n      <!-- 0.06 -->\n      <g transform=\"translate(20.878125 201.928704) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_17\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"167.87514\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_18\">\n      <!-- 0.08 -->\n      <g transform=\"translate(20.878125 171.674359) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_18\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"137.620795\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_19\">\n      <!-- 0.10 -->\n      <g transform=\"translate(20.878125 141.420014) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_19\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"107.36645\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_20\">\n      <!-- 0.12 -->\n      <g transform=\"translate(20.878125 111.165669) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_8\">\n     <g id=\"line2d_20\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"77.112105\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_21\">\n      <!-- 0.14 -->\n      <g transform=\"translate(20.878125 80.911324) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_9\">\n     <g id=\"line2d_21\">\n      <g>\n       <use xlink:href=\"#m07fa6206ea\" x=\"50.14375\" y=\"46.85776\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_22\">\n      <!-- 0.16 -->\n      <g transform=\"translate(20.878125 50.656979) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- Shapley Value -->\n     <g transform=\"translate(14.798438 192.982457) rotate(-90) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 4863 \nL 1159 4863 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-70\" d=\"M 1159 525 \nL 1159 -1331 \nL 581 -1331 \nL 581 3500 \nL 1159 3500 \nL 1159 2969 \nQ 1341 3281 1617 3432 \nQ 1894 3584 2278 3584 \nQ 2916 3584 3314 3078 \nQ 3713 2572 3713 1747 \nQ 3713 922 3314 415 \nQ 2916 -91 2278 -91 \nQ 1894 -91 1617 61 \nQ 1341 213 1159 525 \nz\nM 3116 1747 \nQ 3116 2381 2855 2742 \nQ 2594 3103 2138 3103 \nQ 1681 3103 1420 2742 \nQ 1159 2381 1159 1747 \nQ 1159 1113 1420 752 \nQ 1681 391 2138 391 \nQ 2594 391 2855 752 \nQ 3116 1113 3116 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-56\" d=\"M 1831 0 \nL 50 4666 \nL 709 4666 \nL 2188 738 \nL 3669 4666 \nL 4325 4666 \nL 2547 0 \nL 1831 0 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-53\"/>\n      <use xlink:href=\"#DejaVuSans-68\" x=\"63.476562\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"126.855469\"/>\n      <use xlink:href=\"#DejaVuSans-70\" x=\"188.134766\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"251.611328\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"279.394531\"/>\n      <use xlink:href=\"#DejaVuSans-79\" x=\"340.917969\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"400.097656\"/>\n      <use xlink:href=\"#DejaVuSans-56\" x=\"431.884766\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"492.542969\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"553.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"581.605469\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"644.984375\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"line2d_22\">\n    <path d=\"M 50.14375 288.892519 \nL 446.03375 288.892519 \n\" clip-path=\"url(#p538b23c54a)\" style=\"fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_27\">\n    <path d=\"M 50.14375 292.993664 \nL 50.14375 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_28\">\n    <path d=\"M 446.03375 292.993664 \nL 446.03375 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_29\">\n    <path d=\"M 50.14375 292.993664 \nL 446.03375 292.993664 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_30\">\n    <path d=\"M 50.14375 22.318125 \nL 446.03375 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_24\">\n    <!-- Shapley Values for Synthetic (Training) Data -->\n    <g transform=\"translate(115.6875 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-67\" d=\"M 2906 1791 \nQ 2906 2416 2648 2759 \nQ 2391 3103 1925 3103 \nQ 1463 3103 1205 2759 \nQ 947 2416 947 1791 \nQ 947 1169 1205 825 \nQ 1463 481 1925 481 \nQ 2391 481 2648 825 \nQ 2906 1169 2906 1791 \nz\nM 3481 434 \nQ 3481 -459 3084 -895 \nQ 2688 -1331 1869 -1331 \nQ 1566 -1331 1297 -1286 \nQ 1028 -1241 775 -1147 \nL 775 -588 \nQ 1028 -725 1275 -790 \nQ 1522 -856 1778 -856 \nQ 2344 -856 2625 -561 \nQ 2906 -266 2906 331 \nL 2906 616 \nQ 2728 306 2450 153 \nQ 2172 0 1784 0 \nQ 1141 0 747 490 \nQ 353 981 353 1791 \nQ 353 2603 747 3093 \nQ 1141 3584 1784 3584 \nQ 2172 3584 2450 3431 \nQ 2728 3278 2906 2969 \nL 2906 3500 \nL 3481 3500 \nL 3481 434 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-53\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"63.476562\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"126.855469\"/>\n     <use xlink:href=\"#DejaVuSans-70\" x=\"188.134766\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"251.611328\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"279.394531\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"340.917969\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"400.097656\"/>\n     <use xlink:href=\"#DejaVuSans-56\" x=\"431.884766\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"492.542969\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"553.822266\"/>\n     <use xlink:href=\"#DejaVuSans-75\" x=\"581.605469\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"644.984375\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"706.507812\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"758.607422\"/>\n     <use xlink:href=\"#DejaVuSans-66\" x=\"790.394531\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"825.599609\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"886.78125\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"927.894531\"/>\n     <use xlink:href=\"#DejaVuSans-53\" x=\"959.681641\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"1023.158203\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1082.337891\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1145.716797\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"1184.925781\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"1248.304688\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1309.828125\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1349.037109\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"1376.820312\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1431.800781\"/>\n     <use xlink:href=\"#DejaVuSans-28\" x=\"1463.587891\"/>\n     <use xlink:href=\"#DejaVuSans-54\" x=\"1502.601562\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"1548.935547\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1590.048828\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1651.328125\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1679.111328\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1742.490234\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1770.273438\"/>\n     <use xlink:href=\"#DejaVuSans-67\" x=\"1833.652344\"/>\n     <use xlink:href=\"#DejaVuSans-29\" x=\"1897.128906\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1936.142578\"/>\n     <use xlink:href=\"#DejaVuSans-44\" x=\"1967.929688\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"2044.931641\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"2106.210938\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"2145.419922\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_31\">\n     <path d=\"M 213.108281 44.99625 \nL 283.069219 44.99625 \nQ 285.069219 44.99625 285.069219 42.99625 \nL 285.069219 29.318125 \nQ 285.069219 27.318125 283.069219 27.318125 \nL 213.108281 27.318125 \nQ 211.108281 27.318125 211.108281 29.318125 \nL 211.108281 42.99625 \nQ 211.108281 44.99625 213.108281 44.99625 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"patch_32\">\n     <path d=\"M 215.108281 38.916562 \nL 235.108281 38.916562 \nL 235.108281 31.916562 \nL 215.108281 31.916562 \nz\n\" style=\"fill: #d81b60; stroke: #000000; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_25\">\n     <!-- Order 1 -->\n     <g transform=\"translate(243.108281 38.916562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-4f\" d=\"M 2522 4238 \nQ 1834 4238 1429 3725 \nQ 1025 3213 1025 2328 \nQ 1025 1447 1429 934 \nQ 1834 422 2522 422 \nQ 3209 422 3611 934 \nQ 4013 1447 4013 2328 \nQ 4013 3213 3611 3725 \nQ 3209 4238 2522 4238 \nz\nM 2522 4750 \nQ 3503 4750 4090 4092 \nQ 4678 3434 4678 2328 \nQ 4678 1225 4090 567 \nQ 3503 -91 2522 -91 \nQ 1538 -91 948 565 \nQ 359 1222 359 2328 \nQ 359 3434 948 4092 \nQ 1538 4750 2522 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-4f\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"78.710938\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"118.074219\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"181.550781\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"243.074219\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"284.1875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"315.974609\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p538b23c54a\">\n   <rect x=\"50.14375\" y=\"22.318125\" width=\"395.89\" height=\"270.675539\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Compute Shapley values with the ShapIQ approximator for the game function\n",
+    "exactComputer = shapiq.ExactComputer(n_players=n_players, game_fun=data_valuation_game)\n",
+    "sv_values = exactComputer(\"SV\")\n",
+    "sv_values.plot_stacked_bar(\n",
+    "    title=\"Shapley Values for Synthetic (Training) Data\",\n",
+    "    xlabel=\"Data Point\",\n",
+    "    ylabel=\"Shapley Value\",\n",
+    ")\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:39.005886Z",
+     "start_time": "2024-10-22T16:04:37.657523Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The Shapley values are all positive indicating that all data points have a positive impact on the model's performance.\n",
+    "Interestingly the Shapley values indicate the first five data points to be more important.\n",
+    "\n",
+    "To understand this better notice that we have *four* blue test points and *six* orange test points.\n",
+    "If we are provided with a training set that contains only orange points, the model will have an accuracy of $0.6$.\n",
+    "On the other side, if we are provided with a training set that contains only blue points, the model will have an accuracy of $0.4$.\n",
+    "Thus having orange points in the training set is more important for the model's performance.\n",
+    "Meaning that the orange points are more important regarding accuracy.\n",
+    "These are exactly the first five data points, which are all orange.\n",
+    "\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"407.888835pt\" height=\"325.986375pt\" viewBox=\"0 0 407.888835 325.986375\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:39.045802</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 325.986375 \nL 407.888835 325.986375 \nL 407.888835 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \nL 399.740313 22.318125 \nL 42.620313 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_1\">\n    <defs>\n     <path id=\"C0_0_1388fd0a60\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"285.012041\" y=\"183.576191\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"300.652396\" y=\"260.71049\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"290.996996\" y=\"133.110688\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"383.507585\" y=\"256.816041\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"353.967763\" y=\"227.918158\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"156.217011\" y=\"259.737363\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"176.733801\" y=\"51.603542\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"58.85304\" y=\"141.740658\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"132.512735\" y=\"34.414125\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"131.354799\" y=\"46.4566\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"217.6578\" y=\"124.066344\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p1c269bf94b)\">\n     <use xlink:href=\"#C0_0_1388fd0a60\" x=\"134.80769\" y=\"51.760211\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_2\">\n    <path d=\"M 319.325658 279.334125 \nL 325.325658 273.334125 \nM 319.325658 273.334125 \nL 325.325658 279.334125 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 187.909036 157.352921 \nL 193.909036 151.352921 \nM 187.909036 151.352921 \nL 193.909036 157.352921 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 168.426437 118.632564 \nL 174.426437 112.632564 \nM 168.426437 112.632564 \nL 174.426437 118.632564 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 282.162323 121.123744 \nL 288.162323 115.123744 \nM 282.162323 115.123744 \nL 288.162323 121.123744 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 369.302346 173.719312 \nL 375.302346 167.719312 \nM 369.302346 167.719312 \nL 375.302346 173.719312 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 374.36899 240.271173 \nL 380.36899 234.271173 \nM 374.36899 234.271173 \nL 380.36899 240.271173 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 169.101651 185.469126 \nL 175.101651 179.469126 \nM 169.101651 179.469126 \nL 175.101651 185.469126 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 192.148023 239.679271 \nL 198.148023 233.679271 \nM 192.148023 233.679271 \nL 198.148023 239.679271 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 256.330835 156.764771 \nL 262.330835 150.764771 \nM 256.330835 150.764771 \nL 262.330835 156.764771 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 287.899506 84.323812 \nL 293.899506 78.323812 \nM 287.899506 78.323812 \nL 293.899506 84.323812 \n\" clip-path=\"url(#p1c269bf94b)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"m27f9e20c18\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"53.397575\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- −8 -->\n      <g transform=\"translate(46.026481 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"100.7526\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- −6 -->\n      <g transform=\"translate(93.381506 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"148.107625\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- −4 -->\n      <g transform=\"translate(140.736531 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"195.46265\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- −2 -->\n      <g transform=\"translate(188.091556 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"242.817675\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0 -->\n      <g transform=\"translate(239.636425 303.028562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"290.1727\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 2 -->\n      <g transform=\"translate(286.99145 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"337.527725\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 4 -->\n      <g transform=\"translate(334.346475 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#m27f9e20c18\" x=\"384.882751\" y=\"288.430125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 6 -->\n      <g transform=\"translate(381.701501 303.028562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_9\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(197.520156 316.706687) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-46\" d=\"M 628 4666 \nL 3309 4666 \nL 3309 4134 \nL 1259 4134 \nL 1259 2759 \nL 3109 2759 \nL 3109 2228 \nL 1259 2228 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_9\">\n      <defs>\n       <path id=\"m2c692b10c1\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"283.045937\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- −3 -->\n      <g transform=\"translate(20.878125 286.845155) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"239.922642\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- −2 -->\n      <g transform=\"translate(20.878125 243.721861) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"196.799347\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- −1 -->\n      <g transform=\"translate(20.878125 200.598566) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"153.676052\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0 -->\n      <g transform=\"translate(29.257813 157.475271) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"110.552758\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 1 -->\n      <g transform=\"translate(29.257813 114.351976) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"67.429463\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 2 -->\n      <g transform=\"translate(29.257813 71.228682) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#m2c692b10c1\" x=\"42.620313\" y=\"24.306168\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 3 -->\n      <g transform=\"translate(29.257813 28.105387) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(14.798438 179.034281) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 42.620313 288.430125 \nL 42.620313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 399.740313 288.430125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 42.620313 288.430125 \nL 399.740313 288.430125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 42.620313 22.318125 \nL 399.740313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_18\">\n    <!-- Point 1 -->\n    <g transform=\"translate(267.830791 193.576191) scale(0.1 -0.1)\">\n     <defs>\n      <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-50\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"117.859375\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"145.642578\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"209.021484\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"248.230469\"/>\n     <use xlink:href=\"#DejaVuSans-31\" x=\"280.017578\"/>\n    </g>\n   </g>\n   <g id=\"text_19\">\n    <!-- Point 2 -->\n    <g transform=\"translate(283.471146 270.71049) scale(0.1 -0.1)\">\n     <use xlink:href=\"#DejaVuSans-50\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"117.859375\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"145.642578\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"209.021484\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"248.230469\"/>\n     <use xlink:href=\"#DejaVuSans-32\" x=\"280.017578\"/>\n    </g>\n   </g>\n   <g id=\"text_20\">\n    <!-- Point 3 -->\n    <g transform=\"translate(273.815746 143.110688) scale(0.1 -0.1)\">\n     <use xlink:href=\"#DejaVuSans-50\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"117.859375\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"145.642578\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"209.021484\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"248.230469\"/>\n     <use xlink:href=\"#DejaVuSans-33\" x=\"280.017578\"/>\n    </g>\n   </g>\n   <g id=\"text_21\">\n    <!-- Point 4 -->\n    <g transform=\"translate(366.326335 266.816041) scale(0.1 -0.1)\">\n     <use xlink:href=\"#DejaVuSans-50\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"117.859375\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"145.642578\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"209.021484\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"248.230469\"/>\n     <use xlink:href=\"#DejaVuSans-34\" x=\"280.017578\"/>\n    </g>\n   </g>\n   <g id=\"text_22\">\n    <!-- Point 5 -->\n    <g transform=\"translate(336.786513 237.918158) scale(0.1 -0.1)\">\n     <defs>\n      <path id=\"DejaVuSans-35\" d=\"M 691 4666 \nL 3169 4666 \nL 3169 4134 \nL 1269 4134 \nL 1269 2991 \nQ 1406 3038 1543 3061 \nQ 1681 3084 1819 3084 \nQ 2600 3084 3056 2656 \nQ 3513 2228 3513 1497 \nQ 3513 744 3044 326 \nQ 2575 -91 1722 -91 \nQ 1428 -91 1123 -41 \nQ 819 9 494 109 \nL 494 744 \nQ 775 591 1075 516 \nQ 1375 441 1709 441 \nQ 2250 441 2565 725 \nQ 2881 1009 2881 1497 \nQ 2881 1984 2565 2268 \nQ 2250 2553 1709 2553 \nQ 1456 2553 1204 2497 \nQ 953 2441 691 2322 \nL 691 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-50\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"117.859375\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"145.642578\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"209.021484\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"248.230469\"/>\n     <use xlink:href=\"#DejaVuSans-35\" x=\"280.017578\"/>\n    </g>\n   </g>\n   <g id=\"text_23\">\n    <!-- Synthetic Classification Data -->\n    <g transform=\"translate(135.01375 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 4863 \nL 1159 4863 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \nL 4122 3641 \nQ 3803 3938 3442 4084 \nQ 3081 4231 2675 4231 \nQ 1875 4231 1450 3742 \nQ 1025 3253 1025 2328 \nQ 1025 1406 1450 917 \nQ 1875 428 2675 428 \nQ 3081 428 3442 575 \nQ 3803 722 4122 1019 \nL 4122 359 \nQ 3791 134 3420 21 \nQ 3050 -91 2638 -91 \nQ 1578 -91 968 557 \nQ 359 1206 359 2328 \nQ 359 3453 968 4101 \nQ 1578 4750 2638 4750 \nQ 3056 4750 3426 4639 \nQ 3797 4528 4122 4306 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-53\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"63.476562\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"122.65625\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"186.035156\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"225.244141\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"288.623047\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"350.146484\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"389.355469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"417.138672\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"472.119141\"/>\n     <use xlink:href=\"#DejaVuSans-43\" x=\"503.90625\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"573.730469\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"601.513672\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"662.792969\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"714.892578\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"766.992188\"/>\n     <use xlink:href=\"#DejaVuSans-66\" x=\"794.775391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"829.980469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"857.763672\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"912.744141\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"974.023438\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1013.232422\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"1041.015625\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1102.197266\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1165.576172\"/>\n     <use xlink:href=\"#DejaVuSans-44\" x=\"1197.363281\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1274.365234\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1335.644531\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1374.853516\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 289.923125 103.70875 \nL 392.740313 103.70875 \nQ 394.740313 103.70875 394.740313 101.70875 \nL 394.740313 29.318125 \nQ 394.740313 27.318125 392.740313 27.318125 \nL 289.923125 27.318125 \nQ 287.923125 27.318125 287.923125 29.318125 \nL 287.923125 101.70875 \nQ 287.923125 103.70875 289.923125 103.70875 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_24\">\n     <!-- Data Points -->\n     <g transform=\"translate(312.78875 38.916562) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_16\">\n     <path d=\"M 291.923125 50.094688 \nL 301.923125 50.094688 \nL 311.923125 50.094688 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m9cdba1d048\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m9cdba1d048\" x=\"301.923125\" y=\"50.094688\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_25\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(319.923125 53.594688) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_17\">\n     <path d=\"M 291.923125 64.772813 \nL 301.923125 64.772813 \nL 311.923125 64.772813 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m6cd61b3a31\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m6cd61b3a31\" x=\"301.923125\" y=\"64.772813\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_26\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(319.923125 68.272813) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 291.923125 79.450938 \nL 301.923125 79.450938 \nL 311.923125 79.450938 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m5f3dd5a46f\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #ffb000\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m5f3dd5a46f\" x=\"301.923125\" y=\"79.450938\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_27\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(319.923125 82.950938) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 291.923125 94.129063 \nL 301.923125 94.129063 \nL 311.923125 94.129063 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m250925958e\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #1e88e5\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m250925958e\" x=\"301.923125\" y=\"94.129063\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_28\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(319.923125 97.629063) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p1c269bf94b\">\n   <rect x=\"42.620313\" y=\"22.318125\" width=\"357.12\" height=\"266.112\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "plot_synthetic_data(ax, X_train, y_train, X_test, y_test, \"Synthetic Classification Data\")\n",
+    "for i in range(5):\n",
+    "    ax.annotate(\n",
+    "        f\"Point {i+1}\",\n",
+    "        (X_train[i, 0], X_train[i, 1]),\n",
+    "        textcoords=\"offset points\",\n",
+    "        xytext=(0, -10),\n",
+    "        ha=\"center\",\n",
+    "    )\n",
+    "\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:39.066692Z",
+     "start_time": "2024-10-22T16:04:39.013827Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Corrupting the Data\n",
+    "We can now investigate the impact of corrupting the data on the Shapley values.\n",
+    "Currently the Shapley values are less interesting as we have a clear boundary between the two classes.\n",
+    "If we now corrupt the data by adding noise to the labels, the Shapley values should change and identify the corrupted samples."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 1200x800 with 2 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"719.420312pt\" height=\"503.394375pt\" viewBox=\"0 0 719.420312 503.394375\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:39.183419</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 503.394375 \nL 719.420312 503.394375 \nL 719.420312 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 42.620313 465.838125 \nL 346.983949 465.838125 \nL 346.983949 22.318125 \nL 42.620313 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_1\">\n    <defs>\n     <path id=\"C0_0_ffe7bb8c72\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"249.204172\" y=\"291.081568\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"262.53402\" y=\"419.638734\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"254.304986\" y=\"206.972397\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"333.149238\" y=\"413.147985\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"307.973254\" y=\"364.984846\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"139.435681\" y=\"418.016855\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"156.921581\" y=\"71.127154\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"56.455023\" y=\"221.355679\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"119.233172\" y=\"42.478125\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"118.246295\" y=\"62.548916\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"191.799989\" y=\"191.898489\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p009533982d)\">\n     <use xlink:href=\"#C0_0_ffe7bb8c72\" x=\"121.1891\" y=\"71.388269\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_2\">\n    <path d=\"M 278.00555 448.678125 \nL 284.00555 442.678125 \nM 278.00555 442.678125 \nL 284.00555 448.678125 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 166.002748 245.376119 \nL 172.002748 239.376119 \nM 166.002748 239.376119 \nL 172.002748 245.376119 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 149.398259 180.842189 \nL 155.398259 174.842189 \nM 149.398259 174.842189 \nL 155.398259 180.842189 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 246.332253 184.994157 \nL 252.332253 178.994157 \nM 246.332253 178.994157 \nL 252.332253 184.994157 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 320.599319 272.653437 \nL 326.599319 266.653437 \nM 320.599319 266.653437 \nL 326.599319 272.653437 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 324.917481 383.573205 \nL 330.917481 377.573205 \nM 324.917481 377.573205 \nL 330.917481 383.573205 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 149.973726 292.23646 \nL 155.973726 286.23646 \nM 149.973726 286.23646 \nL 155.973726 292.23646 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 169.61552 382.586702 \nL 175.61552 376.586702 \nM 169.61552 376.586702 \nL 175.61552 382.586702 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 224.316781 244.395868 \nL 230.316781 238.395868 \nM 224.316781 238.395868 \nL 230.316781 244.395868 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 251.221898 123.660937 \nL 257.221898 117.660937 \nM 251.221898 117.660937 \nL 257.221898 123.660937 \n\" clip-path=\"url(#p009533982d)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"m959d7fc660\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"51.805479\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- −8 -->\n      <g transform=\"translate(44.434385 480.436562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"92.164876\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- −6 -->\n      <g transform=\"translate(84.793782 480.436562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"132.524272\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- −4 -->\n      <g transform=\"translate(125.153178 480.436562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"172.883668\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- −2 -->\n      <g transform=\"translate(165.512575 480.436562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"213.243065\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0 -->\n      <g transform=\"translate(210.061815 480.436562) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"253.602461\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 2 -->\n      <g transform=\"translate(250.421211 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"293.961858\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 4 -->\n      <g transform=\"translate(290.780608 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"334.321254\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 6 -->\n      <g transform=\"translate(331.140004 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_9\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(171.141974 494.114687) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-46\" d=\"M 628 4666 \nL 3309 4666 \nL 3309 4134 \nL 1259 4134 \nL 1259 2759 \nL 3109 2759 \nL 3109 2228 \nL 1259 2228 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_9\">\n      <defs>\n       <path id=\"m64f241bc6f\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"456.864478\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- −3 -->\n      <g transform=\"translate(20.878125 460.663696) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"384.99232\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- −2 -->\n      <g transform=\"translate(20.878125 388.791538) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"313.120162\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- −1 -->\n      <g transform=\"translate(20.878125 316.919381) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"241.248004\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0 -->\n      <g transform=\"translate(29.257813 245.047223) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"169.375846\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 1 -->\n      <g transform=\"translate(29.257813 173.175065) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"97.503688\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 2 -->\n      <g transform=\"translate(29.257813 101.302907) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"42.620313\" y=\"25.631531\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 3 -->\n      <g transform=\"translate(29.257813 29.430749) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(14.798438 267.738281) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 42.620313 465.838125 \nL 42.620313 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 346.983949 465.838125 \nL 346.983949 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 42.620312 465.838125 \nL 346.983949 465.838125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 42.620312 22.318125 \nL 346.983949 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_18\">\n    <!-- Synthetic Classification Data -->\n    <g transform=\"translate(108.635568 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 4863 \nL 1159 4863 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \nL 4122 3641 \nQ 3803 3938 3442 4084 \nQ 3081 4231 2675 4231 \nQ 1875 4231 1450 3742 \nQ 1025 3253 1025 2328 \nQ 1025 1406 1450 917 \nQ 1875 428 2675 428 \nQ 3081 428 3442 575 \nQ 3803 722 4122 1019 \nL 4122 359 \nQ 3791 134 3420 21 \nQ 3050 -91 2638 -91 \nQ 1578 -91 968 557 \nQ 359 1206 359 2328 \nQ 359 3453 968 4101 \nQ 1578 4750 2638 4750 \nQ 3056 4750 3426 4639 \nQ 3797 4528 4122 4306 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-53\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"63.476562\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"122.65625\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"186.035156\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"225.244141\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"288.623047\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"350.146484\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"389.355469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"417.138672\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"472.119141\"/>\n     <use xlink:href=\"#DejaVuSans-43\" x=\"503.90625\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"573.730469\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"601.513672\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"662.792969\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"714.892578\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"766.992188\"/>\n     <use xlink:href=\"#DejaVuSans-66\" x=\"794.775391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"829.980469\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"857.763672\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"912.744141\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"974.023438\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1013.232422\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"1041.015625\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1102.197266\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1165.576172\"/>\n     <use xlink:href=\"#DejaVuSans-44\" x=\"1197.363281\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1274.365234\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1335.644531\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1374.853516\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 237.166761 103.70875 \nL 339.983949 103.70875 \nQ 341.983949 103.70875 341.983949 101.70875 \nL 341.983949 29.318125 \nQ 341.983949 27.318125 339.983949 27.318125 \nL 237.166761 27.318125 \nQ 235.166761 27.318125 235.166761 29.318125 \nL 235.166761 101.70875 \nQ 235.166761 103.70875 237.166761 103.70875 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_19\">\n     <!-- Data Points -->\n     <g transform=\"translate(260.032386 38.916562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_16\">\n     <path d=\"M 239.166761 50.094687 \nL 249.166761 50.094687 \nL 259.166761 50.094687 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"ma30da575e8\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#ma30da575e8\" x=\"249.166761\" y=\"50.094687\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_20\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(267.166761 53.594687) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_17\">\n     <path d=\"M 239.166761 64.772812 \nL 249.166761 64.772812 \nL 259.166761 64.772812 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m4e1db68579\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m4e1db68579\" x=\"249.166761\" y=\"64.772812\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_21\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(267.166761 68.272812) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 239.166761 79.450937 \nL 249.166761 79.450937 \nL 259.166761 79.450937 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m030b229f55\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #ffb000\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m030b229f55\" x=\"249.166761\" y=\"79.450937\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_22\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(267.166761 82.950937) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 239.166761 94.129062 \nL 249.166761 94.129062 \nL 259.166761 94.129062 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"mcc89ade231\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #1e88e5\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#mcc89ade231\" x=\"249.166761\" y=\"94.129062\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(267.166761 97.629062) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n  <g id=\"axes_2\">\n   <g id=\"patch_8\">\n    <path d=\"M 407.856676 465.838125 \nL 712.220312 465.838125 \nL 712.220312 22.318125 \nL 407.856676 22.318125 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_3\">\n    <defs>\n     <path id=\"C1_0_b6632a0d01\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"614.440536\" y=\"291.081568\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"627.770384\" y=\"419.638734\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"619.54135\" y=\"206.972397\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"698.385602\" y=\"413.147985\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"673.209617\" y=\"364.984846\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"504.672044\" y=\"418.016855\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"522.157944\" y=\"71.127154\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"421.691387\" y=\"221.355679\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"484.469536\" y=\"42.478125\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"483.482659\" y=\"62.548916\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"557.036353\" y=\"191.898489\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p7307dd78d4)\">\n     <use xlink:href=\"#C1_0_b6632a0d01\" x=\"486.425464\" y=\"71.388269\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_4\">\n    <path d=\"M 643.241914 448.678125 \nL 649.241914 442.678125 \nM 643.241914 442.678125 \nL 649.241914 448.678125 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 531.239111 245.376119 \nL 537.239111 239.376119 \nM 531.239111 239.376119 \nL 537.239111 245.376119 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 514.634623 180.842189 \nL 520.634623 174.842189 \nM 514.634623 174.842189 \nL 520.634623 180.842189 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 611.568617 184.994157 \nL 617.568617 178.994157 \nM 611.568617 178.994157 \nL 617.568617 184.994157 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 685.835682 272.653437 \nL 691.835682 266.653437 \nM 685.835682 266.653437 \nL 691.835682 272.653437 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 690.153845 383.573205 \nL 696.153845 377.573205 \nM 690.153845 377.573205 \nL 696.153845 383.573205 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 515.21009 292.23646 \nL 521.21009 286.23646 \nM 515.21009 286.23646 \nL 521.21009 292.23646 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 534.851884 382.586702 \nL 540.851884 376.586702 \nM 534.851884 376.586702 \nL 540.851884 382.586702 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 589.553144 244.395868 \nL 595.553144 238.395868 \nM 589.553144 238.395868 \nL 595.553144 244.395868 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 616.458261 123.660937 \nL 622.458261 117.660937 \nM 616.458261 117.660937 \nL 622.458261 123.660937 \n\" clip-path=\"url(#p7307dd78d4)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_3\">\n    <g id=\"xtick_9\">\n     <g id=\"line2d_20\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"417.041843\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_24\">\n      <!-- −8 -->\n      <g transform=\"translate(409.670749 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_10\">\n     <g id=\"line2d_21\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"457.401239\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_25\">\n      <!-- −6 -->\n      <g transform=\"translate(450.030145 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_11\">\n     <g id=\"line2d_22\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"497.760636\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_26\">\n      <!-- −4 -->\n      <g transform=\"translate(490.389542 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_12\">\n     <g id=\"line2d_23\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"538.120032\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_27\">\n      <!-- −2 -->\n      <g transform=\"translate(530.748938 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_13\">\n     <g id=\"line2d_24\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"578.479428\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_28\">\n      <!-- 0 -->\n      <g transform=\"translate(575.298178 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_14\">\n     <g id=\"line2d_25\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"618.838825\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_29\">\n      <!-- 2 -->\n      <g transform=\"translate(615.657575 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_15\">\n     <g id=\"line2d_26\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"659.198221\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_30\">\n      <!-- 4 -->\n      <g transform=\"translate(656.016971 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_16\">\n     <g id=\"line2d_27\">\n      <g>\n       <use xlink:href=\"#m959d7fc660\" x=\"699.557618\" y=\"465.838125\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_31\">\n      <!-- 6 -->\n      <g transform=\"translate(696.376368 480.436562) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_32\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(536.378338 494.114687) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_4\">\n    <g id=\"ytick_8\">\n     <g id=\"line2d_28\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"456.864478\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_33\">\n      <!-- −3 -->\n      <g transform=\"translate(386.114489 460.663696) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_9\">\n     <g id=\"line2d_29\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"384.99232\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_34\">\n      <!-- −2 -->\n      <g transform=\"translate(386.114489 388.791538) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_10\">\n     <g id=\"line2d_30\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"313.120162\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_35\">\n      <!-- −1 -->\n      <g transform=\"translate(386.114489 316.919381) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_11\">\n     <g id=\"line2d_31\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"241.248004\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_36\">\n      <!-- 0 -->\n      <g transform=\"translate(394.494176 245.047223) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_12\">\n     <g id=\"line2d_32\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"169.375846\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_37\">\n      <!-- 1 -->\n      <g transform=\"translate(394.494176 173.175065) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_13\">\n     <g id=\"line2d_33\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"97.503688\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_38\">\n      <!-- 2 -->\n      <g transform=\"translate(394.494176 101.302907) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_14\">\n     <g id=\"line2d_34\">\n      <g>\n       <use xlink:href=\"#m64f241bc6f\" x=\"407.856676\" y=\"25.631531\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_39\">\n      <!-- 3 -->\n      <g transform=\"translate(394.494176 29.430749) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_40\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(380.034801 267.738281) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"patch_9\">\n    <path d=\"M 407.856676 465.838125 \nL 407.856676 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_10\">\n    <path d=\"M 712.220312 465.838125 \nL 712.220312 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_11\">\n    <path d=\"M 407.856676 465.838125 \nL 712.220312 465.838125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_12\">\n    <path d=\"M 407.856676 22.318125 \nL 712.220312 22.318125 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_41\">\n    <!-- Corrupted Synthetic Classification Data -->\n    <g transform=\"translate(441.811307 16.318125) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-70\" d=\"M 1159 525 \nL 1159 -1331 \nL 581 -1331 \nL 581 3500 \nL 1159 3500 \nL 1159 2969 \nQ 1341 3281 1617 3432 \nQ 1894 3584 2278 3584 \nQ 2916 3584 3314 3078 \nQ 3713 2572 3713 1747 \nQ 3713 922 3314 415 \nQ 2916 -91 2278 -91 \nQ 1894 -91 1617 61 \nQ 1341 213 1159 525 \nz\nM 3116 1747 \nQ 3116 2381 2855 2742 \nQ 2594 3103 2138 3103 \nQ 1681 3103 1420 2742 \nQ 1159 2381 1159 1747 \nQ 1159 1113 1420 752 \nQ 1681 391 2138 391 \nQ 2594 391 2855 752 \nQ 3116 1113 3116 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-43\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"69.824219\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"131.005859\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"170.369141\"/>\n     <use xlink:href=\"#DejaVuSans-75\" x=\"211.482422\"/>\n     <use xlink:href=\"#DejaVuSans-70\" x=\"274.861328\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"338.337891\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"377.546875\"/>\n     <use xlink:href=\"#DejaVuSans-64\" x=\"439.070312\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"502.546875\"/>\n     <use xlink:href=\"#DejaVuSans-53\" x=\"534.333984\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"597.810547\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"656.990234\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"720.369141\"/>\n     <use xlink:href=\"#DejaVuSans-68\" x=\"759.578125\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"822.957031\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"884.480469\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"923.689453\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"951.472656\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1006.453125\"/>\n     <use xlink:href=\"#DejaVuSans-43\" x=\"1038.240234\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" x=\"1108.064453\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1135.847656\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"1197.126953\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"1249.226562\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1301.326172\"/>\n     <use xlink:href=\"#DejaVuSans-66\" x=\"1329.109375\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1364.314453\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"1392.097656\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1447.078125\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1508.357422\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"1547.566406\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"1575.349609\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"1636.53125\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"1699.910156\"/>\n     <use xlink:href=\"#DejaVuSans-44\" x=\"1731.697266\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1808.699219\"/>\n     <use xlink:href=\"#DejaVuSans-74\" x=\"1869.978516\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"1909.1875\"/>\n    </g>\n   </g>\n   <g id=\"legend_2\">\n    <g id=\"patch_13\">\n     <path d=\"M 602.403125 103.70875 \nL 705.220312 103.70875 \nQ 707.220312 103.70875 707.220312 101.70875 \nL 707.220312 29.318125 \nQ 707.220312 27.318125 705.220312 27.318125 \nL 602.403125 27.318125 \nQ 600.403125 27.318125 600.403125 29.318125 \nL 600.403125 101.70875 \nQ 600.403125 103.70875 602.403125 103.70875 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_42\">\n     <!-- Data Points -->\n     <g transform=\"translate(625.26875 38.916562) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_35\">\n     <path d=\"M 604.403125 50.094687 \nL 614.403125 50.094687 \nL 624.403125 50.094687 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#ma30da575e8\" x=\"614.403125\" y=\"50.094687\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_43\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(632.403125 53.594687) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_36\">\n     <path d=\"M 604.403125 64.772812 \nL 614.403125 64.772812 \nL 624.403125 64.772812 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m4e1db68579\" x=\"614.403125\" y=\"64.772812\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_44\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(632.403125 68.272812) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_37\">\n     <path d=\"M 604.403125 79.450937 \nL 614.403125 79.450937 \nL 624.403125 79.450937 \n\" style=\"fill: none\"/>\n     <g>\n      <use xlink:href=\"#m030b229f55\" x=\"614.403125\" y=\"79.450937\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_45\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(632.403125 82.950937) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_38\">\n     <path d=\"M 604.403125 94.129062 \nL 614.403125 94.129062 \nL 624.403125 94.129062 \n\" style=\"fill: none\"/>\n     <g>\n      <use xlink:href=\"#mcc89ade231\" x=\"614.403125\" y=\"94.129062\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_46\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(632.403125 97.629062) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p009533982d\">\n   <rect x=\"42.620313\" y=\"22.318125\" width=\"304.363636\" height=\"443.52\"/>\n  </clipPath>\n  <clipPath id=\"p7307dd78d4\">\n   <rect x=\"407.856676\" y=\"22.318125\" width=\"304.363636\" height=\"443.52\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from matplotlib import patches\n",
+    "\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 8))\n",
+    "\n",
+    "plot_synthetic_data(ax[0], X_train, y_train, X_test, y_test, \"Synthetic Classification Data\")\n",
+    "\n",
+    "corrupted_X_train = X_train.copy()\n",
+    "corruped_y_train = y_train.copy()\n",
+    "\n",
+    "corruped_y_train[5] = 1\n",
+    "corruped_y_train[2] = 2\n",
+    "plot_synthetic_data(\n",
+    "    ax[1],\n",
+    "    corrupted_X_train,\n",
+    "    corruped_y_train,\n",
+    "    X_test,\n",
+    "    y_test,\n",
+    "    \"Corrupted Synthetic Classification Data\",\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:39.216073Z",
+     "start_time": "2024-10-22T16:04:39.071637Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Let us now look at the Shapley values for the corrupted data.\n",
+    "The Shapley values should now identify the corrupted samples."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"453.333437pt\" height=\"335.275066pt\" viewBox=\"0 0 453.333437 335.275066\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:40.617300</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 335.275066 \nL 453.333437 335.275066 \nL 453.333437 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 58.523438 291.555539 \nL 446.133438 291.555539 \nL 446.133438 22.32 \nL 58.523438 22.32 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 61.753521 152.703726 \nL 87.594188 152.703726 \nL 87.594188 93.414393 \nL 61.753521 93.414393 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 94.054354 152.703726 \nL 119.895021 152.703726 \nL 119.895021 96.914479 \nL 94.054354 96.914479 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 126.355187 152.703726 \nL 152.195854 152.703726 \nL 152.195854 152.703726 \nL 126.355187 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 158.656021 152.703726 \nL 184.496688 152.703726 \nL 184.496688 88.12703 \nL 158.656021 88.12703 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_7\">\n    <path d=\"M 190.956854 152.703726 \nL 216.797521 152.703726 \nL 216.797521 83.509895 \nL 190.956854 83.509895 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_8\">\n    <path d=\"M 223.257687 152.703726 \nL 249.098354 152.703726 \nL 249.098354 152.703726 \nL 223.257687 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_9\">\n    <path d=\"M 255.558521 152.703726 \nL 281.399187 152.703726 \nL 281.399187 120.248385 \nL 255.558521 120.248385 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_10\">\n    <path d=\"M 287.859354 152.703726 \nL 313.700021 152.703726 \nL 313.700021 96.09531 \nL 287.859354 96.09531 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_11\">\n    <path d=\"M 320.160188 152.703726 \nL 346.000854 152.703726 \nL 346.000854 122.705892 \nL 320.160188 122.705892 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_12\">\n    <path d=\"M 352.461021 152.703726 \nL 378.301687 152.703726 \nL 378.301687 122.457659 \nL 352.461021 122.457659 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_13\">\n    <path d=\"M 384.761854 152.703726 \nL 410.602521 152.703726 \nL 410.602521 107.563677 \nL 384.761854 107.563677 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_14\">\n    <path d=\"M 417.062687 152.703726 \nL 442.903354 152.703726 \nL 442.903354 122.457659 \nL 417.062687 122.457659 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_15\">\n    <path d=\"M 61.753521 152.703726 \nL 87.594188 152.703726 \nL 87.594188 152.703726 \nL 61.753521 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_16\">\n    <path d=\"M 94.054354 152.703726 \nL 119.895021 152.703726 \nL 119.895021 152.703726 \nL 94.054354 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_17\">\n    <path d=\"M 126.355187 287.476213 \nL 152.195854 287.476213 \nL 152.195854 152.703726 \nL 126.355187 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_18\">\n    <path d=\"M 158.656021 152.703726 \nL 184.496688 152.703726 \nL 184.496688 152.703726 \nL 158.656021 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_19\">\n    <path d=\"M 190.956854 152.703726 \nL 216.797521 152.703726 \nL 216.797521 152.703726 \nL 190.956854 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_20\">\n    <path d=\"M 223.257687 178.700495 \nL 249.098354 178.700495 \nL 249.098354 152.703726 \nL 223.257687 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_21\">\n    <path d=\"M 255.558521 152.703726 \nL 281.399187 152.703726 \nL 281.399187 152.703726 \nL 255.558521 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_22\">\n    <path d=\"M 287.859354 152.703726 \nL 313.700021 152.703726 \nL 313.700021 152.703726 \nL 287.859354 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_23\">\n    <path d=\"M 320.160188 152.703726 \nL 346.000854 152.703726 \nL 346.000854 152.703726 \nL 320.160188 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_24\">\n    <path d=\"M 352.461021 152.703726 \nL 378.301687 152.703726 \nL 378.301687 152.703726 \nL 352.461021 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_25\">\n    <path d=\"M 384.761854 152.703726 \nL 410.602521 152.703726 \nL 410.602521 152.703726 \nL 384.761854 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"patch_26\">\n    <path d=\"M 417.062687 152.703726 \nL 442.903354 152.703726 \nL 442.903354 152.703726 \nL 417.062687 152.703726 \nz\n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: #d81b60\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"m737876b2c1\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"74.673854\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- 1 -->\n      <g transform=\"translate(68.704326 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"106.974688\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- 2 -->\n      <g transform=\"translate(101.005159 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"139.275521\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- 3 -->\n      <g transform=\"translate(133.305993 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"171.576354\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- 4 -->\n      <g transform=\"translate(165.606826 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"203.877187\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 5 -->\n      <g transform=\"translate(197.907659 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-35\" d=\"M 691 4666 \nL 3169 4666 \nL 3169 4134 \nL 1269 4134 \nL 1269 2991 \nQ 1406 3038 1543 3061 \nQ 1681 3084 1819 3084 \nQ 2600 3084 3056 2656 \nQ 3513 2228 3513 1497 \nQ 3513 744 3044 326 \nQ 2575 -91 1722 -91 \nQ 1428 -91 1123 -41 \nQ 819 9 494 109 \nL 494 744 \nQ 775 591 1075 516 \nQ 1375 441 1709 441 \nQ 2250 441 2565 725 \nQ 2881 1009 2881 1497 \nQ 2881 1984 2565 2268 \nQ 2250 2553 1709 2553 \nQ 1456 2553 1204 2497 \nQ 953 2441 691 2322 \nL 691 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-35\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"236.178021\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 6 -->\n      <g transform=\"translate(230.208493 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"268.478854\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 7 -->\n      <g transform=\"translate(262.509326 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-37\" d=\"M 525 4666 \nL 3525 4666 \nL 3525 4397 \nL 1831 0 \nL 1172 0 \nL 2766 4134 \nL 525 4134 \nL 525 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-37\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"300.779687\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 8 -->\n      <g transform=\"translate(294.810159 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-38\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_9\">\n     <g id=\"line2d_9\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"333.080521\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_9\">\n      <!-- 9 -->\n      <g transform=\"translate(327.110993 308.427413) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-39\" d=\"M 703 97 \nL 703 672 \nQ 941 559 1184 500 \nQ 1428 441 1663 441 \nQ 2288 441 2617 861 \nQ 2947 1281 2994 2138 \nQ 2813 1869 2534 1725 \nQ 2256 1581 1919 1581 \nQ 1219 1581 811 2004 \nQ 403 2428 403 3163 \nQ 403 3881 828 4315 \nQ 1253 4750 1959 4750 \nQ 2769 4750 3195 4129 \nQ 3622 3509 3622 2328 \nQ 3622 1225 3098 567 \nQ 2575 -91 1691 -91 \nQ 1453 -91 1209 -44 \nQ 966 3 703 97 \nz\nM 1959 2075 \nQ 2384 2075 2632 2365 \nQ 2881 2656 2881 3163 \nQ 2881 3666 2632 3958 \nQ 2384 4250 1959 4250 \nQ 1534 4250 1286 3958 \nQ 1038 3666 1038 3163 \nQ 1038 2656 1286 2365 \nQ 1534 2075 1959 2075 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-39\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_10\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"365.381354\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- 10 -->\n      <g transform=\"translate(354.912859 312.926379) rotate(-45) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_11\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"397.682187\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- 11 -->\n      <g transform=\"translate(387.213693 312.926379) rotate(-45) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_12\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#m737876b2c1\" x=\"429.983021\" y=\"291.555539\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- 12 -->\n      <g transform=\"translate(419.514526 312.926379) rotate(-45) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"63.623047\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_13\">\n     <!-- features -->\n     <g transform=\"translate(231.674531 325.995378) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-66\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"35.205078\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"96.728516\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"158.007812\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"197.216797\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"260.595703\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"299.458984\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"360.982422\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_13\">\n      <defs>\n       <path id=\"mdc032cefb8\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"277.813177\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- −0.20 -->\n      <g transform=\"translate(20.878125 281.612396) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-2e\" d=\"M 684 794 \nL 1344 794 \nL 1344 0 \nL 684 0 \nL 684 794 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"83.789062\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"147.412109\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"179.199219\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"242.822266\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"246.535815\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- −0.15 -->\n      <g transform=\"translate(20.878125 250.335033) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"83.789062\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"147.412109\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"179.199219\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"242.822266\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"215.258452\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- −0.10 -->\n      <g transform=\"translate(20.878125 219.057671) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"83.789062\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"147.412109\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"179.199219\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"242.822266\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_16\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"183.981089\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_17\">\n      <!-- −0.05 -->\n      <g transform=\"translate(20.878125 187.780308) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"83.789062\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"147.412109\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"179.199219\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"242.822266\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_17\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"152.703726\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_18\">\n      <!-- 0.00 -->\n      <g transform=\"translate(29.257813 156.502945) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_18\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"121.426363\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_19\">\n      <!-- 0.05 -->\n      <g transform=\"translate(29.257813 125.225582) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_19\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"90.149001\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_20\">\n      <!-- 0.10 -->\n      <g transform=\"translate(29.257813 93.948219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_8\">\n     <g id=\"line2d_20\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"58.871638\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_21\">\n      <!-- 0.15 -->\n      <g transform=\"translate(29.257813 62.670857) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_9\">\n     <g id=\"line2d_21\">\n      <g>\n       <use xlink:href=\"#mdc032cefb8\" x=\"58.523438\" y=\"27.594275\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_22\">\n      <!-- 0.20 -->\n      <g transform=\"translate(29.257813 31.393494) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- n-SII values -->\n     <g transform=\"translate(14.798438 185.886207) rotate(-90) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-2d\" d=\"M 313 2009 \nL 1997 2009 \nL 1997 1497 \nL 313 1497 \nL 313 2009 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-49\" d=\"M 628 4666 \nL 1259 4666 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-76\" d=\"M 191 3500 \nL 800 3500 \nL 1894 563 \nL 2988 3500 \nL 3597 3500 \nL 2284 0 \nL 1503 0 \nL 191 3500 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-6e\"/>\n      <use xlink:href=\"#DejaVuSans-2d\" x=\"63.378906\"/>\n      <use xlink:href=\"#DejaVuSans-53\" x=\"99.462891\"/>\n      <use xlink:href=\"#DejaVuSans-49\" x=\"162.939453\"/>\n      <use xlink:href=\"#DejaVuSans-49\" x=\"192.431641\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"221.923828\"/>\n      <use xlink:href=\"#DejaVuSans-76\" x=\"253.710938\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"312.890625\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"374.169922\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"401.953125\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"465.332031\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"526.855469\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"line2d_22\">\n    <path d=\"M 58.523438 152.703726 \nL 446.133438 152.703726 \n\" clip-path=\"url(#p25a72b5820)\" style=\"fill: none; stroke: #000000; stroke-width: 0.5; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_27\">\n    <path d=\"M 58.523438 291.555539 \nL 58.523438 22.32 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_28\">\n    <path d=\"M 446.133438 291.555539 \nL 446.133438 22.32 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_29\">\n    <path d=\"M 58.523438 291.555539 \nL 446.133437 291.555539 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_30\">\n    <path d=\"M 58.523438 22.32 \nL 446.133437 22.32 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_24\">\n    <!-- n-SII values up to order $1$ -->\n    <g transform=\"translate(176.368438 16.32) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-70\" d=\"M 1159 525 \nL 1159 -1331 \nL 581 -1331 \nL 581 3500 \nL 1159 3500 \nL 1159 2969 \nQ 1341 3281 1617 3432 \nQ 1894 3584 2278 3584 \nQ 2916 3584 3314 3078 \nQ 3713 2572 3713 1747 \nQ 3713 922 3314 415 \nQ 2916 -91 2278 -91 \nQ 1894 -91 1617 61 \nQ 1341 213 1159 525 \nz\nM 3116 1747 \nQ 3116 2381 2855 2742 \nQ 2594 3103 2138 3103 \nQ 1681 3103 1420 2742 \nQ 1159 2381 1159 1747 \nQ 1159 1113 1420 752 \nQ 1681 391 2138 391 \nQ 2594 391 2855 752 \nQ 3116 1113 3116 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-6e\" transform=\"translate(0 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-2d\" transform=\"translate(63.378906 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-53\" transform=\"translate(99.462891 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-49\" transform=\"translate(162.939453 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-49\" transform=\"translate(192.431641 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(221.923828 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-76\" transform=\"translate(253.710938 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-61\" transform=\"translate(312.890625 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-6c\" transform=\"translate(374.169922 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-75\" transform=\"translate(401.953125 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-65\" transform=\"translate(465.332031 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-73\" transform=\"translate(526.855469 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(578.955078 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-75\" transform=\"translate(610.742188 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-70\" transform=\"translate(674.121094 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(737.597656 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-74\" transform=\"translate(769.384766 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" transform=\"translate(808.59375 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(869.775391 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" transform=\"translate(901.5625 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-72\" transform=\"translate(962.744141 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-64\" transform=\"translate(1003.857422 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-65\" transform=\"translate(1067.333984 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-72\" transform=\"translate(1128.857422 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(1169.970703 0.015625)\"/>\n     <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(1201.757812 0.015625)\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_31\">\n     <path d=\"M 217.347969 44.998125 \nL 287.308906 44.998125 \nQ 289.308906 44.998125 289.308906 42.998125 \nL 289.308906 29.32 \nQ 289.308906 27.32 287.308906 27.32 \nL 217.347969 27.32 \nQ 215.347969 27.32 215.347969 29.32 \nL 215.347969 42.998125 \nQ 215.347969 44.998125 217.347969 44.998125 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"patch_32\">\n     <path d=\"M 219.347969 38.918437 \nL 239.347969 38.918437 \nL 239.347969 31.918437 \nL 219.347969 31.918437 \nz\n\" style=\"fill: #d81b60; stroke: #000000; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_25\">\n     <!-- Order 1 -->\n     <g transform=\"translate(247.347969 38.918437) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-4f\" d=\"M 2522 4238 \nQ 1834 4238 1429 3725 \nQ 1025 3213 1025 2328 \nQ 1025 1447 1429 934 \nQ 1834 422 2522 422 \nQ 3209 422 3611 934 \nQ 4013 1447 4013 2328 \nQ 4013 3213 3611 3725 \nQ 3209 4238 2522 4238 \nz\nM 2522 4750 \nQ 3503 4750 4090 4092 \nQ 4678 3434 4678 2328 \nQ 4678 1225 4090 567 \nQ 3503 -91 2522 -91 \nQ 1538 -91 948 565 \nQ 359 1222 359 2328 \nQ 359 3434 948 4092 \nQ 1538 4750 2522 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-4f\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"78.710938\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"118.074219\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"181.550781\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"243.074219\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"284.1875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"315.974609\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p25a72b5820\">\n   <rect x=\"58.523438\" y=\"22.32\" width=\"387.61\" height=\"269.235539\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data_valuation_game = SyntheticDataValuation(\n",
+    "    classifier=classifier,\n",
+    "    n_players=n_players,\n",
+    "    X_train=corrupted_X_train,\n",
+    "    y_train=corruped_y_train,\n",
+    "    X_test=X_test,\n",
+    "    y_test=y_test,\n",
+    ")\n",
+    "\n",
+    "# Compute Shapley values with the shapiq ExactComputer for the game function\n",
+    "exactComputer = shapiq.ExactComputer(n_players=n_players, game_fun=data_valuation_game)\n",
+    "sv_values = exactComputer(\"SV\")\n",
+    "sv_values.plot_stacked_bar()\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:40.635663Z",
+     "start_time": "2024-10-22T16:04:39.216847Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "With both corrupted samples identified by the Shapley values, we can now remove them from the training data and our model should perform better on the test data."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy on test data before removing corrupted samples:  0.5\n",
+      "Accuracy on test data after removing corrupted samples:  1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "classifier.fit(corrupted_X_train, corruped_y_train)\n",
+    "print(\"Accuracy on test data before removing corrupted samples: \", classifier.score(X_test, y_test))\n",
+    "\n",
+    "cleaned_X_train = np.delete(corrupted_X_train, [5, 2], axis=0)\n",
+    "cleaned_y_train = np.delete(corruped_y_train, [5, 2], axis=0)\n",
+    "classifier.fit(cleaned_X_train, cleaned_y_train)\n",
+    "print(\"Accuracy on test data after removing corrupted samples: \", classifier.score(X_test, y_test))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:40.640022Z",
+     "start_time": "2024-10-22T16:04:40.636571Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "To verify this as sensible we plot the decision boundary of the `LinearSVM` classifier for the corrupted and cleaned training data and the corresponding test data."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 1200x700 with 2 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"719.420312pt\" height=\"483.23625pt\" viewBox=\"0 0 719.420312 483.23625\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:04:40.745038</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 483.23625 \nL 719.420312 483.23625 \nL 719.420312 0 \nL 0 0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 42.620313 445.68 \nL 346.983949 445.68 \nL 346.983949 57.6 \nL 42.620313 57.6 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_1\">\n    <defs>\n     <path id=\"C0_0_740965b8f7\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"247.026747\" y=\"296.357911\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"259.823072\" y=\"392.134438\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"251.923403\" y=\"233.695636\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"327.611937\" y=\"387.298757\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"303.443614\" y=\"351.41668\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"141.651706\" y=\"390.92612\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"158.437738\" y=\"132.489409\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"61.992324\" y=\"244.411343\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"122.257797\" y=\"111.145562\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"121.310419\" y=\"126.098526\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"191.920149\" y=\"222.465406\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#p721f0d28e5)\">\n     <use xlink:href=\"#C0_0_740965b8f7\" x=\"124.135439\" y=\"132.683943\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_2\">\n    <path d=\"M 274.555284 414.534076 \nL 280.555284 408.534076 \nM 274.555284 408.534076 \nL 280.555284 414.534076 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 167.03536 263.071805 \nL 173.03536 257.071805 \nM 167.03536 257.071805 \nL 173.03536 263.071805 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 151.095461 214.993305 \nL 157.095461 208.993305 \nM 151.095461 208.993305 \nL 157.095461 214.993305 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 244.149702 218.086568 \nL 250.149702 212.086568 \nM 244.149702 212.086568 \nL 250.149702 218.086568 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 315.44425 283.393713 \nL 321.44425 277.393713 \nM 315.44425 277.393713 \nL 321.44425 283.393713 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 319.589579 366.030182 \nL 325.589579 360.030182 \nM 319.589579 360.030182 \nL 325.589579 366.030182 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 151.647895 297.983285 \nL 157.647895 291.983285 \nM 151.647895 291.983285 \nL 157.647895 297.983285 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 170.503532 365.295226 \nL 176.503532 359.295226 \nM 170.503532 359.295226 \nL 176.503532 365.295226 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 223.015392 262.341507 \nL 229.015392 256.341507 \nM 223.015392 256.341507 \nL 229.015392 262.341507 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 248.84364 172.392633 \nL 254.84364 166.392633 \nM 248.84364 166.392633 \nL 254.84364 172.392633 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"md0c2ceb920\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"57.528877\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- −8 -->\n      <g transform=\"translate(50.157783 460.278437) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \nL 4684 2272 \nL 4684 1741 \nL 678 1741 \nL 678 2272 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"96.272901\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- −6 -->\n      <g transform=\"translate(88.901807 460.278437) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"135.016924\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- −4 -->\n      <g transform=\"translate(127.645831 460.278437) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"173.760948\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- −2 -->\n      <g transform=\"translate(166.389854 460.278437) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"212.504972\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0 -->\n      <g transform=\"translate(209.323722 460.278437) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_6\">\n     <g id=\"line2d_6\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"251.248996\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_6\">\n      <!-- 2 -->\n      <g transform=\"translate(248.067746 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_7\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"289.993019\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 4 -->\n      <g transform=\"translate(286.811769 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_8\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"328.737043\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 6 -->\n      <g transform=\"translate(325.555793 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_9\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(171.141974 473.956562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-46\" d=\"M 628 4666 \nL 3309 4666 \nL 3309 4134 \nL 1259 4134 \nL 1259 2759 \nL 3109 2759 \nL 3109 2228 \nL 1259 2228 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_9\">\n      <defs>\n       <path id=\"m69c493b75d\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"419.868034\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- −3 -->\n      <g transform=\"translate(20.878125 423.667253) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \nQ 3050 2419 3304 2112 \nQ 3559 1806 3559 1356 \nQ 3559 666 3084 287 \nQ 2609 -91 1734 -91 \nQ 1441 -91 1130 -33 \nQ 819 25 488 141 \nL 488 750 \nQ 750 597 1062 519 \nQ 1375 441 1716 441 \nQ 2309 441 2620 675 \nQ 2931 909 2931 1356 \nQ 2931 1769 2642 2001 \nQ 2353 2234 1838 2234 \nL 1294 2234 \nL 1294 2753 \nL 1863 2753 \nQ 2328 2753 2575 2939 \nQ 2822 3125 2822 3475 \nQ 2822 3834 2567 4026 \nQ 2313 4219 1838 4219 \nQ 1578 4219 1281 4162 \nQ 984 4106 628 3988 \nL 628 4550 \nQ 988 4650 1302 4700 \nQ 1616 4750 1894 4750 \nQ 2613 4750 3031 4423 \nQ 3450 4097 3450 3541 \nQ 3450 3153 3228 2886 \nQ 3006 2619 2597 2516 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"366.322472\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- −2 -->\n      <g transform=\"translate(20.878125 370.12169) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"312.776909\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- −1 -->\n      <g transform=\"translate(20.878125 316.576128) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"259.231347\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0 -->\n      <g transform=\"translate(29.257813 263.030566) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"205.685785\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 1 -->\n      <g transform=\"translate(29.257813 209.485004) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_14\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"152.140223\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_15\">\n      <!-- 2 -->\n      <g transform=\"translate(29.257813 155.939442) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_15\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"42.620313\" y=\"98.594661\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_16\">\n      <!-- 3 -->\n      <g transform=\"translate(29.257813 102.393879) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(14.798438 275.300156) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"QuadContourSet_1\">\n    <path d=\"M 42.620313 351.979354 \nL 44.835741 351.6 \nL 45.694693 351.452919 \nL 48.769073 350.926485 \nL 51.843453 350.400051 \nL 54.917833 349.873616 \nL 57.992213 349.347182 \nL 61.066593 348.820747 \nL 64.140974 348.294313 \nL 67.215354 347.767879 \nL 67.728565 347.68 \nL 70.289734 347.241444 \nL 73.364114 346.71501 \nL 76.438494 346.188575 \nL 79.512874 345.662141 \nL 82.587255 345.135707 \nL 85.661635 344.609272 \nL 88.736015 344.082838 \nL 90.621389 343.76 \nL 91.810395 343.556403 \nL 94.884775 343.029969 \nL 97.959155 342.503534 \nL 101.033536 341.9771 \nL 104.107916 341.450666 \nL 107.182296 340.924231 \nL 110.256676 340.397797 \nL 113.331056 339.871362 \nL 113.514213 339.84 \nL 116.405436 339.344928 \nL 119.479817 338.818494 \nL 122.554197 338.292059 \nL 125.628577 337.765625 \nL 128.702957 337.23919 \nL 131.777337 336.712756 \nL 134.851717 336.186322 \nL 136.407037 335.92 \nL 137.926098 335.659887 \nL 141.000478 335.133453 \nL 144.074858 334.607018 \nL 147.149238 334.080584 \nL 150.223618 333.554149 \nL 153.297998 333.027715 \nL 156.372379 332.501281 \nL 159.299861 332 \nL 159.446759 331.974846 \nL 162.521139 331.448412 \nL 165.595519 330.921977 \nL 168.669899 330.395543 \nL 171.744279 329.869109 \nL 174.81866 329.342674 \nL 177.89304 328.81624 \nL 180.96742 328.289805 \nL 182.192684 328.08 \nL 184.0418 327.763371 \nL 187.11618 327.236937 \nL 190.19056 326.710502 \nL 193.264941 326.184068 \nL 196.339321 325.657633 \nL 199.413701 325.131199 \nL 202.488081 324.604764 \nL 205.085508 324.16 \nL 205.562461 324.07833 \nL 208.636841 323.551896 \nL 211.711222 323.025461 \nL 214.785602 322.499027 \nL 217.859982 321.972592 \nL 220.934362 321.446158 \nL 224.008742 320.919724 \nL 227.083122 320.393289 \nL 227.978332 320.24 \nL 230.157503 319.866855 \nL 233.231883 319.34042 \nL 236.306263 318.813986 \nL 239.380643 318.287551 \nL 242.455023 317.761117 \nL 245.529403 317.234683 \nL 248.603784 316.708248 \nL 250.871156 316.32 \nL 251.678164 316.181814 \nL 254.752544 315.655379 \nL 257.826924 315.128945 \nL 260.901304 314.602511 \nL 263.975684 314.076076 \nL 267.050065 313.549642 \nL 270.124445 313.023207 \nL 273.198825 312.496773 \nL 273.76398 312.4 \nL 276.273205 311.970339 \nL 279.347585 311.443904 \nL 282.421965 310.91747 \nL 285.496346 310.391035 \nL 288.570726 309.864601 \nL 291.645106 309.338166 \nL 294.719486 308.811732 \nL 296.656803 308.48 \nL 297.793866 308.285298 \nL 300.868246 307.758863 \nL 303.942627 307.232429 \nL 307.017007 306.705994 \nL 310.091387 306.17956 \nL 313.165767 305.653126 \nL 316.240147 305.126691 \nL 319.314527 304.600257 \nL 319.549627 304.56 \nL 322.388908 304.073822 \nL 325.463288 303.547388 \nL 328.537668 303.020954 \nL 331.612048 302.494519 \nL 334.686428 301.968085 \nL 337.760808 301.44165 \nL 340.835189 300.915216 \nL 342.442451 300.64 \nL 343.909569 300.388781 \nL 346.983949 299.862347 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #440154; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 42.620313 299.196756 \nL 45.694693 298.670322 \nL 48.769073 298.143887 \nL 51.843453 297.617453 \nL 54.917833 297.091019 \nL 57.084584 296.72 \nL 57.992213 296.564584 \nL 61.066593 296.03815 \nL 64.140974 295.511715 \nL 67.215354 294.985281 \nL 70.289734 294.458847 \nL 73.364114 293.932412 \nL 76.438494 293.405978 \nL 79.512874 292.879543 \nL 79.977408 292.8 \nL 82.587255 292.353109 \nL 85.661635 291.826674 \nL 88.736015 291.30024 \nL 91.810395 290.773806 \nL 94.884775 290.247371 \nL 97.959155 289.720937 \nL 101.033536 289.194502 \nL 102.870232 288.88 \nL 104.107916 288.668068 \nL 107.182296 288.141634 \nL 110.256676 287.615199 \nL 113.331056 287.088765 \nL 116.405436 286.56233 \nL 119.479817 286.035896 \nL 122.554197 285.509462 \nL 125.628577 284.983027 \nL 125.763055 284.96 \nL 128.702957 284.456593 \nL 131.777337 283.930158 \nL 134.851717 283.403724 \nL 137.926098 282.877289 \nL 141.000478 282.350855 \nL 144.074858 281.824421 \nL 147.149238 281.297986 \nL 148.655879 281.04 \nL 150.223618 280.771552 \nL 153.297998 280.245117 \nL 156.372379 279.718683 \nL 159.446759 279.192249 \nL 162.521139 278.665814 \nL 165.595519 278.13938 \nL 168.669899 277.612945 \nL 171.548703 277.12 \nL 171.744279 277.086511 \nL 174.81866 276.560077 \nL 177.89304 276.033642 \nL 180.96742 275.507208 \nL 184.0418 274.980773 \nL 187.11618 274.454339 \nL 190.19056 273.927904 \nL 193.264941 273.40147 \nL 194.441527 273.2 \nL 196.339321 272.875036 \nL 199.413701 272.348601 \nL 202.488081 271.822167 \nL 205.562461 271.295732 \nL 208.636841 270.769298 \nL 211.711222 270.242864 \nL 214.785602 269.716429 \nL 217.334351 269.28 \nL 217.859982 269.189995 \nL 220.934362 268.66356 \nL 224.008742 268.137126 \nL 227.083122 267.610692 \nL 230.157503 267.084257 \nL 233.231883 266.557823 \nL 236.306263 266.031388 \nL 239.380643 265.504954 \nL 240.227174 265.36 \nL 242.455023 264.978519 \nL 245.529403 264.452085 \nL 248.603784 263.925651 \nL 251.678164 263.399216 \nL 254.752544 262.872782 \nL 257.826924 262.346347 \nL 260.901304 261.819913 \nL 263.119998 261.44 \nL 263.975684 261.293479 \nL 267.050065 260.767044 \nL 270.124445 260.24061 \nL 273.198825 259.714175 \nL 276.273205 259.187741 \nL 279.347585 258.661306 \nL 282.421965 258.134872 \nL 285.496346 257.608438 \nL 286.012822 257.52 \nL 288.570726 257.082003 \nL 291.645106 256.555569 \nL 294.719486 256.029134 \nL 297.793866 255.5027 \nL 300.868246 254.976266 \nL 303.942627 254.449831 \nL 307.017007 253.923397 \nL 308.905646 253.6 \nL 310.091387 253.396962 \nL 313.165767 252.870528 \nL 316.240147 252.344094 \nL 319.314527 251.817659 \nL 322.388908 251.291225 \nL 325.463288 250.76479 \nL 328.537668 250.238356 \nL 331.612048 249.711921 \nL 331.79847 249.68 \nL 334.686428 249.185487 \nL 337.760808 248.659053 \nL 340.835189 248.132618 \nL 343.909569 247.606184 \nL 346.983949 247.079749 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: none; stroke: #21918c; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 42.620313 246.414159 \nL 45.694693 245.887724 \nL 46.440603 245.76 \nL 48.769073 245.36129 \nL 51.843453 244.834855 \nL 54.917833 244.308421 \nL 57.992213 243.781987 \nL 61.066593 243.255552 \nL 64.140974 242.729118 \nL 67.215354 242.202683 \nL 69.333426 241.84 \nL 70.289734 241.676249 \nL 73.364114 241.149814 \nL 76.438494 240.62338 \nL 79.512874 240.096946 \nL 82.587255 239.570511 \nL 85.661635 239.044077 \nL 88.736015 238.517642 \nL 91.810395 237.991208 \nL 92.22625 237.92 \nL 94.884775 237.464774 \nL 97.959155 236.938339 \nL 101.033536 236.411905 \nL 104.107916 235.88547 \nL 107.182296 235.359036 \nL 110.256676 234.832602 \nL 113.331056 234.306167 \nL 115.119074 234 \nL 116.405436 233.779733 \nL 119.479817 233.253298 \nL 122.554197 232.726864 \nL 125.628577 232.200429 \nL 128.702957 231.673995 \nL 131.777337 231.147561 \nL 134.851717 230.621126 \nL 137.926098 230.094692 \nL 138.011898 230.08 \nL 141.000478 229.568257 \nL 144.074858 229.041823 \nL 147.149238 228.515389 \nL 150.223618 227.988954 \nL 153.297998 227.46252 \nL 156.372379 226.936085 \nL 159.446759 226.409651 \nL 160.904722 226.16 \nL 162.521139 225.883217 \nL 165.595519 225.356782 \nL 168.669899 224.830348 \nL 171.744279 224.303913 \nL 174.81866 223.777479 \nL 177.89304 223.251044 \nL 180.96742 222.72461 \nL 183.797546 222.24 \nL 184.0418 222.198176 \nL 187.11618 221.671741 \nL 190.19056 221.145307 \nL 193.264941 220.618872 \nL 196.339321 220.092438 \nL 199.413701 219.566004 \nL 202.488081 219.039569 \nL 205.562461 218.513135 \nL 206.690369 218.32 \nL 208.636841 217.9867 \nL 211.711222 217.460266 \nL 214.785602 216.933832 \nL 217.859982 216.407397 \nL 220.934362 215.880963 \nL 224.008742 215.354528 \nL 227.083122 214.828094 \nL 229.583193 214.4 \nL 230.157503 214.301659 \nL 233.231883 213.775225 \nL 236.306263 213.248791 \nL 239.380643 212.722356 \nL 242.455023 212.195922 \nL 245.529403 211.669487 \nL 248.603784 211.143053 \nL 251.678164 210.616619 \nL 252.476017 210.48 \nL 254.752544 210.090184 \nL 257.826924 209.56375 \nL 260.901304 209.037315 \nL 263.975684 208.510881 \nL 267.050065 207.984447 \nL 270.124445 207.458012 \nL 273.198825 206.931578 \nL 275.368841 206.56 \nL 276.273205 206.405143 \nL 279.347585 205.878709 \nL 282.421965 205.352274 \nL 285.496346 204.82584 \nL 288.570726 204.299406 \nL 291.645106 203.772971 \nL 294.719486 203.246537 \nL 297.793866 202.720102 \nL 298.261665 202.64 \nL 300.868246 202.193668 \nL 303.942627 201.667234 \nL 307.017007 201.140799 \nL 310.091387 200.614365 \nL 313.165767 200.08793 \nL 316.240147 199.561496 \nL 319.314527 199.035061 \nL 321.154488 198.72 \nL 322.388908 198.508627 \nL 325.463288 197.982193 \nL 328.537668 197.455758 \nL 331.612048 196.929324 \nL 334.686428 196.402889 \nL 337.760808 195.876455 \nL 340.835189 195.350021 \nL 343.909569 194.823586 \nL 344.047312 194.8 \nL 346.983949 194.297152 \n\" clip-path=\"url(#p721f0d28e5)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #fde725; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 42.620313 445.68 \nL 42.620313 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 346.983949 445.68 \nL 346.983949 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 42.620313 445.68 \nL 346.983949 445.68 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 42.620313 57.6 \nL 346.983949 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_18\">\n    <!-- Decision Boundary -->\n    <g transform=\"translate(138.454631 51.6) scale(0.12 -0.12)\">\n     <defs>\n      <path id=\"DejaVuSans-44\" d=\"M 1259 4147 \nL 1259 519 \nL 2022 519 \nQ 2988 519 3436 956 \nQ 3884 1394 3884 2338 \nQ 3884 3275 3436 3711 \nQ 2988 4147 2022 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 1925 4666 \nQ 3281 4666 3915 4102 \nQ 4550 3538 4550 2338 \nQ 4550 1131 3912 565 \nQ 3275 0 1925 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-42\" d=\"M 1259 2228 \nL 1259 519 \nL 2272 519 \nQ 2781 519 3026 730 \nQ 3272 941 3272 1375 \nQ 3272 1813 3026 2020 \nQ 2781 2228 2272 2228 \nL 1259 2228 \nz\nM 1259 4147 \nL 1259 2741 \nL 2194 2741 \nQ 2656 2741 2882 2914 \nQ 3109 3088 3109 3444 \nQ 3109 3797 2882 3972 \nQ 2656 4147 2194 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2241 4666 \nQ 2963 4666 3353 4366 \nQ 3744 4066 3744 3513 \nQ 3744 3084 3544 2831 \nQ 3344 2578 2956 2516 \nQ 3422 2416 3680 2098 \nQ 3938 1781 3938 1306 \nQ 3938 681 3513 340 \nQ 3088 0 2303 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n      <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n     </defs>\n     <use xlink:href=\"#DejaVuSans-44\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"77.001953\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"138.525391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"193.505859\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"221.289062\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"273.388672\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"301.171875\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"362.353516\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"425.732422\"/>\n     <use xlink:href=\"#DejaVuSans-42\" x=\"457.519531\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"526.123047\"/>\n     <use xlink:href=\"#DejaVuSans-75\" x=\"587.304688\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"650.683594\"/>\n     <use xlink:href=\"#DejaVuSans-64\" x=\"714.0625\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"777.539062\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"838.818359\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"879.931641\"/>\n    </g>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 237.166761 138.990625 \nL 339.983949 138.990625 \nQ 341.983949 138.990625 341.983949 136.990625 \nL 341.983949 64.6 \nQ 341.983949 62.6 339.983949 62.6 \nL 237.166761 62.6 \nQ 235.166761 62.6 235.166761 64.6 \nL 235.166761 136.990625 \nQ 235.166761 138.990625 237.166761 138.990625 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_19\">\n     <!-- Data Points -->\n     <g transform=\"translate(260.032386 74.198437) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_16\">\n     <path d=\"M 239.166761 85.376562 \nL 249.166761 85.376562 \nL 259.166761 85.376562 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m26e437054e\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m26e437054e\" x=\"249.166761\" y=\"85.376562\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_20\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(267.166761 88.876562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \nL 4122 3641 \nQ 3803 3938 3442 4084 \nQ 3081 4231 2675 4231 \nQ 1875 4231 1450 3742 \nQ 1025 3253 1025 2328 \nQ 1025 1406 1450 917 \nQ 1875 428 2675 428 \nQ 3081 428 3442 575 \nQ 3803 722 4122 1019 \nL 4122 359 \nQ 3791 134 3420 21 \nQ 3050 -91 2638 -91 \nQ 1578 -91 968 557 \nQ 359 1206 359 2328 \nQ 359 3453 968 4101 \nQ 1578 4750 2638 4750 \nQ 3056 4750 3426 4639 \nQ 3797 4528 4122 4306 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \nQ 1566 4138 1362 3434 \nQ 1159 2731 1159 2009 \nQ 1159 1288 1364 580 \nQ 1569 -128 1984 -844 \nL 1484 -844 \nQ 1016 -109 783 600 \nQ 550 1309 550 2009 \nQ 550 2706 781 3412 \nQ 1013 4119 1484 4856 \nL 1984 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \nL 3928 4666 \nL 3928 4134 \nL 2272 4134 \nL 2272 0 \nL 1638 0 \nL 1638 4134 \nL -19 4134 \nL -19 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-29\" d=\"M 513 4856 \nL 1013 4856 \nQ 1481 4119 1714 3412 \nQ 1947 2706 1947 2009 \nQ 1947 1309 1714 600 \nQ 1481 -109 1013 -844 \nL 513 -844 \nQ 928 -128 1133 580 \nQ 1338 1288 1338 2009 \nQ 1338 2731 1133 3434 \nQ 928 4138 513 4856 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_17\">\n     <path d=\"M 239.166761 100.054687 \nL 249.166761 100.054687 \nL 259.166761 100.054687 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <defs>\n      <path id=\"m4484fa02a8\" d=\"M 0 5 \nC 1.326016 5 2.597899 4.473168 3.535534 3.535534 \nC 4.473168 2.597899 5 1.326016 5 0 \nC 5 -1.326016 4.473168 -2.597899 3.535534 -3.535534 \nC 2.597899 -4.473168 1.326016 -5 0 -5 \nC -1.326016 -5 -2.597899 -4.473168 -3.535534 -3.535534 \nC -4.473168 -2.597899 -5 -1.326016 -5 0 \nC -5 1.326016 -4.473168 2.597899 -3.535534 3.535534 \nC -2.597899 4.473168 -1.326016 5 0 5 \nz\n\" style=\"stroke: #ffffff\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m4484fa02a8\" x=\"249.166761\" y=\"100.054687\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_21\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(267.166761 103.554687) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 239.166761 114.732812 \nL 249.166761 114.732812 \nL 259.166761 114.732812 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"mad5660ea86\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #ffb000\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#mad5660ea86\" x=\"249.166761\" y=\"114.732812\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_22\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(267.166761 118.232812) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 239.166761 129.410937 \nL 249.166761 129.410937 \nL 259.166761 129.410937 \n\" style=\"fill: none\"/>\n     <defs>\n      <path id=\"m13b9e5a22b\" d=\"M -5 5 \nL 5 -5 \nM -5 -5 \nL 5 5 \n\" style=\"stroke: #1e88e5\"/>\n     </defs>\n     <g>\n      <use xlink:href=\"#m13b9e5a22b\" x=\"249.166761\" y=\"129.410937\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_23\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(267.166761 132.910937) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n  <g id=\"axes_2\">\n   <g id=\"patch_8\">\n    <path d=\"M 407.856676 445.68 \nL 712.220312 445.68 \nL 712.220312 57.6 \nL 407.856676 57.6 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"PathCollection_3\">\n    <defs>\n     <path id=\"C1_0_a04a425d50\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 -0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\"/>\n    </defs>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"612.26311\" y=\"296.357911\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"625.059436\" y=\"392.134438\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"692.848301\" y=\"387.298757\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"668.679977\" y=\"351.41668\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"523.674102\" y=\"132.489409\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"427.228688\" y=\"244.411343\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"487.494161\" y=\"111.145562\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"486.546783\" y=\"126.098526\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"557.156513\" y=\"222.465406\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n    <g clip-path=\"url(#pbd92fc0bac)\">\n     <use xlink:href=\"#C1_0_a04a425d50\" x=\"489.371803\" y=\"132.683943\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"PathCollection_4\">\n    <path d=\"M 639.791648 414.534076 \nL 645.791648 408.534076 \nM 639.791648 408.534076 \nL 645.791648 414.534076 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 532.271724 263.071805 \nL 538.271724 257.071805 \nM 532.271724 257.071805 \nL 538.271724 263.071805 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 516.331825 214.993305 \nL 522.331825 208.993305 \nM 516.331825 208.993305 \nL 522.331825 214.993305 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 609.386065 218.086568 \nL 615.386065 212.086568 \nM 609.386065 212.086568 \nL 615.386065 218.086568 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 680.680614 283.393713 \nL 686.680614 277.393713 \nM 680.680614 277.393713 \nL 686.680614 283.393713 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 684.825943 366.030182 \nL 690.825943 360.030182 \nM 684.825943 360.030182 \nL 690.825943 366.030182 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 516.884259 297.983285 \nL 522.884259 291.983285 \nM 516.884259 291.983285 \nL 522.884259 297.983285 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 535.739896 365.295226 \nL 541.739896 359.295226 \nM 535.739896 359.295226 \nL 541.739896 365.295226 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #1e88e5; stroke: #1e88e5; stroke-width: 1.5\"/>\n    <path d=\"M 588.251755 262.341507 \nL 594.251755 256.341507 \nM 588.251755 256.341507 \nL 594.251755 262.341507 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n    <path d=\"M 614.080003 172.392633 \nL 620.080003 166.392633 \nM 614.080003 166.392633 \nL 620.080003 172.392633 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: #ffb000; stroke: #ffb000; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"matplotlib.axis_3\">\n    <g id=\"xtick_9\">\n     <g id=\"line2d_20\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"422.765241\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_24\">\n      <!-- −8 -->\n      <g transform=\"translate(415.394147 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_10\">\n     <g id=\"line2d_21\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"461.509264\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_25\">\n      <!-- −6 -->\n      <g transform=\"translate(454.138171 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_11\">\n     <g id=\"line2d_22\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"500.253288\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_26\">\n      <!-- −4 -->\n      <g transform=\"translate(492.882194 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_12\">\n     <g id=\"line2d_23\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"538.997312\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_27\">\n      <!-- −2 -->\n      <g transform=\"translate(531.626218 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_13\">\n     <g id=\"line2d_24\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"577.741336\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_28\">\n      <!-- 0 -->\n      <g transform=\"translate(574.560086 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_14\">\n     <g id=\"line2d_25\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"616.485359\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_29\">\n      <!-- 2 -->\n      <g transform=\"translate(613.304109 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_15\">\n     <g id=\"line2d_26\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"655.229383\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_30\">\n      <!-- 4 -->\n      <g transform=\"translate(652.048133 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-34\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_16\">\n     <g id=\"line2d_27\">\n      <g>\n       <use xlink:href=\"#md0c2ceb920\" x=\"693.973407\" y=\"445.68\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_31\">\n      <!-- 6 -->\n      <g transform=\"translate(690.792157 460.278437) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-36\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_32\">\n     <!-- Feature 1 -->\n     <g transform=\"translate(536.378338 473.956562) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_4\">\n    <g id=\"ytick_8\">\n     <g id=\"line2d_28\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"419.868034\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_33\">\n      <!-- −3 -->\n      <g transform=\"translate(386.114489 423.667253) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-33\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_9\">\n     <g id=\"line2d_29\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"366.322472\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_34\">\n      <!-- −2 -->\n      <g transform=\"translate(386.114489 370.12169) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_10\">\n     <g id=\"line2d_30\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"312.776909\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_35\">\n      <!-- −1 -->\n      <g transform=\"translate(386.114489 316.576128) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-2212\"/>\n       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_11\">\n     <g id=\"line2d_31\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"259.231347\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_36\">\n      <!-- 0 -->\n      <g transform=\"translate(394.494176 263.030566) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_12\">\n     <g id=\"line2d_32\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"205.685785\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_37\">\n      <!-- 1 -->\n      <g transform=\"translate(394.494176 209.485004) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-31\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_13\">\n     <g id=\"line2d_33\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"152.140223\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_38\">\n      <!-- 2 -->\n      <g transform=\"translate(394.494176 155.939442) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-32\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_14\">\n     <g id=\"line2d_34\">\n      <g>\n       <use xlink:href=\"#m69c493b75d\" x=\"407.856676\" y=\"98.594661\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_39\">\n      <!-- 3 -->\n      <g transform=\"translate(394.494176 102.393879) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-33\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_40\">\n     <!-- Feature 2 -->\n     <g transform=\"translate(380.034801 275.300156) rotate(-90) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-46\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"52.019531\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"113.542969\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"174.822266\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"214.03125\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"277.410156\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"316.273438\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"377.796875\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"409.583984\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"QuadContourSet_2\">\n    <path d=\"M 585.740409 445.68 \nL 586.170726 443.455174 \nL 586.498599 441.76 \nL 587.25679 437.84 \nL 588.01498 433.92 \nL 588.77317 430 \nL 589.245106 427.559994 \nL 589.53136 426.08 \nL 590.289551 422.16 \nL 591.047741 418.24 \nL 591.805931 414.32 \nL 592.319486 411.664815 \nL 592.564121 410.4 \nL 593.322312 406.48 \nL 594.080502 402.56 \nL 594.838692 398.64 \nL 595.393866 395.769635 \nL 595.596882 394.72 \nL 596.355073 390.8 \nL 597.113263 386.88 \nL 597.871453 382.96 \nL 598.468246 379.874455 \nL 598.629643 379.04 \nL 599.387833 375.12 \nL 600.146024 371.2 \nL 600.904214 367.28 \nL 601.542627 363.979275 \nL 601.662404 363.36 \nL 602.420594 359.44 \nL 603.178785 355.52 \nL 603.936975 351.6 \nL 604.617007 348.084096 \nL 604.695165 347.68 \nL 605.453355 343.76 \nL 606.211546 339.84 \nL 606.969736 335.92 \nL 607.691387 332.188916 \nL 607.727926 332 \nL 608.486116 328.08 \nL 609.244307 324.16 \nL 610.002497 320.24 \nL 610.760687 316.32 \nL 610.765767 316.293736 \nL 611.518877 312.4 \nL 612.277068 308.48 \nL 613.035258 304.56 \nL 613.793448 300.64 \nL 613.840147 300.398556 \nL 614.551638 296.72 \nL 615.309829 292.8 \nL 616.068019 288.88 \nL 616.826209 284.96 \nL 616.914527 284.503377 \nL 617.584399 281.04 \nL 618.34259 277.12 \nL 619.10078 273.2 \nL 619.85897 269.28 \nL 619.988908 268.608197 \nL 620.61716 265.36 \nL 621.375351 261.44 \nL 622.133541 257.52 \nL 622.891731 253.6 \nL 623.063288 252.713017 \nL 623.649921 249.68 \nL 624.408112 245.76 \nL 625.166302 241.84 \nL 625.924492 237.92 \nL 626.137668 236.817837 \nL 626.682682 234 \nL 627.440873 230.08 \nL 628.199063 226.16 \nL 628.957253 222.24 \nL 629.212048 220.922658 \nL 629.715443 218.32 \nL 630.473634 214.4 \nL 631.231824 210.48 \nL 631.990014 206.56 \nL 632.286428 205.027478 \nL 632.748204 202.64 \nL 633.506395 198.72 \nL 634.264585 194.8 \nL 635.022775 190.88 \nL 635.360808 189.132298 \nL 635.780965 186.96 \nL 636.539156 183.04 \nL 637.297346 179.12 \nL 638.055536 175.2 \nL 638.435189 173.237119 \nL 638.813726 171.28 \nL 639.571917 167.36 \nL 640.330107 163.44 \nL 641.088297 159.52 \nL 641.509569 157.341939 \nL 641.846487 155.6 \nL 642.604678 151.68 \nL 643.362868 147.76 \nL 644.121058 143.84 \nL 644.583949 141.446759 \nL 644.879248 139.92 \nL 645.637439 136 \nL 646.395629 132.08 \nL 647.153819 128.16 \nL 647.658329 125.551579 \nL 647.912009 124.24 \nL 648.6702 120.32 \nL 649.42839 116.4 \nL 650.18658 112.48 \nL 650.732709 109.6564 \nL 650.94477 108.56 \nL 651.702961 104.64 \nL 652.461151 100.72 \nL 653.219341 96.8 \nL 653.807089 93.76122 \nL 653.977531 92.88 \nL 654.735722 88.96 \nL 655.493912 85.04 \nL 656.252102 81.12 \nL 656.88147 77.86604 \nL 657.010292 77.2 \nL 657.768483 73.28 \nL 658.526673 69.36 \nL 659.284863 65.44 \nL 659.95585 61.97086 \nL 660.043053 61.52 \nL 660.801243 57.6 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #440154; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 547.281886 445.68 \nL 548.040076 441.76 \nL 548.798267 437.84 \nL 549.278164 435.358834 \nL 549.556457 433.92 \nL 550.314647 430 \nL 551.072837 426.08 \nL 551.831028 422.16 \nL 552.352544 419.463654 \nL 552.589218 418.24 \nL 553.347408 414.32 \nL 554.105598 410.4 \nL 554.863789 406.48 \nL 555.426924 403.568474 \nL 555.621979 402.56 \nL 556.380169 398.64 \nL 557.138359 394.72 \nL 557.89655 390.8 \nL 558.501304 387.673294 \nL 558.65474 386.88 \nL 559.41293 382.96 \nL 560.17112 379.04 \nL 560.929311 375.12 \nL 561.575684 371.778115 \nL 561.687501 371.2 \nL 562.445691 367.28 \nL 563.203881 363.36 \nL 563.962072 359.44 \nL 564.650065 355.882935 \nL 564.720262 355.52 \nL 565.478452 351.6 \nL 566.236642 347.68 \nL 566.994833 343.76 \nL 567.724445 339.987755 \nL 567.753023 339.84 \nL 568.511213 335.92 \nL 569.269403 332 \nL 570.027594 328.08 \nL 570.785784 324.16 \nL 570.798825 324.092575 \nL 571.543974 320.24 \nL 572.302164 316.32 \nL 573.060355 312.4 \nL 573.818545 308.48 \nL 573.873205 308.197396 \nL 574.576735 304.56 \nL 575.334925 300.64 \nL 576.093116 296.72 \nL 576.851306 292.8 \nL 576.947585 292.302216 \nL 577.609496 288.88 \nL 578.367686 284.96 \nL 579.125877 281.04 \nL 579.884067 277.12 \nL 580.021965 276.407036 \nL 580.642257 273.2 \nL 581.400447 269.28 \nL 582.158638 265.36 \nL 582.916828 261.44 \nL 583.096346 260.511856 \nL 583.675018 257.52 \nL 584.433208 253.6 \nL 585.191399 249.68 \nL 585.949589 245.76 \nL 586.170726 244.616677 \nL 586.707779 241.84 \nL 587.465969 237.92 \nL 588.22416 234 \nL 588.98235 230.08 \nL 589.245106 228.721497 \nL 589.74054 226.16 \nL 590.49873 222.24 \nL 591.256921 218.32 \nL 592.015111 214.4 \nL 592.319486 212.826317 \nL 592.773301 210.48 \nL 593.531491 206.56 \nL 594.289682 202.64 \nL 595.047872 198.72 \nL 595.393866 196.931137 \nL 595.806062 194.8 \nL 596.564252 190.88 \nL 597.322443 186.96 \nL 598.080633 183.04 \nL 598.468246 181.035958 \nL 598.838823 179.12 \nL 599.597013 175.2 \nL 600.355204 171.28 \nL 601.113394 167.36 \nL 601.542627 165.140778 \nL 601.871584 163.44 \nL 602.629774 159.52 \nL 603.387965 155.6 \nL 604.146155 151.68 \nL 604.617007 149.245598 \nL 604.904345 147.76 \nL 605.662535 143.84 \nL 606.420726 139.92 \nL 607.178916 136 \nL 607.691387 133.350419 \nL 607.937106 132.08 \nL 608.695296 128.16 \nL 609.453486 124.24 \nL 610.211677 120.32 \nL 610.765767 117.455239 \nL 610.969867 116.4 \nL 611.728057 112.48 \nL 612.486247 108.56 \nL 613.244438 104.64 \nL 613.840147 101.560059 \nL 614.002628 100.72 \nL 614.760818 96.8 \nL 615.519008 92.88 \nL 616.277199 88.96 \nL 616.914527 85.664879 \nL 617.035389 85.04 \nL 617.793579 81.12 \nL 618.551769 77.2 \nL 619.30996 73.28 \nL 619.988908 69.7697 \nL 620.06815 69.36 \nL 620.82634 65.44 \nL 621.58453 61.52 \nL 622.342721 57.6 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: none; stroke: #21918c; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n    <path d=\"M 508.823363 445.68 \nL 509.311222 443.157673 \nL 509.581554 441.76 \nL 510.339744 437.84 \nL 511.097934 433.92 \nL 511.856124 430 \nL 512.385602 427.262493 \nL 512.614315 426.08 \nL 513.372505 422.16 \nL 514.130695 418.24 \nL 514.888885 414.32 \nL 515.459982 411.367313 \nL 515.647076 410.4 \nL 516.405266 406.48 \nL 517.163456 402.56 \nL 517.921646 398.64 \nL 518.534362 395.472133 \nL 518.679837 394.72 \nL 519.438027 390.8 \nL 520.196217 386.88 \nL 520.954407 382.96 \nL 521.608742 379.576954 \nL 521.712598 379.04 \nL 522.470788 375.12 \nL 523.228978 371.2 \nL 523.987168 367.28 \nL 524.683122 363.681774 \nL 524.745359 363.36 \nL 525.503549 359.44 \nL 526.261739 355.52 \nL 527.019929 351.6 \nL 527.757503 347.786594 \nL 527.77812 347.68 \nL 528.53631 343.76 \nL 529.2945 339.84 \nL 530.05269 335.92 \nL 530.810881 332 \nL 530.831883 331.891415 \nL 531.569071 328.08 \nL 532.327261 324.16 \nL 533.085451 320.24 \nL 533.843642 316.32 \nL 533.906263 315.996235 \nL 534.601832 312.4 \nL 535.360022 308.48 \nL 536.118212 304.56 \nL 536.876403 300.64 \nL 536.980643 300.101055 \nL 537.634593 296.72 \nL 538.392783 292.8 \nL 539.150973 288.88 \nL 539.909164 284.96 \nL 540.055023 284.205875 \nL 540.667354 281.04 \nL 541.425544 277.12 \nL 542.183734 273.2 \nL 542.941925 269.28 \nL 543.129403 268.310696 \nL 543.700115 265.36 \nL 544.458305 261.44 \nL 545.216495 257.52 \nL 545.974686 253.6 \nL 546.203784 252.415516 \nL 546.732876 249.68 \nL 547.491066 245.76 \nL 548.249256 241.84 \nL 549.007447 237.92 \nL 549.278164 236.520336 \nL 549.765637 234 \nL 550.523827 230.08 \nL 551.282017 226.16 \nL 552.040208 222.24 \nL 552.352544 220.625156 \nL 552.798398 218.32 \nL 553.556588 214.4 \nL 554.314778 210.48 \nL 555.072968 206.56 \nL 555.426924 204.729977 \nL 555.831159 202.64 \nL 556.589349 198.72 \nL 557.347539 194.8 \nL 558.105729 190.88 \nL 558.501304 188.834797 \nL 558.86392 186.96 \nL 559.62211 183.04 \nL 560.3803 179.12 \nL 561.13849 175.2 \nL 561.575684 172.939617 \nL 561.896681 171.28 \nL 562.654871 167.36 \nL 563.413061 163.44 \nL 564.171251 159.52 \nL 564.650065 157.044437 \nL 564.929442 155.6 \nL 565.687632 151.68 \nL 566.445822 147.76 \nL 567.204012 143.84 \nL 567.724445 141.149258 \nL 567.962203 139.92 \nL 568.720393 136 \nL 569.478583 132.08 \nL 570.236773 128.16 \nL 570.798825 125.254078 \nL 570.994964 124.24 \nL 571.753154 120.32 \nL 572.511344 116.4 \nL 573.269534 112.48 \nL 573.873205 109.358898 \nL 574.027725 108.56 \nL 574.785915 104.64 \nL 575.544105 100.72 \nL 576.302295 96.8 \nL 576.947585 93.463718 \nL 577.060486 92.88 \nL 577.818676 88.96 \nL 578.576866 85.04 \nL 579.335056 81.12 \nL 580.021965 77.568539 \nL 580.093247 77.2 \nL 580.851437 73.28 \nL 581.609627 69.36 \nL 582.367817 65.44 \nL 583.096346 61.673359 \nL 583.126008 61.52 \nL 583.884198 57.6 \n\" clip-path=\"url(#pbd92fc0bac)\" style=\"fill: none; stroke-dasharray: 5.55,2.4; stroke-dashoffset: 0; stroke: #fde725; stroke-opacity: 0.5; stroke-width: 1.5\"/>\n   </g>\n   <g id=\"patch_9\">\n    <path d=\"M 407.856676 445.68 \nL 407.856676 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_10\">\n    <path d=\"M 712.220312 445.68 \nL 712.220312 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_11\">\n    <path d=\"M 407.856676 445.68 \nL 712.220312 445.68 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_12\">\n    <path d=\"M 407.856676 57.6 \nL 712.220312 57.6 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"text_41\">\n    <!-- Decision Boundary -->\n    <g transform=\"translate(503.690994 51.6) scale(0.12 -0.12)\">\n     <use xlink:href=\"#DejaVuSans-44\"/>\n     <use xlink:href=\"#DejaVuSans-65\" x=\"77.001953\"/>\n     <use xlink:href=\"#DejaVuSans-63\" x=\"138.525391\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"193.505859\"/>\n     <use xlink:href=\"#DejaVuSans-73\" x=\"221.289062\"/>\n     <use xlink:href=\"#DejaVuSans-69\" x=\"273.388672\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"301.171875\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"362.353516\"/>\n     <use xlink:href=\"#DejaVuSans-20\" x=\"425.732422\"/>\n     <use xlink:href=\"#DejaVuSans-42\" x=\"457.519531\"/>\n     <use xlink:href=\"#DejaVuSans-6f\" x=\"526.123047\"/>\n     <use xlink:href=\"#DejaVuSans-75\" x=\"587.304688\"/>\n     <use xlink:href=\"#DejaVuSans-6e\" x=\"650.683594\"/>\n     <use xlink:href=\"#DejaVuSans-64\" x=\"714.0625\"/>\n     <use xlink:href=\"#DejaVuSans-61\" x=\"777.539062\"/>\n     <use xlink:href=\"#DejaVuSans-72\" x=\"838.818359\"/>\n     <use xlink:href=\"#DejaVuSans-79\" x=\"879.931641\"/>\n    </g>\n   </g>\n   <g id=\"legend_2\">\n    <g id=\"patch_13\">\n     <path d=\"M 602.403125 138.990625 \nL 705.220312 138.990625 \nQ 707.220312 138.990625 707.220312 136.990625 \nL 707.220312 64.6 \nQ 707.220312 62.6 705.220312 62.6 \nL 602.403125 62.6 \nQ 600.403125 62.6 600.403125 64.6 \nL 600.403125 136.990625 \nQ 600.403125 138.990625 602.403125 138.990625 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"text_42\">\n     <!-- Data Points -->\n     <g transform=\"translate(625.26875 74.198437) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-44\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"77.001953\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"138.28125\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"177.490234\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"238.769531\"/>\n      <use xlink:href=\"#DejaVuSans-50\" x=\"270.556641\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"327.234375\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"388.416016\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"416.199219\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"479.578125\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"518.787109\"/>\n     </g>\n    </g>\n    <g id=\"line2d_35\">\n     <path d=\"M 604.403125 85.376562 \nL 614.403125 85.376562 \nL 624.403125 85.376562 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m26e437054e\" x=\"614.403125\" y=\"85.376562\" style=\"fill: #ffb000; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_43\">\n     <!-- Class 1 (Train) -->\n     <g transform=\"translate(632.403125 88.876562) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_36\">\n     <path d=\"M 604.403125 100.054687 \nL 614.403125 100.054687 \nL 624.403125 100.054687 \n\" style=\"fill: none; stroke: #ffffff; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m4484fa02a8\" x=\"614.403125\" y=\"100.054687\" style=\"fill: #1e88e5; stroke: #ffffff\"/>\n     </g>\n    </g>\n    <g id=\"text_44\">\n     <!-- Class 2 (Train) -->\n     <g transform=\"translate(632.403125 103.554687) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"475.630859\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"516.744141\"/>\n      <use xlink:href=\"#DejaVuSans-69\" x=\"578.023438\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"605.806641\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"669.185547\"/>\n     </g>\n    </g>\n    <g id=\"line2d_37\">\n     <path d=\"M 604.403125 114.732812 \nL 614.403125 114.732812 \nL 624.403125 114.732812 \n\" style=\"fill: none\"/>\n     <g>\n      <use xlink:href=\"#mad5660ea86\" x=\"614.403125\" y=\"114.732812\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_45\">\n     <!-- Class 1 (Test) -->\n     <g transform=\"translate(632.403125 118.232812) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n    <g id=\"line2d_38\">\n     <path d=\"M 604.403125 129.410937 \nL 614.403125 129.410937 \nL 624.403125 129.410937 \n\" style=\"fill: none\"/>\n     <g>\n      <use xlink:href=\"#m13b9e5a22b\" x=\"614.403125\" y=\"129.410937\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_46\">\n     <!-- Class 2 (Test) -->\n     <g transform=\"translate(632.403125 132.910937) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-43\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"69.824219\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"97.607422\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"158.886719\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"210.986328\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"263.085938\"/>\n      <use xlink:href=\"#DejaVuSans-32\" x=\"294.873047\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"358.496094\"/>\n      <use xlink:href=\"#DejaVuSans-28\" x=\"390.283203\"/>\n      <use xlink:href=\"#DejaVuSans-54\" x=\"429.296875\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"473.380859\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"534.904297\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"587.003906\"/>\n      <use xlink:href=\"#DejaVuSans-29\" x=\"626.212891\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n  <g id=\"text_47\">\n   <!-- Decision Boundary of Linear SVM -->\n   <g transform=\"translate(267.030625 16.318125) scale(0.12 -0.12)\">\n    <defs>\n     <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n     <path id=\"DejaVuSans-4c\" d=\"M 628 4666 \nL 1259 4666 \nL 1259 531 \nL 3531 531 \nL 3531 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n     <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \nL 3425 3897 \nQ 3066 4069 2747 4153 \nQ 2428 4238 2131 4238 \nQ 1616 4238 1336 4038 \nQ 1056 3838 1056 3469 \nQ 1056 3159 1242 3001 \nQ 1428 2844 1947 2747 \nL 2328 2669 \nQ 3034 2534 3370 2195 \nQ 3706 1856 3706 1288 \nQ 3706 609 3251 259 \nQ 2797 -91 1919 -91 \nQ 1588 -91 1214 -16 \nQ 841 59 441 206 \nL 441 856 \nQ 825 641 1194 531 \nQ 1563 422 1919 422 \nQ 2459 422 2753 634 \nQ 3047 847 3047 1241 \nQ 3047 1584 2836 1778 \nQ 2625 1972 2144 2069 \nL 1759 2144 \nQ 1053 2284 737 2584 \nQ 422 2884 422 3419 \nQ 422 4038 858 4394 \nQ 1294 4750 2059 4750 \nQ 2388 4750 2728 4690 \nQ 3069 4631 3425 4513 \nz\n\" transform=\"scale(0.015625)\"/>\n     <path id=\"DejaVuSans-56\" d=\"M 1831 0 \nL 50 4666 \nL 709 4666 \nL 2188 738 \nL 3669 4666 \nL 4325 4666 \nL 2547 0 \nL 1831 0 \nz\n\" transform=\"scale(0.015625)\"/>\n     <path id=\"DejaVuSans-4d\" d=\"M 628 4666 \nL 1569 4666 \nL 2759 1491 \nL 3956 4666 \nL 4897 4666 \nL 4897 0 \nL 4281 0 \nL 4281 4097 \nL 3078 897 \nL 2444 897 \nL 1241 4097 \nL 1241 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n    </defs>\n    <use xlink:href=\"#DejaVuSans-44\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"77.001953\"/>\n    <use xlink:href=\"#DejaVuSans-63\" x=\"138.525391\"/>\n    <use xlink:href=\"#DejaVuSans-69\" x=\"193.505859\"/>\n    <use xlink:href=\"#DejaVuSans-73\" x=\"221.289062\"/>\n    <use xlink:href=\"#DejaVuSans-69\" x=\"273.388672\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"301.171875\"/>\n    <use xlink:href=\"#DejaVuSans-6e\" x=\"362.353516\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"425.732422\"/>\n    <use xlink:href=\"#DejaVuSans-42\" x=\"457.519531\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"526.123047\"/>\n    <use xlink:href=\"#DejaVuSans-75\" x=\"587.304688\"/>\n    <use xlink:href=\"#DejaVuSans-6e\" x=\"650.683594\"/>\n    <use xlink:href=\"#DejaVuSans-64\" x=\"714.0625\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"777.539062\"/>\n    <use xlink:href=\"#DejaVuSans-72\" x=\"838.818359\"/>\n    <use xlink:href=\"#DejaVuSans-79\" x=\"879.931641\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"939.111328\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"970.898438\"/>\n    <use xlink:href=\"#DejaVuSans-66\" x=\"1032.080078\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1067.285156\"/>\n    <use xlink:href=\"#DejaVuSans-4c\" x=\"1099.072266\"/>\n    <use xlink:href=\"#DejaVuSans-69\" x=\"1154.785156\"/>\n    <use xlink:href=\"#DejaVuSans-6e\" x=\"1182.568359\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"1245.947266\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"1307.470703\"/>\n    <use xlink:href=\"#DejaVuSans-72\" x=\"1368.75\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1409.863281\"/>\n    <use xlink:href=\"#DejaVuSans-53\" x=\"1441.650391\"/>\n    <use xlink:href=\"#DejaVuSans-56\" x=\"1505.126953\"/>\n    <use xlink:href=\"#DejaVuSans-4d\" x=\"1573.535156\"/>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p721f0d28e5\">\n   <rect x=\"42.620313\" y=\"57.6\" width=\"304.363636\" height=\"388.08\"/>\n  </clipPath>\n  <clipPath id=\"pbd92fc0bac\">\n   <rect x=\"407.856676\" y=\"57.6\" width=\"304.363636\" height=\"388.08\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_decision_boundary(ax, classifier, X_train, y_train, X_test, y_test):\n",
+    "    classifier.fit(X_train, y_train)\n",
+    "    plot_synthetic_data(ax, X_train, y_train, X_test, y_test, \"Synthetic Classification Data\")\n",
+    "    DecisionBoundaryDisplay.from_estimator(\n",
+    "        classifier,\n",
+    "        X_train,\n",
+    "        plot_method=\"contour\",\n",
+    "        ax=ax,\n",
+    "        levels=[-1, 0, 1],\n",
+    "        linestyles=[\"--\", \"-\", \"--\"],\n",
+    "        alpha=0.5,\n",
+    "    )\n",
+    "    ax.set_xlabel(\"Feature 1\")\n",
+    "    ax.set_ylabel(\"Feature 2\")\n",
+    "    ax.set_title(\"Decision Boundary\")\n",
+    "\n",
+    "\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 7))\n",
+    "fig.suptitle(\"Decision Boundary of Linear SVM\")\n",
+    "# Plot the decision boundary of the model with corrupted samples\n",
+    "plot_decision_boundary(ax[0], classifier, corrupted_X_train, corruped_y_train, X_test, y_test)\n",
+    "\n",
+    "# Plot the decision boundary of the model with removed corrupted samples\n",
+    "plot_decision_boundary(ax[1], classifier, cleaned_X_train, cleaned_y_train, X_test, y_test)\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:40.881221Z",
+     "start_time": "2024-10-22T16:04:40.641575Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Real Data\n",
+    "We now demonstrate the data valuation for the [AdultCensus](../api/shapiq.datasets.rst) dataset.\n",
+    "Due to increasing runtime we choose a subset of the data, consisting of 200 samples.\n",
+    "Then we divide the data into training and test data at an 80/20 ratio."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Players:  160\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "X, y = shapiq.load_adult_census(to_numpy=True)\n",
+    "\n",
+    "X, y = X[:200], y[:200]\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=random_state)\n",
+    "classifier = DecisionTreeClassifier(random_state=random_state)\n",
+    "n_players = X_train.shape[0]\n",
+    "print(\"Players: \", n_players)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:41.055176Z",
+     "start_time": "2024-10-22T16:04:40.879435Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "outputs": [],
+   "source": [
+    "data_valuation_game = SyntheticDataValuation(\n",
+    "    classifier=classifier,\n",
+    "    n_players=n_players,\n",
+    "    X_train=X_train,\n",
+    "    y_train=y_train,\n",
+    "    X_test=X_test,\n",
+    "    y_test=y_test,\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:04:41.056814Z",
+     "start_time": "2024-10-22T16:04:41.055761Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In the next step we show how different budgets influence the quality of approximation and the corresponding accuracy tradeoff."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 640x480 with 1 Axes>",
+      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"420.780625pt\" height=\"345.42825pt\" viewBox=\"0 0 420.780625 345.42825\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n <metadata>\n  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n   <cc:Work>\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n    <dc:date>2024-10-22T18:05:15.036777</dc:date>\n    <dc:format>image/svg+xml</dc:format>\n    <dc:creator>\n     <cc:Agent>\n      <dc:title>Matplotlib v3.8.0, https://matplotlib.org/</dc:title>\n     </cc:Agent>\n    </dc:creator>\n   </cc:Work>\n  </rdf:RDF>\n </metadata>\n <defs>\n  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 345.42825 \nL 420.780625 345.42825 \nL 420.780625 -0 \nL 0 -0 \nz\n\" style=\"fill: #ffffff\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g id=\"patch_2\">\n    <path d=\"M 50.14375 307.872 \nL 407.26375 307.872 \nL 407.26375 41.76 \nL 50.14375 41.76 \nz\n\" style=\"fill: #ffffff\"/>\n   </g>\n   <g id=\"matplotlib.axis_1\">\n    <g id=\"xtick_1\">\n     <g id=\"line2d_1\">\n      <defs>\n       <path id=\"ma89690ed6d\" d=\"M 0 0 \nL 0 3.5 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#ma89690ed6d\" x=\"66.376477\" y=\"307.872\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_1\">\n      <!-- 0.0 -->\n      <g transform=\"translate(58.424915 322.470438) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \nQ 1547 4250 1301 3770 \nQ 1056 3291 1056 2328 \nQ 1056 1369 1301 889 \nQ 1547 409 2034 409 \nQ 2525 409 2770 889 \nQ 3016 1369 3016 2328 \nQ 3016 3291 2770 3770 \nQ 2525 4250 2034 4250 \nz\nM 2034 4750 \nQ 2819 4750 3233 4129 \nQ 3647 3509 3647 2328 \nQ 3647 1150 3233 529 \nQ 2819 -91 2034 -91 \nQ 1250 -91 836 529 \nQ 422 1150 422 2328 \nQ 422 3509 836 4129 \nQ 1250 4750 2034 4750 \nz\n\" transform=\"scale(0.015625)\"/>\n        <path id=\"DejaVuSans-2e\" d=\"M 684 794 \nL 1344 794 \nL 1344 0 \nL 684 0 \nL 684 794 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_2\">\n     <g id=\"line2d_2\">\n      <g>\n       <use xlink:href=\"#ma89690ed6d\" x=\"138.521932\" y=\"307.872\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_2\">\n      <!-- 0.2 -->\n      <g transform=\"translate(130.570369 322.470438) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \nL 3431 531 \nL 3431 0 \nL 469 0 \nL 469 531 \nQ 828 903 1448 1529 \nQ 2069 2156 2228 2338 \nQ 2531 2678 2651 2914 \nQ 2772 3150 2772 3378 \nQ 2772 3750 2511 3984 \nQ 2250 4219 1831 4219 \nQ 1534 4219 1204 4116 \nQ 875 4013 500 3803 \nL 500 4441 \nQ 881 4594 1212 4672 \nQ 1544 4750 1819 4750 \nQ 2544 4750 2975 4387 \nQ 3406 4025 3406 3419 \nQ 3406 3131 3298 2873 \nQ 3191 2616 2906 2266 \nQ 2828 2175 2409 1742 \nQ 1991 1309 1228 531 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-32\" x=\"95.410156\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_3\">\n     <g id=\"line2d_3\">\n      <g>\n       <use xlink:href=\"#ma89690ed6d\" x=\"210.667386\" y=\"307.872\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_3\">\n      <!-- 0.4 -->\n      <g transform=\"translate(202.715824 322.470438) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \nL 825 1625 \nL 2419 1625 \nL 2419 4116 \nz\nM 2253 4666 \nL 3047 4666 \nL 3047 1625 \nL 3713 1625 \nL 3713 1100 \nL 3047 1100 \nL 3047 0 \nL 2419 0 \nL 2419 1100 \nL 313 1100 \nL 313 1709 \nL 2253 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-34\" x=\"95.410156\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_4\">\n     <g id=\"line2d_4\">\n      <g>\n       <use xlink:href=\"#ma89690ed6d\" x=\"282.812841\" y=\"307.872\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_4\">\n      <!-- 0.6 -->\n      <g transform=\"translate(274.861278 322.470438) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \nQ 1688 2584 1439 2293 \nQ 1191 2003 1191 1497 \nQ 1191 994 1439 701 \nQ 1688 409 2113 409 \nQ 2538 409 2786 701 \nQ 3034 994 3034 1497 \nQ 3034 2003 2786 2293 \nQ 2538 2584 2113 2584 \nz\nM 3366 4563 \nL 3366 3988 \nQ 3128 4100 2886 4159 \nQ 2644 4219 2406 4219 \nQ 1781 4219 1451 3797 \nQ 1122 3375 1075 2522 \nQ 1259 2794 1537 2939 \nQ 1816 3084 2150 3084 \nQ 2853 3084 3261 2657 \nQ 3669 2231 3669 1497 \nQ 3669 778 3244 343 \nQ 2819 -91 2113 -91 \nQ 1303 -91 875 529 \nQ 447 1150 447 2328 \nQ 447 3434 972 4092 \nQ 1497 4750 2381 4750 \nQ 2619 4750 2861 4703 \nQ 3103 4656 3366 4563 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"95.410156\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"xtick_5\">\n     <g id=\"line2d_5\">\n      <g>\n       <use xlink:href=\"#ma89690ed6d\" x=\"354.958295\" y=\"307.872\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_5\">\n      <!-- 0.8 -->\n      <g transform=\"translate(347.006733 322.470438) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \nQ 1584 2216 1326 1975 \nQ 1069 1734 1069 1313 \nQ 1069 891 1326 650 \nQ 1584 409 2034 409 \nQ 2484 409 2743 651 \nQ 3003 894 3003 1313 \nQ 3003 1734 2745 1975 \nQ 2488 2216 2034 2216 \nz\nM 1403 2484 \nQ 997 2584 770 2862 \nQ 544 3141 544 3541 \nQ 544 4100 942 4425 \nQ 1341 4750 2034 4750 \nQ 2731 4750 3128 4425 \nQ 3525 4100 3525 3541 \nQ 3525 3141 3298 2862 \nQ 3072 2584 2669 2484 \nQ 3125 2378 3379 2068 \nQ 3634 1759 3634 1313 \nQ 3634 634 3220 271 \nQ 2806 -91 2034 -91 \nQ 1263 -91 848 271 \nQ 434 634 434 1313 \nQ 434 1759 690 2068 \nQ 947 2378 1403 2484 \nz\nM 1172 3481 \nQ 1172 3119 1398 2916 \nQ 1625 2713 2034 2713 \nQ 2441 2713 2670 2916 \nQ 2900 3119 2900 3481 \nQ 2900 3844 2670 4047 \nQ 2441 4250 2034 4250 \nQ 1625 4250 1398 4047 \nQ 1172 3844 1172 3481 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"95.410156\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_6\">\n     <!-- Percentage of removed samples -->\n     <g transform=\"translate(148.051406 336.148562) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \nL 1259 2394 \nL 2053 2394 \nQ 2494 2394 2734 2622 \nQ 2975 2850 2975 3272 \nQ 2975 3691 2734 3919 \nQ 2494 4147 2053 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2053 4666 \nQ 2838 4666 3239 4311 \nQ 3641 3956 3641 3272 \nQ 3641 2581 3239 2228 \nQ 2838 1875 2053 1875 \nL 1259 1875 \nL 1259 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \nL 3597 1613 \nL 953 1613 \nQ 991 1019 1311 708 \nQ 1631 397 2203 397 \nQ 2534 397 2845 478 \nQ 3156 559 3463 722 \nL 3463 178 \nQ 3153 47 2828 -22 \nQ 2503 -91 2169 -91 \nQ 1331 -91 842 396 \nQ 353 884 353 1716 \nQ 353 2575 817 3079 \nQ 1281 3584 2069 3584 \nQ 2775 3584 3186 3129 \nQ 3597 2675 3597 1894 \nz\nM 3022 2063 \nQ 3016 2534 2758 2815 \nQ 2500 3097 2075 3097 \nQ 1594 3097 1305 2825 \nQ 1016 2553 972 2059 \nL 3022 2063 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \nQ 2534 3019 2420 3045 \nQ 2306 3072 2169 3072 \nQ 1681 3072 1420 2755 \nQ 1159 2438 1159 1844 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1341 3275 1631 3429 \nQ 1922 3584 2338 3584 \nQ 2397 3584 2469 3576 \nQ 2541 3569 2628 3553 \nL 2631 2963 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \nL 3122 2828 \nQ 2878 2963 2633 3030 \nQ 2388 3097 2138 3097 \nQ 1578 3097 1268 2742 \nQ 959 2388 959 1747 \nQ 959 1106 1268 751 \nQ 1578 397 2138 397 \nQ 2388 397 2633 464 \nQ 2878 531 3122 666 \nL 3122 134 \nQ 2881 22 2623 -34 \nQ 2366 -91 2075 -91 \nQ 1284 -91 818 406 \nQ 353 903 353 1747 \nQ 353 2603 823 3093 \nQ 1294 3584 2113 3584 \nQ 2378 3584 2631 3529 \nQ 2884 3475 3122 3366 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \nL 1172 3500 \nL 2356 3500 \nL 2356 3053 \nL 1172 3053 \nL 1172 1153 \nQ 1172 725 1289 603 \nQ 1406 481 1766 481 \nL 2356 481 \nL 2356 0 \nL 1766 0 \nQ 1100 0 847 248 \nQ 594 497 594 1153 \nL 594 3053 \nL 172 3053 \nL 172 3500 \nL 594 3500 \nL 594 4494 \nL 1172 4494 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \nQ 1497 1759 1228 1600 \nQ 959 1441 959 1056 \nQ 959 750 1161 570 \nQ 1363 391 1709 391 \nQ 2188 391 2477 730 \nQ 2766 1069 2766 1631 \nL 2766 1759 \nL 2194 1759 \nz\nM 3341 1997 \nL 3341 0 \nL 2766 0 \nL 2766 531 \nQ 2569 213 2275 61 \nQ 1981 -91 1556 -91 \nQ 1019 -91 701 211 \nQ 384 513 384 1019 \nQ 384 1609 779 1909 \nQ 1175 2209 1959 2209 \nL 2766 2209 \nL 2766 2266 \nQ 2766 2663 2505 2880 \nQ 2244 3097 1772 3097 \nQ 1472 3097 1187 3025 \nQ 903 2953 641 2809 \nL 641 3341 \nQ 956 3463 1253 3523 \nQ 1550 3584 1831 3584 \nQ 2591 3584 2966 3190 \nQ 3341 2797 3341 1997 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-67\" d=\"M 2906 1791 \nQ 2906 2416 2648 2759 \nQ 2391 3103 1925 3103 \nQ 1463 3103 1205 2759 \nQ 947 2416 947 1791 \nQ 947 1169 1205 825 \nQ 1463 481 1925 481 \nQ 2391 481 2648 825 \nQ 2906 1169 2906 1791 \nz\nM 3481 434 \nQ 3481 -459 3084 -895 \nQ 2688 -1331 1869 -1331 \nQ 1566 -1331 1297 -1286 \nQ 1028 -1241 775 -1147 \nL 775 -588 \nQ 1028 -725 1275 -790 \nQ 1522 -856 1778 -856 \nQ 2344 -856 2625 -561 \nQ 2906 -266 2906 331 \nL 2906 616 \nQ 2728 306 2450 153 \nQ 2172 0 1784 0 \nQ 1141 0 747 490 \nQ 353 981 353 1791 \nQ 353 2603 747 3093 \nQ 1141 3584 1784 3584 \nQ 2172 3584 2450 3431 \nQ 2728 3278 2906 2969 \nL 2906 3500 \nL 3481 3500 \nL 3481 434 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \nQ 1497 3097 1228 2736 \nQ 959 2375 959 1747 \nQ 959 1119 1226 758 \nQ 1494 397 1959 397 \nQ 2419 397 2687 759 \nQ 2956 1122 2956 1747 \nQ 2956 2369 2687 2733 \nQ 2419 3097 1959 3097 \nz\nM 1959 3584 \nQ 2709 3584 3137 3096 \nQ 3566 2609 3566 1747 \nQ 3566 888 3137 398 \nQ 2709 -91 1959 -91 \nQ 1206 -91 779 398 \nQ 353 888 353 1747 \nQ 353 2609 779 3096 \nQ 1206 3584 1959 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \nL 2375 4384 \nL 1825 4384 \nQ 1516 4384 1395 4259 \nQ 1275 4134 1275 3809 \nL 1275 3500 \nL 2222 3500 \nL 2222 3053 \nL 1275 3053 \nL 1275 0 \nL 697 0 \nL 697 3053 \nL 147 3053 \nL 147 3500 \nL 697 3500 \nL 697 3744 \nQ 697 4328 969 4595 \nQ 1241 4863 1831 4863 \nL 2375 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6d\" d=\"M 3328 2828 \nQ 3544 3216 3844 3400 \nQ 4144 3584 4550 3584 \nQ 5097 3584 5394 3201 \nQ 5691 2819 5691 2113 \nL 5691 0 \nL 5113 0 \nL 5113 2094 \nQ 5113 2597 4934 2840 \nQ 4756 3084 4391 3084 \nQ 3944 3084 3684 2787 \nQ 3425 2491 3425 1978 \nL 3425 0 \nL 2847 0 \nL 2847 2094 \nQ 2847 2600 2669 2842 \nQ 2491 3084 2119 3084 \nQ 1678 3084 1418 2786 \nQ 1159 2488 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 3500 \nL 1159 3500 \nL 1159 2956 \nQ 1356 3278 1631 3431 \nQ 1906 3584 2284 3584 \nQ 2666 3584 2933 3390 \nQ 3200 3197 3328 2828 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-76\" d=\"M 191 3500 \nL 800 3500 \nL 1894 563 \nL 2988 3500 \nL 3597 3500 \nL 2284 0 \nL 1503 0 \nL 191 3500 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \nL 2906 4863 \nL 3481 4863 \nL 3481 0 \nL 2906 0 \nL 2906 525 \nQ 2725 213 2448 61 \nQ 2172 -91 1784 -91 \nQ 1150 -91 751 415 \nQ 353 922 353 1747 \nQ 353 2572 751 3078 \nQ 1150 3584 1784 3584 \nQ 2172 3584 2448 3432 \nQ 2725 3281 2906 2969 \nz\nM 947 1747 \nQ 947 1113 1208 752 \nQ 1469 391 1925 391 \nQ 2381 391 2643 752 \nQ 2906 1113 2906 1747 \nQ 2906 2381 2643 2742 \nQ 2381 3103 1925 3103 \nQ 1469 3103 1208 2742 \nQ 947 2381 947 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \nL 2834 2853 \nQ 2591 2978 2328 3040 \nQ 2066 3103 1784 3103 \nQ 1356 3103 1142 2972 \nQ 928 2841 928 2578 \nQ 928 2378 1081 2264 \nQ 1234 2150 1697 2047 \nL 1894 2003 \nQ 2506 1872 2764 1633 \nQ 3022 1394 3022 966 \nQ 3022 478 2636 193 \nQ 2250 -91 1575 -91 \nQ 1294 -91 989 -36 \nQ 684 19 347 128 \nL 347 722 \nQ 666 556 975 473 \nQ 1284 391 1588 391 \nQ 1994 391 2212 530 \nQ 2431 669 2431 922 \nQ 2431 1156 2273 1281 \nQ 2116 1406 1581 1522 \nL 1381 1569 \nQ 847 1681 609 1914 \nQ 372 2147 372 2553 \nQ 372 3047 722 3315 \nQ 1072 3584 1716 3584 \nQ 2034 3584 2315 3537 \nQ 2597 3491 2834 3397 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-70\" d=\"M 1159 525 \nL 1159 -1331 \nL 581 -1331 \nL 581 3500 \nL 1159 3500 \nL 1159 2969 \nQ 1341 3281 1617 3432 \nQ 1894 3584 2278 3584 \nQ 2916 3584 3314 3078 \nQ 3713 2572 3713 1747 \nQ 3713 922 3314 415 \nQ 2916 -91 2278 -91 \nQ 1894 -91 1617 61 \nQ 1341 213 1159 525 \nz\nM 3116 1747 \nQ 3116 2381 2855 2742 \nQ 2594 3103 2138 3103 \nQ 1681 3103 1420 2742 \nQ 1159 2381 1159 1747 \nQ 1159 1113 1420 752 \nQ 1681 391 2138 391 \nQ 2594 391 2855 752 \nQ 3116 1113 3116 1747 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \nL 1178 4863 \nL 1178 0 \nL 603 0 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-50\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"56.677734\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"118.201172\"/>\n      <use xlink:href=\"#DejaVuSans-63\" x=\"157.064453\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"212.044922\"/>\n      <use xlink:href=\"#DejaVuSans-6e\" x=\"273.568359\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"336.947266\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"376.15625\"/>\n      <use xlink:href=\"#DejaVuSans-67\" x=\"437.435547\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"500.912109\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"562.435547\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"594.222656\"/>\n      <use xlink:href=\"#DejaVuSans-66\" x=\"655.404297\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"690.609375\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"722.396484\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"761.259766\"/>\n      <use xlink:href=\"#DejaVuSans-6d\" x=\"822.783203\"/>\n      <use xlink:href=\"#DejaVuSans-6f\" x=\"920.195312\"/>\n      <use xlink:href=\"#DejaVuSans-76\" x=\"981.376953\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"1040.556641\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"1102.080078\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"1165.556641\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"1197.34375\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"1249.443359\"/>\n      <use xlink:href=\"#DejaVuSans-6d\" x=\"1310.722656\"/>\n      <use xlink:href=\"#DejaVuSans-70\" x=\"1408.134766\"/>\n      <use xlink:href=\"#DejaVuSans-6c\" x=\"1471.611328\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"1499.394531\"/>\n      <use xlink:href=\"#DejaVuSans-73\" x=\"1560.917969\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"matplotlib.axis_2\">\n    <g id=\"ytick_1\">\n     <g id=\"line2d_6\">\n      <defs>\n       <path id=\"md580d0c50f\" d=\"M 0 0 \nL -3.5 0 \n\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </defs>\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"295.776\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_7\">\n      <!-- 0.60 -->\n      <g transform=\"translate(20.878125 299.575219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_2\">\n     <g id=\"line2d_7\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"261.216\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_8\">\n      <!-- 0.65 -->\n      <g transform=\"translate(20.878125 265.015219) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-35\" d=\"M 691 4666 \nL 3169 4666 \nL 3169 4134 \nL 1269 4134 \nL 1269 2991 \nQ 1406 3038 1543 3061 \nQ 1681 3084 1819 3084 \nQ 2600 3084 3056 2656 \nQ 3513 2228 3513 1497 \nQ 3513 744 3044 326 \nQ 2575 -91 1722 -91 \nQ 1428 -91 1123 -41 \nQ 819 9 494 109 \nL 494 744 \nQ 775 591 1075 516 \nQ 1375 441 1709 441 \nQ 2250 441 2565 725 \nQ 2881 1009 2881 1497 \nQ 2881 1984 2565 2268 \nQ 2250 2553 1709 2553 \nQ 1456 2553 1204 2497 \nQ 953 2441 691 2322 \nL 691 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-36\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_3\">\n     <g id=\"line2d_8\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"226.656\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_9\">\n      <!-- 0.70 -->\n      <g transform=\"translate(20.878125 230.455219) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-37\" d=\"M 525 4666 \nL 3525 4666 \nL 3525 4397 \nL 1831 0 \nL 1172 0 \nL 2766 4134 \nL 525 4134 \nL 525 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-37\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_4\">\n     <g id=\"line2d_9\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"192.096\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_10\">\n      <!-- 0.75 -->\n      <g transform=\"translate(20.878125 195.895219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-37\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_5\">\n     <g id=\"line2d_10\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"157.536\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_11\">\n      <!-- 0.80 -->\n      <g transform=\"translate(20.878125 161.335219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_6\">\n     <g id=\"line2d_11\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"122.976\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_12\">\n      <!-- 0.85 -->\n      <g transform=\"translate(20.878125 126.775219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-38\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_7\">\n     <g id=\"line2d_12\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"88.416\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_13\">\n      <!-- 0.90 -->\n      <g transform=\"translate(20.878125 92.215219) scale(0.1 -0.1)\">\n       <defs>\n        <path id=\"DejaVuSans-39\" d=\"M 703 97 \nL 703 672 \nQ 941 559 1184 500 \nQ 1428 441 1663 441 \nQ 2288 441 2617 861 \nQ 2947 1281 2994 2138 \nQ 2813 1869 2534 1725 \nQ 2256 1581 1919 1581 \nQ 1219 1581 811 2004 \nQ 403 2428 403 3163 \nQ 403 3881 828 4315 \nQ 1253 4750 1959 4750 \nQ 2769 4750 3195 4129 \nQ 3622 3509 3622 2328 \nQ 3622 1225 3098 567 \nQ 2575 -91 1691 -91 \nQ 1453 -91 1209 -44 \nQ 966 3 703 97 \nz\nM 1959 2075 \nQ 2384 2075 2632 2365 \nQ 2881 2656 2881 3163 \nQ 2881 3666 2632 3958 \nQ 2384 4250 1959 4250 \nQ 1534 4250 1286 3958 \nQ 1038 3666 1038 3163 \nQ 1038 2656 1286 2365 \nQ 1534 2075 1959 2075 \nz\n\" transform=\"scale(0.015625)\"/>\n       </defs>\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-39\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"ytick_8\">\n     <g id=\"line2d_13\">\n      <g>\n       <use xlink:href=\"#md580d0c50f\" x=\"50.14375\" y=\"53.856\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n      </g>\n     </g>\n     <g id=\"text_14\">\n      <!-- 0.95 -->\n      <g transform=\"translate(20.878125 57.655219) scale(0.1 -0.1)\">\n       <use xlink:href=\"#DejaVuSans-30\"/>\n       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n       <use xlink:href=\"#DejaVuSans-39\" x=\"95.410156\"/>\n       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n      </g>\n     </g>\n    </g>\n    <g id=\"text_15\">\n     <!-- Accuracy -->\n     <g transform=\"translate(14.798438 197.644125) rotate(-90) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-41\" d=\"M 2188 4044 \nL 1331 1722 \nL 3047 1722 \nL 2188 4044 \nz\nM 1831 4666 \nL 2547 4666 \nL 4325 0 \nL 3669 0 \nL 3244 1197 \nL 1141 1197 \nL 716 0 \nL 50 0 \nL 1831 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \nL 544 3500 \nL 1119 3500 \nL 1119 1403 \nQ 1119 906 1312 657 \nQ 1506 409 1894 409 \nQ 2359 409 2629 706 \nQ 2900 1003 2900 1516 \nL 2900 3500 \nL 3475 3500 \nL 3475 0 \nL 2900 0 \nL 2900 538 \nQ 2691 219 2414 64 \nQ 2138 -91 1772 -91 \nQ 1169 -91 856 284 \nQ 544 659 544 1381 \nz\nM 1991 3584 \nL 1991 3584 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \nQ 1816 -950 1584 -1140 \nQ 1353 -1331 966 -1331 \nL 506 -1331 \nL 506 -850 \nL 844 -850 \nQ 1081 -850 1212 -737 \nQ 1344 -625 1503 -206 \nL 1606 56 \nL 191 3500 \nL 800 3500 \nL 1894 763 \nL 2988 3500 \nL 3597 3500 \nL 2059 -325 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-41\"/>\n      <use xlink:href=\"#DejaVuSans-63\" x=\"66.658203\"/>\n      <use xlink:href=\"#DejaVuSans-63\" x=\"121.638672\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"176.619141\"/>\n      <use xlink:href=\"#DejaVuSans-72\" x=\"239.998047\"/>\n      <use xlink:href=\"#DejaVuSans-61\" x=\"281.111328\"/>\n      <use xlink:href=\"#DejaVuSans-63\" x=\"342.390625\"/>\n      <use xlink:href=\"#DejaVuSans-79\" x=\"397.371094\"/>\n     </g>\n    </g>\n   </g>\n   <g id=\"line2d_14\">\n    <path d=\"M 66.376477 157.536 \nL 102.449205 209.376 \nL 138.521932 71.136 \nL 174.594659 192.096 \nL 210.667386 226.656 \nL 246.740114 122.976 \nL 282.812841 157.536 \nL 318.885568 192.096 \nL 354.958295 122.976 \nL 391.031023 174.816 \n\" clip-path=\"url(#pa8053001c0)\" style=\"fill: none; stroke: #d81b60; stroke-width: 1.5; stroke-linecap: square\"/>\n    <defs>\n     <path id=\"m9b5e234220\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\" style=\"stroke: #d81b60\"/>\n    </defs>\n    <g clip-path=\"url(#pa8053001c0)\">\n     <use xlink:href=\"#m9b5e234220\" x=\"66.376477\" y=\"157.536\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"102.449205\" y=\"209.376\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"138.521932\" y=\"71.136\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"174.594659\" y=\"192.096\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"210.667386\" y=\"226.656\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"246.740114\" y=\"122.976\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"282.812841\" y=\"157.536\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"318.885568\" y=\"192.096\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"354.958295\" y=\"122.976\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     <use xlink:href=\"#m9b5e234220\" x=\"391.031023\" y=\"174.816\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n    </g>\n   </g>\n   <g id=\"line2d_15\">\n    <path d=\"M 66.376477 157.536 \nL 102.449205 157.536 \nL 138.521932 71.136 \nL 174.594659 140.256 \nL 210.667386 140.256 \nL 246.740114 53.856 \nL 282.812841 140.256 \nL 318.885568 209.376 \nL 354.958295 295.776 \nL 391.031023 295.776 \n\" clip-path=\"url(#pa8053001c0)\" style=\"fill: none; stroke: #ffb000; stroke-width: 1.5; stroke-linecap: square\"/>\n    <defs>\n     <path id=\"m3726874445\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\" style=\"stroke: #ffb000\"/>\n    </defs>\n    <g clip-path=\"url(#pa8053001c0)\">\n     <use xlink:href=\"#m3726874445\" x=\"66.376477\" y=\"157.536\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"102.449205\" y=\"157.536\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"138.521932\" y=\"71.136\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"174.594659\" y=\"140.256\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"210.667386\" y=\"140.256\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"246.740114\" y=\"53.856\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"282.812841\" y=\"140.256\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"318.885568\" y=\"209.376\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"354.958295\" y=\"295.776\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     <use xlink:href=\"#m3726874445\" x=\"391.031023\" y=\"295.776\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n    </g>\n   </g>\n   <g id=\"line2d_16\">\n    <path d=\"M 66.376477 157.536 \nL 102.449205 174.816 \nL 138.521932 88.416 \nL 174.594659 122.976 \nL 210.667386 140.256 \nL 246.740114 174.816 \nL 282.812841 122.976 \nL 318.885568 174.816 \nL 354.958295 192.096 \nL 391.031023 157.536 \n\" clip-path=\"url(#pa8053001c0)\" style=\"fill: none; stroke: #1e88e5; stroke-width: 1.5; stroke-linecap: square\"/>\n    <defs>\n     <path id=\"m676da127a1\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\" style=\"stroke: #1e88e5\"/>\n    </defs>\n    <g clip-path=\"url(#pa8053001c0)\">\n     <use xlink:href=\"#m676da127a1\" x=\"66.376477\" y=\"157.536\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"102.449205\" y=\"174.816\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"138.521932\" y=\"88.416\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"174.594659\" y=\"122.976\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"210.667386\" y=\"140.256\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"246.740114\" y=\"174.816\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"282.812841\" y=\"122.976\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"318.885568\" y=\"174.816\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"354.958295\" y=\"192.096\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     <use xlink:href=\"#m676da127a1\" x=\"391.031023\" y=\"157.536\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n    </g>\n   </g>\n   <g id=\"line2d_17\">\n    <path d=\"M 66.376477 157.536 \nL 102.449205 88.416 \nL 138.521932 88.416 \nL 174.594659 71.136 \nL 210.667386 122.976 \nL 246.740114 122.976 \nL 282.812841 105.696 \nL 318.885568 53.856 \nL 354.958295 157.536 \nL 391.031023 192.096 \n\" clip-path=\"url(#pa8053001c0)\" style=\"fill: none; stroke: #fe6100; stroke-width: 1.5; stroke-linecap: square\"/>\n    <defs>\n     <path id=\"m716510116f\" d=\"M 0 3 \nC 0.795609 3 1.55874 2.683901 2.12132 2.12132 \nC 2.683901 1.55874 3 0.795609 3 0 \nC 3 -0.795609 2.683901 -1.55874 2.12132 -2.12132 \nC 1.55874 -2.683901 0.795609 -3 0 -3 \nC -0.795609 -3 -1.55874 -2.683901 -2.12132 -2.12132 \nC -2.683901 -1.55874 -3 -0.795609 -3 0 \nC -3 0.795609 -2.683901 1.55874 -2.12132 2.12132 \nC -1.55874 2.683901 -0.795609 3 0 3 \nz\n\" style=\"stroke: #fe6100\"/>\n    </defs>\n    <g clip-path=\"url(#pa8053001c0)\">\n     <use xlink:href=\"#m716510116f\" x=\"66.376477\" y=\"157.536\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"102.449205\" y=\"88.416\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"138.521932\" y=\"88.416\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"174.594659\" y=\"71.136\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"210.667386\" y=\"122.976\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"246.740114\" y=\"122.976\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"282.812841\" y=\"105.696\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"318.885568\" y=\"53.856\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"354.958295\" y=\"157.536\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     <use xlink:href=\"#m716510116f\" x=\"391.031023\" y=\"192.096\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n    </g>\n   </g>\n   <g id=\"patch_3\">\n    <path d=\"M 50.14375 307.872 \nL 50.14375 41.76 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_4\">\n    <path d=\"M 407.26375 307.872 \nL 407.26375 41.76 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_5\">\n    <path d=\"M 50.14375 307.872 \nL 407.26375 307.872 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"patch_6\">\n    <path d=\"M 50.14375 41.76 \nL 407.26375 41.76 \n\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n   </g>\n   <g id=\"legend_1\">\n    <g id=\"patch_7\">\n     <path d=\"M 57.14375 302.872 \nL 157.109375 302.872 \nQ 159.109375 302.872 159.109375 300.872 \nL 159.109375 243.1595 \nQ 159.109375 241.1595 157.109375 241.1595 \nL 57.14375 241.1595 \nQ 55.14375 241.1595 55.14375 243.1595 \nL 55.14375 300.872 \nQ 55.14375 302.872 57.14375 302.872 \nz\n\" style=\"fill: #ffffff; opacity: 0.8; stroke: #cccccc; stroke-linejoin: miter\"/>\n    </g>\n    <g id=\"line2d_18\">\n     <path d=\"M 59.14375 249.257937 \nL 69.14375 249.257937 \nL 79.14375 249.257937 \n\" style=\"fill: none; stroke: #d81b60; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m9b5e234220\" x=\"69.14375\" y=\"249.257937\" style=\"fill: #d81b60; stroke: #d81b60\"/>\n     </g>\n    </g>\n    <g id=\"text_16\">\n     <!-- Budget: 10 -->\n     <g transform=\"translate(87.14375 252.757937) scale(0.1 -0.1)\">\n      <defs>\n       <path id=\"DejaVuSans-42\" d=\"M 1259 2228 \nL 1259 519 \nL 2272 519 \nQ 2781 519 3026 730 \nQ 3272 941 3272 1375 \nQ 3272 1813 3026 2020 \nQ 2781 2228 2272 2228 \nL 1259 2228 \nz\nM 1259 4147 \nL 1259 2741 \nL 2194 2741 \nQ 2656 2741 2882 2914 \nQ 3109 3088 3109 3444 \nQ 3109 3797 2882 3972 \nQ 2656 4147 2194 4147 \nL 1259 4147 \nz\nM 628 4666 \nL 2241 4666 \nQ 2963 4666 3353 4366 \nQ 3744 4066 3744 3513 \nQ 3744 3084 3544 2831 \nQ 3344 2578 2956 2516 \nQ 3422 2416 3680 2098 \nQ 3938 1781 3938 1306 \nQ 3938 681 3513 340 \nQ 3088 0 2303 0 \nL 628 0 \nL 628 4666 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-3a\" d=\"M 750 794 \nL 1409 794 \nL 1409 0 \nL 750 0 \nL 750 794 \nz\nM 750 3309 \nL 1409 3309 \nL 1409 2516 \nL 750 2516 \nL 750 3309 \nz\n\" transform=\"scale(0.015625)\"/>\n       <path id=\"DejaVuSans-31\" d=\"M 794 531 \nL 1825 531 \nL 1825 4091 \nL 703 3866 \nL 703 4441 \nL 1819 4666 \nL 2450 4666 \nL 2450 531 \nL 3481 531 \nL 3481 0 \nL 794 0 \nL 794 531 \nz\n\" transform=\"scale(0.015625)\"/>\n      </defs>\n      <use xlink:href=\"#DejaVuSans-42\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"68.603516\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"131.982422\"/>\n      <use xlink:href=\"#DejaVuSans-67\" x=\"195.458984\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"258.935547\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"320.458984\"/>\n      <use xlink:href=\"#DejaVuSans-3a\" x=\"359.667969\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"393.359375\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"425.146484\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"488.769531\"/>\n     </g>\n    </g>\n    <g id=\"line2d_19\">\n     <path d=\"M 59.14375 263.936062 \nL 69.14375 263.936062 \nL 79.14375 263.936062 \n\" style=\"fill: none; stroke: #ffb000; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m3726874445\" x=\"69.14375\" y=\"263.936062\" style=\"fill: #ffb000; stroke: #ffb000\"/>\n     </g>\n    </g>\n    <g id=\"text_17\">\n     <!-- Budget: 100 -->\n     <g transform=\"translate(87.14375 267.436062) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-42\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"68.603516\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"131.982422\"/>\n      <use xlink:href=\"#DejaVuSans-67\" x=\"195.458984\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"258.935547\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"320.458984\"/>\n      <use xlink:href=\"#DejaVuSans-3a\" x=\"359.667969\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"393.359375\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"425.146484\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"488.769531\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"552.392578\"/>\n     </g>\n    </g>\n    <g id=\"line2d_20\">\n     <path d=\"M 59.14375 278.614187 \nL 69.14375 278.614187 \nL 79.14375 278.614187 \n\" style=\"fill: none; stroke: #1e88e5; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m676da127a1\" x=\"69.14375\" y=\"278.614187\" style=\"fill: #1e88e5; stroke: #1e88e5\"/>\n     </g>\n    </g>\n    <g id=\"text_18\">\n     <!-- Budget: 1000 -->\n     <g transform=\"translate(87.14375 282.114187) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-42\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"68.603516\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"131.982422\"/>\n      <use xlink:href=\"#DejaVuSans-67\" x=\"195.458984\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"258.935547\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"320.458984\"/>\n      <use xlink:href=\"#DejaVuSans-3a\" x=\"359.667969\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"393.359375\"/>\n      <use xlink:href=\"#DejaVuSans-31\" x=\"425.146484\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"488.769531\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"552.392578\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"616.015625\"/>\n     </g>\n    </g>\n    <g id=\"line2d_21\">\n     <path d=\"M 59.14375 293.292312 \nL 69.14375 293.292312 \nL 79.14375 293.292312 \n\" style=\"fill: none; stroke: #fe6100; stroke-width: 1.5; stroke-linecap: square\"/>\n     <g>\n      <use xlink:href=\"#m716510116f\" x=\"69.14375\" y=\"293.292312\" style=\"fill: #fe6100; stroke: #fe6100\"/>\n     </g>\n    </g>\n    <g id=\"text_19\">\n     <!-- Budget: 5000 -->\n     <g transform=\"translate(87.14375 296.792312) scale(0.1 -0.1)\">\n      <use xlink:href=\"#DejaVuSans-42\"/>\n      <use xlink:href=\"#DejaVuSans-75\" x=\"68.603516\"/>\n      <use xlink:href=\"#DejaVuSans-64\" x=\"131.982422\"/>\n      <use xlink:href=\"#DejaVuSans-67\" x=\"195.458984\"/>\n      <use xlink:href=\"#DejaVuSans-65\" x=\"258.935547\"/>\n      <use xlink:href=\"#DejaVuSans-74\" x=\"320.458984\"/>\n      <use xlink:href=\"#DejaVuSans-3a\" x=\"359.667969\"/>\n      <use xlink:href=\"#DejaVuSans-20\" x=\"393.359375\"/>\n      <use xlink:href=\"#DejaVuSans-35\" x=\"425.146484\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"488.769531\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"552.392578\"/>\n      <use xlink:href=\"#DejaVuSans-30\" x=\"616.015625\"/>\n     </g>\n    </g>\n   </g>\n  </g>\n  <g id=\"text_20\">\n   <!-- Accuracy of the model on the test data after removing samples -->\n   <g transform=\"translate(32.306875 16.318125) scale(0.12 -0.12)\">\n    <defs>\n     <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \nL 3513 0 \nL 2938 0 \nL 2938 2094 \nQ 2938 2591 2744 2837 \nQ 2550 3084 2163 3084 \nQ 1697 3084 1428 2787 \nQ 1159 2491 1159 1978 \nL 1159 0 \nL 581 0 \nL 581 4863 \nL 1159 4863 \nL 1159 2956 \nQ 1366 3272 1645 3428 \nQ 1925 3584 2291 3584 \nQ 2894 3584 3203 3211 \nQ 3513 2838 3513 2113 \nz\n\" transform=\"scale(0.015625)\"/>\n     <path id=\"DejaVuSans-69\" d=\"M 603 3500 \nL 1178 3500 \nL 1178 0 \nL 603 0 \nL 603 3500 \nz\nM 603 4863 \nL 1178 4863 \nL 1178 4134 \nL 603 4134 \nL 603 4863 \nz\n\" transform=\"scale(0.015625)\"/>\n    </defs>\n    <use xlink:href=\"#DejaVuSans-41\"/>\n    <use xlink:href=\"#DejaVuSans-63\" x=\"66.658203\"/>\n    <use xlink:href=\"#DejaVuSans-63\" x=\"121.638672\"/>\n    <use xlink:href=\"#DejaVuSans-75\" x=\"176.619141\"/>\n    <use xlink:href=\"#DejaVuSans-72\" x=\"239.998047\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"281.111328\"/>\n    <use xlink:href=\"#DejaVuSans-63\" x=\"342.390625\"/>\n    <use xlink:href=\"#DejaVuSans-79\" x=\"397.371094\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"456.550781\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"488.337891\"/>\n    <use xlink:href=\"#DejaVuSans-66\" x=\"549.519531\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"584.724609\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"616.511719\"/>\n    <use xlink:href=\"#DejaVuSans-68\" x=\"655.720703\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"719.099609\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"780.623047\"/>\n    <use xlink:href=\"#DejaVuSans-6d\" x=\"812.410156\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"909.822266\"/>\n    <use xlink:href=\"#DejaVuSans-64\" x=\"971.003906\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"1034.480469\"/>\n    <use xlink:href=\"#DejaVuSans-6c\" x=\"1096.003906\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1123.787109\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"1155.574219\"/>\n    <use xlink:href=\"#DejaVuSans-6e\" x=\"1216.755859\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1280.134766\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"1311.921875\"/>\n    <use xlink:href=\"#DejaVuSans-68\" x=\"1351.130859\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"1414.509766\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1476.033203\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"1507.820312\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"1547.029297\"/>\n    <use xlink:href=\"#DejaVuSans-73\" x=\"1608.552734\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"1660.652344\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1699.861328\"/>\n    <use xlink:href=\"#DejaVuSans-64\" x=\"1731.648438\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"1795.125\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"1856.404297\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"1895.613281\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"1956.892578\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"1988.679688\"/>\n    <use xlink:href=\"#DejaVuSans-66\" x=\"2049.958984\"/>\n    <use xlink:href=\"#DejaVuSans-74\" x=\"2083.414062\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"2122.623047\"/>\n    <use xlink:href=\"#DejaVuSans-72\" x=\"2184.146484\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"2225.259766\"/>\n    <use xlink:href=\"#DejaVuSans-72\" x=\"2257.046875\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"2295.910156\"/>\n    <use xlink:href=\"#DejaVuSans-6d\" x=\"2357.433594\"/>\n    <use xlink:href=\"#DejaVuSans-6f\" x=\"2454.845703\"/>\n    <use xlink:href=\"#DejaVuSans-76\" x=\"2516.027344\"/>\n    <use xlink:href=\"#DejaVuSans-69\" x=\"2575.207031\"/>\n    <use xlink:href=\"#DejaVuSans-6e\" x=\"2602.990234\"/>\n    <use xlink:href=\"#DejaVuSans-67\" x=\"2666.369141\"/>\n    <use xlink:href=\"#DejaVuSans-20\" x=\"2729.845703\"/>\n    <use xlink:href=\"#DejaVuSans-73\" x=\"2761.632812\"/>\n    <use xlink:href=\"#DejaVuSans-61\" x=\"2813.732422\"/>\n    <use xlink:href=\"#DejaVuSans-6d\" x=\"2875.011719\"/>\n    <use xlink:href=\"#DejaVuSans-70\" x=\"2972.423828\"/>\n    <use xlink:href=\"#DejaVuSans-6c\" x=\"3035.900391\"/>\n    <use xlink:href=\"#DejaVuSans-65\" x=\"3063.683594\"/>\n    <use xlink:href=\"#DejaVuSans-73\" x=\"3125.207031\"/>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"pa8053001c0\">\n   <rect x=\"50.14375\" y=\"41.76\" width=\"357.12\" height=\"266.112\"/>\n  </clipPath>\n </defs>\n</svg>\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "budgets = [10, 100, 1000, 5000]\n",
+    "erg = {}\n",
+    "for budget in budgets:\n",
+    "    # Compute Shapley interactions with the SVARM approximator for the game function\n",
+    "    approximator = shapiq.SVARM(n=n_players, random_state=random_state)\n",
+    "    shapley_approx = approximator.approximate(budget=budget, game=data_valuation_game)\n",
+    "\n",
+    "    # Sort the approximated values of each player and get the keys\n",
+    "    players = np.array(range(0, n_players))\n",
+    "    sv_values = shapley_approx.values[1:]\n",
+    "    idx = np.argsort(sv_values)\n",
+    "    sorted_players = players[idx]\n",
+    "\n",
+    "    # Compute the accuracy of the model for different amount of removed samples\n",
+    "    percent_removal = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n",
+    "    accuracies = []\n",
+    "    for p in percent_removal:\n",
+    "        n_samples_to_remove = int(p * n_players)\n",
+    "        removed_players = sorted_players[:n_samples_to_remove]\n",
+    "        cleaned_X_train = np.delete(X_train, removed_players, axis=0)\n",
+    "        cleaned_y_train = np.delete(y_train, removed_players, axis=0)\n",
+    "        classifier.fit(cleaned_X_train, cleaned_y_train)\n",
+    "        accuracies.append(classifier.score(X_test, y_test))\n",
+    "    erg[budget] = (percent_removal, accuracies)\n",
+    "\n",
+    "# plot the results\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "fig.suptitle(\"Accuracy of the model on the test data after removing samples\")\n",
+    "for i, (budget, (percent_removal, accuracies)) in enumerate(erg.items()):\n",
+    "    ax.plot(\n",
+    "        percent_removal,\n",
+    "        accuracies,\n",
+    "        label=f\"Budget: {budget}\",\n",
+    "        marker=\"o\",\n",
+    "        linestyle=\"-\",\n",
+    "        color=COLORS_K_SII[i],\n",
+    "    )\n",
+    "plt.xlabel(\"Percentage of removed samples\")\n",
+    "plt.ylabel(\"Accuracy\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-10-22T16:05:15.069797Z",
+     "start_time": "2024-10-22T16:04:41.062860Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Intuitively increasing amount of removed data samples with low Shapley values should yield a better model performance.\n",
+    "Increasing the budget yields a more clear effect for lower percentages.\n",
+    "For very high percentages the effect is less pronounced as the model is already trained on the most important samples."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/docs/source/notebooks/sv_calculation.ipynb b/docs/source/notebooks/sv_calculation.ipynb
new file mode 100644
index 00000000..a7969431
--- /dev/null
+++ b/docs/source/notebooks/sv_calculation.ipynb
@@ -0,0 +1,84 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Shapley Value Calculation\n",
+    "A popular approach to tackle the problem of XAI is to use concepts from game theory in particular cooperative game theory.\n",
+    "The most popular method is to use the **Shapley Values** named after Lloyd Shapley, who introduced it in 1951 with his work *\"II: The Value of an n-Person Game\"*.\n",
+    "\n",
+    "## Cooperative Game Theory\n",
+    "Cooperative game theory deals with the study of games in which players/participants can form groups to achieve a collective payoff. More formally a cooperative game is defined as a tuple $(N,\\nu)$ where:\n",
+    "- $N$ is a finite set of players\n",
+    "- $\\nu$ is a characteristic function that maps every coalition of players to a real number, i.e. $\\nu:2^N \\rightarrow \\mathbb{R}$\n",
+    "\n",
+    "Of particular interest is to find a concept that distributes the payoff of $\\nu(N)$ among the players, as it is assumed that the *grand coalition* $N$ is formed.\n",
+    "The distribution of the payoff among the players is called a *solution concept*.\n",
+    "\n",
+    "## Shapley Values: A Unique Solution Concept\n",
+    "Given a cooperative game $(N,\\nu)$, the Shapley value is a payoff vector dividing the total payoff $\\nu(N)$ among the players. The Shapley value of player $i$ is denoted by $\\phi_i(\\nu)$ and is defined as:\n",
+    "$$\n",
+    "\\phi_i(\\nu) := \\sum_{S \\subseteq N \\setminus \\{i\\}} \\frac{|S|!(|N|-|S|-1)!}{|N|!} [\\nu(S \\cup \\{i\\}) - \\nu(S)]\n",
+    "$$\n",
+    "and can be interpreted as the  average marginal contribution of player $i$ across all possible permutations of the players.\n",
+    "Its popularity arises from uniquely satisfies the following properties:\n",
+    "- **Efficiency**: The sum of the Shapley values equals the total payoff, i.e. $\\sum_{i \\in N} \\phi_i(\\nu) = \\nu(N)$\n",
+    "- **Symmetry**: If two players $i$ and $j$ are such that for all coalitions $S \\subseteq N \\setminus \\{i,j\\}$, $\\nu(S \\cup \\{i\\}) = \\nu(S \\cup \\{j\\})$, then $\\phi_i(\\nu) = \\phi_j(\\nu)$\n",
+    "- **Additivity**: For a game $(N,\\nu + \\mu)$ based on two games $(N,\\nu)$ and $(N,\\mu)$, the Shapley value of the sum of the games is the sum of the Shapley values, i.e. $\\phi_i(\\nu + \\mu) = \\phi_i(\\nu) + \\phi_i(\\mu)$\n",
+    "- **Dummy Player**: If for a player $i$ is holds for all coalitions $S \\subseteq N \\setminus \\{i\\}$, $\\nu(S \\cup \\{i\\}) - \\nu(S) = \\nu(\\{i\\})$ then $\\phi_i(\\nu) = \\nu(\\{i\\})$\n",
+    "\n",
+    "## Shapley Values: Cooking Game\n",
+    "To illustrate the concept of Shapley values, we consider a simple example of a cooking game.\n",
+    " The game consists of three players(cooks), Alice, Bob, and Charlie, who are cooking a meal together.\n",
+    " The characteristic function $\\nu$ maps each coalition of players to the quality of the meal."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

From 96bd7c7b663cf609a68c4b0c734c4ac7d55ebff8 Mon Sep 17 00:00:00 2001
From: Maximilian <maximilian.muschalik@gmail.com>
Date: Fri, 25 Oct 2024 14:40:02 +0200
Subject: [PATCH 10/11] adds useful properties to game and closes #251. (#254)

* adds useful properties to game and closes #251.

Adds `empty_coalition_value`, `grand_coalition_value` properties to game and allows for a getitem (without computation) of a game.

* fixed the setter of _empty/_grand values

* fixed the setter of _empty/_grand values

* updated empty value
---
 shapiq/games/base.py                          | 43 ++++++++++++++++++-
 .../benchmark/unsupervised_cluster/base.py    |  5 +--
 .../games/benchmark/unsupervised_data/base.py |  1 -
 tests/tests_games/test_base_game.py           | 14 +++++-
 4 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/shapiq/games/base.py b/shapiq/games/base.py
index 956544ff..89e9800b 100644
--- a/shapiq/games/base.py
+++ b/shapiq/games/base.py
@@ -134,6 +134,8 @@ def __init__(
         # define some handy coalition variables
         self.empty_coalition = np.zeros(self.n_players, dtype=bool)
         self.grand_coalition = np.ones(self.n_players, dtype=bool)
+        self._empty_coalition_value_property = None
+        self._grand_coalition_value_property = None
 
         self.verbose = verbose
 
@@ -194,7 +196,13 @@ def _lookup_coalitions(self, coalitions: np.ndarray) -> np.ndarray:
         for i, coalition in enumerate(coalitions):
             # convert one-hot vector to tuple
             coalition_tuple = tuple(np.where(coalition)[0])
-            values[i] = self.value_storage[self.coalition_lookup[coalition_tuple]]
+            try:
+                values[i] = self.value_storage[self.coalition_lookup[coalition_tuple]]
+            except KeyError as error:
+                raise KeyError(
+                    f"The coalition {coalition_tuple} is not stored in the game. "
+                    f"Are all values pre-computed?"
+                ) from error
         return values
 
     def value_function(self, coalitions: np.ndarray) -> np.ndarray:
@@ -404,3 +412,36 @@ def get_game_name(cls) -> str:
                 break
             parent = parent.__base__
         return "_".join(class_names)
+
+    @property
+    def empty_coalition_value(self) -> float:
+        """Return the value of the empty coalition."""
+        if self._empty_coalition_value_property is None:
+            self._empty_coalition_value_property = float(self(self.empty_coalition))
+        return self._empty_coalition_value_property
+
+    @property
+    def grand_coalition_value(self) -> float:
+        """Return the value of the grand coalition."""
+        if self._grand_coalition_value_property is None:
+            self._grand_coalition_value_property = float(self(self.grand_coalition))
+        return self._grand_coalition_value_property
+
+    def __getitem__(self, item: tuple[int, ...]):
+        """Return the value of the given coalition. Only retrieves precomputed/store values.
+
+        Args:
+            item: The coalition to evaluate.
+
+        Returns:
+            The value of the coalition
+
+        Raises:
+            KeyError: If the coalition is not stored in the game.
+        """
+        try:
+            return self.value_storage[self.coalition_lookup[tuple(sorted(item))]]
+        except (KeyError, IndexError) as error:
+            raise KeyError(
+                f"The coalition {item} is not stored in the game. Is it precomputed?"
+            ) from error
diff --git a/shapiq/games/benchmark/unsupervised_cluster/base.py b/shapiq/games/benchmark/unsupervised_cluster/base.py
index c005b9b3..1b597ce9 100644
--- a/shapiq/games/benchmark/unsupervised_cluster/base.py
+++ b/shapiq/games/benchmark/unsupervised_cluster/base.py
@@ -71,12 +71,11 @@ def __init__(
         self.data = data
 
         self.random_state = random_state
-        self.empty_cluster_value = empty_cluster_value
 
         super().__init__(
             data.shape[1],
             normalize=normalize,
-            normalization_value=self.empty_cluster_value,
+            normalization_value=0,
             verbose=verbose,
         )
 
@@ -93,7 +92,7 @@ def value_function(self, coalitions: np.ndarray) -> np.ndarray:
         worth = np.zeros(n_coalitions, dtype=float)
         for i, coalition in enumerate(coalitions):
             if sum(coalition) == 0:
-                worth[i] = self.empty_cluster_value
+                worth[i] = 0.0
                 continue
             data_selection = self.data[:, coalition]
             self.cluster.fit(data_selection)
diff --git a/shapiq/games/benchmark/unsupervised_data/base.py b/shapiq/games/benchmark/unsupervised_data/base.py
index d3149f4b..f5a7ad3a 100644
--- a/shapiq/games/benchmark/unsupervised_data/base.py
+++ b/shapiq/games/benchmark/unsupervised_data/base.py
@@ -23,7 +23,6 @@ class UnsupervisedData(Game):
     def __init__(self, data: np.ndarray, verbose: bool = False, *args, **kwargs) -> None:
         self.data = data
         self._n_features = data.shape[1]
-        self.empty_coalition_value = 0.0
 
         # discretize the data
         from sklearn.preprocessing import KBinsDiscretizer
diff --git a/tests/tests_games/test_base_game.py b/tests/tests_games/test_base_game.py
index 8d285305..28f6b5cc 100644
--- a/tests/tests_games/test_base_game.py
+++ b/tests/tests_games/test_base_game.py
@@ -34,15 +34,25 @@ def test_precompute():
     dummy_game.precompute(coalitions=coalitions)
 
     assert dummy_game.n_values_stored == 1
+    with pytest.raises(KeyError):  # test error case where not all values are precomputed
+        _ = dummy_game(dummy_game.empty_coalition)
 
+    # test with large number of players and see if it raises a warning
     with pytest.warns(UserWarning):
         n_players_large = 17
         dummy_game_large = DummyGame(n=n_players_large)
-        # call precompute but stop it before it finishes
         dummy_game_large.precompute()
-
         assert dummy_game_large.n_values_stored == 2**n_players_large
 
+    # test empty and grand coalition lookup
+    dummy_game = DummyGame(n=4, interaction=(0, 1))
+    dummy_game.precompute()
+    assert dummy_game.empty_coalition_value == dummy_game(dummy_game.empty_coalition)
+    assert dummy_game.grand_coalition_value == dummy_game(dummy_game.grand_coalition)
+    assert dummy_game[(0, 1)] == dummy_game[(1, 0)] != 0.0
+    with pytest.raises(KeyError):
+        _ = dummy_game[(0, 9)]  # only 4 players
+
 
 def test_core_functions():
     """This test tests the core functions of the base game class object."""

From 3c3dfc24a23834b323140cae49d145bf2391ea30 Mon Sep 17 00:00:00 2001
From: Theo <49311372+Advueu963@users.noreply.github.com>
Date: Fri, 25 Oct 2024 16:15:10 +0200
Subject: [PATCH 11/11] 183 make games be also callable with a tuplelist of
 tuples (#242)

* added possibility of tuple/list of tuple in BaseGame __call__

* Added possibility for to Game coalitions with given player_names

* Added possibility to call game based on given player_names

* removed player_names property as it caused conflicts

* made __call__ annotations for python3.9

* refactor game call with strings

* refactor game call of tuple and list

* Reimplement _check_coalitions to fewer lines.

---------

Co-authored-by: Maximilian <maximilian.muschalik@gmail.com>
---
 shapiq/games/base.py                | 113 ++++++++++++++++++++++++++--
 tests/tests_games/test_base_game.py |  86 +++++++++++++++++++++
 2 files changed, 194 insertions(+), 5 deletions(-)

diff --git a/shapiq/games/base.py b/shapiq/games/base.py
index 89e9800b..f8e01953 100644
--- a/shapiq/games/base.py
+++ b/shapiq/games/base.py
@@ -4,7 +4,7 @@
 import pickle
 import warnings
 from abc import ABC
-from typing import Optional
+from typing import Optional, Union
 
 import numpy as np
 from tqdm.auto import tqdm
@@ -94,6 +94,7 @@ def __init__(
         normalization_value: Optional[float] = None,
         path_to_values: Optional[str] = None,
         verbose: bool = False,
+        player_names: Optional[list[str]] = None,
         *args,
         **kwargs,
     ) -> None:
@@ -137,6 +138,11 @@ def __init__(
         self._empty_coalition_value_property = None
         self._grand_coalition_value_property = None
 
+        # define player_names
+        self.player_name_lookup: dict[str, int] = (
+            {name: i for i, name in enumerate(player_names)} if player_names is not None else None
+        )
+
         self.verbose = verbose
 
     @property
@@ -159,7 +165,105 @@ def is_normalized(self) -> bool:
         """Checks if the game is normalized/centered."""
         return self(self.empty_coalition) == 0
 
-    def __call__(self, coalitions: np.ndarray, verbose: bool = False) -> np.ndarray:
+    def _check_coalitions(
+        self,
+        coalitions: Union[np.ndarray, list[Union[tuple[int], tuple[str]]]],
+    ) -> np.ndarray:
+        """
+        Check if the coalitions are in the correct format and convert them to one-hot encoding.
+        The format may either be a numpy array containg the coalitions in one-hot encoding or a list of tuples with integers or strings.
+        Args:
+            coalitions: The coalitions to convert to one-hot encoding.
+        Returns:
+            np.ndarray: The coalitions in the correct format
+        Raises:
+            TypeError: If the coalitions are not in the correct format.
+        Examples:
+            >>> coalitions = np.asarray([[1, 0, 0, 0], [0, 1, 1, 0]])
+            >>> coalitions = [(0, 1), (1, 2)]
+            >>> coalitions = [()]
+            >>> coalitions = [(0, 1), (1, 2), (0, 1, 2)]
+            if player_name_lookup is not None:
+            >>> coalitions = [("Alice", "Bob"), ("Bob", "Charlie")]
+            Wrong format:
+            >>> coalitions = [1, 0, 0, 0]
+            >>> coalitions = [(1,"Alice")]
+            >>> coalitions = np.array([1,-1,2])
+
+
+        """
+        error_message = (
+            "List may only contain tuples of integers or strings."
+            "The tuples are not allowed to have heterogeneous types."
+            "Reconcile the docs for correct format of coalitions."
+        )
+
+        if isinstance(coalitions, np.ndarray):
+
+            # Check that coalition is contained in array
+            if len(coalitions) == 0:
+                raise TypeError("The array of coalitions is empty.")
+
+            # Check if single coalition is correctly given
+            if coalitions.ndim == 1:
+                if len(coalitions) < self.n_players or len(coalitions) > self.n_players:
+                    raise TypeError(
+                        "The array of coalitions is not correctly formatted."
+                        f"It should have a length of {self.n_players}"
+                    )
+                coalitions = coalitions.reshape((1, self.n_players))
+
+            # Check that all coalitions have the correct number of players
+            if coalitions.shape[1] != self.n_players:
+                raise TypeError(
+                    f"The number of players in the coalitions ({coalitions.shape[1]}) does not match "
+                    f"the number of players in the game ({self.n_players})."
+                )
+
+            # Check that values of numpy array are either 0 or 1
+            if not np.all(np.logical_or(coalitions == 0, coalitions == 1)):
+                raise TypeError("The values in the array of coalitions are not binary.")
+
+            return coalitions
+
+        # We now assume to work with list of tuples
+        if isinstance(coalitions, tuple):
+            # if by any chance a tuple was given wrap into a list
+            coalitions = [coalitions]
+
+        try:
+            # convert list of tuples to one-hot encoding
+            coalitions = transform_coalitions_to_array(coalitions, self.n_players)
+
+            return coalitions
+        except Exception as err:
+            # It may either be the tuples contain strings or wrong format
+            if self.player_name_lookup is not None:
+                # We now assume the tuples to contain strings
+                try:
+                    coalitions = [
+                        (
+                            tuple(self.player_name_lookup[player] for player in coalition)
+                            if coalition != tuple()
+                            else tuple()
+                        )
+                        for coalition in coalitions
+                    ]
+                    coalitions = transform_coalitions_to_array(coalitions, self.n_players)
+
+                    return coalitions
+                except Exception as err:
+                    raise TypeError(error_message) from err
+
+            raise TypeError(error_message) from err
+
+    def __call__(
+        self,
+        coalitions: Union[
+            np.ndarray, list[Union[tuple[int], tuple[str]]], tuple[Union[int, str]], str
+        ],
+        verbose: bool = False,
+    ) -> np.ndarray:
         """Calls the game's value function with the given coalitions and returns the output of the
         value function.
 
@@ -170,9 +274,8 @@ def __call__(self, coalitions: np.ndarray, verbose: bool = False) -> np.ndarray:
         Returns:
             The values of the coalitions.
         """
-        # check if coalitions are correct dimensions
-        if coalitions.ndim == 1:
-            coalitions = coalitions.reshape((1, self.n_players))
+        # check if coalitions are correct format
+        coalitions = self._check_coalitions(coalitions)
 
         verbose = verbose or self.verbose
 
diff --git a/tests/tests_games/test_base_game.py b/tests/tests_games/test_base_game.py
index 28f6b5cc..5e3ef654 100644
--- a/tests/tests_games/test_base_game.py
+++ b/tests/tests_games/test_base_game.py
@@ -5,10 +5,96 @@
 import numpy as np
 import pytest
 
+from shapiq.games.base import Game
 from shapiq.games.benchmark import DummyGame  # used to test the base class
 from shapiq.utils.sets import powerset, transform_coalitions_to_array
 
 
+def test_call():
+    """This test tests the call function of the base game class."""
+
+    class TestGame(Game):
+        """This is a test game class that inherits from the base game class.
+        Its value function is the amount of players divided by the number of players.
+        """
+
+        def __init__(self, n, **kwargs):
+            super().__init__(n_players=n, normalization_value=0, **kwargs)
+
+        def value_function(self, coalition):
+            return np.sum(coalition) / self.n_players
+
+    n_players = 6
+    test_game = TestGame(
+        n=n_players, player_names=["Alice", "Bob", "Charlie", "David", "Eve", "Frank"]
+    )
+
+    # assert that player names are correctly stored
+    assert test_game.player_name_lookup == {
+        "Alice": 0,
+        "Bob": 1,
+        "Charlie": 2,
+        "David": 3,
+        "Eve": 4,
+        "Frank": 5,
+    }
+
+    assert test_game([]) == 0.0
+
+    # test coalition calls with wrong datatype
+    with pytest.raises(TypeError):
+        assert test_game([(0, 1), "Alice", "Charlie"])
+    with pytest.raises(TypeError):
+        assert test_game([(0, 1), ("Alice",), ("Bob",)])
+    with pytest.raises(TypeError):
+        assert test_game(("Alice", 1))
+
+    # test wrong coalition size in call
+    with pytest.raises(TypeError):
+        assert test_game(np.array([True, False, True])) == 0.0
+    with pytest.raises(TypeError):
+        assert test_game(np.array([])) == 0.0
+
+    # test wrong method for numpy array values
+    with pytest.raises(TypeError):
+        assert test_game(np.array([1, 2, 3, 4, 5, 6])) == 0.0
+
+    # test wrong coalition size in shape[1]
+    with pytest.raises(TypeError):
+        assert test_game(np.array([[True, False, True]])) == 0.0
+
+    # test with empty coalition all call variants
+    test_coalition = test_game.empty_coalition
+    assert test_game(test_coalition) == 0.0
+    assert test_game(()) == 0.0
+    assert test_game([()]) == 0.0
+
+    # test with grand coalition all call variants
+    test_coalition = test_game.grand_coalition
+    assert test_game(test_coalition) == 1.0
+    assert test_game(tuple(range(0, test_game.n_players))) == 1.0
+    assert test_game([tuple(range(0, test_game.n_players))]) == 1.0
+    assert test_game(tuple(test_game.player_name_lookup.values())) == 1.0
+    assert test_game([tuple(test_game.player_name_lookup.values())]) == 1.0
+
+    # test with single player coalition all call variants
+    test_coalition = np.array([True] + [False for _ in range(test_game.n_players - 1)])
+    assert test_game(test_coalition) - 1 / 6 < 10e-7
+    assert test_game((0,)) - 1 / 6 < 10e-7
+    assert test_game([(0,)]) - 1 / 6 < 10e-7
+    assert test_game(("Alice",)) - 1 / 6 < 10e-7
+    assert test_game([("Alice",)]) - 1 / 6 < 10e-7
+
+    # test string calls with missing player names
+    test_game2 = TestGame(n=n_players)
+    with pytest.raises(TypeError):
+        assert test_game2("Alice") == 0.0
+    with pytest.raises(TypeError):
+        assert test_game2(("Bob",)) == 0.0
+    with pytest.raises(TypeError):
+        assert test_game2([("Charlie",)]) == 0.0
+
+
 def test_precompute():
     """This test tests the precompute function of the base game class"""
     n_players = 6