From 375f98fec0ef33d334562e67ed79d058ab171d8d Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 11:06:50 +0200
Subject: [PATCH 01/33] Add helper to plot counts from results

---
 qoolqit/utils/__init__.py      |   5 +
 qoolqit/utils/visualization.py | 166 +++++++++++++++++++++++++++++++++
 2 files changed, 171 insertions(+)
 create mode 100644 qoolqit/utils/__init__.py
 create mode 100644 qoolqit/utils/visualization.py

diff --git a/qoolqit/utils/__init__.py b/qoolqit/utils/__init__.py
new file mode 100644
index 000000000..ba87cea0d
--- /dev/null
+++ b/qoolqit/utils/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .visualization import plot_distribution, plot_histogram
+
+__all__ = ["plot_histogram", "plot_distribution"]
\ No newline at end of file
diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
new file mode 100644
index 000000000..4a88bcf63
--- /dev/null
+++ b/qoolqit/utils/visualization.py
@@ -0,0 +1,166 @@
+"""Visualization helpers for QoolQit results."""
+
+
+def _plot_counts(
+    counts,
+    top=None,
+    distribution=False,
+    ax=None,
+    title=None,
+    color="tab:blue",
+    highlight=None,
+):
+    """Plot counts, optionally highlighting selected outcomes.
+
+    Parameters
+    ----------
+    counts: dict
+        Mapping of bitstrings to counts.
+    top: int, optional
+        If provided, only the top N counts will be plotted.
+    distribution: bool, default False
+        If True, counts will be normalized to probabilities.
+    ax: matplotlib.axes.Axes, optional
+        If provided, the plot will be drawn on this axes.
+    title: str, optional
+        Plot title.
+    color: str, default "tab:blue"
+        Default bar color.
+    highlight: dict, optional
+        Mapping of labels to colors, for example:
+        {"001": "tab:green", "110": "tab:red"}.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The axes object containing the plot.
+    """
+    import matplotlib.pyplot as plt
+
+    if not counts:
+        raise ValueError("counts cannot be empty")
+
+    total = sum(counts.values())
+    if distribution and total == 0:
+        raise ValueError(
+            "cannot plot a distribution with zero total counts"
+        )
+
+    # Sort counts in descending order
+    items = sorted(
+        counts.items(),
+        key=lambda item: item[1],
+        reverse=True,
+    )
+
+    # Select only the top N counts if requested
+    if top is not None:
+        items = items[:top]
+
+    # Extract labels and values from items for plotting
+    labels = [label for label, _ in items]
+    values = [
+        value / total if distribution else value
+        for _, value in items
+    ]
+
+    # Determine bar colors, using the highlight mapping if provided
+    # If a label is not in the highlight mapping, use the default color.
+    highlight = highlight or {}
+    colors = [highlight.get(label, color) for label in labels]
+
+    # Create the plot if no axes are provided
+    if ax is None:
+        _, ax = plt.subplots(figsize=(12, 5))
+
+    # Plot the bar chart
+    ax.bar(labels, values, width=0.6, color=colors)
+    ax.set_xlabel("Bitstring")
+    ax.set_ylabel("Probability" if distribution else "Count")
+
+    # Set the title of the plot, using a default title if none is provided
+    ax.set_title(
+        title
+        or (
+            "Measurement distribution"
+            if distribution
+            else "Measurement histogram"
+        )
+    )
+
+    # Rotate x-axis labels for better readability
+    ax.tick_params(axis="x", labelrotation=90)
+    ax.grid(axis="y", linestyle="--", alpha=0.4)
+
+    return ax
+
+
+def plot_histogram(counts, highlight=None, top=None, ax=None, title=None):
+    """Plot raw measurement counts as a histogram.
+
+    Parameters
+    ----------
+    counts: dict
+        Mapping of bitstrings to counts.
+    top: int, optional
+        If provided, only the top N counts will be plotted.
+    ax: matplotlib.axes.Axes, optional
+        If provided, the plot will be drawn on this axes.
+    title: str, optional
+        Plot title.
+    color: str, default "tab:blue"
+        Default bar color.
+    highlight: dict, optional
+        Mapping of labels to colors, for example:
+        {"001": "tab:green", "110": "tab:red"}.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The axes object containing the plot.
+    """
+    return _plot_counts(
+        counts,
+        highlight=highlight,
+        top=top,
+        distribution=False,
+        ax=ax,
+        title=title,
+    )
+
+
+def plot_distribution(counts, highlight=None, top=None, ax=None, title=None):
+    """Plot normalized measurement counts as a probability distribution.
+
+    Parameters
+    ----------
+    counts: dict
+        Mapping of bitstrings to counts.
+    top: int, optional
+        If provided, only the top N counts will be plotted.
+    ax: matplotlib.axes.Axes, optional
+        If provided, the plot will be drawn on this axes.
+    title: str, optional
+        Plot title.
+    color: str, default "tab:blue"
+        Default bar color.
+    highlight: dict, optional
+        Mapping of labels to colors, for example:
+        {"001": "tab:green", "110": "tab:red"}.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The axes object containing the plot.
+    """    
+    return _plot_counts(
+        counts,
+        highlight=highlight,
+        top=top,
+        distribution=True,
+        ax=ax,
+        title=title,
+    )
+
+
+__all__ = ["plot_histogram", "plot_distribution"]

From e242233f34dd5eba84b6bd16b5c88ff84df3358a Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 11:21:47 +0200
Subject: [PATCH 02/33] precommit

---
 qoolqit/utils/__init__.py      |  2 +-
 qoolqit/utils/visualization.py | 63 ++++++++++++++++++++--------------
 2 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/qoolqit/utils/__init__.py b/qoolqit/utils/__init__.py
index ba87cea0d..29428af02 100644
--- a/qoolqit/utils/__init__.py
+++ b/qoolqit/utils/__init__.py
@@ -2,4 +2,4 @@
 
 from .visualization import plot_distribution, plot_histogram
 
-__all__ = ["plot_histogram", "plot_distribution"]
\ No newline at end of file
+__all__ = ["plot_histogram", "plot_distribution"]
diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index 4a88bcf63..5f01a23a5 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -1,15 +1,22 @@
 """Visualization helpers for QoolQit results."""
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
 
 def _plot_counts(
-    counts,
-    top=None,
-    distribution=False,
-    ax=None,
-    title=None,
-    color="tab:blue",
-    highlight=None,
-):
+    counts: dict[str, int],
+    top: int | None = None,
+    distribution: bool = False,
+    ax: Axes | None = None,
+    title: str | None = None,
+    color: str = "tab:blue",
+    highlight: dict[str, str] | None = None,
+) -> Axes:
     """Plot counts, optionally highlighting selected outcomes.
 
     Parameters
@@ -42,9 +49,7 @@ def _plot_counts(
 
     total = sum(counts.values())
     if distribution and total == 0:
-        raise ValueError(
-            "cannot plot a distribution with zero total counts"
-        )
+        raise ValueError("cannot plot a distribution with zero total counts")
 
     # Sort counts in descending order
     items = sorted(
@@ -59,10 +64,7 @@ def _plot_counts(
 
     # Extract labels and values from items for plotting
     labels = [label for label, _ in items]
-    values = [
-        value / total if distribution else value
-        for _, value in items
-    ]
+    values = [value / total if distribution else value for _, value in items]
 
     # Determine bar colors, using the highlight mapping if provided
     # If a label is not in the highlight mapping, use the default color.
@@ -79,14 +81,7 @@ def _plot_counts(
     ax.set_ylabel("Probability" if distribution else "Count")
 
     # Set the title of the plot, using a default title if none is provided
-    ax.set_title(
-        title
-        or (
-            "Measurement distribution"
-            if distribution
-            else "Measurement histogram"
-        )
-    )
+    ax.set_title(title or ("Measurement distribution" if distribution else "Measurement histogram"))
 
     # Rotate x-axis labels for better readability
     ax.tick_params(axis="x", labelrotation=90)
@@ -95,7 +90,14 @@ def _plot_counts(
     return ax
 
 
-def plot_histogram(counts, highlight=None, top=None, ax=None, title=None):
+def plot_histogram(
+    counts: dict[str, int],
+    top: int | None = None,
+    ax: Axes | None = None,
+    title: str | None = None,
+    color: str = "tab:blue",
+    highlight: dict[str, str] | None = None,
+) -> Axes:
     """Plot raw measurement counts as a histogram.
 
     Parameters
@@ -123,13 +125,21 @@ def plot_histogram(counts, highlight=None, top=None, ax=None, title=None):
         counts,
         highlight=highlight,
         top=top,
+        color=color,
         distribution=False,
         ax=ax,
         title=title,
     )
 
 
-def plot_distribution(counts, highlight=None, top=None, ax=None, title=None):
+def plot_distribution(
+    counts: dict[str, int],
+    top: int | None = None,
+    ax: Axes | None = None,
+    title: str | None = None,
+    color: str = "tab:blue",
+    highlight: dict[str, str] | None = None,
+) -> Axes:
     """Plot normalized measurement counts as a probability distribution.
 
     Parameters
@@ -152,12 +162,13 @@ def plot_distribution(counts, highlight=None, top=None, ax=None, title=None):
     -------
     matplotlib.axes.Axes
         The axes object containing the plot.
-    """    
+    """
     return _plot_counts(
         counts,
         highlight=highlight,
         top=top,
         distribution=True,
+        color=color,
         ax=ax,
         title=title,
     )

From 2575beb17d6a03400918644306251be5a218dd60 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 12:06:57 +0200
Subject: [PATCH 03/33] added option to stack different runs

---
 qoolqit/utils/visualization.py | 153 ++++++++++++++++++++++++---------
 1 file changed, 114 insertions(+), 39 deletions(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index 5f01a23a5..ef04cc02e 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -9,33 +9,42 @@
 
 
 def _plot_counts(
-    counts: dict[str, int],
+    counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
     distribution: bool = False,
     ax: Axes | None = None,
     title: str | None = None,
-    color: str = "tab:blue",
+    color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
+    labels: list[str] | None = None,
 ) -> Axes:
     """Plot counts, optionally highlighting selected outcomes.
 
     Parameters
     ----------
-    counts: dict
-        Mapping of bitstrings to counts.
+    counts: dict or list of dict
+        Mapping of bitstrings to counts, or a list of such mappings. Several
+        mappings are drawn as grouped bars on the same axes.
     top: int, optional
-        If provided, only the top N counts will be plotted.
+        If provided, only the top N counts will be plotted. With several
+        mappings, outcomes are ranked by their total count.
     distribution: bool, default False
-        If True, counts will be normalized to probabilities.
+        If True, counts will be normalized to probabilities. Each mapping is
+        normalized independently.
     ax: matplotlib.axes.Axes, optional
         If provided, the plot will be drawn on this axes.
     title: str, optional
         Plot title.
-    color: str, default "tab:blue"
-        Default bar color.
+    color: str or list of str, optional
+        Default bar color, or one color per mapping. Defaults to matplotlib's
+        color cycle.
     highlight: dict, optional
         Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}.
+        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
+        counts: with several mappings a highlighted outcome takes the same
+        color in every group, so the run it belongs to becomes ambiguous.
+    labels: list of str, optional
+        Legend label for each mapping.
 
     Returns
     -------
@@ -44,39 +53,81 @@ def _plot_counts(
     """
     import matplotlib.pyplot as plt
 
-    if not counts:
+    # Accept a single dict or a list of dicts, and work with a list from here on
+    counts_list = [counts] if isinstance(counts, dict) else list(counts)
+    n = len(counts_list)
+
+    if not counts_list or any(not count for count in counts_list):
         raise ValueError("counts cannot be empty")
 
-    total = sum(counts.values())
-    if distribution and total == 0:
+    # We check for zero total counts here, since the normalization would otherwise
+    # produce NaN values that matplotlib cannot plot. We do not check for zero
+    # counts when plotting a histogram, since matplotlib can handle that case.
+    totals = [sum(count.values()) for count in counts_list]
+    if distribution and any(total == 0 for total in totals):
         raise ValueError("cannot plot a distribution with zero total counts")
 
-    # Sort counts in descending order
-    items = sorted(
-        counts.items(),
-        key=lambda item: item[1],
+    # Sort the union of all bitstrings by their total count, in descending order
+    # We use set for unique bitstrings, and sorted across the union of all
+    # counts to ensure that we have a consistent order for the x-axis.
+    # When top is specified, we will select only the first N bitstrings after sorting
+    bitstrings = sorted(
+        set().union(*counts_list),
+        key=lambda bitstring: sum(count.get(bitstring, 0) for count in counts_list),
         reverse=True,
     )
 
     # Select only the top N counts if requested
     if top is not None:
-        items = items[:top]
+        bitstrings = bitstrings[:top]
 
-    # Extract labels and values from items for plotting
-    labels = [label for label, _ in items]
-    values = [value / total if distribution else value for _, value in items]
+    # One base color per set of counts
+    if color is None:
+        colors = [f"C{index}" for index in range(n)]
+    elif isinstance(color, str):
+        colors = [color] * n
+    else:
+        colors = list(color)
 
-    # Determine bar colors, using the highlight mapping if provided
-    # If a label is not in the highlight mapping, use the default color.
+    # If no highlight mapping is provided, use an empty dict to avoid KeyErrors
     highlight = highlight or {}
-    colors = [highlight.get(label, color) for label in labels]
 
     # Create the plot if no axes are provided
     if ax is None:
         _, ax = plt.subplots(figsize=(12, 5))
 
-    # Plot the bar chart
-    ax.bar(labels, values, width=0.6, color=colors)
+    # Plot one group of bars per set of counts, side by side on each bitstring
+    positions = range(len(bitstrings))
+
+    # Bars are slightly narrower than their slot, so that neighbours sharing a
+    # highlight color do not merge into a single wide bar
+    slot = 0.6 / n
+    width = slot if n == 1 else slot * 0.85
+    for index, count in enumerate(counts_list):
+        # Compute the values to plot, normalizing if requested.
+        # If a bitstring is not present in the counts, we use 0 as its value.
+        values = [
+            count.get(bitstring, 0) / totals[index] if distribution else count.get(bitstring, 0)
+            for bitstring in bitstrings
+        ]
+
+        # Determine bar colors, using the highlight mapping if provided
+        # If a bitstring is not in the highlight mapping, use this series' color.
+        bar_colors = [highlight.get(bitstring, colors[index]) for bitstring in bitstrings]
+
+        # Shift each group so that the bars are centered on the tick
+        offset = (index - (n - 1) / 2) * slot
+        ax.bar(
+            [position + offset for position in positions],
+            values,
+            width=width,
+            color=bar_colors,
+            label=labels[index] if labels else None,
+        )
+
+    # Place one tick per bitstring, since the bars now sit at numeric positions
+    ax.set_xticks(list(positions))
+    ax.set_xticklabels(bitstrings)
     ax.set_xlabel("Bitstring")
     ax.set_ylabel("Probability" if distribution else "Count")
 
@@ -87,34 +138,50 @@ def _plot_counts(
     ax.tick_params(axis="x", labelrotation=90)
     ax.grid(axis="y", linestyle="--", alpha=0.4)
 
+    # Only show a legend when the series have been named. The handles are built
+    # explicitly from the base colors, since matplotlib would otherwise take the
+    # color of the first bar of each series, which may be a highlighted one.
+    if labels:
+        from matplotlib.patches import Patch
+
+        ax.legend(
+            handles=[Patch(color=colors[index], label=label) for index, label in enumerate(labels)]
+        )
+
     return ax
 
 
 def plot_histogram(
-    counts: dict[str, int],
+    counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
     ax: Axes | None = None,
     title: str | None = None,
-    color: str = "tab:blue",
+    color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
+    labels: list[str] | None = None,
 ) -> Axes:
     """Plot raw measurement counts as a histogram.
 
     Parameters
     ----------
-    counts: dict
-        Mapping of bitstrings to counts.
+    counts: dict or list of dict
+        Mapping of bitstrings to counts, or a list of such mappings. Several
+        mappings are drawn as grouped bars on the same axes.
     top: int, optional
         If provided, only the top N counts will be plotted.
     ax: matplotlib.axes.Axes, optional
         If provided, the plot will be drawn on this axes.
     title: str, optional
         Plot title.
-    color: str, default "tab:blue"
-        Default bar color.
+    color: str or list of str, optional
+        Default bar color, or one color per mapping.
     highlight: dict, optional
         Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}.
+        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
+        counts: with several mappings a highlighted outcome takes the same
+        color in every group, so the run it belongs to becomes ambiguous.
+    labels: list of str, optional
+        Legend label for each mapping.
 
     Returns
     -------
@@ -129,34 +196,41 @@ def plot_histogram(
         distribution=False,
         ax=ax,
         title=title,
+        labels=labels,
     )
 
 
 def plot_distribution(
-    counts: dict[str, int],
+    counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
     ax: Axes | None = None,
     title: str | None = None,
-    color: str = "tab:blue",
+    color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
+    labels: list[str] | None = None,
 ) -> Axes:
     """Plot normalized measurement counts as a probability distribution.
 
     Parameters
     ----------
-    counts: dict
-        Mapping of bitstrings to counts.
+    counts: dict or list of dict
+        Mapping of bitstrings to counts, or a list of such mappings. Each
+        mapping is normalized independently.
     top: int, optional
         If provided, only the top N counts will be plotted.
     ax: matplotlib.axes.Axes, optional
         If provided, the plot will be drawn on this axes.
     title: str, optional
         Plot title.
-    color: str, default "tab:blue"
-        Default bar color.
+    color: str or list of str, optional
+        Default bar color, or one color per mapping.
     highlight: dict, optional
         Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}.
+        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
+        counts: with several mappings a highlighted outcome takes the same
+        color in every group, so the run it belongs to becomes ambiguous.
+    labels: list of str, optional
+        Legend label for each mapping.
 
     Returns
     -------
@@ -171,6 +245,7 @@ def plot_distribution(
         color=color,
         ax=ax,
         title=title,
+        labels=labels,
     )
 
 

From 4e2d6dd537f308359e28ddb8e18906032a7ee4a5 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 12:29:43 +0200
Subject: [PATCH 04/33] Simplified visualization.py

---
 qoolqit/utils/__init__.py      |   4 +-
 qoolqit/utils/visualization.py | 121 +++------------------------------
 2 files changed, 13 insertions(+), 112 deletions(-)

diff --git a/qoolqit/utils/__init__.py b/qoolqit/utils/__init__.py
index 29428af02..8ed20191d 100644
--- a/qoolqit/utils/__init__.py
+++ b/qoolqit/utils/__init__.py
@@ -1,5 +1,5 @@
 from __future__ import annotations
 
-from .visualization import plot_distribution, plot_histogram
+from .visualization import plot_histogram
 
-__all__ = ["plot_histogram", "plot_distribution"]
+__all__ = ["plot_histogram"]
diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index ef04cc02e..2f486162a 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -7,18 +7,20 @@
 if TYPE_CHECKING:
     from matplotlib.axes import Axes
 
+__all__ = ["plot_histogram"]
 
-def _plot_counts(
+
+def plot_histogram(
     counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
-    distribution: bool = False,
+    normalize: bool = False,
     ax: Axes | None = None,
     title: str | None = None,
     color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
 ) -> Axes:
-    """Plot counts, optionally highlighting selected outcomes.
+    """Plot measurement counts, optionally highlighting selected outcomes.
 
     Parameters
     ----------
@@ -28,7 +30,7 @@ def _plot_counts(
     top: int, optional
         If provided, only the top N counts will be plotted. With several
         mappings, outcomes are ranked by their total count.
-    distribution: bool, default False
+    normalize: bool, default False
         If True, counts will be normalized to probabilities. Each mapping is
         normalized independently.
     ax: matplotlib.axes.Axes, optional
@@ -64,8 +66,8 @@ def _plot_counts(
     # produce NaN values that matplotlib cannot plot. We do not check for zero
     # counts when plotting a histogram, since matplotlib can handle that case.
     totals = [sum(count.values()) for count in counts_list]
-    if distribution and any(total == 0 for total in totals):
-        raise ValueError("cannot plot a distribution with zero total counts")
+    if normalize and any(total == 0 for total in totals):
+        raise ValueError("cannot plot normalized counts with zero total counts")
 
     # Sort the union of all bitstrings by their total count, in descending order
     # We use set for unique bitstrings, and sorted across the union of all
@@ -107,7 +109,7 @@ def _plot_counts(
         # Compute the values to plot, normalizing if requested.
         # If a bitstring is not present in the counts, we use 0 as its value.
         values = [
-            count.get(bitstring, 0) / totals[index] if distribution else count.get(bitstring, 0)
+            count.get(bitstring, 0) / totals[index] if normalize else count.get(bitstring, 0)
             for bitstring in bitstrings
         ]
 
@@ -129,10 +131,10 @@ def _plot_counts(
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
     ax.set_xlabel("Bitstring")
-    ax.set_ylabel("Probability" if distribution else "Count")
+    ax.set_ylabel("Probability" if normalize else "Count")
 
     # Set the title of the plot, using a default title if none is provided
-    ax.set_title(title or ("Measurement distribution" if distribution else "Measurement histogram"))
+    ax.set_title(title or ("Measurement distribution" if normalize else "Measurement histogram"))
 
     # Rotate x-axis labels for better readability
     ax.tick_params(axis="x", labelrotation=90)
@@ -149,104 +151,3 @@ def _plot_counts(
         )
 
     return ax
-
-
-def plot_histogram(
-    counts: dict[str, int] | list[dict[str, int]],
-    top: int | None = None,
-    ax: Axes | None = None,
-    title: str | None = None,
-    color: str | list[str] | None = None,
-    highlight: dict[str, str] | None = None,
-    labels: list[str] | None = None,
-) -> Axes:
-    """Plot raw measurement counts as a histogram.
-
-    Parameters
-    ----------
-    counts: dict or list of dict
-        Mapping of bitstrings to counts, or a list of such mappings. Several
-        mappings are drawn as grouped bars on the same axes.
-    top: int, optional
-        If provided, only the top N counts will be plotted.
-    ax: matplotlib.axes.Axes, optional
-        If provided, the plot will be drawn on this axes.
-    title: str, optional
-        Plot title.
-    color: str or list of str, optional
-        Default bar color, or one color per mapping.
-    highlight: dict, optional
-        Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
-        counts: with several mappings a highlighted outcome takes the same
-        color in every group, so the run it belongs to becomes ambiguous.
-    labels: list of str, optional
-        Legend label for each mapping.
-
-    Returns
-    -------
-    matplotlib.axes.Axes
-        The axes object containing the plot.
-    """
-    return _plot_counts(
-        counts,
-        highlight=highlight,
-        top=top,
-        color=color,
-        distribution=False,
-        ax=ax,
-        title=title,
-        labels=labels,
-    )
-
-
-def plot_distribution(
-    counts: dict[str, int] | list[dict[str, int]],
-    top: int | None = None,
-    ax: Axes | None = None,
-    title: str | None = None,
-    color: str | list[str] | None = None,
-    highlight: dict[str, str] | None = None,
-    labels: list[str] | None = None,
-) -> Axes:
-    """Plot normalized measurement counts as a probability distribution.
-
-    Parameters
-    ----------
-    counts: dict or list of dict
-        Mapping of bitstrings to counts, or a list of such mappings. Each
-        mapping is normalized independently.
-    top: int, optional
-        If provided, only the top N counts will be plotted.
-    ax: matplotlib.axes.Axes, optional
-        If provided, the plot will be drawn on this axes.
-    title: str, optional
-        Plot title.
-    color: str or list of str, optional
-        Default bar color, or one color per mapping.
-    highlight: dict, optional
-        Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
-        counts: with several mappings a highlighted outcome takes the same
-        color in every group, so the run it belongs to becomes ambiguous.
-    labels: list of str, optional
-        Legend label for each mapping.
-
-    Returns
-    -------
-    matplotlib.axes.Axes
-        The axes object containing the plot.
-    """
-    return _plot_counts(
-        counts,
-        highlight=highlight,
-        top=top,
-        distribution=True,
-        color=color,
-        ax=ax,
-        title=title,
-        labels=labels,
-    )
-
-
-__all__ = ["plot_histogram", "plot_distribution"]

From 8a5f5ea8a17c9be0756e2ab9693c3a19fc9059bf Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 12:39:49 +0200
Subject: [PATCH 05/33] update notebooks

---
 docs/tutorials/Solving_a_MWIS.ipynb | 30 +++---------------
 docs/tutorials/solving_a_qubo.ipynb | 47 ++++++++---------------------
 2 files changed, 16 insertions(+), 61 deletions(-)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index d08d84255..294a7fea4 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -446,33 +446,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
+    "from qoolqit.utils import plot_histogram\n",
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
-    "def plot_distribution(counts, solution, top=None):\n",
-    "    \"\"\"Bar plot of a bitstring-count distribution, highlighting the solution.\n",
-    "\n",
-    "    Args:\n",
-    "        counts (dict[str, int]): Mapping from measured bitstring to its count.\n",
-    "        solution (str): The bitstring to highlight (the exact MWIS answer).\n",
-    "        top (int | None): If given, only show the `top` most frequent bitstrings.\n",
-    "    \"\"\"\n",
-    "    counts = dict(sorted(counts.items(), key=lambda kv: kv[1], reverse=True))\n",
-    "    if top is not None:\n",
-    "        counts = dict(list(counts.items())[:top])\n",
-    "\n",
-    "    colors = [\"tab:green\" if b == solution else \"tab:blue\" for b in counts]\n",
-    "    plt.figure(figsize=(12, 5))\n",
-    "    plt.bar(counts.keys(), counts.values(), width=0.6, color=colors)\n",
-    "    plt.xlabel(\"bitstring\")\n",
-    "    plt.ylabel(\"counts\")\n",
-    "    plt.title(f\"Measurement distribution (solution {solution} in green)\")\n",
-    "    plt.xticks(rotation=\"vertical\")\n",
-    "    plt.tight_layout()\n",
-    "    plt.show()\n",
-    "\n",
-    "plot_distribution(counts, SOLUTION, top=20)"
+    "plot_histogram(counts, highlight={SOLUTION: \"tab:green\"})"
    ]
   },
   {
@@ -518,7 +496,7 @@
     "print(\"Most frequent bitstring:\", max(counts_analog, key=counts_analog.get))\n",
     "print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n",
     "\n",
-    "plot_distribution(counts_analog, SOLUTION, top=20)"
+    "plot_histogram(counts, highlight={SOLUTION: \"tab:green\"})"
    ]
   },
   {
@@ -550,7 +528,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "mwis-tutorial (3.14.6)",
+   "display_name": "devqoolqit (3.14.6)",
    "language": "python",
    "name": "python3"
   },
diff --git a/docs/tutorials/solving_a_qubo.ipynb b/docs/tutorials/solving_a_qubo.ipynb
index ac01bc4f7..58a9e394f 100644
--- a/docs/tutorials/solving_a_qubo.ipynb
+++ b/docs/tutorials/solving_a_qubo.ipynb
@@ -365,38 +365,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from collections import Counter\n",
+    "from qoolqit.utils import plot_histogram\n",
     "\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "\n",
-    "def plot_distribution(counter, solutions, bins=10):\n",
-    "    counter = Counter(counter)\n",
-    "    counter = dict(counter.most_common(bins))\n",
-    "    color = [\n",
-    "        \"tab:green\" if key in solutions.tolist() else \"tab:blue\" for key in counter\n",
-    "    ]\n",
-    "    fig, ax = plt.subplots()\n",
-    "    ax.set_xlabel(\"Bitstrings\")\n",
-    "    ax.set_ylabel(\"Counts\")\n",
-    "    ax.bar(\n",
-    "        range(len(counter)), counter.values(), color=color, tick_label=counter.keys()\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "26",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plot_distribution(counter, marked_bitstrings)"
+    "highlight = {b: \"tab:green\" for b in marked_bitstrings}\n",
+    "plot_histogram(counter, highlight=highlight)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "27",
+   "id": "26",
    "metadata": {},
    "source": [
     "As we can see, the bitstrings we had marked as the optimal solutions of this QUBO problem were the ones sampled with the highest probability, meaning the the QUBO problem was successfully solved with the quantum program we defined."
@@ -404,7 +381,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "28",
+   "id": "27",
    "metadata": {},
    "source": [
     "## Advanced Compilation \n",
@@ -418,7 +395,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29",
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -428,7 +405,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "30",
+   "id": "29",
    "metadata": {},
    "source": [
     "Concretely, we can see the beneficial effect of rescaling the drive duration on the simulation results:"
@@ -437,19 +414,19 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "31",
+   "id": "30",
    "metadata": {},
    "outputs": [],
    "source": [
     "job = emulator.run(program)\n",
     "results = job.results()\n",
     "counter = results.final_bitstrings\n",
-    "plot_distribution(counter, marked_bitstrings)"
+    "plot_histogram(counter, highlight=highlight)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "32",
+   "id": "31",
    "metadata": {},
    "source": [
     "Here the execution was relatively fast and easy, but for larger QUBO instances, or for QPU execution (which might have some queue), see the [Execution](https://docs.pasqal.com/qoolqit/qoolqitDoc/fundamentals/execution/execution/) section of the QoolQit documentation."
@@ -458,7 +435,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qoolqit",
+   "display_name": "devqoolqit (3.14.6)",
    "language": "python",
    "name": "python3"
   },
@@ -472,7 +449,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.11"
+   "version": "3.14.6"
   }
  },
  "nbformat": 4,

From a07525487d11fbb44d32104a2e9c9b9ddf1bf2df Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 12:44:55 +0200
Subject: [PATCH 06/33] added flag for xlabel and ylabel

---
 qoolqit/utils/visualization.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index 2f486162a..79aae5bd9 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -19,6 +19,8 @@ def plot_histogram(
     color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
+    xlabel: str | None = None,
+    ylabel: str | None = None,
 ) -> Axes:
     """Plot measurement counts, optionally highlighting selected outcomes.
 
