From 30393112bced68197aeadbb15085e3ff6491b1fa Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Mon, 26 Apr 2021 17:23:28 +0300
Subject: [PATCH 01/20] Beginning of interleaved RB and several fixes to
 related classes

---
 qiskit_experiments/analysis/curve_fitting.py  |  2 +-
 .../randomized_benchmarking/__init__.py       |  1 +
 .../interleaved_rb_analysis.py                | 44 +++++++++
 .../interleaved_rb_experiment.py              | 94 +++++++++++++++++++
 .../randomized_benchmarking/rb_analysis.py    |  2 +-
 .../randomized_benchmarking/rb_experiment.py  |  2 +-
 test/test_curve_fitting.py                    | 22 ++++-
 7 files changed, 163 insertions(+), 4 deletions(-)
 create mode 100644 qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
 create mode 100644 qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py

diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
index b2d2e83801..b5717eb7a1 100644
--- a/qiskit_experiments/analysis/curve_fitting.py
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -293,7 +293,7 @@ def process_multi_curve_data(
     ydata = np.zeros(size, dtype=float)
     ydata_var = np.zeros(size, dtype=float)
 
-    for i, datum in enumerate(filter_data):
+    for i, datum in enumerate(filtered_data):
         metadata = datum["metadata"]
         series[i] = metadata[series_key]
         xdata[i] = metadata[x_key]
diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
index 8a359dcc72..9104e80567 100644
--- a/qiskit_experiments/randomized_benchmarking/__init__.py
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -13,4 +13,5 @@
 """Randomized Benchmarking Experiment Classes."""
 
 from .rb_experiment import RBExperiment
+from .interleaved_rb_experiment import InterleavedRBExperiment
 from .rb_analysis import RBAnalysis
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
new file mode 100644
index 0000000000..2168304eae
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -0,0 +1,44 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Interleaved RB analysis class.
+"""
+from typing import Optional, List
+from qiskit_experiments.analysis.curve_fitting import process_multi_curve_data
+
+from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.analysis.data_processing import (
+    level2_probability,
+    mean_xy_data,
+    filter_data,
+)
+from .rb_analysis import RBAnalysis
+
+class InterleavedRBAnalysis(BaseAnalysis):
+    """Interleaved RB Analysis class."""
+
+    def _run_analysis(
+            self,
+            experiment_data,
+            p0: Optional[List[float]] = None,
+            plot: bool = True,
+            ax: Optional["AxesSubplot"] = None,
+    ):
+        def data_processor(datum):
+            return level2_probability(datum, datum['metadata']['ylabel'])
+
+        self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
+        series, x, y, sigma = process_multi_curve_data(experiment_data.data,
+                                                       data_processor)
+        return
+
+
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
new file mode 100644
index 0000000000..3b67d138fd
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
@@ -0,0 +1,94 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Interleaved RB Experiment class.
+"""
+from typing import Union, Iterable, Optional, List
+
+from numpy.random import Generator, default_rng
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import Instruction
+from qiskit.quantum_info import Clifford, random_clifford
+
+from .rb_experiment import RBExperiment
+from .interleaved_rb_analysis import InterleavedRBAnalysis
+
+
+class InterleavedRBExperiment(RBExperiment):
+    """Interleaved RB Experiment class"""
+
+    # Analysis class for experiment
+    __analysis_class__ = InterleavedRBAnalysis
+
+    def __init__(
+        self,
+        interleaved_element:
+        Union[QuantumCircuit, Instruction, Clifford],
+        qubits: Union[int, Iterable[int]],
+        lengths: Iterable[int],
+        num_samples: int = 1,
+        seed: Optional[Union[int, Generator]] = None,
+        full_sampling: bool = False,
+    ):
+        """Interleaved randomized benchmarking experiment
+        Args:
+            interleaved_element: the element to interleave, 
+                    given either as a group element or as an instruction/circuit
+            qubits: the number of qubits or list of
+                    physical qubits for the experiment.
+            lengths: A list of RB sequences lengths.
+            num_samples: number of samples to generate for each
+                         sequence length
+            seed: Seed or generator object for random number
+                  generation. If None default_rng will be used.
+            full_sampling: If True all Cliffords are independently sampled for
+                           all lengths. If False for sample of lengths longer
+                           sequences are constructed by appending additional
+                           Clifford samples to shorter sequences.
+        """
+        self._interleaved_element = interleaved_element
+        super().__init__(qubits, lengths, num_samples, seed, full_sampling)
+
+    def _sample_circuits(self, lengths, seed=None):
+        circuits = []
+        for length in (lengths if self._full_sampling else [lengths[-1]]):
+            elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
+            element_lengths = [len(elements)] if self._full_sampling else lengths
+            std_circuits = self._generate_circuit(elements, element_lengths)
+            for circuit in std_circuits:
+                circuit.metadata['series'] = 0
+                circuit.metadata['series_name'] = 'standard'
+            circuits += std_circuits
+
+            int_elements = self._interleave(elements)
+            int_elements_lengths = [length * 2 for length in element_lengths]
+            int_circuits = self._generate_circuit(int_elements, int_elements_lengths)
+            for circuit in int_circuits:
+                circuit.metadata['series'] = 1
+                circuit.metadata['series_name'] = 'interleaved'
+                circuit.metadata['xval'] = circuit.metadata['xval'] // 2
+            circuits += int_circuits
+        return circuits
+
+    def _interleave(self, element_list: List) -> List:
+        """Interleaving the interleaved element inside the element list
+        Args:
+            element_list: The list of elements we add the interleaved element to
+        Returns:
+            The new list with the element interleaved
+            """
+        new_element_list = []
+        for element in element_list:
+            new_element_list.append(element)
+            new_element_list.append(self._interleaved_element)
+        return new_element_list
\ No newline at end of file
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index aae08e9916..60c9a28416 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -115,7 +115,7 @@ def _extract_data(self, experiment_data, **filters):
         ydata_var = np.zeros(size, dtype=float)
         for i, datum in enumerate(data):
             metadata = datum["metadata"]
-            xdata[i] = metadata["xdata"]
+            xdata[i] = metadata["xval"]
             ydata[i], ydata_var[i] = level2_probability(datum, metadata["ylabel"])
 
         ydata_sigma = np.sqrt(ydata_var)
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index be6163dfdf..9e7ef2a551 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -139,7 +139,7 @@ def _generate_circuit(self, elements: Iterable[Clifford], lengths: Iterable[int]
                 rb_circ.barrier(qubits)
                 rb_circ.metadata = {
                     "experiment_type": self._type,
-                    "xdata": current_length + 1,
+                    "xval": current_length + 1,
                     "ylabel": self.num_qubits * "0",
                     "group": "Clifford",
                     "qubits": self.physical_qubits,
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index be180d09e9..46aaf8b6d5 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -17,7 +17,7 @@
 from qiskit import QuantumCircuit, execute
 from qiskit.providers.basicaer import QasmSimulatorPy
 from qiskit_experiments.analysis.curve_fitting import curve_fit, multi_curve_fit, process_curve_data
-from qiskit_experiments.analysis.data_processing import level2_probability
+from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data
 
 
 class TestCurveFitting(QiskitTestCase):
@@ -108,3 +108,23 @@ def test_multi_curve_fit(self):
             [self.objective0, self.objective1], series, xdata, ydata, p0, sigma=sigma, bounds=bounds
         )
         self.assertTrue(abs(sol["popt"][0] - 0.5) < 0.05)
+
+    def test_mean_xy_data(self):
+        x = np.array([1,1,1,2,2,2,2,3,3,4,5,5,5,5])
+        y = np.array([1,2,3,8,10,50,60,10,11,17,10,10,10,10])
+        x_mean, y_mean, y_sigma = mean_xy_data(x, y, method="sample")
+
+        expected_x_mean = np.array([1,2,3,4,5])
+        expected_y_mean = np.array([2, 32, 10.5, 17, 10])
+        expected_y_sigma = np.array([2/3, 542, 1/4, 0, 0])
+        self.assertTrue(np.allclose(expected_x_mean, x_mean))
+        self.assertTrue(np.allclose(expected_y_mean, y_mean))
+        self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
+
+        sigma = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14])
+        x_mean, y_mean, y_sigma = mean_xy_data(x, y, sigma, method="iwv")
+        expected_y_mean = np.array([1.34693878, 23.31590234, 10.44137931, 17., 10.])
+        expected_y_sigma = np.array([0.85714286, 2.57610543, 5.97927455, 10., 6.17470935])
+        self.assertTrue(np.allclose(expected_x_mean, x_mean))
+        self.assertTrue(np.allclose(expected_y_mean, y_mean))
+        self.assertTrue(np.allclose(expected_y_sigma, y_sigma))

From 12fd0481ab17876c5d2c916ba7fe35ce2a4078e9 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Mon, 26 Apr 2021 17:37:36 +0300
Subject: [PATCH 02/20] Small refactor to mean_xy_data

