Repository: Qiskit-Extensions/circuit-knitting-toolbox
Pull request #560 (2024-04-24 16:10:29)

Test on ARM macOS runners
~~This is due to python 3.8 no longer being available on the macos-latest CI runner.~~

This ~also~ allows us to now perform CI on ARM chips on macOS.

This also restores the ubuntu minimum version to 3.8 so that we test on 3.8 somewhere. https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/issues/515#issuecomment-2073378582

~~We might see intermittent CI failures again until #556 is merged (expected to be very soon).~~

coveralls: ## Pull Request Test Coverage Report for [Build 8819756461](https://coveralls.io/builds/67110313)


### Details

* **0** of **0**   changed or added relevant lines in **0** files are covered.
* No unchanged relevant lines lost coverage.
* Overall coverage remained the same at **95.438%**

---



|  Totals | [![Coverage Status](https://coveralls.io/builds/67110313/badge)](https://coveralls.io/builds/67110313) |
| :-- | --: |
| Change from base [Build 8793439464](https://coveralls.io/builds/67069547): |  0.0% |
| Covered Lines: | 3452 |
| Relevant Lines: | 3617 |

---
##### 💛  - [Coveralls](https://coveralls.io)

garrison: I merged $561, which is an alternative to this.

If we want to take this route, we will have to disable the cutqc tests when cplex is not available.  This should be fine, since cutqc is deprecated now anyway.

Patch:
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 1ec08bf..aed43f9 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -28,11 +28,6 @@ jobs:
           pip install tox
           sudo apt-get update
           sudo apt-get install -y pandoc
-      - name: Temporary workaround for GitVersion
-        shell: bash
-        run: |
-          git config --unset-all extensions.worktreeconfig
-          # See https://github.com/GitTools/actions/issues/1115
       - name: Tell reno to name the upcoming release after the branch we are on
         shell: bash
         run: |
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 3412222..37520b9 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -26,11 +26,6 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install tox
-      - name: Temporary workaround for GitVersion
-        shell: bash
-        run: |
-          git config --unset-all extensions.worktreeconfig
-          # See https://github.com/GitTools/actions/issues/1115
       - name: Run styles check
         shell: bash
         run: |
diff --git a/CITATION.bib b/CITATION.bib
index cfd9ff3..f098dff 100644
--- a/CITATION.bib
+++ b/CITATION.bib
@@ -1,5 +1,23 @@
 @misc{circuit-knitting-toolbox,
-  author = {Luciano Bello and Agata M. Bra\'{n}czyk and Sergey Bravyi and Almudena {Carrera Vazquez} and Andrew Eddins and Daniel J. Egger and Bryce Fuller and Julien Gacon and James R. Garrison and Jennifer R. Glick and Tanvi P. Gujarati and Ikko Hamamura and Areeq I. Hasan and Takashi Imamichi and Caleb Johnson and Ieva Liepuoniute and Owen Lockwood and Mario Motta and C. D. Pemmaraju and Pedro Rivero and Max Rossmannek and Travis L. Scholten and Seetharami Seelam and Iskandar Sitdikov and Dharmashankar Subramanian and Wei Tang and Stefan Woerner},
+  author = {
+    Agata M. Bra\'{n}czyk
+    and Almudena {Carrera Vazquez}
+    and Daniel J. Egger
+    and Bryce Fuller
+    and Julien Gacon
+    and James R. Garrison
+    and Jennifer R. Glick
+    and Caleb Johnson
+    and Saasha Joshi
+    and Edwin Pednault
+    and C. D. Pemmaraju
+    and Pedro Rivero
+    and Seetharami Seelam
+    and Ibrahim Shehzad
+    and Dharmashankar Subramanian
+    and Wei Tang
+    and Stefan Woerner
+  },
   title = {{Circuit Knitting Toolbox}},
   howpublished = {\url{https://github.com/Qiskit-Extensions/circuit-knitting-toolbox}},
   year = {2023},
diff --git a/README.md b/README.md
index 61e1fb8..d7a592a 100644
--- a/README.md
+++ b/README.md
@@ -29,15 +29,12 @@
 
 ### About
 
-Circuit Knitting is the process of decomposing a quantum circuit into smaller circuits, executing those smaller circuits on a quantum processor(s), and then knitting their results into a reconstruction of the original circuit's outcome.
-
-Each tool in the CKT partitions a user's problem into quantum and classical components to enable efficient use of resources constrained by scaling limits, i.e. size of quantum processors and classical compute capability. It can assign the execution of "quantum code" to QPUs or QPU simulators and "classical code" to various heterogeneous classical resources such as CPUs, GPUs, and TPUs made available via hybrid cloud, on-prem, data centers, etc. 
-
-The toolbox enables users to run parallelized and hybrid (quantum + classical) workloads without worrying about allocating and managing underlying infrastructure.
+Circuit Knitting is the process of decomposing a larger quantum circuit into many smaller circuits, executing those circuits on a quantum processor(s), and then knitting their results into a reconstruction of the original circuit's outcome.
 
 The toolbox currently contains the following tools:
 - Circuit Cutting [[1-6]](#references)
-  
+ 
+For a more detailed discussion on circuit cutting, check out our [technical guide](https://qiskit-extensions.github.io/circuit-knitting-toolbox/circuit_cutting/explanation/index.html#overview-of-circuit-cutting).
 ----------------------------------------------------------------------------------------------------
   
 ### Documentation
diff --git a/circuit_knitting/__init__.py b/circuit_knitting/__init__.py
index 088834c..45faabe 100644
--- a/circuit_knitting/__init__.py
+++ b/circuit_knitting/__init__.py
@@ -10,3 +10,15 @@
 # that they have been altered from the originals.
 
 """Main Circuit Knitting Toolbox public functionality."""
+
+from __future__ import annotations
+from importlib.metadata import version, PackageNotFoundError
+
+
+try:
+    __version__ = version("circuit-knitting-toolbox")
+except PackageNotFoundError:  # pragma: no cover
+    # Package is not installed
+    pass
+
+__all__: list[str] = []
diff --git a/circuit_knitting/cutting/cut_finding/best_first_search.py b/circuit_knitting/cutting/cut_finding/best_first_search.py
index 61c8af5..f8d1535 100644
--- a/circuit_knitting/cutting/cut_finding/best_first_search.py
+++ b/circuit_knitting/cutting/cut_finding/best_first_search.py
@@ -15,7 +15,7 @@ from __future__ import annotations
 
 import heapq
 import numpy as np
-from typing import TYPE_CHECKING, Callable, cast
+from typing import TYPE_CHECKING, Callable, cast, NamedTuple
 from itertools import count
 
 from .optimization_settings import OptimizationSettings
@@ -26,6 +26,21 @@ if TYPE_CHECKING:  # pragma: no cover
     from .cut_optimization import CutOptimizationFuncArgs
 
 
+class SearchStats(NamedTuple):
+    """NamedTuple for collecting search statistics.
+
+    It carries information about the number of states visited
+    (dequeued from the search queue), the number of next-states generated,
+    the number of next-states that are enqueued after cost pruning,
+    and the number of backjumps performed.
+    """
+
+    states_visited: int
+    next_states_generated: int
+    states_enqueued: int
+    backjumps: int
+
+
 class BestFirstPriorityQueue:
     """Class that implements priority queues for best-first search.
 
@@ -149,6 +164,8 @@ class BestFirstSearch:
 
     ``stop_at_first_min`` (Boolean) is a flag that indicates whether or not to
     stop the search after the first minimum-cost goal state has been reached.
+    In the absence of any non-LO QPD assignments, it always makes sense to stop once
+    the first minimum has been reached and therefore, we set this bool to ``True``.
 
     ``max_backjumps`` (int or None) is the maximum number of backjump operations that
     can be performed before the search is forced to terminate. None indicates
@@ -185,7 +202,7 @@ class BestFirstSearch:
         self,
         optimization_settings: OptimizationSettings,
         search_functions: SearchFunctions,
-        stop_at_first_min: bool = False,
+        stop_at_first_min: bool = True,
     ):
         """Initialize an instance of :class:`BestFirstSearch`.
 
@@ -213,7 +230,7 @@ class BestFirstSearch:
         self.num_next_states = 0
         self.num_enqueues = 0
         self.num_backjumps = 0
-        self.penultimate_stats: np.typing.NDArray | None = None
+        self.penultimate_stats: SearchStats | None = None
 
     def initialize(
         self,
@@ -258,7 +275,6 @@ class BestFirstSearch:
             self.mincost_bound = self.mincost_bound_func(*args)  # type: ignore
 
         prev_depth = None
-
         while (
             self.pqueue.qsize() > 0
             and (not self.stop_at_first_min or not self.min_reached)
@@ -267,7 +283,6 @@ class BestFirstSearch:
             state, depth, cost = self.pqueue.get()
 
             self.update_minimum_reached(cost)
-
             if cost is None or self.cost_bounds_exceeded(cost):
                 return None, None
 
@@ -299,10 +314,10 @@ class BestFirstSearch:
         """Return True if the optimization reached a global minimum."""
         return self.min_reached
 
-    def get_stats(self, penultimate: bool = False) -> np.typing.NDArray[np.int_] | None:
+    def get_stats(self, penultimate: bool = False) -> SearchStats | None:
         """Return statistics of the search that was performed.
 
-        This is a Numpy array containing the number of states visited
+        This is a NamedTuple containing the number of states visited
         (dequeued), the number of next-states generated, the number of
         next-states that are enqueued after cost pruning, and the number
         of backjumps performed. Return None if no search is performed.
@@ -312,14 +327,11 @@ class BestFirstSearch:
         if penultimate:
             return self.penultimate_stats
 
-        return np.array(
-            (
-                self.num_states_visited,
-                self.num_next_states,
-                self.num_enqueues,
-                self.num_backjumps,
-            ),
-            dtype=int,
+        return SearchStats(
+            states_visited=self.num_states_visited,
+            next_states_generated=self.num_next_states,
+            states_enqueued=self.num_enqueues,
+            backjumps=self.num_backjumps,
         )
 
     def get_upperbound_cost(
diff --git a/circuit_knitting/cutting/cut_finding/cut_optimization.py b/circuit_knitting/cutting/cut_finding/cut_optimization.py
index a0319bc..aabe5ac 100644
--- a/circuit_knitting/cutting/cut_finding/cut_optimization.py
+++ b/circuit_knitting/cutting/cut_finding/cut_optimization.py
@@ -18,7 +18,6 @@ from typing import TYPE_CHECKING
 import numpy as np
 from dataclasses import dataclass
 from typing import cast
-from numpy.typing import NDArray
 from .search_space_generator import ActionNames
 from .cco_utils import select_search_engine, greedy_best_first_search
 from .cutting_actions import disjoint_subcircuit_actions
@@ -27,6 +26,7 @@ from .search_space_generator import (
     SearchFunctions,
     SearchSpaceGenerator,
 )
+from .best_first_search import SearchStats
 from .disjoint_subcircuits_state import DisjointSubcircuitsState
 from .circuit_interface import SimpleGateList, GateSpec
 from .optimization_settings import OptimizationSettings
@@ -261,7 +261,7 @@ class CutOptimization:
             "CutOptimization",
             self.settings,
             self.search_funcs,
-            stop_at_first_min=False,
+            stop_at_first_min=True,
         )
         sq.initialize([start_state], self.func_args)
 
@@ -299,7 +299,7 @@ class CutOptimization:
         """
         return self.search_engine.minimum_reached()
 
-    def get_stats(self, penultimate: bool = False) -> NDArray[np.int_]:
+    def get_stats(self, penultimate: bool = False) -> SearchStats | None:
         """Return the search-engine statistics.
 
         This is a Numpy array containing the number of states visited
diff --git a/circuit_knitting/cutting/cut_finding/cutting_actions.py b/circuit_knitting/cutting/cut_finding/cutting_actions.py
index bfa9afe..450f35e 100644
--- a/circuit_knitting/cutting/cut_finding/cutting_actions.py
+++ b/circuit_knitting/cutting/cut_finding/cutting_actions.py
@@ -417,7 +417,7 @@ class ActionCutBothWires(DisjointSearchAction):
         new_state.bell_pairs.append((r2, rnew_2))
         new_state.gamma_UB *= 16
 
-        new_state.add_action(self, gate_spec, ((1, w1, rnew_1), (2, w2, rnew_2)))
+        new_state.add_action(self, gate_spec, (1, w1, rnew_1), (2, w2, rnew_2))
 
         return [new_state]
 
diff --git a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py
index e171264..38fa96a 100644
--- a/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py
+++ b/circuit_knitting/cutting/cut_finding/disjoint_subcircuits_state.py
@@ -37,7 +37,7 @@ class Action(NamedTuple):
 
     action: DisjointSearchAction
     gate_spec: GateSpec
-    args: list
+    args: list | tuple
 
 
 class GateCutLocation(NamedTuple):
@@ -430,12 +430,12 @@ class DisjointSubcircuitsState:
         self,
         action_obj: DisjointSearchAction,
         gate_spec: GateSpec,
-        args: tuple | None = None,
+        *args: tuple,
     ) -> None:
         """Append the specified action to the list of search-space actions that have been performed."""
         if action_obj.get_name() is not None:
             self.actions = cast(list, self.actions)
-            self.actions.append(Action(action_obj, gate_spec, [args]))
+            self.actions.append(Action(action_obj, gate_spec, args))
 
     def get_search_level(self) -> int:
         """Return the search level."""
diff --git a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py
index 6b3fb03..8ae7d97 100644
--- a/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py
+++ b/circuit_knitting/cutting/cut_finding/lo_cuts_optimizer.py
@@ -12,7 +12,7 @@
 """File containing the wrapper class for optimizing LO gate and wire cuts."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, NamedTuple
 
 from .cut_optimization import CutOptimization
 from .cut_optimization import disjoint_subcircuit_actions
@@ -21,9 +21,6 @@ from .cut_optimization import cut_optimization_goal_state_func
 from .cut_optimization import cut_optimization_min_cost_bound_func
 from .cut_optimization import cut_optimization_upper_bound_cost_func
 from .search_space_generator import SearchFunctions, SearchSpaceGenerator
-
-import numpy as np
-from numpy.typing import NDArray
 from .disjoint_subcircuits_state import DisjointSubcircuitsState
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -155,10 +152,10 @@ class LOCutsOptimizer:
         """Return the optimization results."""
         return self.best_result
 
-    def get_stats(self, penultimate=False) -> dict[str, NDArray[np.int_]]:
+    def get_stats(self, penultimate=False) -> dict[str, NamedTuple | None]:
         """Return a dictionary containing optimization results.
 
-        The value is a Numpy array containing the number of states visited
+        The value is a NamedTuple containing the number of states visited
         (dequeued), the number of next-states generated, the number of
         next-states that are enqueued after cost pruning, and the number
         of backjumps performed. Return None if no search is performed.
diff --git a/circuit_knitting/cutting/cutqc/wire_cutting_evaluation.py b/circuit_knitting/cutting/cutqc/wire_cutting_evaluation.py
index 5a35c3f..dcc27a1 100644
--- a/circuit_knitting/cutting/cutqc/wire_cutting_evaluation.py
+++ b/circuit_knitting/cutting/cutqc/wire_cutting_evaluation.py
@@ -17,6 +17,7 @@ import itertools
 import copy
 from typing import Sequence, Any
 from multiprocessing.pool import ThreadPool
+from warnings import warn
 
 import numpy as np
 
@@ -81,6 +82,14 @@ def run_subcircuit_instances(
                     options[i % len(options)] for i, _ in enumerate(subcircuits)
                 ]
         else:
+            warn(
+                "Please provide a list of `backend_names` alongside the `service`. "
+                "With no backend specified, CutQC defaults to using "
+                "ibmq_qasm_simulator, but cloud simulators are not expected to be "
+                "operational past May 15, 2024. For more details, see: "
+                "https://docs.quantum.ibm.com/announcements/product-updates/2024-03-22-announcement-cloud-simulators-and-lab",
+                stacklevel=2,
+            )
             backend_names_repeated = ["ibmq_qasm_simulator"] * len(subcircuits)
             if options:
                 options_repeated = [options[0]] * len(subcircuits)
diff --git a/circuit_knitting/cutting/cutting_experiments.py b/circuit_knitting/cutting/cutting_experiments.py
index ae434d2..f494540 100644
--- a/circuit_knitting/cutting/cutting_experiments.py
+++ b/circuit_knitting/cutting/cutting_experiments.py
@@ -19,12 +19,8 @@ from collections.abc import Sequence, Hashable
 import numpy as np
 from qiskit.circuit import QuantumCircuit, ClassicalRegister
 from qiskit.quantum_info import PauliList
-from qiskit.transpiler import PassManager
-from qiskit.transpiler.passes import RemoveResetInZeroState, DAGFixedPoint
-from qiskit.passmanager.flow_controllers import DoWhileController
 
 from ..utils.iteration import strict_zip
-from ..utils.transpiler_passes import RemoveFinalReset, ConsolidateResets
 from ..utils.observable_grouping import ObservableCollection, CommutingObservableGroup
 from .qpd import (
     WeightType,
@@ -62,12 +58,6 @@ def generate_cutting_experiments(
 
     The coefficients will always be returned as a 1D array -- one coefficient for each unique sample.
 
-    Note that this function also runs some transpiler passes on each generated
-    circuit, namely :class:`~qiskit.transpiler.passes.RemoveResetInZeroState`,
-    :class:`.RemoveFinalReset`, and :class:`.ConsolidateResets`, in order to
-    remove unnecessary :class:`~qiskit.circuit.library.Reset`\ s from the
-    circuit that are added by the subexperiment decompositions for cut wires.
-
     Args:
         circuits: The circuit(s) to partition and separate
         observables: The observable(s) to evaluate for each unique sample
@@ -172,20 +162,11 @@ def generate_cutting_experiments(
     # https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/issues/452.
     # While we are at it, we also consolidate each run of multiple resets
     # (which can arise when re-using qubits) into a single reset.
-    pass_manager = PassManager()
-    passes = [
-        RemoveResetInZeroState(),
-        RemoveFinalReset(),
-        ConsolidateResets(),
-        DAGFixedPoint(),
-    ]
-    pass_manager.append(
-        DoWhileController(
-            passes, do_while=lambda property_set: not property_set["dag_fixed_point"]
-        )
-    )
-    for label, subexperiments in subexperiments_dict.items():
-        subexperiments_dict[label] = pass_manager.run(subexperiments)
+    for subexperiments in subexperiments_dict.values():
+        for circ in subexperiments:
+            _remove_resets_in_zero_state(circ)
+            _remove_final_resets(circ)
+            _consolidate_resets(circ)
 
     # If the input was a single quantum circuit, return the subexperiments as a list
     subexperiments_out: list[QuantumCircuit] | dict[Hashable, list[QuantumCircuit]] = (
@@ -206,7 +187,6 @@ def _get_mapping_ids_by_partition(
     # Collect QPDGate id's and relevant map id's for each subcircuit
     subcirc_qpd_gate_ids: dict[Hashable, list[list[int]]] = {}
     subcirc_map_ids: dict[Hashable, list[int]] = {}
-    decomp_ids = set()
     for label, circ in circuits.items():
         subcirc_qpd_gate_ids[label] = []
         subcirc_map_ids[label] = []
@@ -223,7 +203,6 @@ def _get_mapping_ids_by_partition(
                         ' formatted as "<your_label>_N". This allows SingleQubitQPDGates '
                         "belonging to the same cut to be sampled jointly."
                     ) from ex
-                decomp_ids.add(decomp_id)
                 subcirc_qpd_gate_ids[label].append([i])
                 subcirc_map_ids[label].append(decomp_id)
 
@@ -389,3 +368,90 @@ def _get_pauli_indices(cog: CommutingObservableGroup) -> list[int]:
     if not pauli_indices:
         pauli_indices = [0]
     return pauli_indices
+
+
+def _consolidate_resets(
+    circuit: QuantumCircuit, inplace: bool = True
+) -> QuantumCircuit:
+    """Consolidate redundant resets into a single reset."""
+    if not inplace:  # pragma: no cover
+        circuit = circuit.copy()
+
+    # Keep up with whether the previous instruction on a given qubit was a reset
+    resets = [False] * circuit.num_qubits
+
+    # Remove resets which are immediately following other resets
+    remove_ids = []
+    for i, inst in enumerate(circuit.data):
+        qargs = [circuit.find_bit(q).index for q in inst.qubits]
+        if inst.operation.name == "reset":
+            if resets[qargs[0]]:
+                remove_ids.append(i)
+            else:
+                resets[qargs[0]] = True
+        else:
+            for q in qargs:
+                resets[q] = False
+
+    for i in sorted(remove_ids, reverse=True):
+        del circuit.data[i]
+
+    return circuit
+
+
+def _remove_resets_in_zero_state(
+    circuit: QuantumCircuit, inplace: bool = True
+) -> QuantumCircuit:
+    """Remove resets if they are the first instruction on a qubit."""
+    if not inplace:  # pragma: no cover
+        circuit = circuit.copy()
+
+    # Keep up with which qubits have at least one non-reset instruction
+    active_qubits: set[int] = set()
+    remove_ids = []
+    for i, inst in enumerate(circuit.data):
+        qargs = [circuit.find_bit(q).index for q in inst.qubits]
+        if inst.operation.name == "reset":
+            if qargs[0] not in active_qubits:
+                remove_ids.append(i)
+        else:
+            for q in qargs:
+                active_qubits.add(q)
+            # Early terminate once all qubits have become active
+            if len(active_qubits) == circuit.num_qubits:
+                break
+
+    for i in sorted(remove_ids, reverse=True):
+        del circuit.data[i]
+
+    return circuit
+
+
+def _remove_final_resets(
+    circuit: QuantumCircuit, inplace: bool = True
+) -> QuantumCircuit:
+    """Remove resets if they are the final instruction on a qubit."""
+    if not inplace:  # pragma: no cover
+        circuit = circuit.copy()
+
+    # Keep up with whether we are at the end of a qubit
+    # We iterate in reverse, so all qubits begin in the "end" state
+    qubit_ended = set(range(circuit.num_qubits))
+    remove_ids = []
+    num_inst = len(circuit.data)
+    for i, inst in enumerate(reversed(circuit.data)):
+        qargs = [circuit.find_bit(q).index for q in inst.qubits]
+        if inst.operation.name == "reset":
+            if qargs[0] in qubit_ended:
+                remove_ids.append(num_inst - 1 - i)
+        else:
+            for q in qargs:
+                qubit_ended.discard(q)
+            # Early terminate once all qubits have been touched
+            if not qubit_ended:
+                break
+
+    for i in sorted(remove_ids, reverse=True):
+        del circuit.data[i]
+
+    return circuit
diff --git a/circuit_knitting/cutting/qpd/decompose.py b/circuit_knitting/cutting/qpd/decompose.py
index 999a664..035b210 100644
--- a/circuit_knitting/cutting/qpd/decompose.py
+++ b/circuit_knitting/cutting/qpd/decompose.py
@@ -145,10 +145,10 @@ def _decompose_qpd_measurements(
         if instruction.operation.name.lower() == "qpd_measure"
     ]
 
-    # Create a classical register for the qpd measurement results.  This is
-    # partly for convenience, partly to work around
-    # https://github.com/Qiskit/qiskit-aer/issues/1660.
-    reg = ClassicalRegister(len(qpd_measure_ids), name="qpd_measurements")
+    # Create a classical register for the qpd measurement results.
+    # We force at least one classical bit as a workaround to
+    # https://github.com/openqasm/qe-qasm/issues/37.
+    reg = ClassicalRegister(max(1, len(qpd_measure_ids)), name="qpd_measurements")
     circuit.add_register(reg)
 
     # Place the measurement instructions
diff --git a/docs/circuit_cutting/cutqc/tutorials/tutorial_1_automatic_cut_finding.ipynb b/docs/circuit_cutting/cutqc/tutorials/tutorial_1_automatic_cut_finding.ipynb
index 9177e30..82672cf 100644
--- a/docs/circuit_cutting/cutqc/tutorials/tutorial_1_automatic_cut_finding.ipynb
+++ b/docs/circuit_cutting/cutqc/tutorials/tutorial_1_automatic_cut_finding.ipynb
@@ -246,8 +246,10 @@
     "# Set the Sampler and runtime options\n",
     "options = Options(execution={\"shots\": 4000})\n",
     "\n",
-    "# Run 2 parallel qasm simulator threads\n",
-    "backend_names = [\"ibmq_qasm_simulator\"] * 2"
+    "# Use the least busy backend for both threads\n",
+    "backend_names = None\n",
+    "if service is not None:\n",
+    "    backend_names = [service.least_busy().name] * 2"
    ]
   },
   {
diff --git a/docs/circuit_cutting/cutqc/tutorials/tutorial_2_manual_cutting.ipynb b/docs/circuit_cutting/cutqc/tutorials/tutorial_2_manual_cutting.ipynb
index 4b3037e..18ba96b 100644
--- a/docs/circuit_cutting/cutqc/tutorials/tutorial_2_manual_cutting.ipynb
+++ b/docs/circuit_cutting/cutqc/tutorials/tutorial_2_manual_cutting.ipynb
@@ -75,60 +75,6 @@
     "circuit.draw(\"mpl\", fold=-1, scale=0.75)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "461e57e3",
-   "metadata": {},
-   "source": [
-    "## Set up the Qiskit Runtime Service\n",
-    "\n",
-    "The Qiskit Runtime Service provides access to IBM Runtime Primitives and quantum backends.\n",
-    "Alternatively, a local statevector simulator can be used with the Qiskit primitives."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "5d1fb2ca",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit_ibm_runtime import (\n",
-    "    QiskitRuntimeService,  # noqa: F401\n",
-    "    Options,\n",
-    ")\n",
-    "\n",
-    "# Use local versions of the primitives by default.\n",
-    "service = None\n",
-    "\n",
-    "# Uncomment the following line to instead use Qiskit Runtime.\n",
-    "# service = QiskitRuntimeService()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5fb383d2",
-   "metadata": {},
-   "source": [
-    "The wire cutter tool uses a `Sampler` primitive to evaluate the probabilities of each subcircuit. Here, we configure the options for the Runtime Sampler and specify the backend(s) to be used to evaluate the subcircuits.\n",
-    "\n",
-    "If no service was set up, the `backend_names` argument will be ignored, and Qiskit primitives will be used with statevector simulator."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "d409553d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Set the Sampler and runtime options\n",
-    "options = Options(execution={\"shots\": 4000})\n",
-    "\n",
-    "# Run 2 parallel qasm simulator threads\n",
-    "backend_names = [\"ibmq_qasm_simulator\"] * 2"
-   ]
-  },
   {
    "attachments": {
     "how-to-manual-cut.png": {
@@ -244,6 +190,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from qiskit_ibm_runtime import (\n",
+    "    QiskitRuntimeService,  # noqa: F401\n",
+    "    Options,\n",
+    ")\n",
+    "\n",
     "# Use local versions of the primitives by default.\n",
     "service = None\n",
     "\n",
@@ -273,8 +224,10 @@
     "# Set the Sampler and runtime options\n",
     "options = Options(execution={\"shots\": 4000})\n",
     "\n",
-    "# Run 2 parallel qasm simulator threads\n",
-    "backend_names = [\"ibmq_qasm_simulator\"] * 2"
+    "# Use the least busy backend for both threads\n",
+    "backend_names = None\n",
+    "if service is not None:\n",
+    "    backend_names = [service.least_busy().name] * 2"
    ]
   },
   {
diff --git a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb
index 7843ebf..cb59434 100644
--- a/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb
+++ b/docs/circuit_cutting/tutorials/04_automatic_cut_finding.ipynb
@@ -16,17 +16,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/0AAAGRCAYAAAA3ltNoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB+I0lEQVR4nO3deVwU5R8H8M9eXHIJCIuAggfmgSKeeB9pmpXmbaX5Ky0zz8qy8qw0zcozzay01DzySFMjBe8TU0HwABEPQBaQQ+5j2f39QaEr5wK7s7t83q9Xr9xnZnY/A8zx3XnmGZFarVaDiIiIiIiIiEyOWOgARERERERERKQbLPqJiIiIiIiITBSLfiIiIiIiIiITxaKfiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8Win4iIiIiIiMhEsegnIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhPFop+IiIiIiIjIRLHoJyIiIiIiIjJRLPqJiIiIiIiITBSLfiIiIiIiIiITxaKfiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8Win4iIiIiIiMhEsegnIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhPFop+IiIiIiIjIRLHoJyIiIiIiIjJRLPqJiIiIiIiITBSLfiIiIiIiIiITxaKfiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8Win4iIiIiIiMhESYUOQKQvQa8vQcZdhdAxYOMpR99fZlfrPQxlXYCaWR8iIiJ9MJTjJ4+dZExMabsxlHUB9LsfYNFPtUbGXQXSImOFjlEjTGldiIiI9IXHTyLtmdJ2Y0rrog127yciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8Win4iIiIiIiMhEcSA/oqd0W/EumozqDQBQFRYiJyEN8WfCcXnxVmQrUgROR0RERLrGcwEi7XG7MVy80k9UCsX569jRegJ2tX8HJ99dAcdWnuj1w/tCxyIiIiI94bkAkfa43RgmFv1EpVDlK5GTlIZsRQoSzt9AxJZAOHdoBpm1pdDRiIiISA94LkCkPW43holFP1EFLF3qwvOFzlApC6EuVAkdh4iIiPSM5wJE2uN2Yzh4Tz9RKeRdWuLVqM0QicWQWpoDAMLX7YcyJw8A0GvD+3hwIhSRWwIBAA6tvNBj7XT82W8WCvMKBMtNRERENaOicwEruQOeP7AIB577CLnJ6ZBYmmFw4Dc4+uYypN28L2R0IsFUtN00GNgRvu+N0FjGztsdwXM3IuLXw3rPW1sYddEfGhqKefPm4fjx41Cr1ejTpw/WrVsHb29vDBo0CNu3bxc6IhmppMu3cHr6GkjMZfB8qQvqd2+NK0u3FU8PnrsRA/d9jnuHLiAvNRP+Sybiwic/seAnIiIyERWdC2QrUnB9/QF0WDgep6asgu/7I3Hvrwss+KlWq2i7uf9XMO7/FVz8usGADvD7+BVE/X5cgLS1h9EW/UFBQXjhhRfQsGFDzJkzB5aWlti0aRMGDhyIzMxM+Pr6Ch2RjFhhbj4y7ioAACHLdsDGU45Oi97E2Q++B1B0oL+2/gDazx2Lh1ei8Cg6HvGnw4SMXGkSCzO0njYUXoO7wsrVoWhd7yXg9q6TuPHTIaHjERmkzJgkRGw+jKRLkVApC2HbyBXer/VDPb+mEIlEQscjIh2o6FwAAG789BdeCFiK5hOeR8PnO2F/3w+EiktkECqz3fzHytUBnRZPQOCri1GYk6/vqFrr99unkFlb4a8hc6FWPb5dwcHHC4MOLMbJd1fh3oFzAiYsm1EW/UlJSRg1ahT8/PwQGBgIS8uigSHGjh0LLy8vAGDRTzUq5OsdePnkSkRsPoLk0NsAgJsbAzDo4GK4dm2FPwfOFjhh5fkvmQh511YInvszUq7dg8zGEo6tvFDHzUnoaEQGR61W48rS7bi6ag+gVgMiABAhMfgmorYfg1tvX/Rc/x7MbKyEjkpEOlbauYBapcLF+ZswYM9CHH3jq+IuzERUpLTtBgAgEqHHmukIW/MHUm/cEy6gFk7P+A6Dj34Dn2kv4+qK3QCKLqb1WDMN0XtOGWzBDxjpQH5Lly5FamoqNm7cWFzwA4CdnR38/PwAsOinmpVxR4GYI//Ab/aYx41qNSJ+PYLYoMvIS04XLpyWGgzoiPC1+3A/4CIyYxKRev0eonYeR+jyXUJHIzI4IV/vxNWVu4sKfgBQ4/G/AcQdC8HR8UuhKlAKE5CI9KbUcwEAbn3bIluRgrrPNBAoGZHhKmu7aTNjGPIzsnHz578ESqa9nMQ0nP3ge7SZORyObRoDANp9+hrEZjJcmPOzwOnKZ5RF//bt29G9e3d4e3uXOt3FxQVyuRwAoFQqMX36dDg4OMDe3h5vvvkmcnNz9RmXTET42v1w6+ULuX/Lx40qFdQqddkLGaDsxFS49W4LM3troaMQGbTshNSigr8CirPXcD8guML5iMj4PX0uYP9MAzQY0BEHBs5G01f6wrqBs8AJiQzP09uNc4dmaPpKX5yZ+Z3AybR3P+AionYeR4810+DRvz2ajeuHU1NWQZll2PWl0XXvVygUiIuLw6hRo0pMU6lUCAsLQ9u2bYvbFi9ejGPHjiEsLAxmZmZ46aWX8OGHH2LVqlWV+jylUgmFQlFj+Uk4BZW8End6Ruk7oKR/IrDJdXiN5IiNja32e1TV2ffXocfaGRgd/hPSImKRdDkScUGXcT/gYpWzVHd9iAxR9E+HK/2IodD1+yFty6t8RIaups8F/Je+hYvzNyFbkYIrX21Hp0VvImjsl5XKwWMnGYua3G7MbK3QffU0nJ6+BnmpmVrnEPIc+j8X523Ci0eWoffPs3B1+W4kXYqschZt10cul0Mq1b6EN7qiPysrCwBKHThp3759SExM1Oja/+OPP+Krr76Cm5sbAGDBggUYMWIEli9fDolEUuHnKRQKeHh41Ex4EtQXjv3gJrMVOgYiIyMxspp/U9VZl8SLEdjd+V04tW0K53becOncAr02fIC4o1cQ9PoSrd+vJtaHyBBNs/eHr7lrpQbqi794k8cKIiNQk+cCTV99FrkPHyE26DIA4PbvJ9B0TB80eL4T7h+6UO6yPHaSManJ7abZ68/B0tkeHReO12iP+v0Erv9woNxlhT6H/o8yJw/h6/bDf8lEhK6o+u2xVVmfmJgYuLu7a/1ZRlf0e3h4QCKR4MSJExrt9+7dw9SpUwE8vp8/LS0NMTExGl8C+Pn5ISMjA3fv3kXjxo31FZtMVNTO44jaeVzoGFpTF6qQ9E8Ekv6JwLX1f6LRsO7osWY6XPxbIOHcdaHjERkEESo/Kr+YI/gT1Tq3tgbi1tZAjbaAofMFSkNkHMJW70XY6r1Cx6g29b89BirbI1BoRlf0m5mZYdy4cdi4cSMGDx6MQYMGISYmBhs2bICLiwvi4uKKi/yMjAwAgL29ffHy//37v2kVkcvliImJqclVIIGcG7kEWXeEv1XD29sbMTurN9hHTa/Lo1txAAALRzutl62J9SEyRLdW78e9X49WPKMIcHymIWL+4bGCyNCZ0rkAkb6Y0nZjKOsCVG19/hu3TltGV/QDwKpVqyCTybBv3z4cPXoU/v7+2Lt3Lz777DNERUUVD/BnY2MDAHj06FHxDygtLU1jWkWkUmmVulCQ4ZHJDOPPXSar/t9UddZlwJ6FuPPHGTwMvY3c5Eew9XSF38evIC8tE4qz4VXKwm2ETJHtpJcrV/SrAZ8JL3A7IDICpnQuQKQvprTdGMq6APrdDxjOWmvB2toa69evx/r16zXaw8PD4ePjA7G46KEE9vb28PDwQEhICJo1awYAuHLlCmxsbODp6anv2EQGIe7oFTQa2h2+s0bBzNoSOcmPkHD+Bk7P/A55KZXrAUNUG9h6uaLpmD64ta38wt+uqRu8Xu6mp1RERERE2jHKor80aWlpiI2NxaBBgzTaJ0yYgC+//BLdu3eHTCbDggULMH78+EoN4kdkisLW/IGwNX8IHYPIKHReMhHKnDzc+eNMqdPtvN3R/7c5kFlZ6DkZERERCcXYxvUymaI/LCwMADQG7QOATz75BA8fPkTLli2hUqkwfPhwLF26VICERERkbCRmMvRYOwPNxvZH+Lr9iA28BABw8muK5m8MhOcL/pCYywROSURERFQ2ky/6pVIpVq1ahVWrVgmQioxF01f6ounoPlCrVTj30Qak3bxfPM2jf3u0njYUhQVKRG4+gug9pwAAXb6eBNvG9VGYm48z769D9oNkNBnZC23eG4GsuIcAgCOvLkJhbr4g60RENUMkEkHepSVsPOX4vd3bAIDeGz5AnfqOAicjIl2ydq+HHmtnQKVUQiSR4PzsDUi9ca94evc102DTwAUiiRg3NwXg9u8nynk3ItNV0bYisTRDp8/fgHUDF4glYgS+thjWHvXgv+xtqFVqqJWFOPP+OmTeTxRwLUybyRT9kydPxuTJk4WOQUbIzN4azV7vj4ODPoFNQxf4L5mIv0csLJooEqHdp6/iwMCPUZiXjwF7FiLmyCW4dm2JwrwCBLw8D46tG6Hdp6/h1LsrAQCRW46w+zwREZGRy4pPxqHBcwC1GvKurdB62lCceGd58fSQb3Yi444CYjMpBh/9Fnf+OAPVv4/xIqpNKtpWfN8biei9p6E483jA6NzkdAS+9iUKMrLh1tsXbWYOx5mZa4WIXyuYTNFPVFX12jaB4uw1qJWFSL/9AOYOtoBIBKjVsHCwQe7DdCizcwEAj6IeoJ5fU9g2qo/k0NsAgOSr0XDp9Ezx+zUZ1Rvu/drhfsBFXFu3X5B1IiIioup58vnbZjaWSLl+V2N6xr+P/VLlKwG1Gmq1Wp/xiAxGRduKvGtLSMyl8H1vBB6cuoqrK3YjNzm9eLqqoNBonndvrMRCByASmpm9NfIfZRW/LsjMgZmtFYCibyEtnGxh6WwPaR0LuHRqDnN7a6TevI/6vXwBAG69fWH57/Pt7wcE44+eM/H38IWQ+7eEazcfva8PERER1QyHlp54/s9F6LRoAuJPhZU6T6t3h+DuwfNQKwv1nI7IcJS3rTi08ETcsRAEDF8AR59GkPu3LJ4msTCD76yRuP7jIX1HrlVY9FOtl/8oC2a2dYpfy6wtkZ+eXfz63Ec/oMd309Fz3UykRcQgOyEFcUevID36AQbsXgi3Pm2R8u99S/np2VCrVFAVKHHv0AU4+HjpfX2IiIioZqRcu4tDL36KoPFL0GnxmyWmew3uCkcfL1xZul2AdESGo7xtJTclHXHHQwG1Gg9OhKJui4YAAJFEjB5rp+Pauv0a42lRzWPRT7Ve0uVbcOncHCKJGDaecuSlpANPdNFLOH8Df49YiBOTlkNqZY6kS7cAACFf70TAsPmI+fsfKM5eAwDIbKyKl5P7t0DGnXj9rgwRERHVCLHZ47tgC9KzUZijOTBv/V5t0HRMH5yatlrjvIGotqloW0k4fwOOrRsBABxbN0L6v+fHXb95Bw+Oh+J+wEX9ha2leE8/1Xr5aZm49VsQBu79HGq1Cuc//hFuvX1hZm+NO3tPo/38cXD0aQSVshCXv/wNqgIlzB1s0HvDB1ApC5EV9xAXPv0JANBy0otw6+ULtUqFhyG3uRMjIiIyUs4dnoHvByOhLlRBJBIheMEmjfOD7iunIDshFf23zQUAnJi0HDlJacKGJhJARdvKpcVb0PXrdyCxMENaRAzijl6BW29feL7UBdYezvAa3BUp1+4geN4moVfFZLHoJwIQuSUQkVsCi1+nXn/8mJF/Fv5aYv68lAwEDJtfoj1k2Q6ELNuhm5BERESkN4oz4Qh4YrTxp+1oM1GPaYgMV0XbSlbsQxwe/blGW9yxEGxp9Kquo9G/2L2fiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwU7+mnWsPGU16t5VXKQqRHF402atvIFWKpRJAcNfEeNbUuNZGFiIhIXwzl+MljJxkTU9puDGnb02cWkVrNZ4wQVUbWg2T83u5tAMCIS+tRp76jwImqzpTWhUhfuN0QEfcDRNrjdiM8du8nIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhPFop+IiIiIiIjIRLHoJyIiIiIiIjJRLPqJiIiIiIiITBSLfiIiIiIiIiITxaKfiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8Win4iIiIiIiMhEsegnIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhMlFToAGa6g15cg465C6BgAABtPOfr+MlvoGERERFozpOOpseBxv2KG9HdlTL+vmReAuGyhUwBuVsDyTkKnoNqCRT+VKeOuAmmRsULHICIiMmo8npIu8O+qauKygegMoVMQ6Re79xMRERERERGZKBb9RERERERERCaK3fsNyKOMfETcfYScPCVkUjEaudtA7mQldCwiIiIiIiIyUiz6BXb9dirW7byJv8/G4ta99BLT6ztboVd7V7w9vBm6t5NDJBIJkJKIiIiIiIiMEYt+gdx7kIHJi87i0KnyB2B5kJiN3w7dxm+HbqNNMwesn9sVnVo76yll5XVb8S6ajOoNAFAVFiInIQ3xZ8JxefFWZCtSBE5HREREVHvxPI2oduM9/QL4Zd8ttBq6t8KC/2mhESnoMu4APl55EYWFKh2lqzrF+evY0XoCdrV/ByffXQHHVp7o9cP7QsciIiIiqvV4nkZUe7Ho17NlG69i/NyTyMwuqNLyKpUaS366inGfnjS4wl+Vr0ROUhqyFSlIOH8DEVsC4dyhGWTWlkJHIyIiIqrVeJ5GVHux6NejX/ffwofLL5Y7j0QigpuLFdxcrCCRlH3//m+HbuO9ZRdqOmKNsXSpC88XOkOlLITawL6cICIiIqrNeJ5GVLuw6NeT+/GZmPLluQrnkztZIvbIGMQeGQO5U/nfvK767TqCzj+oqYjVJu/SEq9GbcZr0VsxKmQD5P4tcX3DQShz8gAAVnIHDP9nHSwcbQEAEkszDD2zGvbPNBAyNhEREZHJq+g8rdeG9+H92rPF8zu08sKQkysgMZcJFdmohE30FDoCUZmMuugPDQ3F4MGDYWdnB1tbWwwZMgTx8fGwsbHB6NGjhY6nYcric8jIqlqX/vJMWHAK+QWFNf6+VZF0+Rb2PzsLBwbORsi3vyPxYgSuLN1WPD1bkYLr6w+gw8LxAADf90fi3l8XkHbzvkCJiYhIl5QqICwFuJAE3HoEqNVCJyKqvSo6TwueuxE+U1+GuYMNIBLBf8lEXPjkJxTm1fz5KxHpl9EW/UFBQejcuTMiIiIwZ84cLF68GLGxsRg4cCAyMzPh6+srdMRiEXfS8OcJ3RS2dx9kYk/gXZ28t7YKc/ORcVeBtIgYhCzbgYyYRHRa9KbGPDd++gv23h5oPuF5NHy+E0K/+V2gtEREpCt5hcAPEcCgI8D/TgPvngPGnABGHwf+vM/i/0kunZujz8aPMPziOoyP34XWM4YJHYlMVEXnadmKFFxbfwDt545Fs7H98Cg6HvGnwwRMbBxifpyJ6zN8UZDyANdn+CL6q1FCRyIqwSgf2ZeUlIRRo0bBz88PgYGBsLQs6gY/duxYeHl5AYBBFf3rd93U6fuv3XEDowc21ulnVEXI1zvw8smViNh8BMmhtwEAapUKF+dvwoA9C3H0ja+Ku5QREZFpyFUCU88DV1KAp0emic4AFoYAkenAey0BUdlD19QaUisLpN2KQfTeU+j42f+EjkO1SGnnaTc3BmDQwcVw7doKfw6cLXBCYanychC/azFST21HfnIsxGaWMJc3hmOvsXB+cVrxfB4TlgMo6t7fYkWIQGmJymeUV/qXLl2K1NRUbNy4sbjgBwA7Ozv4+fkBMKyi/++zcTp9/zMhiciq4tMAdCnjjgIxR/6B3+wxGu1ufdsiW5GCuryXn4jI5Ky4XlTwA8DTF/T/e70tGvhLu6fWmqy4o1dwefFvuLv/LFT5hncsJ9NV6nmaWo2IX48gNugy8pLThQtnAO5//w5Sjv0K9/HL0HLNdXh/cQz1nn8Xyqw0oaMRac0oi/7t27eje/fu8Pb2LnW6i4sL5HI5AGDnzp3o1q0brK2t4enpqceURTKzC3DzziOdfoZKpUZIRIpOP6Oqwtfuh1svX8j9WwIA7J9pgAYDOuLAwNlo+kpfWDdwFjghERHVlPR8YH8l7mYTAdgazW7+REJ7+jwNAKBSQa3ixpl24Q+4vDwL9p2HwNzFC1ZebeDUdzzqj54ndDQirRld936FQoG4uDiMGlXyfhmVSoWwsDC0bdu2uK1u3bqYMmUKEhISsHz5cq0/T6lUQqFQVDlv+O10qJ7acUokojJH5nd9ot21jHkUD3NQWKj5nmcv3UHDejV7haCgQFnpeU/P+K7U9qR/IrDJdXjxa/+lb+Hi/E3IVqTgylfb0WnRmwga+2WlssTGCntZKDchrfjf8fHxsFDlCBemmkxpXYj0hdtNxYKSrZCvcqhwPjWAiEdA8G0F3Cwqf6wxVtocT6mIIRz3S2NI+wFdnKdVJ4sh/r5KU1DgAqDiJxLI6roi/XIAHHq8AqlNxfs17XMUIDY2ocbf1xAZ0nZj7ORyOaRS7Ut4oyv6s7KyAACiUm4E3LdvHxITEzW69vfr1w8A8Mcff1Tp8xQKBTw8PKq0LADAqjHQ+GONpv8ey1eRi9uGlNru3m8b4hKyNdo+nP0JPpx4rMoxS/OFYz+4yWxr7P2avvosch8+QmzQZQDA7d9PoOmYPmjwfCfcP3Sh3GUjIyMxsjq/hxpQV2yJb52fBwB07NgRqUa8wzKldSHSF243FXMZ8j7c//d1pefv++IwZN08q8NEhqGmj6e1gSEc90tjSPsBQ/q7MtTfV2larA6HZYOWFc7XcMqPuPPNKwgdVw+WHi1Rp1ln2LV7HnadBpdah2grMjISHs+1qvb7GAND2m6MXUxMDNzd3bVezuiKfg8PD0gkEpw4cUKj/d69e5g6dSoAw7qfHyo9fbuvMozH9pXn1tZA3NoaqNEWMHS+QGmIiKimFWZrdw9wYU7tvmeYyBBF7TyOqJ3HhY4hOOvmXdFq/W1kRQYjK+IcMq6dxO2lw2HXbiAaf7q/ROFv4dFCoKREFTO6ot/MzAzjxo3Dxo0bMXjwYAwaNAgxMTHYsGEDXFxcEBcXV6NFv1wuR0xMTJWXT8sogM+ooxptioc5cO+3rdT5XZ0si6/wdxjzB+IflvwmTFFK2/ZfV6Grr2OVc5bm3MglyLpT9VsbapK3tzdidv4saIbchDScfmEBACA4OBgWLvaC5qkOU1oXIn3hdlOx5HwxJoaroSoxbr8mEdRwMVNiz6m/IK4FI/gb0vHUWBjCcb80hrQfMKS/K0P9fZVm6nUXxORWbl6RRArr5l1g3bwLXIa8j+TjW3B3+VhkXjsJm1Y9NeZtOu+QVjm8vb3xdzVqDGNiSNuNsftv3DptGV3RDwCrVq2CTCbDvn37cPToUfj7+2Pv3r347LPPEBUVVeYAf1UhlUqr1IXiP+4AGrnbIDo2o7itsFBdont+aeIf5lRqPgB4rsczsLc1r2rMUslkhvPnIZNV7/dQE7LET4y34OqKOvVr9ksWfTKldSHSF243FXMH0CcFCHxQ/nxqiDCmqQwNPITdr+tLecdTqZUFbL2KTuLEMiks69nDoaUnCrJykXHXMAo6IRjCcb80hrQf4Hla1chuAahk0f80C/fmAADlo8Tq55DJjOZnVl2GtN3UVoazt9CCtbU11q9fj/Xr12u0h4eHw8fHB2KxYT2UoHcHV42iv6b5PuNQ4wU/ERFRVXzoA9x8BMRmlT1PdxdglJf+MhkypzaNMWDPwuLXzd8YiOZvDITi7DUEDOMtcERCifikJxy6j4FVk/aQ2tVDXnwU4jZ/Akkde9j49BY6HpFWjLLoL01aWhpiY2MxaNAgjfbCwkIUFBSgoKAAarUaubm5EIlEMDfXX5H89ohn8NPeSJ29/6QRzXX23kRERNpwMAc2dgO+CQeOPACefNiMtRQY7glMegaQGtb384JRnLtWI6OnE1HNsvMbiJSTW/Fg2zwUZqdDaucMm5Y94DltI6S2TkLHI9KKyRxyw8LCAJQcxG/z5s2wtLTEyJEjcf/+fVhaWqJZs2Z6zdahVT34t9HN8+gd7Mzx6qDGOnlvbdg2csW4+9tRz6+pRrvv+yMx/OI69Pvt0+I2iaUZnv9zEV65+Qu8BnfVd1QiItKxuubAF+2AX7o/bvu4NRDQH5jSggU/kb6VdZ72nwG7F8J/6VtaLWPq5MNno9mXp9Dm10T47cpF65/uw+u9LbBswAH7yPiYzGG3rKJ//PjxUKvVGv/dvXtX7/m+n9sVUmnNj1a0anZnWFtV/KxRXWszczgU566XaI/YfLhE90RVnhLH3liG6xsO6iseEREJoO4Tneq6uQAWJtO/kMi4lHWeBgDuz7ZDQWbJQaLLW4aIjIvJFP2TJ0+GWq1G586dhY5SqtbeDlgwya/C+f4b2d+937ZSR+l/0st9G+KV54W/yu/UtilyEtOQHZ9cYlpOYhqgUmu0qVUq5CSl6SccERERUS1W3nkaRCI8878BuLkpoPLLEJHRMZmi3xh8MrENJg4r/9aC/0b2j0vIRmGhusz5urV1weZFPUs8I1QIracPRdiavULHICIiIqKnlHee1mRkL9w7dAGFuQWVXoaIjA+Lfj0SiUT4fm5XfDKhDapTqw971hMB655DHQPo1u/e1w/JobeRl5opdBQiIiIiekJ552kScxkaDe2OqO1HK70MERkn3l2nZ2KxCIumtcegHh54Y94pRNx9VOllHe3NsXq2P0YPbGQQV/gBwKGVJ+RdWsK5QzPYP9MAto3r49iby4q69RMRERGRYMo7T7Nu4Awzuzp4dvPHMLO3hqWzPRqP6Ik69R15bkdkYlj0C6SLrwvC9wzFwVMxWLfjBo4Gx6NAqSoxn0gEtGvhhEkjnsHoAY0M4ur+k66u3IOrK/cAALqteBcRvx6GQ0tPmHW1xp29p+H92rNoPKIn7Jq4of+OeTg1bTVyElLR68cP4NjKC8rsXDj5NcXF+ZuEXREiIiIiE1PRedqBAR8BAOT+LeE1pCtu/36ieLknl2HBT2TcWPQLSCoVY3DvhhjcuyHy8gsRHpWKM5cTMP2r8wCAXd/0Qf8ubrCpYyZw0so5PeO7Em2RWwIRuSWwRPvxCV/rIxIRERERofTztP8ozl2D4tw1rZYhIuPBe/oNhLmZBO1aOGHos57FbZ18nI2m4CciIiIiIiLDw6KfiIiIiIiIyESx6CciIiIiIiIyUbynn8pk4ykXOkIxQ8pCREREJDRDOjcypCwVcbMSOkERQ8lBtQOLfipT319mCx2BiIiIiErB87SqWd5J6ARE+sfu/UREREREREQmikU/ERERERERkYli0U9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRiWLRT0RERERERGSiWPQTERERERERmSgW/UREREREREQmikU/ERERERERkYli0U9ERERERERkoqRCByDDNfMCEJctdIoiblbA8k5CpyAybUGvL0HGXYXQMSrNxlOOvr/MFjoGEZEgDGmfrYv9sSGtn7HgcbFitbW+YdFPZYrLBqIzhE5BRPqScVeBtMhYoWMQEVElmPo+29TXj4RRW+sbdu8nIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhPFop+IiIiIiIjIRLHoJyIiIiIyYd1WvIvx8bswPn4XxsXuwIhL69Ft1VRYyR2EjmawBuxeiC5fTyrRbu1eD+Pjd8G54zMCpCJ9ivi0F+6unlCiPS/hLi4NFiHz+mkBUlUNi34iIiIiIhOnOH8dO1pPwK727+Dkuyvg2MoTvX54X+hYRKQHLPqJiIiIiEycKl+JnKQ0ZCtSkHD+BiK2BMK5QzPIrC2FjkZEOsain4iIiIioFrF0qQvPFzpDpSyEulAldBwi0jGp0AGIiIiIiEi35F1a4tWozRCJxZBamgMAwtfthzInDwDQa8P7eHAiFJFbAgEADq280GPtdPzZbxYK8woEy23oBuz9DGbWlhDJpEi8cAPnP/4RahW/SKlN7qx4HemX/4LUzhktV4cLHadURn2lPzQ0FIMHD4adnR1sbW0xZMgQxMfHw8bGBqNHjxY6HhERERGRQUi6fAv7n52FAwNnI+Tb35F4MQJXlm4rnh48dyN8pr4McwcbQCSC/5KJuPDJTyz4KxA09kvs7zcL+3rNhLmjLTxf9Bc6EumZ07NvoOn8AKFjlMtor/QHBQXhhRdeQMOGDTFnzhxYWlpi06ZNGDhwIDIzM+Hr6yt0xFpNlZeD+F2LkXpqO/KTYyE2s4S5vDEce42F84vThI5HpJX8jGzc3nUCsUcuoSArF5b17NF4eA+4P9sOYqlE6Hg659K5OVq+/RIcWnnC2r0eLi/dhqsrdgsdi4iItFCYm4+MuwoAQMiyHbDxlKPTojdx9oPvAQDZihRcW38A7eeOxcMrUXgUHY/402FCRhZUfno2zGzrlGg3sytq++/LkILMHACASCqBRCaFWq3WX0jSKYmVHQqzH5VoL8xKAwCIZBYAAJtWPZGXcFePybRnlEV/UlISRo0aBT8/PwQGBsLSsmgAkrFjx8LLywsAWPQL7P737yAj7Bg8JqyEpVcbFGanIzv6CvKT7gsdjUgr9/4KxqkpK6HMzgNEACAC1GrcO3geNl6uePbX2bBr4iZ0TJ2SWlkg7VYMoveeQsfP/id0HCIiqgEhX+/AyydXImLzESSH3gYA3NwYgEEHF8O1ayv8OXC2wAmF9SgqDp4v+kMkFmt013dq2wQqZSEy7sQXtz23awEcW3khNugy7h04L0Rc0gEL92eQeuZ3qAsLIZI8vsiTdSsYEEtg7tpEwHTaMcru/UuXLkVqaio2btxYXPADgJ2dHfz8/ACw6Bda2oU/4PLyLNh3HgJzFy9YebWBU9/xqD96ntDRiCot7ngIjk/4Gsqc/KIGNYAnvsHPuBOPgGHzkRWfLExAPYk7egWXF/+Gu/vPQpXPbp5ERKYg444CMUf+gd/sMY8b1WpE/HoEsUGXkZecLlw4A3DzlwBY1LND1xXvwrF1I9g0dIHXkK5o++FoRO04hvz07OJ5/x6+ADt8J0JiaQZ5t1YCpqaaVG/gZCjTEnB31f+QFXUJefG3kXJyGx5snQunvv+D1Npe6IiVZpRF//bt29G9e3d4e3uXOt3FxQVyuRx5eXmYOHEiGjVqBBsbG3h7e2P16tV6Tls7yeq6Iv1yAJQZKUJHIaoStVqN4HmbirrpldNVLycxDeHf/aG/YERERDUkfO1+uPXyhdy/5eNGlQpqFbuoZ8U+xKEXP4W5XR30/WU2Xjr6DVpPG4rwtftxbvaGEvMX5ubj/l/BaPBcBwHSki6YOzdEs6VnUZiVittfvIjr01sjftdiuLw8Cw0mrRU6nlaMrnu/QqFAXFwcRo0aVWKaSqVCWFgY2rZtCwBQKpWQy+U4fPgwGjVqhKtXr+K5556Di4sLRo4cWanPUyqVUCgUNboO5Yl/mPv434p4QGmht89+WkGBCwBZlZZtOOVH3PnmFYSOqwdLj5ao06wz7No9D7tOgyESiaqQpQCxsQlVylJTchPSiv8dHx8PC1WOcGGqyZTWRVdSL0Xh0a3YSs0bue0o5K/3guTf0ZCNVUGBUugIWikoUCI2tnK/o5rA7UZ7D/MlAFwBFP3MCswKhQ0kEGPbtgyBvrfvyjKk/YA2f1enZ3xXanvSPxHY5Dq8RrLU9O/LELab1Ov3EPT6kjKny2ysIDaTIi85HSKJGB792kNx9poeE2ridlMxbesbK682aDLnTx1l0b6+kcvlkEq1L+GNrujPysoCgFILx3379iExMbG4a3+dOnXw+eefF0/39fXFSy+9hNOnT1e66FcoFPDw8Kh+8MqS1gWaLwMAdOzQEVCm6u+zn9JidTgsG7SseMZSWDfvilbrbyMrMhhZEeeQce0kbi8dDrt2A9H40/1aF/6RkZHweE7Y7lJ1xZb41vl5AEDHjh2RasQn/Ka0LrrynFVTjLZtXal5C7Pz0L1FO8QoSw72Yky+cOwHN5mt0DEqLTIyEiP1uH/mdqM9maMbWv9cdALasWMHFCTHCZxIGMa2bRkCfW/flWVI+wFD+rvSxe/LkNavLGZ2Vuj94yyIZVKIJGLEnwxFxObDguXhdlOx6tQ3Zbm9dAQyb5yGMv0hrr7hDvnwT+D8/OQKl6tKfRMTEwN3d3etMxpd0e/h4QGJRIITJ05otN+7dw9Tp04FUPb9/AUFBTh16hQ++OADXcckACKJFNbNu8C6eRe4DHkfyce34O7ysci8dhI2rXoKHY+oXGItv5gSQ/seLERERIYmaudxRO08LnQMo5AV+xAHBnwkdAwSWOOPfhc6QoWMrug3MzPDuHHjsHHjRgwePBiDBg1CTEwMNmzYABcXF8TFxZVZ9E+ZMgU2NjYYN25cpT9PLpcjJiamhtJXLP5hLjqOK/pCI/hiMFydhOveP/W6C2JyK56vsizcmwMAlI8StV7W29sbf+vx91Ca3IQ0nH5hAQAgODgYFi72guapDlNaF11JOhmO0Pd/rNS8IqkEx0LOQ2ZX8tE+xuTcyCXIuqO/25mqy9vbGzE7f9bb53G70d7DfAkmhBf9Ozj4Ipxqafd+Y9u2DIG+t+/KMqT9gCH9Xeni92VI62csuN1UrKbrm+qoSn0jl8ur9FlGV/QDwKpVqyCTybBv3z4cPXoU/v7+2Lt3Lz777DNERUWVOsDfe++9h3PnzuHo0aMwMzOr9GdJpdIqdaGoMmlW8T9d5a5wlwtXRMhuAajiRhHxSU84dB8DqybtIbWrh7z4KMRt/gSSOvaw8emtfRaZTL+/h1JkiR8/KcLV1RV16jsKmKZ6TGlddKX+SFfc+novshXJRaP2l8NrcFd4tWymn2A6JJOVfkiQWlnA1qvoICOWSWFZzx4OLT1RkJVb/MxnIchk+t0/c7vRniwHwL9Fv6urK1wsy53dZJW1bVHZ9L19V5Yh7QcM6e9KF78vQ1o/Y8HtpmLVqW9qmj7rG6PcmqytrbF+/XqsX79eoz08PBw+Pj4QizUfSjBjxgwEBQXh6NGjcHJy0mfUWsvObyBSTm7Fg23zUJidDqmdM2xa9oDntI2Q2vJ3QIZPLJWg7YejcGbmWkCE0gt/kQgSCzP4TH1Z3/H0yqlNYwzYs7D4dfM3BqL5GwOhOHsNAcPmC5iMiIiIiCpilEV/adLS0hAbG4tBgwZptE+bNg1Hjx7FsWPHUK9ePYHS1T7y4bMhHz5b6BhE1dJ0dB/kpWbgn882a07490sAWR0L9PnlI9RtZniD5tQkxblrNTK6MxERERHpn8kU/WFhYQA0B/G7d+8eVq9eDXNzc3h5eRW3d+/eHX/99Ze+IxKREWr1zmC49/FD+Lp9iNpxHABg6+WKpmP6oOnoPrBwshM2IBERERFROUy66G/YsCHU6gpuxiUiqoB9Mw+0/XBMcdH/3O8LeD83EREZFWv3euixdgZUSiVEEgnOz96A1Bv3iqd3XzMNNg1cIJKIcXNTAG7/fqKcdxOObSNXDDm+HH8NmYuky7c0plk3cEbXbydDLJPi/l/BuPb9fkgszfDczvmwb+qOcx/9gDv7zpT7/uaOtui86E1YONpCmZOPoHFfakxvMXEQvF7uBlVBIVLConFhTvkD57WZORz1e7VBYW4BTs9Yg+z4lAo/TyyTosd302HpbA+RRIwLn/6E5KvRaDNzOFy7+QAAbLzkCP9uH278dKiyPzrSwuURVqjj3REA4PzCdNT1L3krZ8SnvWDh9gwaTv6+uC03LhLXprZEsy9PwbpZZ73lrYjJFP2TJ0/G5MkVPw+RiIiIiKi2yYpPxqHBcwC1GvKurdB62lCceGd58fSQb3Yi444CYjMpBh/9Fnf+OANVgVLAxKVrM3M4FOeulzqt/ZyxuPzlb0i6FIkBexbi3sHzyIp7iGNvLEOzcf0r9f4d5r+OkK934FHUg1Knxxy5hOsbDgIAeq6bCRf/FkgoI4+9tzucOz6DvwbPhWuP1vD7aAxOz/iuws9z7e6D/IxsHH/rGzi1bYrW04fh2JvLELp8F0KX7wIAvHj4K9w7eL5S60TaM6vXAM0WHS9zetrFA5BY2pRoj9/5OWxaGt6jycUVz0JERERERMZMXagC/u0Ba2ZjiZTrdzWmZ/z7eDxVvhJQqw2yt6xT26bISUxDdnxyqdPtmroh6VIkACA28DJcOjeHWqVCTlJapd5fJBbDvpk7fKa8jAF7FqLpK31LzPPkU2tUSmXRz7UMLp1bIObIJQBA/MmrcGzdqFKfl3FXAYm5DABgZmeF3ORHGsvZe7sj/1EWshWavQao5hSkPEDEJz0RvWw0CtI0HzeuVqmQdOg71Hv+XY32rIgLkNnLYeZkeE9QYNFPRERERFQLOLT0xPN/LkKnRRMQfyqs1HlavTsEdw+eh1pZqOd0FWs9fSjC1uwtc7pILCr+d96jLJjXLXkltjwWTrZwaOGJ8HX7cXj052g6ug9sGrqUOq9zx2dgJXdAYvDNMt/PzN4a+Y8yH+eTaJZeZX1eZmwSpJbmePnUSnT9djJu/KjZhb/RsB6I3ntaq3Uj7fj8EI1mi0/AvuNLiN34vsa05KO/wN5/KMQyC432+N8XQT7MMAcyZ9FPRERERFQLpFy7i0Mvfoqg8UvQafGbJaZ7De4KRx8vXFm6XYB05XPv64fk0NvIS80sc54nOyeY2VohLzVDq8/If5SFrAcPkRYRA1W+Egnnr8O+lCf02DV1Q/s5Y3H87W/Lf7+0TJjZ1nmc76leAWV9XpORvZAZk4i93afjr5fmoOu3mrcwN3y+E+4dOKfVupF2/nvEeN1uI5EdfaW4XZWfi5QTW+HU938a8z/65yCsmrSH1NYwx3xi0U9ERDWm24p3MT5+F8bH78K42B0YcWk9uq2aCiu5g9DRiIhqNbHZ46G8CtKzUZiTrzG9fq82aDqmD05NW61ZPRsIh1aekHdpiX6/fQrXHq3RYeF4WDrba8zzKDIWTr5NABR9SZBw4UaZ7yetYwEzWyuNtsK8AmTFPiw+Zjm0boT0J7rzA0AdNyd0WzkFJ99dibyUx18qWMkdIBJrllYJ56/DrU9bAIC8ayskX42u3OeJRMj9973zHmVB9kRO547PIO1WLPLTs8tcN6qewtwsqAuLerpkXDsJc9cmxdPyEu6gMCsNUZ+/gNhfPsSjS4eQfPRXZEeHIDP8OG4tGID0kCOI/WkmClLihVqFEkxmID8iIjIMivPXceKtbyGSiGHj6YLOiyeg1w/v49BLnwodjYio1nLu8Ax8PxgJdaEKIpEIwQs2wa23L8zsrXFn72l0XzkF2Qmp6L9tLgDgxKTllb4XXh+urtyDqyv3ACj6gjni18PISUzTWIdLi7ei6zfvQCSVIObvi8i8X3Qvdq8fP4BjKy8os3Ph5NcUF+dvgteQbpBamJUY/T54/ib0WDsdYqkUsceu4FFkLCzr2aPF2y/g0hdb0H7OWFg42KLbiqL7ucPW7EXcsRD0WDcDR19folGMp0XGIjnkNgbu+xyFeUqcmVk0iF+Tkb2QGfcQijPhpX5eVkwSeqydgQF7FkJqaY4rS7cVv2ejod0RvYdd+3UpN/Ym7n03ERILa4ikMjSYvB6PLgegMCMFDj1fQfNv/wEAZIQdR8qp7XDsMw4A4Dqy6Dzn7srxcBowCTIHV6FWoQQW/UREVKNU+criE8VsRQoitgSi86I3IbO2REFmjrDhiIhqKcWZcAScCS9z+o42E/WYpnqeHAE/7lhI8b8z7ioQMGx+ifmPT/i6RFvdZzwQumJ3ifaU8DsIGKr5HjlJabj0xRYA0HjiwX9EUgky7yeWevU95JudCPlmp0Zb1M7j5X6eMicPR/+3tMR7AcD52RtKbaeaU6dJO7RYflmjzeKJq/3/sfHpBRufXiXaPadv0lGyqmPRT0REOmPpUheeL3SGSllY7gjHRERE+hQ8d2ONvZdaWYjT09fU2PsR1TTe009ERDVK3qUlXo3ajNeit2JUyAbI/Vvi+oaDUObkASi673H4P+tg4WgLAJBYmmHomdWwf6ZBudOIiIiISHss+omIqEYlXb6F/c/OwoGBsxHy7e9IvBihcT9itiIF19cfQIeF4wEAvu+PxL2/LiDt5v1ypxERERGR9ti9n8rkZlXxPPpiSFmIqHyFufnI+He045BlO2DjKUenRW/i7AffF89z46e/8ELAUjSf8DwaPt8J+/t+UKlpRERUxMZTXq3lVcpCpEcXjS5u28gVYqlEsCz6ek9Tx59ZxQypptBnFhb9VKblnYROQESmIOTrHXj55EpEbD6C5NDbAAC1SoWL8zdhwJ6FOPrGV8Vd/yuaRkRERfr+Mrtay2c9SMbv7d4GADz3+wLUqW9Yzxev7voRlaa21jfs3k9ERDqVcUeBmCP/wG/2GI12t75tka1IQd1S7tcvbxoRERERVR6LfiIi0rnwtfvh1ssXcv+WAAD7ZxqgwYCOODBwNpq+0hfWDZyL5y1vGhERERFph0U/ERHVmNMzvsPhUZ+VaE/6JwKbXIdDce4aAMB/6Vu4OH8TshUpuPLVdnRa9GbxvOVNIyIiIiLtsOgnIiK9avrqs8h9+AixQZcBALd/PwFZHQs0eL5TudOIiIiISHscyI+IiPTq1tZA3NoaqNEWMHS+xvSyphERERGRdniln4iIiIiIiMhEsegnIiIiIiIiMlEs+omIiIiIiIhMFIt+IiIiIiIiIhPFop+IiIiIiIjIRLHoJyIiIiIiIjJRfGQfERHVOHtvd/gvextqlRpqZSHOvL8OmfcTi6f7vj8STUb3xqNbsTjyyqJKLUNERERE2uOVfiIiqnG5yekIfO1LBLw8D+Fr96HNzOEa0yM2H0bAsPlaLUNERERE2mPRT0RENS43OR0FGdkAAFVBIdSFKo3pOYlpgEqt1TJEREREpD0W/UREpDMSCzP4zhqJ6z8e0ukyRERERFQ63tNPRLVG0OtLkHFXUaVlVcrC4n//PWIBxFJJlXPYeMrR95fZVV7eWIgkYvRYOx3X1u1H2s37OluGiIiIqDKqcy5Y0/R5Psiin4hqjYy7CqRFxlb7fdKj42sgjenr+s07eHA8FPcDLup0GSIiIqLKqKlzQWPDop+IiGqcW29feL7UBdYezvAa3BUp1+4g7lgIzOytcWfvaXi/9iwaj+gJuyZu6L9jHk5NWw2HFg1LLBM8b5PQq0JERERk1Fj0ExFRjYs7FoItjV4tc3rklkBEbgnUXCYhtdxliIiIiEh7HMiPiIiIiIiIyESx6CciIiIiIiIyUezeT0T0lG4r3kWTUb0BAKrCQuQkpCH+TDguL96KbEWKwOmIiIiISNdM6XyQV/qJiEqhOH8dO1pPwK727+Dkuyvg2MoTvX54X+hYRERERKQnpnI+yKKfiKgUqnwlcpLSkK1IQcL5G4jYEgjnDs0gs7YUOhoRERER6YGpnA+y6CciqoClS114vtAZKmUh1IUqoeMQERERkZ4Z8/kg7+knIiqFvEtLvBq1GSKxGFJLcwBA+Lr9UObkAQAaDOwI3/dGaCxj5+2O4LkbEfHrYb3nJSIiIqKaZSrng0Zd9IeGhmLevHk4fvw41Go1+vTpg3Xr1sHb2xuDBg3C9u3bhY5IJkKtVuNRVFzxa5WyUMA0pA9Jl2/h9PQ1kJjL4PlSF9Tv3hpXlm4rnn7/r2Dc/yu4+HWDAR3g9/EriPr9uABpiYhI19RqNdLvxBe/VhUoBUxDZDzS7yiK/21s242pnA8abff+oKAgdO7cGREREZgzZw4WL16M2NhYDBw4EJmZmfD19RU6IpkAtVqNqJ3Hsf/ZD3B41GfF7Qdf+Bihy3ehMK9AwHSkS4W5+ci4q0BaRAxClu1ARkwiOi16s9R5rVwd0GnxBJyYtAKFOfl6Tqofbn3a4qUjyzD27jYMD16LFm+/IHQkIiK9if7jNA4M+Ah/D19Q3Hbg+Y9x5avtUGbnCReMyIDd2X8Wfw78CH8Pn1/cdmDgR7i8ZBsKsnMFTFZ5pnI+aJRFf1JSEkaNGgU/Pz9cuXIFs2bNwpQpUxAUFIT79+8DAIt+qja1Wo2L8zfh9PQ1SL1xT2Na7sNHuPLVdhx55Yvi7j1k2kK+3oEmo3rDsU1jzQkiEXqsmY6wNX+U+DsxFY5tGqPvpo8Qe+wK9vf7ACFf70S72a+g2bj+QkcjItK5y0u24eQ7K5AcFq3RnpeajtDluxAwYgEKsnIESkdkmEK+2YkTb3+L5NDbGu15aZm4unI3/h62APkZ2QKlqzpjPR80yqJ/6dKlSE1NxcaNG2Fp+XjkRDs7O/j5+QFg0U/VF73nFK5vOFj0Qv3UxH9fK85ewz9fbNFrLhJGxh0FYo78A7/ZYzTa28wYhvyMbNz8+S+Bkuley7dewMOQ27i8+Dc8uhWHqJ3HcePnv+AzZYjQ0YiIdOreoQu4unJ30YsyzgUeXr6FC5/+rNdcRIYs5sg/CPl6Z9GLsrabkCic//hHveaqCcZ6PmiURf/27dvRvXt3eHt7lzrdxcUFcrkcADB58mR4eHjA1tYWbm5umDFjBvLzDau7BRketVqNa+v/BEQVz3vrtyDkp2fpPhQJLnztfrj18oXcvyUAwLlDMzR9pS/OzPxO4GS65dzxGcQdu6LRFncsBNYezrBydRAoFRGR7l3fcKBS893efRI5Dx/pOA2RcSi+aFaBO3+cRnZCqo7T1DxjPB80uoH8FAoF4uLiMGrUqBLTVCoVwsLC0LZt2+K2KVOmYNmyZahTpw4ePnyIESNGYPHixViwYEGlPk+pVEKhUFQ8Yw2Jf/j4/pZ4RTygtNDbZ9NjWfcSkRJ2p1LzFubmI2Tb36g/qKOOU9Wc3IS04n/Hx8fDQlU7uiUWVHLwmNMzSt9pJ/0TgU2uwwEAZrZW6L56Gk5PX4O81Eytc8TGxmq1jD6U9fOxdLZHTlKaRltOYuq/0+oiOz5F19FKpe+fY23dbqrjYb4EgCuAop9ZgVntHAS1svseeswQ9pO5CWlIOH+jUvOqlYUI3fIX3Id303GqmsN9GulC3sN0xJ8Kq9S86kIVQjYfQoPRPXWc6jFt9seGeD4ol8shlWpfwhtd0Z+VVXRFVSQqeQl23759SExM1Oja36JFi+J/q9VqiMVi3Lp1q9Kfp1Ao4OHhUfXA2pLWBZovAwB07NARUBrft1+moKnMEZ849qr0/PPem42/J1X+70podcWW+Nb5eQBAx44dkVpLDvRfOPaDm8y2Rt6r2evPwdLZHh0Xjtdoj/r9BK7/UP6VocjISIzU536lkmry56MP+v451tbtpjpkjm5o/XPRCU3Hjh1QkBxXwRKmydi2LUNgCPvJBlI7LHR6ttLzL5nzGfbNrNyXBIaA+zTSBTepLb5w6lfp+b9euBh7Z72mw0Saanp/rO/zwZiYGLi7u2sb0/iKfg8PD0gkEpw4cUKj/d69e5g6dSqAkvfzL1myBF988QWysrLg6OiIJUuW6CsuGakctXaj8ueqeRWntglbvRdhq/cKHUMvchLTYFnPXqPN4t/X/13xJyLdklpZ4OXTK3H0f1+VGBjLGEnrWGDY2dU4POYLpF43vEGvACBHy2O7tucORKYoR1W7zqGN5XzQ6Ip+MzMzjBs3Dhs3bsTgwYMxaNAgxMTEYMOGDXBxcUFcXFyJon/27NmYPXs2bty4ga1bt8LV1bXSnyeXyxETE1PDa1G2+Ie56Diu6AuN4IvBcHVi934hqFUqnHn5C+TGp5QcgORpYhF+OvMnzOvZ6SVbTchNSMPpFxYAAIKDg2HhYi9oHn05N3IJsu7o73adsnh7eyNmp+EN+lTWzycx+Cbq9/JF6PJdxW1uvX2RGZMoWNd+QP8/x9q63VTHw3wJJoQX/Ts4+CKcamn3/prY9/hMGYLk0Ggkh96GXZP6ePHwMlyYuxG3tgYWz2PtXg8vBX2NkG9/x/X1ByD3b4n+O+ch8LXFeHAitHg+J98meH7/Fzg+aTnuH7qgVQ6vIV3RbcUUHHh+tkaxLpKI8fz+RchNSYdYIobM2gp/DZkLtUpVPI+DjxcGHViMk++uwr0D53Bt/QF0mP+6xiNx/2MI+0m1Wo3zo5cW/e4qOhcQAauDfoeVu5NestUE7tNIF9RqNYJf+xoZt+Iq3m4ALA/4DT94uug+2L8M5VwQqNp+7r9x67RldEU/AKxatQoymQz79u3D0aNH4e/vj7179+Kzzz5DVFRUmQP8NW/eHG3atMHYsWNx7NixSn2WVCqtUheKKpM+HhDOVe4Kd3kd/X02afCZ+CIuLvylwvk8B3VG47Yt9ZCo5mSJHz/1wtXVFXXqOwqYRn9kMsPY5clket6vVFJZP59rPxzAoD8Xoe3sMYjedQJObZui+RsDcXFBxduHLun751hbt5vqkOUA+Lfod3V1hYtlubObrOrueyTmMjR7vT9OTV0NAHgU9QD/fLYZHRe+DsWZcGTcVUAkFqP7d9PwMDQa19cXdSlVnLuG6z8cQNflk7G/7/vIS82E1NIcPb6bjtu7TpZZ8Mv9W6Lbynexq+PkEtPu/HEG7s+2Q4/vpuPAgI9QmFd0Va/NjOGw9qiHoHFfQiQRY/DRb+Az7WVcXVE08r3Ewgw91kxD9J5TuHfgHAAgascx+M0eA/tmHkiL0LzAYij7yey3X8K5j36ocD633m3h3dlX94FqEPdppCu5k17CmffWVThf/R6t0axbOz0kesxQzgUB/e7njHL0fmtra6xfvx4KhQIZGRk4fPgw/P39ER4eDh8fH4jFZa9WQUEBIiMj9ZiWjFXzNwfCva9fufPYNHRBp8UT9JSISBjJobdx9H9fwePZdngp8Bu0/XA0Li/dhohfDwsdjahWcOvtC4mFmcbV+pubApBw/gZ6rJkGkUQMn2kvw97bA6enr9ZY9vKSbchLyYD/V28DADp+/j+IJGJcmFv1q+jnP/4RsjoW8PvkVQBFPQd8pr2MMzPXIjc5HTmJaTj7wfdoM3N48bOs2336GsRmMlyY8/hzc5PTkfhPBBoP61HlLLrW9NW+aPhC56IXZTzRx6q+I7osm6S/UEQGrsmo3vAa0rXoRVnbjdwBXb8t+cUi6YZRFv2lSUtLQ2xsrEbX/kePHmHTpk1IS0uDWq3G1atX8cUXX+C5554TLigZDbFMit4/z0KrdwdDZqN5eUokEcNrSFc8f2AxLJ2Mp1s/UVXFBl3G/mc/wGbPMdjV4Z3iK4lEpHsu/i2REn4H6kKVRvuZmWth4+mC7qunwfe9ETg/e0OJW25UBUqcfHcl3Pv6ofvqqWgyqjdOTV0FZVYuqqogIxsnp65G8/8NgEf/9ui+eioitwYhNuhy8Tz3Ay4iaudx9FgzDR7926PZuH44NaXk5yZdvgV511ZVzqJrYokEPdfNROsZw2BmY6UxTSQWo+Ggznjh4Je8Sk70BJFYjO5rpqHN+yNgZvtUr2WxCA0GdsSgg1+ijpvx3A5j7Aynf0M1hYUVPRriyaJfJBJhy5YteO+995Cfnw9nZ2cMHToUCxcuFCglGRuJmQzt54xFm/dGIDbwMnKT0iC1toRbb19YOdcVOh7pwGvRW/HwShQA4PqPB3H/r+Diad3XTINNAxeIJGLc3BSA27+fgL23O/yXvQ21Sg21shBn3l+HzPuJQsUnIhNk08C51PEzcpLScOnLbej69STcPXAOd/adKXX5tIgYXPvhANpMH4bwdfuReDGi2pkSL9xA2Np96P3zLKRHx+Ofz34tMc/FeZvw4pFl6P3zLFxdvhtJl0r2tMyOT4FNQ+dq59ElsVQCv4/GoPW0oYgNuoychFRIrcxRv5cv6riy2CcqjVgiQdsPRsHn3SGIDbqCnMRUSC3NUL9HG4Mv9is6tyvtfBAAOi16E46tG0EkESNk2Q7EHQsRaA1KMumi39bWFoGBgWUsQVR5MisLeL3URegYpAdZcQ8RMGx+qdNCvtmJjDsKiM2kGHz0W9z54wxyk9MR+NqXKMjIhltvX7SZORxnZq7Vc2oiMmUSCzPkp2eXaBdJxGg6ujcKsnLg6NMI0joWpV7Bl9axQKMh3VCQlQPnDs0gEos1Btir4+aEISeWP35fsRgScxlejdpc3JYZ+xD7es3UeN+Qr3cWfZGw5g8U5uaX+FxlTh7C1+2H/5KJCF2xq8R0ACjMy4fEwqziH4IBkFqaw/MFf6FjEBmVou2ms9AxtFLRuV1p54M2ni6wa+qOQy9+Cst69ui75WMW/bowefJkTJ7M+0KIqHosXepiwJ6FyElIw4U5PyE3Ob14Wsa/o72q8pWAWg21Wq0xXVVQWKL7LRFRdeUmp8Pc3rpEe5sZw2HbyBV/PvcR+m+bg44Lx+PsB9+XmK/zojehUhbiwMDZGPTnYo0B9gAgW5GC/c/OKn5dz68p2n36msYXoCplycdqqZVFT2NQFZb9VAZ1QdFyZe0bze2tNfajRERCq+jcrrTzwZyEVBTm5UMkEcPMzgp5KRl6zVwRk7mnn4ioJuzu/C4Chs7H/cMX0WHB66XO0+rdIbh78HzxCS9QdCXOd9ZIXP/xkL6iElEtkRwWDftmHhptTm2bovX0oTg7az3Sbz/Aqelr0GR0b7j30xwJu+GgTmg0tDtOTVmFR7ficH7OT2gzczgcfLyK51EXqpBxV1H8X3Z8CtSFhRptWbEPdbJu9s0bIjk0WifvTURUHRWd2z15Ppifno3M+4kYemY1BuxeiLDVe/Wctnws+omInvDfN7N395+FQyuvEtO9BneFo48XrizdXtwmkojRY+10XFu3H2k37+stKxHVDnFHr8CmoQus/h0sTmppjh5rpuH27seP3Us4dx3X1x9A168nwdzRFgBg6WwP/6/eRuiK3XgYUjRWSfSuk4j5+x90Xz0NEnOZMCv0BHmn5ogNvCR0DCIiDRWd2z19Pli/ZxtYOttjt/8U7O05Ex0/fwMiieGU2oaThIhIYFJLc4j+feSnS+cWyLir0Jhev1cbNB3TB6emrQbU6uL2rt+8gwfHQ3E/4KJe8xJR7fDoVhziz4Sj8fCeAIAOn42HSCrWePwdAFxeug05D9PRZVnR4/m6rZyCjLsJuLpyt8Z8Zz9cD3O7OsWP3BOKvEtLSOtY4M6fZwXNQUT0tPLO7Uo9HxQBeWmZgFqNgswcSMykEEslek5dNpO5p5+IqLrsmrqhy9eTUJCVC1VBIc59uB5uvX1hZm+NO3tPo/vKKchOSEX/bXMBACcmLYdDK094vtQF1h7O8BrcFSnX7iB43iZhV4SITM6VZTvQc90MXP/hAM7NWl/qPKp8Jfb3fb/49ZExX5Q6X35aJna2favMz1Kcu4ZdHSs3TtIm1+HlTo/aeRxRO4+XOq3V5MEIW/MHCnNKDgJIRCQUt96+Jc7t4o6FlHs+GH8yDI2GdMPAPz6HxFyGGz/9hcK8AoHX5DEW/URE/0q+Go0/+3+o0fbk1f4dbSaWWCbuWAi2NBL2ahkRmb7ECzcQ+u3vsGngjLTIWKHjVJu0jgUSL0Xi+g8HhI5CRKShonO70s4HAeD0jO90FanaWPQTERERGYHILabzGGJlVi6uLi/9MX5ERFSzeE8/ERERERERkYli0U9ERERERERkoti9n4hqDRtPudARABhOjqcZaq6yGFteIiIiElZ1zx1UykKkR8cDAGwbuVZrhH59nsew6CeiWqPvL7OFjmDQ+PMhIiIiU1bdc52sB8n4vV3RY1Gf+30B6tR3rIlYOsfu/UREREREREQmikU/ERERERERkYli0U9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRiWLRT0RERERERGSiWPQTERERERERmSgW/UREREREREQmikU/ERERERERkYli0U9ERERERERkoqRCByDSl5kXgLhsoVMAblbA8k5CpzBMQa8vQcZdhdAxjJ6Npxx9f5ldI+/10tQjuB2bXiPvVR2N3W2xf3U/oWMQkZEzlONMTe6niYgqwqKfao24bCA6Q+gUVJ6MuwqkRcYKHYOecDs2Hddvpwkdg4ioRvA4Q0S1Ebv3ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RETlGLB7Ibp8PalEu7V7PYyP3wXnjs8IkIqIiIiIqHJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRiTLqoj80NBSDBw+GnZ0dbG1tMWTIEMTHx8PGxgajR48WOh7VEmETPYWOQEREREREVCqjLfqDgoLQuXNnREREYM6cOVi8eDFiY2MxcOBAZGZmwtfXV+iIRES1VuCGgTixcRBEIs32P1Y+i4vbXoJUKip9QSIiA9Tvt0/x/P5FEIk1T50dfLww9t42NHzBX6BkpC8F2bmI3BqIwLGL8deQuTg24WvcO3geKmWh0NFIT7ITUnF9w8Hi1xc/+xWJ/0RArVYLmKpypEIHqIqkpCSMGjUKfn5+CAwMhKWlJQBg7Nix8PLyAgAW/aRzMT/OREb4MRSkPMD1Gb6wqN8MjT7cIXQsqmH56dkws61Tot3MrqitMK9A35GMwutzTuDqrqH46I3WWPLTVQDAW8OboV9nN/iN+gNKpeEfIImI/nN6xncYfPQb+Ex7GVdX7AYASCzM0GPNNETvOYV7B84JnJB0Ke54CE68/S3y07OLGkQiQK3GvYPnYd3AGX1//Rh1m3kIG5J0Rq1WI3ztPlz+8jeoC1XF7Xf3ncHdfWfg2t0HvX54H+b21gKmLJ9RFv1Lly5FamoqNm7cWFzwA4CdnR38/PwQFBTEop+q7NLg8q9Amjk3hM+Gu/CYsBxAUff+FitC9JCMhPAoKg6eL/pDJBZDrXq8o3dq2wQqZSEy7sQLmM5wxSVk450vzmDz4p4IOBOH7Fwlvp3VCbO+DUbE3UdCxyMi0kpOYhrOfvA9eq5/D3HHQpAcehvtPn0NYjMZLsz5Weh4pEMJ568jaNyXUCkfnwPgiSu7mfcTETBsPl74awlsPJwFSEi6dn39AVz6YgtQRokQfyoMgWO/xIBdCyAxl+k3XCUZZdG/fft2dO/eHd7e3qVOd3FxgVwu12jLycmBj48PFAoFMjMz9RGTjFTrTY+LuMybZxG9ZBiaL78MWV3XokaxRKBkJISbvwTgmTcGoOuKd3Hjx4PIf5QFp7ZN0PbD0Yjacezxt/5Uws6/7+DFng2w9cueyM5V4uQlBdbuuCF0LCKiKrkfcBFRO4+jx5pp+OfzzWg2rh8Chs6HMitX6GikQxc/+7WoC385HdTyktNxdcVudP3mHf0FI73IS8vE5SW/Fb0o528g6Z8I3Nl3Bk1G9tJLLm0ZXdGvUCgQFxeHUaNGlZimUqkQFhaGtm3blpg2b948NGzYEAqFQqvPUyqVWi9THfEPHx844hXxgNJCb59t6goKXABU/O2brO7jL4yk1g5F/7etp9FevRwFiI1NqJH3qqrchLTif8fHx8NClSNcmCcUFCiFjlBCVuxDHHrxU/h9NAZ9f5kNma0VMu8lIHztflz/8WDFbyCAggIlYmNja+S9lAXVu31hypfnEBc4GiqVGi9MOVKtHDW1TlVlqNuNIXuYLwFQ9IVpfHw8Csxq572vhrhvM3Q1uR97+n2r4+K8TXjxyDL0/nkWri7fjaRLkVXOwX2a4Uu/EYOHV6IqNe/tXSdQ/82+kNla6TgV6dP9345X7lZOEXD1h/2w6NJEp3nkcjmkUu1LeKMr+rOysgAAoqdHhwKwb98+JCYmlujaf+nSJQQEBOCbb77B0KFDtfo8hUIBDw893qMjrQs0XwYA6NihI6BM1d9nm7gWq8Nh2aCl0DEQGRkJj+daCZqhrtgS3zo/DwDo2LEjUg3kQP+FYz+4yWyFjlFC6vV7CHp9idAxKi0yMhIja2q/1XQhYOFW5cVfG9QYIohgZSFBuxZOOHQqpkrvExkZCQ+PMVXOURMMdbsxZDJHN7T+uaiw6dixAwqS4wROJAxd7tvsvd3hv+xtqFVqqJWFOPP+OmTeT9SYp/uaabBp4AKRRIybmwJw+/cTsHavhx5rZ0ClVEIkkeD87A1IvXGv3M8SSSV4+cQK3NoWhLA1f2hMazFxELxe7gZVQSFSwqKLu7ybO9qi86I3YeFoC2VOPoLGfVmp9arR/dgTqvu7UObkIXzdfvgvmYjQFbuq/D66Wj9tcJ9WsV6WXnjdzq9S86rylejv2wVRBck6TkX69JZdB/hbNqh4RjWQFn4PDTw8yusQUG0xMTFwd3fXejmjK/o9PDwgkUhw4sQJjfZ79+5h6tSpADQH8VMqlZg4cSK+++47qJ64H5eIiHTrGS87fDWzI6Z/dR4tGtnjxwXd4DNsD5LT8oSORmQycpPTEfjalyjIyIZbb1+0mTkcZ2au1Zgn5JudyLijgNhMisFHv8WdP84gKz4ZhwbPAdRqyLu2QutpQ3HineXlflazsf3wKKr0L25ijlwqHtW657qZcPFvgYRz19Fh/usI+XoHHkU9qJkVNgDqf3sLPDmgF5kmcSkXGcsjKeumbzJaYi1+p9r+veiT0RX9ZmZmGDduHDZu3IjBgwdj0KBBiImJwYYNG+Di4oK4uDiNon/ZsmVo27YtevTogePHj2v9eXK5HDExVbsyVRXxD3PRcVzRFxrBF4Ph6sTu/TVl6nUXxOjgtjsLjxZaze/t7Y2/9fg3VZrchDScfmEBACA4OBgWLvaC5vnPuZFLkHVHf7fTmCpvb2/E7KyZgaX6TjqNyPtZWi8nlYqw5cteCLwQhx93R8DcTIJ+/m5YP68rhr93VOv38/b2RtBRbjfG5mG+BBPCi/4dHHwRTrW0e78u9225yenF/1YVFJZaiGb8+9mqfCWgVkOtVmvMZ2ZjiZTrd8v9HKmVBdz6tMW9P8/B0tm+5Gfcfbx+KqUS6kIVRGIx7Ju5w2fKy7Bu4Izbu07i1m9BlVqvmtyPPclQjjO6Wj9tcJ9WsZSLkbg8eW3FMwKASISDF47DvJ6dbkORXkVvCED0DwEVzygCLN3r4f5F3Z6rPD1uXWUZXdEPAKtWrYJMJsO+fftw9OhR+Pv7Y+/evfjss88QFRVVPMBfVFQUvv/+e1y5cqXKnyWVSqvUhaLqH/j45NpV7gp3eclHhVHVyG4B0EHR33TeIe1yyGT6/ZsqRZb48VMvXF1dUae+o4BpHpPJjHKXZHBksprbb0llVRuF9rPJ7eDuUgcDJ/8NAMjLL8RrHx9H8G8vYeyLTbD5z8rdI/lkDm43xkeWA+Dfot/V1RUuluXObrL0sW+TWJjBd9ZInPtoQ5nztHp3CO4ePA/1v88Vd2jpic5LJqJOfScce3NZue/favJLuL7hIOrIHcqdz7njM7CSOyAx+CYsne3h0MITp6etQfqdeAzYtRCKM+HIuFfxuDY1uR97+n0Nga7WTxvcp1XMrX593Fq2Bxl3EzRG7C9NgwEd0Lit8LeRUs2q+/bLuPPjYY0nOJVKDbR683nBt+uyiIUOUBXW1tZYv349FAoFMjIycPjwYfj7+yM8PBw+Pj4Qi4tW6/Tp00hISIC3tzecnJwwePBgZGVlwcnJCSdPnhR4LYiITFPXti6YNd4HExacQlLK42/aQiNSMH/tZaz6qDM8+IUmUY0RScTosXY6rq3bj7Sb90udx2twVzj6eOHK0u3FbSnX7uLQi58iaPwSdFr8Zpnvb+FkB4dWXog/ebXcHHZN3dB+zlgcf/tbAED+oyxkPXiItIgYqPKVSDh/HfZ8ljkZEZFYjLYfji4q+MvquS0SQWwmRetp2o0bRsahTn1HNHu9f4XzWXvUQ5PRffSQqGoM4+vOGpCWlobY2FgMGjSouG3kyJF49tlni1+fO3cO48ePR0hICOrVqydETCIik3fmSgJkfhtLnbbkp6tY8lP5hQMRaafrN+/gwfFQ3A+4WOr0+r3aoOmYPggc92Xx1UqxmbSouz+AgvRsFObkAwCkdSwglog1Hkdat3kDWDjaot9vn8JK7gCxTIrk8Dt4cDy0eJ46bk7otnIKTry9HHkpGQCAwrwCZMU+hJXcAdmKFDi0boSoXZpjMhmjqJ3HEbXzuNAxSE8aDemGvJSMfwenfOJqv6jopcRcht4/fgAnX92O2k7C6bhwPPLTsxG9+6mLxv/+DVg3cEb/7XNhbme4FzRMpugPCwsDoDmIn5WVFaysHj82o169ehCJRAbb7YKIiIhIG269feH5UhdYezjDa3BXpFy7g+B5m+DW2xdm9ta4s/c0uq+cguyEVPTfNhcAcGLScth5u8P3g5FF996LRAhesAkA4DWkG6QWZrjx0+Nb1+JPhSH+VNF5VpORvWDpbI8Hx0NhWc8eLd5+AZe+2IL2c8bCwsEW3Va8CwAIW7MXccdCEDx/E3qsnQ6xVIrYY1fwKFLYx9QRVUXzNwbCtXtrXFu3D7e2FY1LY+3hjCajesP7lb6wquC2FzJuYpkU3VdPhfcrfXFzUwAU569DVVAIG08XNHv1WXgN7Q6ZlWGPw2bSRf/TevXqhczMTD0lIlNg49ML7fbp8sEbVBaJpRme2zkf9k3dce6jH3Bn35kS8/i+PxJNRvfGo1uxOPLKokov96QuX0+C+7PtEPP3RZz76IdS5/GZMgSu3VtDLJXg8tJtSAy+qdVjqMzrWqPbqqkws7HCw5AoXFzwi8Z0eZeW8Pv4FagKlFBm5+HklFXIT3u8r+q2cgos69kVr+Ow898hK+4hAODOvjOI+PVwuetIRKYr7lgItjR6tdT2/+xoM7HE9JykNAScCS/RXvcZD4Su2F3m5z15hTsnKQ2XvtgCAGWO/J8SfgcBQ+eX+X5ExsK+qRt8PxhVXPQP3Ps5x0GoRUQiEeRdWkLexTjHbTCZon/y5MmYPHmy0DGIqIao8pQ49sYyNBtX9n1UEZsPI+r34/BfMlGr5Z4U8vVORO8+Ba8hXUud7tanLSSW5jg86jONdm0eQ+Uz5WVE7z6JO3+cQffvpkPu3xKKc9eKp6ffVeDv4QtQmFeAZuP6o/kbAxH67e8AgLrNG8LMVrO7mKpAiYBhPIkmopoXPLf0W3OIiMh4GeVAfkRk+tQqFXKS0sqdJycxDVBp9sSozHJPylaklDvd80V/SK3M0X/nfHRb8S6kdSw0HkM1YM9CNH2lb7nv4dKpOWKOXAIAxAQEw8Vf8zGP2Q+SUZhXAKCooH9yhNg2M4fj6qo9GvOLxGI8t2sB+v4yGzaeVXt0CxERERHVDiz6iYjKYSV3gLqgEIdHLkTKtbtoNeklWDjZwqGFJ8LX7cfh0Z+j6eg+sGnoUuZ7yGwsocwqGsU+71EWzOtalzqfuaMtmo1/rvg51nL/lngU/QC5T32JcfDFT/D38AUIW7sPXb99p2ZWlIiIiIhMEot+IqJy5KVmFt8bG3fsCuq2aKj1Y6gKMnMh/XeAFzPbOshLLTm2iNTKAr3Wv4fzs38s6sEAwGfqEFxbu69kpn9Hxk68cAOW9eyrt4JEREREZNJY9BNRrSCtYwEzW6uKZ3yK4tw1OLZpDABwbNMY6XfiNR5DBQAOrRsh/a4CIokYls72Jd4j4fx1uPdtCwDw6N8eCeeua0wXy6ToteF9XPv+Tzy8cqs4r2U9e/T8fia6rZoCx9aN0PKdlyA2k0JiLgMA2DZyRUFmjtbrRERERES1h8kM5EdEpqfXjx/AsZUXlNm5cPJriovzNR9D5f3as2g8oifsmrih/455ODVtNXISUktdrrTHUAFF98x7DOgASyd79N8xD4dHfw5LJ7vix1BF7TiGrt+8g+d2FQ20d2raagAo9TFUNl5ytJ8zFsfeXKbxGWFr96H7yilo/ubzSL56u3gQv26rpuL0tNVoOqYP6rVtAqnFS2j1zkuIO3YFYWv+wP5+swAA1u714P/VW7i2bj8sXeri2c0fQ5mdB4iAc7M36OE3QURERETGikU/ERms4xO+LtH25GOoIrcEInJLYKWWK+sxVKHLdyF0+S6NticfQ6XKV+LU1NUllivtMVT12jYtfpTPk/KS0xH42uIS7af//QIh4tfD5T52LzM2qfhxfTkJqfiz/4dlzktERERE9CQW/URUK+jjMVTRe07p/DOIiIiIiLTBe/qJiIiIiIiITBSLfiIiIiIiIiITxe79VGu4aT9wu04YSg5DZOMpFzqCSajJn2Njd9sae6/qMJQcRGTcDOU4Yyg5iKh2YNFPtcbyTkInoIr0/WW20BHoKftX9xM6AhFRjeFxhohqI3bvJyIiIiIiIjJRLPqJiIhIUD/88AN69epV/J+rqys+/fTTMtufdObMGSxaVPRIy+zsbPj7+8Pe3h7bt28v8TlqtRoTJ05Ejx498NxzzyEmJgYAEBwcXPwZ7dq1g5+fHwAgJSUFr732mo7XnoiISLfYvZ+IiIgE9dZbb+Gtt94CANy+fRtDhgzBBx98gLp165ba/qSlS5di48aiR3Kam5tj7969+P7770v9nH379sHc3BwnT57EpUuXMHv2bGzduhUdO3bE8ePHAQArVqxATk4OAMDBwQF2dnYIDw9Hq1atdLHqREREOscr/URERGQQCgoK8Nprr2HdunWoW7duhe3p6el49OgRHB0dAQASiQRyedkDpEVGRqJ9+/YAAD8/P5w6darEPL/99hvGjBlT/HrgwIHYtWtXtdeNiIhIKCz6iYiIyCDMnj0bgwYNQrdu3SrVHhERAS8vr0q/v4+PD/7++2+o1Wr8/fffSExM1JgeGRkJMzMzeHp6Frc1btwYYWFh2q8MERGRgWD3fiIiIhLcoUOHEBoaisOHD1eqvSoGDhyI8+fPo3fv3mjTpg1at26tMX3r1q145ZVXqv05REREhoRFPxEREQkqPj4es2bNQmBgIMRicYXt//H29kZ0dLRWn7Vw4UIAQFBQEMzNzTWm7dy5s0SX/9u3b/N+fiIiMmos+omIiEhQX3zxBdLT0zXupe/Tpw8SEhJKbZ83bx4AwM7ODnZ2dkhOTi6+r3/YsGG4cuUK6tSpgwsXLmD58uUAgHHjxuHbb7/F8OHDIZVK0aBBA6xevbr4fS9cuIBGjRrByclJI9tff/2FSZMm6WzdiYiIdI1FPxEREQnqu+++w3fffVfmtPJ89NFH+P7774sf5bd79+5S5/v1118BoHiU/qd16tQJBw8e1GhLSUnBo0eP4OPjU24GIiIiQ8ain4iIiIxWt27dSgzwV1McHBywZcsWnbw3ERGRvnD0fiIiIiIiIiITxaKfiIiIiIiIyESx6CciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8XR+6lMMy8AcdlCpyjiZgUs7yR0CiIiIjJmQa8vQcZdhdAxYOMpR99fZgsdg4hqCRb9VKa4bCA6Q+gURERERDUj464CaZGxQscgItIrdu8nIiIiIiIiMlEs+omIiIiIiIhMFLv3ExERERERUY3LyVUi4u4jZOcqIZWI4VnfGs6OlkLHqnVY9BMREREREVGNuBuXgfW7buLgyRhcj05DYaFaY7q7Sx10a+uCt4Y3Q68OrhCJRAIlrT1Y9BMREREREVG1JCbnYPrS89jxdzTU6rLni03IwvaAaGwPiEbLxvZYN6crureT6y9oLcR7+omIiIiIiKjK9h+7h5ZD92B7QPkF/9Ou3U5DzzcOYuZX51FQoNJdwFqORT8RERERERFVyaZ9kRgyIxAPU3OrtLxaDazYcg0jPghi4a8jLPqJiIiIiIhIawdP3seb80+Xe3VfIhHBzcUKbi5WkEjKvn9/37H7eOuz0zpISSz6Se/CJnoKHYGIiIiIiKohOS0Xb84/DZWq/P78cidLxB4Zg9gjYyB3Kn/k/k37bmFv0N0aTEmAkRf9oaGhGDx4MOzs7GBra4shQ4YgPj4eNjY2GD16tNDxtKZWqxF571Hx68JCdm8hIiLj9eRh7H4mtLrPk4iIDNusb4ORkJxT4+876fMzyMjKr/H3rc2MtugPCgpC586dERERgTlz5mDx4sWIjY3FwIEDkZmZCV9fX6EjVpparcav+2/Bb+Qf6Dvxr+L2LuMO4MsfQ5FfUChgupoT8+NMXJ/hi4KUB7g+wxfRX40SOhIREelAfiHwcyTwxhO9NN85B7x2AjgUw+L/SW592uKlI8sw9u42DA9eixZvvyB0JCpFv98+xfP7F0Ek1jx1dvDxwth729DwBX+BkhEJQ/EwG1sO3NbJeyem5GLrQd28d21llI/sS0pKwqhRo+Dn54fAwEBYWhZ1Exk7diy8vLwAwGiKfrVajfeWXcCKLdfw9CMq4x9m45NV/+Bo8AP8ubofLMwN89d1aXD5z9Y0c24Inw134TFhOYCi7v0tVoToIRkREelbbiEw4wLwz8OS0yLTgXlXiv4/vQVKHPdqG8c2jdF300cI/34/TkxegXptm8J/6VsozMlHxK+HhY5HTzg94zsMPvoNfKa9jKsrdgMAJBZm6LFmGqL3nMK9A+cETkikXz/tiUSBUne9ktfuuIFJI5vr7P1rG8OsIiuwdOlSpKamYuPGjcUFPwDY2dnBz88PQUFBRlP0bzkQhRVbrgEoeeXjv9eB5x9g9op/sOKjznpOVzmtN8UX/zvz5llELxmG5ssvQ1bXtahRLBEoGRER6duq66UX/ADw32Fuy23gGTtggLveYhmklm+9gIcht3F58W8AgEe34mDfzAM+U4aw6DcwOYlpOPvB9+i5/j3EHQtBcuhttPv0NYjNZLgw52eh4xHp3d9nY3X6/mG3UhGflA3XelY6/Zzawii792/fvh3du3eHt7d3qdNdXFwgl8sBAOPHj4eZmRmsra2L/wsICNBn3DKp1Wos3xxeqSsdP+6JQHqmYd7bIqsrL/5Pau0AAJDa1nvcbldP4IRERKQPGQXAvnsVzycC8Fu0zuMYPOeOzyDu2BWNtrhjIbD2cIaVq4NAqags9wMuImrncfRYMw0e/duj2bh+ODVlFZRZVXtMGZGxUqnUuHIzReefc+l6Gd8gk9aM7kq/QqFAXFwcRo0qeT+4SqVCWFgY2rZtq9H+1ltvYc2aNVX6PKVSCYVCUaVlKxIVk1npDSYrR4lf9obg5d71dZKlNAUFLgBkevu88hQUFCA2NkHoGCYjNyGt+N/x8fGwUNX8ICxEpobbTcWOJlshT1VxsaoGcD0NCI5SoL6FUue5hFZQUPo6WjrbIycpTaMtJzH132l1kR2v+5NqQ1VQoERsbM1fSSzrd1FZF+dtwotHlqH3z7NwdfluJF2KrHIOXayfNrhP0x5/ZkUeJOUgM7tAo00iEZU5Mr/rE+2uZcyjeJiDwkLNbs/nr9yDb2OjvEatM3K5HFKp9iW80RX9WVlZAABRKZfH9+3bh8TExBrt2q9QKODh4VFj76fBqinQ+KNKzz5t5hxMSz6imyylaLE6HJYNWurt88oTGRkJj+daCR3DZNQVW+Jb5+cBAB07dkRqLT1oEWmD203FXIa8D/f/fV3p+fu8OAxZN8/qMJFh+MKxH9xktkLHMCqRkZEYqYPzr+r+LpQ5eQhftx/+SyYidMWuKr+PrtZPG9ynaY8/s3+ZuQDNFmk0/fdYvopc3Dak1Hb3ftsQl5Ct0bboy6+waOaBKsc0RTExMXB31/7eOKP76sTDwwMSiQQnTpzQaL937x6mTp0KoOQgflu3boWDgwOaN2+ORYsWQak0kKsKKi27g2k7v4Gy8GghdAQiItKBwpwMreZXaTm/qclJTINlPXuNNot/X/93xZ8Mj/rf3gJqPlqZaiu1np4spq/PqQWM7kq/mZkZxo0bh40bN2Lw4MEYNGgQYmJisGHDBri4uCAuLk6j6J82bRq++uorODk54fLlyxgzZgxyc3Px+eefV+rz5HI5YmJidLIuhYVqdHvzJOKScit8fJFELML5Yz9D7mihkyylmXrdBTE6+J6h6bxDWi/j7e2Nv3X0e6iNchPScPqFBQCA4OBgWLjYC5qHyBhwu6nYw3wJ3gpXQ4XyB6sRQQ1ns0LsOXUI4lowgv+5kUuQdafkrYKJwTdRv5cvQpc/vmLs1tsXmTGJtbprP1B03I/ZWfMD5JX1u9A3Xa2fNrhP0x5/ZkXyC1RoPiwQ+crHBYziYQ7c+20rdX5XJ8viK/wdxvyB+Icle0goSmlbt/IzvND9h5oJbSL+G7dOW0ZX9APAqlWrIJPJsG/fPhw9ehT+/v7Yu3cvPvvsM0RFRWkM8Ofn51f87/bt22PhwoWYP39+pYt+qVRapS4UlTX1FR98tOJihfMN6+eJ9m2a6CxHaWS3ABhI5wKZTKbT30NtkyV+4t4qV1fUqe8oYBoi48DtpmLuAHolA0fjy59PDRHGNJGigUft2K/LZKWfbl374QAG/bkIbWePQfSuE3Bq2xTN3xiIiwt+0XNCwyOT6eb8q6zfhb7pav20wX2a9vgze6x1M0f8c+3xQHuFheoS3fNLE/8wp1LzAUD/7t5wd+etUTXB6Lr3A4C1tTXWr18PhUKBjIwMHD58GP7+/ggPD4ePjw/E4rJXSywWQ13RZXU9mjG2Jfp3cSt3nsbuNlg9219PiYiIiKruQx+gfgVPWOriDIxupJ88hiw59DaO/u8reDzbDi8FfoO2H47G5aXb+Lg+IjJ4PdtV7YpzZbm71IGXm41OP6M2McqivzRpaWmIjY0tcT//jh078OjRI6jValy9ehULFy7EiBEjhAlZCjOZBPtX9cN741rB2krz22epRIRRA7xwdvOLcHYsfaRLIiIiQ+JkAWzsBvSrD0ie6rpvJQXGNga+6QhITeYMpHpigy5j/7MfYLPnGOzq8A6ur+egVYYuaudx/OpR8ilSRLXJxGHNdPr+b49oVurA7VQ1htHHqQaEhYUBKDmI39q1azFp0iQUFBTA1dUVY8eOxccffyxAwrKZm0nwzQedsOCdtjhwIgaJKTmwqWOGgd3c4VqvgsslBsbGpxfa7TOcnhRERKR/jhbAl+2BpFzgbCKQrQQczIHuLkWFPxERGbdmXvYY0NUdAWdq/tGTFuYSTBiq2y8VahuTOfSWVfQ/Pcq/IbOpY4YxzzcWOgYREVGNqGcBDG4gdAoiItKF1R/7o/XwPcjJrdlR9hdPaw+5k3Fd+DR0JtO5bvLkyVCr1ejcubPQUYiIiIiIiExakwa2+Gpmxwrn+29kf/d+20odpf9JPdrJMe0VPt67pplM0U9ERERERET68+7o5nh/XKty5/lvZP+4hGwUFpZ9G7BP07rYu+JZSCQsUWsaf6JERERERESkNZFIhGXvd8QXU9pB8vTorVro09EVx38eBAc78xpMR/9h0U9ERERERERVIhKJ8Olbvji/5UW0alJXq2WtrWRY+2kXHPlhIAt+HTKZgfyIiIiIiIhIGO1b1kPI70MQcCYW322/gcDzD1CgVJU6b/NG9nhrWDOMH9wU9rYs9nWNRT8RERERERFVm0QixqAeDTCoRwPk5Rci7FYKTl1KwHtfXwAAbP2yF57r6gZHewuBk9Yu7N5PRERERERENcrcTIL2LethRH+v4rYe7eQs+AXAop+IiIiIiIjIRLHoJyIiIiIiIjJRvKefyuRmJXSCxwwpCxERkTZsPOVCRzA6uvqZGcrvwlByEFHtwKKfyrS8k9AJiIiIjF/fX2YLHYH+xd8FEdVG7N5PREREREREZKJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRiWLRT0RERERERGSiWPQTERERERERmSgW/UREREREREQmikU/ERERERERkYli0U9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RERERERERCZKKnQAIn2ZeQGIyxY6BeBmBSzvJHQKoton6PUlyLirqPLyKmVh8b//HrEAYqmkyu9l4ylH319mV3l5IiKqmuocC3gcIGPFop9qjbhsIDpD6BREJJSMuwqkRcbWyHulR8fXyPsQEZF+1dSxgMcBMibs3k9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJ4kB+RERET+m24l00GdUbAKAqLEROQhriz4Tj8uKtyFakCJyOiIh0jccBMiW80k9ERFQKxfnr2NF6Ana1fwcn310Bx1ae6PXD+0LHIiIiPeFxgEwFi34iIqJSqPKVyElKQ7YiBQnnbyBiSyCcOzSDzNpS6GhERKQHPA6QqWDRT0REVAFLl7rwfKEzVMpCqAtVQschIiI943GAjBnv6SciIiqFvEtLvBq1GSKxGFJLcwBA+Lr9UObkAQAaDOwI3/dGaCxj5+2O4LkbEfHrYb3nJSKimlXRcaDXhvfx4EQoIrcEAgAcWnmhx9rp+LPfLBTmFQiWm+hpRl30h4aGYt68eTh+/DjUajX69OmDdevWwdvbG4MGDcL27duFjkhEREYq6fItnJ6+BhJzGTxf6oL63VvjytJtxdPv/xWM+38FF79uMKAD/D5+BVG/HxcgLRER1bSKjgPBczdi4L7Pce/QBeSlZsJ/yURc+OQnFvxkcIy2e39QUBA6d+6MiIgIzJkzB4sXL0ZsbCwGDhyIzMxM+Pr6Ch2RTIQqLwdxW+cifFJTXB5hiZBXHXDj/Q5I/HOV0NGqJOtBMq59v7/49eUlvyHl2l3hAhEZqMLcfGTcVSAtIgYhy3YgIyYRnRa9Weq8Vq4O6LR4Ak5MWoHCnHw9JyUi0k52Yiqu/3iw+PWlRVvwMCRKwESGqaLjQLYiBdfWH0D7uWPRbGw/PIqOR/zpMAETGxaVSo3DZ2Mxbcm54rZf9t9CeiaPk/pmlFf6k5KSMGrUKPj5+SEwMBCWlkWDaYwdOxZeXl4AwKKfasz9799BRtgxeExYCUuvNijMTkd29BXkJ90XOppW1Go1Qr7eiasrdkOtenwv2u3fT+D27yfQ8PlO6LZ6KmRWFgKmJDJcIV/vwMsnVyJi8xEkh95+PEEkQo810xG25g+k3rgnXEAiogqo1WqEf/cHLi/ZpnFfevSeU4jecwruff3QY90MmNlYCZjScJV2HLi5MQCDDi6Ga9dW+HPgbIETGo57DzLw0rQjuBqZqtE+Z80lLPk5FBs/64Hh/b0ESlf7GOWV/qVLlyI1NRUbN24sLvgBwM7ODn5+fgBY9FPNSbvwB1xengX7zkNg7uIFK682cOo7HvVHzxM6mlZCvtmJ0G9/1yj4n3Tv0AUcn/A1VIWFek5GZBwy7igQc+Qf+M0eo9HeZsYw5Gdk4+bPfwmUjIiocq6t249Li7aWORBdbNBlBL2+BIX57J5emlKPA2o1In49gtigy8hLThcunAFJSslB7zcPlSj4/5OVo8SoWUdx4IRxXUAzZkZZ9G/fvh3du3eHt7d3qdNdXFwgl8uLXx88eBB+fn6oU6cO5HI5li1bpq+oZAJkdV2RfjkAyowUoaNUWbYiBVeX765wvrhjIYgNvKyHRETGKXztfrj18oXcvyUAwLlDMzR9pS/OzPxO4GREROXLTcnA5SfuRy9LwrnruHfgvB4SGaenjwMAAJUKapVauFAGZvnma7gTl1nmdLUaUAOYvvQ8VPy56YXRde9XKBSIi4vDqFGjSkxTqVQICwtD27Zti9sOHz6Mt956C7/++it69uyJ7Oxs3L9f+W+VlEolFApFjWQnYRUUuACQab1cwyk/4s43ryB0XD1YerREnWadYdfuedh1GgyRSFSFHAWIjU3QernqiN4QUOYV/qeFfr8P4pauOk5EpH8FBcpKz3t6RulFfNI/EdjkOhwAYGZrhe6rp+H09DXISy375KasLLGxsVotQ0RUHfc2H4Uqv3L7wdAf9sOso2l2va7ssaAyx4Hq5jDF40B+gQrf/34dIhQV9mVRq4Ho2Az89mcoerVz0lc8oyeXyyGVal/CG13Rn5WVBQClFlv79u1DYmKiRtf+uXPnYu7cuejbty8AwNbWFq1atar05ykUCnh4eFQvNBmEFqvDYdmgZcUzPsW6eVe0Wn8bWZHByIo4h4xrJ3F76XDYtRuIxp/u17rwj4yMhMdzlf8brAkz7Lugtbm8Ulnvn72Kl/g3TyboC8d+cJPZ1tj7NXv9OVg626PjwvEa7VG/n8D1Hw6Uu2xkZCRGcjsjIj16x64TOlq6V2re5JDbJnv+W9PHgqoy2eOAmQvQbFGlZx/71lwgsfxjJj0WExMDd/fKbcdPMrqi38PDAxKJBCdOnNBov3fvHqZOnQrg8f38WVlZuHjxIgYOHIhnnnkGqamp6NSpE1auXFk84B9RZYgkUlg37wLr5l3gMuR9JB/fgrvLxyLz2knYtOopdLwKibX4YkIM7XsvENVGYav3Imz1XqFjEBFVilgkglqtrtQFAJ4JaCdq53FE7TwudAzDINL27nGjvNvc6Bhd0W9mZoZx48Zh48aNGDx4MAYNGoSYmBhs2LABLi4uiIuLKy76U1NToVarsXv3bgQEBMDZ2RkzZszA0KFDcfny5Urt9ORyOWJiYnS8VqQPU6+7ICa3Zt7Lwr05AED5KFHrZb29vfG3nv+mIr7Zg5jtJyueUQS4tGqMmF/4N0+m59zIJci6Yxi3a3l7eyNm589CxyCiWiRq7UHc3Xik4hlFgK2XK2L+Mc1zAUM5FpjqcSArRwnfMceQm1+520rXfDsHg3tyXJzKenLcOm0YXdEPAKtWrYJMJsO+fftw9OhR+Pv7Y+/evfjss88QFRVVPMCfjY0NAGD69Onw9PQEACxevBj16tVDTEwMGjRoUOFnSaXSKnWhIMMjuwWgCkV/xCc94dB9DKyatIfUrh7y4qMQt/kTSOrYw8ant/Y5ZDK9/01ZT3q5ckW/GvCZMIh/82SSZDLDOeTJZDy2EJF+2U0agrubAotupi6PGmj5xvMmu48ylGOBKR8Hxr7YFBt2R5Q7jwiAg505Jozwg7mZRD/BajGj7E9hbW2N9evXQ6FQICMjA4cPH4a/vz/Cw8Ph4+MDsbhotezs7NCwYcMqDbZG9B87v4FIObkVUZ8/j2uTm+Huqv/Bon5TNFtyBlJb4xh4xL6ZB7xe7lbhfHZN3OA1uOL5iIiIyLjYNHBB0zF9KpzPuoEzmozspftAZLI+eN0HNlYylFeCqQHMm9SWBb+eGMZXXTUgLS0NsbGxGDRokEb7pEmTsHLlSvTv3x/16tXD3Llz0a5du0pd5ScCAPnw2ZAPny10jGrr+s07UGbnIubvfzQn/Du8ql0TN/TfPhdSK3NB8hEREZFudf5yAgqycnB331nNCf+eC1g3cEH/HXNhZltHkHxkGrw97XBobX+8MOUwHmUWQCQq2cFk7tu+mPpKC2EC1kImU/SHhYUBgMbI/QDw4YcfIjU1FX5+flCpVOjWrRv27NkjQEIiYUktzdHn5w8RdzwUNzcFIOlSJNTKQtg1cYP3uP7weqkLpJYs+ImIiEyVxEyGnutmwvvVZ3FzYwASgm9CXaCEjZcrmr32LLyGdofMykLomGQCuvnJcevACPz8RyQ27buF+KRsWFlIMaiHB94Z2Rx+LYyjt6ypMPmiXywWY+nSpVi6dKkAqYgMi0gshnuftnDv01boKEQGyd7bHf7L3oZapYZaWYgz769D5v2SA3YO2L0Qj6LicO6jHyCxNMNzO+fDvqk7zn30A+7sOyNAciKiyhGJRKjfvTXqd28tdBSDVNFxQGJphk6fvwHrBi4QS8QIfG0x7Jt5oP3csQAAqbUFRCIR/uz/oVCrYDDqOVjiozfa4KM32ggdpdYzmaJ/8uTJmDx5stAxiIjIiOUmpyPwtS9RkJENt96+aDNzOM7MXKsxj/uz7VCQmVP8WpWnxLE3lqHZuP76jktERDWsouOA73sjEb33NBRnwovbHoZEIWDYfABAi4mDILEw03tuovIY5UB+REREupCbnI6CjGwAgKqgEOrCpx45JBLhmf8NwM1NAcVNapUKOUlpekxJRES6UtFxQN61JRo81x4Ddi9E6xnDSizv9XI33Nl7Wi9ZiSqLRT8REdFTJBZm8J01Etd/PKTR3mRkL9w7dAGFuQUCJSMiIn0o6zjg0MITccdCEDB8ARx9GkHu37J4mm0jV6gKlMiMTdJ3XKJysegnIiJ6gkgiRo+103Ft3X6k3bxf3C4xl6HR0O6I2n5UwHRERKRrZR0HACA3JR1xx0MBtRoPToSibouGxdMaDe2O6D28yk+Gh0U/ERHRE7p+8w4eHA/F/YCLGu3WDZxhZlcHz27+GO3mvga3vm3ReERPgVISEZGulHUcAICE8zfg2LoRAMCxdSOk34kvnub5Uhfc/fNsiWWIhGYyA/kRERFVl1tvX3i+1AXWHs7wGtwVKdfuIO5YCMzsrXFn72kcGPARAEDu3xJeQ7ri9u8nAAC9fvwAjq28oMzOhZNfU1ycv0nAtSAioqqq6DhwafEWdP36HUgszJAWEYO4o1cAAE5tmyLjXgLyUjIEXgOikkRqtVotdAgifRh5DIg2gP1wIxtgZ2+hUxDVPn/0nIG0yFihYwAoeiTUkBMrhI5BRFTrGMqxgMcB0id27yciIiIiIiIyUSz6iYiIiIiIiEwUi34iIiIiIiIiE8WB/KjWcLMSOkERQ8lBVNvYeMqFjlDMkLIQEdUmhrL/NZQcVDtwID8iIiIiIiIiE8Xu/UREREREREQmikU/ERERERERkYli0U9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRiWLRT0RERERERGSiWPQTERERERERmSgW/UREREREREQmikU/ERERERERkYli0U9ERERERERkolj0ExEREREREZkoFv1EREREREREJopFPxEREREREZGJYtFPREREREREZKJY9BMRERERERGZKBb9RERERERERCaKRT8RERERERGRifo/4J6/88UxBv8AAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1300.22x494.978 with 1 Axes>"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -52,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -66,12 +66,12 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1367.11x494.978 with 1 Axes>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -275,7 +275,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,
diff --git a/docs/index.rst b/docs/index.rst
index 643a972..b47caeb 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -12,7 +12,9 @@ The toolbox currently contains the following tools:
 
 - Circuit Cutting
 
-This project is meant to evolve rapidly and, as such, does not follow `Qiskit's deprecation policy <https://github.com/Qiskit/qiskit/blob/main/DEPRECATION.md>`_.  We may occasionally make breaking changes in order to improve the user experience.  When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the new ones.  Each substantial improvement, breaking change, or deprecation will be documented in the :ref:`release notes`.
+For a more detailed discussion on circuit cutting, check out our `technical guide <./circuit_cutting/explanation/index.rst#overview-of-circuit-cutting>`__.
+
+This project is meant to evolve rapidly and, as such, does not follow `Qiskit's deprecation policy <https://github.com/Qiskit/qiskit/blob/main/DEPRECATION.md>`__.  We may occasionally make breaking changes in order to improve the user experience.  When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the new ones.  Each substantial improvement, breaking change, or deprecation will be documented in the :ref:`release notes`.
 
 Citing this project
 -------------------
@@ -22,6 +24,8 @@ If you use the Circuit Knitting Toolbox in your research, please cite it accordi
 .. literalinclude:: ../CITATION.bib
    :language: bibtex
 
+If you are using the entanglement forging tool in CKT version 0.5.0 or earlier, please use `an older version of the citation file <https://github.com/Qiskit-Extensions/circuit-knitting-toolbox/blob/stable/0.5/CITATION.bib>`__ which includes the authors of that tool.
+
 Developer guide
 ---------------
 
diff --git a/pyproject.toml b/pyproject.toml
index 96e6039..92be91c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "circuit-knitting-toolbox"
-version = "0.7.0"
+version = "0.7.1"
 description = "A software prototype for a circuit knitting toolbox which connects user applications with runtime primitives"
 readme = "README.md"
 license = {file = "LICENSE.txt"}
@@ -66,7 +66,7 @@ style = [
 lint = [
     "circuit-knitting-toolbox[style]",
     "pydocstyle==6.3.0",
-    "mypy==1.9.0",
+    "mypy==1.10.0",
     "reno>=3.4.0",
     "pylint==3.1.0",
     # pydocstyle prefers to parse our pyproject.toml, hence the following line
diff --git a/releasenotes/notes/0.7/nonzero-register-size-e112e34417ff79b9.yaml b/releasenotes/notes/0.7/nonzero-register-size-e112e34417ff79b9.yaml
new file mode 100644
index 0000000..66f30b7
--- /dev/null
+++ b/releasenotes/notes/0.7/nonzero-register-size-e112e34417ff79b9.yaml
@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Added a workaround so that the classical registers in the
+    generated circuits will always contain at least one bit.  This is
+    currently necessary for the experiments to be able to reach IBM
+    Quantum's hardware backends due to an `openqasm parser issue
+    <https://github.com/openqasm/qe-qasm/issues/37>`__.
diff --git a/releasenotes/notes/0.7/prepare-0.7.1-a18412f0e07ece06.yaml b/releasenotes/notes/0.7/prepare-0.7.1-a18412f0e07ece06.yaml
new file mode 100644
index 0000000..2748361
--- /dev/null
+++ b/releasenotes/notes/0.7/prepare-0.7.1-a18412f0e07ece06.yaml
@@ -0,0 +1,5 @@
+---
+prelude: |
+  The 0.7.1 release provides a workaround to ensure that the
+  experiments generated by the circuit cutting workflow will execute
+  on IBM Quantum's hardware backends.
diff --git a/releasenotes/notes/0.7/subexperiment-gen-speedup-41a4e8679353d1d9.yaml b/releasenotes/notes/0.7/subexperiment-gen-speedup-41a4e8679353d1d9.yaml
new file mode 100644
index 0000000..807637a
--- /dev/null
+++ b/releasenotes/notes/0.7/subexperiment-gen-speedup-41a4e8679353d1d9.yaml
@@ -0,0 +1,4 @@
+---
+other:
+  - |
+    The :func:`.generate_cutting_experiments` function has been optimized for faster execution.
diff --git a/releasenotes/notes/cut-finder-enhancement-1e1d37174d7a8860.yaml b/releasenotes/notes/cut-finder-enhancement-1e1d37174d7a8860.yaml
new file mode 100644
index 0000000..2b5ce2e
--- /dev/null
+++ b/releasenotes/notes/cut-finder-enhancement-1e1d37174d7a8860.yaml
@@ -0,0 +1,4 @@
+---
+upgrade:
+  - |
+    The search engine inside the automated cut-finder has been primed to avoid extraneous searches and is therefore expected to run faster.


Test patch:
diff --git a/.github/workflows/test_latest_versions.yml b/.github/workflows/test_latest_versions.yml
index 2215945..e8baf74 100644
--- a/.github/workflows/test_latest_versions.yml
+++ b/.github/workflows/test_latest_versions.yml
@@ -20,10 +20,10 @@ jobs:
       max-parallel: 4
       matrix:
         os: [ubuntu-latest]
-        python-version: ["3.9", "3.12"]
+        python-version: ["3.8", "3.12"]
         include:
-          - os: macos-13
-            python-version: "3.8"
+          - os: macos-latest
+            python-version: "3.12"
           - os: windows-latest
             python-version: "3.10"
     steps:
diff --git a/test/cutting/cut_finding/test_best_first_search.py b/test/cutting/cut_finding/test_best_first_search.py
index 91a3b56..6cf50f8 100644
--- a/test/cutting/cut_finding/test_best_first_search.py
+++ b/test/cutting/cut_finding/test_best_first_search.py
@@ -20,7 +20,15 @@ from circuit_knitting.cutting.cut_finding.circuit_interface import (
     CircuitElement,
     GateSpec,
 )
-from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization
+from circuit_knitting.cutting.cut_finding.cut_optimization import (
+    cut_optimization_next_state_func,
+    cut_optimization_min_cost_bound_func,
+    cut_optimization_cost_func,
+    cut_optimization_goal_state_func,
+    cut_optimization_upper_bound_cost_func,
+    CutOptimizationFuncArgs,
+    CutOptimization,
+)
 from circuit_knitting.cutting.cut_finding.optimization_settings import (
     OptimizationSettings,
 )
@@ -28,6 +36,15 @@ from circuit_knitting.cutting.automated_cut_finding import DeviceConstraints
 from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import (
     get_actions_list,
 )
+from circuit_knitting.cutting.cut_finding.cutting_actions import (
+    disjoint_subcircuit_actions,
+    DisjointSubcircuitsState,
+)
+
+from circuit_knitting.cutting.cut_finding.best_first_search import (
+    BestFirstSearch,
+    SearchFunctions,
+)
 
 
 @fixture
@@ -97,7 +114,7 @@ def test_best_first_search(test_circuit: SimpleGateList):
                 gate=CircuitElement(name="cx", params=[], qubits=[3, 4], gamma=3),
                 cut_constraints=None,
             ),
-            [((1, 3), (2, 4))],
+            (((1, 3), (2, 4)),),
         ),
         (
             GateSpec(
@@ -105,7 +122,7 @@ def test_best_first_search(test_circuit: SimpleGateList):
                 gate=CircuitElement(name="cx", params=[], qubits=[3, 5], gamma=3),
                 cut_constraints=None,
             ),
-            [((1, 3), (2, 5))],
+            (((1, 3), (2, 5)),),
         ),
         (
             GateSpec(
@@ -113,7 +130,7 @@ def test_best_first_search(test_circuit: SimpleGateList):
                 gate=CircuitElement(name="cx", params=[], qubits=[3, 6], gamma=3),
                 cut_constraints=None,
             ),
-            [((1, 3), (2, 6))],
+            (((1, 3), (2, 6)),),
         ),
     ]
 
@@ -124,3 +141,67 @@ def test_best_first_search(test_circuit: SimpleGateList):
     assert op.get_upperbound_cost() == (27, inf)
     assert op.minimum_reached() is True
     assert out is None
+
+
+def test_best_first_search_termination():
+    """Test that if the best first search is run multiple times, it terminates once no further feasible cut states can be found,
+    in which case None is returned for both the cost and the state. This test also serves to describe the workflow of the optimizer
+    at a granular level."""
+
+    # Specify circuit
+    circuit = [
+        CircuitElement(name="cx", params=[], qubits=[0, 1], gamma=3),
+        CircuitElement(name="cx", params=[], qubits=[2, 3], gamma=3),
+        CircuitElement(name="cx", params=[], qubits=[1, 2], gamma=3),
+    ]
+
+    interface = SimpleGateList(circuit)
+
+    # Specify optimization settings, search engine, and device constraints.
+    settings = OptimizationSettings(seed=123)
+    settings.set_engine_selection("CutOptimization", "BestFirst")
+
+    constraints = DeviceConstraints(qubits_per_subcircuit=3)
+
+    # Initialize and pass arguments to search space generating object.
+    func_args = CutOptimizationFuncArgs()
+    func_args.entangling_gates = interface.get_multiqubit_gates()
+    func_args.search_actions = disjoint_subcircuit_actions
+    func_args.max_gamma = settings.get_max_gamma
+    func_args.qpu_width = constraints.get_qpu_width()
+
+    # Initialize search functions object, needed to explore a search space.
+    cut_optimization_search_funcs = SearchFunctions(
+        cost_func=cut_optimization_cost_func,
+        upperbound_cost_func=cut_optimization_upper_bound_cost_func,
+        next_state_func=cut_optimization_next_state_func,
+        goal_state_func=cut_optimization_goal_state_func,
+        mincost_bound_func=cut_optimization_min_cost_bound_func,
+    )
+
+    # Initialize disjoint subcircuits state object
+    # while specifying number of qubits and max allowed wire cuts.
+    state = DisjointSubcircuitsState(interface.get_num_qubits(), 2)
+
+    # Initialize bfs object.
+    bfs = BestFirstSearch(
+        optimization_settings=settings, search_functions=cut_optimization_search_funcs
+    )
+
+    # Push an input state.
+    bfs.initialize([state], func_args)
+
+    counter = 0
+
+    cut_state = state
+    while cut_state is not None:
+        cut_state, cut_cost = bfs.optimization_pass(func_args)
+        counter += 1
+
+    # There are 5 possible cut states that can be found for this circuit,
+    # given that there need to be 3 qubits per subcircuit. These correspond
+    # to 3 gate cuts (i.e cutting any of the 3 gates) and cutting either of
+    # the input wires to the CNOT between qubits 1 and 2.
+    # After these 5 possible cuts are returned, at the 6th iteration, None
+    # is returned for both the state and the cost.
+    assert counter == 6 and cut_cost is None
diff --git a/test/cutting/cut_finding/test_cut_finder_results.py b/test/cutting/cut_finding/test_cut_finder_results.py
index cbddec0..2178917 100644
--- a/test/cutting/cut_finding/test_cut_finder_results.py
+++ b/test/cutting/cut_finding/test_cut_finder_results.py
@@ -14,7 +14,6 @@
 from __future__ import annotations
 
 import numpy as np
-from numpy import array
 from pytest import fixture, raises
 from qiskit import QuantumCircuit
 from typing import Callable
@@ -190,8 +189,9 @@ def test_four_qubit_circuit_two_qubit_qpu(
     )  # circuit separated into 2 subcircuits.
 
     assert (
-        optimization_pass.get_stats()["CutOptimization"] == array([15, 46, 15, 6])
-    ).all()  # matches known stats.
+        optimization_pass.get_stats()["CutOptimization"].backjumps
+        <= settings.max_backjumps
+    )
 
 
 def test_seven_qubit_circuit_two_qubit_qpu(
diff --git a/test/cutting/qpd/test_qpd.py b/test/cutting/qpd/test_qpd.py
index 7a53913..a3478d0 100644
--- a/test/cutting/qpd/test_qpd.py
+++ b/test/cutting/qpd/test_qpd.py
@@ -148,7 +148,7 @@ class TestQPDFunctions(unittest.TestCase):
         with self.subTest("Empty circuit"):
             circ = QuantumCircuit()
             new_circ = decompose_qpd_instructions(QuantumCircuit(), [])
-            circ.add_register(ClassicalRegister(0, name="qpd_measurements"))
+            circ.add_register(ClassicalRegister(1, name="qpd_measurements"))
             self.assertEqual(circ, new_circ)
         with self.subTest("No QPD circuit"):
             circ = QuantumCircuit(2, 1)
@@ -156,7 +156,7 @@ class TestQPDFunctions(unittest.TestCase):
             circ.cx(0, 1)
             circ.measure(1, 0)
             new_circ = decompose_qpd_instructions(circ, [])
-            circ.add_register(ClassicalRegister(0, name="qpd_measurements"))
+            circ.add_register(ClassicalRegister(1, name="qpd_measurements"))
             self.assertEqual(circ, new_circ)
         with self.subTest("Single QPD gate"):
             circ = QuantumCircuit(2)
@@ -165,7 +165,7 @@ class TestQPDFunctions(unittest.TestCase):
             qpd_gate = TwoQubitQPDGate(qpd_basis)
             circ.data.append(CircuitInstruction(qpd_gate, qubits=[0, 1]))
             decomp_circ = decompose_qpd_instructions(circ, [[0]], map_ids=[0])
-            circ_compare.add_register(ClassicalRegister(0, name="qpd_measurements"))
+            circ_compare.add_register(ClassicalRegister(1, name="qpd_measurements"))
             self.assertEqual(decomp_circ, circ_compare)
         with self.subTest("Incorrect map index size"):
             with pytest.raises(ValueError) as e_info:
@@ -285,8 +285,12 @@ class TestQPDFunctions(unittest.TestCase):
         (SwapGate(), 7),
         (iSwapGate(), 7),
         (DCXGate(), 7),
+        # XXPlusYYGate, XXMinusYYGate, with some combinations:
+        #     beta == 0 or not; and
+        #     within |theta| < pi or not
         (XXPlusYYGate(0.1), 1 + 4 * np.sin(0.05) + 2 * np.sin(0.05) ** 2),
-        (XXMinusYYGate(0.2), 1 + 4 * np.sin(0.1) + 2 * np.sin(0.1) ** 2),
+        (XXPlusYYGate(4), 1 + 4 * np.sin(2) + 2 * np.sin(2) ** 2),
+        (XXMinusYYGate(0.2, beta=0.2), 1 + 4 * np.sin(0.1) + 2 * np.sin(0.1) ** 2),
         (Move(), 4),
     )
     @unpack
diff --git a/test/cutting/test_cutting_experiments.py b/test/cutting/test_cutting_experiments.py
index 6d435f3..47c6e15 100644
--- a/test/cutting/test_cutting_experiments.py
+++ b/test/cutting/test_cutting_experiments.py
@@ -15,7 +15,7 @@ import unittest
 import pytest
 import numpy as np
 from qiskit.quantum_info import PauliList, Pauli
-from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumCircuit, QuantumRegister
 from qiskit.circuit.library.standard_gates import CXGate
 
 from circuit_knitting.cutting.qpd import (
@@ -30,6 +30,9 @@ from circuit_knitting.cutting import partition_problem
 from circuit_knitting.cutting.cutting_experiments import (
     _append_measurement_register,
     _append_measurement_circuit,
+    _remove_final_resets,
+    _consolidate_resets,
+    _remove_resets_in_zero_state,
 )
 
 
@@ -219,3 +222,125 @@ class TestCuttingExperiments(unittest.TestCase):
                 e_info.value.args[0]
                 == "Quantum circuit qubit count (2) does not match qubit count of observable(s) (1).  Try providing `qubit_locations` explicitly."
             )
+
+    def test_consolidate_double_reset(self):
+        """Consolidate a pair of resets.
+        qr0:--|0>--|0>--   ==>    qr0:--|0>--
+        """
+        qr = QuantumRegister(1, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.reset(qr)
+        circuit.reset(qr)
+
+        expected = QuantumCircuit(qr)
+        expected.reset(qr)
+
+        _consolidate_resets(circuit)
+
+        self.assertEqual(expected, circuit)
+
+    def test_two_resets(self):
+        """Remove two final resets
+        qr0:--[H]-|0>-|0>--   ==>    qr0:--[H]--
+        """
+        qr = QuantumRegister(1, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.h(qr[0])
+        circuit.reset(qr[0])
+        circuit.reset(qr[0])
+
+        expected = QuantumCircuit(qr)
+        expected.h(qr[0])
+
+        _remove_final_resets(circuit)
+
+        self.assertEqual(expected, circuit)
+
+    def test_optimize_single_reset_in_diff_qubits(self):
+        """Remove a single final reset in different qubits
+        qr0:--[H]--|0>--          qr0:--[H]--
+                      ==>
+        qr1:--[X]--|0>--          qr1:--[X]----
+        """
+        qr = QuantumRegister(2, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.h(0)
+        circuit.x(1)
+        circuit.reset(qr)
+
+        expected = QuantumCircuit(qr)
+        expected.h(0)
+        expected.x(1)
+
+        _remove_final_resets(circuit)
+        self.assertEqual(expected, circuit)
+
+    def test_optimize_single_final_reset(self):
+        """Remove a single final reset
+        qr0:--[H]--|0>--   ==>    qr0:--[H]--
+        """
+        qr = QuantumRegister(1, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.h(0)
+        circuit.reset(qr)
+
+        expected = QuantumCircuit(qr)
+        expected.h(0)
+
+        _remove_final_resets(circuit)
+
+        self.assertEqual(expected, circuit)
+
+    def test_optimize_single_final_reset_2(self):
+        """Remove a single final reset on two qubits
+        qr0:--[H]--|0>--   ==>    qr0:--[H]-------
+            --[X]--[S]--              --[X]--[S]--
+        """
+        qr = QuantumRegister(2, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.h(0)
+        circuit.x(1)
+        circuit.reset(0)
+        circuit.s(1)
+
+        expected = QuantumCircuit(qr)
+        expected.h(0)
+        expected.x(1)
+        expected.s(1)
+
+        _remove_final_resets(circuit)
+
+        self.assertEqual(expected, circuit)
+
+    def test_dont_optimize_non_final_reset(self):
+        """Do not remove reset if not final instruction
+        qr0:--|0>--[H]--   ==>    qr0:--|0>--[H]--
+        """
+        qr = QuantumRegister(1, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.reset(qr)
+        circuit.h(qr)
+
+        expected = QuantumCircuit(qr)
+        expected.reset(qr)
+        expected.h(qr)
+
+        _remove_final_resets(circuit)
+
+        self.assertEqual(expected, circuit)
+
+    def test_remove_reset_in_zero_state(self):
+        """Remove reset if first instruction on qubit
+        qr0:--|0>--[H]--   ==>    qr0:--|0>--[H]--
+        """
+        qr = QuantumRegister(1, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.reset(qr)
+        circuit.h(qr)
+
+        expected = QuantumCircuit(qr)
+        expected.h(qr)
+
+        _remove_resets_in_zero_state(circuit)
+
+        self.assertEqual(expected, circuit)
diff --git a/test/cutting/test_cutting_roundtrip.py b/test/cutting/test_cutting_roundtrip.py
index b6b91c4..6ea7547c 100644
--- a/test/cutting/test_cutting_roundtrip.py
+++ b/test/cutting/test_cutting_roundtrip.py
@@ -89,7 +89,12 @@ def append_random_unitary(circuit: QuantumCircuit, qubits):
         [RXXGate(np.pi / 3), CPhaseGate(np.pi / 7)],
         [UnitaryGate(random_unitary(2**2))],
         [RZXGate(np.pi / 5)],
+        # XXPlusYYGate, XXMinusYYGate, with some combinations:
+        #     beta == 0 or not; and
+        #     within |theta| < pi or not
         [XXPlusYYGate(7 * np.pi / 11)],
+        [XXPlusYYGate(17 * np.pi / 11, beta=0.4)],
+        [XXPlusYYGate(-19 * np.pi / 11, beta=0.3)],
         [XXMinusYYGate(11 * np.pi / 17)],
         [Move()],
         [Move(), Move()],