@@ -130,8 +132,8 @@ def plot_histogram(
     # Place one tick per bitstring, since the bars now sit at numeric positions
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
-    ax.set_xlabel("Bitstring")
-    ax.set_ylabel("Probability" if normalize else "Count")
+    ax.set_xlabel("Bitstring" if xlabel is None else xlabel)
+    ax.set_ylabel(ylabel or ("Probability" if normalize else "Counts"))
 
     # Set the title of the plot, using a default title if none is provided
     ax.set_title(title or ("Measurement distribution" if normalize else "Measurement histogram"))

From 43eb7db1f53b73926a5db0e8f5a99b8364e8ae26 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 12:52:22 +0200
Subject: [PATCH 07/33] Change color naming to colors

---
 qoolqit/utils/visualization.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index 79aae5bd9..e3b985fe7 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -16,7 +16,7 @@ def plot_histogram(
     normalize: bool = False,
     ax: Axes | None = None,
     title: str | None = None,
-    color: str | list[str] | None = None,
+    colors: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
     xlabel: str | None = None,
@@ -39,7 +39,7 @@ def plot_histogram(
         If provided, the plot will be drawn on this axes.
     title: str, optional
         Plot title.
-    color: str or list of str, optional
+    colors: str or list of str, optional
         Default bar color, or one color per mapping. Defaults to matplotlib's
         color cycle.
     highlight: dict, optional
@@ -86,12 +86,12 @@ def plot_histogram(
         bitstrings = bitstrings[:top]
 
     # One base color per set of counts
-    if color is None:
+    if colors is None:
         colors = [f"C{index}" for index in range(n)]
-    elif isinstance(color, str):
-        colors = [color] * n
+    elif isinstance(colors, str):
+        colors = [colors] * n
     else:
-        colors = list(color)
+        colors = list(colors)
 
     # If no highlight mapping is provided, use an empty dict to avoid KeyErrors
     highlight = highlight or {}

From 628cd32eea7af6f4a157a47441256993a0b438bb Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 13:02:46 +0200
Subject: [PATCH 08/33] Revert colors in color, added some checks on the lists
 lengths

---
 qoolqit/utils/visualization.py | 35 +++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index e3b985fe7..443992f8b 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -16,7 +16,7 @@ def plot_histogram(
     normalize: bool = False,
     ax: Axes | None = None,
     title: str | None = None,
-    colors: str | list[str] | None = None,
+    color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
     xlabel: str | None = None,
@@ -39,7 +39,7 @@ def plot_histogram(
         If provided, the plot will be drawn on this axes.
     title: str, optional
         Plot title.
-    colors: str or list of str, optional
+    color: str or list of str, optional
         Default bar color, or one color per mapping. Defaults to matplotlib's
         color cycle.
     highlight: dict, optional
@@ -49,6 +49,11 @@ def plot_histogram(
         color in every group, so the run it belongs to becomes ambiguous.
     labels: list of str, optional
         Legend label for each mapping.
+    xlabel: str, optional
+        Label for the x-axis. Defaults to "Bitstring".
+    ylabel: str, optional
+        Label for the y-axis. Defaults to "Counts", or "Probability" when
+        `normalize` is True.
 
     Returns
     -------
@@ -71,6 +76,9 @@ def plot_histogram(
     if normalize and any(total == 0 for total in totals):
         raise ValueError("cannot plot normalized counts with zero total counts")
 
+    if top is not None and top <= 0:
+        raise ValueError("top must be a positive integer")
+
     # Sort the union of all bitstrings by their total count, in descending order
     # We use set for unique bitstrings, and sorted across the union of all
     # counts to ensure that we have a consistent order for the x-axis.
@@ -86,12 +94,17 @@ def plot_histogram(
         bitstrings = bitstrings[:top]
 
     # One base color per set of counts
-    if colors is None:
-        colors = [f"C{index}" for index in range(n)]
-    elif isinstance(colors, str):
-        colors = [colors] * n
+    if color is None:
+        color = [f"C{index}" for index in range(n)]
+    elif isinstance(color, str):
+        color = [color] * n
     else:
-        colors = list(colors)
+        color = list(color)
+    if len(color) != n:
+        raise ValueError("color must have one entry per counts mapping")
+
+    if labels is not None and len(labels) != n:
+        raise ValueError("labels must have one entry per counts mapping")
 
     # If no highlight mapping is provided, use an empty dict to avoid KeyErrors
     highlight = highlight or {}
@@ -117,7 +130,7 @@ def plot_histogram(
 
         # Determine bar colors, using the highlight mapping if provided
         # If a bitstring is not in the highlight mapping, use this series' color.
-        bar_colors = [highlight.get(bitstring, colors[index]) for bitstring in bitstrings]
+        bar_colors = [highlight.get(bitstring, color[index]) for bitstring in bitstrings]
 
         # Shift each group so that the bars are centered on the tick
         offset = (index - (n - 1) / 2) * slot
@@ -133,7 +146,7 @@ def plot_histogram(
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
     ax.set_xlabel("Bitstring" if xlabel is None else xlabel)
-    ax.set_ylabel(ylabel or ("Probability" if normalize else "Counts"))
+    ax.set_ylabel(("Probability" if normalize else "Counts") if ylabel is None else ylabel)
 
     # Set the title of the plot, using a default title if none is provided
     ax.set_title(title or ("Measurement distribution" if normalize else "Measurement histogram"))
@@ -149,7 +162,7 @@ def plot_histogram(
         from matplotlib.patches import Patch
 
         ax.legend(
-            handles=[Patch(color=colors[index], label=label) for index, label in enumerate(labels)]
+            handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
         )
 
-    return ax
+    return ax
\ No newline at end of file

From 778f92c02fd1863dca3020c439f038185f4c2784 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 13:03:08 +0200
Subject: [PATCH 09/33] precommit

---
 qoolqit/utils/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index 443992f8b..ec77bebc8 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -165,4 +165,4 @@ def plot_histogram(
             handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
         )
 
-    return ax
\ No newline at end of file
+    return ax

From 4f06f89cd96d680c1e4aae4d4a124fe44eaf3213 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 13:20:32 +0200
Subject: [PATCH 10/33] More forgiving with legend labels format

---
 qoolqit/utils/visualization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qoolqit/utils/visualization.py b/qoolqit/utils/visualization.py
index ec77bebc8..b55543f3e 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/utils/visualization.py
@@ -47,7 +47,7 @@ def plot_histogram(
         {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
         counts: with several mappings a highlighted outcome takes the same
         color in every group, so the run it belongs to becomes ambiguous.
-    labels: list of str, optional
+    labels: str or list of str, optional
         Legend label for each mapping.
     xlabel: str, optional
         Label for the x-axis. Defaults to "Bitstring".
@@ -64,6 +64,7 @@ def plot_histogram(
 
     # Accept a single dict or a list of dicts, and work with a list from here on
     counts_list = [counts] if isinstance(counts, dict) else list(counts)
+    labels = [labels] if isinstance(labels, str) else labels
     n = len(counts_list)
 
     if not counts_list or any(not count for count in counts_list):

From d95a35603331908b9ce751d705622354e446f79e Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 14:27:19 +0200
Subject: [PATCH 11/33] Added test

---
 tests/test_utils.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/test_utils.py

diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 000000000..6009edea6
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,15 @@
+import pytest
+
+from qoolqit.utils import plot_histogram    
+
+def test_plot_histogram_errors() -> None:
+    with pytest.raises(ValueError, match="counts cannot be empty"):
+        plot_histogram(counts={})
+    with pytest.raises(ValueError, match="cannot plot normalized counts with zero total counts"):
+        plot_histogram(counts={"000": 0}, normalize=True)
+    with pytest.raises(ValueError, match="top must be a positive integer"):
+        plot_histogram(counts={"000": 1, "001": 2}, top=0)
+    with pytest.raises(ValueError, match="color must have one entry per counts mapping"):
+        plot_histogram(counts=[{"000": 1}, {"001": 2}], color=["tab:blue"])
+    with pytest.raises(ValueError, match="labels must have one entry per counts mapping"):
+        plot_histogram(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])
\ No newline at end of file

From 5d6bef78964fcc778667a7f4bf5dd64a6f635793 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 14:30:53 +0200
Subject: [PATCH 12/33] precommit

---
 tests/test_utils.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test_utils.py b/tests/test_utils.py
index 6009edea6..bca835ec8 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import pytest
 
-from qoolqit.utils import plot_histogram    
+from qoolqit.utils import plot_histogram
+
 
 def test_plot_histogram_errors() -> None:
     with pytest.raises(ValueError, match="counts cannot be empty"):
@@ -12,4 +15,4 @@ def test_plot_histogram_errors() -> None:
     with pytest.raises(ValueError, match="color must have one entry per counts mapping"):
         plot_histogram(counts=[{"000": 1}, {"001": 2}], color=["tab:blue"])
     with pytest.raises(ValueError, match="labels must have one entry per counts mapping"):
-        plot_histogram(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])
\ No newline at end of file
+        plot_histogram(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])

From 0a9e9761802dd544cebfa11c1d66549775207b87 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:04:00 +0200
Subject: [PATCH 13/33] Gone through changes

---
 docs/tutorials/Solving_a_MWIS.ipynb           | 146 +++++++++++++++---
 docs/tutorials/solving_a_qubo.ipynb           | 145 +++++++++++++----
 qoolqit/utils/__init__.py                     |   5 -
 qoolqit/{utils => }/visualization.py          |  43 ++----
 .../{test_utils.py => test_visualization.py}  |  14 +-
 5 files changed, 260 insertions(+), 93 deletions(-)
 delete mode 100644 qoolqit/utils/__init__.py
 rename qoolqit/{utils => }/visualization.py (84%)
 rename tests/{test_utils.py => test_visualization.py} (54%)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index 294a7fea4..1c22fc406 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -55,10 +55,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "id": "3",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -147,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "id": "6",
    "metadata": {},
    "outputs": [],
@@ -214,10 +225,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "id": "10",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "from qoolqit import Register\n",
     "from qoolqit.embedding import InteractionEmbedder\n",
@@ -241,10 +263,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "id": "12",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pair (i=0, j=1):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
+      "pair (i=1, j=2):  is non-edge   Jij =  0.02   (target Q_ij = 0)\n",
+      "pair (i=0, j=3):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
+      "pair (i=2, j=3):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
+      "pair (i=0, j=2):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
+      "pair (i=1, j=3):  is non-edge   Jij =  0.02   (target Q_ij = 0)\n"
+     ]
+    }
+   ],
    "source": [
     "for (i, j), value in register.interactions().items():\n",
     "    edge = \"edge    \" if Q[i, j] == 1 else \"non-edge\"\n",
@@ -278,10 +313,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "id": "14",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DMM weights (epsilon_i): {0: 1.0, 1: 0.0, 2: 0.0, 3: 1.0}\n"
+     ]
+    }
+   ],
    "source": [
     "node_weights = np.diag(Q)\n",
     "dmm_weights = 1.0 - node_weights / node_weights.max()\n",
@@ -329,10 +372,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "id": "17",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Omega = 10.00   delta_0 = -10.00   delta_f = 10.00   T = 200\n"
+     ]
+    }
+   ],
    "source": [
     "# Strongest interaction in the register sets the reference energy scale.\n",
     "distances = np.array(list(register.distances().values()))\n",
@@ -361,7 +412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "id": "19",
    "metadata": {},
    "outputs": [],
@@ -392,10 +443,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "id": "21",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAGxCAYAAACN/tcCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhrpJREFUeJztnQd8VFX2x3/pvfdeIAECoVfpYANEUbCiLqy97drFLq5/sa3dXdfesKHYEUEFQaV3QocEEkghvff5f84d32SSSUKATLn3nS+f+YR582bmnXveu+/Muac4GQwGAxiGYRiGYXSCs70PgGEYhmEYxpaw8cMwDMMwjK5g44dhGIZhGF3Bxg/DMAzDMLqCjR+GYRiGYXQFGz8MwzAMw+gKNn4YhmEYhtEVbPwwDMMwDKMrXO19AI5Ic3Mzjh07Bj8/Pzg5Odn7cBiGYRiG6QJUt7miogLR0dFwdu7Ev2OQiMbGRsNXX31lOOeccwwJCQmGNWvWtLvfF198YRg3bpyhV69ehlmzZhn27NlzUt+TnZ1NVa/5wWPA5wCfA3wO8DnA5wDkGwO6j3eGVJ6fefPmYd++fbj00kvx97//HbW1tRb7fPPNN7jsssvwwgsvYNSoUXj++ecxbtw4ZGRkIDQ0tEvfQx4fIjs7G/7+/t0qA1mk2ueriuoysnzywzqUG9X1pwcZK6wkX3l5OeLi4k742U5kAUESGhsb4erqipycHCHcihUrMGHChFb7DBkyBAMGDMA777wjnjc0NCAqKgq33347HnrooS4PXkBAAMrKyrrd+Kmrq4OHhwdURnUZWT75YR3Kjer604OMdVaSr6v3b6kCnsnwOZEluXnzZpxzzjmmbW5ubpg8eTJWrlwJR+DAgQNQHdVlZPkcE/odV99Yj9LqUhwrPYZDxw9hf/5+7Mndg13HdmFHzg5sPbIVmw9vxtd/fC3+v/PoTuzN24uDBQdxpOiIeN/xiuOoqqsSsX+ywueo/LAOrYtUy14ngjxCRGRkZKvt9Hz79u2dWqD0MLccGYaxjwFTXlOOvPI85JXlib9FlUUoripGSXWJ8VH119/qElTUVqC6vtr0aGpu6tbj8XH3gY+H8eHn6QdfD1/4e/kjxCcEIb4hpr/B3sHib5hfGKIDoxHmG9Z5sCXDMHZFKeNH+6XW1kNE3p+mpo4nxQULFmD+/PkW23fv3g1fX1/x/9TUVFRXV5sMLCIxMVFMcIcOHTJtoyW2wMBA8V6NkJAQYYDt3btXTO4Uf0Sfm5CQgKysLFRVVYn93N3dkZKSgtzcXBQXF5ven5aWJp7n5eWZtvXo0UMsAx4+fNi0jZYCPT09sX//ftO28PBwhIWFYdeuXeK7CTq+mJgY8ctCM/q8vLyQnJws4pw048/FxQW9e/dGfn4+CgsLTZ/Zq1cvVFZW4ujRo+2OhSYjRduT23HPnj3tjgUdP0Frs/Hx8cjMzBRjbD4WlHVXUlJien/fvn3FsdAxafTs2RP19fU4cuRIq7Egl6r5r6eIiAgR90XHptHeWHh7eyMpKUl8HnkT246FJp82FrQPHacGvZcgeTRoLEhOkluDjoWOicZHOz/bGwuSg2Sk8S4tLT3hWJAcpEcN+jwazxONRVBQkDhOc/naGwu6vkhuOh+LiopM76fxoXPHfCzonKLrks5zory2HI1ejThecxzrd69HbnkujlUcQ2ldKYpqipBbmovaRstYvpPF2ckZLs4u4q+7iztcnIz/b2huAJwAH1cfNBma0NjciLqmOjQ0NcAJTsJ4ou0aVfVV4gGj6F3G1dkV4X7hCPUKRZhPGMJ9w9E7rjfiguLgUe+BGP8YhHiHiPOUxphiGTXoeqXrluYQbU4jN35sbKy4vmpqasQ2utZpHqA5iVz8Qm5nZ/Tp06eVDjuav2j+IV0ePHiw0/krODhYbKdjpDACQpu/aP6huUCbZ+l72s5fdDx03tL2zuYvkq/tWGjzV9uxIOi4tbhPbf5qbywKCgpw/PjxTsfiVOZybf6y1lzeVof2mMs1rDGXE9aYy83PZ2VifjQ6ivmhQSRlUNDz+eefb9o+Z84cYRD88ccfXfb80OdbI+aHlN3VwGtZUV1Glq9zyEuzL28f9ubvFUtK+/L34UDBAWQVZaGsxnhjOhHuru7wdvcWDy83L3i4esDTzRNe7l6m7eSN8XbzFts93Dzg6epp2s/NxU1M4GTwULkK8e+vshX0/2jPaBytNU74NAWKfwYDmg3NwgCqa6xDbUMtautrUdNYY/o//SUPU2V9pVgaq6mvQU3DX6831Ir/0+tdgWRIDElEclgykkKTkBqRij5RfdA7srfwHp1OmQ0+R+WHdWjdmB+lPD9kDZLV+eeff7YyfsjomTZtWofvI6vSVoFlKhsFepGR5TNCy0/bc7YbH0e3i7gaMnQKK1t+WbYHGTO0hOTv6S+WkAK8AhDkHYRA70AE+QSJJSRfT1/hsbHW0lFefZ7wDHUEGVanAhlPdQ11YqmuqKpluY7ikMjrRUt6ZABW1lUKI2lX7i7xaAuNDxlBZAzRo290XwyIHYC44LguGUV8jsoP69C6KGX8EDfffDOeffZZXHnllWJZ4L///a9wR1533XVwBMhNR8elMqrLqDf5yCNCwcMbD2/EtuxtJoMnu6Rlaa0tFBsjjBnvIAT7BCPcPxyR/pGI8I8QRg95duxZQHRk0EisLVnb7Z9LnibyTsUGx4pHR5Dho8U0FZQX4HjlcWEwkaFExhHFMm3I2iAe5gR6BWJg/EAMihuEAXEDMDBuoDCOaDz1fI6qiOoyZthZPqmMny+++AJ33323KT6C6vnQujelsdODuOeee8T65dChQ4U3h17/+OOPlT6JGKY7OV51HN9u/VbceNdnrhdGD3kw2oMMGQr0DfUJRURABKIDosVNn4yetjdkpvWSFy130aMttJSWXZyNnNIckX1GxhF504QHqaYUK/euFA8N8pCRETSyx0iMSBohHhJGMzCMTZHK+Dn33HOFUdMWCnTSIDf5yy+/jKeffloE2dFSGGddMEz7UHwLpYD/fuB3rN6/Gn8e/BM5JS2BoBq0RBTqGyqymMiLEx8cj8TQRJHtxEZO90Keo9TIVPFoaxRlFWbhUOEhoaP88nzhMaL0/vVZ68VDI8grSBhDo3qMwpieY4RB5O3hzZcBw8ho/FBUvZZ9dSIo4p0ejgZl1KiO6jLKLB8F5ZI3hwwdMnj+PPCniEVpu3RDnhvKVqLAWwrG7RHeQ8TmdBYnIxP5dS0ZJjIZRX2i+4iHufFKhhAFlmcWZuJoyVGjl6imBD/u/FE8CAoAH5Y4DONTx2Nc6jic0eMMEW8lKzJfg11FdRmD7CyflNle1saaFZ4ZxpbQzXFr9lb8vOtn/LLnF2H0kAFkDi2bRAZEiiWr5PBkkXVEXh66YTLyQfo9kH8A+wr2mQwika7fxsClpbLJfSbjrLSzhHeIjCuG0cv9m42f0xi8U4FS7qnmgcqoLqOjy0fBycsylglj59c9v1rE61DhvqjAKMQExghDJyU8BX5efuKGSAzwH4Bt5dugMqrLaC4f/b4l7xBVs95fsF/EE7X19lGJgLEpY3FO33OEMdQ/tr9dA9Jlvwa7A9Vl3G8l+XSZ6i4DVMBJdVSX0dHko5iP3/f/jh92/IAlO5ZgT15LITLNsxMTFCPidCgziIwdSuXu6Obm5aK+B0B1Gc3lIz1Tijw9pmCK2EaZZpSxR+cKxRGRZ+jn3T+LB0GVqs/tey6mD5iOs9PORoC3sbCgo+Bo16A1UF3GejvLx8YPw0gIBbuSofPD9h+wbNcykRptfrOjJSy62fWK7IW0qDQRr+PIv+QZ20LLnPQ4u+/ZwjNEBtCW7C0idoi8RNTf7MO1H4oHVasmr9AFAy/Aef3PE/FfDCM7bPzYGCrfrjqqy2gv+TKPZ+KrLV9h8ZbFIivLPFyPUqfJs0NeHar/QoHKpxqcXN6ofm871WU8GfnIKE4KSxIPgqpb78zZia05W0XRSirQuGLvCvG4/bPb0SuilzCEZg6ZKYKo7WFUqz7H6EFGbzvLxzE/7cABz4wjQMbN7tzdWLx5sTB4thzZ0up1KhiYEJyAtJg09IvuJ6oCM0x3c6T4CDZkbhCVqKnuEFWx1ogNisXFQy7GrCGzMDJ5JJcVYeyOQwY8U3FCam5GfbP0avxQwzZqwaEyqstobfn25O7BJ+s/wWcbPxPLEBrUk4pid3qG9cTghMEiBd0aNXZ6+fbC3sqW71UR1WW0lnyi8nTmBpFBSPWGqCGsBlXwJm8QGUO0TGbN+mqqzzF6kPGIleRzqIBn6u5655134r333hMNRDV766qrrsK9996L9PR06AWtM7bKqC6jNeSjDJxPN3wqjB5zDw8tXVEn8J7hPcUSA8XxWLvWTpCb2vVF9CCjteQj7+KkPpPEg1LqN2ZtFBXADxYcFK06XlvxmnhEBURh9ojZ4kHLsN29NKb6HKMHGSvsLJ9NjJ+HH34Y27Ztw7JlyzB+/HjT9lmzZuGxxx7Dl19+aYvDYBiHgno5fb7xc3y87mNRcFCDUs4pfocaW5LBQ2npqhQXZNTB080TY1LGiAdlHG4+vFm0RKH6QrlluXhu2XPiQUH3V4+8GleMuEJUBWcYR8Amxs+iRYvwyy+/WOT0jx49Wnh/9ISrq/ox5qrLeDryNTY1YunOpXjvz/fw7bZvWy0bUN0dulFQKwJbeHg6or5Z7RRbPchoa/lo+ZXaadCDAqapivi6Q+vE0hgt3T749YPiMSp5FOaOnotLh116WhWmVZ9j9CCjq53ls0nMDzUXLSoqgo+Pj1gHbm42Bszl5uaiZ8+eqKpqXX3U3nDAM9PdZBzNEAYPpQ5TmroG1VOh7JnhScNFk0uuqsyoRGVtpfBq0vJYdkm2abuXm5cIkr527LUiPojLMDBKBjxTM1Ja+rrgggvg4uJi6sr+6KOPYsWKFVi1ahX0Yvzk5eUhMjISKqO6jF2Vj4JDF65diHf+eEcsB5inpVNKOi1ppcemi+UDRyLeKx5Hao5AZVSX0RHlo9pBv+37TRhC1KFegwL3rx1zLf52xt9EQH9XUH2O0YOMeVaSz6ECnufPn4/Zs2fj1ltvFc9fe+01LF26FD/++CN++ukn6AnygKl8QutBxhPJRwHLr//2uojlqayrNMXxJIQkiLYBlBIc7BMMRyXaM9rhbpzdjeoyOqJ85OUkb8/MwTNFRiPVDaL0eeo/RktiD3/zsGivccvEW3Buv3M7XfZVfY7Rg4xFdpbPJsbPtGnTRFDzk08+Kbqyz5s3D4MHDxaGz+TJk21xCAxjVarqqvDZhs+E0WPu5Qn2DkZadBrO6HkGEkMSOXCZ0T20xKV1p6eMMWq2u+bgGhwtPWrqRE8xbzdPuBl/H/13hPuH637MmO7HZhFHZOSwocOoxr68fXh1xav4YM0HKKspE9tcnFxE/M6QhCFiacvX09feh8kwDgkt+VIjVXrkFOeIVi1UQ4hKP9y/+H488s0jwlNE3qDRPUdzbBDTbXCFZxvH/FC8E8U9qYzqMjY2NuLXvb/ipV9eEv21NAK9AoWXh1J/ZfbyuMAFTTDG5amK6jLKLF9dQx1W7V8lPELmyQF9o/vizrPuFCnzbs5uSs8xephHm6wkn90DnimLq6scOHAAejF+SkpKEBSkdoE1VWWkpa0P13yIF5a/IGqZaFWXE0ITMCR+iEjz9ffs3vPFHoS7h6OgvgAqo7qMqsi3P38/lu9ajoxjGWhsbhTbQnxC8PeRf8ddU+8SLV5URdV51Nry2T3gmeJ6NA4ePIjnnnsOM2fOxLBhw8S2DRs2iDigu+++G3qC2nuofEKrKCO541/+9WW8ufpN0eRRq2vSO6K38PKQt0elFPVkn2Qlbpx6llEV+VIiUsSjoqZCGEF/HPwDRVVFePaXZ/Hiyhdx+fDLhTeIqkirhmrzqKPJZzXj59prrzX9/5xzzsE777xjUdDwgw8+wMKFC611CAxzWuw8uhPP/fQcFq5baPrVSUtb1w29Dp4BnqIoIdcnYRjr4+flh4uGXIQLBl2APw/8iW2Ht2FH3g4Ra0ePcSnjcP/U+0W2GF+TTFewXuc5M9atWydq/LRlxowZWL9+vS0OgWG6BK0Cr9q3Cue9fB7SH0vH+2veF4YPda8+f8D5eHDag7hy0JXiOU+yDGNbKI5ubOpYfHTJR7jjzDvQJ7KPuA4pRmjKS1PQ/7H++GTdJ6KSOsPYPeA5KipK1Pa56KKLWm1fvHixqP1D7i+9xPzU1NTAy8sLKiOjjFR1/OutX+OZpc9gXeY6UzxPj7AeOKPHGRiaOBQebh5iu4+LD6qaHKsqeXeiunx6kFFP8lHxxO+3f49NhzeZ2sVQb7x5U+Zhzhlz4OUu11wk8zzqCPLZPebHHIrrufLKKzFnzhwR80P21saNG0WXd6r9oye01h4qI5OM9AuR6vM88cMT2JO3R2xzdXYVPbbGp44XGSauLq0vEypYqDKqy6cHGfUkHxVPpH5hVECRsi//PPgnjhQfwc0LbxaFE8lDRKnygd6BkAmZ5lEZ5bNZqvvXX3+NF154Abt27RLP09LScOedd7a7HKay5ycjIwN9+/aFysggY0NjAz5a9xGeXPIkDhQcMNUc6RfdDxN7TRR1eqgPXXuMDBqJtSVroSqqy6cHGfUsH3WYp3pBK/euFC1mCD9PP2EE3XHWHdIYQTLMo44on0N5frT4HnowjL1riFCD0ad+fApZRVmmJosDYgfgzLQzOZaHYSSHMjHP638epvSbIuL3yBAqrirG498/jueXP4/bz7xdZIgF+aibScWcGPv2lGcYGxo9b//+Nhb8uAA5JTlim4+7j0iRpeqy0YHRrAuGUSw4emLviRjfazzWHFiDH3b8INLkaYn7xZ9fxD8n/xN3nn2nQ/fZYyRf9jpRwUM9FTksLS1FYKAcblcVZKSYHkqFpV99h4sOi22+Hr4YHD9YeHpOpUhaqHsoCusLoSqqy6cHGVk+S5oNzVh7cK0wggorjbr38fDBPyf9E/ece4/DLYc50jwqk3x2r/Bszuuvv24R6LR//3688cYb+Mc//oEFCxZAL8YPtUZwdVXb4eYIMtI5RoHMj377KPYX7DcZPVSJmYye02mW6OrkikaDuqm0qsunBxlZvs6NoHWH1okMMc0ICvAKwLxz5+Efk/8Bbw9vOAKOMI/KKJ9DGT+dBUFT8cNvv/0WjgQHPMsbqEen8zdbvxFZHlSkkPB298ag+EGiAFp3lMPXczCpKqguI8vXdSPo223fipggLXPskfMewfXjrhexQ/aEA54VCXhuj7POOgt///vf7XkIjEKs2LMC9315HzZkbRDPPVw9MChuEM7uezZigmLsfXgMwzhYuvyoHqMwImmEKJL4w/YfRM2g2z65TdT7+teMf+HKkVdK26CY6Ry7Gj+rV69WuogTYxvIw0NGj9Zh3d3FHf1j++PstLMRHxLPlZgZhukQKmkxodcEjOk5Bst3L8eyjGXILsnGnHfnYMGSBXju4ucwrf80nkcUwybGz3nnndduR1dqe/H4449DT4SGhkJ1bCUjNRylmB5KXScXNv2S6xvVF2f3Oxs9w3tardDb0dqjUBnV5dODjCzfyUPFTCk9fnLvySIomjzJe/P3Yvqr0zE2ZSxevPRFDE4YDFuh+r0i1M7y2STm5/bbb7fYRt1cx44di0mTJsHRsGbMD3P6lFWX4emlT+OFn19AbUOt2NYzrKdIWU+PTWc3NcMwp01VXRUWb16MNQfXoMnQJLZdNuwyPD3zaeFRZhwTh8v2uvHGG0/6NRWNnz179qB3795QGWvJSGnrb65+E49884gpS4Pq80zqNQkje4yEm4sbbMHQwKHYWLoRqqK6fHqQkeXrPo6XH8enGz81JVDQsjplhVGTY2umx6t+r9hjJfm6ev+2SQOYm2666ZReU5GmJuMvCJWxhoy/7v4Vg/81WPTrIcOHCpNRl/V7zr5HdHm2leGjpRGrjOry6UFGlq/7CPMPw22TbsM959wjGqbWN9XjuWXPIen+JPxnxX/Q1GydOV31e0WTneWz6wyQnZ2N4GCursl0zKHjh3D3orvx1ZavTK0ohiUOw5T0KVyZlWEYm0FxhA9MfQAbszaK5bDi6mLc8vEt+M/K/+A/s/+DcanjWBsSYVXjZ+DAge3+XytCl5WVhenTp0NP6CGGqDtkpIaElGnx7+X/Fo0KKXiZmo5O7T8ViSGJds28KKovgsqoLp8eZGT5rAPNO8OShonA558yfsLSnUuRcSwD458dj1mDZ+H5S59HXHBct3yX6vcKfzvLZ9WYn+eee078veeee/Dss8+2es3NzQ2JiYmYNm2aw1Wx5IBn+0FG8UdrP8K8xfOQW5YrttFkQgUKqSUF19xgGMZRqKipEPFA5A0iPN08cf+U+3HvufeK/zM6D3h+7733MGfOHNiCn376CVu2bGm1LSwsDNdcc41DGD+HDh1CcnIyVOZUZaQJhNzI6zPXi+eBXoEinodST73cHaceVF+/vsioyICqqC6fHmRk+WxLVmEWPlz7oalpclxQHF667CXMGDTjlL3Uqt8rDllJPoeq8Gwrw4f46quvsHLlSsyYMcO0zdPTcSzwmpoaqM7JylhaXYoHv3oQ//3tv6I9BVVmHpIwBNPSpyHUz/FqXfi5+kFlVJdPDzKyfLYlMTQRD017CH8c+EPEJ1KRxIv+exEmpE7Af6/8L3pHnXxWk+r3iho7y2c146dfv37i786dO03/7wjap7u/+6mnnurWz2S6HzJ0Fq5biLs+vwsFFQViW6+IXsLoSYlMsVqRQoZhmO6GPDxjUsaIhAwygKhlxsp9K5H+WLpYBiPjyJE82HrHasbPtdde2+7/bcHRo0fx8ssvC9fXqFGjkJqaCkfBw8MDqtMVGffk7hFp6yv2rhDPKXV9Uu9JGJ863u4NBU9EdVM1VEZ1+fQgI8tnPzzcPHDZ8MswsddEfLDmAxw4fgBPLnkSC9cuxJt/e1MUY+3S5yh+r/Cws3x27epuDahg4u+//45x48YJI2jp0qV4+OGH8dBDD3X4nrq6OvEwXzOMi4vjCs9WoLquGv+35P/w7E/PoqGpAa7OrhiaMBTnDzofIT4h1vhKhmEYu0C313WZ6/D5xs9FxWhi1pBZeOXyVxAZEMlaUT3g2Zbs2LFDLHtpQWZffvklLr74YmEQnXHGGe2+57HHHsP8+fMttq9duxa+vr7i/+Q9qq6uRk6OMaCNoGw1aopHgVsaUVFRCAwMxO7du03bQkJCEBkZib1796KhoUEcG31uQkKCSPevqjJeFO7u7khJSUFubi6Ki4tN709LSxPP8/LyTNt69OiBxsZGHD582LSNDDaKb9q/f79pW3h4uAj43rVrl7gQCTq+mJgYHDhwwGT0UYNZCj6j2kt08hAuLi6iAmd+fj4KC40VlYlevXqhsrJSGJftjQV9D8kYHR0tTj6q5En8lvkbnvrtKWSXZovnYxPHYt64efD29sa+qn1I80uDv6vxZK1pqsG28m1I8k5ChEdEi05K1iLKIwoJ3gmmbVvLtsLTxRO9fVvW1fdW7hW/fgcFDDJtO1xzGLm1uRgRNAJOMJ4fBXUFOFR9CP39+8PbxVtsq2isEMGwqT6pCHY31qFqMDRgU+kmxHnFIdYzFgYYx5KqBAe5BaGHTw/T9+wsNy7j9vNvWe49WHUQJQ0lovKuef+l7JpsDAkcAjcnY5HG4vpiMRYUsKrFbZAc28u3I9k7GeEe4WIbff+6knWI8oxCglfLWGwp2yLk6OXby7RtT+Ue1DbVYmBAS7mJw9WHkVuXi5FBI03b8uvykVmdiWGBw+DiZOxkXd5Yjl0Vu8TnkZxEfXM9NpdtRrxXPKI9o03v31CyASHuIUj2aQli3FG+w9hzza+vaduBqgMobShtdyxom1agj9K191ftb3csenj3QJhHmNjWjGasL1kvjoWOyXwsfFx8kOrb4vndXbFbHD+NhabDrOos5NXltRoLek7baT9PZ2PMYFlDGXZX7m53LEgHpAsNOp5Qj1ChM/OxoHGl81yD5CtvKBfngEZOTQ5yanNa6aGwvlCMWz+/fvB1Nc5JVU1V4jN7+vREqLsxNo7aMGwo3YB0v3T4uPqYPnNz6WbxPvOxIL02GhrFua9B+qdrgq6RtmNB15KHs/HXOumPziu65gLdjFWO65rrxJgneici0qPlxk7nKZ23dC1rkA5Jz+Zjsa9yHyobKzE4sKV/Fp0TdG60HQuaY7xdvYV+CXrfzoqd7Y4FXa+xXrGmz6Tr2N/NHyk+Ka3GgvZP9083baN5obCuEMODhpu20fxB88jggMFwdzZ6qOm6pvmmj28fBLgFiG21zbViXtLGorKuEq+tew2fbP1EnHd+7n745+h/4uL0i5GaktruXF5aWoqKigq7zuUabefytvc1On7Cz88P8fHxyMzMFPdL8/vasWPHRE9PDTp28v7QMWn07NkT9fX1OHLkSKuxoP1IRo2IiAjRGywjoyVpQRsLSngaPHiw/YyfE8X5WDPmpy1kkNxyyy0den9s6fkhZfXt23IjUJG2MuaX5+O2j2/Dok2LxHM/Tz+xvHVmnzOlXAOnmyQZYaqiunx6kJHlc0wyj2eKRsx55cYfsoPiB+Gdv72DgfGt6+Dp4V6RYSX57J7tZes4n84gq5es244gq9Le648qQnb1h2s+xO2f3Y6S6hLhAegf2x/nDzwfMYEx9j48hmEYm5IUloRHpz+KZbuW4fvt32PLkS0Y8sQQ3H7m7XhixhNS/hiUFVdbdnK3Ra8QcsuZW5NU94dceuPHj4cjYM/KxLaU8XDRYdzw4Q2iCioR5heGqf2mYnjScLi6OFZRy5OFlllURnX59CAjy+e40JLSuf3OxYikESIgelfuLjy//HnRMuPDaz4UGWN6uFc42Vk+m8b8UCyKFgvTp08fsQ7YndC648iRI8WaIxlAtG742WefCS/Uq6++2uXP4QrPp1ehmXrdUIVmCvCjgGZK/bxg4AUI8jHGSTAMwzBGNmRtwCfrPkFVfZWIRbxx/I14ZtYz8PU0xnYxEgc8Hz9+HHPnzsUPP/xgamVBhgr19XrnnXdE4FJ33nwpw4uCnoKCgjBmzBj0798S0Gdv44fGgoLWVITS16/94FpR6IuIDogWndcHxA9QqmYPBdYeqz0GVVFdPj3IyPLJRXV9tWjrs+nwJvGcwgJevOhFzBo1C6py3Er3wq7ev21yR7ruuuuEoBs2bEBtba140P8pyvv666/vdpfi1KlT8eCDD+Lmm28+acPH2hQUGIv5qURDYwOe/OFJDHh8gDB8vN28RWXTO8++E4MSBill+BDmGUUqorp8epCR5ZMLb3dvXD/uetwy8Rb4e/rjaOlRXPzOxZjzzhyUVZdBRQrsfC+0SfDFsmXLRAo6pWdrDB06FAsXLnQ444Q5OTKOZuDqd67G5iObxfOEkAS8Pv11HG48bPc1XYZhGJmghJB/zfgXPl3/KdYcWoP317yPpRlL8dbVb+G8AefZ+/CUwiY/yak+gY9PS80JDap1Q/n6jHw0NTfhuZ+eE5kKZPh4uXmJyqW3T74d0f7RbPgwDMOcAtQNfs7oOXh35rsI8g4SpUKmvzodV7x5hbJeIHtgk5ifBx54QAQ7/+9//0NwsLFoHBXtu+GGG0TQ85NPPglHwpoxP1TAiYo+ycyh44cw5905WL1/tXieGJKICwddiF6RvYTRQ4XQqOCZqrB88sM6lBvV9afJWFFfgUUbF4m5loojRgVE4aNrPsKkPpMgO/VWuhc6VMAzLXFt2rRJ1NKhpS/6SqoeSYUFhwwZYgqC1qoqq2z80Gd392faCtLbG6vewF2L7hKZXO4u7iItc3r/6fD2MFZHJoLdglHc0FKhWjVYPvlhHcqN6vprK+O+vH146/e3UFZj9PxQbNCzs56Vui5QuZXuhXYvcmjOjBkzxIOBKDkuY9XOoyVHRSbX0p1LTdkIMwbNQHpMusUSF5XQV7l6LssnP6xDuVFdf21lTI1MxeMXPC6ao67PWo/XVryGn3b+hE9v+BRDElpao8hEtp3vhTYxfjprKso4vrfnk/Wf4JaPb0Fpdamo2zMyeaQwfKhNBcMwDGObWKBrxl6DIYlD8P6f74tu8SOeHIGHpj0kHrIXj7U1auUgM90KGTuXv3k5Zr81W/w/wj8Cc0fPxeyRs9nwYRiGsQMD4waKjLC+0X1F4sn87+Zj+P8NF0tjTNexScwPBTa9++67orO6eVdXje+//x6OhDVjfqjHmNYp3pH5ff/vwug5UnxE1OkZmjAUFw2+qEtVmgNcA1DWqG5WAssnP6xDuVFdf12RkW7dVFft842fo66xDh6uHvj3Jf/GzRNuliLbttJK90KHivmhYoPffPMNpk2bJlrW6xnz4G5HpLGpEf/6/l944ocn0GxoRqBXIKamTxWBzS7OLl36jPrmeqgMyyc/rEO5UV1/XZGRDByal9Oi0vDG6jeQWZiJWz++FT/u+BEfXPMBgn2MmdWOiqud74U28fwEBgbijz/+kCbQ15qen4yMDIcdh8zjmbjy7Svx58E/xXNKXb90yKWICT65Duwjg0YqHYzI8skP61BuVNffycpIP1TJ6KFO8fR/ClH47PrPML6XYzT0tuW90KHaW7i5uSEm5uRuoIxt+Xjdxxj4+EBh+JD79Jy+5+CWCbectOHDMAzD2BYKTZjWfxruPfdeU2HESf+ehAcWPyC8+YydjJ/Zs2fj6aefFmuUjGNRXlOOq9++WsT3lNeWiyJa1429ThQt9HDzsPfhMQzDMF0kKTQJj53/mEh/Jw/Qgh8XYNSCUThcdJjH0B7LXseOHUO/fv1EcFNSUpJFMNbKlSuhl2WvoqIihISEwBHYkLkBl715majYTDoZGj8UFw+9GAHeAaf1uZEekciry4OqsHzywzqUG9X11x0yrjm4Rnj065vq4evhi7f+9hYuHXYpHIUiK90LHarCMwU6b9u2TRQ6pPiftjzxxBPQi/FDw23vSHw6hpd/eRn3fHEPGpoaRBfhKf2miPXhrgY1MwzDMI7N8Yrj+O/K/4ou8cTfRv0Nr81+DT4elr02bY217oUOZfx4eXlh69at6NWrF2RA5YBnqtdzzfvXYPHmxeJ5j7AeuGTYJaI/V3ehejAiyyc/rEO5UV1/3Skj1QL6ctOX+GXPL+J5SngKvrn1G/SJ6gN7oouAZ+rqHhYWZouvYjphY9ZGDP7XYGH4uDi5YGzKWNEjpjsNH4ZhGMZxIG8+/cD95+R/wsfdB/sL9mPIv4bgo7UfQc/YxPih5a7HH38cTU1Ntvg6pg3k3Hv111cx+unRohZEgFcALh9xOa4YfoVDuD8ZhmEY65IWnSaCoSkouqahBle9fRX+/t7fUdtQq8uht0mVIarsvHnzZnzyySdITEy0WOdzhE7utiI42LaFp8qqy3DdB9dh0aZF4jmd+GT0xIfEW+07VQ9EZPnkh3UoN6rrz1oy+nv5495z7hXe/+W7l+PdP94ViS+0DJYclgyV74V2ifk5UUCzozU+tWbMjy3ZcmQLLn79Yhw8flDUgTijxxmYOXgmvD287X1oDMMwjB3Znr0d7/zxjvACUTbY+39/X7Qwkh2HCniWDWsaP/v370dKSgqsCan0zdVv4h+f/EP0fKFsLiqARTE+tsjmGhgwEFvLtkJVWD75YR3Kjer6s5WMJVUleHXFq8gpyRHPb5t0G/598b/h5uoGa2Ote6FDBTx3xMGDB/Hggw9CT1CTV2tC67e0zHXDhzcIwycxNBE3T7wZE3pNsFkau6ezJ1SG5ZMf1qHcqK4/W8kY5BOEB6Y+gHEp48TzV359BaOeGoWcYqMxJPO98ETY3Pipra3FwoULMWnSJGH1ffzxx7Y+BGU5UnQEY58ei7d/f1vEVY1MGolbJ94q4nwYhmEYpi0uzi6YPXK2qOzv7uqOTYc3of/8/li5x7GKD0tr/FCdn9tuuw3R0dG48sorMW7cOGzatAmZmZnQEz4+1smu+mX3LxjyxBBsPLwRXm5emDFwBq4adRX8PP1ga8oayqAyLJ/8sA7lRnX92UPGoYlD8fC0h0VT1JLqEkx+fjKeX/a81dpSWete2FWsGvNDa27k2Xn77bdFhefp06fj+uuvx5QpUxy6z5dMAc80js8tew7zvpwnermE+4XjkqGXID023d6HxjAMw0hGfWO9WD3Ymm2MN6KWR+/NeU+aRBmHiPmJiorCs88+i4suugjZ2dlYvHgxzj33XOiZw4e7r8FcRW0FLv3fpbj3i3uF4dM7sjdum3yb3Q2fXr5yVPI+VVg++WEdyo3q+rOnjO6u7rhx/I1i9YDCJxZtXIThTw5HVmGWw94LTwWrGj/k1qqsrERpaamwxhiI8egO9uXtw8gnR4r6PVSteXzqeHHCkufH3gS5BUFlWD75YR3Kjer6s7eMTk5OmJI+RVSFpjCKjGMZGPj4QCzLWOZw90KHNH6OHj2KV199VSx5paWlYeLEiRzg3A18t+07DPu/YdiVu0vUZyC3JHXr9XL36o6PZxiGYRhQ/69Hpj+CqIAolNWUYcpLU/DUkqccOmzFIYwfd3d3XHLJJfjpp59EWjsFOd9///3itZtuuklst3e6m61xdT31otp0wi1YsgAXvHYBymvLERMYgxvG3YCJvSc6VDf2+ma1dcryyQ/rUG5U158jyRjsEyzS4YckDBHhFfd/dT9m/ncmquqq7HYv7A5sXuSwubkZy5YtE0HQ3377LTw9PUVgkiPhiAHPNfU1ohv7J+s/Ec/TY9JFm4pgX/uWCGcYhmHUx2Aw4OfdP4vWGFqM6dLblyIhJAGOhEMEPLf7hc7OIuh50aJFyMnJwSOPPAI9kZd38v1ajpYcxbhnxgnDh9pUUHzPtWOvdVjDJ8HLsS6G7oblkx/Wodyorj9HlNHJyQlnpZ2F28+8Hd7u3tiTtweD/zUYfxz4w2b3wu7ErhWew8LCcNddd0FPFBUVndT+6zPXi/gerX7PRYMuEvE9nm6OW+E0yjMKKsPyyQ/rUG5U158jy9grshcePu9hhPuHo7iqGBOem4C3V79t9XuhUsYP0zkL1y4UHp/cslyE+IRg7pi5OKvvWQ4V38MwDMPoi2CfYDw49UGkRaWhsakR135wLW7/9HY0NTdBFtj4cUDoBKKihVe+faXoz5UUkiT6cw2IHWDvQ2MYhmEY0OoD1ZU7q89ZYjRe+uUlTHlxiqg/JwPc1d3GAc8U8E1xTx1RXlOO2W/NxvfbvxfPh8QPweUjLrdLm4pTxRnOaEYzVIXlkx/Wodyorj/ZZFxzcA0+XPuh+OGeGp4qAqGTwpJO616oXMCz3qGCjx1xuOgwRj89Whg+rs6uODvtbMwZPUcqw4cI9QiFyrB88sM6lBvV9SebjKN6jMLdZ98NH3cf7CvYJwKhV+1bdcr3QlvAxo+Nyc3NbXf7hswNGPHkCOw8ulMULqT+XBcOulCUGpeNZO9kqAzLJz+sQ7lRXX8yypgcliwCoakgYmlNKSb/ezLeXPXmSd8LbQUbPw7AV5u/wvhnxyO/PB+hvqGYO3ouxvcabxWXIMMwDMNYgyCfIFEQkerQNTY34voPr8c9i+4RS1yOhtJ319raWjh60ajnlz2Pma/PRE1DjSgWddP4m9Avpp+9D41hGIZhThparbhl4i2iJhDx3LLnREXo2gbHuh8rafw8+uijCAwMhK+vL1JSUrB06VI4CsnJRlcmpQfe8vEtuGvRXcII6hfdDzdPuBmxwbGQnR3lO6AyLJ/8sA7lRnX9yS6jk5MTZg2ZhdkjZovCvF9v/Rpjnx6LwopCi3uhvVDO+HnllVfw4osv4vvvv0d1dTXmzp2LGTNm4MCBA3AEyP1HGV3TX52O/678L5zghNE9RouKzYHegVAB6jKvMiyf/LAO5UZ1/aki47jUcbht0m3CG0SFeoc8MQT78/eL1+y9FKac8UOGz7XXXosxY8aIxqoPPPAAIiMj8frrr8MRWLNjDcY+MxZLdy6Fm4sbpqZPxRUjrlCqI3uaXxpUhuWTH9ah3KiuP5VkTItOw7xz5yHAKwBHio9g6BNDsXrfamRlZdn1uJQyfgoLC3Ho0CGMHTu21XbqJr9u3TrYm82HN2P2p7OxPWe7KaPrvAHnwdXFvt1tGYZhGMZaxATF4KFpDyEmMAblteWY9PwkLNmzBPZEqbtuQUGB+Bsa2ro+Qnh4eKfGT11dnXiYF0nqbnJLczHu2XGoqqsSGV2je45GXFCcqO2jGiMCRyCzMBOqwvLJD+tQblTXn6oyXjb8Mny5+UtkFWbh3qX3Ii0lDdP6T7PLsShl/Gi0XUtsbGwUAVgdsWDBAsyfP99i++7du0XQNJGamipiiKgTvUZiYqJIRydvk0ZUVJQItqb3aoSEhCAqMgpzh8zF5pzNeHrK02h2acb+qv3o5dML/q7GKpR1zXXYXrFddPMNdw83vX9D2QZEuEcg3ivetG1nxU64ObuJ92scqD6AqsYqDPBvaYORU5uD3LpcDA0YKuKLiML6QmTWZKKvb194u3iLbZVNldhduRs9vHsg2M3YLb7R0Igt5VsQ4xmDaI9o02fStgDXgFZ1KOi9BhiQ5mt01V6ecrn4jpL6EgwOGGzaL68uD9m12RjoPxBuTm5iW2lDKfZX70dvn97wczUWdKxtrsWOih1I9EpEmHtYp2NB+3k4eyDVJ9W0jca2prkG/f36m7bR99L3m4/F8frjyKrJQj/ffvByMS49VjRWYE/VHvT07okgt6BWYxHrGSvOJZKP2Fy+GUGuQUjyTmo1FkQf3z6mbZnVmShpLMFg/5axIL2Qfgb5D4Krk/FSLGkoEXo0H4uaphrsrNzZaixorDeWbUSkRyTiPONMn0nnj5ezF1J8Ukzb9lXtE+dWul+6aduRmiPIr8/HsIBhpm3aWDSi0SSfNhYp3ikIdDPGpDUYGrC1fKv4Xvp+jc1lmxHkHoQkr5ax2FW5S4y1+Vgcqj6EssYyIbfGsbpjOFp7tNVYFDcU42D1QfFeXxfjdVjdVI2MygzxHaHuoa3GIsojSuhHY1v5Nvi4+gg9auyt2ouG5oZWOmxvLArqC3C45rA4f+jcIsoby8X7aWwDXY1jUd9cj20V2yzGYlPZJoS4hwidadBxu8AFvX17m7aRfDTGdD1o0DjQeNC5osV9FDUUiXGj68vHxafVWCR7JYvvIpoNzdhUvkmca5p8JxqLfn4t2aUkM50HdI1o5Nfl40jtkVZjQfqj84quOZoLzOeveM94RHhEmN5PuqHz1rxLeVfnL20shvgPEYGzYizqi3Co5hAuSL7ANH9VNVWJc43mpBA341g0GZrE9UlzF81hGnTu0rVFc53Gnso9aEKTmBM16Fqg7xoSMMRi/hrgNwDuzsYabKWNpVaZy2nMzXVor7mc6M65/MpeV+KF31/AjuM7kB6SjoyMDNNn9uzZE/X19Thy5IhpW1xcHDw8PFrF7UZERAgnh/l76b4bExODgwcPQnftLahiZFBQED7//HNcfPHFpu1XXHEF8vLy8Ouvv3bZ80MD3t3tLWioa+tq4eWpTnxPezQ0NMDNzXgxqAjLJz+sQ7lRXX96kLG6threnkaDrTvRZXsLsvz69euHX375pZUXiIweCoDuCLIqaZDMH9aAfm0eOtjiJVKVffv2QWVYPvlhHcqN6vrTg4yZB+27pKeU8UNQdte7776LhQsXiuWoW265RXh1brrpJnsfGsMwDMMwDoByMT+XX345ampq8PTTTyM/Px/p6enC80OxOF1FWwm0RuBzZWWlVT7XkVBdRpZPfliHcqO6/vQgY6WV5NM+80QRPUrF/HQXFNRMMT8MwzAMw8hHdnY2YmM77pjAxk87UJzQsWPH4Ofn12mW2MmiBVKTUqwVV2RvVJeR5ZMf1qHcqK4/PchYbkX5yJ9TUVGB6OjoTpuDK7fs1R3QgHVmMZ4u1gyqdhRUl5Hlkx/Wodyorj89yOhvJfko20t3Ac8MwzAMwzCdwcYPwzAMwzC6go0fG0L1hB599FHxV1VUl5Hlkx/Wodyorj89yOjhAPJxwDPDMAzDMLqCPT8MwzAMw+gKNn4YhmEYhtEVbPwwDMMwDKMr2PhhGIZhGEZXsPHDMAzDMIyuYOOHYRiGYRhdwcYPwzAMwzC6go0fhmEYhmF0BRs/DMMwDMPoCjZ+GIZhGIbRFWz8MAzDMAyjK9j4YRiGYRhGV7DxwzAMwzCMrnC19wE4Is3NzTh27Bj8/Pzg5ORk78NhGIZhGKYLGAwGVFRUIDo6Gs7OzuoYP2SYLFu2DHv27MGsWbMQGxtrsU9NTQ2WLl2K/Px8pKenY/To0Sf1HWT4xMXFdeNRMwzDMAxjK7Kzs9u1D6Q0fhYvXox77rkHkZGR+PPPPzFw4EAL4fLy8jB+/Hi4u7uL1x966CGcd955eO+997r8PeTx0QbP39+/W2Ugi1T7fFVRXUaWT35Yh3Kjuv70IGOFleQrLy8XzosTfbZUxk9gYCCWL18uDJuOPDPz5s2Dl5cX1q5dC09PT2zfvh2DBg3ChRdeiAsuuKBL36MtdZHh093Gj4eHh3iojOoysnzywzqUG9X1pwcZPaws34lCVqQKeJ40aRKSk5M7XRL78ssvMWfOHGH4EP379xfLXp9//jkcgQMHDkB1VJeR5ZMf1qHcqK4/Pch4wM7ySeX5ORFHjhxBZWUlevfu3Wo7Pd+wYUOH76urqxMPc7cZwzAMwzDdQ2NtIwq2FODY2mPIXZuLnI056LOvD5xd7OODcVVtDVFbHjMnKCjI9Fp7LFiwAPPnz7fYvnv3bvj6+or/p6amorq6Gjk5OabXExMTRTT5oUOHTNuioqLE99N7NUJCQkSc0t69e0UkekZGhvjchIQEZGVloaqqSuxHy3kpKSnIzc1FcXGx6f1paWniOcUzafTo0QONjY04fPiwaRstBZLHa//+/aZt4eHhCAsLw65du8R3a+MTExMjLG/N6KOlQvKqUZyTZvy5uLgIw5ECxwsLC02f2atXL2FkHj16tN2x0GSkaHtaNqTg9PbGgo6foLXZ+Ph4ZGZmijE2HwsKPi8pKTG9v2/fvuJY6Jg0evbsifr6emH8mo8FuVTNf11EREQgNDRUHJtGe2Ph7e2NpKQk8XnaeWM+Fpp82ljQPnScGvReguTRoLEgOUluDToWOiYan6ampg7HguQgGWm8S0tLTzgWJAfpUYM+j8bzRGNB1wkdp7l87Y2Fq6urkJvOx6KiItP7aXzo3DEfCzqnyCNL57kGjTed/ycaCzp3SI90TlESQ0djQe5tukaOHz+OgoIC02fS+VNbW9tqLOiao+M3l5HOx+DgYHGNaNBzupbpWqJzi/Dx8RHnOV1zdP53NhZ9+vQRx0fXcmdjQTGLNMb79u0zbaPrla5bmkNofyIgIEDsaz4WdK3TPEBzUllZmdhG1yB9t7l8Hc1f2lgcPHiw0/lLGws6xoaGBrFNm7/Mx8LNzU18T9v5q72xaG/+am8stPmr7VgQdNykX/P5q72xoHOCzo3OxuJU5nJt/rLWXN5Wh/aYyzVOdi6n9xYdKELptlJU7KxA9Z5qYfg0Nxh1qLFn2R4Y4o2ydNdcbn4+d4aTQRtFiaCTlgZkxYoVmDBhgmk7CU2DR9lgZ511lmn7TTfdhD/++EPE/3TV80OfTxdRd8f80IlHSlMZ1WVk+eSHdSg3qutPNhnrK+uRtzFPeHToQd6d6nzjjzdzXL1d4RPhA+8Ib3hEemDys5MR1DOoW4+F7t9kIJ/o/q2U54csTrIQyQgyN37oOVnhjhBYJsvJfDqoLiPLJz+sQ7lRXX+OLKOh2YDifcWtDJ3CHYViuzlOzk7wCvOCT6QPfGN8EZQaBL84P7j5uKGprgmVRyvh6mU/E0Qp44fcrlOnTsXHH3+M66+/XrjuyH22cuVKvP3223AEyE1HyxUqo7qMLJ/8sA7lRnX9OZKMtSW1yF3fYujkrcsT29ri7ucuPDo+UT4ISA5AYM9AeAV7wdm1/ZiewuMty2/2QCrjh9Y6aUlLW9P94osvsHXrVowcOVI8iKeffhpnnHEGpkyZghEjRghDaNy4cbjiiivsfPQMwzAM47g0NzWjcGehydChv8V7WmKWNJxcneAd7i2WsPzi/RCYEgj/WH+7enJOFnmOFBCBWVqw4D//+U/xl56bZ3fR8tbOnTuxcOFCEdz12GOP4bLLLhMBXwzDMAzDGKnKr0LuOjOvzvo8NFQZg9rN8Qj0EF4d32hfk1fHI8DDbplaujN+hg8fLh4ngiLB77zzTjgilFGjOqrLyPLJD+tQblTXnzVkbKpvQsHWglZenbJM4yqKOc7uzsag5Ehv+Cf4IyglCL5RvnDx6F4HglaLz15IZfyoAKUMqo7qMrJ88sM6lBvV9Xe6MormnjkVrQyd/E35ItC4LZ4hnsLYIa8OeXTIs0PxOxSwbE18/YxlZOwFGz82huqGdJZ5pgKqy8jyyQ/rUG5U19/JythQ3SCMG83QoUflMWP9JXMoJkcEJUf6wD/R6NWh2B0Xd9uHhZQUt9Rvswds/NgYrWCayqguI8snP6xDuVFdf53JSF6d0oOlrbw6x7cdR3Nj6wKCcAK8w7yNsTqxf3l1EgNEqrnTCfpe2QKtmKm9YOOHYRiGYRyUuvI6EYisGTr0t7bIMtWcjBqK0yGvTkBSgKir4xXScaq53mHjx8ZQ+XbVUV1Glk9+WIdyo6r+qFBg0e4iYeTsXb4XGzI2oDCjEGjTh8HJxZhqTl4dKhwogpJjfeHm7Rhena7W5bMnUra3sDZdLY/NMAzDMKdKdWG1KdVcPNbnor7ccrnLPcBdBCVTAcHA5EAE9AyAZ5CntKnmjbWNosLz4H8Mhl+MX7d+ti7bW8gAVZymNhwqo7qMLJ/8sA7lRkb9NTU0iTYQ5kHJJfstg36d3ZyFV8ct2A0hPUOMXp0YX7h6qnW7Li8zNl21F2qNpgR01l1eFVSXkeWTH9ah3MigP8q2Mjd0qPFnY42x+7k5nsGeprYQFJRMnh0qIJibl6t0Sn+9nYPW2fhhGIZhmNNcxinYUtAqKLniiKWB5uLpYmwLYZZqTv+3R6q53mHjx9YD7qr+kKsuI8snP6xDubGn/ihMtiyrrFVXczJ8mhssU829Qr2MsToxPgjqGSQMHnffrhUQdHFW2yBydrZvvBIHPLcDBzwzDMMwRH1lvViyEobOGqNnp7qg2mJwXL1djYYOeXWS/BGYGgjvUG+4uKltxOgq4Pn111/v8DUPDw8kJydj9OjRyv+6OhXy8vIQGRkJlVFdRpZPfliHcmMt/VGqefG+4lZeHQpSpu3mkOfGK8xLGDoUjEw1dSjlvDsLCFJAsH+AutnGVZVVdv3+U7JOnn/+eVF6m9xW4eHhQtnUQb25uRlxcXE4duyYMIB+/fVXxMbGdv9RS0xRUZHShoEeZGT55Id1KDfdpb/aklqRXm7y6qzLRV1pncV+1OtKC0rWupp7BVu3gGBlVaXSxk9NTY18xs/VV1+NtWvX4n//+x9iYmLEtpycHFx33XUYM2YMbrzxRvztb38TndU///zz7j5mhmEYhjkpqP0DFQw0bwtRvKfYYj8yaEQBwUhjAcHAlED4x/qLvliMOpySNt99912sWrXKZPgQ5OF58803MWHCBDz44IN48cUXMXbs2O48VoZhGIbpElX5VaYCguTVyduQh4aqBov9PAI9jP2von0R0CMAgT2MqeayFhBkrGj80LIWLXG1hbYdPXpU/D8sLAyNjZY1DfRO7969oTqqy8jyyQ/rUC39NdU3oWBrQSuvTllmmcX7nN2dRVAyeXX8E1pSzR2xgKDKoQNESEgI7MkpaZw8Otdcc41Y9kpKShLbDh06hOuvvx7jxo0Tz3/++WdMnjy5e49WASgSPSgoCCqjuowsn/ywDuWFUs2P7TqG6j3VRkNnTS7yN+ejqc6yS7hniKcwdsirI7qaJwXA3b9rqeb2pramFt4+avYwI+rqLGOrHN74eeutt3DppZeKoObg4GBxMpaUlGDkyJH47LPPTAFpL7zwQncfr/SQ10xlw0APMrJ88sM6lIeG6gbkb8pvVS2Zqie3hWJyRFCyVkAwNQjeYd7SFhAsLStV2viprLTUocMbP9RTZc2aNVi3bh12794tsr3IDTlixAjTPuQFYhiGYZiuQj+kSw+WtixfrclFwbYCGJratjWHMGxErE6MrzEoOeGvAoKSdDVn7MtpLXSSsWNu8DAMwzBMV6krr0Pe+rxWbSFqi2ot9qP6ORSnQ14dWrpqCGxAQu8E0QSUYWxq/GzduhV//vkniostUwUfeuihU/1Y5aGlQtVRXUaWT35Yh7aHCgUW7S4yZV+RoVO0qwho69RxcTKmmkcYU81p+Yq8O27eLQUEG+oblDd8wkLDoDKBQYHyGT8vv/wybr/9dqSkpLQb28HGT8e0lyWnGqrLyPLJD+vQ+lQXVptSzcVjfS7qyy07ebsHuBvbQlBX8+RAsYRF6eedpZrT8pjqqC6joU3VbCmMn2effRaffvopLrnkku4/IsXJyspC3759oTKqy8jyyQ/rsHtpamgSbSC03lfk1Sk9UGqxH3lrtK7mfvF/eXWifU861bywqBDR0dFQGdVlLCuzLEXg8MZPRUUFzjvvvO4/GoZhGMbhoWwr8+wravzZWGNZ180z2NPUFoJSzYOSg4SnR4ZUc0ZtTsn4GT58uGhvMWnSpO4/IoZhGMahOnBTHR3zAoIV2RUW+7l4upi8OpRqHpwaLAwfWVPNGbU55SKHl112Ge644w707NnTIrVw1qxZ3XV8ymHeEkRVVJeR5ZMf1mHHcSZlWWWtupoXbClAc0ObOD4nwCvUyxirE+ODoJ5BwuARqeY28OoEBapbR0wvMvr5+dn1+50MpxBVFRjYeZR2aanlWq9s1V8DAgLEmqS/f/d21aWWH66ujldKvTtRXUaWT35Yh0bqK+tFzytzr051QbXFeLl6uxoNHfLqJBkLCJLx4+JmH69Oc1Oz8r23VJaxsbYR5UfKMfSOofCL8bPL/fuU7lCyGzf2ZO/evUoHA+tBRpZPfvSoQ8quKd5X3MqrQ0HKbbNuyHPjFeYlDB1KMSdDh1LOqdaOoxQQzMvPUzoYWA8yFrdTJseWqPvznGEYRsfUltSKVHNTYPK6XNSVWvZTcvdzNwUlByQHiCUsClR2dlXT68AwJ2X8vPfee+LvnDlzTP/vCNqHYRiGsQ3Njc0ozCg0eXSyfsvCj5k/WuxHBo0oIBhpLCAo2kLE+ou+WAyjJ7p8xmuFC8mwOVERQzZ+OiY0NBSqo7qMLJ/8yK7DqvyqVnE6FLfTUNVgsR8VCxT9r6L+6mreIwAeAZ0XEJQBX19fqI7qMnp5e8lh/OTk5LT7f+bkiIiIUH7IVJeR5ZMfmXTYVN+Egq0FrYydskzLAnHO7s4iKJm8OtTkMyglSBg9Lh7qpZp3dyKKI6K6jD4+Pnb9fvZ12pg9e/agd+/eUBnVZWT55MdRdUjJtxU5FaZKyfSgGjtNdU0W+3qGeApjR3Q17xEoGn66+xtTzfPy8hAQGQBVIfkiIyOhMqrLWFRUZNfv58amNqapyXISUw3VZWT55MdRdNhQ3YD8TfmtqiVT9eS2UEyOCEr+q4AgZWB5h3VcQJB7l8mP6jo0yNjbixubMgzDnLxXp/RgaSuvTsG2Ahia2rY1hzBsRKxOrDFWh5axRAFBB0k1ZxjZ4camNkb1dVw9yMjyyY8tdFhXVicCkTWvDv2tLaq12I/q51CcDnl1RKp5ShC8QrxOK9Xcy9O+waTWRnX59CCjh4eHnBWejx07Bm9vb6iINSs8MwyjZjXeot1FrQoIFu0qAto6dVycWqWai6DkGF+4eTtOAUGGsUWF58qjlRj8j8FyVXiWpbEprZk6OztWSuehQ4eQnJwMlVFdRpZPfk5Xh9WF1aJooDB01hxD3vo81FfUW+xHHcxFWwjqap4cKOrqUPq5tVPNC48XIjRM7nR+PcunBxlL7dwpQsnGpgsWLMCLL76IwsJCpKWl4aWXXnIYQ62mpgaqo7qMLJ++dNjU0ITj24+38uqUHrCcuJ3dnI1ByRE+8Iv3Q1AvY6q5q6ftk2rrGywNMZVQXT49yNjY0GjX7z+lq/Lf//63+Pv000+3+7o9jZ/XX38dTz75JL766iuMHDkSzz77LM477zxkZGQgKSnJbsfFMIwcULaVKU6HvDob89BU206qebCnqS0EBSWTZ4cKCNqiqznDMKeHco1Nn3/+eVxzzTU488wzxfPHHnsM7777rjCKOjLW9BTkZQtUl5HlU0eHFHtAdXTMCwhWZFdY7O/i6dKSap7gj+DUYPG8o1Rze+Pm6gaVUV0+Pcjo4mrfa8dVtaJJ+/fvx/jx403baEmOnq9ZswaOAC0Tqo7qMrJ8ckK5HWVZZablq7Vr1orKyc0NbeqpOAFeoV7GWJ0YH9Hok2rriFRzSbw6YeFhUBnV5dODjEFBQfIZP+RF6Ywbb7wR9iA/P1/8DQtrfdKEh4dj/fr1Hb6vrq5OPMyjxa3F7lW7EeRjX6Vbm+MFx5W+cFk+OaACgpRxVbij0PjYWYjaYstUc1dvV5GB5RnkKaomk6HjFdw61byupE48ZKGivAJ+/t2bReNIqC6f6jI2NzajosLSw+rwxs9zzz1nkVV19OhR1NfXiwwKexk/5sfT9nlnaaQUID1//nyL7bt37zY1l0tNTUV1dXWrvmaJiYkim4wyRzSioqJEKQB6r0ZISIgoU75n1x7s/2o/avNr4e7pLtLwyNBqaDA2JHRxdkFgUCCqqqpQW9sySYcEh6CmtkZ8vwal8lGFzPKKFkPNz9dPuBLNlyW9vbxFA7niomIY/sq7JZc/yUX7aZVuXV1dxWfSCUl6JGjMgoODxfeaB4iSxU7HXFnZUomWZHGCE8rKy8T37MEe+Pr4ws3DDSXFJab9PD09RU8X2tZsMOrJ3c1dXOTlZeVoaGwzFpVVqK0zG4uQEHEsrcYiMECkGptfTDQWdPMqK23pgUSlGby8vFqVVW9vLMjd7B/gLyYfLejQfCyqa6qFfKaxqG9AZVXrsWhrRIuxcHdDSUnLWNCx0DEVFxcLr0SHY+HiIs4pGm9zI73DsaCJpdJsLPz8RHbRicbC08MTPr4+KCwqNMnX3lg4OzkjKDjI4jylbQ11rcciwD9AnA+txsLXF25uXRgLd3dx7JSy2tjY2OFY0HlH312WW4aynDLUFdah7ngdGsoaLFPNnZ1EarlrhCu8Ir3gGeWJ4NhgBIQGiHYChLhOvAG/QD8U5BeYzgs6npDQEHEtad9N40p9wkhfNB4adL3TeULbzZup0jlP79egc5w+l77HfHzoHMjLzTONBY0P7UsZQNp84ermKn7olZaUmq5POk8joyJRcbQClU4tegiPCBfXNe2rQeczHT99pgbpmuYMbSy0c4XOK/pxSdeZdt0EhwS3OxZ0npmfk+2ORVio+CzSd6dj4ecrzoG2Y0ElA2rdak1Bs3Q+0We2OxblFa3mqnbHIiRYnNeUJNPZWNDcRdvbG4uiwiLT3EnnKX2PxVhERaK6qrrV9dDeWAiviDNa6VAbi9zcXNN5TXM7XQ8FBQVoamxqNRY0x2rXJ92nIiIjxPfSnKpB+iL9md8z2hsLujd4enkiP8/oYOhwLDw9xHlF76V50Xws6Dtqqv+6j7gAbv5uqKivwJGMI6286jSGR460bIuLixNjfODAgVbHTdcTxfJq0DjExMTg4MGDsFqdn/YgBVOszdChQ3HXXXfBHtBkSgO/aNGiVkHXs2fPFsbZypUru+z5oQHv7jo/dFP67s7vhCeKfmmqCtWAio6OhqqwfPaHOphTc0/xOGT821hjmT1Cva6o71XEkAjEjI5BzNgY+Mf5Y8/+Pejbty9UhW4KLJ/csA4dsM5Pe9CvA8oCmzBhgt2MH7KWKbV9xYoVJuOHvD70fO7cuR2+j6xK1YNYbQn9ElcZls+20K/KqmNVJkOn9FApqvNbfk1rkKeP2kGEpociemQ0YsfGImxAGDz8La9t1QsKsnzywzq0Lt3m+SHI9dajRw+7ruV98MEHuOGGG/DRRx9h1KhReOaZZ/DOO+9g165diI2NtWuFZ/L8rH96vXDfquz5YZjToa68zuTNob/lh8s77GpOKeZRw6IQMyYG0WdEi7o6p9MWgmEYubGq56e95SNacnrllVcwYsQI2JOrr75arO/ef//9Yi0yPT0dy5cv77LhY23o2GitVGUqKyrF+rSqsHzdh4hPyq5o5dVpr/+Vs7uzSDEP7x+OqFFRiBsfh+A+wXD3cT+l7z1+/LhFYoRKsHzywzq0Lqdk/EycONFiGwVijRkzBv/5z39gb26++WbxcEQoKFJ144eCsFU2fli+U4M8nrUltUavzl+enYojFcIAagt5RqlCctTwKESPiRbLWD7hPt2Wak5eapWNH5ZPfliHDmj8aNkGrT7IVamSQQzDnCZN9U1iyUozdkozS1FfZlmy39XLFf5J/ogYGIGoM4xeHQpSdvNSu8gbwzD245QsFi3VtD0oTbOj1xiGURPy6lQXVLfKvqrMqRTlGFrhBBGXQ0tWUSOiRFByxLAIUVdH9QBPhmEkN37M61m09Qi15xVi0Ko2i+pEhEdAZVg+oKGmAeVZLV4dMnYo/bwtbr5uwosTPjgcsaNjETMuBgEJAXZvC5GSkgKVYfnkh3XoQMYPZVC1938tpXzdunXKK+x0oWJtVPRJZcgAtnffFmuiN/nIe1OVWyWWrTRDh55bFBB0cYJfjB9C+oaIoOTYcbEIHxAOz0BPOBpU/I0K6qkKyyc/rEMHMn7uvvvudv+vVZWkiseOEPDsyFD6HRU5VJnikmJEe6lb5FB1+QqOFsCr2qsl3TyrrN2u5h6BHiLVPHJopEg1pyKCVD3Zxc3xDcPs7GyliwCyfPLDOnQg40cr892vXz/s3LnTWsfEMIwNCwhSbI5m6JB3p6agpZWJhrObM/zi/RCWHoboUdGIHR+L0L6hotknwzCMLmJ+2PBhGDmpLW2dak7ZWBZdzalnUKgXglKDEDnc6NURqeaRPqJ/E8MwjOyccn46VUz+8MMPRVPPzz77TGz7/PPPMX36dNF4juk4U051qBGrysgiX1NDk6ijY14tmerstMXF0wUBiQGiFQRVSQ4ZGoKYgTFw81Y31TwhIQEqw/LJD+vQAY2fX375RRg5Z555Jr777juT8bN9+3YcPnwY99xzT3cfpzJQd13VUd074IjyiQKCRbWiQrKpgGB2BQxNlqnmPhE+COptLCBIQcmRwyLhHeptKiBIgZZunuoaPnqoS8byyQ/r0Lqc0gzwwAMP4I033sCVV17ZqjYHdU8no4iNn44pLi5WPuCZyrKr3NXdEeRrrG1sKSD4l1envsKygKCbjxsCkgJEqjl5daiAIHl5XD07vvQPHjyodDCwHmRk+eSHdeigMT8XXXSR+L+58RMfH48jR45039ExDCNSzamAYOnBUqOhQwUEj1Zappo7O8En2gchaSGigCAZOuGDwuEZ5MkFBBmGYU7X+KE+Xrm5uaKDu7nxs379erv/ImYY2aFigZqRo3l2GmsaLfZzD3BHYHIgIoZEiDTzmLEx8I/zt3sBQYZhGCWNn0suuQS333473n//fVOBw9WrV+O6667DZZdd1t3HqBTU/kN1AvwDoDLdKR+lmlcdqzLG6vxl7FTnV1vs5+zqDN9YX4Smh4rMK0o1p7RzD38PdDeRkZFQHdVlZPnkh3VoXZwMFCl5Cu0tyABaunSpMHy8vb1RXV2NadOm4YsvvoCnp+NVdD0ZysvLERAQIAoS+vv7d9vnUvfqdU+tM3WtVhY6o1Ru03Qa8tWV17WK06G4naY6ywKCniGexgKCwyIROyZWxOtQTywygqwNTQmq99lSXUaWT35Yh9a9f5+S58fHxwc//PADtmzZgo0bNwoDaPDgwRg2bNgpHq5+KCgoUD7g+VjuMaWXP7sqH9XPqcgxppprrSEoI6stzu7O8E/wF60gqC1E3Lg4BPcOtlsBQSpjoXIwsB5kZPnkh3VoXU4r33PQoEHiwTB6R6Sal7QuIEg1dsjb1xby+gX1MqaaR4+JNhYQDPcxpZozDMMwDlrnZ/HixcjMzBSu46SkJMycORMTJ07s/iNkGAeElqpEqvlfy1fk2akvs0w1d/VyhX+SPyIGRYi2EHET4kSX885SzRmGYRjrctIz8PXXX48333wTcXFxSE1NFdu++eYbvPbaa7jpppu4sekJ0EP1a1oWVc2rQ6nmmqFTfKAYu3J3iRR0i1TzSB8EpwUbCwiOjUXEsAh4BXtJFV8SHBwM1VFdRpZPfliHDmT8fPnll/j000/x7bffimKG5pABREUOzznnHFxwwQXdfZzKQAFYpxBjLhUUbCYzDTUNKM9s8erQX0o/b4ubn5sx1XzwX6nm42IQkBAgfap5VFQUVEd1GVk++WEdOpDx89577+Hxxx+3MHwIMnjmz5+Pd955h42fTigsLERIiBy9oU6VgvwChEfIEdRN3puq3CpTQDIZOvTcooCgixP8YvwQ0i8EHj090P+i/gjrHwavIPU8efv370dKSgpURnUZWT75YR06kPGzefNmvPrqqx2+TlWfX3zxxe44LmVparJMa1aNxibLgnyOArWAMPfolGWVoanWUicegR6mVHPh1RkTA99oX7i4uSAjIwPxfeOhKvX1lrFLqqG6jCyf/LAOHcj4Ia9FTExMh6/HxsaKvkcM4whQAcHKnEqToUOFBGuO11js5+zmDL94P1E0MGpklAhKDu0bardUc4ZhGMaBjB+yRDvrNOvm5oa6urruOC5lcXdX/4bq4d79VYe7gkg1N/PqUDYW1dppi1eoF4JSzVLNzzCmmne1W7tqAd16k08PMrJ88sM6dLBsr7vvvts6R6ITgoKClA94Dgm1fkxTU0OTqKNj7tWpK7E0vF08XUQX87ABYaau5kEpQXDzdjvl705MTITKqC6fHmRk+eSHdehAxg9VRKWWFifah+mYkpISBAYGKj1ExUXFCA7pvlRiMhZrCmtaeXUqsitgaGoblQz4RPiI6sjU1ZwafVLMjneod7cWEDx8+DASEhKgKqrLpwcZWT75YR06kPGzc+dO6x2JTlA9iI2orbNs4XAyNNY2GgsImvXAokDltrj5uCEgKQDhg8ONXp1xceK5tQsIVlZWQmVUl08PMrJ88sM6tC5cZpaxf6p5flWLoZNZhsqjlZap5lRAMNoHIX1DED0iGrHjYhE+KByeQZ5SFRBkGIZh7A8bPzbG2dn6XbntjYtzx0X+qFigZuRoBk9jjWVqvHuAu7GA4JC/CgiOjYF/nL9DFBDsLOhfBVSXTw8ysnzywzq0Lk4G1aNvT4Hy8nJRpbisrExUZO4uqMnl+qfXixgWam6ph1TzqmNVIhhZM3aq86st9nN2dYZvrK8p1Tx2fKz4v4e/fbLGGIZhGLXv32r//HFAKioq4OvrCxWpK6sTRk7B7gLUHqsVBQSb6y1TzT1DPEUBwahhUaJ4IMXr+Eb5CiNIBvLy8hAZGQlVUV0+PcjI8skP69C6sPFjY6qrq5Uwfqh+TkWOMdVcaw1RW2QZ6Ozi4QL/eH+Rah41KkoEJQf3CYa7j7z1joqKipS+caounx5kZPnkh3VoXdj4YU4ILdOJAoIUo/PXozy7HIZGyxVTWs7ziPNAjwk9RJxO9MhoeId1b6o5wzAMw5wObPwwFjTVNRlTzf+K0yHPTn2ZZaq5q7erKCBIWVfRo6JFW4jAHoHYe3Av13tiGIZhHBYOeLZxwPPaBWtFarajBDyTV6e6oLol++qQMdWcUtAtUs0jfRCcFizaQlCqecTQCHgFe1mkmjc3Nyud1cbyyQ/rUG5U158eZGy2knwc8Oyg1NbWwsvLy27f31DTgPLMFq8O/aX087a4+bm1pJqfEYOYcTEISAjoUqp5aWkpgoO7r8Kzo8HyyQ/rUG5U158eZCy1s3y87GWHbC9bGT+igGBulSkgmR5VeVWWBQRdnOAX44eQfiHGrubj4xDWPwyegZ6n9L25ublKX7Qsn/ywDuVGdf3pQcZcO8vHxo9CUAsIc48OpZo31TZZ7OcR5IGgnkFi2UoUEBwTI4wfWVLNGYZhGOZ0YONH4gKClTmVxgKCfxk7NcdrLPZzdnOGX7yfqYBg/MR4hKSFwN1X3lRzhmEYhtGV8ZOfn493330Xe/bswbx589C7d2+LfbKyssQ+tG96ejquueYaeHqe2hJOd3Oqbj6Ram7m1aFsLKq10xavMC8EpQSJoOToMdGigKBPuA+cXWzn1UlOTobKsHzywzqUG9X1pwcZk+0sn1TGzyuvvIKnn34aU6dOxfvvv485c+ZYGD/UeX706NE4++yzMXLkSLz++uv48MMPsXr1ari5ucHedKWbSFNDEyqOVLTy6tSV1Fns5+LpIlLNqYCg6Go+Pk4YPm7ebnaP4lcZlk9+WIdyo7r+9CBjs53lk8r4Oeecc3DDDTegoKAAb775Zrv73HfffRg+fDgWLVoknl955ZVISEjABx98IDxA9qakpATh4eGtjKGawppWXp2K7AoYmtpGJQM+ET4I7h2MqBFRooAgeXe8QrwcroAged769u0LVWH55Id1KDeq608PMmbZWT6pjJ/U1NROX6+vr8fy5cvxn//8x7QtIiICkyZNwnfffecQxg/1uiKPTv7GfGMWFqWaV7STau7jhoCkAIQPDjd5dcjL4+oplcoYhmEYxuFQ6k565MgRNDQ0IDExsdV2ek7LXh1RV1cnHuZFkrobWsr6aNhHOL79uGWqubMTfGN8RQHB6BHRooAgVU32DPK0KCDIMAzDMIzExs9bb72F33//vdN9nnnmmVbLRJ1RU2PMdvLx8Wm13c/Pz/RaeyxYsADz58+32L57925TE1LyOlFT0pycnFZGFVWoPHTokGlbVFQUAgMDxXs1QkJCRBPF2upaYfi4+rrCN8EX8WfEwz3VHd7p3vCK8IKnjydSUlJE/YNDuYeAXOP709LSUFxcLLr8avTo0QONjY04fPiwaVtcXJwI7N6/f79pG41dWFgYdu3aZYo3ouOLiYnBgQMHTEYf1R6iALTs7GyT8efi4iJiqihwvLCw0PSZvXr1QmVlJY4ePdruWND3ZGRkIDo6WlTIpuD0tmOxd+9ecfyafuLj45GZmSnGmHB3dxdjcezYMbFUqEFuUjoWOiaNnj17Cq8fGb/mY+Hh4SFkNPcChoaGimPTaG8svL29kZSUJD6P6jK1HQtNPm0saB86Tg16L0HyaNBYkJwktwYdCx0TjU9TU1OHY0FykIw03lQY7ERjQXKQHjXo82g8TzQWQUFB4jhdXV1N29sbC3qd5KbzkZovatD40LljPhZ0TtHaPrm4NWi86bo60VjQuUN6pHNKu37bGwv6gUDXyPHjx8WSuAadP1RU1HwsaAmcjt9ch3Q+UiICXSMa9JyuZbqW6NzS5hU6z+mao/O/s7Ho06ePOD66ljsbi9jYWDHG+/btM22j65WuW5pDtLgIqjhP+5qPBV3rNA/QnETV6Am6Bum7aezMddve/KWNxcGDBzudv7SxoGOkH5cE6Y/ebz4WFFNJ30My03zV2Vi0N3+1Nxba/NXeWNBxk37N56/2xoLOCTo3OhuLk53LzecvbSxIr1VVVa3mr7ZjcTJzOX2PuQ7tMZdrWGMuJx1aYy43P58dtr0FGT7mArXHzJkzxYCaQyctDciKFSswYcIE03Y6eUhxS5YswZQpU0zbr7vuOmzevBmbNm3qsueHPr+721vkb8lHs1MzgpOD4eHvAVWhCdIRgsutBcsnP6xDuVFdf3qQscFK8knR3mLMmDHi0V2QwUJCkzVobvxQBli/fv06fB9ZlfSwNhGDIsSxRflHQWXol5vKgXosn/ywDuVGdf3pQcZ9dpZPqZK+5Kq79NJL8c4775hcsevWrROPK664wt6HxzAMwzCMAyBVwDMtk1GckLaW+NRTT+G9997DjBkzxEOL3znzzDNFcUN6rFy5ErfddptIk+8q2kqgNQKfySizxuc6EqrLyPLJD+tQblTXnx5krLSSfNpnniiix64xPycLxQe1FyA9cOBA8dCg4KtVq1aZKjx3tuTVHlpMEcMwDMMw8kEB3xRUrYTxYysoq4Ai0ynQujtTzbVAalJKdwZSOxKqy8jyyQ/rUG5U158eZCy3onxk0lBmKmWoUSiMEstetoIGrDOL8XQhZat4QutJRpZPfliHcqO6/vQgo7+V5KPEJ10FPDMMwzAMw5wINn4YhmEYhtEVbPzYEKol9Oijj9qkppC9UF1Glk9+WIdyo7r+9CCjhwPIxwHPDMMwDMPoCvb8MAzDMAyjK9j4YRiGYRhGV7DxwzAMwzCMrmDjh2EYhmEYXcHGD8MwDMMwuoKNH4ZhGIZhdAUbPwzDMAzD6Ao2fhiGYRiG0RVs/DAMwzAMoyvY+GEYhmEYRlew8cMwDMMwjK5g44dhGIZhGF3Bxg/DMAzDMLqCjR+GYRiGYXSFq70PwBFpbm7GsWPH4OfnBycnJ3sfDsMwDMMwXcBgMKCiogLR0dFwdnbWl/Hzyiuv4MUXX0R+fj7S09Px/PPPY9SoUV1+Pxk+cXFxVj1GhmEYhmGsQ3Z2NmJjY/Vj/Lz77ru477778PHHHwuD55lnnsHZZ5+NXbt2ddmgIY+PNnj+/v7denx1dXXw8PCAyqguI8snP6xDuVFdf3qQsc5K8pWXl4t7vXYf7wgnA/mIFCItLQ2TJk3Cq6++Kp6TeGT9/e1vf8OTTz7Z5cELCAhAWVlZtxs/GRkZ6Nu3L1RGdRlZPvlhHcqN6vrTg4wZVpKvq/dvpQKeS0pKsHv3bkycONG0jWJ26Pmff/5p12NjGIZhGMYxUGrZKzc3V/wNDw9vtT0sLAwbN27s1P1GD3PL0VqQn62wsBoqo7qMLJ/8sA7lRnX96UFGg53XnJQyfjqCIr47W91bsGAB5s+fb7GdvEi+vr7i/6mpqaiurkZOTo7p9cTERPHZhw4dMm2LiopCYGCgeK9GSEgIIiMjsXv3XpFJdvToQeTmNmD16iqMH++LiAijGiorm7FkSTkGD/ZCz54ta6GLFpWK54MGeZm2LV1aDm9vZ4wbZzw+4o8/qlBS0oTzzmtx9e3YUYPdu+swa1YgtMD3zMx6bNhQjbPP9kNgoIvYVlTUiF9+qcSoUT6Ii3MT2+rrDfj66zL06+eJtDRP02d+800ZIiNdMWKEj2nbr79WoLkZOPNMypCDkJG+Izu7HhddFGjab+/eWmzbVovp0/3h5WU8oGPHGvD771WYMMEX4eHGsaioaMaPP5ZjyBAv9OjRMhaff16K1FQPDBzYMha0n6+vM8aObRkL+rzy8iZMndoyFtu21WDv3jpcfHGgOEbi0KF6bNxYjXPP9YO/v3EsCgsb8euvlTjjDB/ExhrHoq7OIOROTzeOBclH0PhER7th+HBv0/f88kuF+Dt5csua8/r11ULOGTMCzM6vWuzYUYsLLgiAh4fxgHJyGvDnn1WYNMkXoaHGsSA5li6twNCh3khOdhfb6HSm86JXLw8MGNAyFnT+kBxjxrToZvXqSnFuTZnSMhZbt9Zg3746XHJJi24OHqzDpk014hg1+QoKGrFyZaX4PJKTqKlpxnfflWPAAE/06tVyXixeXIq4OHcMG9YyFj//XCHOu0mTWsZi3boq5OU1Crk1du2qxc6dteK73d2NY5Gd3YA1a6owebIvQkKMY1Fa2oRlyyrEdyQlGceCzrsvvihFnz4eSE9vGYvvvy9HUJALRo9uGYtVqypRXW0cC03GLVtqcOCA8bzQoOebN9eI84fOLSI/vxG//VaJsWN9EBVlHAv6LPoeOh/pvNT48stSJCS4C51pLF9eAVdX8kS3nKdr11aJMT7//JaxyMioFY8LLwyAm5txLI4cqcfatdXi+goONp6ndK3TZ44Y4S2+i2hsNGDx4jKMG+eDpiajfMR335WJMaRzWoNkqa1txjnntJwXmzdXi2uC5guN/fvrxBhNm+YPHx/jWOTlNWDVqirxPZGRxrGoqmrGDz+Ui3kqJaVlLEg3dN4OHtwyFj/9VA5PT2cx/2nQeU/z0PTpLWNB5wSdGxddFCDGjjh8uF7InpCwT+iXKC5uEufayJHeiI83jkVDgwFffVWGvn09xUPj22/LxDwzcmTLWKxYUSnG7qyzWs5Tmhfou2bObBkLumbo2qE5luZfwlpzOclmrkN7zOUa1pjL9+5tQGBgHsrKikzbevbsifr6ehw5csS0jeJ3KDbowIEDpm0REREIDQ0VS2cadN+NiYnBwYMtY6abmJ/i4mJhaHz55Ze46KKLTNuvuuoqHD58GKtWreqy54cGvLtjfsiKf+GFTfDycoW3ty7sToZhGIZpRXV1I2pqGnHHHUMQGtpiFNsy5kepO3BwcLDw0Pz2228m44dsu5UrV2L27Nkdvo+sSltF1dMv7V9+qYWvr/HXiYqMHOmMtWuboSosn/ywDuVGdf3pQcbp01s8XfZAqYBn4q677sLbb7+Nn376SVh+Dz30kPAI3XjjjfY+NIZhGIZhHAClPD/E9ddfj9LSUsydOxcFBQXo168flixZIuJzGIZhGIZhlDN+iHvvvVc8HBEKKlWd/HxlwsjaheWTH9ah3KiuPz3IePBgHWJi7Pf9yi17OTqUTaM6mZlqX7Qsn/ywDuVGdf3pQcZNdr4XsvFjY8zTjVVlwAC1TyuWT35Yh3Kjuv70IOMUO98L1R5dB8TPT/0h92opYaEkLJ/8sA7lRnX96UFGPzvfC9W/EzMMwzAMw5jBxo+NoWquqmPF7iAOAcsnP6xDuVFdf3qQscDO90I2fmwMtQpQnV271C3MRbB88sM6lBvV9acHGVfa+V7Ixo+NMe+5pCq9eql9WrF88sM6lBvV9acHGcfY+V6o9ug6IFpzSJUJCoLSsHzywzqUG9X1pwcZo+18L2Tjh2EYhmEYXcHGj42pqVF7HZeor4fSsHzywzqUG9X1pwcZa+x8L2Tjx8Z8953iIfwANm9W28Bj+eSHdSg3qutPDzJ+Z+d7IRs/NmbAAE+oTny8E1SG5ZMf1qHcqK4/Pcg4wM73QjZ+bEyvXuobP9HRal+0LJ/8sA7lRnX96UHGXna+F7LxwzAMwzCMrmDjh2EYhmEYXcHGj41ZvLgUqrNhg9qBeiyf/LAO5UZ1/elBxsV2vhey8WNj4uLcoTohIWqvVbN88sM6lBvV9acHGe19L2Tjx8YMG+YN1UlOVvuiZfnkh3UoN6rrTw8yDrPzvZCNH4ZhGIZhdAUbPwzDMAzD6Ao2fmzMzz9XQHV27FA7UI/lkx/Wodyorj89yPizne+FbPzYesB1MOKqy8jyyQ/rUG5U158eZHS2s3yKD6/jMWmSH1Snb1+1TyuWT35Yh3Kjuv70IOMkO98L1R5dhmEYhmGYNrDxwzAMwzCMrmDjx8asW1cF1TlwwACVYfnkh3UoN6rrTw8yrrPzvdD1ZHYuLCzs0n6hoaGnejzKk5fXCF9fF6hMaanaFy3LJz+sQ7lRXX96kDEvr1Eez09YWFiXHkzHXHBBgPLDM3So2g5Flk9+WIdyo7r+9CDjBXa+F56U54dISEjA3LlzMWLECOscEcMwDMMwjKMYP9u2bcNbb72Fl19+GVFRUbjmmmtw1VVX8TIXwzAMwzDScFJ+tf79+wvD59ixY3jggQfw/fffIzY2FhdffDGWLl1qvaNUiF27aqE6R4+qvVbN8skP61BuVNefHmTcZed74SktKnp4eOCKK67AL7/8gu3bt+Pw4cOYMmVK9x+dguzcqb7xk52t9kXL8skP61BuVNefHmTcaed74SlHVO3fvx/3338/JkyYILLA5s+f371HpigzZnDAs+yoHoiounx6kJHlkx/VdTjDzvfCk4r5qa6uxqJFi/D2229jw4YNuPDCC/Hhhx9i0qRJcHJyst5RKoS7u/rj5HrSYfRywfLJD+tQblTXnx5kdLfzvfCkhjcyMhLBwcGYM2eOMICCgoLE9qKiolb7cZ0fhmEYhmEclZMyfioqKsSDlrg6W+YyGNReqzwdsrMboDpFRWrrn+WTH9ah3KiuPz3ImJ3dgJgYSYyf5cuXW+9IdMKaNVUICfGEyuzfr/ZFy/LJD+tQblTXnx5kXLOmCiNHSmL8nHnmmdY7Ep0webIvtm61b1lva9O3rzMyMpqhKiyf/LAO5UZ1/elBxsmTfe36/cr19vrss8+wevXqVtuio6NFXSJHICSEhlxt48fPD0rD8skP61BuVNefHmQMEfdC+3FS397Vvl32jPlZsWIF1q1bJ6pPa4SEhNjteBiGYRiGcSyU7O3Vo0cP3HrrrXBESkuboDrV1VAalk9+WIdyo7r+9CBjaWmTPAHPsvT2OnDgAO69914EBARg7NixGDduHByFZcsqlA943r5d3XVqguWTH9ah3KiuPz3IuGxZBfr2td/3K9fbi4otRkREIDAwUBznueeei5tuuqnT99TV1aG8vLzVw1oMG+YN1enRQ+1Cjiyf/LAO5UZ1/elBxmF2vhc6GU4zQGffvn248sorRcVna8T6fPTRR1i7dm2n+zz22GMm71N2djbi4uJMr/3222+iBceyZctw1llndfj+9uoW0ff6+hoj0lNTU0WF65ycHNPriYmJcHZ2xqFDh0zbyCNGhtfu3btbxRxRgcjdu/egsbEBzc3k8gP27m1Gnz7OCPiryndtLbB1azMSE50QGdly4q9d2yye03aNbdua4e4O8X6NffuaUVUFDBrUsu3IEQOOHTNg+HBnOP+1+fhxAw4eNKB/f2d4/3X+VVRAZBakpDghJMT4PY2NwMaNzYiLc0JMTMt307bAQCf07Nmyjd5LcqWnO4OKfdOpcOiQQdSqGDas5XjoWOiYBg92FsdPlJQYxyItzRn+/sZtNTVGGZOSyJhtPRZRUU5ISGjZRmPm6Qn07t3yPfR55DY2H4vDhw3IzTVgxAjjMRIFBQZxnO2NRWqqE4KDjTs2NACbNhnHIjbWScinjUVQkFOriWrnTuMvtn79Wr6bxrukxNCqZD01LqT+PUOGOMPNzbituNiAffsMItNDC3gkOehXYHKyE8LDjd9D379uneVYbNnSLOTo1avle/bsaRbn1sCBlmMxcmTLtvx8AzIzDRg1ytkkH/0O2LWrWXzeXzVNUV8PbN7cjPh4J0RHt3z3hg3N4tyh49TYsaNZnHckj8aBAwaUlrY/FrRNq2xL5w6l+7Y3FjTeYWHG76Hzbv36ZnEsdEzmY+HjQ9duy/fs3t0sjp/GQpMxK8uAvLzWY0HPaTvtR+cWUVZmfH97Y0E6IF1o0PGEhlqOhYsLxHmuQfKVlxvPAY2cHIN40HVD+xOFhQYxbnRO/TUliWudPpOuQ/ouoqnJqAdzWQg6Rnqf+ViQXukap3Nfg/RP1wRdI23Hgq4lDw/jNpq/6Lyiay4w0Litrs445m3nLzpP6byla1mDdEh6Nh8Lmr8qKyHmBg06J+jcaDsWJC/JT/ol6H103bU3FnS90kODrmN/fycx15mPBe1P85cGzQv0XTR3atA1Q9dOe/NXd8/l5rqy11yu0d1zuXbtBQaGorKy2PSZPXv2RH19PY4cOWLaRvdz6idKKzoa5OCge35GRoZpG913Y2JisGXLFgwePBhlZWXw1w6iO40f6u31zjvv4P3334enp6eo+vzII4+gu6HmqeaGRHvQ0hstcXVEfHy8iFPqqDAjeX7ooUGeHxrwEw3eyVJYWI2jRw/il19q4ev719miIDTx0kWuKiyf/LAO5UZ1/akuY2VlPSZP9kRMTA+EhnavB4ju32QPnOj+7fC9vSZPniwepwNZko1k+nYAWZX0sAVkUauO6jKyfPLDOpQb1fWnBxmb7SyfUr29yMChZS5zY+mDDz5Afn4+zjnnHDgCX3xRqnzAM7n8VYblkx/Wodyorj89yPjFF6W44w77ff9JLXt11btjrzo/TU1NmD59uijG2LdvX7FuuGbNGrEcN2/evG53m53KstfSpTtRUOCk9LIXxV7QerCqsHzywzqUG9X1p7qMlZX1CA834Nxz+8mx7OXovb1cXFywZMkSbN++XQQ9kWeKAqYpCNlRSE/3EjE/KkNBp6petATLJz+sQ7lRXX96kDE93cuu369kby9KyacHwzAMwzBMW065uQZle2VmZoqlsKSkJJGixjAMwzAM4+icVJFDgvpmpaeni7o3FER89tlnIyUlBQMGDBAZYEznfP+99QooOgpU60NlWD75YR3Kjer604OM39v5XnhSxs/hw4fF0hcVGPriiy+wY8cO8aD0dyrkR69RkUGmY4KC/qrUpTBa4TFVYfnkh3UoN6rrTw8yBtn5XnhSxs8LL7wg0sgp8HnmzJno16+feMyaNUsUI6QeWi+++KL1jlYBRo9W/IwW1bBP2qEoFSyf/LAO5UZ1/elBxtF2vhee1OiSgUMNQ9tLeadt9913n9iHYRiGYRjGUTkp4ycrK0vE9nTEwIEDW/W5YhiGYRiGkdr4qaqqgk8nC5HUBLSSOswxHbJqlfrjQ80fVYblkx/Wodyorj89yLjKzvfCk0p1p8rN5l3NO9qH6Zjq6mZTB29VoU7XKsPyyQ/rUG5U158eZKyutq9xd9IRVdTtvLMH0znnntt97TIclQED1A7UY/nkh3UoN6rrTw8ynmvne6FS7S0YhmEYhmF02d6CYRiGYRimI9T2qzkgW7bUQHWystSO+2L55Id1KDeq608PMm6x872QjR8bc+BAHVQnL0/ti5blkx/Wodyorj89yHjAzvdCNn5szMUXB0J1Ro5U+7Ri+eSHdSg3qutPDzJebOd7odqjyzAMwzAM0wY2fhiGYRiG0RVs/OhsndMWqL5WzfLJD+tQblTXnx5kPMAxP/pi82bO9pId1bMwVJdPDzKyfPKjug432/leyJ4fGzN1qvoVngcOVPu0Yvnkh3UoN6rrTw8yTrXzvVDt0XVAfH3VH3JPTygNyyc/rEO5UV1/epDR1873QvXvxAzDMAzDMGaw8WNj8vMboTplZVAalk9+WIdyo7r+9CBjvp3vhWz82JjffquE6uze3QyVYfnkh3UoN6rrTw8y/mbneyEbPzZm7FgfqE6vXmqfViyf/LAO5UZ1/elBRnvfC9UeXQckKsoNqhMUBKVh+eSHdSg3qutPDzJG2fleyMYPwzAMwzC6go0fG1NdrfY6LlFfD6Vh+eSHdSg3qutPDzJW2/leyMaPjfn++3KozubNaht4LJ/8sA7lRnX96UHG7+18L2Tjx8YMHOgF1UlIcILKsHzywzqUG9X1pwcZB9r5XsjGj41JTfWA6kRFqX3RsnzywzqUG9X1pwcZU+18L2Tjh2EYhmEYXcHGD8MwDMMwuoKNHxvz5ZelUJ3169UO1GP55Id1KDeq608PMn5p53shGz82JiHBHaoTGqr2WjXLJz+sQ7lRXX96kDHBzvdCNn5szNCh3lCd5GS1L1qWT35Yh3Kjuv70IONQO98L2fhhGIZhGEZXsPHDMAzDMIyukNL4KSsrw86dO1FVVdXhPqWlpThw4ADqHaxG+PLlFVCdHTvUDtRj+eSHdSg3qutPDzIut/O9UCrjZ9euXbj22mvRo0cPpKenY8OGDRb7NDY24pprrkFERATGjRuH8PBwfPDBB3Y53vZwdVV7HZdwcYHSsHzywzqUG9X1pwcZXe18L5TK+Pntt98wYsQI/PHHHx3u8+STT+L7778XhtKxY8fw8ssvY+7cudi6dSscgYkTfaE6aWlSnVYnDcsnP6xDuVFdf3qQcaKd74VSje5NN92E6667Dj4+Ph3u88Ybb4h9yDtEXH311UhNTcVbb71lwyNlGIZhGMZRcYVC5OXl4ejRo8I7ZM6oUaOwadMm2BODwYCqqgbU1DSirq4Jbm5NUJXq6mbU1RmgKiyf/LAO5UZ1/akuY11dk7gX0n1Rl8YPGSolJSWd7kNeG3f3rhVDKioqEn9DQkJabafnhYWFHb6vrq5OPDTKy8vR3VRXNyAx8c1u/1yGYRiGkZGsrGR9Gj///e9/8fXXX3e6z48//oi4uLgufZ6rq1GcthleZNi4ubl1+L4FCxZg/vz5Ftt3794NX19fkxFWXV2NnJwc0+uJiYlwdnbGoUOHTNuioqIQGBgo3mtufPn5BXdJBoZhGIbRA3V1FcjIaLmn9uzZU9y/jxw5YtpG938PDw+Rva1BCU2hoaHIyMgwbaP7bkxMDA4ePNil73Yy2NPvdIqQAUIDsmLFCkyYMMG0vbKyEv7+/li4cCEuv/xy0/aLL75YeHN++umnLnt+6PMppZ4+rzugYSbvT0bGbkREJEJl8vOzlJaR5ZMf1qHcqK4/PciYn5+FYcP6w8mpe7O+6P4dEBBwwvu3UjE/5KUZNmwYlixZYjJ+yKj5+eefcd9993X4PrIq6WFNSME+Pu7w8XFFQkIAVKayUm0ZWT75YR3Kjer604OMlZWu3W74nAxSGT9UuJC8Pvn5+eJ5ZmamcH1RLR96ELR8dd5556Ffv34i0PmFF14Q2WE33nhjl79Hc4ZZI/aHvFPW+FxHQnUZWT75YR3Kjer604OMlVaST/vMEy1qSbXs9c033+DBBx+02H7zzTeLh8bSpUtFfR8ykqgY4mOPPSbic052WY1hGIZhGPnIzs5GbGysGsaPrWhubhYFEv38/LrVLafFEpFSuiuWyNFQXUaWT35Yh3Kjuv70IGO5FeUjk6aiogLR0dEiIUmJZS9bQQPWmcV4upCyVTyh9SQjyyc/rEO5UV1/epDR30ryUcCzUhWeGYZhGIZhThc2fhiGYRiG0RVs/NgQSqd/9NFHrZ5Wb09Ul5Hlkx/Wodyorj89yOjhAPJxwDPDMAzDMLqCPT8MwzAMw+gKNn4YhmEYhtEVbPwwDMMwDKMruM6PDaFO77W1taL1Rmdd5mWAikhRl13qYh8ZGWnx+po1a9DU1NRqG1XZtmb9pO6CugLn5ua22kYtUgYNGmSxLxXpokriqamp0tTjaE8+rb7VGWecYSpCtn37dot9aAxoLBy1XP62bduQkJDQ4XlWVFSEQ4cOiQJr7Z23Xd3HXmzZskUUcRs8eHC7r5PeSL/U3Vpr+WPO77//brGtR48e4jp2BKi6flZWFgYOHCh6NZqzb98+FBQUtNpG11z//v0tPoc+o7CwEL1797b4HHtC8//mzZvFeCclJZ1QPoLuFSNGjDC1eNq5c6fFPkOHDoWnpyfsTVVVFfbv3y/OPSoy2FERYerGTudx37594eLickr7nDZU4ZmxLllZWYb+/fsbQkNDDYmJiYaIiAjDihUrpJXl0ksvNQQGBhoGDhxo8Pf3N0yePNmQm5vbaj8fHx9Dnz59DKNHjzY9PvroI4MM3HDDDYaQkJBWx37VVVe12qempsZw0UUXGby8vAy9e/cWf19++WWDDDz77LOtZKMH6TEuLs60z+rVq6nyu+GMM85otd/+/fsNjkZ2drbh5ptvNkRGRhrc3NwMCxYsaHe/Rx55xODh4WFIS0sTf6+55hpDU1PTSe9jD+jcouuJrrtevXpZvE56ufDCC8XrgwYNMvj6+hqmTp1qKCoqarUf6bRfv36tdPrll18a7M2ff/5pOP/888UcSce4YcMGi31mz55tCA8Pb3Xs119/fat9KisrDVOmTBHzD42Tt7e34a233jLYm8LCQsPdd99tiI6OFnPFP//5T4t9Hn/8cYvrkvRIetf48ccfxfi03S8nJ8dgT3JycoR+AgICxH2B/o4fP15cm+Zs377d0KNHD0NUVJQhJibGkJCQYNi8efNJ79MdsPFjA8aMGSMMhPr6evH8rrvuEjfXsrIyg2yQ0fbZZ5+ZbgglJSWGIUOGGKZPn95qP5p8vvrqK4OMkPEzc+bMTveZN2+eITY21nDs2DHxnGSlSWnt2rUG2aiqqjL4+fkZHn74YQvjh4w8R2flypWGV199VVxPNFm2Z/x8/fXXwjD6448/xPM9e/aICfqll146qX3sxR133GHIyMgwPPjgg+0aP0uXLjUsXrzY0NzcbLrZkgF3+eWXt9qPdLp8+XKDo/G///1PXEM7d+7s1Pj529/+1unn3HrrrYbk5GTD8ePHxfMPP/zQ4OzsbNixY4fBnmzZssXwzDPPiOOi+bI946ctxcXFBk9PT8PTTz/dyvhxcXExOBq///67YeHChYbGxkbxvLy83DBy5EjDWWedZdqH7hn0Q5F+PGvn6ZVXXin01dDQ0OV9ugs2fqzMvn37xMX8888/m7bRxOTq6iouTBV47rnnDEFBQRbGz+uvvy4mMW0iksn4mTZtmmHTpk2GAwcOtPvLn7x3jz32WKtt9Iua3isb7777rrhBZGZmWhg/27ZtM2zdulUYSDLQkfFDXoVzzz231bZrr73WMGDAgJPax950ZPy0B52f5t48gnT6wQcfGDZu3GjhFXIEdu/e3anxc8kll4hjP3TokMV1STdH8mDSfGROUlKS+MHpKHTV+HnllVeEMZ6Xl2dh/NA40bVZXV1tcFReffVV4XnTWLVqldAtGbgae/fubWWQd2Wf7oIDnm2wRk8MGTLEtC0kJATJycmm12Rnw4YN6Nmzp8X2efPm4ZprrhGxE1OmTBHNYmXhp59+wpw5czBq1CgRQ7JkyRLTayQHxfmY65QYPny4lDp9++23cdZZZ4mYrLacf/75uOSSSxAUFIR77rnHIo5LFkgv7emL4icaGhq6vI8K1+Udd9yBv//97yImY8aMGTh+/Dhk4auvvhLHPmzYMCHbr7/+anqN4rQo5qmtDmlfWa9Luv4iIiJabadrcNq0aZg5c6a4Lh9++GERG+OI51+PHj1Mz0kHVNSQYng0tFhJTT9d2ae7YOPHyhQXF4tgrbaN1sgAotdkhyajzz//XFyA5rz44osicJQCUGlSogDbq666CjJwzjnn4OjRoyLgl4778ssvx8UXXywCSQlNb6RD2XVKQZYUBHvddde12h4aGorffvtNBI7u3btX3GRee+01PP/885AR0kt7+qIbCd0wu7qPLHz00Uf48ccf8eCDD7ba/sYbbwhjh65L0j3p9tprr4UMkKGWl5cnjp2uy6lTp+LCCy8UQdKqXZcUFL1161aL65ICpSmZhOYiCiz+4Ycf8Mwzz+D111+HI7FkyRJ8+OGHre4L7V1fbfXTlX26CzZ+rAxF6tPk2faXY01NDdzd3SEzK1aswOzZs/Hkk09i+vTprV6jCZWyh7QL9rHHHhM3UBl+ZdKEqmXKkOG6YMECocdvv/1WbNMy9ShzQ3ad0q9LkpV+YZpDWTLjxo0zPR89ejSuvvpqfPrpp5AR0ll7+iI0nXVlHxkgo4c8rvQDZPLkya1eo5upk5OT+H98fLwwjr777juRpePozJo1C8HBwSZd/fvf/xb6Inm1bSpdl+RxJo+sOQMGDMDIkSNNz0m/9MPMka7LP/74Q3iLyfChY9No7/pqq5+u7NNdsPFjZegEJtou+dBzmnxkhbwCZPA88MADYnnrRGiuW/KoyAYZQPTLQzt2WsYjw66tLPRcJp02Njbigw8+EMt7XSm9QDqUUX/addievgIDA+Hn59flfRydpUuX4qKLLsJTTz2F2267rUs6pSWT9kofODq0PEK60XSmzbWyX5d08//444+FAav9gJTlulyzZo0Icbj99tvFD15zSD8lJSWorq42baurqxMrBJp+urJPd8HGj5WhmBGqi6J5DbQThOo5tLXqZWH16tVizfm+++7DQw89ZPF6e78ily1bJupQtBeD4EjQjUD7ta9B7uXDhw+L+kyEt7e3qIdjrlOS+eeff5ZKp99//71YRmhv2aOtDmlcSD5tDGSD9EKuePOYpW+++aaVvrqyjyND1xh5Lf/v//5PxPV09bokw87RjQMy1OkmaA4tf9E8qp2TtFRL9YHMr0u6ka5atUoaHRJffPGFqKM2d+7cE+qQzlXyqDvCdbl27Vqce+65wuh+4oknLF6fNGmSMOZo3tGg6410q3kou7JPd8FFDq0MGT6PPPKI8JCQ244C1MjVTJMUBVPKxqZNm8RaO52kEydObFU0jZZGyKVOJy55FMj1Sb9KVq5ciRdeeAH/+te/HKrgWHvQ8iQFTJJBQEF3R44cEct6VFSOYn806OKmCfX+++8XBu4rr7wilo+uv/56yORanzBhAlJSUixeu/POO8Uva3qdJqP33ntPxCCQAeRokLFK5yVRX18vDFU6L+la0wInSR46Jy+77DKxfEexEiTP//73P9PndGUfe0HxZxR3REU1SV7tuqPid+S1o6UGiomh5UuaV7TX6Xqk65KgpRG6NskzRIbC8uXLxXlLy2P2XhYizxPFsdD1phk25AGhQoBUsJFu+mPGjBHXJS3JZmZmimtw7NixQm4NbQmejDkqyElLYxR0S/q0J2Sk0I9erRgnef5JRzQfksHW9rok70l7hTpvvPFGMc+Q3FQI8M033xQxle+++y7syY4dO4ThQ3MhHbv5fYG2kfecAuz/8Y9/4JZbbhGeHdpGSRQ33XSTKdmiK/t0F9zV3UYsXLgQn332mfj1QoYDuQXp5iIbixYtwksvvdTua/QLRJtEyeChgDcKRqSTliYfbRJ2dGgippsCZRfQDZQmGpp02y4N0Q2HgoAp8ys9PV0s/zlaReCOoJsJee/oht823oegX1rvv/++WEahm1BaWpr4ReeIFbrphnnFFVdYbKfYiOeee870nG6YFBxKQb50cyTvCMVQmNOVfezBDTfcICretoW8HBQHQ0YbBTO3xdXVVVyL5lmMn3zyifD4kWGhZU7Zm8WLF7cbTH/rrbcKY5Qgw4+uSzIEaRma5lFasm1b/ZdiESkAmJZKyAAiDzUZe/aEDB4yDtpCPzzMDRcK6iVjjuJl2vNWkXFPxhH9CKFrlIx7MhbsPe988803ePbZZ9t9jeYQ7UcvGWx0ntJ5S95kmoPIsDHXYVf26Q7Y+GEYhmEYRldwzA/DMAzDMLqCjR+GYRiGYXQFGz8MwzAMw+gKNn4YhmEYhtEVbPwwDMMwDKMr2PhhGIZhGEZXsPHDMAzDMIyuYOOHYRipoYJvu3btsvdhMAwjEdzegmEYh22e21nDTaqQTm1iqL/ceeedJ6pQ2xrqjUWNbvv06WPz72YY5tRh44dhGIeEeiFRby2CWmxQCX1qNUL9fwh/f39h/FAbAK2Hl62hnn2zZs1i44dhJIPbWzAM4/BQL6qoqCh89913wsvTdtmLDCLN80O9hJKTk0XPK+rPRj2ByGii3mzkSdqwYQPCwsJE7y9q/Nm2AeX69etFt/DU1NROjRryTFFvLGouqvVHmzlzpkUPOIZhHA/2/DAMIzVtl73uvvtu4RU6evQo+vfvL4wd6gw+d+5c0eW7X79+WLt2LSZPniw6nWtQd2zqCE5QJ/CNGzeKZrzUCJQahLbnmSopKRENR6kZI0FGEBs/DOP4sPHDMIxyFBYWYseOHcIIOnz4sDBm/ve//4lt1GF6z549wqtDy1ZkIBGXXHKJMF4WLFhg6sRNHc9fffVV3H777RbfMW/ePHzxxRdi2Yv+zzCMPHC2F8MwynH55ZcLw4dISEgQS2ZXXHGFMHyI3r17IzAwEPv27RPPt2/fjk2bNol9yaBZtGgRlixZgp49e2LFihV2lYVhmO6HPT8MwyhHUFCQRWZYe9sokJrIysoSf8nQMY8D8vHxQUpKik2OmWEY28HGD8MwukfzEtGSFwVLMwyjNrzsxTCM7hk+fLjwDL3++uutxsJgMHRaa4iW0TTvEcMw8sCeH4ZhdI+3tzfefPNNERdEWWITJ05Efn6+qC100003iUyx9hg6dKjIGEtMTISnpyenujOMJLDxwzCMw+Pl5YVLL71UpKy3pW2RwylTpqBXr16t9qFUeApeNmfGjBnCaNGgGj0U+PzRRx9h9erViI+PxxtvvIGBAwd2eFyPPfYYIiIiRM2fmpoaTnVnGEngIocMwzAMw+gKjvlhGIZhGEZXsPHDMAzDMIyuYOOHYRiGYRhdwcYPwzAMwzC6go0fhmEYhmF0BRs/DMMwDMPoCjZ+GIZhGIbRFWz8MAzDMAyjK9j4YRiGYRhGV7DxwzAMwzCMrmDjh2EYhmEYXcHGD8MwDMMw0BP/D8jjjOPFjgT0AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "from qoolqit import MockDevice, QuantumProgram\n",
     "\n",
@@ -416,10 +478,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "id": "23",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Most frequent bitstring: 0110\n"
+     ]
+    }
+   ],
    "source": [
     "from qoolqit.execution import LocalEmulator\n",
     "\n",
@@ -441,16 +511,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "id": "25",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "from qoolqit.utils import plot_histogram\n",
+    "from qoolqit.visualization import plot_bitstrings\n",
+    "import matplotlib.pyplot as plt\n",
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
-    "plot_histogram(counts, highlight={SOLUTION: \"tab:green\"})"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"tab:green\"})\n"
    ]
   },
   {
@@ -469,10 +551,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "id": "27",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Most frequent bitstring: 0110\n",
+      "P(0110) = 79.30%\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'plot_histogram' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[31]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m     19\u001b[39m p_solution = counts_analog.get(SOLUTION, \u001b[32m0\u001b[39m) / total\n\u001b[32m     20\u001b[39m print(\u001b[33m\"Most frequent bitstring:\"\u001b[39m, max(counts_analog, key=counts_analog.get))\n\u001b[32m     21\u001b[39m print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n\u001b[32m     22\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m plot_histogram(counts, highlight={SOLUTION: \u001b[33m\"tab:green\"\u001b[39m})\n",
+      "\u001b[31mNameError\u001b[39m: name 'plot_histogram' is not defined"
+     ]
+    }
+   ],
    "source": [
     "from qoolqit import AnalogDeviceWithDMM\n",
     "\n",
diff --git a/docs/tutorials/solving_a_qubo.ipynb b/docs/tutorials/solving_a_qubo.ipynb
index 58a9e394f..30dd98133 100644
--- a/docs/tutorials/solving_a_qubo.ipynb
+++ b/docs/tutorials/solving_a_qubo.ipynb
@@ -50,7 +50,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "id": "1",
    "metadata": {},
    "outputs": [],
@@ -78,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "3",
    "metadata": {},
    "outputs": [],
@@ -101,10 +101,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Two best solutions:  ['01011' '00111']\n",
+      "Respective costs:  [-1.38536295 -1.38536295]\n"
+     ]
+    }
+   ],
    "source": [
     "# Classical solution\n",
     "bitstrings = np.array([np.binary_repr(i, len(Q)) for i in range(2 ** len(Q))])\n",
@@ -137,7 +146,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "id": "7",
    "metadata": {},
    "outputs": [],
@@ -150,10 +159,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "id": "8",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Create the register\n",
     "from qoolqit import Register\n",
@@ -198,7 +218,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "id": "12",
    "metadata": {},
    "outputs": [],
@@ -231,10 +251,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "id": "14",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "from qoolqit import Drive, PiecewiseLinearWaveform, QuantumProgram, RampWaveform, Register\n",
     "\n",
@@ -271,10 +302,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "id": "17",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<string>:26: DeprecationWarning: Defining the number of emulation trajectories via 'NoiseModel.runs' is deprecated since pulser v1.7. Please favour using 'EmulationConfig.n_trajectories' instead.\n"
+     ]
+    }
+   ],
    "source": [
     "from pasqal_cloud import PasqalCloudConnection\n",
     "\n",
@@ -294,7 +333,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "id": "19",
    "metadata": {},
    "outputs": [],
@@ -304,10 +343,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "id": "20",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "program.draw(compiled=True)"
    ]