---
 .../analysis/data_processing.py               | 39 ++++++++-----------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 89cb8e299e..12d794359e 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -80,44 +80,37 @@ def mean_xy_data(
     Raises:
         QiskitError: if "ivw" method is used without providing a sigma.
     """
+    if method == "iwv" and sigma is None:
+        raise QiskitError(
+            "The inverse-weighted variance method cannot be used with" " `sigma=None`"
+        )
+    if not method in ["sample", "iwv"]:
+        raise QiskitError(f"Unsupported method {method}")
+
     x_means = np.unique(xdata, axis=0)
     y_means = np.zeros(x_means.size)
     y_sigmas = np.zeros(x_means.size)
 
-    # Sample mean and variance method
-    if method == "sample":
-        for i in range(x_means.size):
-            # Get positions of y to average
-            idxs = xdata == x_means[i]
-            ys = ydata[idxs]
+    for i in range(x_means.size):
+        # Get positions of y to average
+        idxs = xdata == x_means[i]
+        ys = ydata[idxs]
 
+        # Sample mean and variance method
+        if method == "sample":
             # Compute sample mean and biased sample variance
             y_means[i] = np.mean(ys)
             y_sigmas[i] = np.mean((y_means[i] - ys) ** 2)
+            # Inverse-weighted variance method
 
-        return x_means, y_means, y_sigmas
-
-    # Inverse-weighted variance method
-    if method == "iwv":
-        if sigma is None:
-            raise QiskitError(
-                "The inverse-weighted variance method cannot be used with" " `sigma=None`"
-            )
-        for i in range(x_means.size):
-            # Get positions of y to average
-            idxs = xdata == x_means[i]
-            ys = ydata[idxs]
-
+        if method == "iwv":
             # Compute the inverse-variance weighted y mean and variance
             weights = 1 / sigma[idxs] ** 2
             y_var = 1 / np.sum(weights)
             y_means[i] = y_var * np.sum(weights * ys)
             y_sigmas[i] = np.sqrt(y_var)
 
-        return x_means, y_means, y_sigmas
-
-    # Invalid method
-    raise QiskitError(f"Unsupported method {method}")
+    return x_means, y_means, y_sigmas
 
 
 def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:

From aaaffe1a43d380bd122568a60cd089e25e5c8c4e Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Mon, 26 Apr 2021 18:26:18 +0300
Subject: [PATCH 03/20] Updated mean_xy_data to support multi series

---
 .../analysis/data_processing.py               | 29 +++++++++++++------
 test/test_curve_fitting.py                    | 14 +++++++++
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 12d794359e..7de9ba80b8 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -47,7 +47,11 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
 
 
 def mean_xy_data(
-    xdata: np.ndarray, ydata: np.ndarray, sigma: Optional[np.ndarray] = None, method: str = "sample"
+        xdata: np.ndarray,
+        ydata: np.ndarray,
+        sigma: Optional[np.ndarray] = None,
+        series: Optional[np.ndarray] = None,
+        method: str = "sample"
 ) -> Tuple[np.ndarray]:
     r"""Return (x, y_mean, sigma) data.
 
@@ -63,10 +67,11 @@ def mean_xy_data(
       :math:`\sigma^2 = 1 / (\sum_{i=1}^N 1 / \sigma_i^2)`
 
     Args
-        xdata: 1D or 2D array of xdata from curve_fit_data or
+        xdata: 1D array of xdata from curve_fit_data or
                multi_curve_fit_data
         ydata: array of ydata returned from curve_fit_data or
                multi_curve_fit_data
+        series: 1D int array that specifies the data series
         sigma: Optional, array of standard deviations in ydata.
         method: The method to use for computing y means and
                 standard deviations sigma (default: "sample").
@@ -86,14 +91,18 @@ def mean_xy_data(
         )
     if not method in ["sample", "iwv"]:
         raise QiskitError(f"Unsupported method {method}")
-
-    x_means = np.unique(xdata, axis=0)
-    y_means = np.zeros(x_means.size)
-    y_sigmas = np.zeros(x_means.size)
-
-    for i in range(x_means.size):
+    xseries = series if series is not None else np.zeros(xdata.size)
+    x_keys = np.unique(np.column_stack((xdata, xseries)), axis=0)
+    x_means = np.zeros(x_keys.shape[0])
+    y_means = np.zeros(x_keys.shape[0])
+    y_sigmas = np.zeros(x_keys.shape[0])
+    series_mean = np.zeros(x_keys.shape[0])
+
+    for i, (x_val, xseries_val) in enumerate(x_keys):
+        x_means[i] = x_val
+        series_mean[i] = xseries_val
         # Get positions of y to average
-        idxs = xdata == x_means[i]
+        idxs = np.where((xdata == x_val) & (xseries == xseries_val))
         ys = ydata[idxs]
 
         # Sample mean and variance method
@@ -110,6 +119,8 @@ def mean_xy_data(
             y_means[i] = y_var * np.sum(weights * ys)
             y_sigmas[i] = np.sqrt(y_var)
 
+    if series is not None:
+        return x_means, y_means, y_sigmas, series_mean
     return x_means, y_means, y_sigmas
 
 
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 46aaf8b6d5..51a3ec6f83 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -128,3 +128,17 @@ def test_mean_xy_data(self):
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
+
+        x = np.array([1,1,1,1,2,2,2,2])
+        y = np.array([2,6,100,200,17,50,60,70])
+        series = np.array([0,0,1,1,0,1,1,1])
+        x_mean, y_mean, y_sigma, series = mean_xy_data(x, y, method="sample", series=series)
+        expected_x_mean = np.array([1,1,2,2])
+        expected_y_mean = np.array([4, 150, 17, 60])
+        expected_y_sigma = np.array([4., 2500., 0., 66.66666667])
+        expected_series = np.array([0,1,0,1])
+        self.assertTrue(np.allclose(expected_x_mean, x_mean))
+        self.assertTrue(np.allclose(expected_y_mean, y_mean))
+        self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
+        self.assertTrue(np.allclose(expected_series, series))
+

From 5c91db6868633ff02b3539f7637d1cee1274a0d7 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Mon, 26 Apr 2021 18:51:50 +0300
Subject: [PATCH 04/20] Using multi_curve_fit in interleaved analysis (not
 working correctly yet)

---
 .../interleaved_rb_analysis.py                | 24 ++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 2168304eae..c693d8ebeb 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -13,7 +13,10 @@
 Interleaved RB analysis class.
 """
 from typing import Optional, List
-from qiskit_experiments.analysis.curve_fitting import process_multi_curve_data
+from qiskit_experiments.analysis.curve_fitting import (
+    process_multi_curve_data,
+    multi_curve_fit,
+)
 
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.analysis.data_processing import (
@@ -23,7 +26,7 @@
 )
 from .rb_analysis import RBAnalysis
 
-class InterleavedRBAnalysis(BaseAnalysis):
+class InterleavedRBAnalysis(RBAnalysis):
     """Interleaved RB Analysis class."""
 
     def _run_analysis(
@@ -39,6 +42,21 @@ def data_processor(datum):
         self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
         series, x, y, sigma = process_multi_curve_data(experiment_data.data,
                                                        data_processor)
-        return
+        xdata, ydata, ydata_sigma, series = mean_xy_data(x, y, sigma, series)
+
+        def fit_fun(x, a, alpha, b):
+            return a * alpha ** x + b
+
+        p0 = self._p0(xdata, ydata)
+        analysis_result = multi_curve_fit(
+            [fit_fun, fit_fun],
+            series,
+            xdata,
+            ydata,
+            p0,
+            ydata_sigma,
+            bounds=([0, 0, 0], [1, 1, 1])
+        )
+        return analysis_result
 
 

From 83d3b7b0f580014cdc439a5eb60e0dea755131e5 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Mon, 26 Apr 2021 20:12:21 +0300
Subject: [PATCH 05/20] multi_curve_fit seems to work now

---
 .../interleaved_rb_analysis.py                | 25 ++++++++++++++-----
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index c693d8ebeb..57e9774b04 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -12,6 +12,7 @@
 """
 Interleaved RB analysis class.
 """
+import numpy as np
 from typing import Optional, List
 from qiskit_experiments.analysis.curve_fitting import (
     process_multi_curve_data,
@@ -44,19 +45,31 @@ def data_processor(datum):
                                                        data_processor)
         xdata, ydata, ydata_sigma, series = mean_xy_data(x, y, sigma, series)
 
-        def fit_fun(x, a, alpha, b):
-            return a * alpha ** x + b
+        def fit_fun_standard(x, a, alpha_std, alpha_int, b):
+            return a * alpha_std ** x + b
+
+        def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
+            return a * alpha_int ** x + b
+
+        std_idx = (series == 0)
+        p0_std = self._p0(xdata[std_idx], ydata[std_idx])
+
+        int_idx = (series == 1)
+        p0_int = self._p0(xdata[int_idx], ydata[int_idx])
+
+        p0 = (np.mean([p0_std[0], p0_int[0]]),
+              p0_std[1], p0_int[1],
+              np.mean([p0_std[2], p0_int[2]]))
 
-        p0 = self._p0(xdata, ydata)
         analysis_result = multi_curve_fit(
-            [fit_fun, fit_fun],
+            [fit_fun_standard, fit_fun_interleaved],
             series,
             xdata,
             ydata,
             p0,
             ydata_sigma,
-            bounds=([0, 0, 0], [1, 1, 1])
+            bounds=([0, 0, 0, 0], [1, 1, 1, 1])
         )
-        return analysis_result
+        return analysis_result, None
 
 

From d609137e17a59dffb7347cd3bf673829b9200e37 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Wed, 28 Apr 2021 14:12:03 +0300
Subject: [PATCH 06/20] Anaylsis results for interleaved rb

---
 .../interleaved_rb_analysis.py                | 90 ++++++++++++++++++-
 1 file changed, 87 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 57e9774b04..bcbfe459a9 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -19,7 +19,7 @@
     multi_curve_fit,
 )
 
-from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.analysis.plotting import plot_curve_fit, plot_scatter, plot_errorbar
 from qiskit_experiments.analysis.data_processing import (
     level2_probability,
     mean_xy_data,
@@ -27,6 +27,13 @@
 )
 from .rb_analysis import RBAnalysis
 
+try:
+    from matplotlib import pyplot as plt
+
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
 class InterleavedRBAnalysis(RBAnalysis):
     """Interleaved RB Analysis class."""
 
@@ -52,10 +59,16 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
             return a * alpha_int ** x + b
 
         std_idx = (series == 0)
-        p0_std = self._p0(xdata[std_idx], ydata[std_idx])
+        std_xdata = xdata[std_idx]
+        std_ydata = ydata[std_idx]
+        std_ydata_sigma = ydata_sigma[std_idx]
+        p0_std = self._p0(std_xdata, std_ydata)
 
         int_idx = (series == 1)
-        p0_int = self._p0(xdata[int_idx], ydata[int_idx])
+        int_xdata = xdata[int_idx]
+        int_ydata = ydata[int_idx]
+        int_ydata_sigma = ydata_sigma[int_idx]
+        p0_int = self._p0(int_xdata, int_ydata)
 
         p0 = (np.mean([p0_std[0], p0_int[0]]),
               p0_std[1], p0_int[1],
@@ -70,6 +83,77 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
             ydata_sigma,
             bounds=([0, 0, 0, 0], [1, 1, 1, 1])
         )
+
+        # Add EPC data
+        nrb = 2 ** self._num_qubits
+        scale = (nrb - 1) / (2 ** nrb)
+        A, alpha, alpha_c, B = analysis_result["popt"]
+        A_err, alpha_err, alpha_c_err, B_err = analysis_result["popt_err"]
+
+        # Calculate epc_est (=r_c^est) - Eq. (4):
+        epc_est = scale * (1 - alpha_c / alpha)
+         # Calculate the systematic error bounds - Eq. (5):
+        systematic_err_1 = scale * (abs(alpha - alpha_c / alpha) + (1 - alpha))
+        systematic_err_2 = 2 * (nrb * nrb - 1) * (1 - alpha) / \
+                           (alpha * nrb * nrb) + 4 * (np.sqrt(1 - alpha)) * \
+                           (np.sqrt(nrb * nrb - 1)) / alpha
+        systematic_err = min(systematic_err_1, systematic_err_2)
+        systematic_err_l = epc_est - systematic_err
+        systematic_err_r = epc_est + systematic_err
+
+        alpha_err_sq = (alpha_err / alpha) * (alpha_err / alpha)
+        alpha_c_err_sq = (alpha_c_err / alpha_c) * (alpha_c_err / alpha_c)
+        epc_est_err = ((nrb - 1) / nrb) * (alpha_c / alpha) \
+                      * (np.sqrt(alpha_err_sq + alpha_c_err_sq))
+
+        analysis_result["EPC"] = epc_est
+        analysis_result["EPC_err"] = epc_est_err
+        analysis_result['systematic_err'] = systematic_err
+        analysis_result['systematic_err_L'] = systematic_err_l
+        analysis_result['systematic_err_R'] = systematic_err_r
+        analysis_result["plabels"] = ["A", "alpha", "alpha_c", "B"]
+
+        if plot:
+            ax = plot_curve_fit(fit_fun_standard, analysis_result, ax=ax)
+            ax = plot_curve_fit(fit_fun_interleaved, analysis_result, ax=ax)
+            ax = plot_scatter(std_xdata, std_ydata, ax=ax)
+            ax = plot_scatter(int_xdata, int_ydata, ax=ax)
+            ax = plot_errorbar(std_xdata, std_ydata, std_ydata_sigma, ax=ax)
+            ax = plot_errorbar(int_xdata, int_ydata, int_ydata_sigma, ax=ax)
+            self._format_plot(ax, analysis_result)
+            analysis_result.plt = plt
+
         return analysis_result, None
 
+    @classmethod
+    def _format_plot(cls, ax, analysis_result, add_label=True):
+        """Format curve fit plot"""
+        # Formatting
+        ax.tick_params(labelsize=14)
+        ax.set_xlabel("Clifford Length", fontsize=16)
+        ax.set_ylabel("Ground State Population", fontsize=16)
+        ax.grid(True)
 
+        if add_label:
+            alpha = analysis_result["popt"][1]
+            alpha_c = analysis_result["popt"][2]
+            alpha_err = analysis_result["popt_err"][1]
+            alpha_c_err = analysis_result["popt_err"][2]
+            epc = analysis_result["EPC"]
+            epc_err = analysis_result["EPC_err"]
+            box_text = "\u03B1:{:.4f} \u00B1 {:.4f}".format(alpha, alpha_err)
+            box_text += "\n\u03B1_c:{:.4f} \u00B1 {:.4f}".format(alpha_c, alpha_c_err)
+            box_text += "\nEPC: {:.4f} \u00B1 {:.4f}".format(epc, epc_err)
+            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black",
+                              lw=1)
+            ax.text(
+                0.6,
+                0.9,
+                box_text,
+                ha="center",
+                va="center",
+                size=14,
+                bbox=bbox_props,
+                transform=ax.transAxes,
+            )
+        return ax

From 56e3bb3596ab2c9a2348e55dc27ec908bd45605a Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Wed, 28 Apr 2021 14:41:05 +0300
Subject: [PATCH 07/20] Linting

---
 .../interleaved_rb_analysis.py                | 58 ++++++++++---------
 .../interleaved_rb_experiment.py              | 23 ++++----
 .../randomized_benchmarking/rb_analysis.py    |  3 +-
 3 files changed, 44 insertions(+), 40 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index bcbfe459a9..64449c39fc 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -12,8 +12,8 @@
 """
 Interleaved RB analysis class.
 """
-import numpy as np
 from typing import Optional, List
+import numpy as np
 from qiskit_experiments.analysis.curve_fitting import (
     process_multi_curve_data,
     multi_curve_fit,
@@ -23,7 +23,6 @@
 from qiskit_experiments.analysis.data_processing import (
     level2_probability,
     mean_xy_data,
-    filter_data,
 )
 from .rb_analysis import RBAnalysis
 
@@ -34,22 +33,23 @@
 except ImportError:
     HAS_MATPLOTLIB = False
 
+
 class InterleavedRBAnalysis(RBAnalysis):
     """Interleaved RB Analysis class."""
 
+    # pylint: disable=invalid-name, unused-variable, unused-argument, attribute-defined-outside-init
     def _run_analysis(
-            self,
-            experiment_data,
-            p0: Optional[List[float]] = None,
-            plot: bool = True,
-            ax: Optional["AxesSubplot"] = None,
+        self,
+        experiment_data,
+        p0: Optional[List[float]] = None,
+        plot: bool = True,
+        ax: Optional["AxesSubplot"] = None,
     ):
         def data_processor(datum):
-            return level2_probability(datum, datum['metadata']['ylabel'])
+            return level2_probability(datum, datum["metadata"]["ylabel"])
 
         self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
-        series, x, y, sigma = process_multi_curve_data(experiment_data.data,
-                                                       data_processor)
+        series, x, y, sigma = process_multi_curve_data(experiment_data.data, data_processor)
         xdata, ydata, ydata_sigma, series = mean_xy_data(x, y, sigma, series)
 
         def fit_fun_standard(x, a, alpha_std, alpha_int, b):
@@ -58,21 +58,24 @@ def fit_fun_standard(x, a, alpha_std, alpha_int, b):
         def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
             return a * alpha_int ** x + b
 
-        std_idx = (series == 0)
+        std_idx = series == 0
         std_xdata = xdata[std_idx]
         std_ydata = ydata[std_idx]
         std_ydata_sigma = ydata_sigma[std_idx]
         p0_std = self._p0(std_xdata, std_ydata)
 
-        int_idx = (series == 1)
+        int_idx = series == 1
         int_xdata = xdata[int_idx]
         int_ydata = ydata[int_idx]
         int_ydata_sigma = ydata_sigma[int_idx]
         p0_int = self._p0(int_xdata, int_ydata)
 
-        p0 = (np.mean([p0_std[0], p0_int[0]]),
-              p0_std[1], p0_int[1],
-              np.mean([p0_std[2], p0_int[2]]))
+        p0 = (
+            np.mean([p0_std[0], p0_int[0]]),
+            p0_std[1],
+            p0_int[1],
+            np.mean([p0_std[2], p0_int[2]]),
+        )
 
         analysis_result = multi_curve_fit(
             [fit_fun_standard, fit_fun_interleaved],
@@ -81,7 +84,7 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
             ydata,
             p0,
             ydata_sigma,
-            bounds=([0, 0, 0, 0], [1, 1, 1, 1])
+            bounds=([0, 0, 0, 0], [1, 1, 1, 1]),
         )
 
         # Add EPC data
@@ -92,25 +95,27 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
 
         # Calculate epc_est (=r_c^est) - Eq. (4):
         epc_est = scale * (1 - alpha_c / alpha)
-         # Calculate the systematic error bounds - Eq. (5):
+        # Calculate the systematic error bounds - Eq. (5):
         systematic_err_1 = scale * (abs(alpha - alpha_c / alpha) + (1 - alpha))
-        systematic_err_2 = 2 * (nrb * nrb - 1) * (1 - alpha) / \
-                           (alpha * nrb * nrb) + 4 * (np.sqrt(1 - alpha)) * \
-                           (np.sqrt(nrb * nrb - 1)) / alpha
+        systematic_err_2 = (
+            2 * (nrb * nrb - 1) * (1 - alpha) / (alpha * nrb * nrb)
+            + 4 * (np.sqrt(1 - alpha)) * (np.sqrt(nrb * nrb - 1)) / alpha
+        )
         systematic_err = min(systematic_err_1, systematic_err_2)
         systematic_err_l = epc_est - systematic_err
         systematic_err_r = epc_est + systematic_err
 
         alpha_err_sq = (alpha_err / alpha) * (alpha_err / alpha)
         alpha_c_err_sq = (alpha_c_err / alpha_c) * (alpha_c_err / alpha_c)
-        epc_est_err = ((nrb - 1) / nrb) * (alpha_c / alpha) \
-                      * (np.sqrt(alpha_err_sq + alpha_c_err_sq))
+        epc_est_err = (
+            ((nrb - 1) / nrb) * (alpha_c / alpha) * (np.sqrt(alpha_err_sq + alpha_c_err_sq))
+        )
 
         analysis_result["EPC"] = epc_est
         analysis_result["EPC_err"] = epc_est_err
-        analysis_result['systematic_err'] = systematic_err
-        analysis_result['systematic_err_L'] = systematic_err_l
-        analysis_result['systematic_err_R'] = systematic_err_r
+        analysis_result["systematic_err"] = systematic_err
+        analysis_result["systematic_err_L"] = systematic_err_l
+        analysis_result["systematic_err_R"] = systematic_err_r
         analysis_result["plabels"] = ["A", "alpha", "alpha_c", "B"]
 
         if plot:
@@ -144,8 +149,7 @@ def _format_plot(cls, ax, analysis_result, add_label=True):
             box_text = "\u03B1:{:.4f} \u00B1 {:.4f}".format(alpha, alpha_err)
             box_text += "\n\u03B1_c:{:.4f} \u00B1 {:.4f}".format(alpha_c, alpha_c_err)
             box_text += "\nEPC: {:.4f} \u00B1 {:.4f}".format(epc, epc_err)
-            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black",
-                              lw=1)
+            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black", lw=1)
             ax.text(
                 0.6,
                 0.9,
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
index 3b67d138fd..bc9254d095 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_experiment.py
@@ -14,7 +14,7 @@
 """
 from typing import Union, Iterable, Optional, List
 
-from numpy.random import Generator, default_rng
+from numpy.random import Generator
 
 from qiskit import QuantumCircuit
 from qiskit.circuit import Instruction
@@ -32,8 +32,7 @@ class InterleavedRBExperiment(RBExperiment):
 
     def __init__(
         self,
-        interleaved_element:
-        Union[QuantumCircuit, Instruction, Clifford],
+        interleaved_element: Union[QuantumCircuit, Instruction, Clifford],
         qubits: Union[int, Iterable[int]],
         lengths: Iterable[int],
         num_samples: int = 1,
@@ -42,7 +41,7 @@ def __init__(
     ):
         """Interleaved randomized benchmarking experiment
         Args:
-            interleaved_element: the element to interleave, 
+            interleaved_element: the element to interleave,
                     given either as a group element or as an instruction/circuit
             qubits: the number of qubits or list of
                     physical qubits for the experiment.
@@ -61,22 +60,22 @@ def __init__(
 
     def _sample_circuits(self, lengths, seed=None):
         circuits = []
-        for length in (lengths if self._full_sampling else [lengths[-1]]):
+        for length in lengths if self._full_sampling else [lengths[-1]]:
             elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
             element_lengths = [len(elements)] if self._full_sampling else lengths
             std_circuits = self._generate_circuit(elements, element_lengths)
             for circuit in std_circuits:
-                circuit.metadata['series'] = 0
-                circuit.metadata['series_name'] = 'standard'
+                circuit.metadata["series"] = 0
+                circuit.metadata["series_name"] = "standard"
             circuits += std_circuits
 
             int_elements = self._interleave(elements)
             int_elements_lengths = [length * 2 for length in element_lengths]
             int_circuits = self._generate_circuit(int_elements, int_elements_lengths)
             for circuit in int_circuits:
-                circuit.metadata['series'] = 1
-                circuit.metadata['series_name'] = 'interleaved'
-                circuit.metadata['xval'] = circuit.metadata['xval'] // 2
+                circuit.metadata["series"] = 1
+                circuit.metadata["series_name"] = "interleaved"
+                circuit.metadata["xval"] = circuit.metadata["xval"] // 2
             circuits += int_circuits
         return circuits
 
@@ -86,9 +85,9 @@ def _interleave(self, element_list: List) -> List:
             element_list: The list of elements we add the interleaved element to
         Returns:
             The new list with the element interleaved
-            """
+        """
         new_element_list = []
         for element in element_list:
             new_element_list.append(element)
             new_element_list.append(self._interleaved_element)
-        return new_element_list
\ No newline at end of file
+        return new_element_list
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 60c9a28416..40b4e3be52 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -101,7 +101,8 @@ def _p0(self, xdata, ydata):
     def _extract_data(self, experiment_data, **filters):
         """Extract the base data for the fitter from the experiment data.
         Args:
-            data: the experiment data to analyze
+            experiment_data (ExperimentData): the experiment data to analyze
+            filters: parameters for filtering the data
         Returns:
             tuple: ``(xdata, ydata, ydata_sigma)`` , where
                ``xdata`` is an array of unique x-values, ``ydata`` is an array of

From 27a1216f92d6ee3f63878b58d466276065687b16 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Wed, 28 Apr 2021 15:43:23 +0300
Subject: [PATCH 08/20] Linting

---
 .../analysis/data_processing.py               | 12 ++++----
 test/test_curve_fitting.py                    | 28 +++++++++----------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 7de9ba80b8..68b476c99c 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -47,11 +47,11 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
 
 
 def mean_xy_data(
-        xdata: np.ndarray,
-        ydata: np.ndarray,
-        sigma: Optional[np.ndarray] = None,
-        series: Optional[np.ndarray] = None,
-        method: str = "sample"
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    series: Optional[np.ndarray] = None,
+    method: str = "sample",
 ) -> Tuple[np.ndarray]:
     r"""Return (x, y_mean, sigma) data.
 
@@ -89,7 +89,7 @@ def mean_xy_data(
         raise QiskitError(
             "The inverse-weighted variance method cannot be used with" " `sigma=None`"
         )
-    if not method in ["sample", "iwv"]:
+    if method not in ["sample", "iwv"]:
         raise QiskitError(f"Unsupported method {method}")
     xseries = series if series is not None else np.zeros(xdata.size)
     x_keys = np.unique(np.column_stack((xdata, xseries)), axis=0)
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 51a3ec6f83..d1eab5144c 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -110,35 +110,35 @@ def test_multi_curve_fit(self):
         self.assertTrue(abs(sol["popt"][0] - 0.5) < 0.05)
 
     def test_mean_xy_data(self):
-        x = np.array([1,1,1,2,2,2,2,3,3,4,5,5,5,5])
-        y = np.array([1,2,3,8,10,50,60,10,11,17,10,10,10,10])
+        """Test mean_xy_data function"""
+        x = np.array([1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 5, 5, 5])
+        y = np.array([1, 2, 3, 8, 10, 50, 60, 10, 11, 17, 10, 10, 10, 10])
         x_mean, y_mean, y_sigma = mean_xy_data(x, y, method="sample")
 
-        expected_x_mean = np.array([1,2,3,4,5])
+        expected_x_mean = np.array([1, 2, 3, 4, 5])
         expected_y_mean = np.array([2, 32, 10.5, 17, 10])
-        expected_y_sigma = np.array([2/3, 542, 1/4, 0, 0])
+        expected_y_sigma = np.array([2 / 3, 542, 1 / 4, 0, 0])
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
 
-        sigma = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14])
+        sigma = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
         x_mean, y_mean, y_sigma = mean_xy_data(x, y, sigma, method="iwv")
-        expected_y_mean = np.array([1.34693878, 23.31590234, 10.44137931, 17., 10.])
-        expected_y_sigma = np.array([0.85714286, 2.57610543, 5.97927455, 10., 6.17470935])
+        expected_y_mean = np.array([1.34693878, 23.31590234, 10.44137931, 17.0, 10.0])
+        expected_y_sigma = np.array([0.85714286, 2.57610543, 5.97927455, 10.0, 6.17470935])
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
 
-        x = np.array([1,1,1,1,2,2,2,2])
-        y = np.array([2,6,100,200,17,50,60,70])
-        series = np.array([0,0,1,1,0,1,1,1])
+        x = np.array([1, 1, 1, 1, 2, 2, 2, 2])
+        y = np.array([2, 6, 100, 200, 17, 50, 60, 70])
+        series = np.array([0, 0, 1, 1, 0, 1, 1, 1])
         x_mean, y_mean, y_sigma, series = mean_xy_data(x, y, method="sample", series=series)
-        expected_x_mean = np.array([1,1,2,2])
+        expected_x_mean = np.array([1, 1, 2, 2])
         expected_y_mean = np.array([4, 150, 17, 60])
-        expected_y_sigma = np.array([4., 2500., 0., 66.66666667])
-        expected_series = np.array([0,1,0,1])
+        expected_y_sigma = np.array([4.0, 2500.0, 0.0, 66.66666667])
+        expected_series = np.array([0, 1, 0, 1])
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
         self.assertTrue(np.allclose(expected_series, series))
-

From 9804762468bba15da1e3e08c9ba40264b1fd5f45 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Wed, 28 Apr 2021 15:58:01 +0300
Subject: [PATCH 09/20] Linting

---
 test/test_curve_fitting.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index d1eab5144c..38879167bf 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -111,6 +111,7 @@ def test_multi_curve_fit(self):
 
     def test_mean_xy_data(self):
         """Test mean_xy_data function"""
+        # pylint: disable=unbalanced-tuple-unpacking
         x = np.array([1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 5, 5, 5])
         y = np.array([1, 2, 3, 8, 10, 50, 60, 10, 11, 17, 10, 10, 10, 10])
         x_mean, y_mean, y_sigma = mean_xy_data(x, y, method="sample")

From fdf9deb606f609344a6a34d5f953821e2b5e74f5 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Wed, 28 Apr 2021 17:04:47 +0300
Subject: [PATCH 10/20] Added interleaved RB to the notebook

---
 .../randomized_benchmarking/rb_example.ipynb  | 315 +++++++++++++-----
 1 file changed, 229 insertions(+), 86 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
index 950e97d95c..941588f546 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
+++ b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
@@ -17,6 +17,7 @@
    "source": [
     "import numpy as np\n",
     "import qiskit_experiments as qe\n",
+    "import qiskit.circuit.library as circuits\n",
     "rb = qe.randomized_benchmarking\n",
     "\n",
     "# For simulation\n",
@@ -41,23 +42,23 @@
       "text/plain": [
        "---------------------------------------------------\n",
        "Experiment: RBExperiment\n",
-       "Experiment ID: ad68c446-7cb4-4b89-8c75-520b0b83902d\n",
+       "Experiment ID: 792f7a4b-4fa6-4a10-923e-df96eae4d8a0\n",
        "Status: COMPLETE\n",
        "Circuits: 140\n",
        "Analysis Results: 1\n",
        "---------------------------------------------------\n",
        "Last Analysis Result\n",
-       "- popt: [0.39686901 0.9968324  0.56018556]\n",
+       "- popt: [0.46242383 0.99615594 0.52058961]\n",
        "- popt_keys: None\n",
-       "- popt_err: [0.00930198 0.00012858 0.00957537]\n",
-       "- pcov: [[ 8.65267737e-05  1.15558772e-06 -8.88173704e-05]\n",
-       " [ 1.15558772e-06  1.65327564e-08 -1.20201428e-06]\n",
-       " [-8.88173704e-05 -1.20201428e-06  9.16877962e-05]]\n",
-       "- reduced_chisq: 388.46076795461363\n",
+       "- popt_err: [1.68690459e-04 2.71196427e-06 1.71806389e-04]\n",
+       "- pcov: [[ 2.84564709e-08  4.24770960e-10 -2.88930652e-08]\n",
+       " [ 4.24770960e-10  7.35475018e-12 -4.38101233e-10]\n",
+       " [-2.88930652e-08 -4.38101233e-10  2.95174352e-08]]\n",
+       "- reduced_chisq: 1113.6527324644458\n",
        "- dof: 11\n",
-       "- xrange: [1, 500]\n",
-       "- EPC: 0.0015838000563520027\n",
-       "- EPC_err: 6.449417510365912e-05\n",
+       "- xrange: [1.0, 500.0]\n",
+       "- EPC: 0.0019220290414467822\n",
+       "- EPC_err: 1.3612147214267936e-06\n",
        "- plabels: ['A', 'alpha', 'B']"
       ]
      },
@@ -67,7 +68,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABbYklEQVR4nO2dd3hUVdrAf+9kMplJoYRACDUgiqCCAipNmihqBJG1N3BVZBXLx+664q7dta+KigUsiKKoYAUUUECUpiAiiqACoYbeEiD9/f44M8kkZMJNMoGQnN/z3Ccz55577jmT5L5z3iqqisVisVgsTnAd7QlYLBaL5djBCg2LxWKxOMYKDYvFYrE4xgoNi8VisTjGCg2LxWKxOMZ9tCdQmSQkJGhycnK5rt2/fz8xMTHhnVAVx665ZmDXXDOoyJqXLFmyQ1Xrl3SuWguN5ORkFi9eXK5r58yZQ69evcI7oSqOXXPNwK65ZlCRNYvIulDnrHrKYrFYLI6p1jsNS/UmOTmZdetCfiGyWI4IzZs3JzU19WhP44hhhYblmGXdunXYjAaWo42IHO0pHFGsespisVgsjrFCw2KxWCyOsULDYrFYLI6xQsNisVgsjrFCw2IpBy+99BItWrTA6/XSsWNHvv3228NeM3r0aNq0aYPP56N169aMHz++yPmcnBweeughjjvuOLxeL+3bt+fLL788ZJy0tDQGDx5M/fr18Xq9tG3blm+++abgfEZGBrfddhtNmjQpuNezzz5b8UUfhvXr19O/f39iYmJISEjg9ttvJzs7u9RrsrKyuO2220hISCAmJoYBAwawcePGMo/7zTff0LFjR7xeLy1btuSVV14pcn7u3LkMGDCAxo0bIyKMGzcuLGuukahqtT06duyo5WX27Nm6d2+5Lz8mmT179tGeQpkwf75HnokTJ6rb7dYxY8boihUrdPjw4RoTE6Pr1q0Lec1LL72kMTEx+u677+rq1av1vffe09jYWP3ss88K+tx1113asGFDnTJliq5evVpfeukl9Xq9+uOPPxb02b17t7Zo0UKvvfZaXbRoka5Zs0a/+uorXbFiRUGfm266SVu0aKGzZs3StWvX6ltvvaUej0fHjx/veI1vvvmm9uzZ03H/3NxcPfnkk7Vnz566ZMkSnTFjhiYlJenw4cNLvW7YsGGalJSkM2bM0CVLlmjPnj21ffv2mpub63jcNWvWaHR0tA4fPlxXrFihY8aMUbfbrZMmTSroM3XqVB05cqR++OGH6vP59M0333S8tsNxtP4OD0dF/p+BxRriuXrUH+yVeVREaMyaNVtXrNAaJThqmtDIyMjQm266SWvVqqX16tXTe+65R9PT0zU6OlpTU1NDXnfGGWfojTfeWKStVatWevfdd4e8pkuXLnrnnXcWaRsxYoR269at4H1SUpI+99xzRfoMGjRIr7766oL3I0eO1K5du5a6rpNOOknvu+++Im09evTQW2+9tdTrgimr0Jg2bZqKiK5fv76g7e2339aoqCjdG+KfaM+ePRoZGanvvPNOQdv69etVRPTLL790PO5dd92lrVq1KjL2DTfcoJ07dy7xvjExMVZoHIbShIZVTx2GzZvhwIGjPQtLZfDXv/6VWbNm8dVXX/Hee+8xatQohg8fzoknnkjz5s0BSE1NLaLOyM7OZsmSJZx77rlFxjr33HOZP39+yHtlZWXh9XqLtPl8Pr7//ntycnJK7fPdd98VvP/kk08488wzufzyy2nQoAGnnnoqL774YpF4le7du/P555+zYcMGAObPn89PP/3EeeedV8ZPyDkLFiygTZs2NG3atKCtX79+ZGVlsWTJkhKvWbJkCTk5OUU+y6ZNm9KmTZuCz9LJuAsWLDjk99GvXz8WL15c8NlawocVGqUQEQHR0bBhA2RmHu3ZWMLJjh07+PDDD7n//vs5/fTTOeecc7jssst46623uPjiiwv6RUZG0rp1a2rXrl1wXV5eHomJiUXGS0xMZMuWLSHv169fP9544w1++OEHVJXFixfz2muvkZOTw44dOwr6PPfcc6xatYr8/HxmzpzJRx99RFpaWsE4a9as4aWXXqJly5ZMnz6dO+64g7vvvpvRo0cX9Hn++edp3749zZo1IzIykp49e/LEE09w4YUXhpzft99+S2xsbMExbNiwQ9oeffTRkNdv2bLlkM8kISGBiIiIkJ/Lli1biIiIICEhIeRn6WTckvokJiaSm5tb8NlawofjiHARGQxcCTQDvMVOq6oeF86JVRXcboiKgo0boXlziIw82jOyhIM///wTVaVLly4FbWeeeSZvvvkmgwYNKmhr3LgxK1eurPD97r33XrZs2ULXrl1RVRITExk8eDBPPvkkLpf57jZq1Chuuukm2rZti4hw3HHHcf311/PGG28UjJOfn0+nTp147LHHADjttNP4448/GD16NMOHDwfghRdeYP78+Xz22Wc0b96cuXPn8o9//IPk5OSQu41OnTrx008/Fbz/6KOPmDx5MhMmTChoi4+Pr/DnYDn2cbTTEJF7gTeBRsBPwDfFjrmVNL8qgccDLpfZceTmHu3ZWMJBVFQUAB6Pp6AtMTGRunXr0rZt25DXBb7lbt26tUj71q1badiwYcjrfD4fb7zxBgcOHCA1NZX169eTnJxMXFwc9eubDNT169fnk08+Yf/+/axbt46VK1cSGxtLy5YtC8ZJSko6ZH5t2rRh/fr1ABw8eJCRI0fy5JNP0r9/f9q1a8fw4cO54oorePrpp0udX6tWrQqOBg0aHNJWmtBo2LDhIZ9JYFcW6nNp2LAheXl5h+wGgj9LJ+OW1Gfr1q243e5DdjGWiuNUPXUDMEpV26nqVap6ffGjMidZFfB6QdXYOPLzj/ZsLBWlRYsWuFwu/vjjj4K2zz77jN27d7N3796Q13k8Hjp27MjMmTOLtM+cOZOuXbse9r6RkZE0adKEiIgIJk6cyIUXXliw0wjg9Xpp3Lgxubm5TJ48mYsuuqjgXLdu3Vi1alWR/r///nuBDSYnJ4ecnBwiIiKK9ImIiCC/Ev9wu3Tpwm+//VbEXXbmzJlERUXRsWPHEq/p2LEjkZGRRT7LjRs38ttvvxV8lk7G7dKlS4m/j06dOhFpVQPhJ5SFPPgA0oE+TvpWpaO83lP5+fk6a9ZsXbVKddMm1Y0b83XTJvP6999VN25Uzc8v19BVmprmPXXJJZdonz59dP/+/bpy5UqNi4vTRo0a6dtvv13QZ+PGjdq6dWv96KOPCtomTpyokZGROnbsWF2xYoXefvvtGhMTU8Tj6tprr9Vrr7224P2qVat0/Pjx+vvvv+uiRYv08ssv1/j4eF27dm1Bn4ULF+rkyZN19erVOnfuXO3Tp4+2aNFCd+/eXdDn+++/V7fbrY888oj+8ccf+sEHH2itWrX0xRdfLOjTs2dPPemkk3T27Nm6Zs0affPNN9Xr9erzzz8f8rPIysrStLS0Uo/09PSQ1wdcY3v37q0//vijzpw5Uxs1alTENXbRokXaunVrXbRoUUHbsGHDtHHjxjpz5kz98ccftVevXiW63JY2bsDl9o477tAVK1bo2LFjNTIysojLbXp6ui5dulSXLl2qPp9PH3zwQV26dGmpbtJOqejfYWVxVF1ugSnA/znpW5WO8giN2bNn6xdffKHffjhZ102cr5t/3KyTJn2hn302u0BwrFypumVL9RMcNU1obN26VQcOHKjx8fEaHx+v//vf/3TatGnaqFEjvf/++1VVde3atQoc4qI5evRobd68uXo8Hu3QoYN+8803Rc737NmziMvqihUr9NRTT1Wfz6e1atXSiy66SFeuXFnkmjlz5mibNm00KipK69Wrp9dee61u2rTpkHlPmTJF27Vrp1FRUXr88cfrqFGjND/ojzEtLU2HDBmijRo1Uq/Xq61bt9annnqqSJ/izJ49W4FSj8BnEop169ZpSkqK+nw+jY+P19tuu00zMzMPuUfw31lmZqYOHz5c4+Pj1efz6YUXXljEvdbJuIHP7rTTTlOPx6PJycn68ssvO1rf4MGDS12TE2qa0BBzvnREpBXwEfA0MA3YVcKOpcopbTp16qRlqdynqkyfPp0DY8bQf8o0XFFRaHYmn6WkoFcPpXPnfgVpkPftg4QEc1QXjrXqZiKCk79fi6Uyqap/hxWs3LdEVTuVdM6p99Tv/p9vhjivZRiryiIi9GvfnpzPpxGZmwU5WQAMmDqV7feORoPy5sfFwY4dxi23bt2jNWOLxWI5sjh90D+EEQzVHklNxRUVBblZBW2uKB/uDankJCYV9hOIjYWtW43gqFXraMzWYrFYjiyOhIaqPlDJ86gyaHIyklM0ki9//wFymyYf0tflMoJj8+bC1xaLxVKdKXNEuIjEikhTEal2j0hVZfqyZXyakkKux0Ompxb5CHn5MHX0tBL1li4XxMTApk1w8OBRmLTFYrEcQRwLDRHpJyKLgT1AKrBHRL4XkXMqaW5HHBHB6/USPXQoCye8x7bxX/LAxcvYQDNqj5vBH3+UXAs4IgJ8PptuxGKxVH+cRoT3A6YCscDDwC3AI0AcMK06CY5evXrRr18/curFk3laF24adQoP9JrD1Xlvc801ECq9kNttIsc3bICsrJL7WCqfIUOGICKHHJ07dy7ok5ycXNAeHR3NySefzJgxY4qMk52dzVNPPcVpp51GdHQ08fHxdO7cmVdffZWsMv6CD1froSSOZA2J33//nUGDBlGnTh2io6Pp0KEDv/32W5nWWFZs7Y1jF6c7jQeAGUBbVX1QVV/12zlOAmYCD1bO9I4OEuQlFREBD77WhHYdPWRt2s76PkPYv2lPidd5PEZ4bNwINrnm0aNv376kpaUVOaZNm1akz3333UdaWho///wzAwcO5Oabb+b9998HjMDo168f//3vf7n++uuZN28eS5YsYcSIEbz55pssWLDA8VzWrl3LBRdcQNeuXVm6dCkjR47ktttuY/LkySGvycvLIyUlhfT0dL799lvee+89Jk2axN///vcyjZuRkcHJJ5/MqFGj8Pl8IefXrVs3WrRowaxZs/jll1945JFHiC2DgW7cuHFlcu10sr6SuPPOO5k8eTLvvfce3377Lfv27ePCCy8kLy/P8bjh+txqNKECOIIP4ACQEuLchcABJ+Mc6aOi9TQCEeGbNqkuX656ecM5mkWkLq3dQ1NXHiw4V/xYvdocOTnlvv1RoToE9w0ePFhTUlJKva558+b61FNPFWk7/vjj9YorrlBV1SeeeEJFRH/44YdDrs3LywtZH6IkylrrQfXI1pC48sor9aqrrnK6nBKp6bU3Svo7rAoc7XoaWUAop9I4//lqTXw83PFRT26NG8+pe+eyuc81aG5eiX0Deao2brQJDo8VvF5vQe2FCRMm0LdvXzp1OjS2yeVyUcvvXz1u3DhEhNTU1JDjlqfWw5GqIZGfn8/nn39O27ZtOe+886hfvz6nn356wY6rsrC1N45tnAqNOcDDItIiuFFEmmFUV7PDO62qSfPmMOj9K7gr8lm6bJ7M6pTbjXQoAZ8P8vKMV1VeybLFUkl8+eWXRepAxMbG8q9//avEvrm5uYwbN47ly5dz9tlnA/DHH3/Qpk2bw96ndu3atG7dutSkeOWp9XCkakhs27aNjIwMHn30Uc4991xmzpzJlVdeydVXX83UqVNDXmdrb9RsnAb3/QuYB6wSkYVAGtAQ6Izxpir5P7Ia0r497HrzTp66No2Bv3zEOy/s4prb6xWcV9UCm4jPZ9xwN2+GRo2MfcRS+fTo0eMQw3adOnWKvP/3v//NAw88QFZWFh6Ph3/+85/cfPPNAI5TQlx88cVFCjYdawSy3l500UWMGDECgFNPPZXFixfz4osvkpKSUuJ1tvZGzcZpcN/vItIO+DtwFtABk39qFPCsqqaVdv2xSqhnR+/e8MHTj3HG3+9m75N1aFAnjZS2qeQ2TWbBmmV4PF46duwFGMFx4IARHI0bm7gOS+USHR1Nq1atSu0zYsQIbrjhBqKjo0lKSiri/HDCCSeEzXuoPLUeGjZsyLx584q0VUYNiYSEBNxud4n1OSZOnBjyukCdjQDBtTec4GR9JV0TqL0RqD8CZs1nnXWW43Ft7Y2K4/gRpqppqvoPVT1TVY/3/7yrugoMEbMzCKXmvPRyIeXqbVyr47hmZFPqXtqX+p2TkQljyM7OLPJtNTraxG+kpdlaHFWFevXq0apVKxo1alREYABcddVVfPXVV5SU7DI/P599+/Y5vk95aj0cqRoSHo+H008/vdT6HJWBrb1xjBPKQl4djop4T82ePVsPHjRp0NevL9lLatOSzZrpilI1mxJV0ByPRzf/uLnE/gFvrLy8ck+rUqku3lN9+/Y9pBbEtm3bCvqU5D0VTGZmpp511llap04dHTVqlC5dulTXrFmjkydP1i5duhR8Th999JG2bt1aN27cGHIsJ7UeXnjhBW3dunXB+yNZQ+Ljjz/WyMhIffXVV/WPP/7QMWPGqNvt1ilTpoRck629UZSS/g6rAke8ngYwCzgx6HVpx9ehxjmaR0WFhqrqvn2qv/1mCi8VFwLbPp2veXG1igqN6Djd9un8kO64q1apbt5cNWtxVBehQQl1Exo3blzQ53BCQ9UIjscff1zbtWunXq9X69Spo2eeeaa+8sormpWVparG1RQoUkipJA5X6+H+++8/ZC1HsobEm2++qccff7x6vV495ZRT9N133y11Pbb2RlFqmtAIWU9DRGYDf1PVlSIyh8NkuVXV3o62NkeQstbTCCY4F/2uXbBt26GZbGVrGvU7J+MOijjNw8Xyz9fSoEOzkGNnZJjU6g0bGjVYVcHW07BYyk5V/Ts84vU0goWAqpbvztWEunWNbWPv3sJMtqrKgjXLkJQUBkydinh85GUcIJcI/nnDZp75qin16pUsEWJjTREnEUhMrFqCw2KxWErDae6p60SkXohz8SJyXXinVbUQgQYNTDbbAwcCbYLH40WvHsr2hansmvAFa2avo1vjFXy1rTPXXitkZIQeMy7OCKFt20J7aVksFktVw6n31JvAcSHOtSB0Rb9qg4hRJ7ndhSnQO3bsRefO/dDEJHI6daHWCUm8/lkyzZoqPZeN4sm/LCo1XXpcHOzZYwWHxWI5dnAqNEpToMQANSJZRkSEibUACJgxirtrNmwofPBGBn93PceDvwzinuvTSk1eaAWHxWI5lghp0xCRUzFBfAH6i8jJxbr5gCuAP8I/tapJZCQ0aQLr1plAPXcJn2DTtnFsfPVTTrqpC3d8+xf+cdtsnhkdFTIiPCA4VK2Nw2KxVG1Kiwi/CLjf/1qBf4fotxO4IZyTqupERRnBsX69MWqXFOXd5IJ2rLp7HF0fv4xfPx/OyLgxPPGkhBQIARsHWMHhlObNmx+y07NYjjSVGQhZFSlNPfUcxl7REqOeGuR/H3w0Ahqo6meVO82qR3S0ySeVkRFardTwtktZefFIbuB1fnl3GfffX7oKKiA4tmyxqionpKamVjiWZ/bs2Uc9nuhIH3bN4T1Ky3JcHSnN5XYvsBfAn902TVVLL61Vw6hVy6Q+37bNPPBL+tJba9TDzGg/gBX/PZVlrxsPrBAJVwEzTnq6eZ2YaHNVWSyWqoWjR5KqrrMCo2Ti46FevcIH/SFERNDups68/DKc6/qKj57fwKhRpY8ZG2vGs7mqLBZLVcPx91gRGSoiS0XkgIjkFT8qc5JVnYQEqF2bUuMyLui+j0+9l/ExF/P8kwd59VXTrlqyHio2Fvbvt4LDYrFULRwH9wEvAD8AXkxcxjvAPmA18FBlTfBYIBDZHUiDXhIaV4ufR/yDTixhPNcy46H5fPB8GgsXTmfJkjklXhMba8azhZwsFktVwelO407gMeBv/vcvqepgjJH8IMaDqkbjchnDeHDwXzCqyoZTO7CiTRsuZTKzOJuhTxzHukemH5JKPZiYGMjKsoLDYrFUDZwKjeOBuUC+//AAqOpu4L/AHZUyu2OMiAjjiitiHvTBiAhdW7bnhNWrAfCRSTQHGfbTq2z7uX2prqPR0Sb3la05brFYjjZOhcZBwKXm6/AWzA4jQAbG9dYxInKLiKwVkUwRWSIiZx2m/60i8puIHBSRVVU515XbbQRHXl5h1HjBuQ2puKK8Rdqy8fD2Q6l88EHp4/p8RmBs3Bi6MJTFYrFUNk6FxnIgUMvxW+AeEekiIqcDDwArnd5QRC7HlIl9FDgNmA98ISIl5hIXkb8BT2DsJidhAg5Hi0h/p/c80ng80LSpERrBD/jcpsnkZ2UW6RvtOkhbfmHECJg0qfRxfT4jjDZsOFQgWSwWy5HAqdAYA9T1v74XiAW+AxYCJ2BqhztlBDBOVceq6m+qehuQRqG9pDjXAmNV9T1VXaOqE/3zKSXa4egTFWUER2am2SGoKvPXLOOzlBRyPR7y42qT6/GwrWECY2QYV+i73HmnM8EBRnAUV4FZLBZLZROyCFOpF4nEAF2AaGC+qu5weJ0HOABcqaofBrWPBk5W1Z4lXLMEmKGqI4PaHgHuAmJUNadY/6HAUIDExMSOEydOLOvyAMjIyCA2UDyjAuTnm11BRAQcOJCBaj51s3LxbUnjYMMk9mkunf/7CPV+/ZXr9C3elav55z9X0rfv1lLHVX+pQI8nfClHwrXmYwm75pqBXXPZ6N27d9mLMJWGqu4HvirHpQlABFD8ibgV6BvimunADSLyEbAY6AjcCET6x0srNrcxmJ0InTp10vJWrgpnFbv0dOP9FBsLIlrE6K2q5H6cQs7g/oyffx0uzeepp64jKakNl11W+rg5OWYn07SpMZZXlGOtcl84sGuuGdg1h4+Q6ikRaVaWI+wzK+RhYCrG9pEDfAq85T93TIS9xcVBUlIgT1XRbYGIoNEx7Bo/hZzuffhP8juoKiNGwOE2SZGRRl21YUPpgYUWi8USLkrbaaRymLrgxQiR+LsIO4A8ILFYeyLGK+sQVPUg8FcRudnfLw2jfkoHtpdhfkeV2rWNqmrr1pLzVKkvmp3jPicO5Z43hCcezeXvf3eTmwvXXBN6XLfb7DI2bjRxIsXrmFssFks4KU1o/JWyCY3DoqrZfhvFOcCHQafOASYf5tocYCOAiFwBTFHVY2KnEaBuXWOHCJng0OdDgeHX7WPYW/14cNMN/OtfN5KbC0OGhB43IsKovjZtMkb3+PhKXITFYqnRlJbldlwl3fMZ4G0R+R6YBwzDxHm8AiAi4/33v87//gTgTIynVl2M99XJwOBKml+lEh9vdhw7doTOjKuRHuqfUIfXNt2Ei3z+/e+hZGbCsGH+86qHBAO6XGaXsW2bcctNSLA1OSwWS/gplyG8Iqjq+yJSD/gPkAT8Alygquv8XYrbRyIwgqI1xqYxG+iqqqlHZsbhp149s+PYtcsIjkPwetn12sfE3/QXxsy6GRf5jHl4IIlr1jLo78ksWLMMj8dLx469ilwmYsbbtcsIjgYNbGp1i8USXhwJDRF54zBdVFUdV+9T1ZeAl0Kc61Xs/W+YIMBqg4jZCeTnmzKvoQTHzrGTcV3Wk1eW/I3nuZ0DE3z4JmYj/c8n+5qhJe44AoJj3z6jqkpKImSZWYvFYikrTncafTjUvhEPxAF7/IelDIiYnYCqqdZXkuAQrxdGv09+1+Pw5OfgIQfyIOWzL9h57+hS9U+BDLkbN0LjxiXXMrdYLJay4rQIU7Kqtih21AZ6Ybye/lKZk6yuBFKq16oV2mXWvTUNYooG6BzMj+LVu1MPm/U2OtrsNtavt2lHLBZLeKiQxltV5wLPYmptWMpBQHDExpYsOErKVxVLBq/PbMJttx0+eaHPZ+6xbl3JKdstFoulLITDTLqGamZzONK4XNCwoamdESw4Ds1XVYv8iAjc5DHWNYwZnx7ghhsOLwyioky6kfXrSylLa7FYLA6okNAQETcwBH/8hKX8uFzGaB0sOEQEj8eLXj2U7QtT2fnOl2z9YQM/Dr2NfvolsyPO4cevd3HNNYcXBpGRhUGAu3dX/nosFkv1xKn31KwSmj2YDLf1MLEWlgoSEBxpaUZwxMZCx469UFVUhJzEJAAS7xvFntN70fHO6zkragWfLezOpZfCO+8Yr6xQREQYg/vWrcbWYWM5LBZLWXG603ABUuxIBz4CzlbVsZUzvZpHqB1HMCJC5gWD2P59KiOndic5GdYt38vFF5udxOHGD8RybN5sS8haLJay4dR7qpeq9i52nK+qw1R1TiXPscYRLDj27w/dT+vUpVkzmH3zRNZGtCJhzSIGDoQ//ih9/EAsR8Al11YCtFgsTrHxwlWUknYcofD1OJ3YRrWY4+pDu7QvGThQWbKk8HyomikxMYUuubagk8VicYJjoSEix4vIWyLyu4js9/8cJyKtDn+1pTwEvKri4koXHHnJx7Hrs3m4Wp/AFOnPBXve5bZL01j2ygJkaxoLF05nyZI5JV7r8xlbR2qqiVC3WCyW0nAkNESkF7AMuBCTOPAl/8/+wHIROaTiniU8BAuO0jyk8hs0ZOfk2exq05YJXMPKrBZ0ffg86p3eApkwhuzszJA7Do/HeFZlZ1vPKovFUjpOk0v8D1gK9FPVgu+8IhIHzPCfL7E0oKXiiBjB4XKZh3rImhm165D3+ifknXUC3twsvGQVph35T+lpRyIizLF1qxEe9evbZIcWi+VQnD4W2gJPBAsMAFVNB54ATgr3xCxFCeSqqlvX7DhClXZ3b9uC+IrWfj2YF8Wb9x0+7QgYgbR3b2FtDovFYgnGqdDYiInLKAkPsCk807GURkBwxMeHFhwlpR2J5gAvTG3BsGHOUonExhrDuDWQWyyW4jgVGk8AD4pIo+BGEWkM3A88Gu6JWUomkFY9IeFQwVFS2hEVwU0OF3imM20aXHGFidE4HNHRhTmrSnP7tVgsNQunQqMnUAtYIyJzROR9EZkDrAZigV4iMt5/vFVJc7X4CQiOBg2M4Ah4PZWUdmTLvD/ZcVI7Xsu9gSF1P2XxYrjoIiMMDkdUFHi9sGGDsaWEUolZLJaag1NDeHcgF0gDmvsP/O8Bzgrqax8tR4j4eCNAtm41KiWXq+S0I7mTvyX3ynN4Jv4dvk+7iBUrYMAAePNN6NCh9Hu43YWpR7KybDVAi6Wm40hoqGqLyp6IpXzUrWu8njZvNsF6ERGHph0hrhY7J0xHo2P4KBNuHqp8M1e49FJ44QW44ILS7yFiDOTp6UZwNGpkEiBaLJaah/3OWA2oVctU59u/P7THk9auA5GR1M7cypdZvRl5/k9kZsLQofDKK85UT4EIclubw2KpuZQlIjxaRIaLyIci8rX/5y0i4qvMCVqcERcHzZqZh3lpuaQkOwv3hjU8/P25PH3TKlTh4Ydh5EjIzT18ylufz+wy1q839c0tFkvNwmlEeEPgR+B5TBBftP/ni8CPIpJYaTO0OCY6Gpo3N8F5oVxl8xo3Y+f7X4PLxZ1T+vL2w6lERcHbb8O9957Cvn2Hv09kpNl1bNlibB02/YjFUnNwutN4EqgLnOWvD97Fb+foDtTBuORaqgBer9lx5OdDZmbJffJaHs/Od2cgBzK44vW+fPrKZurVgyVL4v2eVYfXVblchYGAtga5xVJzcCo0zgdGquq84EZVnQ/8B0gJ98Qs5ScqyggOEZP+vCRy27Zj5ztfkuF2k5f9NV+OS+PihrPY+/sWzjsvh7ffXuroXrGxRkCtWxf6XhaLpfrgVGjEAptDnNvoP2+pQkRGQtOmJhlhqOC87NPO4OvHniXzy4859S/JvL+3P6nSggH73uc//2nP++878572eo2gWr/eBA7aeA6LpfriVGisAq4Nce4aYGV4pmMJJ243NGlibB0lZcgVEboedyoDpk7FnZ1N5MEDeDWT11xDqZe7jREjhIcfdlbdLxDPsX27rQhosVRnnAqNp4ErReQrEfmriJwvIteLyHTgKuCpypuipSK4XCauok4d2Lfv0F2Ae0MqrihvkTaPW/nfjStxu4077pAhpadlDxCoCJiZadRVoWwqFovl2MVpudd3gGHAycBrwFTgdaAdMExV3620GVoqTCDRYf36RdOOQMkJDiU7i8un/5Vp/11KnTowaxb07w9r1zq7n89nhNW6dcZQbtVVFkv1wXGchqqOARph0qCf5f/ZWFXHVtLcLGFEBOrVMyVkMzJMkF7xBIc50THkejx817UrGRHCKb3rMXUqnHCCqTuekgLffOPsfh6PcctNSzOuuVZdZbFUD0oVGiIyRER+EpEMEdmIUUOtVtV5qvqbqloP/WOM2rWNgdwEARZNcLj00SfYvjCVrSPu5dtRr5HfuBnJzZXvT7yWR9p9wN69yjXXOI8gD7jlZmSYXYdNs26xHPuEFBoichXwBiaQbyomOeH/YdOgH/PExJggwNxcOOmkXnTu3A9NTGJv25PQxCQ6d+5Hx069AZA9u/Gl/sa/f76cX1oMoFH+Bh5+GG6/3XkqkZgYI0BSU3EUPGixWKoupe007gA+Btqo6uWqejrwIHCriEQckdlZKg2v1wgOlwsyM4umDwlOeKh149nx+UL23vc/2myZxeqotoyIfIFPPsrjootM2nQnBNRVmzcblZVVV1ksxyalCY0TgLGqGvzv/RIQBTSr1FlZjgiBWI6oKKNCConbzf6bR7B91i/kd+nGf2s/QZtmB/j1Vzj/fJg719n9Auqq/futd5XFcqxSmtCoDRSv8RZ4X7dypmM50kREGJfc2rXNt//SbBV5zVqw650v2PPlIj74Io5ze2UzePez/PWqTF580bmXVHR0oXeVLe5ksRxbHM57yiUiBQcQUVK7/5zlGMXlMi65kZHGJbdU1ZEI+UmNqVMHJlw1lWcZwY96Kt89NpebbnIWzwGF6qqtW43KKlRKd4vFUrU43MN+HpATdARMn4uKtdt0dcc4ImbX0bixySHlJAFhdsrF7Hx3Oo3rZzOXngz8YihXnLeHVauc3TOgrjp40BjJbe4qi6XqU1rlvgeP2CwsVYa4OGMg37TJPMx9h6mWktXzXLLnL2fvvQ9ww8RnaJK6kZSUaTz5JAwa5Oye0dGmBsj69ab2eXy8LSlrsVRVQgoNVbVCo4YSSK++ebMxWsfElN5fo2Nw/e8pNl9xJV+/6ObgV3Dvbbv5c85+7niqCVFRh79nZKTJX7Vrl7lnUpJRYVkslqqF/T5nKZGAZ1VsbMk5q0oi4vQOjBjXjkcfhSddI3loclveO+sl1qc6iwEVMffLyzMpS2wKEoul6mGFhiUkLhc0bGiM5Ic1kPsRgcGD4YSx/2RZ1Jncs+lW6HEWi95c4fi+Xm9hZUBrJLdYqhZWaFhKRcTYGMpiIAc4/rzjqLdkBk+e9Bat8laR8p9TmXrtRMfXu1zGvhIwkoeqCWKxWI4sVmhYHBEXB8nJJkOuUy+nOnWFq6dfx2sjfuMduY6HZnVj0CDYlJpT0EeL6Z+Kv4+ONraNDRuMe66NJLdYji6leU9ZLEUIlJFNSzPqqthYsxMpDRG47u/1WdzzNfL/BkuXKuk9U9jb7ThSh6VwINJN15btcW9IJbdpMgvWLMPj8dKxY6+CMQIFnvbtKzSSH86ry2KxVA5WaFjKRKAa4I4dsHOnsT1EOMhE1qkTTJ8Od92Zw9KvT6HnN89Rf+HH/H5KMvV/Xoorykt+ViaSkkL21UNR1SI5sETMvbKzTSS5dc21WI4Ojv/lRKSxiDwjIotFZI2InOxvv1NEzqy8KVqqGiKmoFOjRmWzc8THw9i3POx/8H90i1hEWlYCXRcvwp2djSt9H+7sbAZMnUrXlu2LCIxgPB6z69i1y8R12PxVFsuRxZHQEJGTgOWYOuGbgeZAwIu+OSYjrqWGUauWCQQsi51DBG68ER6Y0omHGr7MQYoGcbiifLg3pB52jNhY8zo11QiQfFvZxWI5IjjdafwP+A1oAQwCgr8Gzgc6l+WmInKLiKwVkUwRWSIiZx2m/1X+YlAHRGSLiLwjIg3Lck9L5RAIBPT5nMdzALRrB4992ApxFdtR7M8gr7azfJiBXceOHWbXYYs8WSyVj1Oh0R14XFUzgOKPha2A4we4iFwOjMIUczoNI3S+EJES062LSDfgbeAtTInZgUBbYILTe1oqF7fbqKoSEoyB3ElchaqybOsypl10PtnuKPZSm0yi0Px8fAN64vn2K0f3Duw6VE1AoN11WCyVi1OhUdq/YQKFiQydMAIYp6pj/SVjb8NUBfxbiP5dgI2q+qyqrlXVhcALgLWjVCFEjNBo2tTYGQ5naxApLDW78/u1rHv1C/qfvJYz+Z7N++JJuOIcYv99h+PygFFRRXcd1tZhsVQOToXG98D1Ic5dhsmGe1hExAN0BGYUOzUD6BrisnlAkoj0F0MCcAUwzck9LUeWmBgTz+FyHaawE9CxY2Gp2YQLu/DalCS639GRTvIjo7idWuOeJ/LGwY7vHbzrWLfOCBC767BYwosUD6YqsZNIT+ArYDbwLvA6MBKjLroC6KGqixyM0wjYBPRU1blB7fcBV6tq6xDXDQLGAT6Mm/BM4CJVPeRrqIgMBYYCJCYmdpw4ceJh11cSGRkZxAasrTWEcK85N9ccTlxyg1m+vDZPPtmGk7d+x67I+nS72cfAc1ajkZGo27mXeH6+ESSRkaHjSezvuWZg11w2evfuvURVO5V0zpHQABCRFOA54Lig5lTgVlX9wuEYZRYaItIWIySeA6YDScBTwE+qel1p9+vUqZMuXrzYydQOYc6cOfTq1atc1x6rVMaa9+0zOaQiI3GU7TZAejrcey98+KF5/2XiYLrXW8H+l98mt9WJjsfJzjaqqvh4qFfvUAFmf881A7vmsiEiIYWG4zgNVZ2qqsdjaod3B9qoakunAsPPDiAPSCzWnghsCXHNSOB7VX1KVX9W1enALcC1ItKkDPe2HAUCbrlQtvxRcXHw3HPw6qtQpw6M3dqfzN/WEt/3NGJef96x3ingYbV3r81hZbGEA6dxGvf5dwmo6p+qOl9VV/nPJfl3CodFVbOBJcA5xU6dg/GiKolojKAJJvDexgMfAwTSj9SqZXYeZbEzXHghzJoFu/tcwsm6nC9zzqb2fXdQ65JzcG3e6GiMQDR5ZKTJYZWWZoo+WSyWsuP0oXs/EOpbfSP/eac8AwwRkRtFpI2IjPKP8QqAiIwXkfFB/T8HLhKRv4lIS78L7vPAj6q6vgz3tRxFIiIgMbEwirwsMRWJiTB+PNzxWBKX+z7nJsaw94ff+fbbss3B7TaC68CBwnodFoulbDgVGqWlpasLOH4EqOr7wJ3Af4CfMKquC1R1nb9LM/8R6D8O46Y7HPgFmAT8Dlzk9J6WqkNAXSVivKucBgOKwHXXwcyvhJ/PuImW+X9y2YgmjLgzH/cT/8W1a4fjOfh85tiyxdg8bFCgxeKckK4oItIL6BPUdLOIXFismw9IAX4ty01V9SXgpRDnepXQ9gImNsNSDQioq7Zvh927nSc9BOPOO2kSjB0bxZNPwqoPl1Gbh8h/6wUOPP86WX1THI0TEWFsHWB2HQkJULdu2T29LJaaRmn+iz0xuwEwUeAlxWlkAyuA28M8L0s1x+UyaqfoaPON3+Vynu48IgKGDYO+feHOO0/j9KU/8M7ea2g3+EJ2X3ITmY8+g8Y4czUUKUyAuHevqVR4uJroFktNJqR6SlUfVFWXqrow6qnOgfdBh1dVO6jqgiM3ZUt1IlDcyeMxbrZlqQneqhV8+ikM+Hc7unt+4HH+Re1Jr8GA/mWaQyAoMGAo37TJeeZei6Wm4cim4RcQ31f2ZCw1k8hIU6Ojfn1j5yjLAzsiAm65BabMjGJSx8fpwVwuW/kQt94Ku7aUzWARMJRnZtrsuRZLKMrssioiDUSkWfGjMiZnqTkEapEHUq2XNZ6iVSv4+GPoe393FnvP4pNPYGa3B4jqfjoRvy4r01g+n1Gb7dhhYzssluI4jdNwicijIrITk1xwbQmHxVJhvF4jOAIxHU4y5gaIiIChQ+Hrr6FbN/gqsxs5m7cR3+908h59vEwFxl0uo7KKiLAqK4slGKc7jTuBWzF1NQST1vwRjLBYDdxUGZOz1EwCMR1NmhjtksNEtwUkJ8P770Ofp1PoEvsLn+oAmo4eSW73nrBmDWBSswcTKp1OZGShymrtWlPi1qqsLDUZp0LjeuAh4An/+49V9X6gDSaXlFVPWcJObCy0aGF2H2WNJBeBK6+Ej+YmMO6CD7mGt4la/wf/d1MGkyb9wMKF05GtadRe8SuyNY2FC6ezZMmckOP5fGY+O3ca4VFWo73FUl1wmjK0JbBYVfNEJBcTn4Gq5ojIc5gYigcqZYaWGk2gwFNw4kOv1/n1iYkwZqwwffo1dB75F1JX+pj0f/lMiT+f+nvnkBAZieSOQFJSyL56KKoasj55wMsqNxc2bzaCpEGDss3HYjnWcbrT2AsE/jU2A8HZaN1AfDgnZbEEIwK1a5tdh9ttvuWXVUXUrx98+Y2Pv/4VOuQv5rwdM3DnZBN5YD/u7GwGTJ1K15btQwqMYNxu4yqcl2cM5Vu3ls32YrEcyzjdaSzFlFid7j8eFJGDQC7wX+DHypmexVKIx2MqA+7ZA9u2lX3XERcHDz8Ma9vkceCuWGK0sEqUuCJxb0glJzHJ8XhRUYXxJXv3Gpfh2rWNEd1iqa44/fN+Djjgf30/Jo35BOB9IBKTF8piqXRETLqP5GRjMC/PrqPl2clERRZ1hXJl7uft6fXLnP1WxLjnRkebtCipqdbeYaneOA3um6mqr/pfbwHOwNTVOBU4QVV/rrQZWiwlEMhf1aCBiaNwGsOnqsxfs4zPUlLI9XjI9sWQKV7u4wH+/lIrzj83l/Tb7iFi47rDDxZEwEXX7Tb2jvXry+71ZbEcCziN07hOROoF3qvhT7+wiBORUivoWSyVQfCuw+VytusQETweL3r1ULYvTOWnx55g95I15N+TQsOGB/H+/jPNP3qGul1aE3H3P5BdO8s0p4C9Iz/f1ClPS7PxHZbqhVP11JsULfMaTAv/eYvlqFB815GZWXr/jh170blzPzQxib1tT0ITk7jllo7Mm+ej94gOnOz5g3fyr6L+289Qt9Nx+J5/osz506Oiitbu2L7dGsst1YNw1NOIwRjELZajRmDX4dTDqriXlIjg9cLf/w5vz2nKxHPeoB0/81VWd/Y88wbfzS+fdTsQ37F3r4kr3L3bBgdajm1Kq6dxKtAhqKm/iJxcrJsPuAL4I/xTs1jKTsDDat8+4wobEeE85XqA5s1h3Dj46quTue3+KexO3cPeayIZdG4Gb+wcQO7w/yPrnAuNpHJAwFien2/yWe3aZTyt4uIcD2GxVBlKc7m9iMIyrgr8O0S/ncAN4ZyUxVIRAnEd0dHGNXffPvPa7dTB3E/fvnDWWTBmTB1GjYKVM9axVTZxwvUDONjpLDLufYKcTl0cj+dymVodeXnG1rFjR2FNESs8LMcKpe25n8PYK1pi1FOD/O+Dj0ZAA1X9rHKnabGUnchIaNzYHNnZxr5QVlfYqCi47Tb49ls4cdBJnKS/MIyXSf/xd+pf1JU6N/4FOXjg8AMFEagaGBEBGzcag/mBsg1hsRw1SivCtFdV16lqKkZATPW/Dz62aKhMbxZLFSEuztg64uKMraM83kxJSfDCCzDpk0gWth9Gy/w/uZeHWDg/n++X+/VfZfSxjYwsLDm7fr3JpmvddC1VHadxGutUNQdARKJE5BYReVFE7hGRRpU7RYul4gQy5zZvbnYbGRnlM0iffjpMmQL/fS6WsYn3cvbejxh4sfCfwRuo37EpcU/ei6TvK9OYHo/xtMrNNbuOTZsO7wFmsRwtQgoNEXlIRH4t1hYFLMIkKLwFkx59qYi0qNRZWixhwuczgqN+faMSKo/gcLng0kuNyuqOO4zX1YyvhI/T+xI36hHqdzmOmNefL7ebblaWiSzfvLnMQ1gslU5pO42+wLRibbcC7YCngNpAZyAH+E+lzM5iqQRcrqJBgWUt9hQgJgbuugvmzoXOf2nC5fkT6cQPzEtvR+377qB+n5PLpW/yeo3wOHjQCA8bIGipSpQmNI4DitcFH4ip3DdSVdP9dcOfAs6unOlZLJWHx2PsCk2bQk6OUVmVx0LXuDE8/zxMmwaeLp3olfsV/fiSZ/f8lc+/8qEK7t+WF/R3WgDK5zM2jwMHTIzHli1WeFiOPqU5IdYGtgbeiIgHk3NqUjHj9zLAeWpQi6WKERNjdh27d5siS2532WM7ANq3hw8/hJkzhf/+tx8z/uwHw+Cq1ouZsOp0Mnuey6KBl7CjaVO6tmyPe0MquU2TWbBmGR6Pl44de5U4rs9ndh/795sMv3XqmHrqHk8FFm2xlJPShMYmIBmY639/JuAB5hfrFwnsD/vMLJYjSEQEJCQYtdDWreWP7RCBc8+FPn3gvffgmWdg0qpTaMAzPDjvEXp+M4P1TZrQYOtWxOsjPyvTcQGoYOGxd6+Za3y8sYVYLEeK0tRT3wJ3ikgdMX/JtwP5wNRi/U4FNlbO9CyWI0sgojxYZVUeY7nbDddeC999B7f/I4qxMf9H09w1PM9wmm7cSERODq70fWUuABUQHgG1VcDmYQ3mliNFaULjQcxOYyuwB/gLMEZVi+eMvgL4rjImZ7EcLWJiTGxHQoL5Zl/e+ImYGPi//4P58+HSG2rzYcRVpBNXpE8EQtSCb8o8drDwWLvWuupajgylBfetxewingDGA4NV9ZbgPiLSEKOuslluLdUOl8uof1q2NKqqffvKb4hOSICHHoJnP0nG4ypW6Sk7i7q3XkmdW64sYjB3is9X1FXXBglaKpNSg/tUdb2q3qeqt6nq2yWc3+I/90PlTdFiObpERpqI8ObNzfv0dJM/qqyoKuuyljHtovPJiYwiw12bA/gYzgs84/4HrmlTaNC3HXVvuBjXjm1lHj/gqhsIEly3zuySbM4GSzix1YwtFocEAgOTksy3+rI+kIMLQO1YtJaDk79g/turmdf+Cv6R+xSNctbxeNT97P5xLekRdQBw7dxe5nkGggRVTW6rQAlam5LdEg6s0LBYyoCIeSC3aGECBMtq7wguAJXTqQtt+yQxdWo9Jk+GE86MZ2TWAzTetpQuPT2MfTGLhHNOpd4lvfF8N6vMWwaPx9g8XC4TXb52rfG6slgqghUaFks5CLjotmhh7B3p6c49mEoqANW5M0yebNx0TztN2LkTHntMeSDjn2QtX0XC5WeTcFE3or6eVmbhEUiM6PEYd+KsLFPTw1YStJQHKzQslgoQbO+IiDDG8pycw19XEiLQowd8/jm8/Ta0OdXLf/ffSYOMNfwz5iUO/LmJetel4Fk49/CDlUBEhKki6HKZIMbVq029ERtlbikLVmhYLGHA6y2M78jLM/Ed5TGWgxEeffqYbLrjx8OJ7b08vf9vNNj7B0NiJ/HM4h6kp0PMGy/g++S9ct0oJsYIkPR0o7bauNGo2azR3HI4rNCwWMKESGF8R8OGRg1U3uDAwHhnnw1Tp5qdx8mneXgr4y889rjQ+Uxlz0sTqHvrVTTo2Qbf++PKvMUJDhTMzjY1Pdats0ZzS+mUViN8VhnGUVW1SQstFgqN5TExRl21fbtRCfl85SvrGth59O5tMuqOGgWLFgkt9s7nSu8nPJ7+CE1HXE/cMw+w96mxZPU4p8z38HrNkZNjjOZut4lRiYsreyoVS/WmtJ2GC1PmNXCcCPTCRIn7/D97Aa395y0WSxAREcbDqmVLk2Rw//7ylZwNIAI9e8JHHxmjefezXLybOYhmO5YwMHIqa7Mbszm3AQCu7VvLXIYWihrNd+ww2XUDxnOLBUqPCO+lqr1VtTcwClM3o4uqtlTVLqraEujibx91ZKZrsRx7uN2FnlaBkrMVjdju3BkmTjR2j379hE9zLuCEbfM4bUh7br8d+PsIGpyZTOzoJwoqCTpNyQ5G4MXEmCMjw8R6rF9vgwUtzm0aDwP3quqi4Eb/+wcwFfwsFkspREaakrPBaUkqmivqtNPgjTfg669h0CDTNnky/OXrW1hCR2o9ejeJnZNJ/8f1LPlqErI1jdorfkW2prFw4XSWLJlT6vjBdo/8fGMwX7PGpJG3Lrs1E6dC43ggVGjqNqBVeKZjsVR/PB7jptuihYneDofwOPFEeOEFk1V38GD40duNM3d+QSd+4Bt60vq9cZz4yD3U75zMaff8i/qdk5EJY8jOzix1x1F83gHV1fbtxmV3yxabJLGm4VRorAVuDnHuZiA1LLOxWGoQUVGm6l9ystmF7NtXcdtBs2bw6KPw/fdw552wuk4n+uz5mF7MotmfG3FnZxN5YD/u7Gwu+nwKXVu0c5SSPZhAvEdsrFFXrVtn1Ff79lmvq5qAU6HxINBfRH4RkQdE5G/+n78AKRgVlcViKQeBGI/mzY39oyzR5aGoVw/++U8jPB5+GOo08JJJ0VJ/Ebk5JFx+tnHXLYeRJVh1JWLqeqxebQzo1nBefXEkNFR1ItAP2AuMBEb7f+4B+qnq+5U1QYulpuDzGeHRrFn4hEdMDPz1r/DClGSi3UUHyyaS7VvyqDviehIGdqvQfQJeVz6fKUm7dq0xnFckTsVSNXEc3KeqX6lqN4y7bUPAp6rdVfXrSpudxVIDKS48KmrzUFW+X7+MKf0vINfjIcsbS6Z4uYHXaJyxit7M4qG8//DVV5CfmU2d268j6psZ5Xrau1zGyF+rlrl80yZjON+xw6YrqS6UOWxHVfMxxm+LxVKJBITHwYMmV1R6uhEiPl/ZxgmkZM++eijb7x3Nhrkf0bTHIM6c9we7v9zErFm9mfMbMBj6Nf6dSXumU2/y2+S2OJ79Q27lwKWD0dp1yjx/j8cc+flm97Fzp5l7fLwRLC6bj+KYxLHQEJGWwGVAM8Bb7LSq6g3hnJjFYjH4fNCkidlt7Npldh6RkcYW4tSG3bFjL1QVFWFv25NokpjExRc3ZNAgYc8eE/PxxhswfdPJ1GM9V0dN5p79L9Lq/juJe/wetk9fSt5xJ5Rr/oHdB5jdxubNZt61a5sdibf408RSpXEk60VkILASE48xEOhdwuEYEblFRNaKSKaILBGRs0rpO05EtIRjf1nuabEc63i90KiRcdUNBN2VJcK8pJTsYKLVhw0zdcxffRU6dI7izayrOH7bfDqwhIn1b2f6muPJy4Pot17G+9kH5U7l6/EYr6tAOvl16wrrfNi4j2MDpzuNh4E5wNWqWvZSYkGIyOWYCPJbgO/8P78Qkbaqur6ES+4A7i7WNg8oX35oi+UYJyrKJESMjzdqn927jRus11sxlY/bDRdeaI5ff4U334SPP+7A1es7wBBo3kyZnz2WRluWktewEfuvHsqBq4eSn5hU5nsFPK/ACIutW43wi4szQqy8eboslY/TP7GWwNMVFRh+RgDjVHWsqv6mqrcBacDfSuqsqnv9tci3qOoW4Dj/fMaGYS4WyzGLxwMNGsBxx5kH7cGDFUvJHsxJJ8HTT8MPP8C99xrbyrr1QtMtPzDQPYWfaUet/z1A4hnNiB7/SoXu5XYXxn1kZsKGDYXGc+u6W/VwKjRWAvUqejMR8QAdgRnFTs0Aujoc5ibgV1WdX9H5WCzVgUBuq5YtoX59YzdITw+Puic+3qiu5s2DceOgV58IPstLocOWLzie3xlf+zY+2XwGGRng/m050RPGIgcO1Rw7yXslYnZLcXFmN7VnjwkaTE216quqhDhJISAiZwPPARep6ppy30ykEbAJ6Kmqc4Pa78Oovlof5vramF3JSFUtMUmiiAwFhgIkJiZ2nDhxYrnmmpGRQWxsbLmuPVaxa64+5Oebh2x+vlFZBat6MjMz8HrLv+bNm71MndqIGTMasnevCRj0+XJ5o/E/uOLPUeTExLC53/ls6D+Qg40bc+BABqr51M3KxbcljYMNk9gd5UbERXT04eehWmi3cbmMKq6sarjq+nsujYqsuXfv3ktUtVNJ55wKjW8xaqF6wB/ArmJdVFV7OhinokLjVuB/QCNVLT6HQ+jUqZMuXrz4cN1KZM6cOfTq1atc1x6r2DVXL1SNymrHDvPT7Tbf5FesmMNJJ/Wq8PhZWTBtmqku+P33AEo35vHvOqM5d98kIvJzOXDRFXxx7WBkwhgGTJ2KK8pLflYmn6WkoFcPpXPnfmVKY5KVZXZSLpfxvoqLc+ZFVp1/z6GoyJpFJKTQcGoIzwNWlevuRdnhHyuxWHsisMXB9TcBk50IDIulpiNivJSaNTMP2927C/NDBXYgFSEqCi6+2ByrVsGECcKkSd25YE93GvIMt0SOpfUaF7Uz2nP21Km4s7MhOxsXMGDqVLbfOxoto7U7KsocqkYFt3u3EYYBAeLxWAN6ZeNIaKhqr3DcTFWzRWQJcA7wYdCpc4DJpV0rImcA7YE7wzEXi6UmEfC4qlfPGJozM43B3OcLT2W+1q3hoYdg5Eiz+3j33STuW3gfLIfOQxbQXSJxUxgS7vJE4d6QSk45PK+gqPdVcPBgZKQpfBUTYwSIJfwcjZjMZ4AhInKjiLQRkVFAI+AVABEZLyLjS7huKPCHqs45clO1WKoXkZHGJtCypUnPnptrvrGHK725zwd/+Yup6fHNN3DLLbAvPhnRoilJJCMd77uvI/v2VviegeDBuDizvp07TexHwIBezpASSwgcfccQkR6H6xNsozhMv/dFpB7wHyAJ+AW4QFXX+bs0K+H+ccAVwENO7mGxWErH5TLR2HFxhZHm6emFtczDkeKjVSu45x6lR4+feeOZ67nxhzfI1CiiyOQHTif5g5k8GRfFoCvhxOYHy54fpQQiIgqjz3NzYds2sxPJzjYCJDraCBZL+XG6MZ0DHM5iHuH0pqr6EvBSiHO9SmhLB2qW64PFcgQIqHkaNzYP1n37jJ0gP98YmCv6gBURoqOjSLqrP7tb/od9y1KZ/GMyoyfHsXOzm6zXvIx5LZs1kSex58TORN1/NzFd2oVlbW53UdVbIIDQ5zM2ECtAyodToVFSmpB6wIVAT2B42GZksViOCh6PifeIjzdBgoHdR8DrqrwG5uC8V3HnJjHkXLjuLmXpUuH992HWZ9m8k34Ztyx/iVqXvMeChP5sveEe2g3tHLa8VCImeBCMuiogQLxeExhpBYhznBrCvwlx6iMReRboD3wRtllZLJajRkB1VauWUV3t2WNUO4FdSYRjnUIhxd1qXS6hY0fo2BEOPhjLzJmPc+27/+LU717k9h3P0eWJLvR74VsSBnZn0CA488zwZcWNjCwUEMECJCqqUIBYI3powuA3wVRgIiaHlMViqUZ4vcbrKiHBlHbdudMkSQxk2Q0HPh8MGAADBtRl+/Z7efX9/yNr/PvM2NQN3oXod8cypW4DYq7oz8BBLtq2Dc994VABsn27ESBut/HCCggQ68ZbSDiERmvA1uayWKoxgViIwO5j926jwgqk/ijP7qMk6teHIcNjYfgN9P4dJk9Sho55mVN2L2X5yyfz2MsjWXbCZVw40M3AgaZEbrgIFiC5uSYoMj/ftNWqZdx4K6Kmqy449Z66roRmD3AycAPwUTgnZbFYqiYBFZXPV+iuu3u32X1U1PZRnBNOgJH3CPn/+J4fnnufpHGP8u7eq/nz9/sY9uQrPPlkX047zexS+vc3LsThItiInpdn1HM7dxoVWVxcYSR6uITlsYTTnca4EO1ZwPuY9OUWi6UGEVDh1Kljdh979xbaPrze8AQNArg8bhrfdTX840q2TfuMOo8/ymnJdVmwCDYs3c5TS6N56KEYzjjDCJALLjDZf8NFREShN7CqUdMF1hkobevz1RxDutNfa4sS2jJVdWs4J2OxWI49gncfAdvHrl2F+a6iosJkxHa5yL1wIKRcxP+JMOwg5F57Fw0Xf86z+Xfy3KLhLFpUh3vvhc6dTV2QCy4wKq9wERyJrmrclLf4EyBFRhbWAomKqr5qLEe/SlVdV8JhBYbFYilCwPbRooWxNwSCB9PTw1gbw/809vkg/u6hRPXozAN597ItqhnvtRhJo4itzJ8P99wDp52mXHIJfPppY7ZsKTkle0WmERVVWAskIsLYQdatg9WrjVfW/v3hqW9SlSjTBlJEAnEZ8ZhMt3NUdWplTMxisRzbeL3mSEgwu47du43wCKf6KqdTF3aNn4L7l5+Ie/ExLp/yBOdevZ+3Oz3PhAk7WLo0njULtqILdjB5dCx1TvTSrdtObrqpFU2bVvz+wQTbQfLzjaPAnj3mfSCg0Os99r2xnBrC44ApwFlALrATE9w3wp82/UJVzai0WVoslmMWl8t4HsXEGLfWAweMUfngwfCUqQXIPflUdr/yPhGrH0Zj47ikgdJ+3ziapY2madpmsojClZfLzStf5fWV1/L663DKKXDeeXD++cboHs4HeSAdS4Ds7MKUJhERRb2xjjVjulNZ/yjQAbgWmKiqeSISgckH9bL//O2VM0WLxVJdiIw037hr1zbqqvR08208Ly883ld5x50AgACnZuVTe2MqAkT6M+y+EXEjrj5nM3l+I5Yvh+XL4amnjDrtvPOgXz8TcBiuQMIAHk9hwGB+fqHXGRjhEjCmHwu7EKdC4y/Af1R1QqBBVfOACSKSANyFFRoWi6UMBGpj1Ktndh379plD1Tw8o6IqNn7OGWehsXFIRnpBmzs/h6eHr+P+Vxqx5oWpTP+tGW8sOom1a128/DK8/LIxnJ9zjjnOOisseRSLUHwXkpNjdiGq5lxsbGHJ26rokeVUaNQDVoQ4t4Iw1A+3WCw1k4DranS0eWAfPGh2Hxl+hXfwt/SykNs0mfzsrCLePvkRbnKbJuONUnqPH0LfXTt4PD6BtM69+MbVm1fW9uO7tON49114912z8+nRwwiQvn3D68obIDioMFBtMd0v59xuswuJjjZCpCqospwKjbWY5IQzSzh3gf+8xWKxVIiIiEJvpNxcY//Ys6fQgO7027eqsmDNMiQlhQFTp6LuSCQ3x5SZXbOMzg0asuOLxXjmzSZq/mwazp/N1ZsnMWDoCBZd+j++/iIb7wfjGb+xNzNmtGTGDKMzOvVUIzz69oWTTw6/KingJBAgOLAwsP5gVVa41WhOcCo0XgX+JyKxwAQgDWiIsWncCIyonOlZLJaaSuBbdq1ahQb0gAeWy2UeoKE8sEQEj8dL9tVD2X7vaDbM/YimPQaha5bh8XgREfKaNOfg5UM4ePkQUCUidTVERtK2CbQ/sIT6z9zE/cC+2k1ZGN2bD3b04ZOfUnj6pwSefhoSE6FPHzj7bKPGiq2E4g3BgYVgPodAepPADi0QnX6k7CFOs9w+KyL1McJhiL9ZgGzgcVUdVTnTs1gslqIG9OxsE/+wZ49R5YQSIMEp2fe2PYkmiUl0btDwkIy7AIiQ16JVwducjp3ZNmdFwU7k7PlTOTdnPJfcPYcJG3uy8YvlJG1dzuz3evPee0lERsIZZxgh0qcPHH88gBa5l6qWfO8yfg7Bqqxge0hAiMTGhi+ZZEk4dbmtjama9xTQmcI4jYWqurvypmexWCxFCdg46tYtWYB4PIUP1uIPaccPbRFyj29D7vFtODDkFsjPx73yF9od15p2URBXdyJxLzwKwFrviXyR2YdZ83rz2LyLePjhSOrXz+TUU7czuJ+bbo1SiToxmQX+XU7Hjr3C8jmIFLX3BCLUg6sVBoRJODms0BARNyYu42JV/RxbN8NisVQRiguQ4kGEYfNAcrnIbVtYUTD9nw+RecEgPPNmkTR/NjcveIsbeJdrz7+Y2XOVnts/p+vMeQya+SrZePBINqtOvIOIwQNo315xu8OvRwqsN+B1Fsbg9yIcVmioaq6IbAWqWTC8xWKpTgQESO3ahTaQvXuNAMnPN3EhFXXjLSAigpx2Hclp15H9f/sn5OQQsW4Nz7WKID8fand7kLj1vwLgIxMURvz2HMl338njjwvduxuvrB49CHtkemXj1Pb+DsbgbbFYLFWegA2kWTM47rhCW0BGhjkyM8P8TTwykrxWrQGjIst8ZjT5vpgiXdyST+cGa9mzR8mZ8iUP3LWfzp2he3cYORKmTStMO1KVceo9lQpcJSI/AJ9ivKeKfOSq+kZ4p2axWCwVx+02D/ImTYwLayCBYmAHEtZMvH5yW55Afl5OkW/l4oaXvkjmvpWr6HD1+WS7opgrvfh0bQpT16YwfnxLREx6k+7dzXH66ca4XZVwKjRG+382BjqWcF4BKzQsFkuVJiKiMA9WgwZGZbV/v4lEz80tNC5XxA5SPEbEFeUjP+ugiRFZu4zOXXqz472ZeL+eSs+vp9J37e28wO38s/VnjFrTnz9/3s+Knz289FIkkZHQoQN06wZdu5rXYVOxlZOK1NOwWCyWY5ZAOg+fz6Qyyc4uagcRKdyFlMUDqXiMiHtDKrlNkwtjRKKiyO7Rl+wefeHBZ4lY8wfer6cy4rKzGOaB9HtHc8LkR/nWdy7v7U1h2qLzWbSoAc88Y1xpO3QwAqRLFzjttCMvRJzGaayr7IlYLBbL0SLY86huXbPrCKixMjIKs9M6TeURHCOSk2jq0IaKEclreTz7W94JgA+ofWkXlEvoO2sa/fZ+iIrwZ4OuXFz3G35dGcH8+TB/vrnW6zWCo3Nnc3TsGP5cWcUpc0Z7ESmu+VMNZ2UTi8ViOcq43YXpTAKeV4FdyIEDRshERpYehV3eGJHsM88i+8yz2KtK5C9LifpqKkk7tzHjkQh27YLoIZexMb0WH+5PYdymvixYEMeCBebayEho107p3FlITIz3J1yseFBhMCGFhog0BF4H3lfV8f62CPDnGC4kQ0ROsJX8LBZLdaS4Gisnp+guRNXsPjye8NVFB0CEnFM6kHNKh4Km+Dr51GkWSfLXk+ix73VGuSPZcnwPPml8Ky9vuZhff1WWLBE2LtlCC/ZzU/805m5ZhtfrpVevXmGZVmlLvAVTQ+OS4ksBxgKb/a8vB4YBD4ZlRhaLxVKFCbjvxsUVRl4fOGCM6cHZacPtkQWAy8WeFydATg6eH+bh/Xoq9b+eytXdUrnoJuW7Tz/mxEceoO3WlWSJF9+ZWRxISYGhQ8OSxgRKFxrnAWNV9WCxdgVeVdUfAURkO3AdVmhYLJYahstVWNY2Pt7YQrKyzA4kPd24+DpRZZWZyEiyu/Yiu2svuPcpyM9HRDjbnUe9tOX+wlM5kAcXTZ2Ka/TosKmoShMarYH7Smgvfuff/X0tFoulRhOoEx5w6Q1WZe3fX1hoqaJuvYfg39JowyZobC0kY1/hKZ8PSU2FpKSw3Ko0oeEFitT99pd5TQJ2BDVn+vtaLBaLxU9wQsFatQpVWYEiS5VhDzGFpzKLFp46eBBXcvIh3/bLS2kat21Ay+KNqrrVX+o1QAtge5jmY7FYLNWSgCqrbl2T3qRVK/MzPr6wbnhGhrGP5OaWfXxVZf6aZXyWkkKux0NOdAx5Hg+fpqQwfdkywuXkWpps+w64Fhh/mDGuA+aFZTYWi8VSQwj2yoqPN/aPrKzCnUggwNDlKlpHIxTFgwrXzfmIMy4fRPTPxnvqSNg0nge+E5GngbtVtYjs86dMfxLoBZwVltlYLBZLDSUiorBWer16RYVIINHi4WwixQtPSVIS/ZJCFJ4qJyGFhqouEJG7MILhGhGZCaz3n24GnAMkACNVdUHYZmSxWCyWEoVIdnbRGBEoTHcS8M4qd+Eph5RqelHV/4nIj8C/gL9QaPDOBOYCT6rqrLDOyGKxWCyHEKgX7vMZu0jAsB5w8T1wwLRBmIMMi+GkCNNsYLY/Gryev3lnMWO4xWKxWI4gwTEitWsX1gwPlMB1ucJf6hXKkHvKLyS2hX8KFovFYqkowS6+sbFhjgMJItxB7haLxWKpxlihYbFYLBbHWKFhsVgsFsdYoWGxWCwWx1ihYbFYLBbHWKFhsVgsFsdYoWGxWCwWx1ihYbFYLBbHSLjS5VZF/FUF15Xz8gSK1g2pCdg11wzsmmsGFVlzc1WtX9KJai00KoKILFbVTkd7HkcSu+aagV1zzaCy1mzVUxaLxWJxjBUaFovFYnGMFRqhGXO0J3AUsGuuGdg11wwqZc3WpmGxWCwWx9idhsVisVgcY4WGxWKxWBxjhYbFYrFYHGOFRgmIyC0islZEMkVkiYicdbTnVB5EpIeIfCYim0RERWRIsfMiIg+IyGYROSgic0TkpGJ96orI2yKy13+8LSJ1juQ6yoKIjBSRH0Rkn4hsF5HPReTkYn2q1bpF5FYR+dm/5n0iskBEUoLOV6v1Fsf/O1cReTGordqt2b8eLXZsCTp/RNZshUYxRORyYBTwKHAaMB/4QkSaHdWJlY9Y4BfgDuBgCefvAv4O3AacjinnO1NE4oL6vAt0AM7zHx2AtytxzhWlF/AS0BXoA+QCX4lIfFCf6rbujcC/MHPsBMwCPhGRdv7z1W29BYhIZ2Ao8HOxU9V1zauApKDjlKBzR2bNqmqPoANYBIwt1vYH8NjRnlsF15UBDAl6L0Aa8O+gNh+QDtzsf98GUKBbUJ/u/rbWR3tNDtcdC+QB/WvYuncBN1fn9QK1gdVAb2AO8GJ1/h0DDwC/hDh3xNZsdxpBiIgH6AjMKHZqBuaba3WiBdCQoLWq6kFgLoVr7YIRNvODrpsH7OfY+TziMDvq3f731XrdIhIhIldghOV8qvd6xwCTVHV2sfbqvOaWfvXTWhGZKCIt/e1HbM1WaBQlAYgAthZr34r5hVQnAuspba0Nge3q/0oC4H+9jWPn8xgF/AQs8L+vlusWkVNEJAPIAl4BLlbV5VTf9d4EtAL+U8LparlmjBZkCEatdBNmnvNFpB5HcM3u8szcYjkWEJFnMNvv7qqad7TnU8msAk7FqGwuAd4SkV5HcT6Vhoi0xtgcu6tqztGez5FCVb8Ifi8iC4E1wGBg4ZGah91pFGUHRv+dWKw9EdhyaPdjmsB6SlvrFqC+iEjgpP91A6r45yEizwJXAn1UdU3QqWq5blXNVtU/VXWJqo7E7K7+j+q53i4YrcCvIpIrIrlAT+AW/+ud/n7Vac2HoKoZwK/A8RzB37MVGkGoajawBDin2KlzKKoHrA6sxfyhFKxVRLzAWRSudQFGN94l6LouQAxV+PMQkVEUCoyVxU5X23UXwwVEUT3X+wnGa+jUoGMxMNH/+neq35oPwb+mEzEG8CP3ez7aHgFV7QAuB7KBGzHeBqMwxqPmR3tu5VhLLIX/VAeA+/yvm/nP/wvYCwwCTsb8020G4oLG+AJY7v/j6uJ//fnRXlspax4N7MO42zYMOmKD+lSrdQOP+x8OyZiH6WNAPnB+dVxviM9gDn7vqeq6ZuBpzI6qBXAmMMX/t978SK75qH8QVfEAbgFSMUbFJUCPoz2ncq6jF8adrvgxzn9eMG58aUAm8A1wcrEx6gLv+P849/lf1znaaytlzSWtV4EHgvpUq3UD4zAVKrMwRs2vgH7Vdb0hPoPiQqParTlICGQDm4DJQNsjvWab5dZisVgsjrE2DYvFYrE4xgoNi8VisTjGCg2LxWKxOMYKDYvFYrE4xgoNi8VisTjGCg2LxWKxOMYKDUuVRUS6iMgH/qye2SKyU0RmishgEYnw9xniL0aTHHRdqoiMKzZWfxFZLqawlopIHRFxichzIpImIvki8kklriVZSiiEVUK/wHpaVdZcyouIDBSRESW09/LPue/RmJflyGITFlqqJCJyJ/AMpqDQvzDBa3WBc4GXgT3ApyEuvxgTuBQYyw1MwKRKuBUTHJWOSex3B6ZwzQIKcxZZSmYg0Bfze7HUUKzQsFQ5RKQH5sH0oqreXuz0p/7stTGhrlfVpcWaGmPqanygqnOD7tPG//I5Vc0Pw7yjVDWrouNYLFUZq56yVEX+hak8d1dJJ1V1taoWL+9ZQLB6SkQewKSEAXjdr0aZIyKpmJQLAHnBqiMRSRKR8SKyQ0SyxNTfvqbYPQJqpB4i8qGI7MHUO0BEokXkJb86LUNEPgOalONzCImIDBWRZX512w4Reb1YSVv883tERG73F+1JF5Fv5NC60RH+fmkickBEZonIif7rH/D3GYdJwd1YCutTpxabVrSIvOifzw4ReUeqcM1tS/mwOw1LlcJvq+gNfKKqmWEY8jVMnfQPgUeAqRjVVRRwO6aoTSDr52oRicHk7KkL3ANsAK4B3haRaFUdU2z8CcB7GFVX4P/pVUziyweBHzCZR98Nw1oAEJHHMSq154F/YnZSjwAni0hXLVo75BpMrY07AA/wFGa3dqKq5vr7POhf61OYvFUdgc+K3fZhoD6m9vQAf1vxXdUoTBK9q4DWwJOYUgODK7JeS9XCCg1LVSMBU9t4XTgGU9WNIvKT/+1qVS0oViMim/x9gtuGY+oT9FbVOf7mL0QkEXhERF4v9lCepKp3BV3fGvPQ/LeqPu5vniEiscCwiq7Hb/D/J/Cgqj4U1P478B3QH5M6PEAOcKH6ixX5Syl8CJyBqfpWF7gTeEVV/+W/ZqaIZAP/CwyiqqtFZDuQHfx5FWOuqt7mfz3D/1ncKCJD1Ca5qzZY9ZTFUpQewKYggRHgHcw37bbF2j8u9v5MzP/VB8XaJ4Zpfuf4x58gIu7AgVGNpWPmH8xMLVrdbrn/ZzP/z1Mw9qEPi103qRxzm1rs/XLMjq54YSDLMYzdaViqGjuBg0Dzo3T/eExq6eJsCTofTPG+Sf6fJdVqDgcN/D//DHG+XrH3u4q9D6iUvP6fgfluK9avPPM93L0s1QArNCxVClXNFZE5wDlHyRtpF0YfX5yGQeeDKa52CQiRREz9ZoLeh4OAW/C5wO5SzjslMN8GmNKhAezuwFIiVj1lqYo8jvnG/GRJJ0WkhYi0q6R7fwM0EZFuxdqvwnwbX3GY6xdhquZdVqz9ivBMj5n+8Zup6uISjrVlHG85sB+4tFh78fdgdg6+sk/ZUp2wOw1LlUNV5/ojj58RkbaYynTrMR5NZ2NK8V4FhHS7rQDjMJ5GH4nIv4GNwNUYW8LNxYzgJc19lYi8CzwkIi6M99S5wAVlnMd5IrKlWNteVZ0pIk8AL/oNzd9gqrQ19c/xNVWd7fQmqrpbRJ4D7hGRdIz3VAfgBn+X4PiVFUC8iPwNU5M7U1WXY6lRWKFhqZKo6nMi8j3wf5jayAkYQ+9i4Gbg80q6734R6YnZ5TyOCQpcBVyrqu84HOZmTF35f2DcXGdhhNx3ZZjKCyW0/Yop33mPiPyGiW6/FaMi2wB8DfxRhnsEuB9TKvQGjBvyIowr8jxMzekArwGdgUeBOhgPt+Ry3M9yDGPLvVoslkMQkUswHlU9VPXboz0fS9XBCg2LpYYjImcCKZgdRiYmuO9uzA6rq42xsARj1VMWiyUDE99xK1ALY/D/ABhpBYalOHanYbFYLBbHWJdbi8VisTjGCg2LxWKxOMYKDYvFYrE4xgoNi8VisTjGCg2LxWKxOOb/ASR0AFE2NOolAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -108,23 +109,23 @@
       "text/plain": [
        "---------------------------------------------------\n",
        "Experiment: RBExperiment\n",
-       "Experiment ID: c133cf63-fd67-4d52-97c1-b505b099add4\n",
+       "Experiment ID: 30e27585-6311-4da6-8b3e-7908fd0320b7\n",
        "Status: COMPLETE\n",
        "Circuits: 100\n",
        "Analysis Results: 1\n",
        "---------------------------------------------------\n",
        "Last Analysis Result\n",
-       "- popt: [0.64596559 0.96140732 0.28422628]\n",
+       "- popt: [0.69765588 0.9647669  0.26493626]\n",
        "- popt_keys: None\n",
-       "- popt_err: [0.00487162 0.00058143 0.00209837]\n",
-       "- pcov: [[ 2.37327077e-05 -1.87697724e-08 -3.52987578e-06]\n",
-       " [-1.87697724e-08  3.38058778e-07 -9.09663098e-07]\n",
-       " [-3.52987578e-06 -9.09663098e-07  4.40313680e-06]]\n",
-       "- reduced_chisq: 532.6350849004282\n",
+       "- popt_err: [3.04628480e-04 2.88150690e-05 9.45301854e-05]\n",
+       "- pcov: [[ 9.27985106e-08 -2.50866441e-09 -4.37601950e-09]\n",
+       " [-2.50866441e-09  8.30308199e-10 -1.76959681e-09]\n",
+       " [-4.37601950e-09 -1.76959681e-09  8.93595595e-09]]\n",
+       "- reduced_chisq: 193.60044947837932\n",
        "- dof: 7\n",
-       "- xrange: [1, 200]\n",
-       "- EPC: 0.028944510776536536\n",
-       "- EPC_err: 0.000453575875974297\n",
+       "- xrange: [1.0, 200.0]\n",
+       "- EPC: 0.02642482193432663\n",
+       "- EPC_err: 2.240054216973096e-05\n",
        "- plabels: ['A', 'alpha', 'B']"
       ]
      },
@@ -134,7 +135,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -150,7 +151,7 @@
     "num_samples = 10\n",
     "seed = 1010\n",
     "\n",
-    "# Run an RB experiment on qubits 0,\n",
+    "# Run an RB experiment on qubits 0, 1\n",
     "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
     "expdata2 = exp2.run(backend)\n",
     "\n",
@@ -162,20 +163,162 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Running parallel RB experiments"
+    "# Running 1-qubit Interleaved RB"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "---------------------------------------------------\n",
+       "Experiment: InterleavedRBExperiment\n",
+       "Experiment ID: 2bf05234-9ce5-411a-b3c5-e14575da2d24\n",
+       "Status: COMPLETE\n",
+       "Circuits: 280\n",
+       "Analysis Results: 1\n",
+       "---------------------------------------------------\n",
+       "Last Analysis Result\n",
+       "- popt: [0.47626118 0.99623266 0.99535996 0.51013026]\n",
+       "- popt_keys: None\n",
+       "- popt_err: [1.77332947e-04 2.66140415e-06 2.83096706e-06 1.79438603e-04]\n",
+       "- pcov: [[ 3.14469741e-08  4.28977668e-10  4.58298066e-10 -3.17868436e-08]\n",
+       " [ 4.28977668e-10  7.08307204e-12  6.39967732e-12 -4.36846717e-10]\n",
+       " [ 4.58298066e-10  6.39967732e-12  8.01437450e-12 -4.66354152e-10]\n",
+       " [-3.17868436e-08 -4.36846717e-10 -4.66354152e-10  3.21982123e-08]]\n",
+       "- reduced_chisq: 800.0272045289706\n",
+       "- dof: 24\n",
+       "- xrange: [1.0, 500.0]\n",
+       "- EPC: 0.00021900082002077048\n",
+       "- EPC_err: 1.9493171174852214e-06\n",
+       "- systematic_err: 0.0016646691935545965\n",
+       "- systematic_err_L: -0.001445668373533826\n",
+       "- systematic_err_R: 0.001883670013575367\n",
+       "- plabels: ['A', 'alpha', 'alpha_c', 'B']"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAESCAYAAAABl4lHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAABozklEQVR4nO2deZyN5RfAv2f21djN2GYGZc2+JoyyJolfUaGElIgSqSSULFFRkUikREJR9n1fJyRbtiFryM6Y7fz+eO9MM9cs15jNzPP9fJ7PnfdZ3uc879x7z32Wc46oKgaDwWAwOIJTZgtgMBgMhnsHozQMBoPB4DBGaRgMBoPBYVwyWwCDIbV4enqeCQ8PL5TZchgMHh4eZ2/evOmf2XJkBGI2wg33KiKi5v1ryAqICKoqmS1HRmCWpwwGg8HgMEZpGAwGg8FhMlxpiEh9EZkvIidFREWkkwNtHhCRNSJy09buPRHJEVNBg8FgyEpkxka4D/AnMM2WkkVEcgHLgLVADaA0MBW4DnycXNv8+fNrUFBQqoS8fv063t7eqWp7r5ITx5xaxo8fz6hRozh9+jTly5dnzJgx1KtXL9k2s2bNYtiwYfz1118UKFCAnj170q9fvwR1xo0bxxdffEFYWBjFixdnwIABPPfccwnqXLlyhXfffZfZs2dz4cIFihUrxrBhw2jbti0Aw4cPZ+7cuRw4cAB3d3dq167N8OHDqVChQto+BDsuXrxIr169mD9/PgCPP/44n3/+Oblz5062XUrPUlUZMmQIEydO5OLFi9SqVYtx48ZRvnz5uDq3bt2ib9++zJgxg5s3b/LII48wfvx4ihYtetfyOUr16tWz1Abb3XyeQ0NDz6tqgUQLVTXTEnAN6JRCne7AFcAzXt67wElsG/lJpWrVqmlqWbVqVarb3qvca2O23r4Zz8yZM9XFxUUnTpyoe/fu1Z49e6q3t7ceO3YsyTYLFy5UZ2dnHTdunB4+fFh/++03DQgI0M8//zyuzvjx49Xb21t/+OEHPXz4sM6YMUN9fHx0/vz5cXUiIiK0Vq1a2qxZM123bp0ePXpU161bp1u3bo2r06RJE/3mm2909+7d+scff+gTTzyhhQoV0gsXLjg8xlWrVmlgYOAdPZdmzZppuXLldMOGDbpx40YtV66cPvbYY8m2ceRZjhgxQn18fHT27Nm6e/dufeqppzQgIECvXLkSV+fll1/WgIAAXbp0qYaGhmqDBg20UqVKGhUVdVfyOUpmvReT424+z8B2Teo7OamCjEgOKo1pwAK7vBqAAsHJtTVK486418Z8tx/U69ev64svvqi5cuXSfPny6TvvvKNXr15VT09PDQsLS7JdzZo1tWvXrgnySpUqpW+99VaSbZ555hl94oknEuR99tlnWrRoUY2JiVFV1Tp16uhrr72WoE6fPn20bt26cddfffWVBgcH661btxwe59WrV9XJySmB8kmJO1Uae/fuVUDXr18fl7du3ToFdP/+/Um2S+lZxsTEqL+/vw4dOjSu/MaNG+rj46MTJkxQVdVLly6pq6urfv/993F1jh8/riKiixcvviv5HCUnKY17wU7DHzhhl3c2XtnR+AUi0g3oBlCoUCFWr16dqk6vXbuW6rb3KjltzC+88AKhoaEsX76cS5cu0bp1a06ePEnZsmUJDAwEICwsjODgYKZMmUKnTp2IiIggNDSUvn37JrhXkyZN2LhxY5J93bp1Cw8PjwR5np6enDhxgmPHjhEUFJRkna1btxIZGYmrqyu//PILdevW5dVXX2XevHnkzZuXtm3bMmDAAFxdXRPt++rVq8TExJAnT57UPCaH2LRpEz4+Pjz44INxeXXr1sXb25uNGzdSunTp29o48iyPHj3KmTNnaNKkSVy5p6cn9evXZ+PGjbz00kuEhoYSGRmZoE6xYsUoW7YsGzdupGnTpqmS707Jap+d9Po83wtKA6xZRXwkiXxUdSIwEaw1xpCQkFR1uHr1alLb9l4lJ435/Pnz/PTTT3z77bfUqFEDgLZt2zJlyhQ++OCDuHqurq6ULl0aPz+/uHbR0dEUKpTQprBQoUIsX748yf6aNm1K7969Wbp0KY0aNeLQoUN8/LG1JXf69GmCgoJo2rQpkydPpk2bNlSvXp3Q0FC+/vprIiMjOX/+PAEBARw5coSVK1fy7LPPsmDBAsLCwujRowfXrl1j9OjRifbdu3dvKleuTJ06dZKU7/jx45QrVy7uOjo6mlu3buHj4xOX16FDByZMmJBo+zNnzlCgQAHin08REQoWLMiZM2cSbePIs4xtm1idkydPxtVxdnYmf/78t9WJbZ8a+e6UrPbZSa/P872gNM5gzSjiU9D2ehaDIRUcOnQIVU3wRVqrVi2mTJlCmzZt4vKKFCnC/v37b2tvf3hPVW/Li8+LL77I4cOHadWqFZGRkeTKlYvevXszePBgnJ2dARg4cCBnzpzhwQcfRFUpVKgQzz//PB999FFcnZiYGAoWLMikSZNwdnamWrVqXLhwgddff51Ro0bdJkOfPn1Yv34969evj7tHYhQuXJidO3fGXW/ZsoX+/fsn+KWaK1euJNsn9kwceS6JtUuszZ0+78TqpFY+Q0LuBTuNTUA9EYk/b28MnALC0qNDtbMytr823Pu4u7sD4ObmFpdXqFAh8uTJk+AXtz358+fH2dn5tl+n//zzz22/huMjIowcOZJr165x7Ngxzpw5Q82aNQGIPeHn6enJN998w40bNwgLC+P48eMEBQXh6+sb9ys6ICCA+++/P4ECKFu2LDdu3OD8+fMJ+nz99deZMWMGK1eupESJEsk+DxcXF0qVKhWXihQpcltewYIFk2zv7+/PP//8k+CzoqqcO3cuyefiyLP097d+L6ZUJzo6+rbx29e5U/kMiZMZdho+IlJZRCrb+i9uuy5uKx8uIiviNfkBuAFMFZEKItIGeAv4RNPh23z16tUsXrwYt3//hU2b0NOnWbx4cZZbrzTcHcHBwTg5OXHw4MG4vPnz53Px4kUuX76cZDs3NzeqVavGsmXLEuQvW7YswXp5Ujg7O1OkSBHc3NyYMWMGderUue3L2NXVlaJFi+Ls7MzMmTN57LHHcHKyPqp169bl0KFDxMTExNX/66+/8PLySrA807t3b3744QdWrlxJmTJlUpTrbqlTpw7Xrl1j06ZNcXmbNm3i+vXrST4XR55lcHAw/v7+CeqEh4ezbt26uDrVqlXD1dU1QZ0TJ06wb9++uDqpkc+QBEntkKdXAkKw9iLs01Rb+VQgzK7NA1h2GuHAaWAQKRy31VScnoqJidFJkybpnNatNcrVVWO8vDTK1VXntG6tkyZNijvlkl3JaaennnzySX344Yf1+vXrun//fvX19dXChQvrd999F1fnxIkTWrp0aZ07d25c3syZM9XV1VUnTZqke/fu1V69eqm3t3eCE1dvvfWWPvzww3HX586d0/Hjx+vevXt1x44d2qtXL/Xw8NAtW7bE1Tlw4IBOmzZN//rrL92yZYu2a9dO8+bNq0ePHo2rc/z4cfX19dWePXvq/v37dfHixVqkSBHt27dvXJ1XXnlFfX19dcWKFXr69Om4dPXq1SSfRVRUVIK6iaVLly4l+zybNWumFSpU0E2bNunGjRu1QoUKtx1pLV26dIJjxo48yxEjRqivr6/OmTNHd+/ere3atUv0yG3hwoV12bJl+vvvv2tISEiiR25Tki+13O17MT3Ilkdu0zulRmmsmD5dI8XJejS2FCmiK6ZPN0oji3G3H9SzZ8/qE088oXnz5tW8efPqxx9/rAsXLtTChQvroEGDVFX16NGjCuiUKVMStB03bpwGBgaqm5ubVq1aVdesWZOg/Pnnn09wZPXcuXNau3Zt9fb2Vi8vL33kkUd08+bNCdrs3btXK1eurJ6enporVy5t1apVosdBN23apHXq1FEPDw8NCgrSgQMHJjiCm8SPsrgxJUbsOJNLzz//fLLP88KFC9q+fXv19fVVX19fbd++vV68eDFBncTkSOlZxsTE6KBBg9Tf31/d3d21fv36unv37gR1bt68qT179tS8efOqp6enPvbYY3r8+PE7li+15CSlka293FavXl23b99+R23011/h8ceJvzWmAPPnIy1bpqV4WY577fSUzbNoZothMGTJ9+LdfJ5FJFRVqydWdi9shBsMBoMhi2CURjxUlZVXrhDtlPCxROPMyitXstwvCYPBYMhojNKw4+jNm8xv1YpoV1cixDqOGYkzm1ZHZLJkBoPBkPk4rDRE5HkRWSwie0XkiF06nJ5CZhQiQqlSpfDq1o0tM2dy5rvlHCYYV6L5/bt8nD5tjIAMBkPOxiGLcBEZCAzBcmm+E7iVjjJlKiEhIagqa9asoXhIPSYt+44/v93OvFstONUG1q2DJFz8GAwGQ7bH0ZlGF2CsqlZU1WdV9QX7lJ5CZjTx3Qp0nFCX+UG9icGJOls+ZdqT8zJRMsO9wMWLF+nYsSN+fn74+fnRsWNHLl26lGybq1ev8tprrxEYGIinpycPPvgg27ZtS1Dn7NmzdOrUicKFC+Pl5UWzZs0SGCeC9aNHRBKkp59+OtE+w8PDqVSpEiLCnZ4yTA1r1qyhWrVqeHh4UKJEiST9WMXHkWd5/PhxWrZsibe3N/nz56dXr15ERCRcTt69ezcNGjTA09OTIkWK8P7779+2R5ka+XIkSZ3FjZ+Aq8DDjtTNSimtXKMvX676LN/rv+TWf/HTheOPpvq+WZmcZqeRXqQmbkPbtm21TJkyumrVKj148KAOGjRIc+XKpSdOnFBVy1ahdu3a+uCDD+qWLVt0//792q1bNy1evLheu3Yt7j4NGjTQF154wSGjvB49euijjz6qgG7btu2Oxvj8888na/dhz5EjR9TLy0t79uype/fu1YkTJ6qLi4vOnj072XYpPcuoqCitUKGCNmjQQENDQ3Xp0qUaEBCgPXv2jKtz+fJlLVSokD711FO6e/dunT17tvr4+Ojo0aPvWr5YsuJ7MVON+4DfgNcdqZuVUlrG05hU+2tV0Ot46Fanmnpgt+PxDO4VsqPSSG3MjPj89ttvWrNmTfXw8NC8efPqY489pjdv3ky0bmriNty4cUOdnZ31l19+SZBftWpVHTBggKpa1uKA7ty5M648OjpaCxQooJMmTYrLa9Cggfbo0SPFMf3yyy9arly5OHnTW2m8+eabWqpUqQR5Xbp00dq1ayfZxpFnuXDhQhWRBIZ83333nbq7u+vly5dV1Qpu5evrqzdu3Iir88EHH2jhwoXjDHZTI198cpLScHR56jXgBRF5TkTyi4iTfUqrmU9WpdUvL7DF5UEicaNGzFY21e/PtWuZLZUhJV544QVWrlzJ8uXLmTFjBmPHjqVnz54JYmYkx+LFi2nVqhWNGzcmNDSUVatW0aBBgzjfT4MHD06wnJlS3IbEiIqKIjo6OtFYGuvXrweseBxAgjpOTk64u7vH1Yll5syZ5M+fn/Lly9O3b1+uXr2aoPzEiRN0796d6dOn4+npmeIzSAs2bdqUIN4FWO7it2/fTmRkZJJtUnqWmzZtomzZshQrVizBfW/dukVoaGhcnXr16iUYa9OmTTl16hRhYWGpli+n4uiX/V9ABWAKljvySLuU7c+jFijkxOn3JuDNdf6kPB0ufsaAJw9gTDeyLrExMwYNGkSNGjVo3Lgxbdu25dtvv6V169YO3eODDz7gySefZOjQoZQrV46KFSvSt29fvLy8AMtTa/wAPqmJ2+Dr60udOnUYOnQoJ0+eJDo6mu+//55NmzZx+vRpAMqUKUNgYCDvvPMO//77LxEREYwcOZITJ07E1QF49tlnmT59OqtWrWLgwIHMmTMngav36Oho2rdvzxtvvEHlypUdfpbDhg3Dx8cnLk2fPv22vHXr1iXZ/syZM4nGxIiKirrNO238Nik9y8Tua+89N6m+Y8tSK19OxdF4Gu+TSMCjnEardx9g1tev0+74aDrK93y/pDTFP4E33shsyQyJ4WjMjOTYsWMHnTp1SrK8Z8+e9OzZM0FeauI2fPfdd3Tu3DnOu23VqlV55pln+P333wHL8+2cOXPo0qUL+fLlw9nZmUaNGtG8efME9+nWrVvc3w888AAlSpSgVq1a/P7771StWpVhw4bh6upKnz59HBl+HC+//DJt27aNu+7fvz9FihShV69ecXlFihRJ9h6JxcRILD+5NrHtUoqTYZ/vSN+pkS8n4pDSUNXB6SzHPYEI1Ph1EK1rNOSXiEcBmPfmeqpVqEFIUys+Q0pfDoaMI7UxM+6G+HEbYt8HqinHbShZsiRr1qzh+vXrXLlyhYCAANq1a0dwcHBcnWrVqrFz504uX75MREQEBQoUoFatWlSvnqiLIACqV6+Os7MzBw8epGrVqqxYsYJ169bdFhq2du3atGvXjunTpyd6n7x585I3b964a19fX/LmzUupUqUcfi6JxcRwcXEhX758SbZJ6Vn6+/uzYcOGBO3sIwIm1TeQYp3k5Mup3PFehC0eRjER8U4PgbI6JSr6UPdDS2HUdNvGqpgGHG/1Cmd+tmJvLFmyxMTeyCKkNmZGfKpUqcKKFStSrmjjbuM2eHt7ExAQwMWLF1myZAmtWrW6rY6fnx8FChTg4MGDbN++PdE6sezevZvo6GgCAgIAmDJlCrt27WLnzp3s3LmThQsXAjB9+nRGjhzp8DjvlDp16twWDnfZsmVUr149ydjmjjzLOnXqsG/fPk6cOJHgvu7u7lSrVi2uzrp16wgPD09Qp3DhwnEBsFIjX44lqR1y+wQ0BbYDUUC07XUr0NjRe2R0SsvTU/GJjFTtHzRDz5NX1zg9qAp6Qzw1ys1N57RurYsWLbon3ahnx9NTjsTMSI4FCxaok5OTDhgwQPfs2aN//vmnfvLJJ3r9+nVVVf3888+1dOnSCdqkJq7E4sWLdeHChXrkyBFdunSpVqpUSWvWrKkRERFxdWbNmqUrV67Uw4cP6y+//KKBgYHapk2buPJDhw7pkCFDdNu2bXr06FFdsGCBlilTRqtUqZIgrkR8Yl2ip3R66urVqynG24jvnt2e2COtvXv31r179+qkSZPU1dU1wZHWuXPnaunSpeOOGTvyLGOP3DZs2FB///13XbZsmRYuXDjBkdtLly5poUKFtF27drp7926dM2eO+vr6JnrkNjn5ksOR92JGk9lHbpvalMR+rABILwGDgX1YG+FZUnGkl9JQVd2z4KjewEMjSRh7I8rNTWNOnUp1v5lJdlQajsTMSIl58+Zp1apV1c3NTfPly6ctW7aMO3I7aNCg2+RITVyJH3/8UUuUKKFubm7q7++vPXr0uM2+YuzYsVq0aFF1dXXV4sWL67vvvpvgi/r48eNav359zZs3r7q5uWnJkiW1V69eeuHChSTH5qjSiB1nciml98/q1au1SpUq6ubmpkFBQfrll18mKJ8yZYoCCYJOOfIsjx07pi1atFBPT0/Nmzev9uzZU8PDwxPU+eOPP7RevXrq7u6u/v7+Onjw4Nt+2KUkX3LkJKXhUDwNEdkEXAQeU9WYePlOWDYcuVU1y8VMTE08jVgc8UW//P4ONDqYcA34pqs3+z4dSdUePVLVb2Zi4mkYDKkjK74XMzueRiVgXHyFAWC7Hg9UTpVk9zCqSkz/psTY5TtFRrDuRIks9wYyGAyGtMBRpXELyJVEmS/Z2IFhcjh7OKG32TUKP43JzeFDRmncC5QvXz6BrYG9LYLBYEiIo3Yaq4EPRGSzqh6NzRSR4lh7G6vSXrSsjYiQ59IlYjw9cL5xIy4/ysmVxeGNmFqnH88dGUyupFStIUuwcOHCJC1+kzsiazDkVBxVGv2BDcABEdkMnAb8gdrAJVt5jqNKmzbE2BlJuRDFcp9W9LwwhI/q3ccbv7fH2TmTBDSkiCOuRAwGw384tDylqn8BFYHPAHegKuABjAUqq+rBZJpnS1SVJbt2Ma9FC6Ld3Ijy8kWBnTEPsOWVPqx3bkDvPzrzZfv1Kd7LYDAY7hUcNu5T1dOq2ldVa6nqfbbXN1X1dMqtsx8igoeHB17duuEUFobL8iWsqDOAWmwnYuIWbk6fyzECafdja34afSyzxTUYDIY0Idt7p01PQkJCaNq0KRIQAHXq8NDy91nn3ZTBl95k+y8n2D54ATN5ms7v+LPeTDgyhE6dOt0WhEhEqF27dlydoKCguHwvLy8qVKjAV199leA+ERERjBo1iipVquDt7U3evHmpXbs2X331VZzHWUfJysGH5s6dS5MmTShQoAC+vr7UqlWL+fPn39H4UoOqMnjwYAoXLoynpychISHs2bMnxXaOPMs5c+ZQrlw53N3dKVeuHD///PNtdcaPH09wcDAeHh5Uq1btNmeLqZUvR5CUAQewEigT7+/k0oqk7pOZKT2N+5Jix5Kzegp/3UsZXbP4hvboYdn9Bef+Vw/vj0j5BplIdjDue/7557VRo0a3WSvHN3ALDAzU9957T0+fPq0HDx7UAQMGKKAzZ85UVdVbt25pSEiI+vn56dixY/X333/XI0eO6I8//qi1atW6o+eU1YMP9erVS4cPH65btmzRgwcP6uDBg9XJyUnXrl3r8BhV9TajvJQYMWKE+vj46OzZs3X37t361FNPaUBAgF65ciXJNo48y40bN6qzs7MOHTpU9+7dq0OHDlVnZ2fdvHlzXJ2ZM2eqi4uLTpw4Uffu3as9e/ZUb29vPXbsWKrlS+y9mNlkuEU41omoWKWx2nadZErqPpmZMkNpqKp+02GFvsSXWrRIjF64oNqy4VU9wH36o19XvXQx67oXyS5Ko0WLFsm2CwwM1FGjRiXIu++++/Tpp59WVdWRI0eqiCRqJR0dHR0X3McRsnrwocSoUaOG9unTx+Exqt6Z0oiJiVF/f38dOnRoXN6NGzfUx8dHJ0yYkGQ7R55l27ZttVGjRgnqPPLII3H/W1XVmjVrateuXRPUKVWqlL711lupli8nKY0kl6dUtaGq7rf9HWK7TjKlxawnu9Dhm4fZVvVlTpwU+r0aznc/+7AyX1vaXv6amTVHExX1X101RoBZAg8Pj7ijt9OnT6dRo0aJeo91cnIil+0c9dSpUxGRuEA+iZHVgw8lxtWrV8mTJ0+S5XfL0aNHOXPmTILn4unpSf369ZMMVAWOPcuk6sTeNyIigtDQ0NvqNGnSJK5OauXLKTi0p2GL2Jeof2ARySsiz6WtWPc2rq7w/ffQwnUpH/xQgq3f/0XTLe/zs+v/ePFgf757eDK60XjFTS8WL158m6Fe//6JnwqPiopi6tSp7N69m0ceeQSAgwcPUrZs2RT78fPzo3Tp0sl6Qc3qwYfsGTduHCdOnKBjx45JjgluN4q0zytfvnySbWP7Tky2pORKbjzxn2VSdWLva+82PbE6qZUvp+ConcYUoA5wIZGyYFv5tLQSKjtQtiw88U453IfcolDvdnge2sjfH/TkyFs76LSuK5ENvXEmkhstWkC3bpYjMBOHI02oX78+EydOTJCXO3fuBNcDBgxg8ODB3Lp1Czc3N/r168dLL70EOD77a926tUMRALN68KFY5syZQ79+/Zg5c2aK9iv2RpH33XcfCxcujAvE5Ig78cRkS+kzkNpgSvZ5aVUnJ+Ko0kjuSXljecA12NH5vaIMnDuVD3c/zrwGb9Jz0ztEv3sCiQK3iOsAtFqwAKdx48ybMQ3x8vJKMThQnz596NKlC15eXgQEBCR4/vfffz/79u1LE1myevChWObMmUPHjh2ZNm0ajz/+eIrjSkypBAYGxsWnSA5/f3/A+kUff3ntn3/+SdYK35FnmVSd2Pvaz8YSq5Na+XIKSS5PiUhlEeksIp1tWS1jr+OlHsCHQI4z7nMEJyd4eUFLxru9RqvjX7D55W9x8fJIUEddPZBk1pcN6UO+fPkoVaoUhQsXvk1hP/vssyxfvpzEPCTHxMRw5coVh/vJ6sGHAGbNmkWHDh2YOnUqTz75pMNjSy3BwcH4+/uzbNmyuLzw8HDWrVuXbKAqR55lnTp1Etw3tk7sfd3c3KhWrVqydVIrX44hqR1yrLgZMbYUHe9v+3QOeDyp+2RmyqzTU/b89H24bqOafuncXSNd3TV+/I0IXPTwhqwRfyO7nJ5K7MjtP//8E1cnsdNT8QkPD9f69etr7ty5dezYsbpjxw49cuSIzpkzR+vUqRP3nBILGmRPVg8+NGPGDHVxcdExY8YkeUQ5Mf75559kAzLFf96JMWLECPX19dU5c+bo7t27tV27drcdae3YsaN27Njxjp7lhg0b1NnZWYcNG6b79u3TYcOGqYuLy21Hbl1dXXXSpEm6d+9e7dWrl3p7e2tYWNgdyRefxN6LmU1mHLn1AwKBIJtyeMJ2HT/5gxWTIyumrKI0VFW7PHNNQbVHrs+sQE25/DQSZ1XQ5/P8qP/8k/lHcbOL0iCRAEFFihSJq5OS0lC1FMeIESO0YsWK6uHhoblz59ZatWrphAkT4gIfJRY0KDGycvChBg0aJPq8GjRokOyYAgMDkw3IFBgYmGz7mJgYHTRokPr7+6u7u7vWr19fd+/enaBOgwYNbpPDkUBJP/30k5YuXVpdXV21TJkyOmfOnNvqjBs3TgMDA9XNzU2rVq2qa9asuWP54pOTlIajQZgCgdOqGpFi5SxEegdhuhOuXIGSJa9S5PxhRlf7gUbdSnH1vkqENe1G0cjjvFDpd2ZsCibe6cgMxwRhMhhSR1Z8L2ZqECZVPXavKYyshq+v8s47e/iYPjwSOoqoXq/j1aw+R+sUx0mUgbuepP3/womOzmxJDQaDIWkc9j0lIt1EZIeI3BCRaPt0J52KyCsiclREwkUkVETqpVC/rYjstPV9TET63Ul/WQER4bWnA6nnvBEBXG7dwDkighabl3L1g08pKOf5c9Fxune3NjsMBoMhK+KwcR/wObANyyX6FOB74ApwGHjf0Q5FpB2WS/VhQBVgI7DIFtApsfrNgR+AiUAF4BXgdRHp6WifWQUJC8PV2z1BnpOHB0UfLsPfy/Zz3P1+Jk2CDz7IJAENBoMhBRydabwGDAe6267Hq+rzQAngJokb/SVFH2Cqqk5S1X2q+ipWUKfuSdTvCPyqquNV9YiqLrDJ0l/uMeMGDQoiJt7xR4DoqzfQoCAefMSTGdMiGcFbzBi0j0mTMklIg8FgSAZHlcZ9wFr+O2brBqCqF7HsNHo7chMRcQOqAUvtipYCSR2AdgfC7fJuAkWxTnDdE6gmDNoU4eXHLdx4Ub/is1lHUVVa1zvPqz7fMJsn6fPSdRLx6GwwGAyZiqMW4TcBJ1VVETmDNcPYbCu7BhR28D75AWfgrF3+WaBREm2WAGNFpAmwHCgFvGErCwDC4lcWkW5AN7CsXlPr1+natWtp7hMqKioKl06d2NKhAx6nTzNuYR2mLqxK+Q+PUj3iSyJrlCPP4P480Lcf4/Vl2rWdyqjRf1Cp0uU0lSMp0mPMBkNOIat9dtLt85zUWdz4CVgBvGz7ewbwJ5YvqhrAViDUwfsUxjrHXc8ufxCwP4k2AozEUlxRwL+2+grUTK6/rGSnEUv8M/Lh4aqVK8fofB7Ta65+GrP/gFVn8BBV0Bf5Sn19VXfuTBdRbuNes9NIyVbAJJMyKqVkl5IZZLhrdDsmArG+kgcCPsB6rNnG/fz3yz8lzmNZl/vb5Rfk9tkHQKzFTH9bn4G2tlttxWEO9ptliL8N4+4OP/0kvOX1OTciXbnU4HG4fBkZ+C7auAmfuPaHq1do3BgOHcpEobMoYWFhd20AumrVqkw3Qs3oZMac9ik5V/PZDUftNH5U1eG2vw8B5YGmQGuglKqudvA+EUAo0NiuqDHWKark2kar6knbPZ4BNqnqP470m5UpVQoGTg7iSWbjc/Ywl1s8C6rI9O9x27CaGg/n4tw5eOQROHnSaqOqmSu0wWDIsaQqRriqXlfV5ao6X1UTDwqQNJ8AnUSkq4iUFZGxWMtWEwBEZLiIrIitLCL5RaS7rW5lW/2nsE50ZQuefhrKvdyAV/kcvw0Lufn+KChQALcalejbdx3PF53HreOn6Vt3Exf2mBgcBoMh80hyIzwpu4mkUNXjDtb70RbQ6V2sjew/gUdV9ZitSgBQ0q7Zc8AorP2NTUCIqm4lG/Hpp1Bn88v03BnFxS3P8L0CKPl3rGPqiQFE4sL1Y164PxDB5Ucfg55dUDX+/Q0GQ8aS3OmpMKxNHkdxdrSiqo4HxidR1snu+jzWpnu2xsMDZs+GKlV6cnUJVB0RwRtPHad6p07owIG4xkSRmyug0Grhb8R89plRGAaDIcNJTml05s6UhuEuKVkSvv0W2rSBgAEvcOuT1bh/MwH18bE8HtoIV3feaxfGqPUBuLsnc0ODwWBIY5JUGqo6NQPlMNho3Rr69oWRo9/kifO/EDFgCM43byaYxnkQzqztwRxra81OHIisaTAYDGlCqjbCDenL8OGQu34lOjINt92h/O0fQLSLC+rlRYyzMz80fJornnmYPx/at8d4xjUYDBmGQxbhIvJNClVUVbukgTwGwMUFfvwRqlRpw+Azgxj89xBinJ1BBHV2JnfuK3z52FBcfz5Op58m0dnTjSlTrPCyBoPBkJ446kbkYW7f38gL+AKXbMmQhvj7w+zZwtP1X2RAzIe4RkfB9es4A60WLMCpfwUkahqFnE7RetocPDxyMWECmL1xg8GQnjhq3BekqsF2yQ8IAc4A/0tPIXMqdevCp68d5zpeCfKdPD2R5s1hyhQasoo1EsK8iWfo2ROM3Z/BYEhP7mpBQ1XXAp9ixdowpANt3gjCwylh0MSYG5Y7dTp1wum3X3nA7QCbeJAfx5/ntdeM4jAYDOlHWqyCH8EKpmRIY1SVpX/s4tcWLbgpHlzBFwXCnV1YvXy55U6keXNc1q4i+n9tueKSj88+g759NYHiMG5HDAZDWnFXSkNEXIBOwIk0kcaQABHBw8MD31e6cn7LEdr5LaExS5EoZ2oOHIhcvGhVrFmTUrNH8NNsoZzTXv78ZCmDXz6NbtyEnjZuRwwGQ9rh6OmplYlku2F5uM0HvJyWQhn+IyQkJM5dyDu/BvDww9Aiaj7LTzazjDpWr47b/X78ceX++17hvgNriZ7oQvhUT9wI50aLFtCtm3E7YjAY7hpHZxpOWH6f4qerwFzgEVU1wUnTkdgv+nr14PPPYTUNeZYZHGjZN8FxKRGhzPyJOAm4E4lnxBWcIyJotWABTStVMgrDYDDcNQ7NNFQ1JJ3lMDjIyy/Dzp3w1VdtWDMaQp+BIqe3Q7VqIIJcuAC+vgncjkSoBx5HwyAgINPkNhgM2QNjDnYP8tln1qzj7Fno+/DvaK1a0L8/ABoUREx4wpDqGhlJv/FBxMRkhrQGgyE74bDSEJH7RORbEflLRK7bXqeKSKn0FNBwO25u8PPPEBQEM/+qwpLAl2DUKHT0aJbs2sW8Fi2IdnND/fyIdHGnu4xnynQ3vmj8i3E5YjAY7gqHlIaIhAC7gMewQryOt722BHaLSIN0ks+QBPnywYIF4OsrtDj6OX+WeRLp14/ANWvwfPFFnMLCkEWLcDl+lNJDy/Gu04f0WtmahRXeJCo8KrPFNxgM9yiOzjQ+BnYAgar6nKr2U9XngCBgp63ckMGUK2f5qMLJmWr7v+d0uYcp89FH+B47lqBe1ar/4jKyHZNcutNy/yj2FmtKxMlzmSO0wWC4p3FUaZQDRqrqtfiZqnoVGIkVM9yQCTRvbkX9i8CdBw7OZWmbN/lnyRJigoLQZs2ICQrixsSJ3FfhIg+sG0cPz2+4//wGLpWqRvj2PzNbfIPBcI/hqNI4gWWXkRhuwMm0EceQGnr1gh494EKkH72X9eLxBYtwjohAriQ8clu7ttB1wws8mmsDB8IDaduzIFeu3G4xbizIDQZDUjiqNEYCQ0SkSPxM2/UgYFhaC2a4M8aMgWbNIM/lMG5EJQzn5+TpiYSFAVClCnyxqRptC63l1y0FqVP9Ars6vYKGhZFrzx5jQW4wGJLFUaXRAMsN+mERWS0iP4rIauAw4AOEiMg0W/o2nWQ1JIOLC8yaBe6lg3DRyARlMTdvWg4ObZQrBxs3CUFBStDBzVSeNgFKlKBiv35xy1nh4eFmxmEwGG7DUaXxEBANnAYCgZq219NADFDPLhkyAR8fpcuA/fR2H8MNPIl0slYUt1WuzJJduxIogeBg2LBBuFyyKrdwQ1RxuXnTWJAbDIZkcdQiPDi9BTHcPSJCsWJC1U/L8UDfwxS+cZCZ+V+l6r59hF69epsSKFwYFnwRRkQLD9xj/nO/7uTqai1nGQtyg8Fgh6OR+wz3CCEhITRooJQsKbRoEUDD8z/xY70vqNOiRaL1c1UKItolHOKF7Ii+FYFzUBBmnmEwGOy5E4twLxHpKSI/icgKEZklIq+IiFfKrQ0ZiYjQpAlMmgQHuZ9q6z/jpwVe2PsRUVWW7NrFfJsF+TVnX27gSZfoibw3/jS6d28mjcBgMGRVHLUI9wd+Bz4DqgNeQA3gCyBURAqlm4SGVNOpE3z4oRXJ7/32B7he8gHYujWuPDZeh1e3bjiFhbHv0+EM6nCYadqJsA/3ohUegG/NuQaDwfAfjs40PgLyAPVs8cHr2PY5HgJyYx3JNWRB3n4bXnkFTkQW5MKxa9x68lm4ejWuPCQkhKZNmyIBAVx/oDwfTQvgvfeUn/UJlusj0KkT+umYzBuAwWDIUjiqNJoDb6vqhviZqroReBdIfMHckOmIWF5xG7bOQ3v9Hpe/j3L1hVft6kiC+kOGCKO/9KGV/Mps/of0eZ2Yd98zwccNBoPDSsMHOJVE2QlbuSGL4uwMP/wAzg3qMZR38Z3zLZcnzEi2zcsvw8yf3enkPpPJdIYPh3Jj7fYMkthgMGRVHFUaB4COSZR1APanjTiG9MLDA+bPh/kVB7KROvzx5ndcvpT8zKFVK1i2yoV+ub+mHut46PUanDmTQQIbDIYsiaNKYzTwjIgsF5HOItJcRF4QkSXAs8Co9BPRkFbkygULl7rQK3A+Da/O59EWwo0bybepUwc2bxFOBdVlxw54o+IyrjR9Cm7ezBihDQZDlsIhpaGq3wMvAxWAr4EFwGSgIvCyqv6QbhIa0pRChWD26vwUDHDhr43nGFPnRyIikm9z//2wZQtUrw5e58LwWTqHi3WaJwgpazAYcgYO22mo6kSgMJYb9Hq21yKqOimdZDOkE0FBsGIFDPUYSv8/nuX9pusTRPRLzOdUwYKwZg388/iLtGc6Prs2cL7iw3DOxOUwGHISySoNEekkIjtF5JqInMBahjqsqhtUdZ+qmqjT9yhly0LNJUM5JkG8uLo97/xvPz67k/dy6+UFc+dCod7P8AS/4H1sD/+UrU/MuQsZPwCDwZApJKk0ROQZ4BssQ74FWM4JX8e4Qc82VK7nw8aeAyjC33w4rwJl+7ydopdbZ2fLDfujX7SgudNSZl5oTNuX86a4N2IwGLIHyc00XgN+BsqqajtVrQEMAXqIiPPddGpzP3JURMJFJFREkvWMKyJNRWSTiFwVkfMiMk9E7r8bGQyWfUb7t5sjTk64EI131FWHvdz26AH9f6vHAJ/PmDNXeKbWEc4t3ZGB0hsMhswgOaVxPzBJVeOtdjMecAeKp7ZDEWkHjMWasVQBNgKLRCTRe4pIMDAPWGer3wjwBBamVgbDf0hYGE4+3gnyIuW/oE3J0bw5bN4MxYpB7z+74t4shL8mr0snSQ0GQ1YgOaXhB/xrlxd7necu+uwDTFXVSbZ9kVexlr66J1G/GuCKZZF+SFV3AsOBkiKS/y7kMAAaFERMeHjCzFvhjJ4T5FD78uUhNBTGVvmWk1qYYl2bsO5to88NhuxKSqennEQkLgHOieXbylJERNywlMBSu6KlwINJNNsORAJdRcRZRHyB54FtqnrekX4NiRPr5XaezcttlLc30eKMC5Gs/XgbH37omNuQAgVg1qZijGu7lj2Up/aIVvz0vxn2TnUNBkM2IKUv+w1YX9ixKdaia4tdfgon/ePIj6V4ztrlnwX8E2ugqmFAY6z9lFvAZeAB4DEH+zQkgb2X2z9GjsRp3x5O+ZdjNk+y5d1fGT7csXu5u8PnMwuw4f2VbKAuReZ+Ttv/RXPtWvqOwWAwZCySVBxoERl0JzdS1SEpdiZSGDgJ1FfVdfHyBwHPqGqZRNr4A2uBX4AZWLHK37cVP2x/7FdEugHdAAoVKlRt5syZdzKMOK5du4aPT85yqRU7Zudr1wjsNgD/0/t4ktn4v1iBZ5897vB9Qtd78enwYE7eKMD9Qf8yaOgBChe5lY6Sp56c/H/OSZgx3xkNGzYMVdXqiRaqaoYlwA2IAp6yyx8HrEmizQfADru8ooACDyXXX7Vq1TS1rFq1KtVt71USjPnSJT0bXFNPUFg9uKFDh97ZvfbvVy1X6pYupZF+5t5Xly6JSVNZ04oc/3/OIZgx3xnAdk3ie9Vhi/C0QFUjgFCs5ab4NMY6RZUYXkC0XV7sdYbKn6Pw86PgjqVs+WAZt8STd9+F999PuVkspUvDxq0u3Awsy6u3RnO86Yt8NDzaeFc3GO5xMuNL9xOgk4h0FZGyIjIWyz3JBAARGS4iK+LVXwBUFZFBInKfiFQFpgB/YykgQ3rh50ebd8vxzWRlMIMJHTSPAQMcD6vhl8eJxw6PZcVDg+jCZEq8045n/3fL7HMYDPcwGa40VPVHLMPBd4GdWNH/HlXVY7YqAUDJePVXYnnSbQXsAJZgbb43U9XrGSZ4DqbTM7foUXIRs3mSP4fN4803HVccTs7CI+sG80fnMTzJHB79uSs1a8KBA+krs8FgSB8yZXlHVcerapCquqtqNVVdG6+sk6oG2dWfqapVVdVHVQuoaktV3ZvhgudUPDzIH7qUq6WqMpsn+Wv0PHr25I6O1Fac3JtTI79jVuCb7NtnecydOzf9RDYYDOmD2RMwOIafH3m3L+XafZbiODF+Hi+8QALvuClR+M0O/LD7Adq0Vl689gk9/3eKN95QIiP/q6Nm08NgyNIYpWFwHD8/8mxbyvVyNcnjep1p06BdO1KMxxEfX1+Y/fExRrgPYh31+PmTo7R58DTn5m9K1sOuwWDIGjisNESkiIh8IiLbReSIiFSw5b8mIrXST0RDlsLPj9y71/Hiqmfx9YXVc87z+OPckZdbCQ7Cdc1yCnudJ5Qq/LQ9GPcnmhFVPDhZD7sGgyHzcdT9R3lgN1ac8FNAIJbNBba/e6eLdIasiZMTdevCtlGrCSMI9yXzaNwYLl1y/BZSqxYeC+eTmyt4cItcegXXqFu0mL+IRhWS97BrMBgyD0dnGh8D+4BgoA0Q/xO9EaidxnIZ7gFKP10F54oVmM2T5N84j/r14cwZx9uLm5u1XhWPm9Hu9H487I7uYzAYMg5HlcZDwAhVvYZliR2fJP1GGbI5fn54rl1CTJVqzOZJgnfP48EH4fBhx5prUBAxtxK6F/HiBpd3HKZiRVi2LB1kNhgMd4WjSiO5w5X5+c+RoSGn4eeH+6olUNVSHLmO7qROHdiRQjwmtfOwq35+RLu5cdXXm+/pyIhznWnb5BJvvUWC01UGgyFzcVRpbAVeSKKsLZY3XENOxc8P15VLiB72EXlDKnHuHNSvDytWJN3E3sOuLFqEU1gY27//lqPPtqeTfMtuKrBz5GLq1wcHYkIZDIYMwFGl8QHQUkSWYm2GK9BIRL4FWgMfppN8hnsFPz883n6dxUuEns0P0eDabzRvDtOnJ90kJCSEpk2bIgEBUKcOEhBAk5YtCZ7+PU5bNpMnyI/feIzTm8OoWBFS6bDYYDCkIQ4pDVVdAzyBtRH+DdZG+AigHvCEqm5JLwEN9xZubvCZ19vMc2pNi8if6dABRoxI2u2I/SmpuOsaNfDeF8qNWQt44LEgrl6FQc8coFMnuHo1fcdgMBiSxmE7DVVdoKr3YcUOfwgoq6olVHVRuklnuCeRbybjXLM6s53a0pqfeftt6NEDoqLu8EYeHuR6qinz58PPvVezj7LU/vZl6la8yubN6SK6wWBIAUftNN6zBVBCrTjdG1X1gK0sQETeS08hDfcYuXLBkiWW4nBuy1MuP/Pll/D446TKw60IPDG8Fv++8AbdmMj8sAcYWHclgwenQhEZDIa7wtGZxiCswEeJUdhWbjD8h01xONWozqTyY8jtpyxaBA89BKdOpeJ+np7k/2YUUavW45XbjWUxj+A5pD9168Jff6W59AaDIQkcVRrJmefmwYrdbTAkxKY4/Nb+ytZtQnCQsmsX1KgBO3em7pZuIQ9S8OROjv3vdf7NFczWrVClCowf77i7doPBkHpckioQkRDg4XhZL4nIY3bVPIEWwJ40l8yQPciVC4D7nK+zP6gN77m9xMi/2lC3LsyYYS1Z3TFeXgTO/oS3L8Gxl8H9x2+J6hFKqznD+XKaN0WKpOkIDAZDPJJUGkADrEBJYB2xTcxOIwLYC/RKY7kM2Y3oaNzCrzD8SDsKPfQjfda34YknYORI6NvX2re4U3Lnto7h7rl1kPK/fM6jKxfStfQU2k+oR/v2qbunwWBIniSXp1R1iKo6qaoT1vJU7djreMnDFhxpU8aJbLgnsS1VSfXqvLa5HbOenosqvPkmdOoEt+5igbP8z0O5MGc1Xp7KgusNONfxddq1vMHZs2kmvcFgsOGonYaTqm5Nb2EM2Zx4iuOp2e1Y13ceHh7KtGkQEgJnz6Y+CFO+Ng0IOLuLfSGv8DpjuLJgLWXLWktgZq/DYEg77jgIk4gUFJHi9ik9hDNkQ2yKg8cew638RUaN2kilQqdh8yaaVT7N559vSnUQJvH1ofyqLzi1bA+3Qppx8SJMfnY5T7e6yenTaTsMgyGn4qidhpOIDBORC8Bp4GgiyWBwjFy50Llz+dffn8IrRhP6byDLnJux4UxJQl87wMKFee4qCFPhRuVYuRKmDjvFAlow5NcqdLxvM99+a2YdBsPd4uhM4zWgB1ZcDQGGAUOxlMVh4MX0EM6QfRERmlaqxBO//opzZCQ+0Vfw4iZfag+mjSpEnz5yV4Z7IvD824W5PH0BeTxusuR6Xc506k/LxuGEhd2+DGYiBRoMjuGo0ngBeB8Yabv+WVUHAWWBk4BZnjLcMRIWhnh7J8hzcXPiPuejjBkDjzwC//xzd30UfLYRBc/s5lD9LvTnI4atqEnFMjfp3n0/USdOk2vPHhOb3GC4AxxVGiWA7aoaDURh2WegqpHAGKBzukhnyNZoUBAx4eEJ8lwjrvNdxyUULAhr11qGe1vu0h2m+OWi9JqJ/PvDYkIrPM/VW55c/2o7UcVLUKFff2KCgkxscoPBQRxVGpcBD9vfp4DS8cpcgLxpKZQh+5NUEKawwEDOlvVixw6lVk3l1CmoVw/Gjbv7/Yi8zzTlhd1v8NvXp/marnhoOG43r+McEcHjCxbQtJKJTW4wpISjSmMHUM729xJgiIg8IyJPAcOB39NDOEP2JakgTAcmTOBmzZoULixseLAf68t0xSvyEj17Qvv2cP363ffdolwYbl4J7VrDI93ZMjPs7m9uMGRzkrMIj88YrCUqsJwTVgViw+scA3qmrViGnEBISAiqav26DwhAgKb+/ta1Ks6ebtQ9OJXTfgvofHMcM2a0YedOmDMHypZNfb8aFERMVBTO8fK89Srr+8zmk011GDMGChe+u7EZDNkVR437lqnqV7a/zwA1seJqVAbuV9U/0k1CQ7YmySBMIjBsGGzdimewPzMi/sdin//x774zVK8O06alrj/7ZbEob2+iXd3YkacSR11K8dNPUKF0JONGXDVu1w2GRHDUTuM5EckXe60Wh2zKwldEnks3CQ05m6pVYetWGD6cJs4rePbRy9y4Ac8/D5073/lylf2y2B8jR+J0LIx/fhjBQ9Mq07w5PHXtG556uySjin/OpjUR6TMug+EexdE9jSlAySTKgm3lBkP64OoKb72F/P03H/9WmokTYaDzMNZOOUT16rB7953dLn5s8ivlyyMBATRt2pRnnqnDwoXw9OjqHHSvwNune1EopAxf1vuBs6dj0mdsBsM9RlrE0/DGOoZrMKQvvr6IwIvN/maQ50h2S0Va7B9NnRpRfPnlnZ2uSnJZDGj4RjWqXFjB5KcWc0X86L6+PWuKd2TsWIiMTKvBGAz3JkkqDRGpLCKdRSTWBqNl7HW81AP4EDiYIdIaDADFiuG8fy+ujzZmNP1Yfas2E17ZRevWcOFC2nTh5S10mdUU732hDK8wnS+juvLaa/BQhUtsHbctbToxGO5BkptptAK+tiUFBsS7jk2fA2WAd9JXTIPBjiJFcPn1F/jxR8rn+psl0oxF827xwAOwcmXadXNfaSfe+uNZev/ckOLFodlfY6nZsyYbirbl+ArzW8mQ80hOaYzB2q8ogbU81cZ2HT8VBgqq6vz0FdNgSAQRaNsWzyN7iflxNpVrunP2dDT9H9lOv353F6PDvpsnnoADB8DrndcZ5vIelU4uJKBROTZVfYVrh86kTUcGwz1AckGYLqvqMVUNw1IQC2zX8dMZNX4XDJlNvnwUfqouGzbA3Ecns40aBI9+hYbVrvDnn2nXjYcH9P8wF88dHcIbrQ7zFS9RfcckVlfowddfQ3R02vVlMGRVHLXTOGbzM4WIuIvIKyLyhYi8IyLGDMqQJXBxgVaz2nOq3eu8xFf8uKc8A6v8xscfQ0waHn4qWhS++qUQ1TZ+wVPl9/HarZG8+CK0LHeYA6+MSbspjsGQBUluI/x9Edljl+cObMHay3gFyz36DhEJvpNObUrnqIiEi0ioiNRLpu5gEdEkUsE76deQA/D2pvDMT7i1ahOSOzc/R7Uksu9bNGwIYWFp21WdOvDz7lIM/q4URYpApb9mUfrL1zmbuzQnhn9nph6GbElyM41GwEK7vB5ARWAU4AfUBiKBdx3tUETaAWOxYnJUATYCi5KJ/jcaCLBLa4DVqnqXjrMN2RWvkJoUPRvKvmfeZ5Nfc9auhcrlI5k0UVFNu3gaItChAxw8CF7vv01Lj2X8HZ6fou88x4kCVbjw/aK0GI7BkGVITmmUBOzjgj+BFbnvbVW9aosbPgp45A767ANMVdVJqrpPVV+13bN7YpVV9Zpt7+SMzYWJK1APmHQHfRpyIm5ulP1hIJMPNeCJJ+C9G/0p9lJzHq+0i+++W4OeTrt4Gp6eMHAgTD7WiEldt/KMzCT84g1+6rSAAQPgypX/6poAUIZ7meSUhh9wNvZCRNywfE6tstv83oX16z9FbPeoBiy1K1oKPOjIPYAuwCVgjoP1DTmc/Plh7lyo16kUddnAjN11ce40kchiwVTsn7bxNAoWhK8mOTFobzv6PbqXftHDGTYMni22joOV/sf6r6exZMkS9PRp2LTJBIAy3HNIUh8SETkMDFHVabbreljLQj1VdXy8eo2BH1U1xZgatk3zk0ADVV0bL/89oL2qlk6ysVXPCQgD5qjq60nU6QZ0AyhUqFC1mTNnpiRWoly7dg0fH59Utb1XyQljvnngXwr0/5Tql9cnyI92c2PLjBlE5E3b0DB79uRiwoQSVPlzPuPogSc3ORRQifvO70bd3JDISLZ26cK5Zs3IlStXmvadFDnh/2yPGfOd0bBhw1BVrZ5ooaommoCpWHEycmPZafyE5S4k0K7em8AfSd3Hrm5hLEPBenb5g4D9DrR/zNa+vCP9VatWTVPLqlWrUt32XiWnjDlm/QaNdPO0tjZsKdzDT6PWbUyf/mJUf/lFtU7JszqRLhoTr18FjXJz05hTp9Kl78TIKf/n+Jgx3xlYkVoT/V5NbnlqCBCEtUR1CfgfMFFVj9nV6wSsxzHOA9GAv11+QeIthSXDi8BGVd2TYk2DISlKBCMkPNnkHH6NcU+vZtfvaX/iSQRatYJ1BwoS8E4XrkvCX38xLh4w6WuIMB51DVmf5Iz7jmLFyxgJTAOeV9VX4texLTetwEEvt6oaAYQCje2KGmOdokoSW18tMBvghrtAE4mnEeniziEpQa+T70C1qnz1zGpu3Ej7vp2doUXPIDxdEyqHmBvhyKD3uFWoGPruQDhxIu07NxjSiGSN+1T1uKq+p6qvqup3iZSfspXdiQe3T4BOItJVRMqKyFisZasJACIyXERWJNKuM3AdmHUHfRkMCUgsnobL8aPs/ekLRtaYgB+XeWlmQ1YXeIoV09PWPYi9wtJcfkQ4u9PD9XOasYill2qiH35ITGAQ/O9/cPlymvZvMKQFjrpGTzNU9UfgNSzbjp3AQ8Cj8Za9ArCL3SGW3+ouwHRVTYffgIacRGLxNFq3aUz/rS9xdtU+Pi/wPuVvbOXJDu489RScPJk2/d4WF33xIlz/PsqjM4Mp/ML9dPT7lZIcZlTMG+xafo5Vobksd+/r1iU8s2swZCZJbXZkh2Q2wu8MM2aLiAjVkR/cUk9PVSeidKHzY7qg/XSNuBWTJn3GxMQken35surAgaq5cqlCjILqw3VuaIS3n8b4+Kh2767655933b/5P+cMMmMj3GDIkbi6wpvvurFvH7Rv9A8Fo0/x6PT27M5Tj9CJoXd9/6QCQOXKBe+/D8ePw7vvCn5+sHKTJ3WuL2eBx5NEf/0NVKgAISFWCFyDIRMwSsNgSILAQJi2LICTc7fSL8/XFLlxkCov1WBlya6c2p9+y0V+fvDBB5byGDwYjuSpTsvzUygUeYIxASO5vvcY0Wr76B4/DqdOpZssBoM9RmkYDCnweGtn3j/Zhclv/sVY5z7kO7KNctU8GTYMwsPTr99cuWDQIEsvDB8OTgXy8/rpN/E9d5hyz1VnyhSIfm+wpd3atoU1a+4s5q3BkAqM0jAYHMDTE94Z6ccTB0cz6NHtXL7hyvABV9mZJ4RNAxem63e1jw+89ZalPMaMgSJFnfjrL+jcGRosfofQur3QZcusZauKFeHbb9NPGEOOJznX6CvvICV2RNZgyHYEB8MvC1xZsgTqBf5NnvDT1Bnagi35W7DvlwPp2reHB/TuDUeOwOTJcN99sOFsKaqv+ZiinOTnFl8TKa7w++9WA1X466+49mocJRrSgORmGk5Y7kNiUxkgBMtK3NP2GgKUtpUbDDmGJk1g/qFyLP5oNwM8Pqbsv+sp1boCSx7oy+njkenat6urNcvYvx/mzIHq1eHUJS/aLOiC74FQXrn2kaUrVq+G0qXhkUf48/33WbpwYZp69jXkTJKzCA9R1Yaq2hAr/kUkUFtVS6hqHVUtAdSx5Y/NGHENhqyDiwv07ufGGyf7MOKFv5gmndA//6RUGRcGD4Zr19K3fycnaNMGtm2z9EPTpnArQvjyG3fKlIH2Ix7g6IvD0EOHqDBoEPWefBItVoyKb76Zpp59DTkLR/c0PgAGqhU/Iw5V3QIMxorgZzDkSPLmheHfFOKhfZMY3/w3btwUvhlynD/z1mNev/VEpu/EA4AGDWDxYtizB557zpqN/LA0PyUmvU3NfEfY+OI3eN66hVN0NC43buAcEUGrBQtoWqnSbUeADYbkcFRp3AecS6LsH6BU2ohjMNy7lC4N8xe6sHo1NLrvOEUiw2g1uh6L8z7Lool/x22Wp+feQrly1j748ePW5nnevLB9hzNvTCrDVXwT1HWKjESaN7fWuKKi0kwGQ/bGUaVxFHgpibKXsGJcGAwGrF/9kw88xMbJ+xnrN5BG136m/ktlmFDsQz75eEeGBGEqVMg6pnviBIwbB04lgnDRhFOeGCcn9MIFePJJKFUKRo+GS5fSVA5D9sNRpTEEaCkif4rIYBHpbnv9E8vz7OB0k9BguAcRgXadven+z/vMGLiP5W4tcDp5nDf6VmHZc38SFRiMNmuW7nsLnp7Qvbvy7he7+LZOR8LFg0v4cQNPOkVPoVKu39nwxhzLSWK/frBhg9XQ7HMYksAhpaGqM4GmwGXgbWCc7fUS0FQtJ4QGg8EONzfo/H4Qj1yYxdmB4yjhdZoPz72La+Qt5MqVDNlbEBE8PT0Ifq817iePsPm90bzX/jBzPJ9h994CPPRxG4odWs2E7rs4Xbm51ejdd+HRR2HJEqNADAlw2LhPVZeral2s47b+gKeqPqSqxkbDYEgBHx94730XdswNw8nFOUFZdJQTx379I137j+/Z16NhKUZ/H8CZM8588gmULGl5Iun+ZUWKBznRrh0cvFwQ3bEDmjWD8uVhwgS4fj1dZTTcG9yxRbiqxqjqP6oakx4CGQzZGd+KQTg7Jdx0dosJx+mlrjzTLoa9e9Ovb/uZTK5cwuuvw8GD1smrRx+1JhWzZsH943pT0TeMxc9OI8rNC7p3h5490084wz2Dw0pDREqIyFsiMl5EvrFLk9NTSIMhO6D2QZj8/Ihyc+fLwt143WksM2c5UbF8NJuKPcXfI6bDrVsZIpeIZeOxYAEcPQr9+0PBgvDnQXea/9AR3/3b+KDpen5/uK+1UrVnD7RrBxs3mqWrHIhDSkNEWgH7sewxngAaJpIMBkMy3BaEadEinMOOEjy5NW1/CKBLFwh2PUG+E7so9nYHLuUqxukX3rHOz2YQxYrBiBHWqauZM6F+fQi/Jby3pC7VnitP+fIwf9QBYpYshbp1oWZNmD7dxDfPQTg60xgKrAYCVLWwqgbbpRLpJ6LBkH2Iv7dAnTpIQABNmzalXbs6fP01rDoSyJiX9vOoy1JWRdSl4NSRRAcGs2PClgz9Ue/qak0m1qyxlq/69IH8+WHfPmj1bRvyXj/BpKrjuXbmKnToYO17GFuPHIGjSqMEMFpVkzLwMxgMDpJUECaAokVh/AQnJh9vzJreP1Pe8yjvMpTq3atTty7sfukLYj75FC5ezDB5S5WCjz+2NstnzYJHHoGrMd50+707uU7spWP+Rcwv+TqHwlys5arBg2HXrgT3MM4Ssw+OKo39QL70FMRgMPxHQIDlBn3jieLI22+TK7czmzbBoYkrcHqjD1H+RYju3BV27MgwmVxd4amnYPlya+/j3XehWHEnvj/fjFZLXuG++6BtzTAih4+CypWhYUOYN4/VK1ZkiEGjIWNwVGm8CbwjImYZymDIQPLmhWHD4O+/4aOPoEfAz1RmB5MjOnJr6gyoWpXwNwZkuFzFi1vRBY8ehWXLLGXi6Qk/bQ+mYMQJ3nH5iPNbj8ATT1CjQwdcRo0iJigoQwwaDemLo0pjMNZMY5/NKnytXVqTfiIaDAYfH8tgOywMek2uzKelv6KwnqQXY2n+5eO89hqcWL4f3n7bqpRBODlBo0bWstWZMzB+PJSulYfhUf3wv3GYJ/mJ7f9WoN7qDThHRGSYQaMh/XBUaUQDB4CNWI4Lo+2SsdkwGDIANzcrlsa+ffD9r7nZ8VAvVt+sxdix8EGTdUSP+AgtUQJ9/HHL+CLmv49meu8r5MplmXNs3gyHDsGbb7sQGvQkb0W8z80Y9wR1nSIjkb594Y/0NWo0pD2OuhGJi62RVEpvQQ0Gw3+IwGOPwbp1VqC+tm1hisuLBHOUD/Ud/l20BZo3J6ZyFYiJYfXq1XH7ChkRhKlkSWtZ7cgRGPNLEJ5OCY/kRqsQ9cOPUKkSN7sYo8F7CRMj3GC4x6lSBX78EY4dg2f7F2dMvqEUjjrOM/zAkMMdeedd4fhxKP7668QEBlKxf/8M3FdQLrrvYkGr5kS7uRHh5Ue4kwdd5Gv8OUN3xtNqamuaNoVZo48TWa+hFcvWeNvNsrg4UklE6qdUR1XX3r04BoMhtQQEWIZ5gwfD99+7M2bMM8zcAwyH6nizlf1WXGZbVKhWCxbgNG5cuu4rxBo00q0bTuPG4RwWhgYF0WrTnwRs/Ydt27qzdi1ELYVrS/+mCie5b31Xorv3IObRlri+0AGaN7fW5QxZAoeUBpZhX0o/R5xTKDcYDBmAhwd07QpdusDatTB2LJybH8WV6Fz4cSWunlNEBDJnTrr7lAoJCUFVLeUUEIAArVv706aNpazOn7esz2fMqEuZTQeoptvoEPk9T8+bSb75PzP381M0bl+Q3NEXrONkZvM8U3F0eaoh8LBdegr4FisA02PpIZzBYEg9IlZAqLlz4aftQXg4J9xXiMKF15Y2Z9060AlfWbvYmzaliz+p5Awa8+e39NaGDfD3CeGZT2oyveZnFOUkdXQjbXsWpGBB2FX6Ka4UKsWNvu/BgQNpLqPBMRzdCF+TSJqrqp2B+UDL9BXTYDCkFlVl55ldLHjc2lcId/chXDzozGTG/lqS+vXhy3dPEjn5W3jwQbj//v+MMDKYwoXh9ddhyxY4esKVpz+uSa1aEB0Noy50ZvO5krh//CGUKcPZwBr8O2FWhsuY00mLjfAFQNs0uI/BYEgH7B0l7v14BO4nj/DwN4E8/fQxChSAHhfeJ2/kWbo4T2H35WLooEHEdIsX4fnmzQyXu0gRy+fV5s2WA8Van3Xgw/pLCXb+mz58zMnj0bzf/RS1asHo965w4qPp6LWEMT+M+5K0x9E9jeQojbHTMBiyNPH3Fa6UL48EBNCpkz8vvCBERsK8efDVV75MXdmJb851ohjHuW/XZWq+DV2an6LUo/dbZ3w7doQmTSyfIhlIQAC8+qqV/v23MHPn9mHAnD6sXRXNja1QYusC+tKB6295s69Ma9w7d+BcRRciYiJpWqmSdcy4dGmW7NqFh4cHISEhGSp/dsJR1+jPJZK6isgYYASwKF2lNBgMd01S+wqurvDkk5Y7kGPHYNAgcA4qzspzDzBiBIQ0iOEnn06E/7bMUhxFi1prSCdPZsYwyJvX2uhftAj+ueDMrFmgT7XjUZ+1fK/tKbnvNx7o14zyzdoT2nktkcWDeeDNjDxmnL1xdHlqaiJpIvASMAfoldaCGQyGjKdoUevI7pEjsGoVPPssXPYpStuzX5Dr+mmecvmZTS4PET1+wn8xovbutVzgZgLe3pbfq5mznPj1Uj3uW/EVQ14+w0sF5vKztuL102Nwi7qF643rOEdE0HL+AoI9KwHmBFZqcVRpBCeSAlTVU1U7qerl9BLQYDBkPCIQEmLFVzp7Fr75BmrXc2NuzBM8eGoOfhHnCKhehG7d4N9OfdBixazwf9OnJxpLPCP2Fpyd4eGHYcyX7nz1T2uaTu+Ek3vCZTTX6AgkpD4f5R3Be8+FsWCBCX1+pzh6eupYIulsegtnMBgyHy8veOEFy+bj2DEYOhSKlfHh4kWYNAlqb/uMsd7v8O/mA9ChA+rvD0OGxLWP78IkI12jBzUMwlXDE+RFigvXnfzof+ltvL/7ksceg4J5o3im/kk++cSKZGtWrpLnjk5PichjIjJKRCaLyEci0iK9BDMYDFmPokVhwADLYeLOndbWxo0i9/P61Q/If+UIDVjNT9KO+Rvzs2sXxFy7TtGJE3EePTpDXaPbx2OP8vYm2s2NX59oyan5Q9k26wgRL/WiYkV4KGIl09cVo+obIXxeYQKVi5yja1fLc++FC+ki3r2NqqaYAF9gDdYpqQjgtO01Gsta3MeR+8S73yvAUSAcCAXqpVBfgNewgkHdsvU/IqV+qlWrpqll1apVqW57r2LGnDNI6zHHxKiuWaPatatq/vyq1m91Kz1XdIVG4ZQwEzTKzU1jTp1KUznsWbVqlS5atEhjTp3S0C++0JhTp3TRokW3jf+f0OMa2mqI/u1bRhU0EmddTBMtwFkVUa1eXfXtt1VXrlQND09XkdOUu/k/A9s1ie9VR4/cDgOqAh2BmaoaLSLOwNPAl7ZyhzbDRaQdMNamONbbXheJSDlVPZ5Es4+xrM77AbsBPyDAQdkNBkM6IgL161tpwgRYscLa2vjtN5h24mHOM4/ZPIUn/y0VObm5IWFh1kaEnx+4uyfdQSpJ7JhxU3//206RFahajAK/vAc6kJhdu/ln7I+UXbGa+4vk41IoVNg+hbDt7rQc/jgxnj7Uq2eFvH3kEStAoXMOc6DkqNL4H/Cuqk6PzVDVaGC6iOTHiuzn6AmqPsBUVZ1ku35VRJoB3YG37SuLSGngVaCiqu6LV5RxcS4NBoNDODtbZhxNmkBUlBUaduE31dCfEn5Rh1+L5v2JQfQ69Sb+G+cgTZpAy5bw6KNQsGCayZOc+5JEKuNUuSKFp1QErF+0165BRLWvyPvXFm6KJ/NvtmTm0qd5b2lz+uNBnjzWgYGHH7ai25Yrl/1dYzm6p5EP2JtE2V4cjB8uIm5ANWCpXdFS4MEkmrUCjgDNROSIiISJyLciknbvLIPBkOa4uEDTpsqjnXexsFUzIl3cueHqx0086cZXjJgaQIelHZka0Z5/F2+BF16wNtHbtcts0ePw8YG8+zbC2rV4dn+BJ/Ot4mfasLBET4oUgYsXlV9/juTVV6FCBYgV/8svYc8eTbCprtlkh10cGYiI7AeWqGrvRMo+BZqpalkH7lMYOAk00Hiu1EXkPaC9qpZOpM0EoBOwC2t5SoHRtuI6qhpjV78b0A2gUKFC1WbOnJni+BLj2rVr+Pj4pKrtvYoZc84go8d87do1YmJiyB8Vhcfp09woFMDmsPxs3lyYLVsKc+KEF6BUZidPOM3Hr4gTYW3aUbf2PzQd3JWrZctyvk4dLlWujKbSRXpajVmio8m9YwcRuXNzvVQpbm45Qf3BPVmVpyVfX2vPr1cbExPP4ff9uY7zSIk/yVM1NwUrRhAcfI1cuTLm2d/NmBs2bBiqqtUTLUxqsyN+Al7H2gSfjOXhtiyW59uvsDbDezt4n8JYX/r17PIHAfuTaDPR1ub+eHn32/JqJdef2Qi/M8yYcwaZMeaYmJgkr/fsUR0yRLVqVVWR//bL83FOV/o+rrdcPFVBY7y9VVu3Vt206Y77T7cx79mj2r69qo+PKmhEvkK6o15PbVFjl3Zx/0qv46kXyaXX8dQOTFNv7wht0SJGR4xQ3bAhfTfWM3UjXFU/FZECNuXRyZYtWCeZRqjqWAcV2HmbkvG3yy8IJGX3cRqIUtW/4uUdBKKA4sAWB/s2GAyZRHJ7C+XKwXvvWenMGcsP1rx5sHZtfh6+Og8PbvIwK/lf5G+0Wvwrv5e6ygNB4H92F/z6q7UXUrFiopsJGhvHI4nru6ZcOfj+e7hxAxYuxHXmTCqv+oFft/QmpvyrOBOBF5azx4l0Y9n1RixYEMCCBVZzd3eoWRPq1rXSgw9ablKyMo76nvID3seaKTwGPAe0AAqr6gBHO1PVCKwjto3tihoDG5NotgFwEZGS8fJKYG3iH3O0b4PBkPXx94eXXoKFCy0biQUL4PmXPNkX3IIuEV+S/+bfNB31CAEBMLLFWhg4ECpXRoOCoEcPyyFVVBRAxsZF9/KyHHjNng2nTyPnzuHk4ZGgiifhnPIsRVjlVnToYHmgD7m1GKd1q/l+xN883jKGfPksPdS1qxX1du9eiLlDd7Caztb3Kc40RMQFuAC0VtVfuXvnhJ8A34nIViyF8DKWMppg6284UFNVH7HVXw78DnwjIq/Z8sZgzTC236UsBoMhi+Lubh2mevRR6/rAAZg/X1i4UNi8Gd46+Sqf8hQtWMATJ3+l8VdTcZo8jcObz1O6ojNuu3dzfeFCYlaupKKrKzF9+nCjRQvo1i3tZxzxcXNDg4KICQ9PEM40xtkZebodgYUL891QKy+6xKs4Hz0EwC1x5wglmLuvNe/u+5DJk+Eh1nHdN4CA2oHUeNCV2rWtmUlSs5HVq1cTHh6erp59U1QaqholImexlpXuGlX9UUTyAe9i2Vr8CTyqqrGzhgCgZLz6MSLyGPAZsBa4CSwD+qjdJrjBYMi+lC4N/fpZ6cYNWLkSfvvNn9Wru/DNgS64E0656L3sqOJO4cKw9do4Hrxii/AXYUUtzIi46GqzRr/RooXVn6cnMTdvMq9FC7zatqVp06Zx7hKdVy6DQ4fg8GHcDx3i/oOH6ZjPDadSsHF9DLMWNsHzajhRy5w5tiyQQ5TidZ5l033PU6um0jxwL/c3DeaBWl64uSnh4eHcmDiRmAUL0k1ROmqn8T3QFVh41z0CqjoeGJ9EWadE8k5jhZc1GAwGvLwsL+2P2QJN//03LFzowdKlVTmxznK6+xbvMIlueHDrv4Yxwr+hYeR7LP1sg2ODXtGtm6WgwsJwCgrCy/aLP8EXd1CQlRo1AsAZa6P2bYBohY1LOb/lMKfWHebW3kMUPXWYgFvnOHgQLh48z3dUgGFwgiL841uSfIUCaHT0N5yjI9NNUTqqNMKAZ0VkGzAPa3M6wUKZqn6TJhIZDAbDHVKsmLUX8tJL1tmrXbtg3U+NYbgk+KaKilLKtwymbKkTvOv1CZEdO1OpfQUC0liHxLdGJyAAgUSt0ZPF2Rnq1SN/vXrk7/tf9pBb8MQO2LrSk0/n/QCHDpPn30OUvHqYsleXEYELLkTG1Xfy9LSs79NokI4qjXG21yJYxnn2KGCUhsFgyHREoFIl5cyZXSzc15xWCxYQ5eQGkVG8k/cDLl3JT75Dv1CPL3Dr9ylb+9XgywKd+bfJ01RvlJt69aBEibu37L4ja/Q7wN0dateG2rV94J1nALh0yQqLO2XZaV79tEQCRRlz8yZOQUFpFkHEUaURnEb9GQwGQ7pjv0S0Z+5cqrRpQ+Ndu2jqtAF39yf5eF4DfOZNp+HRb3j/XHeuTu9H4emnuIYvAQHw0EP/HYWtVCnDI9zeEblzW9b3sIuFRy1FGePiilNUpLWXsmvXnc90ksBROw1ztNVgMNxTpOSwsEGDAvDJa0RF9uaP70I5+cs26kb4sm0bDD3dmbCfgvj4p068RnE8Pa1TSw8+CHXqWL/0CxTI5AHaYa8od9kUZaJ7KXeBozON+ILZ23bEWhAaDAZDlsKRJSIXV6Fi5+pU7Fyd5oDeiuB6wxP4bJrCYAazwaMR42525pc1T7BmzX+2F6VKQa1algKpVcuajaTSy0ma4ahn37shSaUhIv5YbkN+VNVptjxnrDga8bkmIverieRnMBiyAeLuhs/GpRAWhtO331JvyhTqHXuGHc+PYUqu3mzbEsOuP4RDh4RDhyw38GApjCpVoEYNa1ZSo4ZlwOd0R6Hu0kD+dNpLiSW5mcYrWDE0nrSXCZgEnLL93Q7LQG8IBoPBkF0ICoJBgyyr81WrqFKpElXyA1OnEfPpGP5u1JmFedqzclc+duyAw4dhyxYrxeLrC9WqQfXq1mu1alCyZMYrkrQkOaXRDJikqjft8hX4SlV/BxCRc1huRYzSMBgM2Q8nJyviUix58+Lk5krgJ73p7taP7q1awReduVizKZu3CBs3wrZtsGuXcuaMsHo1xPdckiuXNSOpUgWqVrVey5SxXMnfCyQnZmngvUTy7ec6f9nqGgwGQ/bn8cet9McfMGUKfPcdHDpEnt+b0bw5NK95gdW7dxMeHs4DBSrx15Iw1p0IYt4WZ44e9ePiRXfWrIE1a/67pbs7PPCAFQmwcmVrf6RiRUvBZDWSUxoewLX4GWqFeQ3A8lYbS7itrsFgMOQcKlaETz+FESPg5Ekr78oVNDCQiiVKcNjVFf8//6Swhwf1w8Op0KIFXh92o3z5pmzbJmzbBjt3wp9/wokTsH27leITHGx1E5seeMDagM/MELPJKY1/sLzJro+fmciGdzBwLo3lMhgMhnsDd3fLGhBAFRkwgDwTJ1IjLMzKi4jAGZs7j4EDkZ2/Uey+INo0DrI2PYB//4XQUOIUyd69cPAgHD1qpXnz/uvOwwPKlrUiBVaoAOXLW6l48YzZK0lOaawHOgLTUrjHc1jeag0GgyFn4+cHb7+NNGiANmmCXL8eV+Tk6YnMnw+DB/9XP18+CAoi77RpNG5cjsZBB6HiAQgKIqJwEHuP+/D775Yi2bMH9u+3/Grt2GGl+Pj4WMqkXDmlXDkhOjoftWqBh0faevRNTml8BqwXkdHAW6oaFb/Q5jL9IyAEqJdmEhkMBsM9jgYHExMZmdA1+s2bOD3zDNK8OYSFWVOIsDAr+flZlebOhbfeAsANqJwvH5WDgqw4IQUKwI4dXP3rFPtuBLH1nyBC93tz4AD89ZcVf2TbNti2TSjEGYK5xkutTrPmeAa5RlfVTSLyJpZi6CAiy4DjtuLiWIGT8gNvq+qmNJHGYDAY7nGSdY1+5IjlGr1mzcQbd+sGISG3K5Xcua3yyZPxHTeOmkBNsBRJiRJwdgNnzjmxfMhEvJYu5rGwhUSIO55VbmWsa3RV/VhEfgf6A//jvw3vcKzYFh+p6sq7lsJgMBiyCXfkGt2ePHks8/JatRIvHzwYOnRIqFCuXAFnZ/z9of2RuciRpQC4EQHRmeAaXVVXAats1uD5sI7cnlfVNAnKZDAYDNmNNHGNnhj581updu1Ei6VXL3TDhtv3UjLBNTo2JfFPmvRqMBgM2Zz0dueRGFq1auJ7KWnoGv0eNmY3GAwGQyyxeynzWrQg2s2NKG9vot3cmNeiBUt27SKt/MoapWEwGAzZgNi9FK9u3XAKC+OPkSNxCgvDq1u3zHWNbjAYDIasSUa4RjczDYPBYMhGpPdeilEaBoPBYHAYozQMBoPB4DBGaRgMBoPBYYzSMBgMBoPDSFqd3c2K2KIKHktl8/wkjBuSEzBjzhmYMecM7mbMgapaILGCbK007gYR2a6q1TNbjozEjDlnYMacM0ivMZvlKYPBYDA4jFEaBoPBYHAYozSSZmJmC5AJmDHnDMyYcwbpMmazp2EwGAwGhzEzDYPBYDA4jFEaBoPBYHAYozTsEJFXROSoiISLSKiI1MtsmVKLiNQXkfkiclJEVEQ62ZWLiAwWkVMiclNEVotIebs67iLyuYicF5HrtvsVzdCB3AEi8raIbBORKyJyTkR+FZEKdnWy1bhFpIeI/GEb8xUR2SQiLeKVZ6vx2iMi79je31/Ey8t2Y7aNR+3SmXjlGTJmozTiISLtgLHAMKAKsBFYJCLFM1Ww1OMD/An0Bm4mUv4m8AbwKlADKzLjMhHxjVdnDFZ8+GeAekAu4Ddb+N+sSAgwHngQeBiIApaLSN54dbLbuE8A/YGqQHVgJfCLiFS0lWe38cYhIrWBF4E/7Iqy65gPAAHx0gPxyjJmzKpqki0BW4BJdnkHgeGZLVsajO0a0CnetQCngQHx8jyBq8BLtms/IAJoH69OMSAGaJrZY3Jw3D5ANNAyh437X+Cl7Dxem9yHsX4crAa+yM7/Y2Aw8GcSZRk2ZjPTsCEibkA1YKld0VKsX63ZjWDAn3jjVdWbwFr+G281wNWuzt/APu6dZ+KLNaO+aLvO1uMWEWcReRpLWW4ke493IjBbVVfa5WfnMZewLTcfFZGZIlLClp9hYzZK4z/yA87AWbv8s1j/jOxG7JiSG68/1q90e/8199IzGQvsBDbZrrPluEXkARG5BtwCJgCtVXU32Xe8LwKlgIGJFGfLMWOthHQCmmMtyfkDG0UkHxk4ZhPu9XbsDVckkbzsRGrGe088ExH5BHgIeEhVo+2Ks9u4DwCVgdxYa9bfikhIvPJsM14RKY2171hPVSOSqZptxgygqoviX4vIZuAI8DywObaaXbM0H7OZafzHeSwtbK9xC3K79s4OxJ66SG68Z7BmX/mTqZMlEZFPsTb7HlbVI/GKsuW4VTVCVQ+p6nZVfRtrdvU62XO8dbBk/VNEokQkCmgAvGL7+4KtXnYa822o6jVgD3AfGfh/NkrDhu0XSyjQ2K6oMdbacHbjKNabKG68IuKBdaIidryhQKRdnaJAWbLwMxGRscCzWApjv11xth23HU6AO9lzvL9gnRqqHC9tB2ba/v6L7Dfm27CNqQzWBnjG/Z8z+0RAVkpAO6zTBV1tD3Is1qmjwMyWLZXj8eG/D9UN4D3b38Vt5f2BK0AboALWh+4U4BvvHl8CJ4FGWMeQV2H9inXO7PElMeZxtjE9jPWrKzb5xKuTrcYNjLB9OQRhfZkOxzoR0zw7jjeJZ7Aa2+mp7DpmYDTWjCoYqAX8ZhtjYEaOOdMfRFZLwCtAGNaGYihQP7NluouxhGCtVdqnqbZywTrGdxoIB9YAFezu4QF8jjXlvwH8ChTL7LElM+bExqvA4Hh1stW4galYwcZuYZ3NX068I5TZbbxJPAN7pZHtxhxPCUTYvvjnAOUyeszGYaHBYDAYHMbsaRgMBoPBYYzSMBgMBoPDGKVhMBgMBocxSsNgMBgMDmOUhsFgMBgcxigNg8FgMDiMURqGLIuI1BGRWbagMhEickFElonI87H+/0Wkky0YTVC8dmEiMtXuXi1FZLdYwbVURHKLiJOIjBGR0yISIyK/pONYgiSRQFiJ1IsdT6n0kiW1iMgTItInkfwQm8yNMkMuQ8ZiHBYasiQi8hrwCVZAof5Yxmt5gCZYVq2XgHlJNG+NZRkbey8XYDqWq4QeWMZRV4EnsQJUvYHlBffCbXcyxOcJLEviTzJZDkMmYpSGIcshIvWxvpi+UNVedsXzbN5rvZNqr6o77LKKYMXVmKWqa+P1U9b25xhVjUkDud1V9dbd3sdgyMqY5SlDVuQtrMhzbyZWqKqHVdU+vGcc8ZenRGQwllsYgMm2ZZTVIhKG5XIBIDr+0pGIBIjINFsc5Vtixd/uYNdH7DJSfRH5SUQuYcU7QES8RGS8bTntmojMB9I09rSIvCgiu2zLbedFZLJdSFts8g0VkV62oD1XRWSN3B432tlW77SI3BCRlSJSxtZ+sK3OVCwX3EXkv/jUYXZieYnIFzZ5zonI9yKSOy3Hbch8zEzDkKWw7VWEAL+oanga3PJrrDjpPwFDgQVYS1fuQC+soDZ1bHUPi4g3ls+ePMA7wN9AB+A7EfFS1Yl2958OzMBa6or9PH2F5fxyCLANy6voD2kwFgBEZATWktpnQD+smdRQoIKIPKgJY4d0wIq10RtwA0ZhzdbKqGqUrc4Q21hHYfmtqgrMt+v2A6AAVuzpx2159rOqsVhO9J4FSgMfYYUbeP5uxmvIWhilYchq5MeKbXwsLW6mqidEZKft8rCqxgarQURO2urEz+uJFZ+goaqutmUvEpFCwFARmWz3pTxbVd+M17401pfmAFUdYcteKiI+wMt3Ox7bhn8/YIiqvh8v/y9gPdASy3V4LJHAY6oaaasHlgKtiRX1LQ/wGjBBVfvb2iwTkUjg49ibqOphETkHRMR/XnasVdVXbX8vtT2LriLSSY2Tu2yDWZ4yGBJSHzgZT2HE8j3WL+1ydvk/213XwvpczbLLn5lG8jW23X+6iLjEJqylsStY8sdnWazCsLHb9lrc9voA1v7QT3btZqdCtgV217uxZnSFUnEvQxbFzDQMWY0LwE0gMJP6z4vlWtqeM/HK42NfN8D2mlis5rSgoO31UBLl+eyu/7W7jl1S8rC9xsr7j1291MibUl+GbIBRGoYshapGichqoHEmnUb6F2s93p7YMJr2x3Ltl11ilUghrPjNxLtOC2L7bwJcTKbcUWLlLYgVOjQWMzswJIpZnjJkRUZg/WIelVihiASLSMV06nsNUFRE6trlP4v1a3xfCu23YEXNa2uX/3TaiMcy2/2LqxUP3D4dvcP77QauA0/Z5dtfgzVz8LxzkQ3ZCTPTMGQ5VHWtzfL4E5stxVTgONaJpkewwvE+CyR57PYumIp10miuiAwATgDtsfYSXrLbBE9M9gMi8gPwvog48d/pqUfvUI5mInLGLu+yqi4TkZHAF7aN5jVYUdqK2fr5WlVXOdqJql4UkTHAOyJylf9OT3WxVYlvv7IXyCsi3bFicoer6m4MOQqjNAxZElUdIyJbgdexYiPnx7Li3g68hBWmMj36vS4iDbCOi47AMgo8AHRU1e8dvM1LWLHl+2Idc12JpeTW34EonyeStwcrfOc7IrIPy7q9B9YS2d/ACuDgHfQRyyCsUKFdsI4hb8E6irwBuByv3tdAbWAYkBvrhFtQKvoz3MOYcK8Gg+E2ROQprBNg9VV1XWbLY8g6GKVhMORwRKQW0AJrhhEOVMOyyj8APGhsLAzxMctTBoPhGpZ9Rw8gF9aG/yzgbaMwDPaYmYbBYDAYHMYcuTUYDAaDwxilYTAYDAaHMUrDYDAYDA5jlIbBYDAYHMYoDYPBYDA4jFEaBoPBYHCY/wP1C1Ohtt+/XwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an RB experiment on qubit 0\n",
+    "int_exp1 = rb.InterleavedRBExperiment(circuits.XGate(), [0], lengths, num_samples=num_samples, seed=seed)\n",
+    "int_expdata1 = int_exp1.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "int_expdata1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Running 2-qubit Interleaved RB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "---------------------------------------------------\n",
+       "Experiment: InterleavedRBExperiment\n",
+       "Experiment ID: 2bf05234-9ce5-411a-b3c5-e14575da2d24\n",
+       "Status: COMPLETE\n",
+       "Circuits: 280\n",
+       "Analysis Results: 1\n",
+       "---------------------------------------------------\n",
+       "Last Analysis Result\n",
+       "- popt: [0.47626118 0.99623266 0.99535996 0.51013026]\n",
+       "- popt_keys: None\n",
+       "- popt_err: [1.77332947e-04 2.66140415e-06 2.83096706e-06 1.79438603e-04]\n",
+       "- pcov: [[ 3.14469741e-08  4.28977668e-10  4.58298066e-10 -3.17868436e-08]\n",
+       " [ 4.28977668e-10  7.08307204e-12  6.39967732e-12 -4.36846717e-10]\n",
+       " [ 4.58298066e-10  6.39967732e-12  8.01437450e-12 -4.66354152e-10]\n",
+       " [-3.17868436e-08 -4.36846717e-10 -4.66354152e-10  3.21982123e-08]]\n",
+       "- reduced_chisq: 800.0272045289706\n",
+       "- dof: 24\n",
+       "- xrange: [1.0, 500.0]\n",
+       "- EPC: 0.00021900082002077048\n",
+       "- EPC_err: 1.9493171174852214e-06\n",
+       "- systematic_err: 0.0016646691935545965\n",
+       "- systematic_err_L: -0.001445668373533826\n",
+       "- systematic_err_R: 0.001883670013575367\n",
+       "- plabels: ['A', 'alpha', 'alpha_c', 'B']"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an Interleaved RB experiment on qubits 4, 6\n",
+    "int_exp2 = rb.InterleavedRBExperiment(circuits.CXGate(), [4,6], lengths, num_samples=num_samples, seed=seed)\n",
+    "int_expdata2 = int_exp2.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "int_expdata1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running parallel RB experiments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "---------------------------------------------------\n",
        "Experiment: ParallelExperiment\n",
-       "Experiment ID: d670490f-77d8-4110-ac7f-f4e611963cac\n",
+       "Experiment ID: 140d68a4-74af-48f9-8cc1-7d3b61a1f331\n",
        "Status: COMPLETE\n",
        "Component Experiments: 5\n",
        "Circuits: 140\n",
@@ -183,17 +326,17 @@
        "---------------------------------------------------\n",
        "Last Analysis Result\n",
        "- experiment_types: ['RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment']\n",
-       "- experiment_ids: ['38052c41-b1de-4044-a7ea-351116323acb', 'deff9141-4adb-4a2a-9c26-8f1dd56d7533', 'd0d62d02-9613-4ddd-9acc-128867b66d9d', '37ad5eb7-d7eb-4e65-b46e-276b8ff8e1de', 'ea5ac2b9-3082-433a-bc06-0b636f9ff700']\n",
+       "- experiment_ids: ['ba4e4b75-3802-424e-8d5c-3e7928fa9c95', '93c7220c-dbd1-43a8-bb60-e8bcd8b6fbfa', 'adfd1b3c-4435-4c95-aa43-b67a8d230e16', '842fcff6-662c-47c2-a024-e871ac1b9c5b', '11b1662b-3f18-43cb-8e35-8df96ec6003c']\n",
        "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -205,7 +348,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -217,7 +360,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -229,7 +372,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -241,7 +384,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -278,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -287,107 +430,107 @@
      "text": [
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 38052c41-b1de-4044-a7ea-351116323acb\n",
+      "Experiment ID: ba4e4b75-3802-424e-8d5c-3e7928fa9c95\n",
       "Status: COMPLETE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.39894313 0.99683541 0.55506056]\n",
+      "- popt: [0.45163202 0.99592734 0.53346007]\n",
       "- popt_keys: None\n",
-      "- popt_err: [0.00864615 0.00013107 0.00889515]\n",
-      "- pcov: [[ 7.47558822e-05  1.07234670e-06 -7.66189222e-05]\n",
-      " [ 1.07234670e-06  1.71788812e-08 -1.11871309e-06]\n",
-      " [-7.66189222e-05 -1.11871309e-06  7.91236855e-05]]\n",
-      "- reduced_chisq: 1272.0160808279704\n",
+      "- popt_err: [2.76362095e-04 4.69836111e-06 2.81882215e-04]\n",
+      "- pcov: [[ 7.63760076e-08  1.21900813e-09 -7.74978656e-08]\n",
+      " [ 1.21900813e-09  2.20745971e-11 -1.26382118e-09]\n",
+      " [-7.74978656e-08 -1.26382118e-09  7.94575830e-08]]\n",
+      "- reduced_chisq: 121.7024893164993\n",
       "- dof: 11\n",
-      "- xrange: [1, 500]\n",
-      "- EPC: 0.0015822930393300516\n",
-      "- EPC_err: 6.574216227495952e-05\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.002036328730827597\n",
+      "- EPC_err: 2.358787086606496e-06\n",
       "- plabels: ['A', 'alpha', 'B'] \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: deff9141-4adb-4a2a-9c26-8f1dd56d7533\n",
+      "Experiment ID: 93c7220c-dbd1-43a8-bb60-e8bcd8b6fbfa\n",
       "Status: COMPLETE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.44218305 0.99807077 0.54973109]\n",
+      "- popt: [0.47169909 0.99688744 0.51927115]\n",
       "- popt_keys: None\n",
-      "- popt_err: [0.01844602 0.00012207 0.0185208 ]\n",
-      "- pcov: [[ 3.40255831e-04  2.23678462e-06 -3.41596341e-04]\n",
-      " [ 2.23678462e-06  1.49011638e-08 -2.24689669e-06]\n",
-      " [-3.41596341e-04 -2.24689669e-06  3.43020211e-04]]\n",
-      "- reduced_chisq: 1549.0951739566842\n",
+      "- popt_err: [3.22156128e-04 3.36318925e-06 3.23899863e-04]\n",
+      "- pcov: [[ 1.03784571e-07  1.05691293e-09 -1.04281971e-07]\n",
+      " [ 1.05691293e-09  1.13110419e-11 -1.06516581e-09]\n",
+      " [-1.04281971e-07 -1.06516581e-09  1.04911121e-07]]\n",
+      "- reduced_chisq: 698.3818845120279\n",
       "- dof: 11\n",
-      "- xrange: [1, 500]\n",
-      "- EPC: 0.0009646171164408579\n",
-      "- EPC_err: 6.115314040377361e-05\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0015562786871028411\n",
+      "- EPC_err: 1.686845026470112e-06\n",
       "- plabels: ['A', 'alpha', 'B'] \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: d0d62d02-9613-4ddd-9acc-128867b66d9d\n",
+      "Experiment ID: adfd1b3c-4435-4c95-aa43-b67a8d230e16\n",
       "Status: COMPLETE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.52303193 0.99915474 0.45778815]\n",
+      "- popt: [0.48489571 0.99685652 0.50226562]\n",
       "- popt_keys: None\n",
-      "- popt_err: [0.13268492 0.0002403  0.13309719]\n",
-      "- pcov: [[ 1.76052888e-02  3.17884639e-05 -1.76597949e-02]\n",
-      " [ 3.17884639e-05  5.77427989e-08 -3.18957752e-05]\n",
-      " [-1.76597949e-02 -3.18957752e-05  1.77148626e-02]]\n",
-      "- reduced_chisq: 2544.227028407227\n",
+      "- popt_err: [4.67226100e-04 4.51247210e-06 4.74594366e-04]\n",
+      "- pcov: [[ 2.18300229e-07  2.00381319e-09 -2.21544151e-07]\n",
+      " [ 2.00381319e-09  2.03624045e-11 -2.05160852e-09]\n",
+      " [-2.21544151e-07 -2.05160852e-09  2.25239812e-07]]\n",
+      "- reduced_chisq: 554.2470051270237\n",
       "- dof: 11\n",
-      "- xrange: [1, 500]\n",
-      "- EPC: 0.0004226317452037942\n",
-      "- EPC_err: 0.00012025029993371939\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0015717396315151344\n",
+      "- EPC_err: 2.263350847455984e-06\n",
       "- plabels: ['A', 'alpha', 'B'] \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: 37ad5eb7-d7eb-4e65-b46e-276b8ff8e1de\n",
+      "Experiment ID: 842fcff6-662c-47c2-a024-e871ac1b9c5b\n",
       "Status: COMPLETE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.48200586 0.99862884 0.51488511]\n",
+      "- popt: [0.47796991 0.98417873 0.51016471]\n",
       "- popt_keys: None\n",
-      "- popt_err: [0.04031094 0.00013729 0.04035047]\n",
-      "- pcov: [[ 1.62497216e-03  5.50531363e-06 -1.62655001e-03]\n",
-      " [ 5.50531363e-06  1.88489659e-08 -5.51137888e-06]\n",
-      " [-1.62655001e-03 -5.51137888e-06  1.62816078e-03]]\n",
-      "- reduced_chisq: 2938.583948413994\n",
+      "- popt_err: [8.68826944e-05 1.05557314e-05 7.66890971e-05]\n",
+      "- pcov: [[ 7.54860259e-09  3.02649695e-10 -5.67513974e-09]\n",
+      " [ 3.02649695e-10  1.11423466e-10 -4.31459400e-10]\n",
+      " [-5.67513974e-09 -4.31459400e-10  5.88121761e-09]]\n",
+      "- reduced_chisq: 422.49065309169913\n",
       "- dof: 11\n",
-      "- xrange: [1, 500]\n",
-      "- EPC: 0.0006855812070217238\n",
-      "- EPC_err: 6.874002178346546e-05\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.007910633750468743\n",
+      "- EPC_err: 5.362710602598715e-06\n",
       "- plabels: ['A', 'alpha', 'B'] \n",
       "\n",
       "---------------------------------------------------\n",
       "Experiment: RBExperiment\n",
-      "Experiment ID: ea5ac2b9-3082-433a-bc06-0b636f9ff700\n",
+      "Experiment ID: 11b1662b-3f18-43cb-8e35-8df96ec6003c\n",
       "Status: COMPLETE\n",
       "Circuits: 140\n",
       "Analysis Results: 1\n",
       "---------------------------------------------------\n",
       "Last Analysis Result\n",
-      "- popt: [0.48732663 0.99746475 0.49859746]\n",
+      "- popt: [0.46057898 0.99499266 0.52740683]\n",
       "- popt_keys: None\n",
-      "- popt_err: [0.02101995 0.00016439 0.02112632]\n",
-      "- pcov: [[ 4.41838395e-04  3.36684929e-06 -4.43970529e-04]\n",
-      " [ 3.36684929e-06  2.70239146e-08 -3.38901026e-06]\n",
-      " [-4.43970529e-04 -3.38901026e-06  4.46321425e-04]]\n",
-      "- reduced_chisq: 1791.8516210952346\n",
+      "- popt_err: [9.96213286e-05 2.52493125e-06 1.00644325e-04]\n",
+      "- pcov: [[ 9.92440911e-09  2.10349103e-10 -9.98184864e-09]\n",
+      " [ 2.10349103e-10  6.37527782e-12 -2.16645073e-10]\n",
+      " [-9.98184864e-09 -2.16645073e-10  1.01292802e-08]]\n",
+      "- reduced_chisq: 3646.3294248027814\n",
       "- dof: 11\n",
-      "- xrange: [1, 500]\n",
-      "- EPC: 0.0012676235257643165\n",
-      "- EPC_err: 8.240367410319429e-05\n",
+      "- xrange: [1.0, 500.0]\n",
+      "- EPC: 0.0025036719357949266\n",
+      "- EPC_err: 1.2688190380616948e-06\n",
       "- plabels: ['A', 'alpha', 'B'] \n",
       "\n"
      ]
@@ -402,9 +545,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qiskit-exp",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "qiskit-exp"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -416,7 +559,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.8"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,

From e111d3e241dde121593bff6e80401b72653d9816 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Mon, 3 May 2021 12:55:34 +0300
Subject: [PATCH 11/20] Small fixes

---
 .../analysis/data_processing.py               | 27 ++++++++++++-------
 .../interleaved_rb_analysis.py                | 10 ++++---
 test/test_curve_fitting.py                    |  4 +--
 3 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 68b476c99c..ac172289bf 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -45,15 +45,27 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
             filtered_data.append(datum)
     return filtered_data
 
-
 def mean_xy_data(
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    method: str = "sample",
+) -> Tuple[np.ndarray]:
+    r"""Wrapper function for multi_mean_xy_data
+    in the case of one data series
+    """
+    series = np.zeros(xdata.size)
+    x_means, y_means, y_sigmas, _ = multi_mean_xy_data(xdata, ydata, sigma, series, method)
+    return x_means, y_means, y_sigmas
+
+def multi_mean_xy_data(
     xdata: np.ndarray,
     ydata: np.ndarray,
     sigma: Optional[np.ndarray] = None,
     series: Optional[np.ndarray] = None,
     method: str = "sample",
 ) -> Tuple[np.ndarray]:
-    r"""Return (x, y_mean, sigma) data.
+    r"""Return (x, y_mean, sigma, series) data.
 
     The mean is taken over all ydata values with the same xdata value using
     the specified method. For each x the mean :math:`\overline{y}` and variance
@@ -91,8 +103,7 @@ def mean_xy_data(
         )
     if method not in ["sample", "iwv"]:
         raise QiskitError(f"Unsupported method {method}")
-    xseries = series if series is not None else np.zeros(xdata.size)
-    x_keys = np.unique(np.column_stack((xdata, xseries)), axis=0)
+    x_keys = np.unique(np.column_stack((xdata, series)), axis=0)
     x_means = np.zeros(x_keys.shape[0])
     y_means = np.zeros(x_keys.shape[0])
     y_sigmas = np.zeros(x_keys.shape[0])
@@ -102,7 +113,7 @@ def mean_xy_data(
         x_means[i] = x_val
         series_mean[i] = xseries_val
         # Get positions of y to average
-        idxs = np.where((xdata == x_val) & (xseries == xseries_val))
+        idxs = np.where((xdata == x_val) & (series == xseries_val))
         ys = ydata[idxs]
 
         # Sample mean and variance method
@@ -110,8 +121,8 @@ def mean_xy_data(
             # Compute sample mean and biased sample variance
             y_means[i] = np.mean(ys)
             y_sigmas[i] = np.mean((y_means[i] - ys) ** 2)
-            # Inverse-weighted variance method
 
+        # Inverse-weighted variance method
         if method == "iwv":
             # Compute the inverse-variance weighted y mean and variance
             weights = 1 / sigma[idxs] ** 2
@@ -119,9 +130,7 @@ def mean_xy_data(
             y_means[i] = y_var * np.sum(weights * ys)
             y_sigmas[i] = np.sqrt(y_var)
 
-    if series is not None:
-        return x_means, y_means, y_sigmas, series_mean
-    return x_means, y_means, y_sigmas
+    return x_means, y_means, y_sigmas, series_mean
 
 
 def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 64449c39fc..9e392222c4 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -35,7 +35,11 @@
 
 
 class InterleavedRBAnalysis(RBAnalysis):
-    """Interleaved RB Analysis class."""
+    """Interleaved RB Analysis class.
+       According to the paper: "Efficient measurement of quantum gate
+       error by interleaved randomized benchmarking" (arXiv:1203.4550)
+       - Equations (4) and (5).
+        """
 
     # pylint: disable=invalid-name, unused-variable, unused-argument, attribute-defined-outside-init
     def _run_analysis(
@@ -105,8 +109,8 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
         systematic_err_l = epc_est - systematic_err
         systematic_err_r = epc_est + systematic_err
 
-        alpha_err_sq = (alpha_err / alpha) * (alpha_err / alpha)
-        alpha_c_err_sq = (alpha_c_err / alpha_c) * (alpha_c_err / alpha_c)
+        alpha_err_sq = (alpha_err / alpha) ** 2
+        alpha_c_err_sq = (alpha_c_err / alpha_c) ** 2
         epc_est_err = (
             ((nrb - 1) / nrb) * (alpha_c / alpha) * (np.sqrt(alpha_err_sq + alpha_c_err_sq))
         )
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 38879167bf..4bc9674e9d 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -17,7 +17,7 @@
 from qiskit import QuantumCircuit, execute
 from qiskit.providers.basicaer import QasmSimulatorPy
 from qiskit_experiments.analysis.curve_fitting import curve_fit, multi_curve_fit, process_curve_data
-from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data
+from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data, multi_mean_xy_data
 
 
 class TestCurveFitting(QiskitTestCase):
@@ -134,7 +134,7 @@ def test_mean_xy_data(self):
         x = np.array([1, 1, 1, 1, 2, 2, 2, 2])
         y = np.array([2, 6, 100, 200, 17, 50, 60, 70])
         series = np.array([0, 0, 1, 1, 0, 1, 1, 1])
-        x_mean, y_mean, y_sigma, series = mean_xy_data(x, y, method="sample", series=series)
+        x_mean, y_mean, y_sigma, series = multi_mean_xy_data(x, y, method="sample", series=series)
         expected_x_mean = np.array([1, 1, 2, 2])
         expected_y_mean = np.array([4, 150, 17, 60])
         expected_y_sigma = np.array([4.0, 2500.0, 0.0, 66.66666667])

From 09a69385752c07e0a9254a5e5ba38735248d7397 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Mon, 3 May 2021 13:02:44 +0300
Subject: [PATCH 12/20] Moved RB notebook to tutorial folder

---
 .../randomized_benchmarking => docs/tutorials}/rb_example.ipynb   | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {qiskit_experiments/randomized_benchmarking => docs/tutorials}/rb_example.ipynb (100%)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/docs/tutorials/rb_example.ipynb
similarity index 100%
rename from qiskit_experiments/randomized_benchmarking/rb_example.ipynb
rename to docs/tutorials/rb_example.ipynb

From ef7c0d923fd3e141f55667e9800666f411c29b04 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Mon, 3 May 2021 13:08:11 +0300
Subject: [PATCH 13/20] Linting

---
 qiskit_experiments/analysis/data_processing.py       |  2 ++
 .../interleaved_rb_analysis.py                       | 12 ++++++------
 test/test_curve_fitting.py                           |  6 +++++-
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index ac172289bf..b503a0b58f 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -45,6 +45,7 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
             filtered_data.append(datum)
     return filtered_data
 
+
 def mean_xy_data(
     xdata: np.ndarray,
     ydata: np.ndarray,
@@ -58,6 +59,7 @@ def mean_xy_data(
     x_means, y_means, y_sigmas, _ = multi_mean_xy_data(xdata, ydata, sigma, series, method)
     return x_means, y_means, y_sigmas
 
+
 def multi_mean_xy_data(
     xdata: np.ndarray,
     ydata: np.ndarray,
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 9e392222c4..fc5bc51fac 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -22,7 +22,7 @@
 from qiskit_experiments.analysis.plotting import plot_curve_fit, plot_scatter, plot_errorbar
 from qiskit_experiments.analysis.data_processing import (
     level2_probability,
-    mean_xy_data,
+    multi_mean_xy_data,
 )
 from .rb_analysis import RBAnalysis
 
@@ -36,10 +36,10 @@
 
 class InterleavedRBAnalysis(RBAnalysis):
     """Interleaved RB Analysis class.
-       According to the paper: "Efficient measurement of quantum gate
-       error by interleaved randomized benchmarking" (arXiv:1203.4550)
-       - Equations (4) and (5).
-        """
+    According to the paper: "Efficient measurement of quantum gate
+    error by interleaved randomized benchmarking" (arXiv:1203.4550)
+    - Equations (4) and (5).
+    """
 
     # pylint: disable=invalid-name, unused-variable, unused-argument, attribute-defined-outside-init
     def _run_analysis(
@@ -54,7 +54,7 @@ def data_processor(datum):
 
         self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
         series, x, y, sigma = process_multi_curve_data(experiment_data.data, data_processor)
-        xdata, ydata, ydata_sigma, series = mean_xy_data(x, y, sigma, series)
+        xdata, ydata, ydata_sigma, series = multi_mean_xy_data(x, y, sigma, series)
 
         def fit_fun_standard(x, a, alpha_std, alpha_int, b):
             return a * alpha_std ** x + b
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 4bc9674e9d..4c8a47e5b7 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -17,7 +17,11 @@
 from qiskit import QuantumCircuit, execute
 from qiskit.providers.basicaer import QasmSimulatorPy
 from qiskit_experiments.analysis.curve_fitting import curve_fit, multi_curve_fit, process_curve_data
-from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data, multi_mean_xy_data
+from qiskit_experiments.analysis.data_processing import (
+    level2_probability,
+    mean_xy_data,
+    multi_mean_xy_data,
+)
 
 
 class TestCurveFitting(QiskitTestCase):

From 319d5da9dadff0d187b674fcb0e68fc9ba7f4869 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Thu, 6 May 2021 08:46:37 +0300
Subject: [PATCH 14/20] Switch to Chris' version of multi_mean_xy_data

---
 .../analysis/data_processing.py               | 105 ++++++++++--------
 .../interleaved_rb_analysis.py                |   2 +-
 test/test_curve_fitting.py                    |  10 +-
 3 files changed, 65 insertions(+), 52 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index b503a0b58f..4c7d915885 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -47,27 +47,9 @@ def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
 
 
 def mean_xy_data(
-    xdata: np.ndarray,
-    ydata: np.ndarray,
-    sigma: Optional[np.ndarray] = None,
-    method: str = "sample",
+    xdata: np.ndarray, ydata: np.ndarray, sigma: Optional[np.ndarray] = None, method: str = "sample"
 ) -> Tuple[np.ndarray]:
-    r"""Wrapper function for multi_mean_xy_data
-    in the case of one data series
-    """
-    series = np.zeros(xdata.size)
-    x_means, y_means, y_sigmas, _ = multi_mean_xy_data(xdata, ydata, sigma, series, method)
-    return x_means, y_means, y_sigmas
-
-
-def multi_mean_xy_data(
-    xdata: np.ndarray,
-    ydata: np.ndarray,
-    sigma: Optional[np.ndarray] = None,
-    series: Optional[np.ndarray] = None,
-    method: str = "sample",
-) -> Tuple[np.ndarray]:
-    r"""Return (x, y_mean, sigma, series) data.
+    r"""Return (x, y_mean, sigma) data.
 
     The mean is taken over all ydata values with the same xdata value using
     the specified method. For each x the mean :math:`\overline{y}` and variance
@@ -81,11 +63,10 @@ def multi_mean_xy_data(
       :math:`\sigma^2 = 1 / (\sum_{i=1}^N 1 / \sigma_i^2)`
 
     Args
-        xdata: 1D array of xdata from curve_fit_data or
+        xdata: 1D or 2D array of xdata from curve_fit_data or
                multi_curve_fit_data
         ydata: array of ydata returned from curve_fit_data or
                multi_curve_fit_data
-        series: 1D int array that specifies the data series
         sigma: Optional, array of standard deviations in ydata.
         method: The method to use for computing y means and
                 standard deviations sigma (default: "sample").
@@ -99,41 +80,73 @@ def multi_mean_xy_data(
     Raises:
         QiskitError: if "ivw" method is used without providing a sigma.
     """
-    if method == "iwv" and sigma is None:
-        raise QiskitError(
-            "The inverse-weighted variance method cannot be used with" " `sigma=None`"
-        )
-    if method not in ["sample", "iwv"]:
-        raise QiskitError(f"Unsupported method {method}")
-    x_keys = np.unique(np.column_stack((xdata, series)), axis=0)
-    x_means = np.zeros(x_keys.shape[0])
-    y_means = np.zeros(x_keys.shape[0])
-    y_sigmas = np.zeros(x_keys.shape[0])
-    series_mean = np.zeros(x_keys.shape[0])
-
-    for i, (x_val, xseries_val) in enumerate(x_keys):
-        x_means[i] = x_val
-        series_mean[i] = xseries_val
-        # Get positions of y to average
-        idxs = np.where((xdata == x_val) & (series == xseries_val))
-        ys = ydata[idxs]
-
-        # Sample mean and variance method
-        if method == "sample":
+    x_means = np.unique(xdata, axis=0)
+    y_means = np.zeros(x_means.size)
+    y_sigmas = np.zeros(x_means.size)
+
+    # Sample mean and variance method
+    if method == "sample":
+        for i in range(x_means.size):
+            # Get positions of y to average
+            idxs = xdata == x_means[i]
+            ys = ydata[idxs]
+
             # Compute sample mean and biased sample variance
             y_means[i] = np.mean(ys)
             y_sigmas[i] = np.mean((y_means[i] - ys) ** 2)
 
-        # Inverse-weighted variance method
-        if method == "iwv":
+        return x_means, y_means, y_sigmas
+
+    # Inverse-weighted variance method
+    if method == "iwv":
+        if sigma is None:
+            raise QiskitError(
+                "The inverse-weighted variance method cannot be used with" " `sigma=None`"
+            )
+        for i in range(x_means.size):
+            # Get positions of y to average
+            idxs = xdata == x_means[i]
+            ys = ydata[idxs]
+
             # Compute the inverse-variance weighted y mean and variance
             weights = 1 / sigma[idxs] ** 2
             y_var = 1 / np.sum(weights)
             y_means[i] = y_var * np.sum(weights * ys)
             y_sigmas[i] = np.sqrt(y_var)
 
-    return x_means, y_means, y_sigmas, series_mean
+        return x_means, y_means, y_sigmas
 
+    # Invalid method
+    raise QiskitError(f"Unsupported method {method}")
+
+
+def multi_mean_xy_data(
+        series: np.ndarray, xdata: np.ndarray, ydata: np.ndarray,
+        sigma: Optional[np.ndarray] = None, method: str = "sample"):
+    series_vals = np.unique(series)
+
+    series_means = []
+    xdata_means = []
+    ydata_means = []
+    sigma_means = []
+
+    # Get x, y, sigma data for series and process mean data
+    for i in series_vals:
+        idxs = series == series_vals[i]
+        sigma_i = sigma[idxs] if sigma is not None else None
+        x_mean, y_mean, sigma_mean = mean_xy_data(
+            xdata[idxs], ydata[idxs], sigma=sigma_i, method=method)
+        series_means.append(i * np.ones(x_mean.size, dtype=int))
+        xdata_means.append(x_mean)
+        ydata_means.append(y_mean)
+        sigma_means.append(sigma_mean)
+
+    # Concatenate lists
+    return (
+        np.concatenate(series_means),
+        np.concatenate(xdata_means),
+        np.concatenate(ydata_means),
+        np.concatenate(sigma_means))
 
 def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:
     """Return the outcome probability mean and variance.
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index fc5bc51fac..22bb166df6 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -54,7 +54,7 @@ def data_processor(datum):
 
         self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
         series, x, y, sigma = process_multi_curve_data(experiment_data.data, data_processor)
-        xdata, ydata, ydata_sigma, series = multi_mean_xy_data(x, y, sigma, series)
+        series, xdata, ydata, ydata_sigma = multi_mean_xy_data(series, x, y, sigma)
 
         def fit_fun_standard(x, a, alpha_std, alpha_int, b):
             return a * alpha_std ** x + b
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 4c8a47e5b7..9e725b18e0 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -138,11 +138,11 @@ def test_mean_xy_data(self):
         x = np.array([1, 1, 1, 1, 2, 2, 2, 2])
         y = np.array([2, 6, 100, 200, 17, 50, 60, 70])
         series = np.array([0, 0, 1, 1, 0, 1, 1, 1])
-        x_mean, y_mean, y_sigma, series = multi_mean_xy_data(x, y, method="sample", series=series)
-        expected_x_mean = np.array([1, 1, 2, 2])
-        expected_y_mean = np.array([4, 150, 17, 60])
-        expected_y_sigma = np.array([4.0, 2500.0, 0.0, 66.66666667])
-        expected_series = np.array([0, 1, 0, 1])
+        series, x_mean, y_mean, y_sigma = multi_mean_xy_data(series, x, y, method="sample")
+        expected_x_mean = np.array([1, 2, 1, 2])
+        expected_y_mean = np.array([4, 17, 150, 60])
+        expected_y_sigma = np.array([4.0, 0.0, 2500.0, 66.66666667])
+        expected_series = np.array([0, 0, 1, 1])
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))

From 738e688fb83da2d730cb852a2986d0ecca9f21d2 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Thu, 6 May 2021 08:57:07 +0300
Subject: [PATCH 15/20] Small fixes

---
 .../interleaved_rb_analysis.py                     | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 22bb166df6..4cf5733908 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -41,7 +41,7 @@ class InterleavedRBAnalysis(RBAnalysis):
     - Equations (4) and (5).
     """
 
-    # pylint: disable=invalid-name, unused-variable, unused-argument, attribute-defined-outside-init
+    # pylint: disable=invalid-name
     def _run_analysis(
         self,
         experiment_data,
@@ -52,14 +52,14 @@ def _run_analysis(
         def data_processor(datum):
             return level2_probability(datum, datum["metadata"]["ylabel"])
 
-        self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
+        num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
         series, x, y, sigma = process_multi_curve_data(experiment_data.data, data_processor)
         series, xdata, ydata, ydata_sigma = multi_mean_xy_data(series, x, y, sigma)
 
-        def fit_fun_standard(x, a, alpha_std, alpha_int, b):
+        def fit_fun_standard(x, a, alpha_std, _, b):
             return a * alpha_std ** x + b
 
-        def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
+        def fit_fun_interleaved(x, a, _, alpha_int, b):
             return a * alpha_int ** x + b
 
         std_idx = series == 0
@@ -92,10 +92,10 @@ def fit_fun_interleaved(x, a, alpha_std, alpha_int, b):
         )
 
         # Add EPC data
-        nrb = 2 ** self._num_qubits
+        nrb = 2 ** num_qubits
         scale = (nrb - 1) / (2 ** nrb)
-        A, alpha, alpha_c, B = analysis_result["popt"]
-        A_err, alpha_err, alpha_c_err, B_err = analysis_result["popt_err"]
+        _, alpha, alpha_c, _ = analysis_result["popt"]
+        _, alpha_err, alpha_c_err, _ = analysis_result["popt_err"]
 
         # Calculate epc_est (=r_c^est) - Eq. (4):
         epc_est = scale * (1 - alpha_c / alpha)

From 51494f82a83b6c38306afc1ef8ed79f61e10247c Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Thu, 6 May 2021 09:10:12 +0300
Subject: [PATCH 16/20] Added equations

---
 .../randomized_benchmarking/interleaved_rb_analysis.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 4cf5733908..b2e791fbd9 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -38,7 +38,15 @@ class InterleavedRBAnalysis(RBAnalysis):
     """Interleaved RB Analysis class.
     According to the paper: "Efficient measurement of quantum gate
     error by interleaved randomized benchmarking" (arXiv:1203.4550)
-    - Equations (4) and (5).
+
+    The epc estimate is obtained using the equation
+    :math:`r_{\mathcal{C}}^{\text{est}}=\frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}`
+
+    The error bounds are given by
+    :math:`E=\min\left\{ \begin{array}{c}
+    \frac{\left(d-1\right)\left[\left|p-p_{\overline{\mathcal{C}}}/p\right|+\left(1-p\right)\right]}{d}\\
+    \frac{2\left(d^{2}-1\right)\left(1-p\right)}{pd^{2}}+\frac{4\sqrt{1-p}\sqrt{d^{2}-1}}{p}
+    \end{array}\right.`
     """
 
     # pylint: disable=invalid-name

From ca827f10afeb0dd0b10cc9543f7c4274319f1ced Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Thu, 6 May 2021 09:14:29 +0300
Subject: [PATCH 17/20] Linting

---
 .../analysis/data_processing.py               | 19 +++++++++++++++----
 .../interleaved_rb_analysis.py                |  5 +++--
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 4c7d915885..3ad5956f32 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -121,8 +121,16 @@ def mean_xy_data(
 
 
 def multi_mean_xy_data(
-        series: np.ndarray, xdata: np.ndarray, ydata: np.ndarray,
-        sigma: Optional[np.ndarray] = None, method: str = "sample"):
+    series: np.ndarray,
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    method: str = "sample",
+):
+    r"""Return (series, x, y_mean, sigma) data.
+        Performs `mean_xy_data` for each series
+        and returns the concatenated results
+    """
     series_vals = np.unique(series)
 
     series_means = []
@@ -135,7 +143,8 @@ def multi_mean_xy_data(
         idxs = series == series_vals[i]
         sigma_i = sigma[idxs] if sigma is not None else None
         x_mean, y_mean, sigma_mean = mean_xy_data(
-            xdata[idxs], ydata[idxs], sigma=sigma_i, method=method)
+            xdata[idxs], ydata[idxs], sigma=sigma_i, method=method
+        )
         series_means.append(i * np.ones(x_mean.size, dtype=int))
         xdata_means.append(x_mean)
         ydata_means.append(y_mean)
@@ -146,7 +155,9 @@ def multi_mean_xy_data(
         np.concatenate(series_means),
         np.concatenate(xdata_means),
         np.concatenate(ydata_means),
-        np.concatenate(sigma_means))
+        np.concatenate(sigma_means),
+    )
+
 
 def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:
     """Return the outcome probability mean and variance.
diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index b2e791fbd9..4c361b30c2 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -35,12 +35,13 @@
 
 
 class InterleavedRBAnalysis(RBAnalysis):
-    """Interleaved RB Analysis class.
+    r"""Interleaved RB Analysis class.
     According to the paper: "Efficient measurement of quantum gate
     error by interleaved randomized benchmarking" (arXiv:1203.4550)
 
     The epc estimate is obtained using the equation
-    :math:`r_{\mathcal{C}}^{\text{est}}=\frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}`
+    :math:`r_{\mathcal{C}}^{\text{est}}=
+    \frac{\left(d-1\right)\left(1-p_{\overline{\mathcal{C}}}/p\right)}{d}`
 
     The error bounds are given by
     :math:`E=\min\left\{ \begin{array}{c}

From a61bda047c01f11ce5b2770b6a23ac23eafead77 Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Thu, 6 May 2021 09:17:18 +0300
Subject: [PATCH 18/20] Running black

---
 qiskit_experiments/analysis/data_processing.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
index 3ad5956f32..92113827a2 100644
--- a/qiskit_experiments/analysis/data_processing.py
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -128,8 +128,8 @@ def multi_mean_xy_data(
     method: str = "sample",
 ):
     r"""Return (series, x, y_mean, sigma) data.
-        Performs `mean_xy_data` for each series
-        and returns the concatenated results
+    Performs `mean_xy_data` for each series
+    and returns the concatenated results
     """
     series_vals = np.unique(series)
 

From fae6824dad813be222592b0988897c48a201740b Mon Sep 17 00:00:00 2001
From: gadial <gadial@gmail.com>
Date: Mon, 10 May 2021 09:36:05 +0300
Subject: [PATCH 19/20] Bugfixes

---
 .../randomized_benchmarking/interleaved_rb_analysis.py        | 4 ++--
 test/test_curve_fitting.py                                    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
index 4c361b30c2..ea5cb99ac8 100644
--- a/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/interleaved_rb_analysis.py
@@ -75,13 +75,13 @@ def fit_fun_interleaved(x, a, _, alpha_int, b):
         std_xdata = xdata[std_idx]
         std_ydata = ydata[std_idx]
         std_ydata_sigma = ydata_sigma[std_idx]
-        p0_std = self._p0(std_xdata, std_ydata)
+        p0_std = self._p0(std_xdata, std_ydata, num_qubits)
 
         int_idx = series == 1
         int_xdata = xdata[int_idx]
         int_ydata = ydata[int_idx]
         int_ydata_sigma = ydata_sigma[int_idx]
-        p0_int = self._p0(int_xdata, int_ydata)
+        p0_int = self._p0(int_xdata, int_ydata, num_qubits)
 
         p0 = (
             np.mean([p0_std[0], p0_int[0]]),
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
index 9e725b18e0..81c8d30dfd 100644
--- a/test/test_curve_fitting.py
+++ b/test/test_curve_fitting.py
@@ -122,7 +122,7 @@ def test_mean_xy_data(self):
 
         expected_x_mean = np.array([1, 2, 3, 4, 5])
         expected_y_mean = np.array([2, 32, 10.5, 17, 10])
-        expected_y_sigma = np.array([2 / 3, 542, 1 / 4, 0, 0])
+        expected_y_sigma = np.sqrt(np.array([2 / 3, 542, 1 / 4, 0, 0]))
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))
         self.assertTrue(np.allclose(expected_y_sigma, y_sigma))
@@ -141,7 +141,7 @@ def test_mean_xy_data(self):
         series, x_mean, y_mean, y_sigma = multi_mean_xy_data(series, x, y, method="sample")
         expected_x_mean = np.array([1, 2, 1, 2])
         expected_y_mean = np.array([4, 17, 150, 60])
-        expected_y_sigma = np.array([4.0, 0.0, 2500.0, 66.66666667])
+        expected_y_sigma = np.sqrt(np.array([4.0, 0.0, 2500.0, 66.66666667]))
         expected_series = np.array([0, 0, 1, 1])
         self.assertTrue(np.allclose(expected_x_mean, x_mean))
         self.assertTrue(np.allclose(expected_y_mean, y_mean))

From 45f4852b2c014fa5ac845fc95d8faf2e2c457251 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadia@il.ibm.com>
Date: Tue, 11 May 2021 11:38:24 +0300
Subject: [PATCH 20/20] Added interleaved analysis to __init__

---
 qiskit_experiments/randomized_benchmarking/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
index 9104e80567..31d6d98d7a 100644
--- a/qiskit_experiments/randomized_benchmarking/__init__.py
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -15,3 +15,4 @@
 from .rb_experiment import RBExperiment
 from .interleaved_rb_experiment import InterleavedRBExperiment
 from .rb_analysis import RBAnalysis
+from .interleaved_rb_analysis import InterleavedRBAnalysis