@@ -331,10 +381,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "id": "23",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Counter({'00111': 185, '01011': 157, '01010': 95, '01001': 90, '00110': 85, '10000': 73, '00101': 65, '10001': 58, '10010': 51, '01000': 37, '00100': 36, '00011': 33, '10011': 19, '00001': 11, '00010': 5})\n"
+     ]
+    }
+   ],
    "source": [
     "from qoolqit.execution import LocalEmulator\n",
     "\n",
@@ -360,15 +418,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "id": "25",
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qoolqit.utils import plot_histogram\n",
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from qoolqit.visualization import plot_bitstrings\n",
     "\n",
     "highlight = {b: \"tab:green\" for b in marked_bitstrings}\n",
-    "plot_histogram(counter, highlight=highlight)"
+    "plot_bitstrings(counter, highlight=highlight)"
    ]
   },
   {
@@ -394,10 +463,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "id": "28",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "program.compile_to(device=fresnel_device, device_max_duration_ratio=1)\n",
     "program.compiled_sequence.draw()"
@@ -413,15 +493,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "id": "30",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "job = emulator.run(program)\n",
     "results = job.results()\n",
     "counter = results.final_bitstrings\n",
-    "plot_histogram(counter, highlight=highlight)"
+    "plot_bitstrings(counter, highlight=highlight)"
    ]
   },
   {
diff --git a/qoolqit/utils/__init__.py b/qoolqit/utils/__init__.py
deleted file mode 100644
index 8ed20191d..000000000
--- a/qoolqit/utils/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from .visualization import plot_histogram
-
-__all__ = ["plot_histogram"]
diff --git a/qoolqit/utils/visualization.py b/qoolqit/visualization.py
similarity index 84%
rename from qoolqit/utils/visualization.py
rename to qoolqit/visualization.py
index b55543f3e..18ce9e8d2 100644
--- a/qoolqit/utils/visualization.py
+++ b/qoolqit/visualization.py
@@ -2,26 +2,22 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.patches import Patch
 
-if TYPE_CHECKING:
-    from matplotlib.axes import Axes
+__all__ = ["plot_bitstrings"]
 
-__all__ = ["plot_histogram"]
 
-
-def plot_histogram(
+def plot_bitstrings(
     counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
     normalize: bool = False,
     ax: Axes | None = None,
-    title: str | None = None,
     color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
-    xlabel: str | None = None,
-    ylabel: str | None = None,
-) -> Axes:
+) -> None:
     """Plot measurement counts, optionally highlighting selected outcomes.
 
     Parameters
@@ -37,8 +33,6 @@ def plot_histogram(
         normalized independently.
     ax: matplotlib.axes.Axes, optional
         If provided, the plot will be drawn on this axes.
-    title: str, optional
-        Plot title.
     color: str or list of str, optional
         Default bar color, or one color per mapping. Defaults to matplotlib's
         color cycle.
@@ -49,18 +43,7 @@ def plot_histogram(
         color in every group, so the run it belongs to becomes ambiguous.
     labels: str or list of str, optional
         Legend label for each mapping.
-    xlabel: str, optional
-        Label for the x-axis. Defaults to "Bitstring".
-    ylabel: str, optional
-        Label for the y-axis. Defaults to "Counts", or "Probability" when
-        `normalize` is True.
-
-    Returns
-    -------
-    matplotlib.axes.Axes
-        The axes object containing the plot.
     """
-    import matplotlib.pyplot as plt
 
     # Accept a single dict or a list of dicts, and work with a list from here on
     counts_list = [counts] if isinstance(counts, dict) else list(counts)
@@ -146,24 +129,20 @@ def plot_histogram(
     # Place one tick per bitstring, since the bars now sit at numeric positions
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
-    ax.set_xlabel("Bitstring" if xlabel is None else xlabel)
-    ax.set_ylabel(("Probability" if normalize else "Counts") if ylabel is None else ylabel)
-
-    # Set the title of the plot, using a default title if none is provided
-    ax.set_title(title or ("Measurement distribution" if normalize else "Measurement histogram"))
 
     # Rotate x-axis labels for better readability
     ax.tick_params(axis="x", labelrotation=90)
     ax.grid(axis="y", linestyle="--", alpha=0.4)
 
+    # We set some default labels, the user can override 
+    # them by calling ax.set_xlabel and ax.set_ylabel after this function.
+    ax.set_ylabel("Probability" if normalize else "Counts")
+    ax.set_xlabel("Bitstrings")
+
     # Only show a legend when the series have been named. The handles are built
     # explicitly from the base colors, since matplotlib would otherwise take the
     # color of the first bar of each series, which may be a highlighted one.
     if labels:
-        from matplotlib.patches import Patch
-
         ax.legend(
             handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
         )
-
-    return ax
diff --git a/tests/test_utils.py b/tests/test_visualization.py
similarity index 54%
rename from tests/test_utils.py
rename to tests/test_visualization.py
index bca835ec8..e7fe1a24f 100644
--- a/tests/test_utils.py
+++ b/tests/test_visualization.py
@@ -2,17 +2,17 @@
 
 import pytest
 
-from qoolqit.utils import plot_histogram
+from qoolqit.visualization import plot_bitstrings
 
 
-def test_plot_histogram_errors() -> None:
+def test_plot_bitstrings_errors() -> None:
     with pytest.raises(ValueError, match="counts cannot be empty"):
-        plot_histogram(counts={})
+        plot_bitstrings(counts={})
     with pytest.raises(ValueError, match="cannot plot normalized counts with zero total counts"):
-        plot_histogram(counts={"000": 0}, normalize=True)
+        plot_bitstrings(counts={"000": 0}, normalize=True)
     with pytest.raises(ValueError, match="top must be a positive integer"):
-        plot_histogram(counts={"000": 1, "001": 2}, top=0)
+        plot_bitstrings(counts={"000": 1, "001": 2}, top=0)
     with pytest.raises(ValueError, match="color must have one entry per counts mapping"):
-        plot_histogram(counts=[{"000": 1}, {"001": 2}], color=["tab:blue"])
+        plot_bitstrings(counts=[{"000": 1}, {"001": 2}], color=["tab:blue"])
     with pytest.raises(ValueError, match="labels must have one entry per counts mapping"):
-        plot_histogram(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])
+        plot_bitstrings(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])

From 92acd16cb663b273728a3ac1090199ab54463321 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:05:00 +0200
Subject: [PATCH 14/33] precommit

---
 docs/tutorials/Solving_a_MWIS.ipynb | 145 +++++-----------------------
 docs/tutorials/solving_a_qubo.ipynb | 137 +++++---------------------
 qoolqit/visualization.py            |   2 +-
 3 files changed, 46 insertions(+), 238 deletions(-)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index 1c22fc406..3a67497b9 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -55,21 +55,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "3",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -158,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "6",
    "metadata": {},
    "outputs": [],
@@ -225,21 +214,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "10",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit import Register\n",
     "from qoolqit.embedding import InteractionEmbedder\n",
@@ -263,23 +241,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "12",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "pair (i=0, j=1):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
-      "pair (i=1, j=2):  is non-edge   Jij =  0.02   (target Q_ij = 0)\n",
-      "pair (i=0, j=3):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
-      "pair (i=2, j=3):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
-      "pair (i=0, j=2):  is edge       Jij =  1.00   (target Q_ij = 1)\n",
-      "pair (i=1, j=3):  is non-edge   Jij =  0.02   (target Q_ij = 0)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for (i, j), value in register.interactions().items():\n",
     "    edge = \"edge    \" if Q[i, j] == 1 else \"non-edge\"\n",
@@ -313,18 +278,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "14",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "DMM weights (epsilon_i): {0: 1.0, 1: 0.0, 2: 0.0, 3: 1.0}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "node_weights = np.diag(Q)\n",
     "dmm_weights = 1.0 - node_weights / node_weights.max()\n",
@@ -372,18 +329,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "17",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Omega = 10.00   delta_0 = -10.00   delta_f = 10.00   T = 200\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Strongest interaction in the register sets the reference energy scale.\n",
     "distances = np.array(list(register.distances().values()))\n",
@@ -412,7 +361,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "19",
    "metadata": {},
    "outputs": [],
@@ -443,21 +392,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "21",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit import MockDevice, QuantumProgram\n",
     "\n",
@@ -478,18 +416,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "id": "23",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Most frequent bitstring: 0110\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit.execution import LocalEmulator\n",
     "\n",
@@ -511,24 +441,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "25",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
+    "\n",
     "from qoolqit.visualization import plot_bitstrings\n",
-    "import matplotlib.pyplot as plt\n",
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
@@ -551,30 +470,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "27",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Most frequent bitstring: 0110\n",
-      "P(0110) = 79.30%\n"
-     ]
-    },
-    {
-     "ename": "NameError",
-     "evalue": "name 'plot_histogram' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[31]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m     19\u001b[39m p_solution = counts_analog.get(SOLUTION, \u001b[32m0\u001b[39m) / total\n\u001b[32m     20\u001b[39m print(\u001b[33m\"Most frequent bitstring:\"\u001b[39m, max(counts_analog, key=counts_analog.get))\n\u001b[32m     21\u001b[39m print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n\u001b[32m     22\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m plot_histogram(counts, highlight={SOLUTION: \u001b[33m\"tab:green\"\u001b[39m})\n",
-      "\u001b[31mNameError\u001b[39m: name 'plot_histogram' is not defined"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit import AnalogDeviceWithDMM\n",
     "\n",
@@ -598,7 +497,7 @@
     "print(\"Most frequent bitstring:\", max(counts_analog, key=counts_analog.get))\n",
     "print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n",
     "\n",
-    "plot_histogram(counts, highlight={SOLUTION: \"tab:green\"})"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"tab:green\"})"
    ]
   },
   {
diff --git a/docs/tutorials/solving_a_qubo.ipynb b/docs/tutorials/solving_a_qubo.ipynb
index 30dd98133..f49c08005 100644
--- a/docs/tutorials/solving_a_qubo.ipynb
+++ b/docs/tutorials/solving_a_qubo.ipynb
@@ -50,7 +50,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "1",
    "metadata": {},
    "outputs": [],
@@ -78,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "3",
    "metadata": {},
    "outputs": [],
@@ -101,19 +101,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Two best solutions:  ['01011' '00111']\n",
-      "Respective costs:  [-1.38536295 -1.38536295]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Classical solution\n",
     "bitstrings = np.array([np.binary_repr(i, len(Q)) for i in range(2 ** len(Q))])\n",
@@ -146,7 +137,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "7",
    "metadata": {},
    "outputs": [],
@@ -159,21 +150,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "8",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Create the register\n",
     "from qoolqit import Register\n",
@@ -218,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "12",
    "metadata": {},
    "outputs": [],
@@ -251,21 +231,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "14",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit import Drive, PiecewiseLinearWaveform, QuantumProgram, RampWaveform, Register\n",
     "\n",
@@ -302,18 +271,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "id": "17",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "<string>:26: DeprecationWarning: Defining the number of emulation trajectories via 'NoiseModel.runs' is deprecated since pulser v1.7. Please favour using 'EmulationConfig.n_trajectories' instead.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pasqal_cloud import PasqalCloudConnection\n",
     "\n",
@@ -333,7 +294,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "19",
    "metadata": {},
    "outputs": [],
@@ -343,21 +304,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "20",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 2000x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "program.draw(compiled=True)"
    ]
@@ -381,18 +331,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "23",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Counter({'00111': 185, '01011': 157, '01010': 95, '01001': 90, '00110': 85, '10000': 73, '00101': 65, '10001': 58, '10010': 51, '01000': 37, '00100': 36, '00011': 33, '10011': 19, '00001': 11, '00010': 5})\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit.execution import LocalEmulator\n",
     "\n",
@@ -418,21 +360,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "25",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from qoolqit.visualization import plot_bitstrings\n",
     "\n",
@@ -463,21 +394,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "28",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 2000x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "program.compile_to(device=fresnel_device, device_max_duration_ratio=1)\n",
     "program.compiled_sequence.draw()"
@@ -493,21 +413,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "30",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "job = emulator.run(program)\n",
     "results = job.results()\n",
diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 18ce9e8d2..a1bfaafc6 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -134,7 +134,7 @@ def plot_bitstrings(
     ax.tick_params(axis="x", labelrotation=90)
     ax.grid(axis="y", linestyle="--", alpha=0.4)
 
-    # We set some default labels, the user can override 
+    # We set some default labels, the user can override
     # them by calling ax.set_xlabel and ax.set_ylabel after this function.
     ax.set_ylabel("Probability" if normalize else "Counts")
     ax.set_xlabel("Bitstrings")

From 432b476bc54c74ed2b7d01323361d3df0a7039f7 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:14:10 +0200
Subject: [PATCH 15/33] fixed docstring

---
 qoolqit/visualization.py | 36 +++++++++++++-----------------------
 1 file changed, 13 insertions(+), 23 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index a1bfaafc6..a27a19797 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -20,29 +20,19 @@ def plot_bitstrings(
 ) -> None:
     """Plot measurement counts, optionally highlighting selected outcomes.
 
-    Parameters
-    ----------
-    counts: dict or list of dict
-        Mapping of bitstrings to counts, or a list of such mappings. Several
-        mappings are drawn as grouped bars on the same axes.
-    top: int, optional
-        If provided, only the top N counts will be plotted. With several
-        mappings, outcomes are ranked by their total count.
-    normalize: bool, default False
-        If True, counts will be normalized to probabilities. Each mapping is
-        normalized independently.
-    ax: matplotlib.axes.Axes, optional
-        If provided, the plot will be drawn on this axes.
-    color: str or list of str, optional
-        Default bar color, or one color per mapping. Defaults to matplotlib's
-        color cycle.
-    highlight: dict, optional
-        Mapping of labels to colors, for example:
-        {"001": "tab:green", "110": "tab:red"}. Meant for a single mapping of
-        counts: with several mappings a highlighted outcome takes the same
-        color in every group, so the run it belongs to becomes ambiguous.
-    labels: str or list of str, optional
-        Legend label for each mapping.
+    Arguments:
+        counts: dictionary of bitstrings to counts, or a list of dictionaries.
+            the element of the list are drawn as grouped bars on the same axes.
+        top: If provided, only the top N counts will be plotted. With several
+            counts, outcomes are ranked by their total count.
+        normalize: If True, counts will be normalized to probabilities. Each
+            mapping is normalized independently. Defaults to False.
+        ax: If provided, the plot will be drawn on this axes.
+        color: Default bar color, or one color per mapping. Defaults to
+            matplotlib's color cycle.
+        highlight: Mapping of labels to colors, for example
+            ``{"001": "tab:green", "110": "tab:red"}``.
+        labels: Legend label for each mapping.
     """
 
     # Accept a single dict or a list of dicts, and work with a list from here on

From a98d245d583839af0ad9352fb538652f30275f45 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:22:25 +0200
Subject: [PATCH 16/33] Added fallback label for legend

---
 qoolqit/visualization.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index a27a19797..59a0cea38 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -132,7 +132,8 @@ def plot_bitstrings(
     # Only show a legend when the series have been named. The handles are built
     # explicitly from the base colors, since matplotlib would otherwise take the
     # color of the first bar of each series, which may be a highlighted one.
-    if labels:
-        ax.legend(
-            handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
-        )
+    if labels is None:
+        labels = [f"Histogram {index + 1}" for index in range(n)]
+    ax.legend(
+        handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
+    )

From 764064bfd82a29f997e2c1826121816c2ef542f9 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:31:08 +0200
Subject: [PATCH 17/33] Add fallback label only when there is more than one
 histogram

---
 qoolqit/visualization.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 59a0cea38..fffb7d84f 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -132,8 +132,11 @@ def plot_bitstrings(
     # Only show a legend when the series have been named. The handles are built
     # explicitly from the base colors, since matplotlib would otherwise take the
     # color of the first bar of each series, which may be a highlighted one.
-    if labels is None:
-        labels = [f"Histogram {index + 1}" for index in range(n)]
-    ax.legend(
-        handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
-    )
+    if n > 1 and labels is None:
+        # If no labels are provided, we generate default labels for each series.
+        labels = [f"Series {index + 1}" for index in range(n)]
+
+    if labels is not None:
+        ax.legend(
+            handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
+        )

From 09bf443c812fe15501602e6c122687bac97dbb93 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 15:32:09 +0200
Subject: [PATCH 18/33] Rename default legend labels

---
 qoolqit/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index fffb7d84f..83ca41b30 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -134,7 +134,7 @@ def plot_bitstrings(
     # color of the first bar of each series, which may be a highlighted one.
     if n > 1 and labels is None:
         # If no labels are provided, we generate default labels for each series.
-        labels = [f"Series {index + 1}" for index in range(n)]
+        labels = [f"Counts {index + 1}" for index in range(n)]
 
     if labels is not None:
         ax.legend(

From 8723140a0fe8ec0e2b2d4f82af6ef47495a6cda1 Mon Sep 17 00:00:00 2001
From: Alessandro Santini
 <76155864+alessandro-santini@users.noreply.github.com>
Date: Fri, 14 Aug 2026 15:59:25 +0200
Subject: [PATCH 19/33] Apply suggestions from code review

Co-authored-by: Stefano Grava <42062939+sgrava@users.noreply.github.com>
---
 qoolqit/visualization.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 83ca41b30..96fe30684 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -6,17 +6,16 @@
 from matplotlib.axes import Axes
 from matplotlib.patches import Patch
 
-__all__ = ["plot_bitstrings"]
 
 
 def plot_bitstrings(
     counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
     normalize: bool = False,
-    ax: Axes | None = None,
     color: str | list[str] | None = None,
     highlight: dict[str, str] | None = None,
     labels: list[str] | None = None,
+    ax: Axes | None = None,
 ) -> None:
     """Plot measurement counts, optionally highlighting selected outcomes.
 
@@ -27,12 +26,12 @@ def plot_bitstrings(
             counts, outcomes are ranked by their total count.
         normalize: If True, counts will be normalized to probabilities. Each
             mapping is normalized independently. Defaults to False.
-        ax: If provided, the plot will be drawn on this axes.
         color: Default bar color, or one color per mapping. Defaults to
             matplotlib's color cycle.
         highlight: Mapping of labels to colors, for example
-            ``{"001": "tab:green", "110": "tab:red"}``.
+            ``{"001": "tab:green", "110": "tab:red"}``. If highlighted bitstring is not in top...
         labels: Legend label for each mapping.
+        ax: Axes to draw on. Uses a new axes if omitted.
     """
 
     # Accept a single dict or a list of dicts, and work with a list from here on

From 9691d6414e166bfc879ccda2eea20ff4b70ff110 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 16:00:54 +0200
Subject: [PATCH 20/33] Fix labels position

---
 qoolqit/visualization.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 96fe30684..1384a95c3 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -7,7 +7,6 @@
 from matplotlib.patches import Patch
 
 
-
 def plot_bitstrings(
     counts: dict[str, int] | list[dict[str, int]],
     top: int | None = None,
@@ -78,6 +77,9 @@ def plot_bitstrings(
 
     if labels is not None and len(labels) != n:
         raise ValueError("labels must have one entry per counts mapping")
+    if n > 1 and labels is None:
+        # If no labels are provided, we generate default labels for each series.
+        labels = [f"Counts {index + 1}" for index in range(n)]
 
     # If no highlight mapping is provided, use an empty dict to avoid KeyErrors
     highlight = highlight or {}
@@ -131,9 +133,6 @@ def plot_bitstrings(
     # Only show a legend when the series have been named. The handles are built
     # explicitly from the base colors, since matplotlib would otherwise take the
     # color of the first bar of each series, which may be a highlighted one.
-    if n > 1 and labels is None:
-        # If no labels are provided, we generate default labels for each series.
-        labels = [f"Counts {index + 1}" for index in range(n)]
 
     if labels is not None:
         ax.legend(

From e2cb091e6c18a8fbf95e6725f65e45c9d230dedf Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 16:03:20 +0200
Subject: [PATCH 21/33]  fix docstring

---
 qoolqit/visualization.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 1384a95c3..23f2f8145 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -28,7 +28,8 @@ def plot_bitstrings(
         color: Default bar color, or one color per mapping. Defaults to
             matplotlib's color cycle.
         highlight: Mapping of labels to colors, for example
-            ``{"001": "tab:green", "110": "tab:red"}``. If highlighted bitstring is not in top...
+            ``{"001": "tab:green", "110": "tab:red"}``.
+            If highlighted bitstring is not in top N counts, it will not be shown.
         labels: Legend label for each mapping.
         ax: Axes to draw on. Uses a new axes if omitted.
     """

From 936a653ab787493292c5402c87eb843a1b243edf Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 16:30:23 +0200
Subject: [PATCH 22/33] Changed highlight behavior

---
 docs/tutorials/Solving_a_MWIS.ipynb |  6 ++--
 docs/tutorials/solving_a_qubo.ipynb |  2 +-
 qoolqit/visualization.py            | 45 +++++++++++++++++------------
 3 files changed, 30 insertions(+), 23 deletions(-)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index 3a67497b9..6a8915a6c 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -436,7 +436,7 @@
    "id": "24",
    "metadata": {},
    "source": [
-    "Finally we plot the full distribution of measured bitstrings, highlighting the exact MWIS solution `0110` in green. An adiabatic run that stayed in the ground state should return `0110` with overwhelming probability."
+    "Finally we plot the full distribution of measured bitstrings, highlighting the exact MWIS solution `0110`. An adiabatic run that stayed in the ground state should return `0110` with overwhelming probability."
    ]
   },
   {
@@ -451,7 +451,7 @@
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"tab:green\"})\n"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"C4\"})\n"
    ]
   },
   {
@@ -497,7 +497,7 @@
     "print(\"Most frequent bitstring:\", max(counts_analog, key=counts_analog.get))\n",
     "print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"tab:green\"})"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"C4\"})"
    ]
   },
   {
diff --git a/docs/tutorials/solving_a_qubo.ipynb b/docs/tutorials/solving_a_qubo.ipynb
index f49c08005..7da2cbcc1 100644
--- a/docs/tutorials/solving_a_qubo.ipynb
+++ b/docs/tutorials/solving_a_qubo.ipynb
@@ -367,7 +367,7 @@
    "source": [
     "from qoolqit.visualization import plot_bitstrings\n",
     "\n",
-    "highlight = {b: \"tab:green\" for b in marked_bitstrings}\n",
+    "highlight = {b: \"C0\" for b in marked_bitstrings}\n",
     "plot_bitstrings(counter, highlight=highlight)"
    ]
   },
diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 23f2f8145..836c09ee5 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -4,7 +4,6 @@
 
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
-from matplotlib.patches import Patch
 
 
 def plot_bitstrings(
@@ -27,8 +26,10 @@ def plot_bitstrings(
             mapping is normalized independently. Defaults to False.
         color: Default bar color, or one color per mapping. Defaults to
             matplotlib's color cycle.
-        highlight: Mapping of labels to colors, for example
-            ``{"001": "tab:green", "110": "tab:red"}``.
+        highlight: Mapping of bitstrings to colors, for example
+            ``{"001": "tab:green", "110": "tab:red"}``. The outcome is marked
+            with a faint background band and a colored tick label, so that the
+            bar colors keep identifying the counts they belong to.
             If highlighted bitstring is not in top N counts, it will not be shown.
         labels: Legend label for each mapping.
         ax: Axes to draw on. Uses a new axes if omitted.
@@ -92,10 +93,7 @@ def plot_bitstrings(
     # Plot one group of bars per set of counts, side by side on each bitstring
     positions = range(len(bitstrings))
 
-    # Bars are slightly narrower than their slot, so that neighbours sharing a
-    # highlight color do not merge into a single wide bar
     slot = 0.6 / n
-    width = slot if n == 1 else slot * 0.85
     for index, count in enumerate(counts_list):
         # Compute the values to plot, normalizing if requested.
         # If a bitstring is not present in the counts, we use 0 as its value.
@@ -104,24 +102,38 @@ def plot_bitstrings(
             for bitstring in bitstrings
         ]
 
-        # Determine bar colors, using the highlight mapping if provided
-        # If a bitstring is not in the highlight mapping, use this series' color.
-        bar_colors = [highlight.get(bitstring, color[index]) for bitstring in bitstrings]
-
         # Shift each group so that the bars are centered on the tick
         offset = (index - (n - 1) / 2) * slot
         ax.bar(
             [position + offset for position in positions],
             values,
-            width=width,
-            color=bar_colors,
+            width=slot,
+            color=color[index],
             label=labels[index] if labels else None,
         )
 
+    # Mark highlighted outcomes with a faint band behind their group. zorder=0
+    # keeps the band below the bars.
+    for position, bitstring in enumerate(bitstrings):
+        if bitstring in highlight:
+            ax.axvspan(
+                position - 0.45,
+                position + 0.45,
+                color=highlight[bitstring],
+                alpha=0.15,
+                zorder=0,
+            )
+
     # Place one tick per bitstring, since the bars now sit at numeric positions
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
 
+    # Highlighted outcomes are also marked on their tick label
+    for tick_label in ax.get_xticklabels():
+        if tick_label.get_text() in highlight:
+            tick_label.set_color(highlight[tick_label.get_text()])
+            tick_label.set_fontweight("bold")
+
     # Rotate x-axis labels for better readability
     ax.tick_params(axis="x", labelrotation=90)
     ax.grid(axis="y", linestyle="--", alpha=0.4)
@@ -131,11 +143,6 @@ def plot_bitstrings(
     ax.set_ylabel("Probability" if normalize else "Counts")
     ax.set_xlabel("Bitstrings")
 
-    # Only show a legend when the series have been named. The handles are built
-    # explicitly from the base colors, since matplotlib would otherwise take the
-    # color of the first bar of each series, which may be a highlighted one.
-
+    # Only show a legend when the series have been named
     if labels is not None:
-        ax.legend(
-            handles=[Patch(color=color[index], label=label) for index, label in enumerate(labels)]
-        )
+        ax.legend()

From 08d16bd5f017928ecf59a5e0da7e1db2e65de501 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 16:32:25 +0200
Subject: [PATCH 23/33] Fix comment

---
 qoolqit/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 836c09ee5..6d9412a8b 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -124,7 +124,7 @@ def plot_bitstrings(
                 zorder=0,
             )
 
-    # Place one tick per bitstring, since the bars now sit at numeric positions
+    # Place one tick per bitstring
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
 

From f3b714d1abdc8ec7ee0097b54c6f4903c658b1a3 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Fri, 14 Aug 2026 16:39:26 +0200
Subject: [PATCH 24/33] uniform colors

---
 docs/tutorials/Solving_a_MWIS.ipynb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index 6a8915a6c..272b9ac8b 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -451,7 +451,7 @@
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"C4\"})\n"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"C0\"})\n"
    ]
   },
   {
@@ -497,7 +497,7 @@
     "print(\"Most frequent bitstring:\", max(counts_analog, key=counts_analog.get))\n",
     "print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"C4\"})"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"C0\"})"
    ]
   },
   {

From a61c571c1f2b86a25192b1d81d2635b273294879 Mon Sep 17 00:00:00 2001
From: Alessandro Santini
 <76155864+alessandro-santini@users.noreply.github.com>
Date: Fri, 14 Aug 2026 18:04:52 +0200
Subject: [PATCH 25/33] Update visualization.py

Co-authored-by: Stefano Grava <42062939+sgrava@users.noreply.github.com>
---
 qoolqit/visualization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 6d9412a8b..3348fb291 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -15,7 +15,7 @@ def plot_bitstrings(
     labels: list[str] | None = None,
     ax: Axes | None = None,
 ) -> None:
-    """Plot measurement counts, optionally highlighting selected outcomes.
+    """Plot bitstrings counts, optionally highlighting selected ones.
 
     Arguments:
         counts: dictionary of bitstrings to counts, or a list of dictionaries.

From c829d48063874cfd7681e68b8fa2506619bda4b9 Mon Sep 17 00:00:00 2001
From: Alessandro Santini
 <76155864+alessandro-santini@users.noreply.github.com>
Date: Fri, 14 Aug 2026 18:05:12 +0200
Subject: [PATCH 26/33] Update visualization.py

Co-authored-by: Stefano Grava <42062939+sgrava@users.noreply.github.com>
---
 qoolqit/visualization.py | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 3348fb291..454e8655d 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -17,22 +17,16 @@ def plot_bitstrings(
 ) -> None:
     """Plot bitstrings counts, optionally highlighting selected ones.
 
-    Arguments:
-        counts: dictionary of bitstrings to counts, or a list of dictionaries.
-            the element of the list are drawn as grouped bars on the same axes.
-        top: If provided, only the top N counts will be plotted. With several
-            counts, outcomes are ranked by their total count.
-        normalize: If True, counts will be normalized to probabilities. Each
-            mapping is normalized independently. Defaults to False.
-        color: Default bar color, or one color per mapping. Defaults to
-            matplotlib's color cycle.
-        highlight: Mapping of bitstrings to colors, for example
-            ``{"001": "tab:green", "110": "tab:red"}``. The outcome is marked
-            with a faint background band and a colored tick label, so that the
-            bar colors keep identifying the counts they belong to.
-            If highlighted bitstring is not in top N counts, it will not be shown.
-        labels: Legend label for each mapping.
-        ax: Axes to draw on. Uses a new axes if omitted.
+Arguments:
+    counts: Mapping(s) of bitstrings to counts. Multiple mappings are grouped
+        as bars on the same axes.
+    top: Plot only the top N counts. With multiple mappings, rank by total count.
+    normalize: Normalize each mapping to probabilities. Defaults to False.
+    color: Bar color, or one color per mapping. Defaults to the matplotlib cycle.
+    highlight: Mapping of bitstrings to highlight colors. Highlighted outcomes
+        get a background band and colored tick label.
+    labels: Legend label for each mapping.
+    ax: Axes to draw on. Creates new axes if omitted.
     """
 
     # Accept a single dict or a list of dicts, and work with a list from here on

From 90fc216278a1e5fc45a01a0b7749bd40a43017e9 Mon Sep 17 00:00:00 2001
From: Alessandro Santini
 <76155864+alessandro-santini@users.noreply.github.com>
Date: Fri, 14 Aug 2026 18:05:31 +0200
Subject: [PATCH 27/33] Update visualization.py

Co-authored-by: Stefano Grava <42062939+sgrava@users.noreply.github.com>
---
 qoolqit/visualization.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 454e8655d..85156c269 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -50,7 +50,6 @@ def plot_bitstrings(
     # Sort the union of all bitstrings by their total count, in descending order
     # We use set for unique bitstrings, and sorted across the union of all
     # counts to ensure that we have a consistent order for the x-axis.
-    # When top is specified, we will select only the first N bitstrings after sorting
     bitstrings = sorted(
         set().union(*counts_list),
         key=lambda bitstring: sum(count.get(bitstring, 0) for count in counts_list),

From 7809752ecf328b1c5a5532f154eaf062a67f1faa Mon Sep 17 00:00:00 2001
From: Stefano Grava <s.grava-ext@pasqal.com>
Date: Mon, 17 Aug 2026 16:22:45 +0200
Subject: [PATCH 28/33] format

---
 qoolqit/visualization.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 85156c269..529cf8b88 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -17,16 +17,16 @@ def plot_bitstrings(
 ) -> None:
     """Plot bitstrings counts, optionally highlighting selected ones.
 
-Arguments:
-    counts: Mapping(s) of bitstrings to counts. Multiple mappings are grouped
-        as bars on the same axes.
-    top: Plot only the top N counts. With multiple mappings, rank by total count.
-    normalize: Normalize each mapping to probabilities. Defaults to False.
-    color: Bar color, or one color per mapping. Defaults to the matplotlib cycle.
-    highlight: Mapping of bitstrings to highlight colors. Highlighted outcomes
-        get a background band and colored tick label.
-    labels: Legend label for each mapping.
-    ax: Axes to draw on. Creates new axes if omitted.
+    Arguments:
+        counts: Mapping(s) of bitstrings to counts. Multiple mappings are grouped
+            as bars on the same axes.
+        top: Plot only the top N counts. With multiple mappings, rank by total count.
+        normalize: Normalize each mapping to probabilities. Defaults to False.
+        color: Bar color, or one color per mapping. Defaults to the matplotlib cycle.
+        highlight: Mapping of bitstrings to highlight colors. Highlighted outcomes
+            get a background band and colored tick label.
+        labels: Legend label for each mapping.
+        ax: Axes to draw on. Creates new axes if omitted.
     """
 
     # Accept a single dict or a list of dicts, and work with a list from here on

From 2e9474a703c5cd3a1c6d95f16e2d989de7e66221 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Wed, 9 Sep 2026 11:19:52 +0200
Subject: [PATCH 29/33] simplify API

---
 docs/tutorials/Solving_a_MWIS.ipynb |   8 +--
 docs/tutorials/solving_a_qubo.ipynb |   4 +-
 qoolqit/visualization.py            | 106 +++++++---------------------
 tests/test_visualization.py         |  24 +++++--
 4 files changed, 50 insertions(+), 92 deletions(-)

diff --git a/docs/tutorials/Solving_a_MWIS.ipynb b/docs/tutorials/Solving_a_MWIS.ipynb
index 29ab76775..c6d2ef23f 100644
--- a/docs/tutorials/Solving_a_MWIS.ipynb
+++ b/docs/tutorials/Solving_a_MWIS.ipynb
@@ -451,7 +451,7 @@
     "\n",
     "SOLUTION = \"0110\"\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"C0\"})\n"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"#00C887\"})\n"
    ]
   },
   {
@@ -497,7 +497,7 @@
     "print(\"Most frequent bitstring:\", max(counts_analog, key=counts_analog.get))\n",
     "print(f\"P({SOLUTION}) = {p_solution:.2%}\")\n",
     "\n",
-    "plot_bitstrings(counts, highlight={SOLUTION: \"C0\"})"
+    "plot_bitstrings(counts, highlight={SOLUTION: \"#00C887\"})"
    ]
   },
   {
@@ -529,7 +529,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "devqoolqit (3.14.6)",
+   "display_name": "devqoolqit (3.14.6.final.0)",
    "language": "python",
    "name": "python3"
   },
@@ -543,7 +543,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.11"
+   "version": "3.14.6"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/solving_a_qubo.ipynb b/docs/tutorials/solving_a_qubo.ipynb
index 72cea01d9..501f1c00c 100644
--- a/docs/tutorials/solving_a_qubo.ipynb
+++ b/docs/tutorials/solving_a_qubo.ipynb
@@ -367,7 +367,7 @@
    "source": [
     "from qoolqit.visualization import plot_bitstrings\n",
     "\n",
-    "highlight = {b: \"C0\" for b in marked_bitstrings}\n",
+    "highlight = {b: \"#00C887\" for b in marked_bitstrings}\n",
     "plot_bitstrings(counter, highlight=highlight)"
    ]
   },
@@ -435,7 +435,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "devqoolqit (3.14.6)",
+   "display_name": "devqoolqit (3.14.6.final.0)",
    "language": "python",
    "name": "python3"
   },
diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 529cf8b88..1a8f68179 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -5,119 +5,69 @@
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
 
+DEFAULT_BAR_COLOR = "#397378"
+
 
 def plot_bitstrings(
-    counts: dict[str, int] | list[dict[str, int]],
+    counts: dict[str, int],
     top: int | None = None,
     normalize: bool = False,
-    color: str | list[str] | None = None,
+    color: str = DEFAULT_BAR_COLOR,
     highlight: dict[str, str] | None = None,
-    labels: list[str] | None = None,
+    label: str | None = None,
     ax: Axes | None = None,
 ) -> None:
-    """Plot bitstrings counts, optionally highlighting selected ones.
+    """Plot bitstring counts, optionally highlighting selected ones.
 
     Arguments:
-        counts: Mapping(s) of bitstrings to counts. Multiple mappings are grouped
-            as bars on the same axes.
-        top: Plot only the top N counts. With multiple mappings, rank by total count.
-        normalize: Normalize each mapping to probabilities. Defaults to False.
-        color: Bar color, or one color per mapping. Defaults to the matplotlib cycle.
-        highlight: Mapping of bitstrings to highlight colors. Highlighted outcomes
-            get a background band and colored tick label.
-        labels: Legend label for each mapping.
+        counts: Mapping of bitstrings to counts.
+        top: Plot only the top N counts.
+        normalize: Normalize counts to probabilities. Defaults to False.
+        color: Bar color.
+        highlight: Mapping of bitstrings to highlight colors. Highlighted
+            outcomes get a background band and colored tick label.
+        label: Legend label for the bars. Call ax.legend() to show it.
         ax: Axes to draw on. Creates new axes if omitted.
     """
 
-    # Accept a single dict or a list of dicts, and work with a list from here on
-    counts_list = [counts] if isinstance(counts, dict) else list(counts)
-    labels = [labels] if isinstance(labels, str) else labels
-    n = len(counts_list)
-
-    if not counts_list or any(not count for count in counts_list):
+    if not counts:
         raise ValueError("counts cannot be empty")
 
-    # We check for zero total counts here, since the normalization would otherwise
-    # produce NaN values that matplotlib cannot plot. We do not check for zero
-    # counts when plotting a histogram, since matplotlib can handle that case.
-    totals = [sum(count.values()) for count in counts_list]
-    if normalize and any(total == 0 for total in totals):
+    # Zero total would divide-by-zero into NaN when normalizing
+    total = sum(counts.values())
+    if normalize and total == 0:
         raise ValueError("cannot plot normalized counts with zero total counts")
 
     if top is not None and top <= 0:
         raise ValueError("top must be a positive integer")
 
-    # Sort the union of all bitstrings by their total count, in descending order
-    # We use set for unique bitstrings, and sorted across the union of all
-    # counts to ensure that we have a consistent order for the x-axis.
-    bitstrings = sorted(
-        set().union(*counts_list),
-        key=lambda bitstring: sum(count.get(bitstring, 0) for count in counts_list),
-        reverse=True,
-    )
-
-    # Select only the top N counts if requested
+    bitstrings = sorted(counts, key=lambda bitstring: counts[bitstring], reverse=True)
     if top is not None:
         bitstrings = bitstrings[:top]
 
-    # One base color per set of counts
-    if color is None:
-        color = [f"C{index}" for index in range(n)]
-    elif isinstance(color, str):
-        color = [color] * n
-    else:
-        color = list(color)
-    if len(color) != n:
-        raise ValueError("color must have one entry per counts mapping")
-
-    if labels is not None and len(labels) != n:
-        raise ValueError("labels must have one entry per counts mapping")
-    if n > 1 and labels is None:
-        # If no labels are provided, we generate default labels for each series.
-        labels = [f"Counts {index + 1}" for index in range(n)]
-
-    # If no highlight mapping is provided, use an empty dict to avoid KeyErrors
     highlight = highlight or {}
 
     # Create the plot if no axes are provided
     if ax is None:
         _, ax = plt.subplots(figsize=(12, 5))
 
-    # Plot one group of bars per set of counts, side by side on each bitstring
     positions = range(len(bitstrings))
+    values = [
+        counts[bitstring] / total if normalize else counts[bitstring] for bitstring in bitstrings
+    ]
+    ax.bar(positions, values, width=0.65, color=color, label=label)
 
-    slot = 0.6 / n
-    for index, count in enumerate(counts_list):
-        # Compute the values to plot, normalizing if requested.
-        # If a bitstring is not present in the counts, we use 0 as its value.
-        values = [
-            count.get(bitstring, 0) / totals[index] if normalize else count.get(bitstring, 0)
-            for bitstring in bitstrings
-        ]
-
-        # Shift each group so that the bars are centered on the tick
-        offset = (index - (n - 1) / 2) * slot
-        ax.bar(
-            [position + offset for position in positions],
-            values,
-            width=slot,
-            color=color[index],
-            label=labels[index] if labels else None,
-        )
-
-    # Mark highlighted outcomes with a faint band behind their group. zorder=0
-    # keeps the band below the bars.
+    # zorder=0 keeps the highlight band behind the bars
     for position, bitstring in enumerate(bitstrings):
         if bitstring in highlight:
             ax.axvspan(
                 position - 0.45,
                 position + 0.45,
                 color=highlight[bitstring],
-                alpha=0.15,
+                alpha=0.35,
                 zorder=0,
             )
 
-    # Place one tick per bitstring
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
 
@@ -127,15 +77,9 @@ def plot_bitstrings(
             tick_label.set_color(highlight[tick_label.get_text()])
             tick_label.set_fontweight("bold")
 
-    # Rotate x-axis labels for better readability
     ax.tick_params(axis="x", labelrotation=90)
     ax.grid(axis="y", linestyle="--", alpha=0.4)
 
-    # We set some default labels, the user can override
-    # them by calling ax.set_xlabel and ax.set_ylabel after this function.
+    # Default labels; the caller can override via ax.set_xlabel/ax.set_ylabel
     ax.set_ylabel("Probability" if normalize else "Counts")
     ax.set_xlabel("Bitstrings")
-
-    # Only show a legend when the series have been named
-    if labels is not None:
-        ax.legend()
diff --git a/tests/test_visualization.py b/tests/test_visualization.py
index e7fe1a24f..728cf725f 100644
--- a/tests/test_visualization.py
+++ b/tests/test_visualization.py
@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import matplotlib.pyplot as plt
 import pytest
+from matplotlib.colors import to_rgba
 
-from qoolqit.visualization import plot_bitstrings
+from qoolqit.visualization import DEFAULT_BAR_COLOR, plot_bitstrings
 
 
 def test_plot_bitstrings_errors() -> None:
@@ -12,7 +14,19 @@ def test_plot_bitstrings_errors() -> None:
         plot_bitstrings(counts={"000": 0}, normalize=True)
     with pytest.raises(ValueError, match="top must be a positive integer"):
         plot_bitstrings(counts={"000": 1, "001": 2}, top=0)
-    with pytest.raises(ValueError, match="color must have one entry per counts mapping"):
-        plot_bitstrings(counts=[{"000": 1}, {"001": 2}], color=["tab:blue"])
-    with pytest.raises(ValueError, match="labels must have one entry per counts mapping"):
-        plot_bitstrings(counts=[{"000": 1}, {"001": 2}], labels=["run 1"])
+
+
+def test_plot_bitstrings_default_bar_color() -> None:
+    _, ax = plt.subplots()
+    plot_bitstrings(counts={"000": 1, "001": 2}, ax=ax)
+
+    bars = ax.containers[0]
+    assert all(bar.get_facecolor() == to_rgba(DEFAULT_BAR_COLOR) for bar in bars)
+
+
+def test_plot_bitstrings_label_sets_bar_label() -> None:
+    _, ax = plt.subplots()
+    plot_bitstrings(counts={"000": 1, "001": 2}, label="run 1", ax=ax)
+
+    assert ax.get_legend() is None
+    assert ax.containers[0].get_label() == "run 1"

From 47fc4e94f59b5f0d5c503204d76ccab3fedc0ea3 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Wed, 9 Sep 2026 13:09:58 +0200
Subject: [PATCH 30/33] Kept the old way of highlighting the Histogram since
 now we just plot one barplot at a time

---
 qoolqit/visualization.py    | 15 +++++----------
 tests/test_visualization.py | 17 +++++++++++++++++
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 1a8f68179..e82940b8f 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -25,7 +25,7 @@ def plot_bitstrings(
         normalize: Normalize counts to probabilities. Defaults to False.
         color: Bar color.
         highlight: Mapping of bitstrings to highlight colors. Highlighted
-            outcomes get a background band and colored tick label.
+            outcomes get their bar and tick label colored accordingly.
         label: Legend label for the bars. Call ax.legend() to show it.
         ax: Axes to draw on. Creates new axes if omitted.
     """
@@ -57,16 +57,11 @@ def plot_bitstrings(
     ]
     ax.bar(positions, values, width=0.65, color=color, label=label)
 
-    # zorder=0 keeps the highlight band behind the bars
-    for position, bitstring in enumerate(bitstrings):
+    # Redraw highlighted bars on top in their own color, so the legend swatch
+    # for `label` (taken from the first patch) still reflects `color`.
+    for position, bitstring, value in zip(positions, bitstrings, values):
         if bitstring in highlight:
-            ax.axvspan(
-                position - 0.45,
-                position + 0.45,
-                color=highlight[bitstring],
-                alpha=0.35,
-                zorder=0,
-            )
+            ax.bar(position, value, width=0.65, color=highlight[bitstring])
 
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
diff --git a/tests/test_visualization.py b/tests/test_visualization.py
index 728cf725f..c503227ea 100644
--- a/tests/test_visualization.py
+++ b/tests/test_visualization.py
@@ -30,3 +30,20 @@ def test_plot_bitstrings_label_sets_bar_label() -> None:
 
     assert ax.get_legend() is None
     assert ax.containers[0].get_label() == "run 1"
+
+
+def test_plot_bitstrings_highlight_colors_the_bar() -> None:
+    _, ax = plt.subplots()
+    plot_bitstrings(counts={"000": 1, "001": 2}, highlight={"001": "tab:red"}, ax=ax)
+
+    assert all(bar.get_facecolor() == to_rgba(DEFAULT_BAR_COLOR) for bar in ax.containers[0])
+    assert [bar.get_facecolor() for bar in ax.containers[1]] == [to_rgba("tab:red")]
+
+
+def test_plot_bitstrings_legend_uses_base_color_even_if_first_bar_highlighted() -> None:
+    _, ax = plt.subplots()
+    # "001" has the higher count so it plots first, and is also highlighted.
+    plot_bitstrings(counts={"000": 1, "001": 2}, highlight={"001": "tab:red"}, label="run 1", ax=ax)
+
+    legend = ax.legend()
+    assert legend.legend_handles[0].get_facecolor() == to_rgba(DEFAULT_BAR_COLOR)

From e64fa65fe84650e70f58a9c042f61738332dba51 Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Wed, 9 Sep 2026 13:13:05 +0200
Subject: [PATCH 31/33] changed comment

---
 qoolqit/visualization.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index e82940b8f..02d3d1870 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -57,8 +57,7 @@ def plot_bitstrings(
     ]
     ax.bar(positions, values, width=0.65, color=color, label=label)
 
-    # Redraw highlighted bars on top in their own color, so the legend swatch
-    # for `label` (taken from the first patch) still reflects `color`.
+    # Redraw highlighted bars on top in their own color
     for position, bitstring, value in zip(positions, bitstrings, values):
         if bitstring in highlight:
             ax.bar(position, value, width=0.65, color=highlight[bitstring])

From a7ebfe252e345a15786a8396ecae58c7bad94b0a Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Thu, 10 Sep 2026 14:28:11 +0200
Subject: [PATCH 32/33] small fix

---
 qoolqit/visualization.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 02d3d1870..5366e74d8 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -58,9 +58,8 @@ def plot_bitstrings(
     ax.bar(positions, values, width=0.65, color=color, label=label)
 
     # Redraw highlighted bars on top in their own color
-    for position, bitstring, value in zip(positions, bitstrings, values):
-        if bitstring in highlight:
-            ax.bar(position, value, width=0.65, color=highlight[bitstring])
+    colors = [highlight.get(b, color) for b in bitstrings]
+    ax.bar(positions, values, width=0.65, color=colors)
 
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)

From 811c80f4d535a9c4039ba118d7c0c25f2754c61c Mon Sep 17 00:00:00 2001
From: Alessandro Santini <alessandro.santini@pasqal.com>
Date: Thu, 10 Sep 2026 14:37:25 +0200
Subject: [PATCH 33/33] more small fix

---
 qoolqit/visualization.py    | 25 +++++++++++++------------
 tests/test_visualization.py | 20 ++++++++++++++++----
 2 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/qoolqit/visualization.py b/qoolqit/visualization.py
index 5366e74d8..156d2ce58 100644
--- a/qoolqit/visualization.py
+++ b/qoolqit/visualization.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from collections import Counter
+
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
 
@@ -33,7 +35,6 @@ def plot_bitstrings(
     if not counts:
         raise ValueError("counts cannot be empty")
 
-    # Zero total would divide-by-zero into NaN when normalizing
     total = sum(counts.values())
     if normalize and total == 0:
         raise ValueError("cannot plot normalized counts with zero total counts")
@@ -41,9 +42,10 @@ def plot_bitstrings(
     if top is not None and top <= 0:
         raise ValueError("top must be a positive integer")
 
-    bitstrings = sorted(counts, key=lambda bitstring: counts[bitstring], reverse=True)
-    if top is not None:
-        bitstrings = bitstrings[:top]
+    # most_common(None) returns all entries, sorted by decreasing count
+    selected_counts = Counter(counts).most_common(top)
+    bitstrings = [bitstring for bitstring, _ in selected_counts]
+    values = [count / total if normalize else count for _, count in selected_counts]
 
     highlight = highlight or {}
 
@@ -52,14 +54,13 @@ def plot_bitstrings(
         _, ax = plt.subplots(figsize=(12, 5))
 
     positions = range(len(bitstrings))
-    values = [
-        counts[bitstring] / total if normalize else counts[bitstring] for bitstring in bitstrings
-    ]
-    ax.bar(positions, values, width=0.65, color=color, label=label)
-
-    # Redraw highlighted bars on top in their own color
-    colors = [highlight.get(b, color) for b in bitstrings]
-    ax.bar(positions, values, width=0.65, color=colors)
+    bar_colors = [highlight.get(bitstring, color) for bitstring in bitstrings]
+    ax.bar(positions, values, width=0.65, color=bar_colors)
+
+    if label is not None:
+        # A zero-height bar draws nothing but gives the legend a swatch in
+        # `color`, regardless of which bitstrings are highlighted.
+        ax.bar(0, 0, color=color, label=label)
 
     ax.set_xticks(list(positions))
     ax.set_xticklabels(bitstrings)
diff --git a/tests/test_visualization.py b/tests/test_visualization.py
index c503227ea..597633299 100644
--- a/tests/test_visualization.py
+++ b/tests/test_visualization.py
@@ -24,20 +24,23 @@ def test_plot_bitstrings_default_bar_color() -> None:
     assert all(bar.get_facecolor() == to_rgba(DEFAULT_BAR_COLOR) for bar in bars)
 
 
-def test_plot_bitstrings_label_sets_bar_label() -> None:
+def test_plot_bitstrings_label_shows_up_in_legend() -> None:
     _, ax = plt.subplots()
     plot_bitstrings(counts={"000": 1, "001": 2}, label="run 1", ax=ax)
 
     assert ax.get_legend() is None
-    assert ax.containers[0].get_label() == "run 1"
+    legend = ax.legend()
+    assert legend.legend_handles[0].get_facecolor() == to_rgba(DEFAULT_BAR_COLOR)
+    assert legend.get_texts()[0].get_text() == "run 1"
 
 
 def test_plot_bitstrings_highlight_colors_the_bar() -> None:
     _, ax = plt.subplots()
     plot_bitstrings(counts={"000": 1, "001": 2}, highlight={"001": "tab:red"}, ax=ax)
 
-    assert all(bar.get_facecolor() == to_rgba(DEFAULT_BAR_COLOR) for bar in ax.containers[0])
-    assert [bar.get_facecolor() for bar in ax.containers[1]] == [to_rgba("tab:red")]
+    bars = dict(zip(["001", "000"], ax.containers[0]))
+    assert bars["001"].get_facecolor() == to_rgba("tab:red")
+    assert bars["000"].get_facecolor() == to_rgba(DEFAULT_BAR_COLOR)
 
 
 def test_plot_bitstrings_legend_uses_base_color_even_if_first_bar_highlighted() -> None:
@@ -47,3 +50,12 @@ def test_plot_bitstrings_legend_uses_base_color_even_if_first_bar_highlighted()
 
     legend = ax.legend()
     assert legend.legend_handles[0].get_facecolor() == to_rgba(DEFAULT_BAR_COLOR)
+
+
+def test_plot_bitstrings_two_calls_on_same_axes_keep_their_own_highlights() -> None:
+    _, ax = plt.subplots()
+    plot_bitstrings(counts={"000": 1, "001": 2}, highlight={"001": "tab:red"}, ax=ax)
+    plot_bitstrings(counts={"000": 1, "001": 2}, color="C2", ax=ax)
+
+    first_call_bars = dict(zip(["001", "000"], ax.containers[0]))
+    assert first_call_bars["001"].get_facecolor() == to_rgba("tab:red")