From 71cb38b8c8f1f97b3f12a14501789bb6202015b6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 31 Oct 2022 14:41:31 +0000
Subject: [PATCH 01/14] Update pillow requirement from ~=9.2.0 to ~=9.3.0

Updates the requirements on [pillow](https://github.com/python-pillow/Pillow) to permit the latest version.
- [Release notes](https://github.com/python-pillow/Pillow/releases)
- [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst)
- [Commits](https://github.com/python-pillow/Pillow/compare/9.2.0...9.3.0)

---
updated-dependencies:
- dependency-name: pillow
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index ee41b4a5f49a..f32307ede4e9 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -84,7 +84,7 @@ pandas~=1.5.1
 pandocfilters~=1.5.0
 parso~=0.8.3
 pickleshare~=0.7.5
-Pillow~=9.2.0
+Pillow~=9.3.0
 pluggy~=1.0.0
 portalocker~=2.6.0
 prometheus-client~=0.15.0

From 0609905d3673ba341c64a95c8c4a68e506cb4890 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Tue, 25 Oct 2022 09:19:49 +0200
Subject: [PATCH 02/14] Add ability to get parameter after set to dond

---
 qcodes/dataset/dond/do_nd.py  |  7 ++++++-
 qcodes/dataset/dond/sweeps.py | 24 ++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/qcodes/dataset/dond/do_nd.py b/qcodes/dataset/dond/do_nd.py
index eb32f4bddeb1..68c21e5df601 100644
--- a/qcodes/dataset/dond/do_nd.py
+++ b/qcodes/dataset/dond/do_nd.py
@@ -60,6 +60,7 @@ class ParameterSetEvent:
     should_set: bool
     delay: float
     actions: ActionsT
+    get_after_set: bool
 
 
 class _Sweeper:
@@ -228,6 +229,7 @@ def __getitem__(self, index: int) -> tuple[ParameterSetEvent, ...]:
                 should_set=should_set,
                 delay=sweep.delay,
                 actions=sweep.post_actions,
+                get_after_set=sweep.get_after_set,
             )
             parameter_set_events.append(event)
         return tuple(parameter_set_events)
@@ -708,7 +710,10 @@ def dond(
                             act()
                         time.sleep(set_event.delay)
 
-                    results[set_event.parameter] = set_event.new_value
+                    if set_event.get_after_set:
+                        results[set_event.parameter] = set_event.parameter()
+                    else:
+                        results[set_event.parameter] = set_event.new_value
 
                 meas_value_pair = call_params_meas()
                 for meas_param, value in meas_value_pair:
diff --git a/qcodes/dataset/dond/sweeps.py b/qcodes/dataset/dond/sweeps.py
index 309b50fa7a86..981511b8bba0 100644
--- a/qcodes/dataset/dond/sweeps.py
+++ b/qcodes/dataset/dond/sweeps.py
@@ -57,6 +57,10 @@ def post_actions(self) -> ActionsT:
         """
         pass
 
+    @property
+    def get_after_set(self) -> bool:
+        return False
+
 
 class LinSweep(AbstractSweep[np.float64]):
     """
@@ -78,6 +82,7 @@ def __init__(
         num_points: int,
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._start = start
@@ -85,6 +90,7 @@ def __init__(
         self._num_points = num_points
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[np.float64]:
         """
@@ -109,6 +115,10 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
 
 class LogSweep(AbstractSweep[np.float64]):
     """
@@ -130,6 +140,7 @@ def __init__(
         num_points: int,
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._start = start
@@ -137,6 +148,7 @@ def __init__(
         self._num_points = num_points
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[np.float64]:
         """
@@ -161,6 +173,11 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
+
 
 class ArraySweep(AbstractSweep, Generic[T]):
     """
@@ -171,6 +188,7 @@ class ArraySweep(AbstractSweep, Generic[T]):
         array: array with values to sweep.
         delay: Time in seconds between two consecutive sweep points.
         post_actions: Actions to do after each sweep point.
+
     """
 
     def __init__(
@@ -179,11 +197,13 @@ def __init__(
         array: Sequence[Any] | npt.NDArray[T],
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._array = np.array(array)
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[T]:
         return self._array
@@ -204,6 +224,10 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
 
 class TogetherSweep:
     """

From 7c76c7f378b4f703f02c6c90915eede43897aa38 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 10:22:53 +0200
Subject: [PATCH 03/14] add basic test of get after set working correctly

---
 qcodes/tests/dataset/dond/test_doNd.py | 67 ++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/qcodes/tests/dataset/dond/test_doNd.py b/qcodes/tests/dataset/dond/test_doNd.py
index b3476c32bea4..099355bb37f3 100644
--- a/qcodes/tests/dataset/dond/test_doNd.py
+++ b/qcodes/tests/dataset/dond/test_doNd.py
@@ -34,6 +34,27 @@
 from qcodes.validators import Ints
 
 
+class TrackingParameter(Parameter):
+    """Parameter that keeps track of number of get and set operations"""
+
+    def __init__(self, *args, **kwargs):
+        self.set_count = 0
+        self.get_count = 0
+        super().__init__(*args, **kwargs)
+
+    def set_raw(self, value):
+        self.set_count += 1
+        self.cache._set_from_raw_value(value)
+
+    def get_raw(self):
+        self.get_count += 1
+        return self.cache.raw_value
+
+    def reset_count(self) -> None:
+        self.get_count = 0
+        self.set_count = 0
+
+
 def test_linear_sweep_get_setpoints(_param):
     start = 0
     stop = 1
@@ -1589,3 +1610,49 @@ def test_default_log_info(caplog):
         dond(LinSweep(param_1, 0, 10, 10), param_2)
 
     assert "Using 'qcodes.dataset.dond'" in caplog.text
+
+
+def test_dond_get_after_set(_param_set, _param_set_2, _param):
+
+    n_points = 10
+
+    a = TrackingParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    dond(LinSweep(a, 0, 10, n_points, get_after_set=True), b)
+
+    assert a.get_count == n_points
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0
+
+
+def test_dond_no_get_after_set(_param_set, _param_set_2, _param):
+
+    n_points = 10
+
+    a = TrackingParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    dond(LinSweep(a, 0, 10, n_points, get_after_set=False), b)
+
+    assert a.get_count == 0
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0

From e6047c90e9ceeffb4db475c489eb22ae96b5e6d0 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 10:27:49 +0200
Subject: [PATCH 04/14] document get_after_set

---
 qcodes/dataset/dond/sweeps.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/qcodes/dataset/dond/sweeps.py b/qcodes/dataset/dond/sweeps.py
index 981511b8bba0..f0b34f8a55b0 100644
--- a/qcodes/dataset/dond/sweeps.py
+++ b/qcodes/dataset/dond/sweeps.py
@@ -59,6 +59,13 @@ def post_actions(self) -> ActionsT:
 
     @property
     def get_after_set(self) -> bool:
+        """
+        Should we perform a call to get on the parameter after setting it
+        and store that rather than the setpoint value in the dataset?
+
+        This defaults to False for backwards compatibility
+        but subclasses should overwrite this to implement if correctly.
+        """
         return False
 
 
@@ -71,7 +78,10 @@ class LinSweep(AbstractSweep[np.float64]):
         start: Sweep start value.
         stop: Sweep end value.
         num_points: Number of sweep points.
-        delay: Time in seconds between two consecutive sweep points
+        delay: Time in seconds between two consecutive sweep points.
+        post_actions: Actions to do after each sweep point.
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(
@@ -130,6 +140,9 @@ class LogSweep(AbstractSweep[np.float64]):
         stop: Sweep end value.
         num_points: Number of sweep points.
         delay: Time in seconds between two consecutive sweep points.
+        post_actions: Actions to do after each sweep point.
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(
@@ -178,7 +191,6 @@ def get_after_set(self) -> bool:
         return self._get_after_set
 
 
-
 class ArraySweep(AbstractSweep, Generic[T]):
     """
     Sweep the values of a given array.
@@ -188,7 +200,8 @@ class ArraySweep(AbstractSweep, Generic[T]):
         array: array with values to sweep.
         delay: Time in seconds between two consecutive sweep points.
         post_actions: Actions to do after each sweep point.
-
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(

From e933ba9446d0888981d147ea4969534f5baee904 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 10:53:25 +0200
Subject: [PATCH 05/14] ensure that manual parameters use the instrument logger
 if avilable

---
 qcodes/parameters/parameter.py   | 14 ++++++++++++--
 qcodes/tests/instrument_mocks.py | 12 ++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/qcodes/parameters/parameter.py b/qcodes/parameters/parameter.py
index f011fdb1fcc2..4be3a5c580cb 100644
--- a/qcodes/parameters/parameter.py
+++ b/qcodes/parameters/parameter.py
@@ -180,7 +180,11 @@ def __init__(
         **kwargs: Any,
     ) -> None:
         def _get_manual_parameter() -> ParamRawDataType:
-            log.debug(
+            if self.root_instrument is not None:
+                mylogger = self.root_instrument.log
+            else:
+                mylogger = log
+            mylogger.debug(
                 "Getting raw value of parameter: %s as %s",
                 self.full_name,
                 self.cache.raw_value,
@@ -188,7 +192,13 @@ def _get_manual_parameter() -> ParamRawDataType:
             return self.cache.raw_value
 
         def _set_manual_parameter(x: ParamRawDataType) -> ParamRawDataType:
-            log.debug("Setting raw value of parameter: %s to %s", self.full_name, x)
+            if self.root_instrument is not None:
+                mylogger = self.root_instrument.log
+            else:
+                mylogger = log
+            mylogger.debug(
+                "Setting raw value of parameter: %s to %s", self.full_name, x
+            )
             return x
 
         if instrument is not None and bind_to_instrument:
diff --git a/qcodes/tests/instrument_mocks.py b/qcodes/tests/instrument_mocks.py
index 5308a164247d..ebc601c38010 100644
--- a/qcodes/tests/instrument_mocks.py
+++ b/qcodes/tests/instrument_mocks.py
@@ -209,7 +209,11 @@ def get_raw(self):
         dac = self.root_instrument._setter_instr
         val = self._ed.send(dac.ch1.cache.get())
         next(self._ed)
-        log.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
+        if self.root_instrument is not None:
+            mylogger = self.root_instrument.log
+        else:
+            mylogger = log
+        mylogger.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
         return val
 
     @staticmethod
@@ -241,7 +245,11 @@ def get_raw(self):
         dac = self.root_instrument._setter_instr
         val = self._gauss.send((dac.ch1.cache.get(), dac.ch2.cache.get()))
         next(self._gauss)
-        log.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
+        if self.root_instrument is not None:
+            mylogger = self.root_instrument.log
+        else:
+            mylogger = log
+        mylogger.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
         return val
 
     def _gauss_model(self):

From a56ee38b3425f30b4cfaf5e0bd0cdcf90de23ba5 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 11:51:07 +0200
Subject: [PATCH 06/14] extend dond example notebooks with get_after_set

---
 ..._manager_for_performing_measurements.ipynb | 3528 +++++++++--------
 1 file changed, 1837 insertions(+), 1691 deletions(-)

diff --git a/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb b/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
index 137634285a12..585125af6ac0 100644
--- a/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
+++ b/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
@@ -21,6 +21,11 @@
     "## Setup before measurement"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -30,29 +35,68 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "import time\n",
+    "\n",
     "import numpy as np\n",
-    "from qcodes.dataset import do1d, do2d, dond, LinSweep, LogSweep, ArraySweep, TogetherSweep\n",
-    "from qcodes.utils.dataset.doNd import plot\n",
-    "from qcodes.dataset.sqlite.database import initialise_or_create_database_at\n",
-    "from qcodes.dataset.experiment_container import load_or_create_experiment\n",
-    "from qcodes.tests.instrument_mocks import DummyInstrument, DummyInstrumentWithMeasurement\n",
-    "from qcodes.dataset.measurements import Measurement\n",
-    "from qcodes.dataset.plotting import plot_dataset"
+    "\n",
+    "import qcodes.logger\n",
+    "from qcodes.dataset import (\n",
+    "    ArraySweep,\n",
+    "    LinSweep,\n",
+    "    LogSweep,\n",
+    "    Measurement,\n",
+    "    TogetherSweep,\n",
+    "    do1d,\n",
+    "    do2d,\n",
+    "    dond,\n",
+    "    initialise_or_create_database_at,\n",
+    "    load_or_create_experiment,\n",
+    "    plot_dataset,\n",
+    ")\n",
+    "from qcodes.tests.instrument_mocks import (\n",
+    "    DummyInstrument,\n",
+    "    DummyInstrumentWithMeasurement,\n",
+    ")\n",
+    "from qcodes.utils.dataset.doNd import plot"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Logging hadn't been started.\n",
+      "Activating auto-logging. Current session state plus future input saved.\n",
+      "Filename       : C:\\Users\\jenielse\\.qcodes\\logs\\command_history.log\n",
+      "Mode           : append\n",
+      "Output logging : True\n",
+      "Raw input log  : False\n",
+      "Timestamping   : True\n",
+      "State          : active\n",
+      "Qcodes Logfile : C:\\Users\\jenielse\\.qcodes\\logs\\221028-74616-qcodes.log\n"
+     ]
+    }
+   ],
+   "source": [
+    "qcodes.logger.start_all_logging()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "tutorial_db_path = os.path.join(os.getcwd(), 'tutorial_doNd.db')\n",
+    "tutorial_db_path = os.path.join(os.getcwd(), \"tutorial_doNd.db\")\n",
     "initialise_or_create_database_at(tutorial_db_path)"
    ]
   },
@@ -65,13 +109,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "# preparatory mocking of physical setup\n",
-    "dac = DummyInstrument('dac', gates=['ch1', 'ch2'])\n",
-    "dmm = DummyInstrumentWithMeasurement('dmm', setter_instr=dac)"
+    "dac = DummyInstrument(\"dac\", gates=[\"ch1\", \"ch2\"])\n",
+    "dmm = DummyInstrumentWithMeasurement(\"dmm\", setter_instr=dac)"
    ]
   },
   {
@@ -83,11 +127,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "tutorial_exp = load_or_create_experiment('doNd_VS_Measurement', sample_name='no sample')"
+    "tutorial_exp = load_or_create_experiment(\"doNd_VS_Measurement\", sample_name=\"no sample\")"
    ]
   },
   {
@@ -113,58 +157,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 208. \n"
+      "Starting experimental run with id: 63. \n"
      ]
     }
    ],
    "source": [
     "# Setting up Measurement\n",
-    "meas = Measurement(name= '1d_measurement of dmm from dac sweep', exp=tutorial_exp)\n",
+    "meas = Measurement(name=\"1d_measurement of dmm from dac sweep\", exp=tutorial_exp)\n",
     "meas.register_parameter(dac.ch1)\n",
     "meas.register_parameter(dmm.v1, setpoints=(dac.ch1,))\n",
     "meas.register_parameter(dmm.v2, setpoints=(dac.ch1,))\n",
     "\n",
     "# Running Measurement\n",
     "with meas.run() as datasaver:\n",
-    "    for dac_sweep in np.linspace(0, 1, 10): # sweep points\n",
+    "    for dac_sweep in np.linspace(0, 1, 10):  # sweep points\n",
     "        dac.ch1(dac_sweep)\n",
     "        datasaver.add_result(\n",
-    "            (dac.ch1, dac.ch1()),\n",
-    "            (dmm.v1, dmm.v1()),\n",
-    "            (dmm.v2, dmm.v2())\n",
-    "            )\n",
-    "        time.sleep(0.01) # Can be removed if there is no intention to see a live plot\n",
+    "            (dac.ch1, dac_sweep), (dmm.v1, dmm.v1()), (dmm.v2, dmm.v2())\n",
+    "        )\n",
+    "        time.sleep(0.01)  # Can be removed if there is no intention to see a live plot\n",
     "\n",
     "    dataset1 = datasaver.dataset"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "([<AxesSubplot: title={'center': 'Run #208, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #208, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
+       "([<AxesSubplot: title={'center': 'Run #63, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #63, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
        " [None, None])"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -174,7 +216,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -203,20 +245,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 209. Using 'qcodes.dataset.do1d'\n"
+      "Starting experimental run with id: 64. Using 'qcodes.dataset.do1d'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d8ce05184ce64acd997a191498ed5b33",
+       "model_id": "a2fef1373f75488aa2aae8b1e8bb0309",
        "version_major": 2,
        "version_minor": 0
       },
@@ -230,8 +272,8 @@
     {
      "data": {
       "text/plain": [
-       "(results #209@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #64@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
@@ -239,7 +281,7 @@
        " [None])"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -262,36 +304,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 210. Using 'qcodes.dataset.do1d'\n"
+      "Starting experimental run with id: 65. Using 'qcodes.dataset.do1d'\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "(results #210@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #65@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #210, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #210, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
+       " [<AxesSubplot: title={'center': 'Run #65, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #65, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
        " [None, None])"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -301,7 +343,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -311,7 +353,7 @@
     }
    ],
    "source": [
-    "do1d(dac.ch1, 0, 1, 10, 0.01, dmm.v1, dmm.v2, do_plot = True)"
+    "do1d(dac.ch1, 0, 1, 10, 0.01, dmm.v1, dmm.v2, do_plot=True)"
    ]
   },
   {
@@ -344,63 +386,65 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 211. \n"
+      "Starting experimental run with id: 66. \n"
      ]
     }
    ],
    "source": [
     "# Setting up Measurement\n",
-    "meas = Measurement(name= '2d_measurement of dmm from dac sweep', exp=tutorial_exp)\n",
+    "meas = Measurement(name=\"2d_measurement of dmm from dac sweep\", exp=tutorial_exp)\n",
     "meas.register_parameter(dac.ch1)\n",
     "meas.register_parameter(dac.ch2)\n",
-    "meas.register_parameter(dmm.v1, setpoints=(dac.ch1,dac.ch2))\n",
-    "meas.register_parameter(dmm.v2, setpoints=(dac.ch1,dac.ch2))\n",
+    "meas.register_parameter(dmm.v1, setpoints=(dac.ch1, dac.ch2))\n",
+    "meas.register_parameter(dmm.v2, setpoints=(dac.ch1, dac.ch2))\n",
     "\n",
     "# Running Measurement\n",
     "with meas.run() as datasaver:\n",
-    "    for dac1_sweep in np.linspace(-1, 1, 20): # sweep points over channel 1\n",
+    "    for dac1_sweep in np.linspace(-1, 1, 20):  # sweep points over channel 1\n",
     "        dac.ch1(dac1_sweep)\n",
-    "        for dac2_sweep in np.linspace(-1, 1, 20): # sweep points over channel 2\n",
+    "        for dac2_sweep in np.linspace(-1, 1, 20):  # sweep points over channel 2\n",
     "            dac.ch2(dac2_sweep)\n",
     "            datasaver.add_result(\n",
-    "                (dac.ch1, dac.ch1()),\n",
-    "                (dac.ch2, dac.ch2()),\n",
+    "                (dac.ch1, dac1_sweep),\n",
+    "                (dac.ch2, dac2_sweep),\n",
     "                (dmm.v1, dmm.v1()),\n",
-    "                (dmm.v2, dmm.v2())\n",
-    "                )\n",
-    "            time.sleep(0.01) # Can be removed if there is no intention to see a live plot\n",
+    "                (dmm.v2, dmm.v2()),\n",
+    "            )\n",
+    "            time.sleep(\n",
+    "                0.01\n",
+    "            )  # Can be removed if there is no intention to see a live plot\n",
     "\n",
     "    dataset2 = datasaver.dataset"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "([<AxesSubplot: title={'center': 'Run #211, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #211, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
-       " [<matplotlib.colorbar.Colorbar at 0x1f3c2a8a3a0>,\n",
-       "  <matplotlib.colorbar.Colorbar at 0x1f3c2ae02b0>])"
+       "([<AxesSubplot: title={'center': 'Run #66, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #66, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
+       " [<matplotlib.colorbar.Colorbar at 0x19b8fd97880>,\n",
+       "  <matplotlib.colorbar.Colorbar at 0x19b8fdf54b0>])"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -410,7 +454,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -439,20 +483,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 212. Using 'qcodes.dataset.do2d'\n"
+      "Starting experimental run with id: 67. Using 'qcodes.dataset.do2d'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "908d9817b5b841c49a1933461f977248",
+       "model_id": "b62ec6a3ea004a25b51a34d27b73e79d",
        "version_major": 2,
        "version_minor": 0
       },
@@ -746,25 +790,25 @@
     {
      "data": {
       "text/plain": [
-       "(results #212@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #67@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #212, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #212, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
-       " [<matplotlib.colorbar.Colorbar at 0x1f3c2fbb640>,\n",
-       "  <matplotlib.colorbar.Colorbar at 0x1f3c2ff12b0>])"
+       " [<AxesSubplot: title={'center': 'Run #67, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #67, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
+       " [<matplotlib.colorbar.Colorbar at 0x19b8fd134f0>,\n",
+       "  <matplotlib.colorbar.Colorbar at 0x19b900d95d0>])"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -774,7 +818,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -785,7 +829,22 @@
    ],
    "source": [
     "# Running masurement with do2d\n",
-    "do2d(dac.ch1, -1, 1, 20, 0.01, dac.ch2, -1, 1, 20, 0.01, dmm.v1, dmm.v2, do_plot = True, show_progress=True)"
+    "do2d(\n",
+    "    dac.ch1,\n",
+    "    -1,\n",
+    "    1,\n",
+    "    20,\n",
+    "    0.01,\n",
+    "    dac.ch2,\n",
+    "    -1,\n",
+    "    1,\n",
+    "    20,\n",
+    "    0.01,\n",
+    "    dmm.v1,\n",
+    "    dmm.v2,\n",
+    "    do_plot=True,\n",
+    "    show_progress=True,\n",
+    ")"
    ]
   },
   {
@@ -808,65 +867,88 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 213. Using 'qcodes.dataset.do1d'\n"
+      "Starting experimental run with id: 68. Using 'qcodes.dataset.do1d'\n"
      ]
     }
    ],
    "source": [
-    "result_1d = do1d(dac.ch1, 0, 0.25, 10, 0.01, dmm.v1, dmm.v2,\n",
-    "                 exp=tutorial_exp, measurement_name='1d_measurement of dmm from dac sweep')"
+    "result_1d = do1d(\n",
+    "    dac.ch1,\n",
+    "    0,\n",
+    "    0.25,\n",
+    "    10,\n",
+    "    0.01,\n",
+    "    dmm.v1,\n",
+    "    dmm.v2,\n",
+    "    exp=tutorial_exp,\n",
+    "    measurement_name=\"1d_measurement of dmm from dac sweep\",\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 214. Using 'qcodes.dataset.do2d'\n"
+      "Starting experimental run with id: 69. Using 'qcodes.dataset.do2d'\n"
      ]
     }
    ],
    "source": [
-    "result_2d = do2d(dac.ch1, -0.6, 0.6, 20, 0.01, dac.ch2, -0.6, 0.6, 20, 0.01, dmm.v1, dmm.v2,\n",
-    "                 exp=tutorial_exp, measurement_name='2d_measurement of dmm from dac sweep')"
+    "result_2d = do2d(\n",
+    "    dac.ch1,\n",
+    "    -0.6,\n",
+    "    0.6,\n",
+    "    20,\n",
+    "    0.01,\n",
+    "    dac.ch2,\n",
+    "    -0.6,\n",
+    "    0.6,\n",
+    "    20,\n",
+    "    0.01,\n",
+    "    dmm.v1,\n",
+    "    dmm.v2,\n",
+    "    exp=tutorial_exp,\n",
+    "    measurement_name=\"2d_measurement of dmm from dac sweep\",\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1d_measurement of dmm from dac sweep #213@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " ----------------------------------------------------------------------------------------------------------------------\n",
+       "(1d_measurement of dmm from dac sweep #68@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ---------------------------------------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #213, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate v1 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #213, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate v2 (mV)'>],\n",
+       " [<AxesSubplot: title={'center': 'Run #68, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate v1 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #68, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate v2 (mV)'>],\n",
        " [None, None])"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB3kklEQVR4nO3dd3hTZf8G8PskbdM2XXRPKN1A2QiyUVBUhqCA7CGoaFHwh8h4cSAK+qK+DmS52CIguFiiLNlQ9iotFFqgpYvumeT5/VESGrpn2uT+XFevqz05yfnmJE3vPucZkhBCgIiIiMhIyAxdABEREVFNYrghIiIio8JwQ0REREaF4YaIiIiMCsMNERERGRWGGyIiIjIqDDdERERkVBhuiIiIyKgw3BAREZFRYbghKoWvry/Gjx9v6DLqxPjx4+Hr62vQGt5//31IkmTQGoi0NBoNQkND8dFHHxm6lAajqp+ZycnJUCqV2L59e43VwnDzkJUrV0KSJN2XmZkZvLy8MH78eNy+fdvQ5QEAUlNTIZPJsGvXLgDA1q1boVAokJeXV+L+p06dwsCBA+Ho6Ahra2uEhobiq6++0ttHo9Fg2bJlaNOmDWxsbODm5oann34ahw8frnKdvXr10juXRb9CQkKq/Lj0wKVLl/D+++/jxo0bBqvB19cXkiTh9ddfL3bbvn37IEkSNm/eXOPHbdWqFRo3boyyVpDp2rUr3NzcoFKpAACJiYmYOnUqQkJCYGVlBVdXV3Ts2BEzZ85EZmZmhY+tfV6SJGHt2rWlHluSJISGhlbuiVGN2759O95///1K3eenn35CbGwspkyZUjtFkY6TkxMmTZqEd955p8Ye06zGHsnIfPDBB2jatClyc3Nx9OhRrFy5EgcPHsSFCxdgaWlp0NqOHz8OAOjUqRMA4MiRI2jbti0UCkWxff/66y8MGDAAbdu2xTvvvAMbGxtcu3YNt27d0ttvxowZ+PzzzzF69Gi89tprSE1NxfLly9GzZ08cOnQIHTt2rFKt3t7eWLhwYbHt9vb2VXq8uhQREQGZrH7n/0uXLmHevHno1auXwVtevv32W8yePRuenp51crxRo0Zh1qxZ+Pfff9GjR49it9+4cQNHjhzBlClTYGZmhpSUFHTo0AHp6el48cUXERISguTkZJw7dw5Lly7Fq6++Chsbm0rVYGlpifXr12P06NHFjn348GGDf1ZQoe3bt+Obb76pVMBZtGgRhg8f3iA+q4zB5MmT8dVXX2HPnj14/PHHq/14DDelePrpp9GhQwcAwKRJk+Ds7IxPPvkEv//+O4YNG2bQ2o4fP47g4GA4ODgAKAw32qBTVHp6OsaOHYt+/fph8+bNpf6hVqlUWLp0KYYMGYI1a9botg8dOhR+fn5Yt25dlcONvb19sQ/++kwIgdzcXFhZWZUYFqlkLVq0QEREBD7++ONirYK1ZeTIkZg9ezbWr19fYrj56aefIITAqFGjAADff/89YmJicOjQIXTp0kVv3/T0dFhYWFS6hmeeeQa///47kpKS4OzsrNu+fv16uLm5ITAwEPfu3av049YnWVlZUCqVhi6jTp0+fRpnz57FZ599ZuhSTEazZs0QGhqKlStX1ki4qd//ltYj3bt3BwBcu3ZNt61Xr17o1atXsX0f7r9w48YNSJKETz/9FCtWrIC/vz8UCgUeeeQRnDhxokLHT0tLQ1JSEpKSknDkyBG0bt0aSUlJuHv3LsLDwxESEoKkpCSkpaXp7rN+/XrcvXsXH330EWQyGbKysqDRaIo9dkFBAXJycuDm5qa33dXVFTKZDFZWVhWqsSpycnIQEhKCkJAQ5OTk6LanpKTAw8MDXbp0gVqtBlB4Xm1sbHD9+nX07dsXSqUSnp6e+OCDD4pdmtBoNPjiiy/QokULWFpaws3NDa+88kqxPzS+vr7o378/du3ahQ4dOsDKygrLly/X3Vb0+rH2kuXBgwfxxhtvwMXFBQ4ODnjllVeQn5+P1NRUjB07Fo0aNUKjRo3w9ttvV7uugwcPomPHjrC0tISfnx9Wr16tV8/QoUMBAI899pjuMsm+ffvKPOe//vorQkNDYWlpidDQUGzdurXE/bKysjB9+nT4+PhAoVAgODgYn376aYmXgXx9fTF27Fh8++23uHPnTpnHB4CDBw/ikUcegaWlJfz9/XXnvDJ8fHzQo0cPbN68GQUFBcVuX79+Pfz9/XXB/9q1a5DL5Xj00UeL7WtnZ1elVpZnn30WCoUCmzZtKnbsYcOGQS6Xl3i/tWvXon379rCysoKjoyOGDx+O2NhYvX3+/fdfDB06FI0bN4ZCoYCPjw/efPNNvd8TAIiPj8eECRPg7e0NhUIBDw8PPPvss3qXKiVJKrHVorT3+P79+/Haa6/B1dUV3t7eutt37NiB7t27Q6lUwtbWFv369cPFixf1HlP7exoTE4P+/fvDxsYGXl5e+OabbwAA58+fx+OPPw6lUokmTZpg/fr1xepKTU3FtGnTdO+9gIAAfPLJJ3qfXxX9XB0/frzu2EUvjZfl119/hYWFRbHQrO0XFhUVhfHjx8PBwQH29vaYMGECsrOz9fZVqVSYP3++ri5fX1/MmTOn1O4DRVXkNf3tt9/Qr18/eHp6QqFQwN/fH/Pnz9d9Xmr16tULoaGhOHfuHHr27Alra2sEBAToLhXv378fnTp1gpWVFYKDg/H333+X+JyvXLmCYcOGwc7ODk5OTpg6dSpyc3PLfS4VeS21nnjiCfzxxx9lXmquMEF6fvzxRwFAnDhxQm/74sWLBQCxdOlS3baePXuKnj17FnuMcePGiSZNmuh+jo6OFgBE27ZtRUBAgPjkk0/Ef//7X+Hs7Cy8vb1Ffn5+uXX17NlTACj3q2g9zz//vLCzsxO7d+8WQUFBAoBQKpVi8uTJIicnR+/xO3XqJJRKpVi7dq24efOmOHv2rBgyZIhwcnIS165dq9jJK6HmkJAQkZiYWOwrMzNTt9/Ro0eFXC4Xb775pm7b8OHDhZWVlYiIiNBtGzdunLC0tBSBgYFizJgxYvHixaJ///4CgHjnnXf0jj1p0iRhZmYmXnrpJbFs2TIxc+ZMoVQqxSOPPKJ3vps0aSICAgJEo0aNxKxZs8SyZcvE3r17dbeNGzdOt6/2vdGmTRvx1FNPiW+++UaMGTNGABBvv/226Natmxg5cqRYsmSJrq5Vq1ZVua7g4GDh5uYm5syZIxYvXizatWsnJEkSFy5cEEIIce3aNfHGG28IAGLOnDlizZo1Ys2aNSI+Pr7U12TXrl1CJpOJ0NBQ8fnnn4v//Oc/wt7eXrRo0ULvPavRaMTjjz8uJEkSkyZNEosXLxYDBgwQAMS0adP0HrNJkyaiX79+4tq1a8LMzEy8/vrrutv27t0rAIhNmzbptp07d05YWVmJxo0bi4ULF4r58+cLNzc30apVK1HZj6QVK1YIAOKPP/7Q237u3DkBQLz77ru6bQsWLBAAxMqVKyt1jJIUfV4jR44U3bt319125swZAUAcOXJE9OzZU7Ro0ULvvh9++KGQJEm88MILYsmSJWLevHnC2dlZ+Pr6inv37un2e/3118UzzzwjFixYIJYvXy4mTpwo5HK5GDJkiN7jdenSRdjb24u5c+eK7777TixYsEA89thjYv/+/bp9AIj33nuv2PMo7T3evHlz0bNnT/H111+Ljz/+WAghxOrVq4UkSeKpp54SX3/9tfjkk0+Er6+vcHBwENHR0brH0P6eNm/eXEyePFl88803okuXLgKA+PHHH4Wnp6eYMWOG+Prrr0WLFi2EXC4X169f190/KytLtGrVSjg5OYk5c+aIZcuWibFjxwpJksTUqVN1+1X0c/Xw4cPiiSeeEAB0vyNr1qwp8/Xt06ePaNeuXbHt7733nu6Yzz33nFiyZImYNGmS7jOgqHHjxgkAYsiQIeKbb74RY8eOFQDEoEGDyjy2EBV7TQcNGiSGDRsmFi1aJJYuXSqGDh0qAIi33npL77F69uwpPD09hY+Pj+68N2/eXMjlcrFhwwbh7u4u3n//ffHFF18ILy8vYW9vL9LT04s955YtW4oBAwaIxYsXi9GjRwsAYsyYMXrHevj9VNHXUmvt2rUCgDh//ny556g8DDcP0f5y//333yIxMVHExsaKzZs3CxcXF6FQKERsbKxu38qGGycnJ5GSkqLb/ttvv5X4wVySkydPit27d4tvvvlGABBr164Vu3fvFuPHjxc+Pj5i9+7dYvfu3eLkyZO6+7Rq1UpYW1sLa2tr8frrr4tffvlFvP766wKAGD58uN7jR0ZGinbt2ukFJT8/P3HlypVKnD19ZQWyV155RW/f2bNnC5lMJg4cOCA2bdokAIgvvvhCbx/th0XRP54ajUb069dPWFhYiMTERCGEEP/++68AINatW6d3/507dxbb3qRJEwFA7Ny5s1j9pX3w9+3bV2g0Gt32zp07C0mSxOTJk3XbVCqV8Pb21nt/VKWuAwcO6LYlJCQIhUIhpk+frtumPVfaQFaeNm3aCA8PD5Gamqrb9tdffwkAeu/ZX3/9VQAQH374od79hwwZIiRJElFRUXq19uvXTwghxIQJE4SlpaW4c+eOEKLkcDNo0CBhaWkpbt68qdt26dIlIZfLKx1uUlJShEKhECNGjNDbPmvWLAFALxzHx8cLFxcXAUCEhISIyZMni/Xr1+udi4oq+rz+/PNPIUmSiImJEUIIMWPGDOHn5yeEEMXCzY0bN4RcLhcfffSR3uOdP39emJmZ6W3Pzs4udtyFCxcKSZJ05+7evXsCgFi0aFGZ9VY23HTr1k2oVCrd9oyMDOHg4CBeeuklvfvHx8cLe3t7ve3a39MFCxbott27d09YWVkJSZLEhg0bdNuvXLlSrLb58+cLpVIprl69qnesWbNmCblcrjvPlflcDQsLq9R7y9vbWzz//PPFtmv/0L/44ot62wcPHiycnJx0P2sD7qRJk/T2e+uttwQAsWfPnlKPXdHXtKT3xyuvvCKsra1Fbm6ubpv2c3j9+vW6bdrzLpPJxNGjR3Xbd+3apQuhDz/ngQMH6h3rtddeEwDE2bNnddsefj9V9LXUOnz4sAAgfv755zKfe0XwslQp+vTpAxcXF/j4+GDIkCFQKpX4/fff9ZpoK+uFF15Ao0aNdD9rL3Vdv3693Pu2b98effr0gUqlgqenJ0aNGoU+ffogMTERvXv3Rp8+fdCnTx+0b99ed5/MzExkZ2dj7Nix+Oqrr/Dcc8/hq6++wiuvvIINGzYgMjJSt6+trS1atGiBsLAwbNmyBUuWLIFKpcKgQYOQlJRU5efs6+uL3bt3F/uaNm2a3n7vv/8+WrRogXHjxuG1115Dz5498cYbb5T4mEVHL0iShClTpiA/P1/XnLpp0ybY29vjiSee0F3KS0pKQvv27WFjY4O9e/fqPV7Tpk3Rt2/fCj+niRMn6jVrd+rUCUIITJw4UbdNLpejQ4cOeq9tZetq3ry57j0CAC4uLggODq7Q+6UkcXFxOHPmDMaNG6fXSfKJJ55A8+bN9fbdvn075HJ5sddg+vTpEEJgx44dJR5j7ty5UKlU+Pjjj0u8Xa1WY9euXRg0aBAaN26s296sWbNKvQZajRo10vV7ycrKAlDYb2rDhg3o0KEDgoKCdPu6ubnh7NmzmDx5Mu7du4dly5Zh5MiRcHV1xfz586vcFP7kk0/C0dERGzZs0B17xIgRJe67ZcsWaDQaDBs2TO894O7ujsDAQL33QNHLwVlZWUhKSkKXLl0ghMDp06d1+1hYWGDfvn012rfnpZde0ruktnv3bqSmpmLEiBF6dcvlcnTq1KnYexco7Kuo5eDggODgYCiVSr0+i9q+gw//nnTv3h2NGjXSO1afPn2gVqtx4MABveNU53O1NMnJyXqP+bDJkyfr/dy9e3ckJycjPT0dAHRDmv/v//5Pb7/p06cDALZt21bqY1f0NS36/sjIyEBSUhK6d++O7OxsXLlyRW9fGxsbDB8+XPez9rw3a9ZMr7+m9vuSzl1YWJjez9rRkWUN367sa6k959X5m6PFDsWl+OabbxAUFIS0tDT88MMPOHDgQLU7mBb9MAcevJDlfShlZmbqrm3u3r0bjz76KJKSkqDRaPDvv//iww8/1H3QFP2F1L75H/6gHTlyJJYvX44jR44gMDAQKpUKffr0Qa9evfD111/r9uvTpw9atGiBRYsW4ZNPPqnSc1YqlejTp0+5+1lYWOCHH37Q9cP48ccfS7wuLpPJ4Ofnp7dN+wdMez06MjISaWlpcHV1LfFYCQkJej83bdq0Ik9F5+HXURsUfHx8im0v+tpWtq6HjwMUvmeq+kfs5s2bAIDAwMBitwUHB+PUqVN6+3p6esLW1lZvv2bNmuk91sP8/PwwZswYrFixArNmzSp2e2JiInJyckqtoSrzXIwaNQpbt27Fb7/9hpEjR+Lw4cO4ceMGpk6dWmxfDw8PLF26FEuWLEFkZCR27dqFTz75BO+++y48PDz0/iBXlLm5OYYOHYr169ejY8eOiI2NxciRI0vcNzIyEkKIEp+/9rG0YmJi8O677+L3338v9ppr+9YpFAp88sknmD59Otzc3PDoo4+if//+GDt2LNzd3Sv9XLQe/p3Q/iNUWkdPOzs7vZ8tLS3h4uKit83e3h7e3t7Ffq9L+j05d+5csftrlfd7UtHP1fKUFXbLOqadnR1u3rwJmUyGgIAAvf3c3d3h4OBQ6u8PUPHX9OLFi5g7dy727NmjC1VaRfteAij1vJf0maV9Hg97+D3r7+8PmUxW5jQUlX0ttee8Jua7YrgpRceOHXWjpQYNGoRu3bph5MiRiIiI0A0XlSSpxF+Ahzt0aZXWubC8/xinTJmCVatW6W3bsmWL7vs33ngDb7zxBpo0aaL3RvP09MTFixdL7CgMPHgDHzhwABcuXMDnn3+ut19gYCCaNWuGQ4cOlVlfTdHO25Obm4vIyMhKhw4tjUYDV1dXrFu3rsTbH/5Fq2yH6dJex5K2F31tK1tXVd8vhvaf//wHa9aswSeffIJBgwbV+vH69+8Pe3t7rF+/HiNHjsT69eshl8v1/lN9mCRJCAoKQlBQEPr164fAwECsW7euSuEGKPyHYdmyZXj//ffRunXrYi1hWhqNBpIkYceOHSW+vtrPFrVajSeeeAIpKSmYOXMmQkJCoFQqcfv2bYwfP16vM+a0adMwYMAA/Prrr9i1axfeeecdLFy4EHv27EHbtm3LrLu0z6qHfye0x1uzZk2JocnMTP9PSWV+R4DivydPPPEE3n777RL3LdoaV9HHrCwnJ6cyw1FFj1nVP9Llvaapqano2bMn7Ozs8MEHH8Df3x+WlpY4deoUZs6cWayzbnVej9JU5LlV9rXUnvOiIw+riuGmAuRyORYuXIjHHnsMixcv1v1H2qhRoxKb78pK5VXx9ttvY/To0YiOjsbLL7+M1atXw8PDAxs3bsT27duxcuVKAMU/kNq3b4/du3fj9u3bCA4O1m3XjmbR/jG9e/cugJI/6AoKCnQToNWmc+fO4YMPPsCECRNw5swZTJo0CefPny82x4RGo8H169f1fimuXr0KALoRav7+/vj777/RtWvXWh3pVVm1UVdlPjybNGkCAHqXI7UiIiKK7fv3338jIyNDr/VG29ytfayS+Pv7Y/To0Vi+fHmxKQpcXFxgZWVVoRoqSqFQYMiQIVi9ejXu3r2LTZs24fHHH69wy4Wfnx8aNWqEuLi4Kh0fALp164bGjRtj3759ZbZy+vv7QwiBpk2bFvtgL+r8+fO4evUqVq1ahbFjx+q27969u9THnT59OqZPn47IyEi0adMGn332mW6CwUaNGiE1NVXvPvn5+RV+zv7+/gAK/zGqSEtsdfj7+yMzM7NGj1PZkBESEoLo6OgqH69JkybQaDSIjIzUtXYChZ+1qampZf7+aJX1mu7btw/JycnYsmWL3oiu6tRcnof/4YyKioJGoylzfq3Kvpba+oues6pin5sK6tWrFzp27IgvvvhCd4nI398fV65cQWJiom6/s2fP1nhLR/PmzdGnTx+YmZmhUaNGGD16NPr06YP09HR069ZN19+ma9euevfTXtv+/vvv9bZ/9913MDMz0w1j137IbtiwQW+/U6dOISIiotz//qqroKAA48ePh6enJ7788kusXLkSd+/exZtvvlni/osXL9Z9L4TA4sWLYW5ujt69ewMofN5qtRrz588vdl+VSlXsQ76u1EZd2vlHKnJfDw8PtGnTBqtWrdJrtt69ezcuXbqkt+8zzzwDtVqtd64B4H//+x8kScLTTz9d5rHmzp2LgoIC/Pe//9XbLpfL0bdvX/z666+IiYnRbb98+bKu5a4qRo0ahYKCArzyyitITEzUzW1T1LFjx3T9coo6fvw4kpOT9f4BqCxJkvDVV1/hvffew5gxY0rd77nnnoNcLse8efOK/XcshEBycjKAB/9RF91HCIEvv/xS7z7Z2dnFhuP6+/vD1tZWb8ixv79/sf4NK1asKLXl5mF9+/aFnZ0dFixYUOKw+6KfgdU1bNgwHDlypMT3Q2pqapX+2arM7wkAdO7cGRcuXKjQsO2SPPPMMwCAL774Qm+7tnW8X79+pd63Iq9pSe+P/Px8LFmypEr1VoR2OL2WtgtDWZ8FlX0tw8PDYW9vjxYtWlS7XrbcVMKMGTMwdOhQrFy5EpMnT8aLL76Izz//HH379sXEiRORkJCAZcuWoUWLFsWugdaEQ4cO4dFHH9X9F3L48GG89dZbpe7ftm1bvPjii/jhhx+gUqnQs2dP7Nu3D5s2bdKbSbZ9+/Z44oknsGrVKqSnp+PJJ59EXFwcvv76a1hZWRXr/CtJku6xypOWllbq9PTayf0+/PBDnDlzBv/88w9sbW3RqlUrvPvuu5g7dy6GDBmi+6AACq/l79y5E+PGjUOnTp2wY8cObNu2DXPmzNG1RPXs2ROvvPIKFi5ciDNnzuDJJ5+Eubk5IiMjsWnTJnz55ZcYMmRIubXXtNqoq02bNpDL5fjkk0+QlpYGhUKBxx9/vNR+PQsXLkS/fv3QrVs3vPjii0hJScHXX3+NFi1a6C0/MGDAADz22GP4z3/+gxs3bqB169b466+/8Ntvv2HatGm6/+RLo229efhyKgDMmzcPO3fuRPfu3fHaa69BpVLpajh37lylnr9Wz5494e3tjd9++w1WVlZ47rnniu2zZs0arFu3DoMHD0b79u1hYWGBy5cv44cffoClpSXmzJlTpWNrPfvss3j22WfL3Mff3x8ffvghZs+ejRs3bmDQoEGwtbVFdHQ0tm7dipdffhlvvfUWQkJC4O/vj7feegu3b9+GnZ0dfvnll2KXSq5evYrevXtj2LBhaN68OczMzLB161bcvXtX77LcpEmTMHnyZDz//PN44okncPbsWezatavCzf92dnZYunQpxowZg3bt2mH48OFwcXFBTEwMtm3bhq5duxYLwlU1Y8YM/P777+jfvz/Gjx+P9u3bIysrC+fPn8fmzZtx48aNSl+20A60eOONN9C3b99yL1s+++yzmD9/Pvbv348nn3yy0s+hdevWGDduHFasWKG7hHT8+HGsWrUKgwYNwmOPPVbqfSvymnbp0gWNGjXCuHHj8MYbb0CSJKxZs6ZWL1lHR0dj4MCBeOqpp3DkyBGsXbsWI0eOROvWrUu9T2Vfy927d2PAgAE1s8ZctcdbGZnS5rkRQgi1Wi38/f2Fv7+/bpjk2rVrhZ+fn7CwsBBt2rQRu3btKnUoeElD+1DKEM2ShISEiPnz5wshhLh161apdRaVn58v3n//fdGkSRNhbm4uAgICxP/+979i+2VnZ4sPPvhANG/eXFhZWQl7e3vRv39/cfr0ab39MjIyShxKXpLy5uYRQojw8PBic6MIUTiU+pFHHhGenp66uT/GjRsnlEqluHbtmnjyySeFtbW1cHNzE++9955Qq9XFjr9ixQrRvn17YWVlJWxtbUXLli3F22+/rRumLIT+MOaHlTZM9uFzrh0qqR2KrqWttybrKmn6gW+//Vb4+fnphlKXNyz8l19+Ec2aNRMKhUI0b95cbNmypdh7VojC1/rNN98Unp6ewtzcXAQGBopFixbpDYMvq9bIyEhdTUWHggshxP79+0X79u2FhYWF8PPzE8uWLdOdx6qaMWOGACCGDRtW4u3nzp0TM2bMEO3atROOjo7CzMxMeHh4iKFDh4pTp05V6lglDXEvSUnz3AhR+Bp069ZNKJVKoVQqRUhIiAgLC9Mbun7p0iXRp08fYWNjI5ydncVLL70kzp49qzdUNykpSYSFhYmQkBChVCqFvb296NSpk9i4caPe8dRqtZg5c6ZwdnYW1tbWom/fviIqKqrC7/Giz7tv377C3t5eWFpaCn9/fzF+/Hi9KShKe9+Xdi5Kev9kZGSI2bNni4CAAGFhYSGcnZ1Fly5dxKeffqqbv6Yyn6sqlUq8/vrrwsXFRUiSVKH3WatWrcTEiRP1tpX2u649b0Xn+ykoKBDz5s0TTZs2Febm5sLHx0fMnj1bb5h2SSr6mh46dEg8+uijwsrKSnh6eoq3335bN5S76GdAZc67EIXnLiwsrNhzvnTpkhgyZIiwtbUVjRo1ElOmTCk2X9rD7ychKvZaCiHE5cuXddOw1ATp/pMhqpDt27ejf//+OHv2LFq2bFmnxx4/fjw2b95cqQUOiYiqYs2aNQgLC0NMTIxuqRtT9P7772PevHlITEyskY6+pZk2bRoOHDiA8PDwGmm5YZ8bqpS9e/di+PDhdR5siIjq0qhRo9C4ceNifU2o5iUnJ+O7777Dhx9+WDOXpMA+N1RJixYtMnQJZALS0tKKraH0sOrM41KanJycYnOEPMzR0bFKi2xSwyKTyXDhwgVDl2ESnJycarxFnuGGiOqdqVOnltgZuajauKL+888/Y8KECWXus3fv3hIXzCWi+oN9boio3rl06VK5q4vXxnwrcXFxxVa5flj79u3LnJqfiAyP4YaIiIiMCjsUExERkVExuT43Go0Gd+7cga2tbY31yiYiIqLaJYRARkYGPD09IZOV3TZjcuHmzp07xVZCJSIiooYhNjYW3t7eZe5jcuFGuwhgbGws7OzsDFwNERERVUR6ejp8fHz0FvMtjcmFG+2lKDs7O4YbIiKiBqYiXUrYoZiIiIiMCsMNERERGRWGGyIiIjIqDDdERERkVBhuiIiIyKgw3BAREZFRYbghIiIio8JwQ0REREaF4YaIiIiMCsMNERERGRWGGyIiIjIqDDdERERkVBhuqJjcAjWEEIYug4iIqEpMblVwKi4rT4UTN1Jw5HoyjlxLxoXbafCwt8KnQ1ujs7+TocsjIiKqFIYbE5RboMapm/dw5HoyDl9LxtnYVKg0+i01t1NzMPK7o5jc0x9v9gmChRkb+YiIqGFguDEB+SoNzt5KxeGoZBy5noRTManIV2n09vFuZIXOfk7oEuCENj6NsHz/NWw4EYul+67hYGQSvhjeBv4uNgZ6BkRERBUnCRPrXJGeng57e3ukpaXBzs7O0OXUCpVagwt30nH4WhKOXEvGyRv3kFOg1tvHzU6BLv7O6OznhM7+TvBxtC72ODsvxGHWlvNIzS6Albkc7/RvjhEdfSBJUl09FSIiIgCV+/vNcGMENBqBS3HpOHr/MtPx6BRk5qn09nFSWuBRf6fC1hl/JzR1VlYopMSn5WL6pjM4FJUMAHiiuRs+fq4lnGwUtfJciIiISsJwUwZjCDdCCEQmZOJwVBKOXE/GsegUpGYX6O1jb2WOTk0d0cXfCZ39nRHkZlPlFheNRuD7g9FYtCsC+WoNXGwV+Gxoa/QIcqmJp0NERFQuhpsyNMRwI4RAdFKWbjTT0evJSMrM19tHaSFHx6aOhZea/J3QzMMOclnNXj66eCcNUzecQVRCJgDgxa5N8fZTwbA0l9focYiIiB7GcFOGhhJuYlOydWHmyLVkxKfn6t1uaS7DI76OePT+ZaaWXvYwk9f+iKbcAjUWbr+MVUduAgBC3G3xxfA2CHGvv+eSiIgaPoabMtTXcHM3PRdHriUXdgK+nozYlBy92y3kMrRt7IDO/k7o4u+M1j72UJgZrsVk75UEzNh8FkmZ+bAwk2HWUyEY38UXshpuLSIiIgIYbspUX8JNUmYejhZpmbmelKV3u5lMQitve91lpvZNGtW7yz+JGXl4e/NZ7I1IBAD0CHLBp0NawdXO0sCVERGRsTHqcPP+++9j3rx5etuCg4Nx5cqVCt3fUOEmLbsAR6MfhJmIuxl6t0sSEOppjy7+TnjU3wmP+DrCRlH/pyESQmDt0Zv4cNtl5Kk0cFRa4JPnW+GJ5m6GLo2IiIxIZf5+1/+/niVo0aIF/v77b93PZmb172lk5qlwIjpFd5np4p10PBwjQ9xtdZeZOjZ1hL2VuWGKrQZJkjCmsy8e9XPC1A1ncCkuHS+tPomRnRpjbr9msLaof68NEREZtwb5l8fMzAzu7u6GLkNPTr4aJ2+m3O83k4zzt9OgfmhJA38XpS7MdGrqaFRzxQS62WJrWBd89tdVrDhwHeuPxeDo9WR8+UJbtPS2N3R5RERkQhpkuImMjISnpycsLS3RuXNnLFy4EI0bNy5x37y8POTl5el+Tk9Pr5Wa9l9NxOS14XrbGjta359nxgmP+jnBzcj7oijM5JjzTDP0CHTB9E1ncD0xC4OXHML0J4Pxcg+/Gh+aTkREVJIG1+dmx44dyMzMRHBwMOLi4jBv3jzcvn0bFy5cgK2tbbH9S+qjA6DG+9ykZuej31cH0cnPUbekgXej4ksamIp7WfmYs/U8dlyIBwA86ueIz4e1gaeDlYErIyKihsioOxQ/LDU1FU2aNMHnn3+OiRMnFru9pJYbHx8fg4+WMgVCCGw6eQvv/3ER2flq2FmaYcFzLdG/laehSyMiogamMuGm9md9q2UODg4ICgpCVFRUibcrFArY2dnpfVHdkCQJwx7xwfY3uqO1jwPSc1WYsv40pm88i4zcgvIfgIiIqAoafLjJzMzEtWvX4OHhYehSqBS+zkpsntwZrz8eAJkE/HLqFp756l+E37xn6NKIiMgINbhw89Zbb2H//v24ceMGDh8+jMGDB0Mul2PEiBGGLo3KYC6XYfqTwfj5lc7wcrBCbEoOhi0/gv/tvgqVWmPo8oiIyIg0uHBz69YtjBgxAsHBwRg2bBicnJxw9OhRuLhwheqG4BFfR+yY1h2D2nhCrRH48p9IDFt+BDHJ2YYujYiIjESD71BcWfVl+QUCfjtzG3O3XkBGngo2CjPMG9gCz7XzgiRxyDgREekzqQ7F1HA928YL26d2xyO+jZCZp8L0TWcx5afTSMtmZ2MiIqo6hhsyKB9Ha2x4uTNm9A2GmUzCtnNxeOrLAzhyLdnQpRERUQPFcEMGJ5dJCHssAL+82gVNnZWIS8vFyO+O4uMdV5CvYmdjIiKqHIYbqjda+zjgz9e7YfgjPhACWLb/Gp5begjXEjMNXRoRETUgDDdUrygVZvj4+VZYNrodHKzNceF2Ovp99S/WHbsJE+v7TkREVcRwQ/XSU6Ee2Dm1B7oFOCO3QIP/bL2Al1aHIzkzr/w7ExGRSWO4oXrL3d4Sq1/siLn9msFCLsPfl+/iqS//xb6IBEOXRkRE9RjDDdVrMpmESd398GtYVwS62iAxIw/jfzyBeX9cRG6B2tDlkQkSQiA7X2XoMoioDAw31CA097TDH693w7jOTQAAPx66gWcXH8KV+HQDV0ampECtQdj6U2j5/l84eSPF0OUQUSkYbqjBsDSXY96zofhx/CNwtrFAxN0MDFx8CD8cjIZGw87GVLvUGoHpG89i+/l4qDUCPxyKNnRJRFQKhhtqcB4LccXOaT3weIgr8lUafPDnJYz78TgS0nMNXRoZKSEE5v56Hr+fvQO5rHB5kN2X7rKDO1E9xXBDDZKzjQLfj+uA+YNCoTCT4d/IJPT94gD+uhhv6NLIyAgh8NG2y/jpeCxkEvDV8LZo6WWPArXA1tO3DV0eEZWA4YYaLEmSMObRJvjz9W5o7mGHe9kFeHlNOOZsPc8On1Rjvvg7Et8dLLwE9cnzrdCvlQeGdfAGAGw8Gcv5l4jqIYYbavAC3WyxNawLXu7hBwBYfywG/b86iPO30gxcGTV03x64ji//iQQAvD+gOYZ28AEADGzjBYWZDFfvZuIs32dE9Q7DDRkFhZkcc55phnWTOsHdzhLXk7IweElhZ2Oiqlh/LAYfbb8MAJjRNxjjuzbV3WZvZY6nQ90BAD+fiDVIfURUOoYbMipdA5yxY2p3PB3qDpVG4IM/L+HiHf5nTZXz6+nb+M+v5wEAr/byR9hjAcX2GfZIYSvOH2fv8DIoUT3DcENGp5HSAktGtUO/lh4ACi8tEFXUXxfjMX3TWQgBjO3cBG/3DS5xv0ebOsHH0QqZeSrsOM+O7ET1CcMNGSVJkvBqL38AwB/n4nA7NcfAFVFD8G9kIqasPw21RuD5dt54f0ALSJJU4r4ymYRh7Qtbb34+yUtTRPUJww0ZrVAve3TxdyqccI19b6gcJ26k4OXV4chXa/B0qDs+eb4lZLKSg43WkA7ekEnA8egURCdl1VGlRFQehhsyatoRVD8dj0FadoGBq6H66vytNLz44wnkFKjRM8gFXw5vCzN5+R+PHvZW6BHkAqBwWDgR1Q8MN2TUega5IMTdFtn5aqw9dtPQ5VA9FHk3A2N/OIaMPBU6NnXEstHtYWFW8Y/GYfeHh/8Sfgsqtaa2yiQjJ4TAiRspyMxj5/SawHBDRk2SJF3rzcrDN7iSOOm5mZyFUd8dw73sArT2tsf34zrAykJeqcfo08wNjkoLJGTkYf/VxFqqlIzd6iM3MXTZEXy847KhSzEKDDdk9Aa09oSHvSUSM/LwK6fLp/vi0nIw8ttjSMjIQ7CbLVa92BG2luaVfhwLMxkGt/UCwDlvqGpyC9RYvDcKAHDyxj0DV2McGG7I6JnLZZjYrXACthX/XucK4oSkzDyM+u4YbqfmoKmzEmsmdYSDtUWVH097aWrPlQQkZnAxTaqcdcdidO+ba4mZKODlzWpjuCGTMLxjY9hamuF6Yhb+uZJg6HLIgNKyCzDm++O4npgFLwcrrJ3UCa62ltV6zGB3W7T2cYBKI7D19K0aqpRMQW6BGsv2X9P9XKAWuMGRd9XGcEMmwUZhhlGdmgAAlhf5ICHTkpmnwviVx3E5Lh3ONgqsndQJXg5WNfLYL9xvvfn5BBfTpIrTttp4OVgh1MsOAHD1bqaBq2r4GG7IZEzo6gsLuQwnb95D+E1e1zY1uQVqvLTqJE7HpMLB2hxrJ3VEU2dljT3+gNYesDKX41piFk7F8P1F5SvaajPl8QC08LAHAETczTBkWUaB4YZMhpudJQa19QQArDjA1htTUqDWIGzdKRy5ngwbhRlWTeiIEHe7Gj2GraU5nrm/5Ac7FlNFFG21eb6dN4LcbQEUTk9A1cNwQyZFOyz8r0t3cT2RTb+mQK0RePPnM/jnSgIUZjJ8P64DWvs41MqxXri/mOaf5+KQxflKqAwPt9pYmMkQ7FYYbthyU30MN2RSAlxt0aeZK4QAvv2XSzIYO41GYPaWc/jzXBzM5RKWj2mPTn5OtXa8R3wboamzEtn5amw7F1drx6GG7+FWGwAIcrMBANxIyuKcXNXEcEMm5+UehQtq/nLqFoftGjEhBOZvu4SNJ29BJgFfDW+LXsGutXpMSZIwtEPhHyoupkmlKanVBgBcbBVwsDaHRgDXEzliqjoYbsjkPOLbCG18HJCv0mD1kRuGLodqyee7r+LHQzcAAIuGtMbT9/vD1LYh7bwhl0kIv3kPUQm8vEDFldRqAxSG4yDXwktTV3lpqloYbsjkSJKEV+73vVl95Cb7RhihZfuv4es9hTO+zn+2BZ5v713OPWqOq50lHgsuXExz00nOeUP6Smu10QpyL7w0xXBTPQw3ZJKebOEOXydrpOUUcDVnI7Pm6E18vOMKAGDmUyEY09m3zmsYql1M89QtzjZLetaX0mqjFeTGlpuawHBDJkkukzCpe2HrzXf/RnM1ZyOx5dQtvPPrBQDAlMcC8Govf4PU8XiIK5xtFEjKzMcezohN9+UWqLG0jFYb4EG44Yip6mG4IZM1pL03nJQWuJ2ag23nObKlodt5IQ5vbToLABjfxRfTnwwyWC3mchmeb1e4mOZGznlD95XXagM8CDexKTnIzucl86piuCGTZWkux7guvgCAFQeuc8r8Bmz/1US8/tNpaAQwtL033u3fHJIkGbQm7aWpvREJuJuea9BayPCKttqEPVZyqw0AOCot4GyjAABEchmGKmO4IZM25tEmsDKX4+KddBy+lmzocqgKjl1PxitrTqJALdCvpQc+fr4VZDLDBhsACHC1QfsmjaARhX1vyLQVbbUZUk4H92B2Kq42hhsyaY2UFhh2f16SZVxQs8E5G5uKiatOIrdAg8dDXPG/F9pAXg+CjZZ2Mc1NJ2+xZdCEVbTVRiuQw8GrjeGGTN6k7n6QScC/kUm4dCfd0OVQBUXEZ2Dcj8eRmadCZz8nLBnVrtw/GnWtXysPKC3kiE7KwvHoFEOXQwZSmVYbAAh213Yq5mWpqqpfnwREBuDjaK1b8PDbf68buBqqiOikLIz+/hhSswvQxscB347rAEtzuaHLKkapMEP/VoWLtW7knDcmqbKtNsCDTsVcQLPqGG6IALxyf0mGP87ewe3UHANXQ2W5nZqD0d8dQ2JGHkLcbbFqQkfYKMwMXVaphj1S+J/69vNxyMgtMHA1VNcq22oDAIH315iKS8tFWg7fM1XBcEMEoKW3Pbr4O0GlEfjhIBfUrK8SM/Iw+rtjuJ2aAz9nJdZM7AR7a3NDl1Wmdo0bwd9FiZwCNf44yykHTElVWm0AwM7SHJ72lgDAJTyqiOGG6L6X7y/JsOF4DP9bqodSs/Mx5vtjiE7KgpeDFdZO6gQXW4WhyyqXJEl44ZHCjsVcTNO0/HS88q02WoHayfzi2e+mKhhuiO7rGeSCEHdbZOWrse7YTUOXQ0Vk5qkw7scTuBKfARdbBdZN6gRPBytDl1Vhg9t6w0wm4WxsKiLi+Z+4KcgtUGPpvsq32mhpOxVzxFTVMNwQ3SdJEl66vyTDj4duIE+lNnBFBBT+kZi48gTOxqaikbU51k3qBF9npaHLqhQXWwUeD3EFAK5lZiJ+Oh6DhCq22gBcY6q6GG6IihjQ2hMe9pZIzMjDr6dvG7ock5ev0mDy2nAci06BrcIMq1/spPvQb2i0l6a2nr6NfBXXMjNmRVttXnvMv0pTFAS5cSK/6mC4ISrCwkyGF7s2BVC4JINGw4nXDEWl1mDaz6exLyIRluYy/DDhEbT0tjd0WVXWM8gFrrYKpGTl4+/Ldw1dDtUibauNp70lhrb3qdJjBLjaQJKApMx8JGfm1XCFxo/hhughwzv6wFZhhmuJWfiHKzobhEYjMGvLeWw/Hw8LuQwrxnTAI76Ohi6rWszkMt3lCV6aMl56fW1KWfm7IqwtzODTyBoAcJWT+VUaww3RQ2wtzTHq0SYAgBUHuCRDXRNCYN4fF7E5/BbkMglfj2yLHkEuhi6rRmgX0zxwNRFxaZxPyRjVRKuNlm4yPw4HrzSGG6ISTOjqC3O5hBM37iH85j1Dl2NSFu2KwKojNyFJwKdDW6FvC3dDl1Rjmjor0bGpIzQC2MwZi41OTbXaaGn73XCEXeUx3BCVwM3OEoPaeAFg601d+mZvFJbc/+Pw4aBQDG5b+VEm9Z12Mc2N4bHs02VkarLVBuBw8OpguCEqhXZSv78u3cX1RF7zrm2rDt/Aol0RAIA5z4RgVKcmBq6odjzT0gM2CjPEpuTgaHSyocuhGlLTrTZA0eHgmVxVvpIYbohKEehmi94hrhAC+I5LMtSqTSdj8d7vFwEAb/QOxMv31/oyRlYWcgxofX8xzRPsWGwsNtRwqw0A+LkoIZdJSMspQEIGR0xVBsMNURm0rTebw28hkR8utWLbuTjM/OUcAODFrk3xZp9AA1dU+7Rz3uy4EM+lPoxAboFadzm1plptAEBhJoevk3bEFC9NVQbDDVEZOjZ1RBsfB+SrNFh95IahyzE6e68kYNrPp6ERwPBHfPBO/2aQJMnQZdW61t72CHazRZ5Kg9/PcLLIhq42Wm20gnRrTDHcVAbDDVEZJEnCK/dbb9YcvYnsfJWBKzIeR64lY/LacBSoBQa09sRHg1uaRLABCt9Xw+633mzkqKkGrbZabbS4DEPVMNwQlePJFu7wdbJGanYB+0jUkNMx9zBp1QnkqTTo08wVnw9rDbnMNIKN1uC2XjCXSzh/Ow2X7qQbuhyqotpstQGKjpjioIbKYLghKodcJmHi/QU1vzsYDZWa6wJVx+W4dIz/8QSy8tXoGuCExSPbwVxueh9FjkoLPNHcDQBnLG6oirbavFaFlb8rQjvXTeTdDI6YqgTT+0QhqoKh7b3hpLTArXs52H4h3tDlNFjXEzMx5vtjSMspQLvGDlgxpgMszeWGLstghnV4sJhmbgFXoW9o9FptOtTOnExNnJSwkMuQla/G7VTOal1RDDdEFWBpLsfYzr4ACif1439QlXfrXjZGf3cMSZn5aO5hhx8ndIRSYWbosgyqe6ALPOwtkZZTgN2XuJhmQ/Jwq43CrHZCurlcBj8XJQD2u6mMehNuPv74Y0iShGnTppW6T0FBAT744AP4+/vD0tISrVu3xs6dO+uuSDJpYzo3gaW5DBdup+PwNU6+VhkZuQUY/+MJ3EnLhb+LEmsmdoS9lbmhyzI4uUziYpoNVF202mg9GDHFfjcVVS/CzYkTJ7B8+XK0atWqzP3mzp2L5cuX4+uvv8alS5cwefJkDB48GKdPn66jSsmUOSotdFPnLz9w3cDVNBwajcBbm84iKiET7naWWDupE5xsFIYuq97QdkI9GJWEW/eyDVwNVURdtdpoaTsVR7LlpsIMHm4yMzMxatQofPvtt2jUqFGZ+65ZswZz5szBM888Az8/P7z66qt45pln8Nlnn9VRtWTqJnX3g0wqXNX5chxHuFTE0v3XsOviXVjIZVg6uh087K0MXVK90tjJGl38nSAEsInDwhuEumy1AYBA1/sLaDLcVJjBw01YWBj69euHPn36lLtvXl4eLC0t9bZZWVnh4MGDtVUekR4fR2s83dIDALCCrTfl2huRgE//Klwv6oNnW6Bt47L/gTFV2hmLN4ff4mKa9VxugRpL99ddqw3woOUmKiETar4/KsSg4WbDhg04deoUFi5cWKH9+/bti88//xyRkZHQaDTYvXs3tmzZgri4uFLvk5eXh/T0dL0vourQTur3x9k7uMPRC6W6mZyFqT+dhhDAiI6NMbxjY0OXVG/1beEOW0sz3E7NwaFrSYYuh8rw84lY3E2vu1YbAPBpZA1LcxnyVBrEpPDSZUUYLNzExsZi6tSpWLduXbHWmNJ8+eWXCAwMREhICCwsLDBlyhRMmDABMlnpT2PhwoWwt7fXffn41PwkS2RaWnk7oLOfE1QagR+4oGaJsvNVeGVNONJzVWjb2AHvD2xu6JLqNUtzOQa18QJQ+MeT6qfCvjZRAOqu1QYAZDIJga5chqEyDBZuwsPDkZCQgHbt2sHMzAxmZmbYv38/vvrqK5iZmUGtLj7ng4uLC3799VdkZWXh5s2buHLlCmxsbODn51fqcWbPno20tDTdV2wsPzio+l7uWfie++l4DBc+fIgQAm9vPocr8RlwtlFg2ej2dfZHoCHTXpr66+Jd3MvKN3A1VBJDtNpoBRaZzI/KZ7Bw07t3b5w/fx5nzpzRfXXo0AGjRo3CmTNnIJeX/mFoaWkJLy8vqFQq/PLLL3j22WdL3VehUMDOzk7vi6i6egW5INjNFln5aqw7dtPQ5dQr3/0bjT/PxcFMJmHp6HZws6tYy6ypC/WyR3MPO+SrNfiNi2nWO0VbbV6tw1YbrWDtcHCGmwoxWLixtbVFaGio3pdSqYSTkxNCQ0MBAGPHjsXs2bN19zl27Bi2bNmC69ev499//8VTTz0FjUaDt99+21BPg0yUJEl4+X7fmx8P3UCeirPLAsChqCQs3HEZAPDugOZ4xNfRwBU1LMPutwb8fPIWJ4qsZ7StNh72lrrXqS4F6YaDc66bijD4aKmyxMTE6HUWzs3Nxdy5c9G8eXMMHjwYXl5eOHjwIBwcHAxXJJmsAa094W5nicSMPPx2+o6hyzG4W/eyMWX9KWgEMKS9N8Y82sTQJTU4g9p6wcJMhstx6bhwm4Mf6gtD9bUpSjuR37XETOSruL5deerV3Of79u0r8+eePXvi0qVLdVcQURkszGR4sZsvFmy/guUHrmFIe2/ITGxla63cAjVeWROOe9kFaOlljw8HhUKSTPNcVIeDtQX6tnDHH2fv4OeTMWjp3dLQJREM32oDAJ72lrBRmCEzT4UbyVm6sEMlq9ctN0T13YiOjWGrMMO1xCzsuZJg6HIMQgiBOVvP4+KddDgqLbBsTHuTXgyzurSzYP925g4X06wH6kOrDVB4KVzbqZhrTJWP4YaoGmwtzTHy0cL5W0x1Ur9Vh29gy6nbkMskLB7ZFl4OnIG4Orr4O8HLwQoZuSrs5Ar0BlcfWm20tJ2Kr3I4eLkYboiq6cWuTWEul3D8RgpOxdwzdDl16tj1ZHy4rbAD8eynQ9DF39nAFTV8MpmkG2bMOW8MK7dAjaV1uIZUebSXoq6yU3G5GG6IqsnNzlI3AduK/abTehOXloOw9aeg0gg828YTE7s1NXRJRmNoBx9IEnDkejJuJmcZuhyTtfFkLOLTc+tFqw1QNNyw5aY8DDdENUA7LHzXpXhEJxn/H6M8lRqT155CUmY+Qtxt8fFzrdiBuAZ5OVihW0BhK9jmcC6maQi5BWos2Vt/Wm0AIMi9sM/NjeQs9scqB8MNUQ0IdLPF4yGuEAL49l/jb71577eLOBubCnsrc6wY0wFWFob/4Dc2wzo8WEyTiyXWvfrWagMALjYKOFibQyMKh4RT6RhuiGqIdkHNzeG3kJSZZ+Bqas/6YzHYcCIWkgR8NaItGjtZG7oko/RkCzc4WJsjLi0XByITDV2OSamPrTZA4YgpXpqqGIYbohrSsakjWvs4IF+lwerDNwxdTq0Iv3kP7/1+AQAwo28wega5GLgi46Uwe7CY5kZ2LK5T9bHVRiuYnYorhOGGqIZIkqRrvVl99Cay81UGrqhmJWTk4rV14ShQCzwd6o5Xe/obuiSjp7009fflu0g24tbA+kSv1aaXf71ptdEK0s51w+HgZWK4IapBfVu4o4mTNVKzC4zqv+18lQZh607hbnoeAl1tsGhoa3YgrgPNPe3Q0sseBWqBrae5mGZd0LbauNtZYtj9ldrrE91lqQSGm7Iw3BDVILlMwqTuha033x2MhkptHGvAfLjtEk7cuAdbhRmWj2kPG0W9WrnFqGn/wG48GcvFNGtZ0VabsMfqX6sN8CDcxKbkICvPuFqHaxLDDVENG9reG45KC9y6l4MdRjDD7KaTsVh95CYA4IvhbeDnYmPgikzLwNaeUJjJcPVuJs7Ephq6HKNW31ttAKCR0gIutgoAQGQC+92UhuGGqIZZmssxtnPhitjLD1xr0P9tn7uViv/8WtiBeFqfQPRu5mbgikyPvZU5nmnpAQDYeJJz3tSWPFX9b7XRCuIaU+ViuCGqBWM7+8LSXIYLt9Nx5FqyocupkuTMPExeE458lQZ9mrnijccDDV2SydIux/DH2TtG11G9vth4ov632mgFcY2pcjHcENUCR6WFbqTL8ga4oKZKrUHY+lO4k5YLP2clPn+hDWQydiA2lEebOqGxozUy81TYfr7hX+qsb/JUanzTQFptgCLDwXlZqlQMN0S1ZFI3P8gkYP/VRFyOSzd0OZXy8Y4rOHo9BUoLOZaPaQ87S3NDl2TSZDJJN9+KMY3Cqy8aUqsNUDgjOsCWm7Iw3BDVksZO1nj6fl+JbxtQ681vZ27ju4PRAIDPhrXWfZCSYT3f3hsyCTh+IwXXOfV+jWlorTbAgz438em5SMspMHA19RPDDVEt0k7q9/vZO7iTmmPgasp36U46Zv5yDkDhBGZPhXoYuCLS8rC3Qo/7M0Jv4mKaNaahtdoAgK2lOTztLQEAkexUXCKGG6Ja1MrbAY/6OUKlEfjhfmtIfZWanY9X1p5EboEGPYJcMP3JYEOXRA954X4/rl/CbxnNHEqGVLTV5rUG0mqjFeRe2KIawXBTIoYbolr2yv1lCn46HlNvm5DVGoHXfzqN2JQcNHa0xlfD20DODsT1Tu9mbnBSWiAhIw/7IriYZnXptdp0aBitNlraTsWRXGOqRAw3RLWsV5ALgt1skZWvxvpjMYYup0Sf/hWBfyOTYGVe2IHYwdrC0CVRCSzMZBjc9v5imifZsbg6Hm61sTRvOK02wINOxRHsVFwihhuiWiZJEl663/fmx0PRyFOpDVyRvh3n47B0X+GH/CdDWqGZh52BK6KyaPuF7LmSgMQMLqZZVQ251QYoujo4w01JGG6I6sDA1p5wt7NEQkYefjt9x9Dl6Fy9m4Hpm84CAF7q3hQDW3sauCIqT5CbLdr4OEClEdhyih2LqyJPpcaSfQ231QYAAlxtIElAclY+krhifDEMN0R1wMJMhhe7+QIAVvx7HRqN4ZdkSMspwCtrwpGdr0YXfyfMfCrE0CVRBb1wv/XmZy6mWSUbT95CXFrDbbUBACsLORo7WgNg601JGG6I6siIjo1hqzBDVEIm9kYkGLQWjUbg/34+g+ikLHg5WOHrEW1hJufHQUPRv5UHrMzluJ6YhVMx9wxdToNSuIZUFICG22qjFcROxaXipxlRHbG1NMfITo0BAMv3G3ZSvy//icQ/VxJgYSbDstHt4WSjMGg9VDm2lg8W0/yZMxZXijG02mhpJ/PjcPDiGG6I6tCErk1hLpdw/EYKThvoP+7dl+7iy38iAQALB7dES297g9RB1aO9NPXnuThk5nExzYowplYbgAtoloXhhqgOudtb4tk2hUN5VxhgSYZriZn4v5/PAADGdW6C59t713kNVDMe8W0EP2clsvPV2Hau/nRSr8+MqdUGKBJu7maw79VDGG6I6tjL94eF77wYj+ikrDo7bmaeCq+sCUdGngodfR0xt3/zOjs21TxJkjD0/h/ojSc5aqo8RVttXu3V8FttAMDPRQm5TEJ6rgp30zliqiiGG6I6FuRmi8dDXCEE8N2/ddN6I4TAWxvPIiohE252Ciwe1Rbm7EDc4D3fzgtymYTwm/cQlcBLE2XRttq42Sl0l/QaOoWZHL5OHDFVEn66ERmAtvVmc/itOpmjYsm+a9h5MR4WchmWjm4PV1vLWj8m1T5XO0s8Fly4mCZbb0qn19emV4BRtNpoBbtzMr+SMNwQGUCnpo5o7W2PPJUGqw/fqNVj7YtIwKd/RQAA5j3bAu0aN6rV41Hd0vYd2XLqFgq4mGaJjLHVRiuIMxWXiOGGyAAkSdItqLn66E1k59fOaJebyVl446fTEAIY0dEHIzo2rpXjkOE8FuIKZxsFkjLzseeKYedPqo+MudUGeBBuIjjXjR6GGyID6dvCHU2crJGaXYBNtXBJITu/sANxeq4KbXwc8P7AFjV+DDI8c7kMz7e/v5gm57wpxphbbYCiE/ll1IuZz+sLhhsiA5HLJEzq1hQA8O2/16GqwUsKQgjM/OU8rsRnwNlGgWWj20NhZlz/sdIDQ9sX/tHeG5GAu+m5Bq6m/shTqbHUiFttAMDXyRoWchmy89W4nZpj6HLqDYYbIgMa0t4HjkoL3LqXgx0X4mvscb8/GI0/zt6BmUzCklHt4G7PDsTGLMDVBh2aNIJGFHZSp0KbTt7CHSNutQEAM7kMfi5KAOx3UxTDDZEBWVnIMbZzEwCFk/rVxERch6OSsGD7ZQDAO/2bo2NTx2o/JtV/w+7/8d7ExTQBGH9fm6IejJhivxsthhsiAxvb2ReW5jKcv52GI9eTq/VYt+5lY8pPp6ERwPPtvHXBiYxfv5YeUFrIcSM5G8ejUwxdjsGZQquNFkdMFVelcJOXl4cDBw5gzZo1WL58ObZs2YLo6Oiaro3IJDgqLXR9JqqzoGZugRqT14YjJSsfoV52+GhwKCRJqqkyqZ5TKszQv5UnAODnk6bdsdiUWm2AIiOmuMaUTqXCzaFDhzBs2DA4ODjg8ccfx7Rp0zB//nyMHj0aAQEBCAwMxKJFi5CRwRNMVBmTujeFTAL2X03Elfj0St9fCIE5W8/jwu10OCotsGx0e6P/QKfitJemtp+PQ3pugYGrMRxTarUBHqwOHpWYCTVHTAGoRLgZOHAgXnjhBfj6+uKvv/5CRkYGkpOTcevWLWRnZyMyMhJz587FP//8g6CgIOzevbs26yYyKk2clHg61ANA1RbUXH3kJracug2ZBCwe0RbejaxrukRqANo1dkCAqw1yCzT482ycocsxCL01pHoaxxpS5fFpZA1LcxnyVRrcTK679erqswqHm379+iE6Ohr//e9/0b17d1hZWend7ufnh3HjxmHnzp34559/IJOxOw9RZWiXZPj9zB3cqcSQzuPRKZj/5yUAwJxnmqFLgHOt1Ef1nyRJeOH+jMWmemlK22rjaqvAcBOZtFImk4r0u2GnYqAS4eaVV16pcGBp3rw5evfuXeWiiExRax8HPOrnCJVG4MdDFevDFp+Wi9fWhUOlERjQ2hMT78+bQ6ZrcDsvmMkknI1NNbk+GPp9bUyj1UYr0JWdiouqVPOKl5cXZs2ahatXr9ZWPUQm7ZUehUsy/HQ8Fmk5ZfeZyFMVdiBOysxHiLstPnm+JTsQE5xtFOjdzBUA8LOJzVhsiq02WsHuhf1uIhhuAFQy3ISFhWHz5s1o1qwZunfvjpUrVyI7O7u2aiMyOb2CXRDkZoPMPBXWH4spc9/3f7+IM7GpsLcyx4oxHWBtYVZHVVJ9p+1Eu/X0LeSrTGMxzXyVxmRbbQAgsMgyDFTJcPPOO+8gKioK//zzD/z8/DBlyhR4eHjgpZdewrFjx2qrRiKTIUkSXupe2Pfmx0PRyFOpS9xv/bEY/HQ8FpIEfDm8DRo7sQMxPdAj0AVudgrcyy7A35fvGrqcOrEpPNZkW20AIPh+uLmemGUygbYsVer126tXL6xatQrx8fH47LPPcPnyZXTu3BktWrTA559/XtM1EpmUZ9t4wc1OgYSMPPx25k6x20/F3MN7v18AALz1ZDB6BbvWdYlUz5nJZXi+nTcA07g0la/S4Js9pttqAwAe9pawVZhBpRG4wRFT1Zuh2MbGBpMmTcLBgwfxxx9/ID4+HjNmzKip2ohMkoWZDC92LewYvOLAdb2VfhMycvHq2nAUqAWeauGO13r5G6pMqueG3R81dSAysVKj7xoiU2+1AQpbfQPvz3djah3JS1KtcJOdnY2VK1eiZ8+eGDhwIJycnPDRRx/VVG1EJmtEp8awUZghKiETeyMSABT+dxq27hTupuchwNUGnw5rzQ7EVCpfZyU6NXWEEMAvRryYJlttHniwxhTDTZXCzeHDhzFp0iR4eHggLCwMvr6+2Lt3L65evYpZs2bVdI1EJsfO0hyjOhX+B7r8/qR+H227hBM37sFWYYYVY9rDRsEOxFQ2bcfijeGxei2AxuB2ag6+PXAdzy09ZPKtNlocDv5ApT4d//vf/+LHH3/E1atX0aFDByxatAgjRoyAra1tbdVHZLImdG2KHw5F43h0Cub9cRGrjtwEAPzvhTbwc7ExcHXUEDwd6oH3fruI2JQcHL2e3OAneLyTmoPt5+Ow7XwcTsek6rbLZRLm9m9u0q02AFcHL6pS4WbRokUYPXo0Nm3ahNDQ0NqqiYgAuNtbYmBrL/xy6hZ+PHQDADC1dyD6NHczbGHUYFhZyDGgjSfWH4vBzydjG2S4iU/L1QWa8Jv3dNslCejo64h+rTzwVKg7XG0tDVhl/aDtc3MzOQu5BWqTDnuVCjd37tyBubl5bdVCRA95uYcffjlV2F+id4grpvYONHBF1NC80MEH64/FYMeFeHyQXQB76/r/GX43PRc77geaEzf0A80jTQoDzdOh7nC1Y6ApysVGgUbW5riXXYCohEyEetkbuiSDqXC42bBhA4YPH16hfWNjYxETE4OuXbtWuTAiKmxmfv3xAFyOy8DnL7SGTMYOxFQ5rbztEeJuiyvxGfj97G2M6exr6JJKlJCRi50X4vHnuTicuJECUaSLUIcmje4HGg+42zPQlEaSCteYOhadgqt3MxhuKmLp0qWYN28eJkyYgAEDBqBZs2Z6t6elpeHQoUNYu3Ytdu/eje+//77GiyUyRdOfDDZ0CdSASZKEoR18MP/PS/j5ZGy9CjeJGXnYeTEe287dwbFo/UDTrrED+rXyxNOh7vB0sCr9QUjPg3Bj2v1uKhxu9u/fj99//x1ff/01Zs+eDaVSCTc3N1haWuLevXuIj4+Hs7Mzxo8fjwsXLsDNjf0CiIjqg8FtvfDxjsu4cDsdF++koYWn4f6jT87UBpo4HL2ejKKDuNr4OKB/Kw883dIDXgw0VRLE4eAAKtnnZuDAgRg4cCCSkpJw8OBB3Lx5Ezk5OXB2dkbbtm3Rtm3bCq8cTkREdcNRaYEnm7tj2/k4bDp5Cy0G1m24ScnKx677gebI9WSoiySa1t72uktOPo5cRqS6glwLOxUz3FSBs7MzBg0aVMOlEBFRbRn2iA+2nY/D1tO3MevpkFofSXMvKx9/XSrsQ3P4mn6gaelVGGj6tWSgqWlB99eYunUvB1l5KihNdD4s03zWREQmpluAMzztLXEnLRd/XbqLga09a/wYadkF2HWpsIXmUFQSVEUCTQtPO12gaeKkrPFjU6FGSgu42hauTReZkIk2Pg6GLskgGG6IiEyAXCZhSHtvfLUnChtPxNZYuEnLKcDuS3ex7dwdHIxKQoH6QaBp5mGH/q088ExLDzR1ZqCpK0FutkjIyMPV+AyGGyIiMm5DO/jgqz1ROBiVhNiU7CpfEkrPLcDfl+5i27k4HIhM1As0Ie626NfSA8+08oA/Z9I2iCA3WxyMSkKECfe7YbghIjIRPo7W6BrghENRydgcfgtvPhFU4ftm5Bbgn8sJ+PNcHA5cTUS+WqO7LdjNFv3ut9AEuDLQGFqQGzsV15uhTR9//DEkScK0adPK3O+LL75AcHAwrKys4OPjgzfffBO5ubl1UyQRUQM3rEPhYpqbw2/pdfItSWaeCr+duY2XV59E+w//xrSfz+Dvy3eRr9YgwNUG0/oEYvebPbDrzR54o3cgg009weHgNdxyExsbi/feew8//PBDpe534sQJLF++HK1atSpzv/Xr12PWrFn44Ycf0KVLF1y9ehXjx4+HJEn4/PPPq1M6EZFJ6NvCHXaWZridmoNDUUnoEeSid3tWngp7riRg27k47I1IQJ7qQQuNn4sS/Vt5on8rD92oHKp/Au+HzLvpeUhrIEtu1LQaDTcpKSlYtWpVpcJNZmYmRo0ahW+//RYffvhhmfsePnwYXbt2xciRIwEAvr6+GDFiBI4dO1atuomITIWluRyD2nph9ZGb+PlkLHoEuSA7X4W9VxKx7fwd7LmSgNyCB4GmqbMS/Vt5oF8rDwS72UKSuARIfWdraQ4vByvcTs3B1YQMPOLraOiS6lylws3vv/9e5u3Xr1+vdAFhYWHo168f+vTpU2646dKlC9auXYvjx4+jY8eOuH79OrZv344xY8aUep+8vDzk5eXpfk5PT690jURExmRYBx+sPnITuy/eRdi6U9hzJQE5BWrd7b5O1veHbXuimQcDTUMU5GaD26k5iIhnuCnXoEGDIEkShCj9Om1lfgk2bNiAU6dO4cSJExXaf+TIkUhKSkK3bt0ghIBKpcLkyZMxZ86cUu+zcOFCzJs3r8I1EREZu1AvezT3sMOluHRsOx8HAGjsaK2bh6aFpx0DTQMX5GaLvRGJiDTRfjeV6lDs4eGBLVu2QKPRlPh16tSpCj9WbGwspk6dinXr1sHSsmKrvO7btw8LFizAkiVLcOrUKWzZsgXbtm3D/PnzS73P7NmzkZaWpvuKjY2tcI1ERMbqP/2a4RHfRnilpx/+mNIN+2f0wsynQhDqZc9gYwS0faJMdTh4pVpu2rdvj/DwcDz77LMl3l5eq05R4eHhSEhIQLt27XTb1Go1Dhw4gMWLFyMvLw9yuf704O+88w7GjBmDSZMmAQBatmyJrKwsvPzyy/jPf/5T4rpWCoUCCoWiok+RiMgkdA1wRtcAZ0OXQbVEG24iTXR18EqFmxkzZiArK6vU2wMCArB3794KPVbv3r1x/vx5vW0TJkxASEgIZs6cWSzYAEB2dnaxAKPdr6KhioiIyNgFuNpAkoDkrHwkZebB2ca0/smvVLjp3r17mbcrlUr07NmzQo9la2uL0NDQYvd3cnLSbR87diy8vLywcOFCAMCAAQPw+eefo23btujUqROioqLwzjvvYMCAASWGISIiIlNkZSFHE0dr3EjOxtX4DDgHMNyUa+3atRg8eDCUytpdKyQmJkavpWbu3LmQJAlz587F7du34eLiggEDBuCjjz6q1TqIiIgamkA328JwczcDXUzsEqQkqnA9x8XFBTk5ORg4cCBGjx6Nvn37NpiWk/T0dNjb2yMtLQ12dnaGLoeIiKhWfLorAov3RmFEx8ZY+FxLQ5dTbZX5+12l5Rfi4uKwYcMGSJKEYcOGwcPDA2FhYTh8+HCVCiYiIqKaFXh/jSlTHA5epXBjZmaG/v37Y926dUhISMD//vc/3LhxA4899hj8/f1rukYiIiKqpGD3B8PBTW3QTbWXX7C2tkbfvn1x79493Lx5E5cvX66JuoiIiKga/JxtYCaTkJGrQnx6LjzsrQxdUp2p8qrg2dnZWLduHZ555hl4eXnhiy++wODBg3Hx4sWarI+IiIiqwMJMBl/nwoE/V01svpsqtdwMHz4cf/75J6ytrTFs2DC888476Ny5c03XRkRERNUQ7GaLqIRMXI3PQM+HVoA3ZlUKN3K5HBs3bmxQo6SIiIhMTaCbDXAeuGpinYqrFG7WrVtX03UQERFRDQu+vwyDqYWbKve5ISIiovotyF0bbjKh0ZjOiCmGGyIiIiPVxNEaFnIZcgrUuJ2aY+hy6gzDDRERkZEyk8vg71o4mV9EvOlcmmK4ISIiMmJB92cqvprAcFOua9euYe7cuRgxYgQSEhIAADt27OA8N0RERPVIkLZTMVtuyrZ//360bNkSx44dw5YtW5CZWTg50NmzZ/Hee+/VaIFERERUdbpwY0IT+VUp3MyaNQsffvghdu/eDQsLC932xx9/HEePHq2x4oiIiKh6tMPBoxIzoVJrDFxN3ahSuDl//jwGDx5cbLurqyuSkpKqXRQRERHVDO9GVrAylyNfpcHNlGxDl1MnqhRuHBwcEBcXV2z76dOn4eXlVe2iiIiIqGbIZFLhTMUAIk1kMr8qhZvhw4dj5syZiI+PhyRJ0Gg0OHToEN566y2MHTu2pmskIiKiatD2u4mIN41+N1UKNwsWLEBISAh8fHyQmZmJ5s2bo0ePHujSpQvmzp1b0zUSERFRNZjacPAqrS1lYWGBb7/9Fu+++y7Onz+PzMxMtG3bFoGBgTVdHxEREVWTqQ0Hr1LLzQcffIDs7Gz4+PjgmWeewbBhwxAYGIicnBx88MEHNV0jERERVUPw/TWmopOykK8y/hFTVQo38+bN081tU1R2djbmzZtX7aKIiIio5rjbWcJWYQaVRiA6KcvQ5dS6KoUbIQQkSSq2/ezZs3B0dKx2UURERFRzJEnSrRAeYQIjpirV56ZRo0aQJKnwJAUF6QUctVqNzMxMTJ48ucaLJCIiouoJcrNB+M17JjEcvFLh5osvvoAQAi+++CLmzZsHe3t73W0WFhbw9fVF586da7xIIiIiqp4Hw8EZbvSMGzcOANC0aVN06dIF5ubmtVIUERER1axg3RpTDDcl6tmzp+773Nxc5Ofn691uZ2dXvaqIiIioRgXeDzc3U7KRW6CGpbncwBXVnip1KM7OzsaUKVPg6uoKpVKJRo0a6X0RERFR/eJsYwFHpQWEAKISjHum4iqFmxkzZmDPnj1YunQpFAoFvvvuO8ybNw+enp5YvXp1TddIRERE1SRJEgJd789UbOSXpqoUbv744w8sWbIEzz//PMzMzNC9e3fMnTsXCxYswLp162q6RiIiIqoBwSYyHLxK4SYlJQV+fn4ACvvXpKSkAAC6deuGAwcO1Fx1REREVGMCTWQZhiqFGz8/P0RHRwMAQkJCsHHjRgCFLToODg41VhwRERHVnAcjptjnppgJEybg7NmzAIBZs2bhm2++gaWlJd58803MmDGjRgskIiKimqFdHfx2ag4y81QGrqb2VGko+Jtvvqn7vk+fPrhy5QrCw8MREBCAVq1a1VhxREREVHMcrC3gaqtAQkYeIu9moG1j4xzhXKVw87AmTZqgSZMmNfFQREREVIuC3W2RkJGHqww3hXJycvDPP/+gf//+AIDZs2cjLy9Pd7tcLsf8+fNhaWlZs1USERFRjQh0tcW/kUmIiDfefjeVCjerVq3Ctm3bdOFm8eLFaNGiBaysrAAAV65cgaenp95lKyIiIqo/gt0L+91EJhjviKlKdShet24dXn75Zb1t69evx969e7F3714sWrRIN3KKiIiI6h9TWECzUuEmKioKLVu21P1saWkJmezBQ3Ts2BGXLl2queqIiIioRmnnuknIyENqdn45ezdMlQo3qampen1sEhMT4evrq/tZo9Ho3U5ERET1i43CDF4Ohd1JjHW+m0qFG29vb1y4cKHU28+dOwdvb+9qF0VERES1RzvfjbEuw1CpcPPMM8/g3XffRW5ubrHbcnJyMG/ePPTr16/GiiMiIqKaF3R/jalIIw03lRotNWfOHGzcuBHBwcGYMmUKgoKCAAARERFYvHgxVCoV5syZUyuFEhERUc0INvJOxZUKN25ubjh8+DBeffVVzJo1C0IIAIXLqD/xxBNYsmQJ3NzcaqVQIiIiqhlBujWmMiCEgCRJBq6oZlV6huKmTZti586dSElJQVRUFAAgICAAjo6ONV4cERER1bwAVxtIEnAvuwBJmflwsVUYuqQaVeXlFxwdHdGxY8earIWIiIjqgKW5HE0crXEjORuRdzOMLtxUaVVwIiIiath0k/kZYadihhsiIiITVLTfjbFhuCEiIjJB2uHgxjiRH8MNERGRCdIOB78an6Eb/WwsGG6IiIhMUFNnJcxkEjLyVIhPLz45b0PGcENERGSCLMxkaOqsBGB8k/kx3BAREZkoY+1UzHBDRERkoh6EG+PqVMxwQ0REZKKC3QtXB2fLDRERERmFQDft6uCZ0GiMZ8QUww0REZGJauJoDQszGXIK1Lh1L8fQ5dQYhhsiIiITZSaXwd+l8NKUMS3DwHBDRERkwoLdjK/fDcMNERGRCXuwDAPDDRERERmBIFfjGw7OcENERGTCgu+33FxLyIRKrTFwNTWD4YaIiMiEeTlYwcpcjny1BjeSsw1dTo2oN+Hm448/hiRJmDZtWqn79OrVC5IkFfvq169f3RVKRERkRGQyCUH3OxVHGkm/m3oRbk6cOIHly5ejVatWZe63ZcsWxMXF6b4uXLgAuVyOoUOH1lGlRERExkc7mZ+xDAc3eLjJzMzEqFGj8O2336JRo0Zl7uvo6Ah3d3fd1+7du2Ftbc1wQ0REVA3BRWYqNgYGDzdhYWHo168f+vTpU+n7fv/99xg+fDiUSmWp++Tl5SE9PV3vi4iIiB7QDgc3lpYbM0MefMOGDTh16hROnDhR6fseP34cFy5cwPfff1/mfgsXLsS8efOqWiIREZHR0/a5iU7KQp5KDYWZ3MAVVY/BWm5iY2MxdepUrFu3DpaWlpW+//fff4+WLVuiY8eOZe43e/ZspKWl6b5iY2OrWjIREZFRcrezhK2lGdQageikLEOXU20GCzfh4eFISEhAu3btYGZmBjMzM+zfvx9fffUVzMzMoFarS71vVlYWNmzYgIkTJ5Z7HIVCATs7O70vIiIiekCSJARpOxXHN/xLUwa7LNW7d2+cP39eb9uECRMQEhKCmTNnQi4vvUls06ZNyMvLw+jRo2u7TCIiIpMQ5GaL8Jv3jKJTscHCja2tLUJDQ/W2KZVKODk56baPHTsWXl5eWLhwod5+33//PQYNGgQnJ6c6q5eIiMiYaRfQNIZOxQbtUFyemJgYyGT6V84iIiJw8OBB/PXXXwaqioiIyPgE6YaDM9zUqH379pX5MwAEBwdDCFE3BREREZkI7XDwmynZyMlXw8qi4Y6YMvg8N0RERGR4zjYKOCotIAQQldCw+90w3BARERGAB/PdXG3gl6YYboiIiAjAg2UYGG6IiIjIKAQy3BAREZExCXbXhhv2uSEiIiIjEORaGG5up+YgI7fAwNVUHcMNERERAQDsrc3hZqcAAEQ24BFTDDdERESko53M72oDXmOK4YaIiIh0dOGmAfe7YbghIiIiHWMYDs5wQ0RERDqBRrCAJsMNERER6WjnuknMyMO9rHwDV1M1DDdERESkY6Mwg5eDFYCGe2mK4YaIiIj06Cbza6DDwRluiIiISE9DHw7OcENERER6ghp4p2KGGyIiItKjbbmJvJsBIYSBq6k8hhsiIiLSE+BqA5kE3MsuQGJmnqHLqTSGGyIiItJjaS5HEyclACCyAc5UzHBDRERExej63TTATsUMN0RERFRMUANehoHhhoiIiIphuCEiIiKj8mDEVGaDGzHFcENERETFNHVWwkwmISNPhbi0XEOXUykMN0RERFSMhZkMTZ0LR0w1tMn8GG6IiIioREHuDybza0gYboiIiKhEwff73UTEN6y5bhhuiIiIqETauW4a2ogphhsiIiIqkW7EVEIGNJqGM2KK4YaIiIhK1MRJCQszGXILNIi9l23ociqM4YaIiIhKJJdJCHDRXppqOP1uGG6IiIioVMHuDW+mYoYbIiIiKlVgA1xAk+GGiIiIShXcANeYYrghIiKiUmlHTF1PzIJKrTFwNRXDcENERESl8nKwgrWFHPlqDW4kN4wRUww3REREVCqZTEJgA7s0xXBDREREZQpybVidihluiIiIqEza4eCRCQw3REREZAQCdQtoMtwQERGREdAOB7+RnI08ldrA1ZSP4YaIiIjK5GangK2lGdQageuJWYYup1wMN0RERFQmSZIa1GR+DDdERERUrqAGtMYUww0RERGV68Fw8Pq/OjjDDREREZUrqAENB2e4ISIionJp15iKSclGdr7KwNWUjeGGiIiIyuVso4CT0gJCAFEJ9fvSFMMNERERVUiQbsQUww0REREZgSC3wk7F9X3EFMMNERERVUhDGQ7OcENEREQVorssVc/XmGK4ISIiogoJci0MN3fScpGeW2DgakrHcENEREQVYm9tDnc7SwBAZD3uVMxwQ0RERBUW2AA6FTPcEBERUYU1hAU0GW6IiIiowoIYboiIiMiYPBgOzj43REREZAQC768OnpiRh5SsfANXUzKGGyIiIqowpcIM3o2sANTfS1MMN0RERFQp2k7FkQw3Zfv4448hSRKmTZtW5n6pqakICwuDh4cHFAoFgoKCsH379ropkoiIiBB4P9xE1NNwY2boAgDgxIkTWL58OVq1alXmfvn5+XjiiSfg6uqKzZs3w8vLCzdv3oSDg0PdFEpEREQIdtfOdVM/OxUbPNxkZmZi1KhR+Pbbb/Hhhx+Wue8PP/yAlJQUHD58GObm5gAAX1/fOqiSiIiItAJdHwwHF0JAkiQDV6TP4JelwsLC0K9fP/Tp06fcfX///Xd07twZYWFhcHNzQ2hoKBYsWAC1Wl3qffLy8pCenq73RURERFUX4GoDmQSkZhcgMSPP0OUUY9Bws2HDBpw6dQoLFy6s0P7Xr1/H5s2boVarsX37drzzzjv47LPPymzxWbhwIezt7XVfPj4+NVU+ERGRSbI0l8PXSQmgfl6aMli4iY2NxdSpU7Fu3TpYWlpW6D4ajQaurq5YsWIF2rdvjxdeeAH/+c9/sGzZslLvM3v2bKSlpem+YmNja+opEBERmSztGlP1sVOxwfrchIeHIyEhAe3atdNtU6vVOHDgABYvXoy8vDzI5XK9+3h4eMDc3Fxve7NmzRAfH4/8/HxYWFgUO45CoYBCoai9J0JERGSCgt1ssevi3Xo5HNxg4aZ37944f/683rYJEyYgJCQEM2fOLBZsAKBr165Yv349NBoNZLLCRqerV6/Cw8OjxGBDREREtaM+Dwc32GUpW1tbhIaG6n0plUo4OTkhNDQUADB27FjMnj1bd59XX30VKSkpmDp1Kq5evYpt27ZhwYIFCAsLM9TTICIiMknB7tqJ/DIhhDBwNfoMPhS8LDExMboWGgDw8fHBrl278Oabb6JVq1bw8vLC1KlTMXPmTANWSUREZHp8nZQwl0vIzFPhTlouvBysDF2STr0KN/v27SvzZwDo3Lkzjh49WjcFERERUYkszGRo6qzE1buZuBqfUa/CjcHnuSEiIqKGKcjtwWR+9QnDDREREVVJUD3tVMxwQ0RERFXClhsiIiIyKtoRU1EJmVBr6s+IKYYbIiIiqpLGjtZQmMmQW6BBbEq2ocvRYbghIiKiKpHLJAS4Fi7DUJ8uTTHcEBERUZXVx343DDdERERUZQ9GTNWf1cEZboiIiKjKgu6vDl6fFtBkuCEiIqIq07bcXEvMRIFaY+BqCjHcEBERUZV5OVhBaSFHgVrgZnKWocsBwHBDRERE1SCTSQjQ9ruJrx/9bhhuiIiIqFqC3erXcHCGGyIiIqqW+jYcnOGGiIiIqqW+LaDJcENERETVol1j6mZyNnIL1AauhuGGiIiIqsnVVgE7SzOoNQLXEw0/YorhhoiIiKpFkiRd601kguEvTTHcEBERUbUF6oaDM9wQERGREQiuRyOmGG6IiIio2h4MBzf8RH4MN0RERFRt2gU0Y1KykZ2vMmgtDDdERERUbU42CjjbWAAAohIM23rDcENEREQ1ItC1fnQqZrghIiKiGqEdDm7oTsUMN0RERFQjAnULaPKyFBERERmBYDdbyCQgT2XYJRjMDHp0IiIiMhptfBxw6YOnYGkuN2gdDDdERERUI8zkMpgZNtcA4GUpIiIiMjIMN0RERGRUGG6IiIjIqDDcEBERkVFhuCEiIiKjwnBDRERERoXhhoiIiIwKww0REREZFYYbIiIiMioMN0RERGRUGG6IiIjIqDDcEBERkVFhuCEiIiKjYnKrggshAADp6ekGroSIiIgqSvt3W/t3vCwmF24yMjIAAD4+PgauhIiIiCorIyMD9vb2Ze4jiYpEICOi0Whw584d2NraQpKkGn3s9PR0+Pj4IDY2FnZ2djX62PQAz3Pd4HmuGzzPdYfnum7U1nkWQiAjIwOenp6QycruVWNyLTcymQze3t61egw7Ozv+4tQBnue6wfNcN3ie6w7Pdd2ojfNcXouNFjsUExERkVFhuCEiIiKjwnBTgxQKBd577z0oFApDl2LUeJ7rBs9z3eB5rjs813WjPpxnk+tQTERERMaNLTdERERkVBhuiIiIyKgw3BAREZFRYbghIiIio8JwU0O++eYb+Pr6wtLSEp06dcLx48cNXVKD9v7770OSJL2vkJAQ3e25ubkICwuDk5MTbGxs8Pzzz+Pu3bsGrLjhOHDgAAYMGABPT09IkoRff/1V73YhBN599114eHjAysoKffr0QWRkpN4+KSkpGDVqFOzs7ODg4ICJEyciMzOzDp9F/VfeeR4/fnyx9/hTTz2ltw/Pc9kWLlyIRx55BLa2tnB1dcWgQYMQERGht09FPitiYmLQr18/WFtbw9XVFTNmzIBKparLp1LvVeRc9+rVq9h7evLkyXr71NW5ZripAT///DP+7//+D++99x5OnTqF1q1bo2/fvkhISDB0aQ1aixYtEBcXp/s6ePCg7rY333wTf/zxBzZt2oT9+/fjzp07eO655wxYbcORlZWF1q1b45tvvinx9v/+97/46quvsGzZMhw7dgxKpRJ9+/ZFbm6ubp9Ro0bh4sWL2L17N/78808cOHAAL7/8cl09hQahvPMMAE899ZTee/ynn37Su53nuWz79+9HWFgYjh49it27d6OgoABPPvkksrKydPuU91mhVqvRr18/5Ofn4/Dhw1i1ahVWrlyJd9991xBPqd6qyLkGgJdeeknvPf3f//5Xd1udnmtB1daxY0cRFham+1mtVgtPT0+xcOFCA1bVsL333nuidevWJd6WmpoqzM3NxaZNm3TbLl++LACII0eO1FGFxgGA2Lp1q+5njUYj3N3dxaJFi3TbUlNThUKhED/99JMQQohLly4JAOLEiRO6fXbs2CEkSRK3b9+us9obkofPsxBCjBs3Tjz77LOl3ofnufISEhIEALF//34hRMU+K7Zv3y5kMpmIj4/X7bN06VJhZ2cn8vLy6vYJNCAPn2shhOjZs6eYOnVqqfepy3PNlptqys/PR3h4OPr06aPbJpPJ0KdPHxw5csSAlTV8kZGR8PT0hJ+fH0aNGoWYmBgAQHh4OAoKCvTOeUhICBo3bsxzXk3R0dGIj4/XO7f29vbo1KmT7tweOXIEDg4O6NChg26fPn36QCaT4dixY3Vec0O2b98+uLq6Ijg4GK+++iqSk5N1t/E8V15aWhoAwNHREUDFPiuOHDmCli1bws3NTbdP3759kZ6ejosXL9Zh9Q3Lw+daa926dXB2dkZoaChmz56N7Oxs3W11ea5NbuHMmpaUlAS1Wq33YgGAm5sbrly5YqCqGr5OnTph5cqVCA4ORlxcHObNm4fu3bvjwoULiI+Ph4WFBRwcHPTu4+bmhvj4eMMUbCS056+k97P2tvj4eLi6uurdbmZmBkdHR57/Snjqqafw3HPPoWnTprh27RrmzJmDp59+GkeOHIFcLud5riSNRoNp06aha9euCA0NBYAKfVbEx8eX+H7X3kbFlXSuAWDkyJFo0qQJPD09ce7cOcycORMRERHYsmULgLo91ww3VC89/fTTuu9btWqFTp06oUmTJti4cSOsrKwMWBlRzRg+fLju+5YtW6JVq1bw9/fHvn370Lt3bwNW1jCFhYXhwoULen3zqHaUdq6L9gdr2bIlPDw80Lt3b1y7dg3+/v51WiMvS1WTs7Mz5HJ5sd73d+/ehbu7u4GqMj4ODg4ICgpCVFQU3N3dkZ+fj9TUVL19eM6rT3v+yno/u7u7F+ssr1KpkJKSwvNfDX5+fnB2dkZUVBQAnufKmDJlCv7880/s3bsX3t7euu0V+axwd3cv8f2uvY30lXauS9KpUycA0HtP19W5ZripJgsLC7Rv3x7//POPbptGo8E///yDzp07G7Ay45KZmYlr167Bw8MD7du3h7m5ud45j4iIQExMDM95NTVt2hTu7u565zY9PR3Hjh3TndvOnTsjNTUV4eHhun327NkDjUaj+zCjyrt16xaSk5Ph4eEBgOe5IoQQmDJlCrZu3Yo9e/agadOmerdX5LOic+fOOH/+vF6Q3L17N+zs7NC8efO6eSINQHnnuiRnzpwBAL33dJ2d6xrtnmyiNmzYIBQKhVi5cqW4dOmSePnll4WDg4Nej3CqnOnTp4t9+/aJ6OhocejQIdGnTx/h7OwsEhIShBBCTJ48WTRu3Fjs2bNHnDx5UnTu3Fl07tzZwFU3DBkZGeL06dPi9OnTAoD4/PPPxenTp8XNmzeFEEJ8/PHHwsHBQfz222/i3Llz4tlnnxVNmzYVOTk5usd46qmnRNu2bcWxY8fEwYMHRWBgoBgxYoShnlK9VNZ5zsjIEG+99ZY4cuSIiI6OFn///bdo166dCAwMFLm5ubrH4Hku26uvvirs7e3Fvn37RFxcnO4rOztbt095nxUqlUqEhoaKJ598Upw5c0bs3LlTuLi4iNmzZxviKdVb5Z3rqKgo8cEHH4iTJ0+K6Oho8dtvvwk/Pz/Ro0cP3WPU5blmuKkhX3/9tWjcuLGwsLAQHTt2FEePHjV0SQ3aCy+8IDw8PISFhYXw8vISL7zwgoiKitLdnpOTI1577TXRqFEjYW1tLQYPHizi4uIMWHHDsXfvXgGg2Ne4ceOEEIXDwd955x3h5uYmFAqF6N27t4iIiNB7jOTkZDFixAhhY2Mj7OzsxIQJE0RGRoYBnk39VdZ5zs7OFk8++aRwcXER5ubmokmTJuKll14q9g8Rz3PZSjq/AMSPP/6o26cinxU3btwQTz/9tLCyshLOzs5i+vTpoqCgoI6fTf1W3rmOiYkRPXr0EI6OjkKhUIiAgAAxY8YMkZaWpvc4dXWupftFExERERkF9rkhIiIio8JwQ0REREaF4YaIiIiMCsMNERERGRWGGyIiIjIqDDdERERkVBhuiIiIyKgw3BAREZFRYbghogZt5cqVcHBwqLXHHzNmDBYsWFBrj1/Uo48+il9++aVOjkVkzBhuiEhPfHw8pk6dioCAAFhaWsLNzQ1du3bF0qVLkZ2dXeHHqe3QURkXL17E888/D19fX0iShC+++KJC9zt79iy2b9+ON954o8rH/uWXXyCXy3H79u0Sbw8MDMT//d//AQDmzp2LWbNmQaPRVPl4RMRwQ0RFXL9+HW3btsVff/2FBQsW4PTp0zhy5Ajefvtt/Pnnn/j7778NXWKVZGdnw8/PDx9//DHc3d0rfL+vv/4aQ4cOhY2NTZWPPXDgQDg5OWHVqlXFbjtw4ACioqIwceJEAMDTTz+NjIwM7Nixo8rHIyJwVXAieqBv377C29tbZGZmlni7RqPRff/ZZ5+J0NBQYW1tLby9vcWrr76qW9SxpEUj33vvPSGEELm5uWL69OnC09NTWFtbi44dO4q9e/eWWde9e/fEyy+/LFxdXYVCoRAtWrQQf/zxhxBCiB9//FHY29uLnTt3ipCQEKFUKkXfvn3FnTt3SnysJk2aiP/973/lnguVSiXs7e3Fn3/+Wez+8+fPF2PGjBFKpVI0btxY/PbbbyIhIUEMHDhQKJVK0bJlS3HixAndff7v//5PBAYGFjvGuHHjRKdOnfS2TZgwQYwePbrc+oiodGy5ISIAQHJyMv766y+EhYVBqVSWuI8kSbrvZTIZvvrqK1y8eBGrVq3Cnj178PbbbwMAunTpgi+++AJ2dnaIi4tDXFwc3nrrLQDAlClTcOTIEWzYsAHnzp3D0KFD8dRTTyEyMrLEY2o0Gjz99NM4dOgQ1q5di0uXLuHjjz+GXC7X7ZOdnY1PP/0Ua9aswYEDBxATE6M7XlWdO3cOaWlp6NChQ7Hb/ve//6Fr1644ffo0+vXrhzFjxmDs2LEYPXo0Tp06BX9/f4wdOxbi/rrEEydORGRkJA4cOKB7jMzMTGzevFnXaqPVsWNH/Pvvv9WqncjkGTpdEVH9cPToUQFAbNmyRW+7k5OTUCqVQqlUirfffrvU+2/atEk4OTnpfta2qBR18+ZNIZfLxe3bt/W29+7dW8yePbvEx921a5eQyWQiIiKixNt//PFHAUBERUXptn3zzTfCzc2txP0r2nKzdetWIZfL9VqrtPcv2rISFxcnAIh33nlHt+3IkSMCgIiLi9Nte/TRR8W4ceN0P3///ffC2tpapKen6z3+b7/9JmQymVCr1eXWSEQlY8sNEZXp+PHjOHPmDFq0aIG8vDzd9r///hu9e/eGl5cXbG1tMWbMGCQnJ5fZ6fj8+fNQq9UICgqCjY2N7mv//v24du1aifc5c+YMvL29ERQUVOrjWltbw9/fX/ezh4cHEhISqvBsH8jJyYFCodBrrdJq1aqV7ns3NzcAQMuWLYttK1rDiy++iM2bNyMjIwMA8MMPP2Do0KGwtbXVe2wrKytoNBq9c01ElWNm6AKIqH4ICAiAJEmIiIjQ2+7n5weg8I+u1o0bN9C/f3+8+uqr+Oijj+Do6IiDBw9i4sSJyM/Ph7W1dYnHyMzMhFwuR3h4uN5lJQCldtotetzSmJub6/0sSZLuklBVOTs7Izs7G/n5+bCwsCj1eNrwU9K2oqOehg8fjjfffBMbN25Ejx49cOjQISxcuLDYcVNSUqBUKiv0vImoZAw3RAQAcHJywhNPPIHFixfj9ddfL7XfDQCEh4dDo9Hgs88+g0xW2AC8ceNGvX0sLCygVqv1trVt2xZqtRoJCQno3r17hepq1aoVbt26hatXr5bZelPT2rRpAwC4dOmS7vvqsLW1xdChQ/HDDz/g2rVrCAoKKvEcXLhwAW3btq328YhMGS9LEZHOkiVLoFKp0KFDB/z888+4fPkyIiIisHbtWly5ckXX2hIQEICCggJ8/fXXuH79OtasWYNly5bpPZavry8yMzPxzz//ICkpCdnZ2QgKCsKoUaMwduxYbNmyBdHR0Th+/DgWLlyIbdu2lVhTz5490aNHDzz//PPYvXs3oqOjsWPHDuzcubPCzys/Px9nzpzBmTNnkJ+fj9u3b+PMmTOIiooq9T4uLi5o164dDh48WOHjlGfixIk4fPgwli1bhhdffLHEff799188+eSTNXZMIpNk6E4/RFS/3LlzR0yZMkU0bdpUmJubCxsbG9GxY0exaNEikZWVpdvv888/Fx4eHsLKykr07dtXrF69WgAQ9+7d0+0zefJk4eTkpDcUPD8/X7z77rvC19dXmJubCw8PDzF48GBx7ty5UmtKTk4WEyZMEE5OTsLS0lKEhobqhmiX1HF569atoujHW3R0dLGh6QBEz549yzwXS5YsEY8++qjetpI6JAMQW7duLXa806dPF3vM4OBgIZfLSxyqfuvWLWFubi5iY2PLrIuIyiYJUc0L00RERionJwfBwcH4+eef0blz51o/3syZM3Hv3j2sWLGi1o9FZMzY54aIqBRWVlZYvXo1kpKS6uR4rq6uuqUYiKjq2HJDRERERoUdiomIiMioMNwQERGRUWG4ISIiIqPCcENERERGheGGiIiIjArDDRERERkVhhsiIiIyKgw3REREZFQYboiIiMio/D/IlX6cQkvSFwAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -876,7 +958,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -886,36 +968,36 @@
     }
    ],
    "source": [
-    "plot(result_1d[0], save_pdf = False, save_png =True)"
+    "plot(result_1d[0], save_pdf=False, save_png=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(2d_measurement of dmm from dac sweep #214@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " ----------------------------------------------------------------------------------------------------------------------\n",
+       "(2d_measurement of dmm from dac sweep #69@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ---------------------------------------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #214, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate ch2 (mV)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #214, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate ch2 (mV)'>],\n",
-       " [<matplotlib.colorbar.Colorbar at 0x1f3c34dfcd0>,\n",
-       "  <matplotlib.colorbar.Colorbar at 0x1f3c35289a0>])"
+       " [<AxesSubplot: title={'center': 'Run #69, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate ch2 (mV)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #69, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (mV)', ylabel='Gate ch2 (mV)'>],\n",
+       " [<matplotlib.colorbar.Colorbar at 0x19b9060a6e0>,\n",
+       "  <matplotlib.colorbar.Colorbar at 0x19b905dfac0>])"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -925,7 +1007,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -935,7 +1017,7 @@
     }
    ],
    "source": [
-    "plot(result_2d[0], save_pdf = True, save_png = False)"
+    "plot(result_2d[0], save_pdf=True, save_png=False)"
    ]
   },
   {
@@ -961,7 +1043,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -978,20 +1060,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 215. \n"
+      "Starting experimental run with id: 70. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "586a5b6c66f24569ac422a4d98551e2e",
+       "model_id": "b03840ab0fd740938e45d68480e91b5d",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1005,23 +1087,23 @@
     {
      "data": {
       "text/plain": [
-       "(results #215@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #70@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #215, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #215, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
+       " [<AxesSubplot: title={'center': 'Run #70, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #70, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
        " [None, None])"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1031,7 +1113,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1041,25 +1123,27 @@
     }
    ],
    "source": [
-    "dond(sweep_1, dmm.v1, dmm.v2, do_plot=True, show_progress=True) # replacing above do1d example"
+    "dond(\n",
+    "    sweep_1, dmm.v1, dmm.v2, do_plot=True, show_progress=True\n",
+    ")  # replacing above do1d example"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 216. \n"
+      "Starting experimental run with id: 71. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "95cfd5212a4049a181e7453f9ab6b21d",
+       "model_id": "d759c9feffdb4b6a9688f1966e1b2169",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1073,25 +1157,25 @@
     {
      "data": {
       "text/plain": [
-       "(results #216@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #71@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #216, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #216, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
-       " [<matplotlib.colorbar.Colorbar at 0x1f3c30bc370>,\n",
-       "  <matplotlib.colorbar.Colorbar at 0x1f3c3033b20>])"
+       " [<AxesSubplot: title={'center': 'Run #71, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #71, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
+       " [<matplotlib.colorbar.Colorbar at 0x19b90a46ce0>,\n",
+       "  <matplotlib.colorbar.Colorbar at 0x19b90a9c8e0>])"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1101,7 +1185,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1111,7 +1195,9 @@
     }
    ],
    "source": [
-    "dond(sweep_1, sweep_2, dmm.v1, dmm.v2, do_plot=True, show_progress=True) # replacing above do2d example"
+    "dond(\n",
+    "    sweep_1, sweep_2, dmm.v1, dmm.v2, do_plot=True, show_progress=True\n",
+    ")  # replacing above do2d example"
    ]
   },
   {
@@ -1130,7 +1216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1140,20 +1226,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 217. \n"
+      "Starting experimental run with id: 72. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "778e5497f5cb4da5b33e7054a51804ad",
+       "model_id": "afc74f3725b6486db926fea82da41a63",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1167,23 +1253,23 @@
     {
      "data": {
       "text/plain": [
-       "(results #217@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #72@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #217, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #217, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
+       " [<AxesSubplot: title={'center': 'Run #72, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v1 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #72, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate v2 (mV)'>],\n",
        " [None, None])"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1193,7 +1279,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1203,25 +1289,25 @@
     }
    ],
    "source": [
-    "dond(sweep_3, dmm.v1, dmm.v2, show_progress=True, do_plot=True) # 1d"
+    "dond(sweep_3, dmm.v1, dmm.v2, show_progress=True, do_plot=True)  # 1d"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 218. \n"
+      "Starting experimental run with id: 73. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a9f9435e398843c2a9991a79a13d3e8f",
+       "model_id": "5a6e17f48dd249c2981d0da672f84446",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1235,25 +1321,25 @@
     {
      "data": {
       "text/plain": [
-       "(results #218@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #73@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric\n",
        " dmm_v2 - numeric,\n",
-       " [<AxesSubplot: title={'center': 'Run #218, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
-       "  <AxesSubplot: title={'center': 'Run #218, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
-       " [<matplotlib.colorbar.Colorbar at 0x1f3c3cdd850>,\n",
-       "  <matplotlib.colorbar.Colorbar at 0x1f3c3d247c0>])"
+       " [<AxesSubplot: title={'center': 'Run #73, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>,\n",
+       "  <AxesSubplot: title={'center': 'Run #73, Experiment doNd_VS_Measurement (no sample)'}, xlabel='Gate ch1 (V)', ylabel='Gate ch2 (V)'>],\n",
+       " [<matplotlib.colorbar.Colorbar at 0x19b90e3cdc0>,\n",
+       "  <matplotlib.colorbar.Colorbar at 0x19b90f8aaa0>])"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1263,7 +1349,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHHCAYAAAChjmJTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbsklEQVR4nO3deVhUZRsG8HsYYFhEXJBNERA0BDcSdw0XlNwqM7U0FzKXwtxyQVNxR82MckMtt9y1LDVzidRcc0vT3BWVVEDUQEBAZ97vDz8mxxkQzoCHYe7fdZ1Leeec9zxnZhieebejEEIIEBEREZkQC7kDICIiIiooJjBERERkcpjAEBERkclhAkNEREQmhwkMERERmRwmMERERGRymMAQERGRyWECQ0RERCaHCQwRERGZHCYwVKSuX78OhUKB5cuXyx3KS+Hl5YU+ffrIGkPz5s3RvHlzWWMgyhEfHw8bGxscPHhQ7lBMgjGfmTt27ECpUqVw9+7dwg+sGCpQArN8+XIoFArtZmlpiYoVK6JPnz64detWUcVYIP/++y8sLCywc+dOAMDmzZuhUqmQlZWls9+xY8cwaNAgBAQEwN7eHpUrV0bXrl1x6dIlvTqPHj2Kjz/+GHXr1oWVlRUUCkWu509JScGoUaNQtWpV2NrawtPTE3379sXNmzclX9Ozz/nz28CBAyXXS//Zvn07Jk6cKNv5cz60FAoFvv/+e73HJ06cCIVCgeTk5EI9b1JSEiwtLfH+++/nus/Dhw9ha2uLt99+W1t25swZvPPOO/D09ISNjQ0qVqyI1q1bY+7cuQU6f851WVhYID4+Xu/x1NRU2NraQqFQYNCgQQWqmwrfggULCvyHdfLkyWjQoAGaNGlSNEGR1uuvvw5fX19ERUXJHcpLYSnloMmTJ8Pb2xuZmZk4cuQIli9fjgMHDuDs2bOwsbEp7BgL5OjRowCABg0aAAAOHz6MwMBAqFQqnf1mzpyJgwcPokuXLqhVqxYSEhIwb948vPrqqzhy5Ahq1Kih3Xf79u345ptvUKtWLVSpUsVgkgMAGo0GrVu3xrlz5/Dxxx+jWrVquHLlChYsWICdO3fi/PnzcHBwkHRdrVu3Rq9evfTKq1WrJqm+l8XT0xOPHj2ClZWV3KHkafv27Zg/f76sSUyOyZMn4+23384zUS4szs7OaN26NX766SdkZGTAzs5Ob58ffvgBmZmZ2iTn0KFDaNGiBSpXrox+/frB1dUV8fHxOHLkCL766it88sknBY5DpVJh7dq1GDVqlN65qfhYsGABnJyc8t3KePfuXaxYsQIrVqwo2sBIa8CAARgxYgQmTZok+e+NyRAFsGzZMgFAHDt2TKd89OjRAoBYv359QaorElOmTBF+fn7an5s2bSoGDx6st9/BgwdFVlaWTtmlS5eESqUSPXr00ClPSEgQGRkZQgghwsPDRW5P28GDBwUAMW/ePJ3ypUuXCgDihx9+kHRNAER4eLikY+Xy+PFjvee3OMvrdS0IT09P0bt37wIfFxcXJwCIOnXqCADi+++/13k8MjJSABB37959YV3BwcEiODg43+f+7rvvBACxdu1ag4+3adNGODo6iszMTCGEEO3atRMVKlQQDx480Ns3MTEx3+cV4r/revvtt0WdOnX0Hm/durXo3LmzSf4OPC8tLU3uEIwWEBBQoPfWnDlzhK2trXj48GHRBVXC5HwWLFu2TNLxiYmJQqlUim+//bZwAyuGCmUMTLNmzQAAV69e1Zbl1g/fp08feHl5aX/OaTqfPXs2Fi9eDB8fH6hUKtSrVw/Hjh3L1/lTUlKQnJyM5ORkHD58GLVr10ZycjISExNx4sQJ+Pn5ITk5GSkpKdpjGjduDGtra516qlatioCAAJw/f16n3MXFBba2ti+MIzU1Vbv/s9zc3AAgX3VIdf78edja2uq10hw4cABKpRKjR4/Wlnl5eaFDhw7YtWsX6tSpAxsbG/j7+xv8tvvvv/9i6NCh8PDwgEqlgq+vL2bOnAmNRqPd59nXMDo6Wvsanjt3zmB/bp8+fVCqVCncvHkTHTp0QKlSpVCxYkXMnz8fwNPuiZYtW8Le3h6enp5Ys2aN0XHl9d7q06eP9tzPds/lRQiBqVOnolKlSrCzs0OLFi3w999/G9z32rVr6NKlC8qVKwc7Ozs0bNgQP//8s8F93333XVSrVg2TJ0+GyMeN4nOuy9bWFvXr18f+/ftfeMzzOnXqBHt7e4PPc1JSEmJjY/HOO+9oWzGvXr2KgIAAlClTRm9/Z2fnAp8fALp3745Tp07hwoUL2rKEhAT89ttv6N69u8FjsrKyEBkZCV9fX6hUKnh4eGDUqFF63cXLli1Dy5Yt4ezsDJVKBX9/fyxcuFCvvuPHjyM0NBROTk6wtbWFt7c3PvjgA+3je/fuhUKhwN69e3WOy+s9fvXqVbRr1w4ODg7o0aMHgKcttdHR0QgICICNjQ1cXFwwYMAAPHjwQKfenN/TvXv3IigoCLa2tqhZs6b2/D/88ANq1qwJGxsb1K1bF3/++afeNV24cAHvvPMOypUrBxsbGwQFBWHLli06++QMDTh48CCGDx+OChUqwN7eHp06ddIZS+Hl5YW///4b+/bt0/6OvGis1Y8//ogGDRqgVKlSOuXNmzdHjRo1cO7cObRo0QJ2dnaoWLEiZs2apVdHUlIS+vbtCxcXF9jY2KB27dr5btF50WsKALNnz0bjxo1Rvnx52Nraom7duti0aZNeXTndmBs3boS/vz9sbW3RqFEjnDlzBgCwaNEi+Pr6wsbGBs2bN8f169cNXvOJEyfQuHFjbTwxMTH5upb8vJbA09/BWrVq4aeffspXvSatINlObi0w8+bNEwDEwoULtWW5fQvs3bu38PT01P6ck20GBgYKX19fMXPmTDFr1izh5OQkKlWqJLKzs18YV3BwsADwwu1F3xw0Go2oWLGiaNOmTa775PVN/e7du8Le3l74+fmJ2NhY8c8//4i9e/eKmjVrinr16onHjx+/8FoMASD69u0r7t69q7c928rx+eefCwDip59+EkI8/cbn4+Mj/P39td+ehXjaSlCtWjVRpkwZERERIebMmSNq1qwpLCwsxK5du7T7paeni1q1aony5cuLsWPHipiYGNGrVy+hUCjEkCFDtPvlvIb+/v6iSpUqYsaMGeLLL78UN27cMPhtonfv3sLGxkb4+/uLgQMHivnz54vGjRtr93N3dxcjR44Uc+fOFQEBAUKpVIpr165JjutF761Dhw6J1q1bCwDiu+++0255GTdunAAg2rVrJ+bNmyc++OAD4e7uLpycnHRaYBISEoSLi4twcHAQn332mZgzZ46oXbu2sLCw0GmRy4n1888/FytXrtRrhTHUAvPNN98IAKJx48bi66+/FkOHDhVlypQRVapUKdC3ZCGE6N69u7C2thb37t3TKf/6668FAPHbb79py9q0aSMcHBzEmTNnCnQOQ3KuKykpSVSqVEmMHz9e+1h0dLS25QfPtcCo1WrRpk0bYWdnJ4YOHSoWLVokBg0aJCwtLcWbb76pc4569eqJPn36iC+//FLMnTtXtGnTRq+lNDExUZQtW1ZUq1ZNfP7552LJkiXis88+E9WrV9fus2fPHgFA7NmzR6f+3N7jKpVK+Pj4iN69e4uYmBixcuVKIYQQH374obC0tBT9+vUTMTExYvTo0cLe3l7Uq1dP5/PO09NTvPLKK8LNzU1MnDhRfPnll6JixYqiVKlSYtWqVaJy5cpixowZYsaMGcLR0VH4+voKtVqtPf7s2bPC0dFR+Pv7i5kzZ4p58+aJ1157TSgUCp33Xs7nemBgoGjZsqWYO3eu+PTTT4VSqRRdu3bV7rd582ZRqVIl4efnp/0defbz4nnZ2dnC1tZWDB8+XO+x4OBg4e7uLjw8PMSQIUPEggULRMuWLQUAsX37du1+GRkZonr16sLKykoMGzZMfP3116JZs2YCgIiOjs713ELk7zUVQohKlSqJjz/+WMybN0/MmTNH1K9fXwAQ27Zt09kPgKhVq5bw8PDQed4rV64s5s2bJ/z9/cUXX3whxo0bJ6ytrUWLFi0MXrOzs7MYNGiQ+Prrr0XTpk0FAJ3WEkPvp/y+ljk+/PBD4eTklOfzUxJISmB+/fVXcffuXREfHy82bdokKlSoIFQqlYiPj9fuW9AEpnz58uL+/fva8p9++kkAEFu3bn1hXMePHxe7d+8W8+fPFwDEqlWrxO7du0WfPn2Eh4eH2L17t9i9e7c4fvx4nvXkNKXn1fT2oq6Gbdu2CTc3N53EKTQ01Kgm1LySsmeb/dVqtWjatKlwcXERycnJIjw8XFhaWuolnJ6ennp/IFNSUoSbm5sIDAzUlk2ZMkXY29uLS5cu6RwfEREhlEqluHnzphDiv9ewdOnSIikpSWff3D7cAYjp06dryx48eCBsbW2FQqEQ69at05ZfuHBBABCRkZGS48rPe6sgXUhJSUnC2tpatG/fXmg0Gm352LFjBQCdBGbo0KECgNi/f7+27OHDh8Lb21t4eXlp/+A8m8A8efJEVK1aVdSuXVtb//MJTHZ2tnB2dhZ16tTRSWIXL16cr2T9eT///LMAIBYtWqRT3rBhQ1GxYkWdP4y7du0SSqVSKJVK0ahRIzFq1Cixc+fOfH3ZeN6z1zVixAjh6+urfaxevXoiLCxMCKHfjfrdd98JCwsLnedVCCFiYmIEAHHw4EFtWU7377NCQ0NFlSpVtD9v3rzZ4JezZxU0gQEgIiIidPbdv3+/ACBWr16tU75jxw698pzf00OHDmnLdu7cKQAIW1tbcePGDW35okWL9GJr1aqVqFmzps6XF41GIxo3biyqVq2qLcv5XA8JCdF5Pw8bNkwolUrx77//assK0oV05coVAUDMnTtX77GcL505SZ0QQmRlZQlXV1fRuXNnbVl0dLT2Mz1Hdna2aNSokShVqpRITU3N9fz5eU2F0H9/ZGdnixo1aoiWLVvqlAMQKpVKxMXFactynndXV1edWMaMGSMA6Oybc81ffPGFzjXXqVNHODs7a39/DL2f8vta5pg+fboAUOAuXVMjqQspJCQEFSpUgIeHB9555x3Y29tjy5YtqFSpkpTqAADdunVD2bJltT/ndEtdu3bthcfWrVsXISEhePLkCdzd3dGjRw+EhITg7t27aNWqFUJCQhASEoK6devmWseFCxcQHh6ORo0aoXfv3pKvo0KFCggMDMS0adPw448/YuLEidi/fz/CwsIk1wkAb775Jnbv3q23tWjRQruPhYUFli9fjrS0NLRt2xYLFizAmDFjEBQUpFefu7s7OnXqpP25dOnS6NWrF/78808kJCQAADZu3IhmzZqhbNmy2i665ORkhISEQK1W4/fff9eps3PnzqhQoUK+r+nDDz/U/r9MmTJ45ZVXYG9vj65du2rLX3nlFZQpU0bnfVDQuIx5bxny66+/Ijs7G5988olOV9PQoUP19t2+fTvq16+Ppk2bastKlSqF/v374/r16zh37pzeMUqlEuPGjcPp06fx448/Gozh+PHjSEpKwsCBA3W6Qvv06QNHR8cCX1ObNm1QoUIFnW6kuLg4HDlyBO+99x4sLP77qGjdujUOHz6MN954A6dPn8asWbMQGhqKihUrGmzSzq/u3bvjypUrOHbsmPbf3LqPNm7ciOrVq2u7h3O2li1bAgD27Nmj3ffZrtuc7ubg4GBcu3ZN262c0x22bds2PH78WPI1PO+jjz7Si9vR0RGtW7fWibtu3booVaqUTtwA4O/vj0aNGml/zpmc0LJlS1SuXFmvPOc9ff/+ffz222/o2rUrHj58qD3PvXv3EBoaisuXL+vNHO3fv7/O+7lZs2ZQq9W4ceOGpGu/d+8eAOj87j2rVKlSOrPfrK2tUb9+fZ3fy+3bt8PV1RXvvfeetszKygqDBw9GWloa9u3bl+v58/uaPvv+ePDgAVJSUtCsWTOcPHlSb99WrVrpDIHIed47d+6sM2D2+dcjh6WlJQYMGKBzzQMGDEBSUhJOnDhhMD4pr2XOc17YsxaLG0mzkObPn49q1aohJSUFS5cuxe+//643y6egnv1lBP57AZ7vF35eWloaMjMzAQC7d+9Gw4YNkZycDI1Gg/3792Pq1KlITk6GUqnM9RcpISEB7du3h6OjIzZt2gSlUinpGq5du4YWLVpg5cqV6Ny5M4CniUfO2iC//PIL2rZtK6nuSpUqISQk5IX7+fj4YOLEiRg5ciRq1KiB8ePHG9zP19dXb5xHzoym69evw9XVFZcvX8Zff/2Va1KSlJSk87O3t3d+LgUAYGNjo1evo6MjKlWqpBeXo6OjzvugoHFJfW/lJucDvWrVqjrlFSpU0HuP3bhxQ/th9qzq1atrH392xluOHj16YMqUKZg8eTLeeuutfMdgZWWFKlWq5P9i/s/S0hLdunXDggULcOvWLVSsWFGbzOSM3XhWvXr18MMPPyA7OxunT5/G5s2b8eWXX+Kdd97BqVOn4O/vX+AYAgMD4efnhzVr1qBMmTJwdXXVJiTPu3z5Ms6fP5+v98DBgwcRGRmJw4cPIyMjQ2e/lJQUODo6Ijg4GJ07d8akSZPw5Zdfonnz5njrrbfQvXt3yZ9tlpaWel/qLl++jJSUlFzHCr3ovZuTnHp4eBgsz3lPX7lyBUIIjB8/PtfPgKSkJFSsWDHXcxn7e5JD5DKWy9DvetmyZfHXX39pf75x4waqVq2qk0ADur8/ucnva7pt2zZMnToVp06d0hk/ZWgcnNTXI4e7uzvs7e11yp793G3YsKHeOaW8ljnP+cuYySgnSQlM/fr1td/q33rrLTRt2hTdu3fHxYsXtYO1FAqFwTeuWq02WGduSUNub/4cgwYN0hvQ9exg1MGDB2Pw4MHw9PTUG1QFPP0Aa9u2Lf7991/s378f7u7ueZ4vL8uXL0dmZiY6dOigU/7GG28AePpBKjWBKYhdu3YBAG7fvo179+7B1dVVUj0508Kfn9qa4/kp3AUZpJzb652f90FB45L63pJTTitMnz59XtpgvPfffx/z5s3D2rVrMWLECKxduxb+/v6oU6dOrsdYW1ujXr16qFevHqpVq4awsDBs3LgRkZGRkmLo3r07Fi5cCAcHB3Tr1k3vD1cOjUaDmjVrYs6cOQYfz/mDcvXqVbRq1Qp+fn6YM2cOPDw8YG1tje3bt+PLL7/UDvpWKBTYtGkTjhw5gq1bt2Lnzp344IMP8MUXX+DIkSMoVapUrn8McvtMU6lUevFrNBo4Oztj9erVBo95PiGT+nuSc10jRoxAaGiowX19fX0LVGdBlS9fHkDuCVBR/17m5zXdv38/3njjDbz22mtYsGAB3NzcYGVlhWXLlhkc1G7M55ZUUl7LnOfcycnJ6PMXZ5ISmGcplUpERUWhRYsWmDdvHiIiIgA8zaQNNdFLbY7MzahRo/D+++8jLi4O/fv3x8qVK+Hm5oYNGzZg+/bt2pkBhv64ZmZmomPHjrh06RJ+/fVXSd8an5WYmAghhN4HWk7z5ZMnT4yqPz9iYmKwe/duTJs2DVFRURgwYIDBP4A5Wf2zH8o569vkNJH6+PggLS0tXy0/L1NRxFWQbyqenp4Ann6bfra14+7du3of1p6enrh48aJeHTmzbXLqMuT999/H1KlTMWnSJG0SbCiGZ1spHj9+jLi4ONSuXTvf15OjQYMG8PHxwZo1a9C6dWv8/fffmDZtWr6Pz/lSc+fOnQKfO0f37t0xYcIE3LlzB999912u+/n4+OD06dNo1apVnq/d1q1bkZWVhS1btuh8e36+qyZHw4YN0bBhQ0ybNg1r1qxBjx49sG7dOnz44YfaFol///1X55iCfKb5+Pjg119/RZMmTYp0VmLO+9LKykq235PKlSvD1tYWcXFxks/n6emJv/76CxqNRicZzM/vT468XtPvv/8eNjY22Llzp06rzLJlyyTHnJfbt28jPT1dpxXm+c/d50l5LePi4uDk5FSgLn1TVCjTqJs3b4769esjOjpa253j4+ODCxcu6EzDO336dKEvJ+3v74+QkBBYWlqibNmyeP/99xESEoLU1FQ0bdpUO/7l+VUg1Wo1unXrhsOHD2Pjxo06/cxSVatWDUIIbNiwQad87dq1AJ42kReluLg4jBw5Ep07d8bYsWMxe/ZsbNmyBStXrtTb9/bt29i8ebP259TUVKxcuRJ16tTRtth07doVhw8f1q5q/Kx///33pSRkhhRFXDkfKM//cTIkJCQEVlZWmDt3rs43rOjoaL1927Vrh6NHj+Lw4cPasvT0dCxevBheXl55Js05rTCnTp3SG1sSFBSEChUqICYmBtnZ2dry5cuX5+sactOjRw/8+eefiIyMhEKhMDgGZc+ePQa/WW7fvh3A03FLUvn4+CA6OhpRUVGoX79+rvt17doVt27dwpIlS/Qee/ToEdLT0wH898342XhTUlL0/kA9ePBA75pyWp5yuhU8PT2hVCr1xlgtWLAgn1f3NG61Wo0pU6boPfbkyROjXrtnOTs7o3nz5li0aJHBhFLqUvP29vb5jtHKygpBQUE4fvy4pHMBT39/EhISsH79em3ZkydPMHfuXJQqVQrBwcG5Hpuf11SpVEKhUOh86bx+/XquY8+M9eTJEyxatEj7c3Z2NhYtWoQKFSrkOkZTymt54sSJQvmbVtwZ3QKTY+TIkejSpQuWL1+OgQMH4oMPPsCcOXMQGhqKvn37IikpCTExMQgICNCul1KYDh48iIYNG2q/IRw6dAgjRozIdf9PP/0UW7ZsQceOHXH//n2sWrVK5/FnB5fduHFD+20w55dx6tSpAJ5+qPXs2RPA0wGUs2fPxoABA/Dnn38iICAAJ0+exDfffIOAgACdQbN79+5FixYtEBkZma/VXy9duqQXI/B0zZnWrVtDCIEPPvgAtra22jUuBgwYgO+//x5DhgxBSEiITvdYtWrV0LdvXxw7dgwuLi5YunQpEhMTdT7YR44ciS1btqBDhw7o06cP6tati/T0dJw5cwabNm3C9evXZWmiLIq4cj48Bg8ejNDQUCiVSrz77rsG961QoQJGjBiBqKgodOjQAe3atcOff/6JX375Re+8ERERWLt2Ldq2bYvBgwejXLlyWLFiBeLi4vD999/n2kWSI2cszKlTp3TKraysMHXqVAwYMAAtW7ZEt27dEBcXh2XLlkkaA5Pj/fffx+TJk/HTTz+hSZMmBr8VfvLJJ8jIyECnTp3g5+eH7OxsHDp0COvXr4eXl5fRA9aHDBnywn169uyJDRs2YODAgdizZw+aNGkCtVqNCxcuYMOGDdi5cyeCgoLQpk0bWFtbo2PHjhgwYADS0tKwZMkSODs76/wxWLFiBRYsWIBOnTrBx8cHDx8+xJIlS1C6dGm0a9cOwNNxDV26dMHcuXOhUCjg4+ODbdu26Y1byUtwcDAGDBiAqKgonDp1Cm3atIGVlRUuX76MjRs34quvvsI777xT8CfNgPnz56Np06aoWbMm+vXrhypVqiAxMRGHDx/GP//8g9OnTxe4zrp162LhwoWYOnUqfH194ezsnOs4JeDpGMDPPvsMqampKF26dIHP179/fyxatAh9+vTBiRMn4OXlhU2bNuHgwYOIjo7Oc6XZ/Lym7du3x5w5c/D666+je/fuSEpKwvz58+Hr66szFqewuLu7Y+bMmbh+/TqqVauG9evX49SpU1i8eHGeq5UX5LVMSkrCX3/9hfDw8EKPv9gpyJSl3NaBEeLpFF4fHx/h4+Mjnjx5IoQQYtWqVaJKlSrC2tpa1KlTR+zcuTPXadSff/65Xp14bvpsXvz8/MSUKVOEEEL8888/L5w+96K1Y56VM33S0Pb8lMJ//vlHfPDBB8Lb21tYW1sLNzc30a9fP70VVLdu3SoAiJiYmBdeW15x5pz/q6++0psaLYQQN2/eFKVLlxbt2rXTlnl6eor27duLnTt3ilq1agmVSiX8/PzExo0b9c798OFDMWbMGOHr6yusra2Fk5OTaNy4sZg9e7betD9Dr2FuU0zt7e319g0ODhYBAQF65TnxFmZcz7+3njx5Ij755BNRoUIFoVAoXjilWq1Wi0mTJgk3Nzdha2srmjdvLs6ePWtwJd6rV6+Kd955R5QpU0bY2NiI+vXr660xkVesOb93gP5KvAsWLBDe3t5CpVKJoKAg8fvvvxd4Jd7n1atXTwAQCxYsMPj4L7/8Ij744APh5+cnSpUqJaytrYWvr6/45JNPJK/E+6IVhgH9lXizs7PFzJkzRUBAgFCpVKJs2bKibt26YtKkSSIlJUW735YtW0StWrWEjY2N8PLyEjNnztSujp0zzfXkyZPivffeE5UrVxYqlUo4OzuLDh066C29cPfuXdG5c2dhZ2cnypYtKwYMGCDOnj2b7/d4jsWLF4u6desKW1tb4eDgIGrWrClGjRolbt++rd3H0Ps+t+cit/fP1atXRa9evYSrq6uwsrISFStWFB06dBCbNm3S7pPb57qhaeMJCQmiffv2wsHBIV/T9RMTE4WlpaXeukq5/a4///chp46wsDDh5OQkrK2tRc2aNfO1Sm1+X9Nvv/1WVK1aVfs5uGzZMu378lkFed5znrtnP1Nzrvn48eOiUaNGwsbGRnh6euqt3J7bSrz5eS2FEGLhwoXCzs4uzynmJYVCiGI8krEEGzVqFNauXYsrV64YPYOroLy8vFCjRg1s27btpZ6XiMxP3759cenSJUmrRJckzZs3R3JyMs6ePVuk5wkMDETz5s3x5ZdfFul5ioNC60KigtmzZw/Gjx//0pMXIqKXKTIyEtWqVcPBgwd5R+oitmPHDly+fNng+MCSiAmMTPJ7nyciY9y9ezfXab7A02nQ5cqVK/TzpqSk4NGjR3nuI3V6P5mWypUrayd3UNF6/fXXkZaWJncYLw0TGKISrF69ei9c7Ov5mxMWhiFDhrzwhnvsvSYiY3AMDFEJdvDgwTxbQsqWLZvnLTakOnfuHG7fvp3nPsVtfSEiMi1MYIiIiMjkFMpCdkREREQvk9mMgdFoNLh9+zYcHBxK/A2uiIjIOEIIPHz4EO7u7i9ccNIYmZmZOqtpS2VtbQ0bG5tCiMh0mE0Cc/v2bb07hhIREeUlPj5e767ihSUzMxPenqWQkJT7TMH8cnV1RVxcnFklMWaTwOQsOd0U7WCJ3JdsJiIieoLHOIDted6uwFjZ2dlISFLjxgkvlHaQ3sqT+lADz7rXkZ2dzQSmJMrpNrKEFSwVTGCIiCgP/5/e8jKGHJRyUKCUg/TzaGCewyLMJoEhIiIqjtRCA7UR84HVQlN4wZgQJjBEREQy0kBAA+kZjDHHmjJOoyYiIiKTwxYYIiIiGWmggTGdQMYdbbqYwBAREclILQTURiyKb8yxpoxdSERERGRy2AJDREQkIw7ilYYJDBERkYw0EFAzgSkwdiERERGRyWELDBERkYzYhSQNExgiIiIZcRaSNOxCIiIiIpPDFhgiIiIZaf6/GXO8OWICQ0REJCO1kbOQjDnWlDGBISIikpFawMi7URdeLKaEY2CIiIjI5LAFhoiISEYcAyMNExgiIiIZaaCAGgqjjjdH7EIiIiIik8MWGCIiIhlpxNPNmOPNERMYIiIiGamN7EIy5lhTxi4kIiIiMjlsgSEiIpIRW2CkYQJDREQkI41QQCOMmIVkxLGmjF1IREREZHLYAkNERCQjdiFJwwSGiIhIRmpYQG1Eh4i6EGMxJUxgiIiIZCSMHAMjOAaGiIiIyDQUmwTm999/R8eOHeHu7g6FQoEff/xR53EhBCZMmAA3NzfY2toiJCQEly9flidYIiKiQpIzBsaYzRwVmwQmPT0dtWvXxvz58w0+PmvWLHz99deIiYnBH3/8AXt7e4SGhiIzM/MlR0pERFR41MLC6M0cFZsxMG3btkXbtm0NPiaEQHR0NMaNG4c333wTALBy5Uq4uLjgxx9/xLvvvvsyQyUiIiKZmUTaFhcXh4SEBISEhGjLHB0d0aBBAxw+fNjgMVlZWUhNTdXZiIiIihsNFNDAwoiNXUjFVkJCAgDAxcVFp9zFxUX72POioqLg6Oio3Tw8PIo8TiIiooLiGBhpTCKBkWLMmDFISUnRbvHx8XKHRERERIWk2IyByYurqysAIDExEW5ubtryxMRE1KlTx+AxKpUKKpXqZYRHREQkmbEDcdVCFGI0psMkWmC8vb3h6uqK2NhYbVlqair++OMPNGrUSMbIiIiIjPN0DIxxW0G9aOkSU1BsEpi0tDScOnUKp06dAvB04O6pU6dw8+ZNKBQKDB06FFOnTsWWLVtw5swZ9OrVC+7u7njrrbdkjZuIiMjUvGjpElNQbLqQjh8/jhYtWmh/Hj58OACgd+/eWL58OUaNGoX09HT0798f//77L5o2bYodO3bAxsZGrpCJiIiMpjHyXkgaFLwLKa+lS0xFsUlgmjdvDpFHP55CocDkyZMxefLklxgVERFR0SqsMTDPLxdS0seCFpsuJCIiInNk3BowTzcA8PDw0Fk+JCoqSuYrK1rFpgWGiIiIpIuPj0fp0qW1P5fk1heACQwREZGs1EIBtZC+GF3OsaVLl9ZJYEo6JjBEREQyUhs5iFctYRBvScAEhoiIyMykpaXhypUr2p9zli4pV64cKleuLGNk+ccEhoiISEYaYQGNEbOQNBJW4n3R0iWmgAkMERGRjOToQnrR0iWmgNOoiYiIyOSwBYaIiEhGGsCoWUiawgvFpDCBISIiktGzi9FJPd4cmedVExERkUljCwwREZGMjL8Xknm2RTCBISIikpEGCmhgzBgY6ceaMiYwREREMmILjDTmedVERERk0tgCQ0REJCPjF7Izz7YIJjBEREQy0ggFNMasA2PEsabMPNM2IiIiMmlsgSEiIpKRxsguJHNdyI4JDBERkYyMvxu1eSYw5nnVREREZNLYAkNERCQjNRRQG7EYnTHHmjImMERERDJiF5I05nnVREREZNLYAkNERCQjNYzrBlIXXigmhQkMERGRjNiFJA0TGCIiIhnxZo7SmOdVExERkUljCwwREZGMBBTQGDEGRnAaNREREb1s7EKSxjyvmoiIiEwaW2CIiIhkpBEKaIT0biBjjjVlTGCIiIhkpDbybtTGHGvKzPOqiYiIyKSxBYaIiEhG7EKShgkMERGRjDSwgMaIDhFjjjVl5nnVREREZNLYAkNERCQjtVBAbUQ3kDHHmjImMERERDLiGBhpmMAQERHJSBh5N2rBlXiJiIiITANbYIiIiGSkhgJqI27IaMyxpowJDBERkYw0wrhxLBpRiMGYEHYhERERkclhCwwREZGMNEYO4jXmWFPGBIaIiEhGGiigMWIcizHHmjLzTNuIiIjIpLEFhoiISEZciVcaJjBEREQy4hgYaczzqomIiMiksQWGiIhIRhoYeS8kMx3EywSGiIhIRsLIWUiCCQwRERG9bLwbtTQcA0NEREQmhy0wREREMuIsJGmYwBAREcmIXUjSmEzaplarMX78eHh7e8PW1hY+Pj6YMmUKhDDT23ASERGZMZNpgZk5cyYWLlyIFStWICAgAMePH0dYWBgcHR0xePBgucMjIiKShPdCksZkEphDhw7hzTffRPv27QEAXl5eWLt2LY4ePSpzZERERNKxC0kak+lCaty4MWJjY3Hp0iUAwOnTp3HgwAG0bdtW5siIiIjoZTOZFpiIiAikpqbCz88PSqUSarUa06ZNQ48ePQzun5WVhaysLO3PqampLytUIiKifGMLjDQm0wKzYcMGrF69GmvWrMHJkyexYsUKzJ49GytWrDC4f1RUFBwdHbWbh4fHS46YiIjoxXISGGM2KebPnw8vLy/Y2NigQYMGLxySER0djVdeeQW2trbw8PDAsGHDkJmZKenchcFkEpiRI0ciIiIC7777LmrWrImePXti2LBhiIqKMrj/mDFjkJKSot3i4+NfcsRERETF0/r16zF8+HBERkbi5MmTqF27NkJDQ5GUlGRw/zVr1iAiIgKRkZE4f/48vv32W6xfvx5jx459yZH/x2QSmIyMDFhY6IarVCqh0WgM7q9SqVC6dGmdjYiIqLiRowVmzpw56NevH8LCwuDv74+YmBjY2dlh6dKlBvc/dOgQmjRpgu7du8PLywtt2rTBe++9J+tEGpNJYDp27Ihp06bh559/xvXr17F582bMmTMHnTp1kjs0IiIiyQT+m0otZctZDS01NVVne3Yc6LOys7Nx4sQJhISEaMssLCwQEhKCw4cPGzymcePGOHHihDZhuXbtGrZv34527doV5lNRICYziHfu3LkYP348Pv74YyQlJcHd3R0DBgzAhAkT5A6NiIhIssIaxPv8WM/IyEhMnDhRb//k5GSo1Wq4uLjolLu4uODChQsGz9G9e3ckJyejadOmEELgyZMnGDhwoKxdSCaTwDg4OCA6OhrR0dFyh0JERFTsxMfH6wyXUKlUhVb33r17MX36dCxYsAANGjTAlStXMGTIEEyZMgXjx48vtPMUhMkkMERERCVRYbXA5He8p5OTE5RKJRITE3XKExMT4erqavCY8ePHo2fPnvjwww8BADVr1kR6ejr69++Pzz77TG+M6stgMmNgiIiISqKXPYjX2toadevWRWxs7H8xaDSIjY1Fo0aNDB6T20QaALLdk5AtMERERGZm+PDh6N27N4KCglC/fn1ER0cjPT0dYWFhAIBevXqhYsWK2qVKOnbsiDlz5iAwMFDbhTR+/Hh07NhRm8i8bExgiIiIZCTHSrzdunXD3bt3MWHCBCQkJKBOnTrYsWOHdmDvzZs3dVpcxo0bB4VCgXHjxuHWrVuoUKGCdnawXBRCrraflyw1NRWOjo5ojjdhqbCSOxwiIirGnojH2IufkJKSUmTriOX8XWry0yBY2ksfcPskPQsH35xXpLEWRxwDQ0RERCaHXUhEREQyylmQzpjjzRETGCIiIhnxbtTSsAuJiIiITA5bYIiIiGQkhALCiFYUY441ZUxgiIiIZMQuJGmYwBAREcmILTDScAwMERERmRy2wBAREclIGNmFZK4tMExgiIiIZCQAGLMmvlksp28Au5CIiIjI5LAFhoiISEYaKKDgSrwFxgSGiIhIRpyFJA27kIiIiMjksAWGiIhIRhqhgIIL2RUYExgiIiIZCWHkLCQznYbELiQiIiIyOWyBISIikhEH8UrDBIaIiEhGTGCkYQJDREQkIw7ilYZjYIiIiMjksAWGiIhIRpyFJA0TGCIiIhk9TWCMGQNTiMGYEHYhERERkclhCwwREZGMOAtJGiYwREREMhL/34w53hyxC4mIiIhMDltgiIiIZMQuJGmMSmCysrLwxx9/4MaNG8jIyECFChUQGBgIb2/vwoqPiIioZGMfkiSSEpiDBw/iq6++wtatW/H48WM4OjrC1tYW9+/fR1ZWFqpUqYL+/ftj4MCBcHBwKOyYiYiISg4jW2Bgpi0wBR4D88Ybb6Bbt27w8vLCrl278PDhQ9y7dw///PMPMjIycPnyZYwbNw6xsbGoVq0adu/eXRRxExERkRkrcAtM+/bt8f3338PKysrg41WqVEGVKlXQu3dvnDt3Dnfu3DE6SCIiopKKK/FKU+AEZsCAAVCr1fna19/fH/7+/gUOioiIyFyYyyDemzdv6oyZDQgIgEqlklyfpGnUFStWREREBC5duiT5xERERFSyXb9+HaNHj4anpye8vb0RHByMtm3bIigoCI6OjmjdujU2btwIjUZT4LolJTDh4eHYtGkTqlevjmbNmmH58uXIyMiQUhUREZF5Ewrjt2Jo8ODBqF27NuLi4jB16lScO3cOKSkpyM7ORkJCArZv346mTZtiwoQJqFWrFo4dO1ag+iUlMOPHj8eVK1cQGxuLKlWqYNCgQXBzc0O/fv3wxx9/SKmSiIjILOWMgTFmK47s7e1x7do1bNiwAT179sQrr7wCBwcHWFpawtnZGS1btkRkZCTOnz+P2bNnIz4+vkD1G7USb/PmzbFixQokJCTgiy++wPnz59GoUSMEBARgzpw5xlRNREREJiwqKgrly5fP176vv/463n777QLVXyi3EihVqhQ+/PBDHDhwAFu3bkVCQgJGjhxZGFUTERGVbKIQtmIqKCgIMTExSE1NLfS6CyWBycjIwPLlyxEcHIw33ngD5cuXx7Rp0wqjaiIiohItZxaSMVtxVbt2bYwaNQpubm7o2bMn9u7dW2h1G5XAHDp0CB9++CHc3NwQHh4OLy8v7NmzB5cuXUJERERhxUhEREQm6Ntvv0VCQgLmz5+P+Ph4tGrVCr6+vpg+fTpu3bplVN2SEphZs2ZpZyCdOXMGn3/+ORISErBixQq89tprRgVERERkdkpg91EOOzs79OnTB3v37sWlS5fw7rvvYtGiRfDy8kL79u3xww8/SKpXUgLz+eef4/XXX8fp06fxxx9/oH///rznERERkQQluQvpeT4+Ppg6dSquX7+OtWvX4siRI+jSpYukuiTdzPH27du53kqAiIiICsDM7ka9d+9eLFu2DN9//z0sLS3Rr18/SfUUuAVm3bp1+U5e4uPjcfDgwQIHRURERCXHP//8g6lTp8LX1xctW7bE9evXsWDBAty5cwcxMTGS6ixwArNw4UJUr14ds2bNwvnz5/UeT0lJwfbt29G9e3e8+uqruHfvnqTAiIiIzIOiELbiacOGDXj99dfh7e2NhQsXomvXrrh06RL27duHXr16wdbWVnLdBe5C2rdvH7Zs2YK5c+dizJgxsLe3h4uLC2xsbPDgwQMkJCTAyckJffr0wdmzZ+Hi4iI5OCIiohKvBHchvf/++2jfvj02b96Mdu3awcKiUFZvASBxDMwbb7yBN954A8nJyThw4ABu3LiBR48ewcnJCYGBgQgMDCzUIImIiMj0/PPPP3B2di6SuiUlMDmcnJzw1ltvFVIoREREZqiEtsAcOXIEDRs2zNe+GRkZiIuLQ0BAQL7rZzMJERGRnEro3ah79uyJ0NBQbNy4Eenp6Qb3OXfuHMaOHQsfHx+cOHGiQPUb1QJDREREZMi5c+ewcOFCjBs3Dt27d0e1atXg7u6uHTN74cIFpKWloVOnTti1axdq1qxZoPqZwBAREclIiKebMccXR1ZWVhg8eDAGDx6M48eP64yZrV27NoYNG4YWLVqgXLlykupnAkNERCSnEjoG5llBQUEICgoq1DpNagzMrVu38P7776N8+fKwtbVFzZo1cfz4cbnDIiIiopdMcgJz584drFq1Ctu3b0d2drbOY+np6Zg8ebLRwT3rwYMHaNKkCaysrPDLL7/g3Llz+OKLL1C2bNlCPQ8REdFLVUIH8RY1SQnMsWPH4O/vj/DwcLzzzjsICAjA33//rX08LS0NkyZNKrQgAWDmzJnw8PDAsmXLUL9+fXh7e6NNmzbw8fEp1PMQERG9TAph/CbF/Pnz4eXlBRsbGzRo0ABHjx7Nc/9///0X4eHhcHNzg0qlQrVq1bB9+3ZpJy8EkhKYsWPHolOnTnjw4AESExPRunVrBAcH488//yzs+LS2bNmCoKAgdOnSBc7OzggMDMSSJUty3T8rKwupqak6GxERUbEjCmEroPXr12P48OGIjIzEyZMnUbt2bYSGhiIpKcng/tnZ2WjdujWuX7+OTZs24eLFi1iyZAkqVqxY8JMXEkkJzIkTJxAREQELCws4ODhgwYIFGDFiBFq1aoVjx44VdowAgGvXrmHhwoWoWrUqdu7ciY8++giDBw/GihUrDO4fFRUFR0dH7ebh4VEkcREREZmaOXPmoF+/fggLC4O/vz9iYmJgZ2eHpUuXGtx/6dKluH//Pn788Uc0adIEXl5eCA4ORu3atV9y5P+RPAYmMzNT5+eIiAiMHTsWbdq0waFDh4wO7HkajQavvvoqpk+fjsDAQPTv3x/9+vXL9S6WY8aMQUpKinaLj48v9JiIiIiM9pLHwGRnZ+PEiRMICQnRlllYWCAkJASHDx82eMyWLVvQqFEjhIeHw8XFBTVq1MD06dOhVqtfeL5Hjx7hwIEDOHfunN5jmZmZWLlyZYHi18Ys5aAaNWoYTFJGjBiBMWPG4L333pMUTF7c3Nzg7++vU1a9enXcvHnT4P4qlQqlS5fW2YiIiIqdQupCen7YRFZWlsHTJScnQ61W691s2cXFBQkJCQaPuXbtGjZt2gS1Wo3t27dj/Pjx+OKLLzB16tQ8L+3SpUuoXr06XnvtNdSsWRPBwcG4c+eO9vGUlBSEhYXlWUduJCUwvXr1wsGDBw0+NmrUKEyaNAmVK1eWFFBumjRpgosXL+qUXbp0CZ6enoV6HiIiIlPk4eGhM3QiKiqq0OrWaDRwdnbG4sWLUbduXXTr1g2fffZZrr0gOUaPHo0aNWogKSkJFy9ehIODA5o0aZJr40NBSFrI7sMPP8SHH36Y6+OjR4/G6NGjJQdlyLBhw9C4cWNMnz4dXbt2xdGjR7F48WIsXry4UM9DRET0UhXSQnbx8fE6vQ0qlcrg7k5OTlAqlUhMTNQpT0xMhKurq8Fj3NzcYGVlBaVSqS2rXr06EhISkJ2dDWtra4PHHTp0CL/++iucnJzg5OSErVu34uOPP0azZs2wZ88e2NvbF+RKdZjMQnb16tXD5s2bsXbtWtSoUQNTpkxBdHQ0evToIXdoRERE0hVSF9LzwyZyS2Csra1Rt25dxMbGass0Gg1iY2PRqFEjg8c0adIEV65cgUaj0ZZdunQJbm5uuSYvwNPxL5aW/7WVKBQKLFy4EB07dkRwcDAuXbqU1zOTJ6MSmMTERPTs2RPu7u6wtLSEUqnU2Qpbhw4dcObMGWRmZuL8+fPo169foZ+DiIiopBs+fDiWLFmCFStW4Pz58/joo4+Qnp6uHY/Sq1cvjBkzRrv/Rx99hPv372PIkCG4dOkSfv75Z0yfPh3h4eF5nsfPz8/givnz5s3Dm2++iTfeeEPyNRh1L6Q+ffrg5s2bGD9+PNzc3KBQmOdqgERERJIZu5quhGO7deuGu3fvYsKECUhISECdOnWwY8cO7cDemzdvwsLivzYODw8P7Ny5E8OGDUOtWrVQsWJFDBky5IXDRTp16oS1a9eiZ8+eeo/NmzcPGo3mheNocqMQQvp9LB0cHLB//37UqVNHahUvTWpqKhwdHdEcb8JSYSV3OEREVIw9EY+xFz8hJSWlyGax5vxdqjxrKixsbSTXo3mUiZujxhVprMWRUV1IHh4eMCL/ISIiIjOwatUqpKenF2qdRiUw0dHRiIiIwPXr1wspHCIiIjMjw60EXrZhw4bBxcUF3bt3x/bt2/O1AN6LFHgMTNmyZXXGuqSnp8PHxwd2dnawstLtmrl//77RARIREZFpu3PnDnbs2IG1a9eia9eusLOzQ5cuXdCjRw80btxYUp0FTmCio6MlnYiIiIj0KSD9jtI5xxd3lpaW6NChAzp06ICMjAxs3rwZa9asQYsWLVCpUiVcvXq14HUW9IDevXsX+CREREREAGBnZ4fQ0FA8ePAAN27cwPnz5yXVY9QYmO3bt2Pnzp165bt27cIvv/xiTNVERETm4SXfzFEuGRkZWL16Ndq1a4eKFSsiOjoanTp1wt9//y2pPqMSmIiICIMDcTQaDSIiIoypmoiIyDyYwSDed999F87Ozhg2bBiqVKmCvXv34sqVK5gyZQr8/Pwk1WnUQnaXL1/Wu0M08HTlvStXrhhTNREREZUQSqUSGzZsQGhoaKGt1G9UAuPo6Ihr167By8tLp/zKlStG3aCJiIjIbBTSzRyLs9WrVxd6nUZ1Ib355psYOnSozujhK1eu4NNPPzXq/gZERETmQiGM38yRUQnMrFmzYG9vDz8/P3h7e8Pb2xvVq1dH+fLlMXv27MKKkYiIiEiH0V1Ihw4dwu7du3H69GnY2tqiVq1aeO211worPiIiopLNDLqQioJRCQwAKBQKtGnTBm3atCmMeIiIiMwLExhJjOpCIiIiIsqPq1evYty4cXjvvfeQlJQEAPjll1/kWQeGiIiIjGMOg3j37duHmjVr4o8//sAPP/yAtLQ0AMDp06cRGRkpqU4mMERERHIyg5V4IyIiMHXqVOzevRvW1tba8pYtW+LIkSOS6mQCQ0REJCczWIn3zJkz6NSpk165s7MzkpOTJdVpdAJT2H1aREREVLKUKVMGd+7c0Sv/888/UbFiRUl1GpXAFEWfFhERkTkxhzEw7777LkaPHo2EhAQoFApoNBocPHgQI0aMQK9evSTVafTNHAu7T4uIiMismEEX0vTp0+Hn5wcPDw+kpaXB398fr732Gho3boxx48ZJqtOodWDOnDmDNWvW6JUb06dFREREJYu1tTWWLFmCCRMm4MyZM0hLS0NgYCCqVq0quU6jWmCKok+LiIjIrBjbfWQCLTCTJ09GRkYGPDw80K5dO3Tt2hVVq1bFo0ePMHnyZEl1GpXAFEWfFhERkVkxgy6kSZMmacfJPisjIwOTJk2SVKdRCUxR9GkRERFRySKEgEKhv17N6dOnUa5cOUl1GjUGpij6tIiIiMxKCb4XUtmyZaFQKKBQKFCtWjWdJEatViMtLQ0DBw6UVLdRCczkyZMxYsQIeHh4wMPDQ1v+6NEjfP7555gwYYIx1RMREZV4xk6FLs7TqKOjoyGEwAcffIBJkybB0dFR+5i1tTW8vLzQqFEjSXUrhBCSL12pVOLOnTtwdnbWKb937x6cnZ2hVqulVl3oUlNT4ejoiOZ4E5YKK7nDISKiYuyJeIy9+AkpKSkoXbp0kZwj5++Sz9jpUNrYSK5HnZmJq9PHFmmsxtq3bx8aN24MK6vC+/trVAtMUfRpERERUckSHBys/X9mZiays7N1HpeSeElKYIqyT4uIiMislOAxMDkyMjIwatQobNiwAffu3dN7XEqPjaQEpij7tIiIiMxJSR4Dk2PkyJHYs2cPFi5ciJ49e2L+/Pm4desWFi1ahBkzZkiqU1IC07t3bwCAt7d3ofdpERERUcmydetWrFy5Es2bN0dYWBiaNWsGX19feHp6YvXq1ejRo0eB6zRqDExR9GkRERGZHRNoRTHG/fv3UaVKFQBPc4P79+8DAJo2bYqPPvpIUp1GLWSXkZGBQYMGwdnZGfb29ihbtqzORkRERC9gBivxVqlSBXFxcQAAPz8/bNiwAcDTlpkyZcpIqtOoBGbkyJH47bffsHDhQqhUKnzzzTeYNGkS3N3dsXLlSmOqJiIiohIiLCwMp0+fBgBERERg/vz5sLGxwbBhwzBy5EhJdRrVhVQUfVpERETmxBwG8Q4bNkz7/5CQEFy4cAEnTpyAr68vatWqJalOoxKYoujTIiIiMitmMI36eZ6envD09DSqDqMSmJw+rcqVK2v7tOrXr29UnxYRERGVDI8ePUJsbCw6dOgAABgzZgyysrK0jyuVSkyZMgU2ElYiNiqByenTCg4ORkREBDp27Ih58+bh8ePHmDNnjjFVExERmYWS3IW0YsUK/Pzzz9oEZt68eQgICICtrS0A4MKFC3B3d9fpYsovoxKYoujTIiIiMisluAtp9erVGDVqlE7ZmjVrtMNPVq1ahfnz57/8BOZ5hdGnRURERCXDlStXULNmTe3PNjY2sLD4bwJ0/fr1ER4eLqluSQlMUfZpERERmZUS3ALz77//6uQHd+/e1Xlco9HoPF4QkhKYouzTIiIiMicleQxMpUqVcPbsWbzyyisGH//rr79QqVIlSXVLWshu9erV6N+/v07ZmjVrsGfPHuzZsweff/65dpU9IiIiykMJXom3Xbt2mDBhAjIzM/Uee/ToESZNmoT27dtLqltSC0xR9mkRERFRyTB27Fhs2LABr7zyCgYNGoRq1aoBAC5evIh58+bhyZMnGDt2rKS6JSUwRdmnRUREZFZK8BgYFxcXHDp0CB999BEiIiIgxNNgFQoFWrdujQULFsDFxUVS3ZISmKLs0yIiIjInJXkMDAB4e3tjx44duH//Pq5cuQIA8PX1Rbly5YyqV9IYmKLs0yIiIqKSp1y5cqhfvz7q169vdPICSGyBKco+LSIiIrNSgruQipKkBKYo+7SIiIjMSUnvQioqklfiLao+LSIiIqIXMfpWAjl9WkRERCQBu5AkKdR7IREREVEBMYGRRNIsJCIiIiI5sQWGiIhIRor/b8Ycb45MtgVmxowZUCgUGDp0qNyhEBERSVeC74VUlEwygTl27BgWLVqEWrVqyR0KERGRUXKmURuzSTF//nx4eXnBxsYGDRo0wNGjR/N13Lp166BQKPDWW29JO3EhMbkEJi0tDT169MCSJUtQtmxZucMhIiIyOevXr8fw4cMRGRmJkydPonbt2ggNDUVSUlKex12/fh0jRoxAs2bNXlKkuTO5BCY8PBzt27dHSEhInvtlZWUhNTVVZyMiIip2ZOhCmjNnDvr164ewsDD4+/sjJiYGdnZ2WLp0aa7HqNVq9OjRA5MmTUKVKlUKftJCZlIJzLp163Dy5ElERUW9cN+oqCg4OjpqNw8Pj5cQIRERkQSFkLw8/6U9KyvL4Kmys7Nx4sQJnYYACwsLhISE4PDhw7mGOHnyZDg7O6Nv375GXGjhMZkEJj4+HkOGDMHq1athY2Pzwv3HjBmDlJQU7RYfH/8SoiQiIpKHh4eHzhf33L7sJycnQ61W693yx8XFBQkJCQaPOXDgAL799lssWbKk0OOWymSmUZ84cQJJSUl49dVXtWVqtRq///475s2bh6ysLCiVSu1jKpUKKpVKjlCJiIjyrbDuhRQfH4/SpUtrywvrb+DDhw/Rs2dPLFmyBE5OToVSZ2EwmQSmVatWOHPmjE5ZWFgY/Pz8MHr0aJ3khYiIyGQU0kq8pUuX1klgcuPk5ASlUonExESd8sTERLi6uurtf/XqVVy/fh0dO3bUlmk0GgCApaUlLl68CB8fHyMuQBqTSWAcHBxQo0YNnTJ7e3uUL19er5yIiIgMs7a2Rt26dREbG6udCq3RaBAbG4tBgwbp7e/n56fXgDBu3Dg8fPgQX331lWxjTE0mgSEiIiqJCqsLqSCGDx+O3r17IygoCPXr10d0dDTS09MRFhYGAOjVqxcqVqyIqKgo2NjY6DUUlClTBgBkbUAw6QRm7969codARERkHBlu5titWzfcvXsXEyZMQEJCAurUqYMdO3ZoB/bevHkTFhbFe56PSScwREREJM2gQYMMdhkBL24gWL58eeEHVEBMYIiIiGQkRxdSScAEhoiISE4ydCGVBExgiIiI5MQERpLiPUKHiIiIyAC2wBAREcmIY2CkYQJDREQkJ3YhScIuJCIiIjI5bIEhIiKSkUIIKIT0ZhRjjjVlTGCIiIjkxC4kSdiFRERERCaHLTBEREQy4iwkaZjAEBERyYldSJKwC4mIiIhMDltgiIiIZMQuJGmYwBAREcmJXUiSMIEhIiKSEVtgpOEYGCIiIjI5bIEhIiKSE7uQJGECQ0REJDNz7QYyBruQiIiIyOSwBYaIiEhOQjzdjDneDDGBISIikhFnIUnDLiQiIiIyOWyBISIikhNnIUnCBIaIiEhGCs3TzZjjzRG7kIiIiMjksAWGiIhITuxCkoQJDBERkYw4C0kaJjBERERy4jowknAMDBEREZkctsAQERHJiF1I0jCBISIikhMH8UrCLiQiIiIyOWyBISIikhG7kKRhAkNERCQnzkKShF1IREREZHLYAkNERCQjdiFJwwSGiIhITpyFJAm7kIiIiMjksAWGiIhIRuxCkoYJDBERkZw04ulmzPFmiAkMERGRnDgGRhKOgSEiIiKTwxYYIiIiGSlg5BiYQovEtDCBISIikhNX4pWEXUhERERkctgCQ0REJCNOo5aGCQwREZGcOAtJEnYhERERkclhCwwREZGMFEJAYcRAXGOONWVMYIiIiOSk+f9mzPFmiF1IREREZHLYAkNERCQjdiFJwwSGiIhITpyFJAm7kIiIiOSUsxKvMZsE8+fPh5eXF2xsbNCgQQMcPXo0132XLFmCZs2aoWzZsihbtixCQkLy3P9lMJkEJioqCvXq1YODgwOcnZ3x1ltv4eLFi3KHRUREZHLWr1+P4cOHIzIyEidPnkTt2rURGhqKpKQkg/vv3bsX7733Hvbs2YPDhw/Dw8MDbdq0wa1bt15y5P8xmQRm3759CA8Px5EjR7B79248fvwYbdq0QXp6utyhERERSZazEq8xW0HNmTMH/fr1Q1hYGPz9/RETEwM7OzssXbrU4P6rV6/Gxx9/jDp16sDPzw/ffPMNNBoNYmNjjbx66UxmDMyOHTt0fl6+fDmcnZ1x4sQJvPbaazJFRUREZKRCupljamqqTrFKpYJKpdLbPTs7GydOnMCYMWO0ZRYWFggJCcHhw4fzdcqMjAw8fvwY5cqVkx63kUymBeZ5KSkpAJDrk5eVlYXU1FSdjYiIqKTy8PCAo6OjdouKijK4X3JyMtRqNVxcXHTKXVxckJCQkK9zjR49Gu7u7ggJCTE6bqlMpgXmWRqNBkOHDkWTJk1Qo0YNg/tERUVh0qRJLzkyIiKiglFonm7GHA8A8fHxKF26tLbcUOtLYZgxYwbWrVuHvXv3wsbGpkjOkR8m2QITHh6Os2fPYt26dbnuM2bMGKSkpGi3+Pj4lxghERFRPhXSLKTSpUvrbLklME5OTlAqlUhMTNQpT0xMhKura56hzp49GzNmzMCuXbtQq1atwrl+iUwugRk0aBC2bduGPXv2oFKlSrnup1Kp9F5MIiIic2dtbY26devqDMDNGZDbqFGjXI+bNWsWpkyZgh07diAoKOhlhJonk+lCEkLgk08+webNm7F37154e3vLHRIREZHxZFjIbvjw4ejduzeCgoJQv359REdHIz09HWFhYQCAXr16oWLFitpxNDNnzsSECROwZs0aeHl5acfKlCpVCqVKlTIieOlMJoEJDw/HmjVr8NNPP8HBwUH75Dk6OsLW1lbm6IiIiKSR41YC3bp1w927dzFhwgQkJCSgTp062LFjh3Zg782bN2Fh8V8nzcKFC5GdnY133nlHp57IyEhMnDhRcuzGUAhhGjdRUCgUBsuXLVuGPn36vPD41NRUODo6ojnehKXCqpCjIyKikuSJeIy9+AkpKSlFNgQh5+9Si6CxsLSUPhj2yZNM7Dk+vUhjLY5MpgXGRPIsIiKigimkdWDMjckkMERERCWSAGDENGpzvZkjExgiIiIZyTEGpiQwuWnURERERGyBISIikpOAkWNgCi0Sk8IEhoiISE4cxCsJu5CIiIjI5LAFhoiISE4aAIaXOsv/8WaICQwREZGMOAtJGnYhERERkclhCwwREZGcOIhXEiYwREREcmICIwm7kIiIiMjksAWGiIhITmyBkYQJDBERkZw4jVoSJjBEREQy4jRqaTgGhoiIiEwOW2CIiIjkxDEwkjCBISIikpNGAAojkhCNeSYw7EIiIiIik8MWGCIiIjmxC0kSJjBERESyMjKBgXkmMOxCIiIiIpPDFhgiIiI5sQtJEiYwREREctIIGNUNxFlIRERERKaBLTBERERyEpqnmzHHmyEmMERERHLiGBhJzC6BsbC1gYXC+ukPz/UbCrX6mR90M1phqI/RTLNeIiIqRBwDIwnHwBAREZHJMbsWGCIiomKFXUiSMIEhIiKSk4CRCUyhRWJS2IVEREREJoctMERERHJiF5IkTGCIiIjkpNEAMGJWq8Y8Z8SaXwJTzQtQqgANoPj/i654/P/p05nZ/+2XkaFzmCYtXa8qkZVl8BQ607GJiIio0JlfAkNERFScsAtJEiYwREREcmICIwlnIREREZHJYQsMERGRnHgrAUmYwBAREclICA2EEffWM+ZYU2Z2Cczt1xyhVNlAoQYsnjwts0p/mr3aPPjvTWB355HOccpb9/Tq0ty7b/Ac4tEjg+VERER6hDCuFYVjYIiIiIhMg9m1wBARERUrwsgxMGbaAsMEhoiISE4aDaAwYhwLx8CYB1XwPSjtVMh+bIn0TCsAwJMHNgAAm9tK7X5lbO10jivz6LFeXYqHaYZPkml4hV4tM32zERERFRazS2CIiIiKFXYhScIEhoiISEZCo4EwogvJXKdRcxYSERERmRyza4EZWOV32JayxEO1Da5nVQAA/Hm/IgDgipWrdj/rVCud40rFq/TqsrI0u6ePiIgKG7uQJOFfYCIiIjlpBKBgAlNQ7EIiIiIik2N2LTCtbG/Cwc4CKRrgknUyAEAtFACAfx6U0e73xE63C0ljpYQeC0WRxUlERGZCCADGrANjni0wZpfAEBERFSdCIyCM6EISZprAmF0XUnmlHZyUdnBSWqC8Mg3llWlwtHwER8tHUFk90W4aS+hsQqnQ26AwvCks8t6IiIi0hMb4TYL58+fDy8sLNjY2aNCgAY4ePVrIF1a0zC6ByRKP/79p8FhYPt00SjzWKKHWWGg3xf/HVP23Cb2NiIjIFK1fvx7Dhw9HZGQkTp48idq1ayM0NBRJSUlyh5ZvZpfAEBERFSdCI4zeCmrOnDno168fwsLC4O/vj5iYGNjZ2WHp0qVFcIVFw+zGwDzQZOOJxgL/apS4p7YHAKQ+sQUAPH7y30BdS/VzBxpqoculFUbKm4mIiMyU0MC4QbxPj01NTdUpVqlUUKn01zDLzs7GiRMnMGbMGG2ZhYUFQkJCcPjwYelxvGRmk8DkDHK6lmIFe7UFUtQ2iHtcCgCQlPI0ccn+978bNlqkZ+ocr87W/RkAnmiyDZ7ridC/8aNuMOa57DMRkal4gqef4y9jgOwTPDZqHbucWD08PHTKIyMjMXHiRL39k5OToVar4eLiolPu4uKCCxcuSA/kJTObBObhw4cAgI4Nbz1Tevn//x544fEXCz8kIiIq5h4+fAhHR8ciqdva2hqurq44kLDd6LpcXV1x+vRp2NjYaMsMtb6UJGaTwLi7uyM+Ph4ODg5QKDgTKEdqaio8PDwQHx+P0qVLyx1OscPnJ298fvLG5ydvxfn5EULg4cOHcHd3L7Jz2NjYIC4uDtnZhlvzC8La2lonecmLk5MTlEolEhMTdcoTExPh6uqay1HFj9kkMBYWFqhUqZLcYRRbpUuXLnYfIMUJn5+88fnJG5+fvBXX56eoWl6eZWNjk+/Eo7BYW1ujbt26iI2NxVtvvQUA0Gg0iI2NxaBBg15qLMYwmwSGiIiInho+fDh69+6NoKAg1K9fH9HR0UhPT0dYWJjcoeUbExgiIiIz061bN9y9excTJkxAQkIC6tSpgx07dugN7C3OmMCYOZVKhcjIyBI/2EsqPj954/OTNz4/eePzI69BgwaZVJfR8xTCXG+iQERERCaLK/ESERGRyWECQ0RERCaHCQwRERGZHCYwREREZHKYwJihqKgo1KtXDw4ODnB2dsZbb72Fixd5s4TczJgxAwqFAkOHDpU7lGLj1q1beP/991G+fHnY2tqiZs2aOH78uNxhFRtqtRrjx4+Ht7c3bG1t4ePjgylTpryU++oUR7///js6duwId3d3KBQK/PjjjzqPCyEwYcIEuLm5wdbWFiEhIbh8+bLhyoj+jwmMGdq3bx/Cw8Nx5MgR7N69G48fP0abNm2Qnp4ud2jFzrFjx7Bo0SLUqlVL7lCKjQcPHqBJkyawsrLCL7/8gnPnzuGLL75A2bJl5Q6t2Jg5cyYWLlyIefPm4fz585g5cyZmzZqFuXPnyh2aLNLT01G7dm3Mnz/f4OOzZs3C119/jZiYGPzxxx+wt7dHaGgoMjP1b6JLlIPTqAl3796Fs7Mz9u3bh9dee03ucIqNtLQ0vPrqq1iwYAGmTp2KOnXqIDo6Wu6wZBcREYGDBw9i//79codSbHXo0AEuLi749ttvtWWdO3eGra0tVq1aJWNk8lMoFNi8ebN2CXshBNzd3fHpp59ixIgRAICUlBS4uLhg+fLlePfdd2WMlooztsAQUlJSAADlypWTOZLiJTw8HO3bt0dISIjcoRQrW7ZsQVBQELp06QJnZ2cEBgZiyZIlcodVrDRu3BixsbG4dOkSAOD06dM4cOAA2rZtK3NkxU9cXBwSEhJ0fs8cHR3RoEEDHD58WMbIqLjjSrxmTqPRYOjQoWjSpAlq1KghdzjFxrp163Dy5EkcO3ZM7lCKnWvXrmHhwoUYPnw4xo4di2PHjmHw4MGwtrZG79695Q6vWIiIiEBqair8/PygVCqhVqsxbdo09OjRQ+7Qip2EhAQA0FvC3sXFRfsYkSFMYMxceHg4zp49iwMHDsgdSrERHx+PIUOGYPfu3S/9LrGmQKPRICgoCNOnTwcABAYG4uzZs4iJiWEC838bNmzA6tWrsWbNGgQEBODUqVMYOnQo3N3d+RwRFRJ2IZmxQYMGYdu2bdizZw8qVaokdzjFxokTJ5CUlIRXX30VlpaWsLS0xL59+/D111/D0tISarVa7hBl5ebmBn9/f52y6tWr4+bNmzJFVPyMHDkSERERePfdd1GzZk307NkTw4YNQ1RUlNyhFTuurq4AgMTERJ3yxMRE7WNEhjCBMUNCCAwaNAibN2/Gb7/9Bm9vb7lDKlZatWqFM2fO4NSpU9otKCgIPXr0wKlTp6BUKuUOUVZNmjTRm3Z/6dIleHp6yhRR8ZORkQELC92PV6VSCY1GI1NExZe3tzdcXV0RGxurLUtNTcUff/yBRo0ayRgZFXfsQjJD4eHhWLNmDX766Sc4ODho+5kdHR1ha2src3Tyc3Bw0BsPZG9vj/Lly3OcEIBhw4ahcePGmD59Orp27YqjR49i8eLFWLx4sdyhFRsdO3bEtGnTULlyZQQEBODPP//EnDlz8MEHH8gdmizS0tJw5coV7c9xcXE4deoUypUrh8qVK2Po0KGYOnUqqlatCm9vb4wfPx7u7u7amUpEBgkyOwAMbsuWLZM7tGIrODhYDBkyRO4wio2tW7eKGjVqCJVKJfz8/MTixYvlDqlYSU1NFUOGDBGVK1cWNjY2okqVKuKzzz4TWVlZcocmiz179hj8zOndu7cQQgiNRiPGjx8vXFxchEqlEq1atRIXL16UN2gq9rgODBEREZkcjoEhIiIik8MEhoiIiEwOExgiIiIyOUxgiIiIyOQwgSEiIiKTwwSGiIiITA4TGCIiIjI5TGCIiIjI5DCBISKt5cuXo0yZMkVWf8+ePbV3sc6vHTt2oE6dOryPEBHpYAJDVIQSEhIwZMgQ+Pr6wsbGBi4uLmjSpAkWLlyIjIyMfNdT1IlFQfz999/o3LkzvLy8oFAoEB0dna/jTp8+je3bt2Pw4MEAgJo1a2LgwIEG9/3uu++gUqmQnJyM119/HVZWVli9enVhXQIRlQBMYIiKyLVr1xAYGIhdu3Zh+vTp+PPPP3H48GGMGjUK27Ztw6+//ip3iJJkZGSgSpUqmDFjBlxdXfN93Ny5c9GlSxeUKlUKANC3b1+sW7cOjx490tt32bJleOONN+Dk5AQA6NOnD77++uvCuQAiKhnkvhkTUUkVGhoqKlWqJNLS0gw+rtFotP//4osvRI0aNYSdnZ2oVKmS+Oijj8TDhw+FEIZvhBcZGSmEECIzM1N8+umnwt3dXdjZ2Yn69euLPXv25BnXgwcPRP/+/YWzs7NQqVQiICBAbN26VQghxLJly4Sjo6PYsWOH8PPzE/b29iI0NFTcvn3bYF2enp7iyy+/fOFz8eTJE+Ho6Ci2bdumLbt7966wtrYW3333nc6+165dEwqFQvzyyy/ashs3bggA4sqVKy88FxGZB7bAEBWBe/fuYdeuXQgPD4e9vb3BfRQKhfb/FhYW+Prrr/H3339jxYoV+O233zBq1CgAQOPGjREdHY3SpUvjzp07uHPnDkaMGAEAGDRoEA4fPox169bhr7/+QpcuXfD666/j8uXLBs+p0WjQtm1bHDx4EKtWrcK5c+cwY8YMKJVK7T4ZGRmYPXs2vvvuO/z++++4efOm9nxS/fXXX0hJSUFQUJC2zMnJCW+++SaWLl2qs+/y5ctRqVIltGnTRltWuXJluLi4YP/+/UbFQUQliNwZFFFJdOTIEQFA/PDDDzrl5cuXF/b29sLe3l6MGjUq1+M3btwoypcvr/05p2XkWTdu3BBKpVLcunVLp7xVq1ZizJgxBuvduXOnsLCwEBcvXjT4+LJly/RaOubPny9cXFwM7p/fFpjNmzcLpVKp0+okhBA7duwQCoVCXLt2TQjxtFXK09NTjBs3Tq+OwMBAMXHixBeei4jMg6XcCRSROTl69Cg0Gg169OiBrKwsbfmvv/6KqKgoXLhwAampqXjy5AkyMzORkZEBOzs7g3WdOXMGarUa1apV0ynPyspC+fLlDR5z6tQpVKpUSe+YZ9nZ2cHHx0f7s5ubG5KSkgpymXoePXoElUql0+oEAK1bt0alSpWwbNkyTJ48GbGxsbh58ybCwsL06rC1tS3QwGciKtmYwBAVAV9fXygUCly8eFGnvEqVKgCe/jHOcf36dXTo0AEfffQRpk2bhnLlyuHAgQPo27cvsrOzc01g0tLSoFQqceLECZ0uIADagbLPe/a8ubGystL5WaFQQAjxwuPy4uTkhIyMDGRnZ8Pa2lpbbmFhgT59+mDFihWYOHEili1bhhYtWmifp2fdv38fFSpUMCoOIio5OAaGqAiUL18erVu3xrx585Cenp7nvidOnIBGo8EXX3yBhg0bolq1arh9+7bOPtbW1lCr1TplgYGBUKvVSEpKgq+vr86W2+ygWrVq4Z9//sGlS5eMu8ACqlOnDgDg3Llzeo+FhYUhPj4eP/zwAzZv3oy+ffvq7ZOZmYmrV68iMDCwqEMlIhPBBIaoiCxYsABPnjxBUFAQ1q9fj/Pnz+PixYtYtWoVLly4oG018fX1xePHjzF37lxcu3YN3333HWJiYnTq8vLyQlpaGmJjY5GcnIyMjAxUq1YNPXr0QK9evfDDDz8gLi4OR48eRVRUFH7++WeDMQUHB+O1115D586dsXv3bsTFxeGXX37Bjh078n1d2dnZOHXqFE6dOoXs7GzcunULp06dwpUrV3I9pkKFCnj11Vdx4MABvce8vb3RsmVL9O/fHyqVCm+//bbePkeOHIFKpUKjRo3yHScRlXByD8IhKslu374tBg0aJLy9vYWVlZUoVaqUqF+/vvj8889Fenq6dr85c+YINzc3YWtrK0JDQ8XKlSsFAPHgwQPtPgMHDhTly5fXmUadnZ0tJkyYILy8vISVlZVwc3MTnTp1En/99VeuMd27d0+EhYWJ8uXLCxsbG1GjRg3t9GZDg4U3b94snv2oiIuL05vWDUAEBwfn+VwsWLBANGzY0OBja9asEQDExx9/bPDx/v37iwEDBuRZPxGZF4UQRnZuExHlw6NHj/DKK69g/fr1BWpJSU5OxiuvvILjx4/D29u7CCMkIlPCLiQieilsbW2xcuVKJCcnF+i469evY8GCBUxeiEgHW2CIiIjI5LAFhoiIiEwOExgiIiIyOUxgiIiIyOQwgSEiIiKTwwSGiIiITA4TGCIiIjI5TGCIiIjI5DCBISIiIpPDBIaIiIhMzv8AXj2ZxLLrznMAAAAASUVORK5CYII=\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1273,7 +1359,7 @@
     }
    ],
    "source": [
-    "dond(sweep_3, sweep_4, dmm.v1, dmm.v2, show_progress=True, do_plot=True) # 2d"
+    "dond(sweep_3, sweep_4, dmm.v1, dmm.v2, show_progress=True, do_plot=True)  # 2d"
    ]
   },
   {
@@ -1306,21 +1392,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 219. \n",
-      "Starting experimental run with id: 220. \n"
+      "Starting experimental run with id: 74. Using 'qcodes.dataset.dond'\n",
+      "Starting experimental run with id: 75. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "61258f2d18744df0b2d8b9a4d1a68760",
+       "model_id": "4749b6ff817047fc9c1364d7ba49ed74",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1333,7 +1419,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1343,7 +1429,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1365,12 +1451,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
-    "dataset_v1 = result[0][0] # dataset for the first group\n",
-    "dataset_v2 = result[0][1] # dataset for the second group"
+    "dataset_v1 = result[0][0]  # dataset for the first group\n",
+    "dataset_v2 = result[0][1]  # dataset for the second group"
    ]
   },
   {
@@ -1389,7 +1475,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1400,20 +1486,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 221. \n"
+      "Starting experimental run with id: 76. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "eec17bd8116b4b2ab64b7ff6c3c543ec",
+       "model_id": "a47566f763e84971b348fad0f3045e2b",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1426,7 +1512,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmZUlEQVR4nO3dd1gU1/4/8PeCsCAConRFQIwFG0YjsaKRiCW2JMau2PXKL1FjI9dY0BssiRIrxsSu15LYkhgUiWisSbAbNYKgaADFAgIKunt+f/hlruvStsCy7PvlM8/jnj1z5jOz7cM5Z2ZkQggBIiIiIhNiZugAiIiIiMoaEyAiIiIyOUyAiIiIyOQwASIiIiKTwwSIiIiITA4TICIiIjI5TICIiIjI5DABIiIiIpPDBIiIiIhMDhMgKtdkMhnmzJlj6DDKRIcOHdChQweDxhAcHAwvLy+DxkCULysrC87Ozti6dauhQzEa2n5n/vXXX6hUqRIuX76s/6DKqTJLgDZs2ACZTCYtlSpVQo0aNRAcHIy7d++WVRhFevz4MczMzHDw4EEAwJ49eyCXy5Gbm6tS748//kBISAgaNmwIGxsb1KpVCx999BH+/vtvlXpKpRIbNmxAz5494eHhARsbGzRq1Ajz58/Hs2fP1La/evVq9O3bF7Vq1YJMJkNwcLDO++Tl5aVy3F9dunTponP7BJw8eRJz5szB48ePDRZD/mv61VdfqT2X/9n7888/9brN58+fw9HREW3bti20jhACHh4eePPNN6WypKQkDB8+HD4+PrCysoKrqyvat2+P2bNna7T9V79Tjh8/Xui2ZTIZ3nvvPY3aJv3btm0bIiIiNFrn66+/hq2tLfr37186QZHE19cX3bt3x6xZswwdSpmpVNYbDAsLg7e3N549e4bTp09jw4YNOH78OC5fvgwrK6uyDkfF77//DgDw9/cHAJw6dQrNmjWDXC5Xqbdw4UKcOHECffv2RZMmTZCamooVK1bgzTffxOnTp9GoUSMAQE5ODoYPH463334b48aNg7OzM06dOoXZs2cjJiYGv/76K2QymUq7T548QcuWLZGSkqK3/fLz88Onn36qVu7u7q63bZSWp0+folKlMn+bauTkyZOYO3cugoODUbVqVYPGsnjxYowfPx6VK1cu9W1ZWFigb9++WLNmDW7dugVPT0+1OseOHcOdO3cwadIkAEB8fDzeeustWFtbY8SIEfDy8kJKSgrOnj2LhQsXYu7cuRrHYWVlhW3btqklYkePHsWdO3fUPr9kGNu2bcPly5cxceLEEtV//vw5vv76a0yaNAnm5ualGxwBAMaNG4du3bohISEBPj4+hg6n1JX5L0vXrl3RokULAMCoUaPg6OiIhQsXYv/+/fjoo4/KOhwVv//+O+rVqyf9iJ06dUpKhl41efJkbNu2DZaWllJZv3790LhxYyxYsABbtmwBAFhaWuLEiRNo3bq1VG/06NHw8vKSkqDAwEDpuaNHj0q9P1WqVNHbftWoUQODBw/WW3ulTalUIi8vD1ZWVgZPio2Jn58fzp8/j8jISEyePLlMtjlo0CBERkbiv//9L2bMmKH2/LZt22BmZib9Bb906VJkZWXh/PnzagnTvXv3tIqhW7du2LVrF5YtW6aSLG/btg3NmzdHenq6Vu2WJ9nZ2bCxsTF0GGXqp59+wv379w3+u2BKAgMD4eDggI0bNyIsLMzQ4ZQ6g88BateuHQAgISFBKitsLsTr8xOSkpIgk8nw5Zdf4ptvvoGPjw/kcjneeust/PHHHyXafkZGBtLT05Geno5Tp06hadOmSE9PR1paGuLi4lC/fn2kp6cjIyNDWqd169YqyQ8AvPHGG2jYsCGuXr0qlVlaWqokP/n69OkDACp1AcDT01OlR6is3Lt3D05OTujQoQOEEFJ5fHw8bGxs0K9fP6msQ4cOaNSoEeLi4tC6dWtYW1vD29sbkZGRau3m5uZi9uzZqFOnDuRyOTw8PDBt2jS1IUWZTIaQkBBs3boVDRs2hFwuR1RUlPTcq+PZc+bMgUwmw99//43BgwfD3t4eTk5O+PzzzyGEQHJyMnr16gU7Ozu4uroWOCSkaVx79+5Fo0aNIJfL0bBhQym2/HimTp0KAPD29paGZJKSkoo85vnvV2tra7Rs2RK//fZbgfXu3buHkSNHwsXFBVZWVmjatCk2btxYYN02bdrgnXfewaJFi/D06dMitw9A2i8rKys0atQIe/bsKXadgrbp5eWFbdu2qT33/PlzfP/99+jYsaPU25iQkICaNWsW2Fvk7Oys8fYBYMCAAXjw4AGio6Olsry8PHz//fcYOHBggesolUpERESgYcOGsLKygouLC8aOHYtHjx6p1Nu3bx+6d+8Od3d3yOVy+Pj4YN68eVAoFCr1bty4gQ8++ACurq6wsrJCzZo10b9/f+l7I/+7asOGDWqxFPYe/+uvvzBw4EA4ODio9G5t2bIFzZs3h7W1NapVq4b+/fsjOTlZpc38z+nFixcREBCAypUro06dOvj+++8BvPxjy9/fH9bW1qhXrx4OHz6sFtfdu3cxYsQIuLi4SO/9devWqdSJjY2FTCbDzp078Z///Ac1a9aElZUVOnXqhPj4eJV4fv75Z9y6dUv6jBQ312zv3r3w8vJS64kIDg5GlSpVcPfuXfTu3RtVqlSBk5MTpkyZova6ZGdn49NPP4WHhwfkcjnq1auHL7/8UuV7rjDFvaYAsH79erzzzjtwdnaGXC6Hr68vVq9erdaWl5cX3nvvPcTGxqJFixawtrZG48aNERsbCwDYvXs3GjduDCsrKzRv3hznzp0rcJ9v3ryJoKAg2NjYwN3dHWFhYSXal5K8lsDLXt0OHTpg3759xbZZIYgysn79egFA/PHHHyrlK1asEADE6tWrpbKAgAAREBCg1sawYcOEp6en9DgxMVEAEM2aNRN16tQRCxcuFIsWLRKOjo6iZs2aIi8vr9i4AgICBIBil4LieZVSqRQ1atQQnTt3Lnabhw4dEgDEtm3bCq1jY2Mjhg0bVmxbxfH09BSdO3cW9+/fV1tycnKkert27RIAxNdffy2EEEKhUIg2bdoIFxcXkZ6eLtULCAgQ7u7uwtnZWYSEhIhly5aJtm3bCgDiu+++k+opFArRuXNnUblyZTFx4kSxZs0aERISIipVqiR69eqlEiMA0aBBA+Hk5CTmzp0rVq5cKc6dOyc9N3v2bKnu7NmzBQDh5+cnBgwYIFatWiW6d+8uAIglS5aIevXqifHjx4tVq1aJNm3aCADi6NGjWsfVtGlT4ebmJubNmyciIiJE7dq1ReXKlaVjcuHCBTFgwAABQCxdulRs3rxZbN68WWRlZRX6mnz77bcCgGjdurVYtmyZmDhxoqhataqoXbu2yvssJydHNGjQQFhYWIhJkyaJZcuWiXbt2gkAIiIiQi3WCRMmiGPHjgkA4quvvpKeK+izd/DgQWFmZiYaNWoklixZIv79738Le3t70bBhQ5XPWEl89tlnAoC4fPmySvn+/fsFALFu3TqpbMyYMcLc3FzExMRotI2CvLpfrVu3FkOGDJGe27t3rzAzMxN3794Vnp6eonv37irrjho1SlSqVEmMHj1aREZGiunTpwsbGxvx1ltvqXxv9O7dW3z00Udi8eLFYvXq1aJv374CgJgyZYpUJzc3V3h7ewt3d3cxf/588e2334q5c+eKt956SyQlJQkh/vddtX79erX9KOw97uvrK3r16iVWrVolVq5cKYQQYv78+UImk4l+/fqJVatWiblz5wpHR0fh5eUlHj16JLWR/zn18PAQU6dOFcuXLxe+vr7C3NxcbN++Xbi6uoo5c+aIiIgIUaNGDWFvby8yMzOl9VNTU0XNmjWFh4eHCAsLE6tXrxY9e/aU3uf5jhw5In0HN2/eXCxdulTMmTNHVK5cWbRs2VKqd+jQIeHn5yccHR2lz8iePXuKfH3r1Kkj3n//fbXyYcOGCSsrK9GwYUMxYsQIsXr1avHBBx8IAGLVqlVSPaVSKd555x0hk8nEqFGjxIoVK0SPHj0EADFx4sQit12S11QIId566y0RHBwsli5dKpYvXy46d+4sAIgVK1aotOfp6Snq1asn3NzcxJw5c8TSpUtFjRo1RJUqVcSWLVtErVq1xIIFC8SCBQuEvb29qFOnjlAoFGr7/MYbb4ghQ4aIFStWiPfee08AEJ9//rnKtl5/P5X0tcw3f/58YWZmJjIyMoo8RhVBmSdAhw8fFvfv3xfJycni+++/F05OTkIul4vk5GSprqYJUPXq1cXDhw+l8n379gkA4scffyw2rj///FNER0eLlStXCgBiy5YtIjo6WgQHBwsPDw8RHR0toqOjxZ9//llkO5s3b1ZLAgoTGBgo7OzsVL6wXqfPBKiwpC48PFyl7oABA0TlypXF33//LRYvXiwAiL1796rUyU8YX/2Bzc3NFX5+fsLZ2Vn68di8ebMwMzMTv/32m8r6kZGRAoA4ceKEVAZAmJmZiStXrqjFX9iPw5gxY6SyFy9eiJo1awqZTCYWLFgglT969EhYW1urHEdN47K0tBTx8fFS2YULFwQAsXz5cqks/1glJiaqxf+6vLw84ezsLPz8/ERubq5U/s0336gl2hEREdJ78tX1W7VqJapUqaLyg5WfAAkhRMeOHYWrq6uU4BaUAPn5+Qk3Nzfx+PFjqSw/Mdc0Abpy5YoAIEJDQ1XK+/fvL6ysrFS+SC9fviysra2lJPaTTz4Re/fuFdnZ2Rpt8/X9WrFihbC1tZX2uW/fvqJjx45CCKGWAP32228CgNi6datKe1FRUWrlr/6RkG/s2LGicuXK4tmzZ0IIIc6dOycAiF27dhUaqzYJ0IABA1TqJSUlCXNzc/Gf//xHpfzSpUuiUqVKKuX5n9NX/8i6du2a9Fk7ffq0VH7w4EG12EaOHCnc3NxU/vgR4uVram9vLx2X/ASoQYMGKu/nr7/+WgAQly5dksq6d+9e4vfW8+fPhUwmE59++qnac8OGDRMARFhYmEp5fhKWb+/evQKAmD9/vkq9Dz/8UMhkMpXP9etK8poKUfD7IygoSNSuXVulLP97+OTJk1JZ/nG3trYWt27dksrXrFkjAIgjR46o7fP/+3//TypTKpWie/fuwtLSUty/f18qf/39VNLXMt+2bdsEAHHmzJki970iKPMhsMDAQDg5OcHDwwMffvghbGxssH//ftSsWVPrNvv16wcHBwfpcf6w2s2bN4tdt3nz5ggMDMSLFy/g7u6OQYMGITAwEPfv30enTp0QGBiIwMBANG/evNA2rl27hgkTJqBVq1YYNmxYkdv74osvcPjwYSxYsKDMJsz6+/sjOjpabRkwYIBKvRUrVsDe3h4ffvghPv/8cwwZMgS9evVSa69SpUoYO3as9NjS0hJjx47FvXv3EBcXBwDYtWsXGjRoIA0h5i/vvPMOAODIkSMqbQYEBMDX17fE+zRq1Cjp/+bm5mjRogWEEBg5cqRUXrVqVdSrV0/lfaBpXIGBgSpd8E2aNIGdnV2J3lsF+fPPP3Hv3j2MGzdOZRg1ODgY9vb2KnUPHDgAV1dXldfJwsICH3/8MbKysnD06NECtzFnzhykpqYWOCwJACkpKTh//jyGDRumss13331Xo9cgn6+vL5o1a4bt27dLZdnZ2di/fz/ee+892NnZSeUNGzbE+fPnMXjwYCQlJeHrr79G79694eLigrVr12q87XwfffQRnj59ip9++glPnjzBTz/9VOjw165du2Bvb493331X5T3QvHlzVKlSReU9YG1tLf3/yZMnSE9PR7t27ZCTk4Nr164BgHQMDx48iJycHK334XXjxo1Tebx7924olUp89NFHKnG7urrijTfeUHvvVqlSReXsqfz5jQ0aNFCZ25j///z3tBACP/zwA3r06AEhhMq2goKCkJGRgbNnz6psa/jw4SrvZ02+gwvy8OFDCCFUvtdf9/rxadeuncr2Dhw4AHNzc3z88ccq9T799FMIIfDLL78U2nZJX9NX3x/50ykCAgJw8+ZNlaEy4OXnpFWrVtLj/OP+zjvvoFatWmrlBR27kJAQ6f/5Q/R5eXkFDmEC2r2W+ce8IsydK06ZT4JeuXIl6tati4yMDKxbtw7Hjh3T+SyNV988wP9ewNfH81+XlZUlnY4eHR2Nt99+G+np6VAqlfjtt98wf/58pKenw9zcvNAPYmpqKrp37w57e3t8//33RZ6tsGPHDsycORMjR47E+PHjNdlFnTg6OqpMti5MtWrVsGzZMvTt2xcuLi5YtmxZgfXc3d3VJmTWrVsXwMu5Dm+//TZu3LiBq1evwsnJqcA2Xp/w6u3tXZJdkbz+mtvb28PKygqOjo5q5Q8ePJAeaxrX69sBXr6/intvFebWrVsAXs4Ze5WFhQVq166tVveNN96AmZnq3ykNGjRQaet17du3R8eOHbFo0SK1H4miYgBe/ki+/oVYEoMGDcKUKVNw8uRJtG7dGnv37kVOTg4GDRqkVrdu3brYvHkzFAoF/vrrL/z0009YtGgRxowZA29v7xK9V1/n5OSEwMBAbNu2DTk5OVAoFPjwww8LrHvjxg1kZGQUOufo1ffAlStXMHPmTPz666/IzMxUqZf/A+ft7Y3JkydjyZIl2Lp1K9q1a4eePXtKc9S09fpn4saNGxBCFPi6AS/fQ6+qWbOm2pxCe3t7eHh4qJUB//u+vH//Ph4/foxvvvkG33zzTYHbKu5zUtLv4OKIQua3WFlZqX2GX/9c3rp1C+7u7rC1tVWpV9znByj5a3rixAnMnj0bp06dUkuUMjIyVOoW9J0FoNjXI5+ZmZnad8Sr37sF0ea1zD/mhpiPWtbKPAFq2bKldBZY79690bZtWwwcOBDXr1+XznySyWQFvvFfn+CWr7Cko7APT76QkBC1CaW7d++W/v/xxx/j448/hqenZ4FvsIyMDHTt2hWPHz/Gb7/9VuRp5dHR0Rg6dCi6d+9e6F/m5UH+NZAePXqEO3fuaN1LpVQq0bhxYyxZsqTA51//0L/6l1RJFPSal+R9oGlc2r63DG327Nno0KED1qxZUyY9jQMGDMC0adOwbds2tG7dGtu2bYODgwO6detW6Drm5uZo3LgxGjdujFatWqFjx47YunWrVgkQAAwcOBCjR49GamoqunbtWuh+K5XKIi+ul//D+vjxYwQEBMDOzg5hYWHSdYvOnj2L6dOnQ6lUSut89dVXCA4Oxr59+3Do0CF8/PHHCA8Px+nTpwtMRPIV9p0GqH8mlEolZDIZfvnllwLfl6+fOVrYe7e493T+fg0ePLjQHu0mTZpo1KamqlWrBplMVmgCVRanxRf3miYkJKBTp06oX78+lixZAg8PD1haWuLAgQNYunSpyvujqJhL8ztGm9cy/5i//sdkRWTQC6yYm5sjPDwcHTt2xIoVK6TTaB0cHArs/isqY9fGtGnTMHjwYCQmJmLMmDHYtGkT3NzcsHPnThw4cEA6Y6OgH+dnz56hR48e+Pvvv3H48OEihw7OnDmDPn36oEWLFti5c2e5va5NVFQUvv32W0ybNg1bt27FsGHDcObMGbV4//nnH7XTcvMvApl/ZoePjw8uXLiATp06lau/JEojLk3ayT/76caNG9KwG/DyjKnExEQ0bdpUpe7FixehVCpVeoHyh14KOpMqX0BAADp06ICFCxeqXdjs1Rhed/369RLvy6vc3d3RsWNH7Nq1C59//jmio6MRHBysdrZkYfL/KNLl+ld9+vTB2LFjcfr0aezYsaPQej4+Pjh8+DDatGlTZOIdGxuLBw8eYPfu3Wjfvr1UnpiYWGD9/GRu5syZOHnyJNq0aYPIyEjMnz9f6hF5/WKZmnyn+fj4QAgBb29v6S//0uDk5ARbW1soFAqtk9GCaPI5qVSpEnx8fAo91iXh6emJw4cP48mTJyq9QCX5/OQr6jX98ccfkZubi/3796v07rw+FKkvSqUSN2/eVHntX//efZ02r2ViYiLMzMxK9T1WXhj8NPgOHTqgZcuWiIiIkIajfHx8cO3aNdy/f1+qd+HCBZw4cUKv2/b19UVgYCAqVaoEBwcHDB48GIGBgcjMzETbtm2l+T9t2rRRWU+hUKBfv344deoUdu3apTKu+7qrV6+ie/fu8PLywk8//aRxT0dZefz4MUaNGoWWLVviiy++wLfffouzZ8/iiy++UKv74sULrFmzRnqcl5eHNWvWwMnJSZor9dFHH+Hu3bsFzut4+vQpsrOzS29nilAaceUngiW5EnSLFi3g5OSEyMhI5OXlSeUbNmxQW79bt25ITU1V+TF/8eIFli9fjipVqiAgIKDIbeXPBXq969vNzQ1+fn7YuHGjyjyF6Oho/PXXX8XuQ2EGDRqEe/fuYezYsXj+/HmBw1+//fYbnj9/rlZ+4MABAC+H4LRVpUoVrF69GnPmzEGPHj0KrffRRx9BoVBg3rx5as+9ePFCeh3y/zJ/9S/xvLw8rFq1SmWdzMxMvHjxQqWscePGMDMzky6tYGdnB0dHRxw7dkyl3uttFeX999+Hubk55s6dq9Y7IIRQGerVhbm5OT744AP88MMPBd4W4dXvZU3Y2NiozYspSqtWrXS6enm3bt2gUCiwYsUKlfKlS5dCJpOha9euha5bkte0oPdHRkYG1q9fr3XMxXl1X4QQWLFiBSwsLNCpU6cC62vzWsbFxaFhw4Y6Dd8ai3LRFTF16lT07dsXGzZswLhx4zBixAgsWbIEQUFBGDlyJO7du4fIyEg0bNhQbRxeH06cOIG3335b+gvl5MmTmDJlSqH1P/30U+zfvx89evTAw4cPpQsf5su/6OCTJ08QFBSER48eYerUqfj5559V6vn4+KgkTz/++CMuXLgA4GWPwMWLFzF//nwAQM+ePaWuyqSkJHh7e2PYsGEFXlfkdXfv3lWLEXj5g9G7d28AwCeffIIHDx7g8OHDMDc3R5cuXTBq1CjMnz8fvXr1UumZcHd3x8KFC5GUlIS6detix44dOH/+PL755htpHsKQIUOwc+dOjBs3DkeOHEGbNm2gUChw7do17Ny5EwcPHpT+6i9LpRFXftL373//G/3794eFhQV69OhR4IXrLCwsMH/+fIwdOxbvvPMO+vXrh8TERKxfv15tfH/MmDFYs2YNgoODERcXBy8vL3z//fc4ceIEIiIi1OY2vC4gIAABAQEFTpYODw9H9+7d0bZtW4wYMQIPHz7E8uXL0bBhQ2RlZWm0//k++OAD/Otf/8K+ffvg4eGh0muSb+HChYiLi8P7778vvZ/Pnj2LTZs2oVq1aiW+SnBhijsJAXh5XMaOHYvw8HCcP38enTt3hoWFBW7cuIFdu3bh66+/xocffojWrVvDwcEBw4YNw8cffwyZTIbNmzerJR+//vorQkJC0LdvX9StWxcvXrzA5s2bpR+ffKNGjcKCBQswatQotGjRAseOHVO7fU5RfHx8MH/+fISGhiIpKQm9e/eGra0tEhMTsWfPHowZM6bI7y1NLFiwAEeOHIG/vz9Gjx4NX19fPHz4EGfPnsXhw4fx8OFDjdts3rw5duzYgcmTJ+Ott95ClSpVikxUe/Xqhc2bN+Pvv//WqjeiR48e6NixI/79738jKSkJTZs2xaFDh7Bv3z5MnDixyCsdl+Q17dy5MywtLdGjRw+MHTsWWVlZWLt2LZydnfV6Jf98VlZWiIqKwrBhw+Dv749ffvkFP//8Mz777LNC5zQCmr2Wz58/x9GjR/Gvf/1L7/GXS2V1ullh1wES4uW1WXx8fISPj4948eKFEEKILVu2iNq1awtLS0vh5+cnDh48WOhp8IsXL1ZrE6+dCliU+vXri3nz5gkhhLhz506hceYr7tpBr8dX2PL6ae75pzoWtLx6iuqlS5cEADFjxoxi962o0+Dzj2X+ZQNePbVdCCEyMzOFp6enaNq0qXR6e0BAgGjYsKH4888/RatWrYSVlZXw9PRUu+6FEC9P2V64cKFo2LChkMvlwsHBQTRv3lzMnTtX5dRovHIK9+tefx3zTxF+9bTP/GNnY2Ojtn5+vPqMy9PTU+21mzdvnqhRo4YwMzMr0Snxq1atEt7e3kIul4sWLVqIY8eOFXj5h7S0NDF8+HDh6OgoLC0tRePGjQs9lbqgWPNPUy7oPf3DDz+IBg0aCLlcLnx9fcXu3bvVPmOayr9OzrRp0wp8/sSJE2LChAmiUaNGwt7eXlhYWIhatWqJ4OBgkZCQoNG2ivpOeVVB1wES4uWlB5o3by6sra2Fra2taNy4sZg2bZr4559/VOJ9++23hbW1tXB3dxfTpk2TTl/OP0355s2bYsSIEcLHx0dYWVmJatWqiY4dO4rDhw+rbC8nJ0eMHDlS2NvbC1tbW/HRRx+Je/fulfg9nu+HH34Qbdu2FTY2NsLGxkbUr19fTJgwQVy/fl2qU9D7vqhjUdD7Jy0tTUyYMEF4eHgICwsL4erqKjp16iS++eYbqU7+++v108ULOu0/KytLDBw4UFStWrVEl1vIzc0Vjo6O0ndzvsI+6/nH7VVPnjwRkyZNEu7u7sLCwkK88cYbYvHixUKpVBa57ZK+pvv37xdNmjQRVlZWwsvLSyxcuFCsW7dO7TtAk+Ne0O9a/j4nJCRI1zFzcXERs2fPVrleUH6br//2leS1FEKIX375RQAQN27cKPL4VBQyIcr5bE5Ss2rVKkybNg0JCQlwcXEp02136NAB6enpJnXHYCIyjHnz5mH9+vW4ceOGSd8PLDg4GN9//73WvbMl1bt3b8hkMq2uCm+MDD4HiDR35MgRfPzxx2We/BARlaVJkyYhKytL5RpTVDquXr2Kn376qcC5cRVVuZgDRJrZtWuXoUMgE/Dw4UOVidqvMzc3L3LugbaysrKK/UvXycnJpHsETEWVKlW0vkkuaaZBgwZqE78rOiZARFSg999/v9CrTQMo9PpYuvryyy8xd+7cIuskJiYWezNNIqKicA4QERUoLi6uyCv5Wltbq10iQh9u3rxZ7C0U2rZtCysrK71vm4hMBxMgIiIiMjmcBE1EREQmh3OASkipVOKff/6Bra1tubq1AxERlT9CCDx58gTu7u5qNzTWl2fPnhV5ooImLC0tTW5YmQlQCf3zzz9qN8okIiIqSnJyMmrWrKn3dp89ewZvzypIvVf4DXU14erqisTERJNKgpgAlVD+bQeSk5NhZ2dn4GiIiEjfetkP1VtbL/Acx3Gg2FvWaCsvLw+p9xS4FecFO1vdepgynyjh2TwJeXl5TIBIXf6wl52dHRMgIqIKqJLMQn+N/d/pRaU9ZaKKrQxVbHXbhhKmOa2DCRAREZGRUgglFDqey60QSv0EY2SYABERERkpJQSU0C0D0nV9Y2Uyp8EfO3YMPXr0gLu7O2QyGfbu3WvokIiIiMhATCYBys7ORtOmTbFy5UpDh0JERKQXSj39M0UmMwTWtWtXdO3a1dBhEBER6Y1CCCh0vKGDrusbK5NJgDSVm5uL3Nxc6XFmZqYBoyEiIiJ9MpkhME2Fh4fD3t5eWngRRCIiKm/yJ0HrupgiJkCFCA0NRUZGhrQkJycbOiQiIiIVSggodFxMNQHiEFgh5HI55HK5ocMgIiKiUsAEiIiIyEjxOkDaM5kEKCsrC/Hx8dLjxMREnD9/HtWqVUOtWrUMGBkREZF2eBaY9kwmAfrzzz/RsWNH6fHkyZMBAMOGDcOGDRsMFBUREREZgskkQB06dIAw0SyXiIgqJuX/Lbq2YYpMJgEiIiKqaPLP5NK1DVPEBIiIiMhIKQT0cDd4/cRibHgdICIiIjI57AEiIiKj1NVtgl7bi1bu0ltbmZmZsLe311t7heEcIO0xASIiIjJSSsiggEznNkwRh8CIiIjI5LAHiIiIyEgpxctF1zZMERMgIiIiI6XQwxCYrusbKw6BERERkclhDxAREZGRYg+Q9pgAERERGSmlkEEpdDwLTMf1jRWHwIiIiMjksAeIiIjISHEITHtMgIiIiIyUAmZQ6DiYo9BTLMaGCRAREZGREnqYAyQ4B4iIiIjINLAHiIiIyEhxDpD2mAAREREZKYUwg0LoOAfIRG+FwSEwIiIiMjnsASIiIjJSSsig1LEvQwnT7AJiAkRERGSkOAdIe0yAiIioTLzbZr5e24tOWanX9si0MAEiIiIyUvqZBG2aQ2CcBE1ERGSkXs4B0n3R1N27dzF48GBUr14d1tbWaNy4Mf78889S2MPSwx4gIiIiKrFHjx6hTZs26NixI3755Rc4OTnhxo0bcHBwMHRoGmECREREZKSUergXmKZngS1cuBAeHh5Yv369VObt7a1TDIbAITAiIiIjlT8HSNdFE/v370eLFi3Qt29fODs7o1mzZli7dm0p7WHpYQJERERkpJQw08sCAJmZmSpLbm5ugdu8efMmVq9ejTfeeAMHDx7E+PHj8fHHH2Pjxo1lues6YwJERERE8PDwgL29vbSEh4cXWE+pVOLNN9/EF198gWbNmmHMmDEYPXo0IiMjyzhi3XAOEBERkZFSCBkUQscLIf7f+snJybCzs5PK5XJ5gfXd3Nzg6+urUtagQQP88MMPOsVR1pgAERERGSmFHiZBK/5vErSdnZ1KAlSYNm3a4Pr16yplf//9Nzw9PXWKo6xxCIyIiIhKbNKkSTh9+jS++OILxMfHY9u2bfjmm28wYcIEQ4emEfYAERERGSmlMINSxytBKzW8EvRbb72FPXv2IDQ0FGFhYfD29kZERAQGDRqkUxxlrVz2AK1cuRJeXl6wsrKCv78/fv/990LrdujQATKZTG3p3r27VCc4OFjt+S5dupTFrhAREZWa/CEwXRdNvffee7h06RKePXuGq1evYvTo0aWwd6Wr3PUA7dixA5MnT0ZkZCT8/f0RERGBoKAgXL9+Hc7Ozmr1d+/ejby8POnxgwcP0LRpU/Tt21elXpcuXVQu2lTY5C4iIiKq+MpdD9CSJUswevRoDB8+HL6+voiMjETlypWxbt26AutXq1YNrq6u0hIdHY3KlSurJUByuVylnrFdspuIiOh1SvzvTDBtF6Whd8JAylUClJeXh7i4OAQGBkplZmZmCAwMxKlTp0rUxnfffYf+/fvDxsZGpTw2NhbOzs6oV68exo8fjwcPHhTZTm5urtpFoYiIiMoTfV4I0dSUq71OT0+HQqGAi4uLSrmLiwtSU1OLXf/333/H5cuXMWrUKJXyLl26YNOmTYiJicHChQtx9OhRdO3aFQqFotC2wsPDVS4I5eHhod1OERERUblT7uYA6eK7775D48aN0bJlS5Xy/v37S/9v3LgxmjRpAh8fH8TGxqJTp04FthUaGorJkydLjzMzM5kEERFRuaLNvbwKasMUlau9dnR0hLm5OdLS0lTK09LS4OrqWuS62dnZ2L59O0aOHFnsdmrXrg1HR0fEx8cXWkcul0sXhSrpxaGIiIjKkhIyvSymqFz1AFlaWqJ58+aIiYlB7969Aby850hMTAxCQkKKXHfXrl3Izc3F4MGDi93OnTt38ODBA7i5uekjbCKiCqnz22F6bS/69Cy9tkfsAdJFudvryZMnY+3atdi4cSOuXr2K8ePHIzs7G8OHDwcADB06FKGhoWrrfffdd+jduzeqV6+uUp6VlYWpU6fi9OnTSEpKQkxMDHr16oU6deogKCioTPaJiIiIypdy1QMEAP369cP9+/cxa9YspKamws/PD1FRUdLE6Nu3b8PMTDVvu379Oo4fP45Dhw6ptWdubo6LFy9i48aNePz4Mdzd3dG5c2fMmzeP1wIiIiKjpp97gZW7vpAyUe4SIAAICQkpdMgrNjZWraxevXoQhVzK29raGgcPHtRneEREROWCUsig1PFu8Lqub6xMM+0jIiIik1Yue4CIiIioeEo9DIGZ6oUQmQAREREZKf3cDd40EyDT3GsiIiIyaewBIiIiMlIKyKDQ8UKGuq5vrJgAERERGSkOgWnPNPeaiIiITBp7gIiIiIyUAroPYSn0E4rRYQJERERkpDgEpj0mQEREREaKN0PVnmnuNREREZk09gAREREZKQEZlDrOARI8DZ6IiIiMCYfAtGeae01EREQmjT1AREQVxLtt5uu1vejTs/TaHumfUsigFLoNYem6vrFiAkRERGSkFHq4G7yu6xsr09xrIiIiMmnsASIiIjJSHALTHhMgIiIiI6WEGZQ6Dubour6xMs29JiIiIpPGHiAiIiIjpRAyKHQcwtJ1fWPFBIiIiMhIcQ6Q9pgAERERGSmhh7vBC14JmoiIiMg0sAeIiIjISCkgg0LHm5nqur6xYgJERERkpJRC9zk8SqGnYIwMh8CIiIjI5LAHiIiIyEgp9TAJWtf1jRUTICIiIiOlhAxKHefw6Lq+sTLNtI+IiIhMGnuAiIiIjBSvBK09JkBERERGinOAtGeae01EREQmzWh7gFauXInFixcjNTUVTZs2xfLly9GyZcsC627YsAHDhw9XKZPL5Xj27FlZhEpEVKiWw5bora3fT8zUW1tkHJTQw73AOAnaeOzYsQOTJ0/G7NmzcfbsWTRt2hRBQUG4d+9eoevY2dkhJSVFWm7dulWGERMREemf+L+zwHRZBBMg47FkyRKMHj0aw4cPh6+vLyIjI1G5cmWsW7eu0HVkMhlcXV2lxcXFpQwjJiIi0r/8u8Hrupgio0uA8vLyEBcXh8DAQKnMzMwMgYGBOHXqVKHrZWVlwdPTEx4eHujVqxeuXLlS5HZyc3ORmZmpshAREVHFYHQJUHp6OhQKhVoPjouLC1JTUwtcp169eli3bh327duHLVu2QKlUonXr1rhz506h2wkPD4e9vb20eHh46HU/iIiIdJV/Fpiuiykyib1u1aoVhg4dCj8/PwQEBGD37t1wcnLCmjVrCl0nNDQUGRkZ0pKcnFyGERMRERWPQ2DaM7qzwBwdHWFubo60tDSV8rS0NLi6upaoDQsLCzRr1gzx8fGF1pHL5ZDL5TrFSkREROWT0fUAWVpaonnz5oiJiZHKlEolYmJi0KpVqxK1oVAocOnSJbi5uZVWmERERKVO1zPA9HEvMWNldD1AADB58mQMGzYMLVq0QMuWLREREYHs7GzpWj9Dhw5FjRo1EB4eDgAICwvD22+/jTp16uDx48dYvHgxbt26hVGjRhlyN4iIiHSijyEsDoEZkX79+uH+/fuYNWsWUlNT4efnh6ioKGli9O3bt2Fm9r/OrUePHmH06NFITU2Fg4MDmjdvjpMnT8LX19dQu0BEREQGZJQJEACEhIQgJCSkwOdiY2NVHi9duhRLly4tg6iIiIjKDnuAtGe0CRAREZGpYwKkPaObBE1ERESkK/YAERERGSn2AGmPCRAREZGREtD9bu5CP6EYHSZARERERoo9QNrjHCAiIiIyOewBIiIiMlLsAdIeEyAiIg20671Yr+39vneqXtsj08IESHscAiMiIiKTwx4gIiIiI8UeIO0xASIiIjJSQsggdExgdF3fWHEIjIiIiEwOe4CIiIiMlBIynS+EqOv6xooJEBERkZHiHCDtcQiMiIiITA57gIiIiIwUJ0Frjz1ARERERip/CEzXRRNz5syBTCZTWerXr19o/Q0bNqjVt7Ky0nXXdcYeICIiIiNlqB6ghg0b4vDhw9LjSpWKTifs7Oxw/fp16bFMZvheJyZAREREpJFKlSrB1dW1xPVlMplG9csCh8CIiIiMlNDD8Jc2PUA3btyAu7s7ateujUGDBuH27dtF1s/KyoKnpyc8PDzQq1cvXLlyRdtd1hsmQEREREZKABBCx+X/2srMzFRZcnNzC9ymv78/NmzYgKioKKxevRqJiYlo164dnjx5UmD9evXqYd26ddi3bx+2bNkCpVKJ1q1b486dO6VzUEqICRARERHBw8MD9vb20hIeHl5gva5du6Jv375o0qQJgoKCcODAATx+/Bg7d+4ssH6rVq0wdOhQ+Pn5ISAgALt374aTkxPWrFlTmrtTLM4BIiIiMlJKyCDT05Wgk5OTYWdnJ5XL5fISrV+1alXUrVsX8fHxJapvYWGBZs2albh+aWEPEBERkZHKPwtM1wV4eabWq0tJE6CsrCwkJCTAzc2tRPUVCgUuXbpU4vqlhQkQERERldiUKVNw9OhRJCUl4eTJk+jTpw/Mzc0xYMAAAMDQoUMRGhoq1Q8LC8OhQ4dw8+ZNnD17FoMHD8atW7cwatQoQ+0CAA6BEVEF5/vZUr2299feqXptj0gXSiGDrIzvBXbnzh0MGDAADx48gJOTE9q2bYvTp0/DyckJAHD79m2Ymf2vf+XRo0cYPXo0UlNT4eDggObNm+PkyZPw9fXVKW5dMQEiIiIyUvlncunahia2b99e5POxsbEqj5cuXYqlS/X7h4g+cAiMiIiITA57gIiIiIwUb4aqPSZARERERooJkPaYABERERkpQ0yCrig4B4iIiIhMDnuAiIiIjJQhzgKrKMplD9DKlSvh5eUFKysr+Pv74/fffy+07tq1a9GuXTs4ODjAwcEBgYGBavWDg4Mhk8lUli5dupT2bhAREZWqlwmQrleCNvReGEa5S4B27NiByZMnY/bs2Th79iyaNm2KoKAg3Lt3r8D6sbGxGDBgAI4cOYJTp07Bw8MDnTt3xt27d1XqdenSBSkpKdLy3//+tyx2h4iIiMqhcpcALVmyBKNHj8bw4cPh6+uLyMhIVK5cGevWrSuw/tatW/Gvf/0Lfn5+qF+/Pr799lsolUrExMSo1JPL5XB1dZUWBweHstgdIiKiUqPPe4GZmnKVAOXl5SEuLg6BgYFSmZmZGQIDA3Hq1KkStZGTk4Pnz5+jWrVqKuWxsbFwdnZGvXr1MH78eDx48KDIdnJzc5GZmamyEBERlSdCT4spKlcJUHp6OhQKBVxcXFTKXVxckJqaWqI2pk+fDnd3d5UkqkuXLti0aRNiYmKwcOFCHD16FF27doVCoSi0nfDwcNjb20uLh4eHdjtFRERE5U6FOgtswYIF2L59O2JjY2FlZSWV9+/fX/p/48aN0aRJE/j4+CA2NhadOnUqsK3Q0FBMnjxZepyZmckkiIiIyhVeCFF7GidAubm5OHPmDG7duoWcnBw4OTmhWbNm8Pb21jkYR0dHmJubIy0tTaU8LS0Nrq6uRa775ZdfYsGCBTh8+DCaNGlSZN3atWvD0dER8fHxhSZAcrkccrlcsx0gIiIqS/oYwzLRMbASJ0AnTpzA119/jR9//BHPnz+Hvb09rK2t8fDhQ+Tm5qJ27doYM2YMxo0bB1tbW62CsbS0RPPmzRETE4PevXsDgDShOSQkpND1Fi1ahP/85z84ePAgWrRoUex27ty5gwcPHsDNzU2rOImIiMoFfUxiNtEeoBLNAerZsyf69esHLy8vHDp0CE+ePMGDBw9w584d5OTk4MaNG5g5cyZiYmJQt25dREdHax3Q5MmTsXbtWmzcuBFXr17F+PHjkZ2djeHDhwMAhg4ditDQUKn+woUL8fnnn2PdunXw8vJCamoqUlNTkZWVBQDIysrC1KlTcfr0aSQlJSEmJga9evVCnTp1EBQUpHWcREREZLxK1APUvXt3/PDDD7CwsCjw+dq1a6N27doYNmwY/vrrL6SkpGgdUL9+/XD//n3MmjULqamp8PPzQ1RUlDQx+vbt2zAz+1/etnr1auTl5eHDDz9UaWf27NmYM2cOzM3NcfHiRWzcuBGPHz+Gu7s7OnfujHnz5nGIi4iIjBqvBK09mRAl23WFQgFzc/PSjqfcyszMhL29PTIyMmBnZ2focIiohHw/W6rX9v76YpJe26OKqbR/M/Lb91o3E2aVrYpfoQjKnGdIGjG/XP++lcb84xLPAapRowaCg4MxYsQI1K1bV+sNEhEVhQkLEeUrzfnHJb4O0IQJE/D999+jQYMGaNeuHTZs2ICcnByNd4aIiIj0RMj0s5RDpT3/uMQJ0Oeff474+HjExMSgdu3aCAkJgZubG0aPHo0zZ85ovGNERESkm/w5QLou5VH37t2RmJiIRYsWoV27drC2tlZ5Pn/ucVRUFGJiYlTmB5eExleC7tChAzZu3IjU1FR89dVXuHr1Klq1aoWGDRtiyZIlmjZHREREpGbs2LElTmp8fX0Lva5fYbS+FUaVKlUwatQoHD9+HD/++CNSU1MxdepUbZsjIiIiTVXwm4HVqFEDM2bMwN9//633trVOgHJycrBhwwYEBASgZ8+eqF69Ov7zn//oMzYiIiIqQkW/G3xpzj/WOAE6efIkRo0aBTc3N0yYMAFeXl44cuQI/v77b8yYMUMvQRERERGV5vzjEidAixYtkjKwS5cuYfHixUhNTcXGjRvRvn17nYIgIiIiLVXQ4a9Xlcb84xInQIsXL0aXLl1w4cIFnDlzBmPGjNH6nl9ERESku4o+BPY6fc4/LvGFEP/5559Cb4VBREREBmBid4PPycnBzp07sX79ehw/fhw+Pj5aJ0Al6gHavn17iZOf5ORknDhxQqtgiIiIiF5XGvOPS5QArV69Gg0aNMCiRYtw9epVteczMjJw4MABDBw4EG+++SYePHigVTBERESkCZmelvKpNOcfl2gI7OjRo9i/fz+WL1+O0NBQ2NjYwMXFBVZWVnj06BFSU1Ph6OiI4OBgXL58WbpzOxEREZWiCj4EtnjxYgwePBi7du1Co0aN9Np2iecA9ezZEz179kR6ejqOHz+OW7du4enTp3B0dESzZs3QrFkzjS9DTURERFSY0px/XOIEKJ+joyN69+5dCqEQERGRRipwD9D27dvRv3//EtVNTk7G7du30aZNmxK3zy4bIiIiY1WB7wZf2vOPNe4BIiIiIiptpT3/mAkQERGRkRLi5aJrG+VVac4/ZgJERDrxWvmVXttL+uJTvbZHVKFV4DlAryqN+cecA0REREQmR6MEKCUlBVu2bMGBAweQl5en8lx2djbCwsL0GhwREREVoQJPgi5tJU6A/vjjD/j6+mLChAn48MMP0bBhQ1y5ckV6PisrC3Pnzi2VIImIiEidTOhnMUUlToA+++wz9OnTB48ePUJaWhreffddBAQE4Ny5c6UZHxERERVG6GkxQSWeBB0XF4eVK1fCzMwMtra2WLVqFWrVqoVOnTrh4MGDqFWrVmnGSURERKQ3Gs0BevbsmcrjGTNm4LPPPkPnzp1x8uRJvQZGRERExTDxOUDJyckYMWKEVuuWOAFq1KhRgUnOlClTEBoaigEDBmgVABEREWnJxIfAHj58iI0bN2q1bomHwIYOHYqjR49i3Lhxas9NmzYNQghERkZqFQQRERHR6/bv31/k8zdv3tS67RInQKNGjcKoUaMKfX769OmYPn261oEQERGRhir4hRB79+4NmUwGUcTlqmUy7YbweCFEIiIiY1XBh8Dc3Nywe/duKJXKApezZ89q3bbGCVBaWhqGDBkCd3d3VKpUCebm5ioLERERkT40b94ccXFxhT5fXO9QUTS+F1hwcDBu376Nzz//HG5ublp3PREREZGO9HEWVzk+C2zq1KnIzs4u9Pk6dergyJEjWrWtcQJ0/Phx/Pbbb/Dz89Nqg0RERKQf+riSc3m+EnS7du2KfN7GxgYBAQFata3xEJiHh4fW3U1EREREmtqyZUuRPUHa0DgBioiIwIwZM5CUlKTXQMrCypUr4eXlBSsrK/j7++P33383dEhERETaq+CToPNNmjQJLi4uGDhwIA4cOACFQqFzmyUaAnNwcFCZ65OdnQ0fHx9UrlwZFhYWKnUfPnyoc1ClYceOHZg8eTIiIyPh7++PiIgIBAUF4fr163B2djZ0eERERFSIlJQUREVF4b///S8++ugjVK5cGX379sWgQYPQunVrrdosUQIUERGhVePlyZIlSzB69GgMHz4cABAZGYmff/4Z69atw4wZMwwcHRERkeZk0MMcIL1EUroqVaqE9957D++99x5ycnKwZ88ebNu2DR07dkTNmjWRkJCgeZslqTRs2DCNGy5P8vLyEBcXh9DQUKnMzMwMgYGBOHXqVIHr5ObmIjc3V3qcmZlZ6nESERFR0SpXroygoCA8evQIt27dwtWrV7VqR+OzwA4cOABzc3MEBQWplB86dAgKhQJdu3bVKpDSlJ6eDoVCARcXF5VyFxcXXLt2rcB1wsPDMXfu3LIIj6hM1Zu3VK/tJX3+qV7bIyINVPDT4F+V3/OzdetWxMTEwMPDAwMGDMD333+vVXsaT4KeMWNGgZOPlEplhRpKCg0NRUZGhrQkJycbOiQiIiJVJjIJun///nB2dsakSZNQu3ZtxMbGIj4+HvPmzUP9+vW1alPjHqAbN27A19dXrbx+/fqIj4/XKojS5ujoCHNzc6SlpamUp6WlwdXVtcB15HI55HJ5WYRHRERERTA3N8fOnTsRFBSkt7tOaNwDZG9vX+DdV+Pj42FjY6OXoPTN0tISzZs3R0xMjFSmVCoRExODVq1aGTAyIiIiHZhID9DWrVvRrVs3vd5yS+MEqFevXpg4caLKjOv4+Hh8+umn6Nmzp94C07fJkydj7dq12LhxI65evYrx48cjOztbOiuMiIjI2ORfCVrXxRRpPAS2aNEidOnSBfXr10fNmjUBAHfu3EG7du3w5Zdf6j1AfenXrx/u37+PWbNmITU1FX5+foiKilKbGE1EREQVn8YJkL29PU6ePIno6GhcuHAB1tbWaNKkCdq3b18a8elVSEgIQkJCDB0GERGRfuhjCIs9QCUnk8nQuXNndO7cWd/xEBERUUkxAdKaxnOAiIiIiMpaQkICZs6ciQEDBuDevXsAgF9++QVXrlzRqj0mQEREREbKVCZBHz16FI0bN8aZM2ewe/duZGVlAQAuXLiA2bNna9UmEyAiIiJjlX8laF2Xcm7GjBmYP38+oqOjYWlpKZW/8847OH36tFZtMgEiIiIyViZyHaBLly6hT58+auXOzs5IT0/Xqk2tEiB9j8MRERERFaZq1apISUlRKz937hxq1KihVZsaJ0ClMQ5HREREmjOVOUD9+/fH9OnTkZqaCplMBqVSiRMnTmDKlCkYOnSoVm1qdTNUfY/DERERkRZMZAjsiy++QP369eHh4YGsrCz4+vqiffv2aN26NWbOnKlVmxpfB+jSpUvYtm2bWrku43BEREREhbG0tMTatWsxa9YsXLp0CVlZWWjWrBneeOMNrdvUuAeoNMbhiIiISAv6GP7SsAdozpw5kMlkKkv9+vVLZffyhYWFIScnBx4eHujWrRs++ugjvPHGG3j69CnCwsK0alPjBKg0xuGIiIhICwYaAmvYsCFSUlKk5fjx4zrvSlHmzp0rzTl+VU5ODubOnatVmxoPgX3xxReYMGECPDw8oFAo4OvrC4VCgYEDB2o9DkdEhfP5aole20v4fLJe2yMi01OpUiW4urqW2faEEJDJ1K9XdOHCBVSrVk2rNjVOgEpjHI6IiIi0oMd7gWVmZqoUy+VyyOXyAle5ceMG3N3dYWVlhVatWiE8PBy1atXSMRB1Dg4O0jBb3bp1VZIghUKBrKwsjBs3Tqu2NU6AwsLCMGXKFHh4eMDDw0Mqf/r0KRYvXoxZs2ZpFQgRERFpRh+nseev/+pvOgDMnj0bc+bMUavv7++PDRs2oF69ekhJScHcuXPRrl07XL58Gba2troF85qIiAgIITBixAjMnTsX9vb20nOWlpbw8vJCq1attGpbJoTQ6NCZm5sjJSUFzs7OKuUPHjyAs7MzFAqFVoGUd5mZmbC3t0dGRgbs7OwMHQ6ZEL0PgX3KITCi0lbavxn57ft89gXMrax0akvx7BkSvvgMycnJKrEW1QP0qsePH8PT0xNLlizByJEjdYqlMEePHkXr1q1hYWGhtzY17gEqjXE4IiIiMiw7OzutkrWqVauibt26iI+PL4WoXgoICJD+/+zZM+Tl5ak8r03cJU6ASnMcjoiIiLSgxzlA2srKykJCQgKGDBmiYyCFy8nJwbRp07Bz5048ePBA7XltRp9KnACV5jgcERERaU6fc4BKasqUKejRowc8PT3xzz//YPbs2TA3N8eAAQN0C6QIU6dOxZEjR7B69WoMGTIEK1euxN27d7FmzRosWLBAqzZLnAANGzYMAODt7a33cTgiIiIyDnfu3MGAAQPw4MEDODk5oW3btjh9+jScnJxKbZs//vgjNm3ahA4dOmD48OFo164d6tSpA09PT2zduhWDBg3SuE2N5wCVxjgcERERaamM7+W1ffv2st0ggIcPH6J27doAXuYZDx8+BAC0bdsW48eP16pNja8EnZOTg5CQEDg7O8PGxgYODg4qCxEREZURE7kZau3atZGYmAgAqF+/Pnbu3AngZc9Q1apVtWpT4wRo6tSp+PXXX7F69WrI5XJ8++23mDt3Ltzd3bFp0yatgiAiIiIqzPDhw3HhwgUAwIwZM7By5UpYWVlh0qRJmDp1qlZtajwEVhrjcERERKQ5Q0yCNoRJkyZJ/w8MDMS1a9cQFxeHOnXqoEmTJlq1qXECVBrjcERERKSFcnAavCF4enrC09NTpzY0ToDyx+Fq1aoljcO1bNlSp3E4IiIiotc9ffoUMTExeO+99wAAoaGhyM3NlZ43NzfHvHnzYKXF1bA1ToDyx+ECAgIwY8YM9OjRAytWrMDz58+xZIl+L9lPREREhavoQ2AbN27Ezz//LCVAK1asQMOGDWFtbQ0AuHbtGtzd3VWGyEpK4wSoNMbhiIiISAsVfAhs69atmDZtmkrZtm3bpKk4W7ZswcqVK8smAXqdPsbhiIiIiF4XHx+Pxo0bS4+trKxgZva/E9hbtmyJCRMmaNV2iROg0hyHIyIiIi1U8B6gx48fq+Qa9+/fV3leqVSqPK+JEidApTkOR0RERJqr6HOAatasicuXL6NevXoFPn/x4kXUrFlTq7ZLnACV5jgcUUXjtVm7m/MVJOnTGXpri4gqmAreA9StWzfMmjUL3bt3Vxthevr0KebOnYvu3btr1XaJE6DSHIcjIiIiet1nn32GnTt3ol69eggJCUHdunUBANevX8eKFSvw4sULfPbZZ1q1XeIEqDTH4YiIiEgLFbwHyMXFBSdPnsT48eMxY8YMCPEyWJlMhnfffRerVq2Ci4uLVm2X+F5g+eNwhdFlHC6fEAKzZs2Cm5sbrK2tERgYiBs3bhS5Tnh4ON566y3Y2trC2dkZvXv3xvXr11XqdOjQATKZTGUZN26cTrESEREZWv4cIF2X8szb2xtRUVG4f/8+Tp8+jdOnT+P+/fuIioqSpuFoo8QJUP443LNnz9Se03UcLt+iRYuwbNkyREZG4syZM7CxsUFQUFCB28x39OhRTJgwAadPn0Z0dDSeP3+Ozp07Izs7W6Xe6NGjkZKSIi2LFi3SKVYiIiIqO9WqVUPLli3RsmVLVKtWTef2SjwEVprjcMDL3p+IiAjMnDkTvXr1AgBs2rQJLi4u2Lt3L/r371/gelFRUSqPN2zYAGdnZ8TFxaF9+/ZSeeXKleHq6qp1fEREROVOBR8CK00l7gHKH4dr0KABZsyYgT59+qBPnz4IDQ2Fr68vjh8/rvU4HAAkJiYiNTUVgYGBUpm9vT38/f1x6tSpEreTkZEBAGrZ4datW+Ho6IhGjRohNDQUOTk5RbaTm5uLzMxMlYWIiKg8MYUhsNKi0ZWg88fhHj58iPj4eABAnTp19NIVlZqaCgBqSZSLi4v0XHGUSiUmTpyINm3aoFGjRlL5wIED4enpCXd3d1y8eBHTp0/H9evXsXv37kLbCg8Px9y5c7XYEyIiIirvtLoVRv44nC62bt2KsWPHSo9//vlnndoDgAkTJuDy5cs4fvy4SvmYMWOk/zdu3Bhubm7o1KkTEhIS4OPjU2BboaGhmDx5svQ4MzMTHh4eOsdIRESkNxwC05rO9wLTVs+ePeHv7y89zj+FPi0tDW5ublJ5Wloa/Pz8im0vJCQEP/30E44dO1bs2Wj5242Pjy80AZLL5ZDL5cVul4iIyGCYAGnNYAmQra0tbG1tpcdCCLi6uiImJkZKeDIzM3HmzBmMHz++0HaEEPh//+//Yc+ePYiNjYW3t3ex2z5//jwAqCRaREREZDoMlgC9TiaTYeLEiZg/fz7eeOMNeHt74/PPP4e7uzt69+4t1evUqRP69OmDkJAQAC+HvbZt24Z9+/bB1tZWmi9kb28Pa2trJCQkYNu2bejWrRuqV6+OixcvYtKkSWjfvj2aNGliiF0lIiLSC9n/Lbq2YYrKTQIEANOmTUN2djbGjBmDx48fo23btoiKilK5/0dCQgLS09Olx6tXrwbw8mKHr1q/fj2Cg4NhaWmJw4cPIyIiAtnZ2fDw8MAHH3yAmTNnlsk+ERERlRoOgWmtXCVAMpkMYWFhCAsLK7ROUlKSyuP8y2IXxsPDA0ePHtVHeEREROVKRb8bfGkq8XWAiIiIiCqKctUDRERERBrgEJjWmAAREREZMxNNYHTFITAiIiIyOewBIgLgtX6RXttLGj5Dr+0RERWEk6C1xwSIiIjIWHEOkNY4BEZEREQmhz1ARERERopDYNpjAkRERGSsOASmNQ6BERERkclhDxAREZGR4hCY9pgAERERGSsOgWmNCRAREZGxYgKkNc4BIiIiIpPDHiAiIiIjxTlA2mMCREREZKw4BKY1DoERERGRyWEPEBERkZGSCQGZ0K0LR9f1jRUTICIiImPFITCtcQiMiIiITA57gIiIiIwUzwLTHhMgIiIiY8UhMK1xCIyIiIhMDnuAyCj57PiPXttLGv5vvbZHRFQWOASmPSZARERExopDYFpjAkRERGSk2AOkPc4BIiIiIpPDHiAiIiJjxSEwrTEBIiIiMmKmOoSlKw6BERERkclhDxAREZGxEuLlomsbJogJEBERkZHiWWDaM7ohMCEEZs2aBTc3N1hbWyMwMBA3btwocp05c+ZAJpOpLPXr1y+jiImIiKi8MboEaNGiRVi2bBkiIyNx5swZ2NjYICgoCM+ePStyvYYNGyIlJUVajh8/XkYRExERlRKhp8UEGdUQmBACERERmDlzJnr16gUA2LRpE1xcXLB3717079+/0HUrVaoEV1fXsgqViIio1MmULxdd2zBFRtUDlJiYiNTUVAQGBkpl9vb28Pf3x6lTp4pc98aNG3B3d0ft2rUxaNAg3L59u7TDJSIionLKqHqAUlNTAQAuLi4q5S4uLtJzBfH398eGDRtQr149pKSkYO7cuWjXrh0uX74MW1vbAtfJzc1Fbm6u9DgzM1MPe0BERKRHvBCi1sp1D9DWrVtRpUoVaXn+/LlW7XTt2hV9+/ZFkyZNEBQUhAMHDuDx48fYuXNnoeuEh4fD3t5eWjw8PLTdDSIiolKRfxaYrospKtcJUM+ePXH+/HlpcXR0BACkpaWp1EtLS9Nofk/VqlVRt25dxMfHF1onNDQUGRkZ0pKcnKzdThAREZWW/OsA6bqYoHI9BGZra6syRCWEgKurK2JiYuDn5wfg5dDUmTNnMH78+BK3m5WVhYSEBAwZMqTQOnK5HHK5XOvYiYiIqPwq1z1Ar5PJZJg4cSLmz5+P/fv349KlSxg6dCjc3d3Ru3dvqV6nTp2wYsUK6fGUKVNw9OhRJCUl4eTJk+jTpw/Mzc0xYMAAA+wFERGRfnAITHvlugeoINOmTUN2djbGjBmDx48fo23btoiKioKVlZVUJyEhAenp6dLjO3fuYMCAAXjw4AGcnJzQtm1bnD59Gk5OTobYBZM0/I/hem0vod96vbZHRGSUOAlaa0aXAMlkMoSFhSEsLKzQOklJSSqPt2/fXspRERERkTExugSIiIiIXuK9wLTHBIiIiMhY8W7wWjOqSdBERERE+sAEiIiIyEgZ+iywBQsWSGdoF2bDhg2QyWQqy6snLhkKh8CIiIiMlQHPAvvjjz+wZs0aNGnSpNi6dnZ2uH79uvRYJpNpt1E9Yg8QERERaSQrKwuDBg3C2rVr4eDgUGx9mUwGV1dXaXn9np6GwASIiIjISOlzCCwzM1NlefWG4K+bMGECunfvjsDAwBLFmZWVBU9PT3h4eKBXr164cuWKPnZfJ0yAiIiIjJVS6GcB4OHhoXIT8PDw8AI3uX37dpw9e7bQ519Xr149rFu3Dvv27cOWLVugVCrRunVr3LlzR2+HQRucA0RERGSs9DgHKDk5GXZ2dlJxQffDTE5OxieffILo6OgST2Ru1aoVWrVqJT1u3bo1GjRogDVr1mDevHm6xa4DJkBEREQEOzs7lQSoIHFxcbh37x7efPNNqUyhUODYsWNYsWIFcnNzYW5uXmQbFhYWaNasGeLj4/USt7aYABERERkpGfRwJWgN6nbq1AmXLl1SKRs+fDjq16+P6dOnF5v8AC8TpkuXLqFbt24aRqpfTICIiIiMVRlfCdrW1haNGjVSKbOxsUH16tWl8qFDh6JGjRrSHKGwsDC8/fbbqFOnDh4/fozFixfj1q1bGDVqlG5x64gJEBEREenN7du3YWb2v3OsHj16hNGjRyM1NRUODg5o3rw5Tp48CV9fXwNGyQSIiIjIaJWHm6HGxsYW+Xjp0qVYunSpbhspBUyAiIiIjJUBrwRt7HgdICIiIjI57AEiIiIyUjIhINNxErSu6xsrJkBUoK7HPtFre7+0X6/X9oiICIDy/xZd2zBBHAIjIiIik8MeICIiIiPFITDtMQEiIiIyVjwLTGtMgIiIiIxVGV8JuiLhHCAiIiIyOewBIiIiMlLl4UrQxooJEBERkbHiEJjWOARGREREJoc9QEREREZKpny56NqGKWICREREZKw4BKY1DoERERGRyWEPEBERkbHihRC1xgSIiIjISPFWGNrjEBgRERGZHPYAERERGStOgtZaueoBEkJg1qxZcHNzg7W1NQIDA3Hjxo0i1/Hy8oJMJlNbJkyYINXp0KGD2vPjxo0r7d0hIiIqXQKAUsfFNPOf8pUALVq0CMuWLUNkZCTOnDkDGxsbBAUF4dmzZ4Wu88cffyAlJUVaoqOjAQB9+/ZVqTd69GiVeosWLSrVfSEiIipt+XOAdF1MUbkZAhNCICIiAjNnzkSvXr0AAJs2bYKLiwv27t2L/v37F7iek5OTyuMFCxbAx8cHAQEBKuWVK1eGq6tr6QRfDvy/s4P02t4v7bfqtT0iIqLypNz0ACUmJiI1NRWBgYFSmb29Pfz9/XHq1KkStZGXl4ctW7ZgxIgRkMlkKs9t3boVjo6OaNSoEUJDQ5GTk6PX+ImIiMqcwP/mAWm9GHonDKPc9AClpqYCAFxcXFTKXVxcpOeKs3fvXjx+/BjBwcEq5QMHDoSnpyfc3d1x8eJFTJ8+HdevX8fu3bsLbSs3Nxe5ubnS48zMzBLuCRERURnhJGitGSwB2rp1K8aOHSs9/vnnn3Vu87vvvkPXrl3h7u6uUj5mzBjp/40bN4abmxs6deqEhIQE+Pj4FNhWeHg45s6dq3NMREREVP4YbAisZ8+eOH/+vLQ4OjoCANLS0lTqpaWllWjuzq1bt3D48GGMGjWq2Lr+/v4AgPj4+ELrhIaGIiMjQ1qSk5OLbZeIiKhM6XoGWP5iggzWA2RrawtbW1vpsRACrq6uiImJgZ+fH4CXw05nzpzB+PHji21v/fr1cHZ2Rvfu3Yute/78eQCAm5tboXXkcjnkcnmxbRERERkKrwStvXIzCVomk2HixImYP38+9u/fj0uXLmHo0KFwd3dH7969pXqdOnXCihUrVNZVKpVYv349hg0bhkqVVHO6hIQEzJs3D3FxcUhKSsL+/fsxdOhQtG/fHk2aNCmLXSMiIqJyptxMggaAadOmITs7G2PGjMHjx4/Rtm1bREVFwcrKSqqTkJCA9PR0lfUOHz6M27dvY8SIEWptWlpa4vDhw4iIiEB2djY8PDzwwQcfYObMmaW+P0RERKWKk6C1Vq4SIJlMhrCwMISFhRVaJykpSa2sc+fOEIW8gB4eHjh69Ki+QiQiIio/mABprdwMgRERERGVlXLVA0REREQaYA+Q1pgAERERGSslAFmxtYpvwwQxASIiIjJSPA1ee5wDRERERCaHPUBERETGinOAtMYEiIiIyFgpBSDTMYFRmmYCxCEwIiIiMjnsASIiIjJWHALTGhMgIiIio6WHBAhMgKiMhf/VTW9tLX/zgN7aIiIiquiYABERERkrDoFpjQkQERGRsVIK6DyExbPAiIiIiEwDe4CIiIiMlVC+XHRtwwQxASIiIjJWnAOkNSZARERExopzgLTGOUBERERkctgDREREZKw4BKY1JkBERETGSkAPCZBeIjE6HAIjIiIik8MeICIiImPFITCtMQEiIiIyVkolAB2v46M0zesAcQiMiIiITA57gIiIiIwVh8C0xgSIiIjIWDEB0hqHwIiIiMjksAeIiIjIWPFWGFpjAqQhZVozKHPM9dJWqO/femmHiIhMkxBKCB3v5q7r+saKCRAREZGxEkL3HhzOASIiIiIyDewBIiIiMlZCD3OATLQHiAkQERGRsVIqAZmOc3hMdA6QSQyB7d69G507d0b16tUhk8lw/vx5Q4dEREREBmQSCVB2djbatm2LhQsXGjoUIiIi/cm/EKKuiwkyiSGwIUOGAACSkpIMGwgREZEeCaUSQschMJ4GTypyc3ORm5srPc7MzDRgNERERKRPJjEEpo3w8HDY29tLi4eHh6FDIiIiUsUhMK1VuARo69atqFKlirT89ttvWrUTGhqKjIwMaUlOTtZzpERERDpSCv0sJqjCDYH17NkT/v7+0uMaNWpo1Y5cLodcLtdXWERERFSOVLgeIFtbW9SpU0darK2tDR0SERFR6RDi5XV8dFq07wFasGABZDIZJk6cqL99KiMVrgeoIA8fPsTt27fxzz//AACuX78OAHB1dYWrq6shQyMiItKaUAoImW5DWELLBOiPP/7AmjVr0KRJE522bygVrgeoIPv370ezZs3QvXt3AED//v3RrFkzREZGGjgyIiIiHejc+6PU6krQWVlZGDRoENauXQsHB4dS2LHSZxIJUHBwMIQQasucOXMMHRoREVG5kJmZqbK8eimY102YMAHdu3dHYGBgGUaoXyaRABEREVVEQin0sgCAh4eHyuVfwsPDC9zm9u3bcfbs2UKfNxYmMQeIiIioQhJKAPq5GWpycjLs7Oyk4oLOhE5OTsYnn3yC6OhoWFlZ6bZdA2MCVEL5k8Qys/R3yXCzyry6NBFRRZR/9wBtJxiX1As8B3TcxAs8BwDY2dmpJEAFiYuLw7179/Dmm29KZQqFAseOHcOKFSuQm5sLc3Nz3QIqI0yASujJkycAAM83k/TYqr0e2yIiovLmyZMnsLfX/3e9paUlXF1dcTz1gF7ac3V1haWlZbH1OnXqhEuXLqmUDR8+HPXr18f06dONJvkBmACVmLu7O5KTk2FrawuZTFZovczMTHh4eKh1JRoDxm4YjN0wGLvhGHP8JY1dCIEnT57A3d29VOKwsrJCYmIi8vLy9NKepaVliYa0bG1t0ahRI5UyGxsbVK9eXa28vGMCVEJmZmaoWbNmieuXpCuxvGLshsHYDYOxG44xx1+S2Euj5+dVVlZWRj8Px5CYABEREZHWYmNjDR2CVngaPBEREZkcJkB6JpfLMXv2bKO8kSpjNwzGbhiM3XCMOX5jjp1UyURpn6NHREREVM6wB4iIiIhMDhMgIiIiMjlMgIiIiMjkMAEiIiIik8MESI92796Nzp07o3r16pDJZDh//ryhQ4IQArNmzYKbmxusra0RGBiIGzduFLmOl5cXZDKZ2jJhwgSpTocOHdSeHzduXLnblzlz5qjFWb9+/VKNU9tYw8PD8dZbb8HW1hbOzs7o3bs3rl+/rlLHEMe9KCtXroSXlxesrKzg7++P33//3WCxaBrP2rVr0a5dOzg4OMDBwQGBgYFq9YODg9WOd5cuXUp7NwBoti8bNmxQi7MsL5CnSawFvYdlMhm6d+8u1THkcS/MsWPH0KNHD7i7u0Mmk2Hv3r0GjYd0xwRIj7Kzs9G2bVssXLjQ0KFIFi1ahGXLliEyMhJnzpyBjY0NgoKC8OzZs0LX+eOPP5CSkiIt0dHRAIC+ffuq1Bs9erRKvUWLFpW7fQGAhg0bqsR5/PjxUo1T21iPHj2KCRMm4PTp04iOjsbz58/RuXNnZGdnq9Qr6+NemB07dmDy5MmYPXs2zp49i6ZNmyIoKAj37t0zinhiY2MxYMAAHDlyBKdOnYKHhwc6d+6Mu3fvqtTr0qWLyvH+73//W+72BXh5ZeJX47x161apx6lNrLt371aJ8/LlyzA3N1f7fjHEcS9KdnY2mjZtipUrVxo0DtIjQXqXmJgoAIhz584ZNA6lUilcXV3F4sWLpbLHjx8LuVwu/vvf/5a4nU8++UT4+PgIpVIplQUEBIhPPvlEn+EWSdt9mT17tmjatGkZRPg/+jru9+7dEwDE0aNHpbKyPu5FadmypZgwYYL0WKFQCHd3dxEeHm6U8bx48ULY2tqKjRs3SmXDhg0TvXr10neoxdJ0X9avXy/s7e3LKDpVuh73pUuXCltbW5GVlSWVGeq4lxQAsWfPHkOHQTpiD1AFlpiYiNTUVAQGBkpl9vb28Pf3x6lTp0rURl5eHrZs2YIRI0ao3QR269atcHR0RKNGjRAaGoqcnBy9xv8qXfblxo0bcHd3R+3atTFo0CDcvn271OLUNdZXZWRkAACqVaumUl6Wx70weXl5iIuLU9lHMzMzBAYGarSP5SmenJwcPH/+XO14x8bGwtnZGfXq1cP48ePx4MEDvcb+Om33JSsrC56envDw8ECvXr1w5cqVUo1Tl1hf9d1336F///6wsbFRKS/r406mh/cCq8BSU1MBAC4uLirlLi4u0nPF2bt3Lx4/fozg4GCV8oEDB8LT0xPu7u64ePEipk+fjuvXr2P37t16if112u6Lv78/NmzYgHr16iElJQVz585Fu3btcPnyZdja2parWF+lVCoxceJEtGnTRuUOy2V93AuTnp4OhUJR4D5eu3atTGPRVzzTp0+Hu7u7yo95ly5d8P7778Pb2xsJCQn47LPP0LVrV5w6dQrm5uZ63Yd82uxLvXr1sG7dOjRp0gQZGRn48ssv0bp1a1y5ckWjmziXRayv+v3333H58mV89913KuWGOO5kepgAaWnr1q0YO3as9PiXX35Bu3btDBiRekw///yzzm1+99136Nq1K9zd3VXKx4wZI/2/cePGcHNzQ6dOnZCQkAAfHx+dt6uvfenatav0/yZNmsDf3x+enp7YuXMnRo4cqXOcQOkc9wkTJuDy5ctq85VK+7ibqgULFmD79u2IjY1VmTzcv39/6f+NGzdGkyZN4OPjg9jYWHTq1MkQoRaoVatWaNWqlfS4devWaNCgAdasWYN58+YZMLKifffdd2jcuDFatmypUm4sx52MGxMgLfXs2RP+/v7S4xo1ahgwmpdejyk3NxcAkJaWBjc3N6k8LS0Nfn5+xbZ369YtHD58uES9C/nbjY+P18sPsb73JV/VqlVRt25dxMfH6xxjacUaEhKCn376CceOHSv2r3d9H/eScnR0hLm5OdLS0lTK09LS4OrqWmZx6COeL7/8EgsWLMDhw4fRpEmTIuvWrl0bjo6OiI+PL7UfYn0cWwsLCzRr1kyv7/OC6BJrdnY2tm/fjrCwsGK3UxbHnUwP5wBpydbWFnXq1JEWa2trQ4ekFpOvry9cXV0RExMj1cnMzMSZM2dU/loszPr16+Hs7Kxyemph8k/5f/UHXxf63pd8WVlZSEhI0Fuc+oxVCIGQkBDs2bMHv/76K7y9vYvdtr6Pe0lZWlqiefPmKvuoVCoRExOj0eth6HgWLVqEefPmISoqCi1atCh2O3fu3MGDBw9K9Xjr49gqFApcunSp1N8XusS6a9cu5ObmYvDgwcVupyyOO5kgQ8/CrkgePHggzp07J37++WcBQGzfvl2cO3dOpKSkGCymBQsWiKpVq4p9+/aJixcvil69eglvb2/x9OlTqc4777wjli9frrKeQqEQtWrVEtOnT1drMz4+XoSFhYk///xTJCYmin379onatWuL9u3bl7t9+fTTT0VsbKxITEwUJ06cEIGBgcLR0VHcu3ev3MU6fvx4YW9vL2JjY0VKSoq05OTkCCEMd9wLs337diGXy8WGDRvEX3/9JcaMGSOqVq0qUlNTy2U8Q4YMETNmzJDqL1iwQFhaWorvv/9e5Xg/efJECCHEkydPxJQpU8SpU6dEYmKiOHz4sHjzzTfFG2+8IZ49e1au9mXu3Lni4MGDIiEhQcTFxYn+/fsLKysrceXKlVKNU5tY87Vt21b069dPrdyQx70oT548EefOnRPnzp0TAMSSJUvEuXPnxK1btwwWE+mGCZAerV+/XgBQW2bPnm2wmJRKpfj888+Fi4uLkMvlolOnTuL69esqdTw9PdViPHjwoACgVlcIIW7fvi3at28vqlWrJuRyuahTp46YOnWqyMjIKM1d0Wpf+vXrJ9zc3ISlpaWoUaOG6Nevn4iPjy/VOLWNtaD3DgCxfv16IYThjntRli9fLmrVqiUsLS1Fy5YtxenTpw0WS3HxBAQEiGHDhkmPPT09i/y85uTkiM6dOwsnJydhYWEhPD09xejRo8sswdNkXyZOnCjVdXFxEd26dRNnz54tkzg1jVUIIa5duyYAiEOHDqm1ZejjXpgjR44U+H55fd/IeMiEEKLMupuIiIiIygHOASIiIiKTwwSIiIiITA4TICIiIjI5TICIiIjI5DABIiIiIpPDBIiIiIhMDhMgIiIiMjlMgIiIiMjkMAEiIr3YsGEDqlatWmrtDxkyBF988YVG60RFRcHPzw9KpbKUoiIiY8UEiKicSk1NxSeffII6derAysoKLi4uaNOmDVavXo2cnJwSt1PaiYkmrly5gg8++ABeXl6QyWSIiIgo0XoXLlzAgQMH8PHHHwMAGjdujHHjxhVYd/PmzZDL5UhPT0eXLl1gYWGBrVu36msXiKiCYAJEVA7dvHkTzZo1w6FDh/DFF1/g3LlzOHXqFKZNm4affvoJhw8fNnSIWsnJyUHt2rWxYMECuLq6lni95cuXo2/fvqhSpQoAYOTIkdi+fTuePn2qVnf9+vXo2bMnHB0dAQDBwcFYtmyZfnaAiCoOQ9+MjIjUBQUFiZo1a4qsrKwCn1cqldL/v/rqK9GoUSNRuXJlUbNmTTF+/HjpjuYF3cAx/2afz549E59++qlwd3cXlStXFi1bthRHjhwpMq5Hjx6JMWPGCGdnZyGXy0XDhg3Fjz/+KIR4eTNge3t7ERUVJerXry9sbGxEUFCQ+Oeffwpsy9PTUyxdurTYY/HixQthb28vfvrpJ6ns/v37wtLSUmzevFml7s2bN4VMJhO//PKLVHbr1i0BoExugktExoM9QETlzIMHD3Do0CFMmDABNjY2BdaRyWTS/83MzLBs2TJcuXIFGzduxK+//opp06YBAFq3bo2IiAjY2dkhJSUFKSkpmDJlCgAgJCQEp06dwvbt23Hx4kX07dsXXbp0wY0bNwrcplKpRNeuXXHixAls2bIFf/31FxYsWABzc3OpTk5ODr788kts3rwZx44dw+3bt6XtaevixYvIyMhAixYtpDJHR0f06tUL69atU6m7YcMG1KxZE507d5bKatWqBRcXF/z22286xUFEFYyhMzAiUnX69GkBQOzevVulvHr16sLGxkbY2NiIadOmFbr+rl27RPXq1aXH+T0zr7p165YwNzcXd+/eVSnv1KmTCA0NLbDdgwcPCjMzM3H9+vUCn1+/fr1aT8vKlSuFi4tLgfVL2gO0Z88eYW5urtLrJYQQUVFRQiaTiZs3bwohXvaKeXp6ipkzZ6q10axZMzFnzpxit0VEpqOSoRMwIiqZ33//HUqlEoMGDUJubq5UfvjwYYSHh+PatWvIzMzEixcv8OzZM+Tk5KBy5coFtnXp0iUoFArUrVtXpTw3NxfVq1cvcJ3z58+jZs2aauu8qnLlyvDx8ZEeu7m54d69e5rsppqnT59CLper9HoBwLvvvouaNWti/fr1CAsLQ0xMDG7fvo3hw4ertWFtba3RxHEiqviYABGVM3Xq1IFMJsP169dVymvXrg3g5Y95vqSkJLz33nsYP348/vOf/6BatWo4fvw4Ro4ciby8vEIToKysLJibmyMuLk5lCAuANNH4da9utzAWFhYqj2UyGYQQxa5XFEdHR+Tk5CAvLw+WlpZSuZmZGYKDg7Fx40bMmTMH69evR8eOHaXj9KqHDx/CyclJpziIqGLhHCCicqZ69ep49913sWLFCmRnZxdZNy4uDkqlEl999RXefvtt1K1bF//8849KHUtLSygUCpWyZs2aQaFQ4N69e6hTp47KUtjZWU2aNMGdO3fw999/67aDGvLz8wMA/PXXX2rPDR8+HMnJydi9ezf27NmDkSNHqtV59uwZEhIS0KxZs9IOlYiMCBMgonJo1apVePHiBVq0aIEdO3bg6tWruH79OrZs2YJr165JvTZ16tTB8+fPsXz5cty8eRObN29GZGSkSlteXl7IyspCTEwM0tPTkZOTg7p162LQoEEYOnQodu/ejcTERPz+++8IDw/Hzz//XGBMAQEBaN++PT744ANER0cjMTERv/zyC6Kiokq8X3l5eTh//jzOnz+PvLw83L17F+fPn0d8fHyh6zg5OeHNN9/E8ePH1Z7z9vbGO++8gzFjxkAul+P9999Xq3P69GnI5XK0atWqxHESkQkw9CQkIirYP//8I0JCQoS3t7ewsLAQVapUES1bthSLFy8W2dnZUr0lS5YINzc3YW1tLYKCgsSmTZsEAPHo0SOpzrhx40T16tVVToPPy8sTs2bNEl5eXsLCwkK4ubmJPn36iIsXLxYa04MHD8Tw4cNF9erVhZWVlWjUqJF0enpBk6337NkjXv2aSUxMVDstH4AICAgo8lisWrVKvP322wU+t23bNgFA/Otf/yrw+TFjxoixY8cW2T4RmR6ZEDoO0BMRlbKnT5+iXr162LFjh0Y9Oenp6ahXrx7+/PNPeHt7l2KERGRsOARGROWetbU1Nm3ahPT0dI3WS0pKwqpVq5j8EJEa9gARERGRyWEPEBEREZkcJkBERERkcpgAERERkclhAkREREQmhwkQERERmRwmQERERGRymAARERGRyWECRERERCaHCRARERGZnP8PT+h6uP/4a/kAAAAASUVORK5CYII=\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHHCAYAAABEEKc/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtBklEQVR4nO3deVxUVf8H8M8wyIAIiOwogoBCLqhpkltYomCaS6m5pGLu6VNmbvgz90fcMh9zK1NxjbRHzZ4MUxLK3MpyTxJCwQQUFBFQUOb8/vDhPg4zwKzA4Of9et3Xi3vm3HO/984wfDnn3HtlQggBIiIiIpJYVHUARERERNUNEyQiIiKiUpggEREREZXCBImIiIioFCZIRERERKUwQSIiIiIqhQkSERERUSlMkIiIiIhKYYJEREREVAoTJKo2fHx8EBERUdVhVIqIiAj4+PhUaQzz5s2DTCar0hiISiiVSjRv3hz//Oc/qzoUs6Hvd2Z2djZsbW1x8OBB4wdVg1R5ghQdHQ2ZTCYtlpaWqF+/PiIiIvD3339XdXgAgJycHFhYWODQoUMAgH379kGhUKCwsFClXkREhMqxlF5KH09RUREWL16MwMBAWFtbw83NDT179sSNGzf0irNLly5l7jswMFC/gycVly9fxrx583Dt2rUqi8HHxwcymQz/+Mc/1F6Lj4+HTCbDV199ZfT9BgUFoWHDhijv6UQdO3aEm5sbHj9+DAC4ffs23nvvPQQGBsLGxgaurq5o164dZsyYgby8PK33XXJcMpkMO3bsKHPfMpkMzZs31+3AyOgOHjyIefPm6bTNF198gbS0NEyaNMk0QZHEyckJo0ePxocffljVoVRrllUdQIkFCxagUaNGePjwIU6ePIno6GgcO3YMFy9ehLW1dZXGdvr0aQBAcHAwAODEiRNo3bo1FAqFSr1x48YhNDRUpUwIgfHjx8PHxwf169eXyh89eoSePXvi+PHjGDNmDIKCgnD37l2cOnUK9+7dQ4MGDfSKtUGDBoiKilIrd3Bw0Ku9ypSYmAgLiyrP2ct1+fJlzJ8/H126dKnyHqCNGzciMjISnp6elbK/oUOHYubMmfjpp5/w0ksvqb1+7do1nDhxApMmTYKlpSXu3LmDtm3bIjc3F2+//TYCAwORnZ2N8+fPY/369ZgwYQLq1KmjUwzW1tbYtWsX3nrrLbV9Hz9+vMq/K+iJgwcPYu3atTolScuXL8egQYPM4ruqJhg/fjxWr16NH374Aa+88kpVh1MtVZsEqUePHmjbti0AYPTo0XB2dsbSpUtx4MABDBw4sEpjO336NAICAlC3bl0ATxKkkmTpae3bt0f79u1Vyo4dO4aCggIMHTpUpfzjjz9GQkICjh07hnbt2hktVgcHB7U/HtWZEAIPHz6EjY2NWsJJZWvWrBkSExOxZMkSrF69ulL2OWTIEERGRmLXrl0aE6QvvvgCQgjps75p0yakpqbi559/RocOHVTq5ubmwsrKSucYXn31VRw4cABZWVlwdnaWynft2gU3Nzc0btwYd+/e1bnd6iQ/Px+2trZVHUal+v3333Hu3Dl89NFHVR3KM+O5555D8+bNER0dzQSpDNX23/XOnTsDAJKTk6WyLl26oEuXLmp1S8/nuHbtGmQyGVasWIHPPvsMfn5+UCgUeOGFF/DLL79otf979+4hKysLWVlZOHHiBFq2bImsrCxkZmbizJkzCAwMRFZWFu7du1duO7t27YJMJsOQIUOkMqVSiX/961/o168f2rVrh8ePH6OgoECruAz14MEDBAYGIjAwEA8ePJDK79y5Aw8PD3To0AHFxcUAnpzXOnXq4K+//kJYWBhsbW3h6emJBQsWqA2zKJVKrFq1Cs2aNZOGC8eNG6f2x8rHxwe9evXCoUOH0LZtW9jY2ODTTz+VXnt6PL1k+PXYsWN499134eLigrp162LcuHEoKipCTk4Ohg8fDkdHRzg6OmL69OkGx1WSsFpbW8PX1xfbtm1TiWfAgAEAgJdfflka8omPjy/3nO/fvx/NmzeHtbU1mjdvjn379mmsl5+fjw8++ABeXl5QKBQICAjAihUrNA5p+fj4YPjw4di4cSNu3rxZ7v6BJ4n6Cy+8AGtra/j5+UnnXBdeXl546aWX8NVXX+HRo0dqr+/atQt+fn7SPw/JycmQy+V48cUX1era29vr1dvTp08fKBQK7NmzR23fAwcOhFwu17jdjh070KZNG9jY2KBevXoYNGgQ0tLSVOr89NNPGDBgABo2bAiFQgEvLy+8//77Kr8nAJCRkYGRI0eiQYMGUCgU8PDwQJ8+fVSGXWUymcbek7I+4wkJCXjnnXfg6uqq0nv83XffoXPnzrC1tYWdnR169uyJS5cuqbRZ8nuampqKXr16oU6dOqhfvz7Wrl0LALhw4QJeeeUV2NrawtvbG7t27VKLKycnB5MnT5Y+e/7+/li6dCmUSqVUR9vv1YiICGnfTw/zl2f//v2wsrJSS7xL5sklJSUhIiICdevWhYODA0aOHKn2nfn48WMsXLhQisvHxwezZs1SmwqhiTbv6ddff42ePXvC09MTCoUCfn5+WLhwofR9WaJLly5o3rw5zp8/j5CQENSuXRv+/v7SsHdCQgKCg4NhY2ODgIAAHDlyROMxX7lyBQMHDoS9vT2cnJzw3nvv4eHDhxUeizbvZYlu3brhm2++KXfY/JkmqtiWLVsEAPHLL7+olK9Zs0YAEOvXr5fKQkJCREhIiFobI0aMEN7e3tJ6SkqKACBat24t/P39xdKlS8WyZcuEs7OzaNCggSgqKqowrpCQEAGgwkVTPCWKioqEk5OT6Nixo0r5hQsXBACxaNEiMWbMGGFlZSUAiBYtWogffvihwtjKizkwMFDcvn1bbcnLy5PqnTx5UsjlcvH+++9LZYMGDRI2NjYiMTFRKhsxYoSwtrYWjRs3FsOGDRNr1qwRvXr1EgDEhx9+qLLv0aNHC0tLSzFmzBixYcMGMWPGDGFrayteeOEFlfPt7e0t/P39haOjo5g5c6bYsGGDOHr0qPTaiBEjpLoln41WrVqJ8PBwsXbtWjFs2DABQEyfPl106tRJDBkyRKxbt06Ka+vWrXrHFRAQINzc3MSsWbPEmjVrxPPPPy9kMpm4ePGiEEKI5ORk8e677woAYtasWWL79u1i+/btIiMjo8z35NChQ8LCwkI0b95crFy5Uvzf//2fcHBwEM2aNVP5zCqVSvHKK68ImUwmRo8eLdasWSNee+01AUBMnjxZpU1vb2/Rs2dPkZycLCwtLcU//vEP6bWjR48KAGLPnj1S2fnz54WNjY1o2LChiIqKEgsXLhRubm4iKChI6PoV8NlnnwkA4ptvvlEpP3/+vAAg5syZI5UtXrxYABDR0dE67UOTp49ryJAhonPnztJrZ8+eFQDEiRMnREhIiGjWrJnKtosWLRIymUy8+eabYt26dWL+/PnC2dlZ+Pj4iLt370r1/vGPf4hXX31VLF68WHz66adi1KhRQi6Xi/79+6u016FDB+Hg4CBmz54tPv/8c7F48WLx8ssvi4SEBKkOADF37ly14yjrM960aVMREhIiPvnkE7FkyRIhhBDbtm0TMplMhIeHi08++UQsXbpU+Pj4iLp164qUlBSpjZLf06ZNm4rx48eLtWvXig4dOggAYsuWLcLT01NMmzZNfPLJJ6JZs2ZCLpeLv/76S9o+Pz9fBAUFCScnJzFr1iyxYcMGMXz4cCGTycR7770n1dP2e/X48eOiW7duAoD0O7J9+/Zy39/Q0FDx/PPPq5XPnTtX2ufrr78u1q1bJ0aPHi19BzxtxIgRAoDo37+/WLt2rRg+fLgAIPr27VvuvoXQ7j3t27evGDhwoFi+fLlYv369GDBggAAgpk6dqtJWSEiI8PT0FF5eXtJ5b9q0qZDL5SImJka4u7uLefPmiVWrVon69esLBwcHkZubq3bMLVq0EK+99ppYs2aNeOuttwQAMWzYMJV9lf48afteltixY4cAIC5cuFDhOXoWVZsE6ciRI+L27dsiLS1NfPXVV8LFxUUoFAqRlpYm1dU1QXJychJ37tyRyr/++muNX+6a/Prrr+Lw4cNi7dq1AoDYsWOHOHz4sIiIiBBeXl7i8OHD4vDhw+LXX38ts41vvvlGABDr1q1TKd+7d68UX+PGjcWWLVvEli1bROPGjYWVlZU4d+5chfFpUl5SN27cOJW6kZGRwsLCQvz4449iz549AoBYtWqVSp2SL5yn/wArlUrRs2dPYWVlJW7fvi2EEOKnn34SAMTOnTtVto+NjVUr9/b2FgBEbGysWvxl/fEICwsTSqVSKm/fvr2QyWRi/PjxUtnjx49FgwYNVD4f+sT1448/SmW3bt0SCoVCfPDBB1JZybkqSeoq0qpVK+Hh4SFycnKksu+//14AUPnM7t+/X0qan9a/f38hk8lEUlKSSqw9e/YUQggxcuRIYW1tLW7evCmE0Jwg9e3bV1hbW4vr169LZZcvXxZyuVznBOnOnTtCoVCIwYMHq5TPnDlTAFBJsDMyMoSLi4sAIAIDA8X48ePFrl27VM6Ftp4+rv/85z9CJpOJ1NRUIYQQ06ZNE76+vkIIoZYgXbt2TcjlcvHPf/5Tpb0LFy4IS0tLlfKCggK1/UZFRQmZTCadu7t37woAYvny5eXGq2uC1KlTJ/H48WOp/P79+6Ju3bpizJgxKttnZGQIBwcHlfKS39PFixdLZXfv3hU2NjZCJpOJmJgYqfzKlStqsS1cuFDY2tqKP//8U2VfM2fOFHK5XDrPunyvTpw4UafPVoMGDcQbb7yhVl6SLLz99tsq5f369RNOTk7SekmSPHr0aJV6U6dOFQDK/cdT2/dU0+dj3Lhxonbt2uLhw4dSWcn38K5du6SykvNuYWEhTp48KZUfOnRISmRLH3Pv3r1V9vXOO+8IACp/H0p/nrR9L0scP35cABBffvllucf+rKo2Q2yhoaFwcXGBl5cX+vfvD1tbWxw4cEDvycoA8Oabb8LR0VFaLxm2++uvvyrctk2bNggNDcXjx4/h6emJoUOHIjQ0FLdv30bXrl0RGhqK0NBQtGnTpsw2du3ahVq1aqnNoSq5euf+/fuIi4tDREQEIiIicOTIEQghsGzZMn0OF8CTLvzDhw+rLZMnT1apN2/ePDRr1gwjRozAO++8g5CQELz77rsa23z6qhKZTIZJkyahqKhI6hres2cPHBwc0K1bN2lYMisrC23atEGdOnVw9OhRlfYaNWqEsLAwrY9p1KhRKl30wcHBEEJg1KhRUplcLkfbtm1V3ltd42ratKn0GQEAFxcXBAQEaPV50SQ9PR1nz57FiBEjVCaeduvWDU2bNlWpe/DgQcjlcrX34IMPPoAQAt99953GfcyePRuPHz/GkiVLNL5eXFyMQ4cOoW/fvmjYsKFU/txzz+n0HpRwdHSU5gHl5+cDeDKPLCYmBm3btkWTJk2kum5ubjh37hzGjx+Pu3fvYsOGDRgyZAhcXV2xcOFCvbv1u3fvjnr16iEmJkba9+DBgzXW3bt3L5RKJQYOHKjyGXB3d0fjxo1VPgM2NjbSz/n5+cjKykKHDh0ghMDvv/8u1bGyskJ8fLxR5zqNGTNGZXjw8OHDyMnJweDBg1XilsvlCA4OVvvsAk/mbpaoW7cuAgICYGtrq/L9UzKXsvTvSefOneHo6Kiyr9DQUBQXF+PHH39U2Y8h36tlyc7OVmmztPHjx6usd+7cGdnZ2cjNzQUA6XL1KVOmqNT74IMPAADffvttmW1r+54+/fm4f/8+srKy0LlzZxQUFODKlSsqdevUqYNBgwZJ6yXn/bnnnlOZv1rys6ZzN3HiRJX1kqtWy7s0X9f3suScZ2Vlldnms6zaTNJeu3YtmjRpgnv37mHz5s348ccfDZ60+/QfBOB/H4aKvtjy8vKksd7Dhw/jxRdfRFZWFpRKJX766ScsWrRI+rIq65c6Ly8PX3/9NcLCwuDk5KTyWskvWseOHeHl5aUSb6dOnXD8+HHdDvQptra2alfSaWJlZYXNmzdL81K2bNmicZ6AhYUFfH19VcpK/giWjM9fvXoV9+7dg6urq8Z93bp1S2W9UaNG2hyKpPT7WJJsPH3uSsqffm91jav0foAnnxl9/xBev34dANC4cWO11wICAvDbb7+p1PX09ISdnZ1Kveeee06lrdJ8fX0xbNgwfPbZZ5g5c6ba67dv38aDBw/KjEGf+6AMHToU+/btw9dff40hQ4bg+PHjuHbtGt577z21uh4eHli/fj3WrVuHq1ev4tChQ1i6dCnmzJkDDw8PlT/q2qpVqxYGDBiAXbt2oV27dkhLS1OZ4/e0q1evQgih8fhL2iqRmpqKOXPm4MCBA2rveclcQ4VCgaVLl+KDDz6Am5sbXnzxRfTq1QvDhw+Hu7u7zsdSovTvxNWrVwGgzMmz9vb2KuvW1tZwcXFRKXNwcECDBg3Ufq81/Z6cP39ebfsSFf2eaPu9WpHyEuby9mlvb4/r16/DwsIC/v7+KvXc3d1Rt27dMn9/AO3f00uXLmH27Nn44YcfpMSsROm5qGWdd03fWSXHUVrpz6yfnx8sLCzKvcWIru9lyTnn/dA0qzYJUrt27aSr2Pr27YtOnTphyJAhSExMlC4FlslkGn+JSk+SK1HWhM2K/nOdNGkStm7dqlK2d+9e6ed3330X7777Lry9vcv8sO7fv1/j1WsApMuy3dzc1F5zdXWV/ls1tZL7Oj18+BBXr17VOXEpoVQq4erqip07d2p8vfQv69P/iWmjrPdRU/nT762ucen7ealq//d//4ft27dj6dKl6Nu3r8n316tXLzg4OGDXrl0YMmQIdu3aBblcrvIfc2kymQxNmjRBkyZN0LNnTzRu3Bg7d+7UK0ECnlxRt2HDBsybNw8tW7ZU65EroVQqIZPJ8N1332l8f0u+W4qLi9GtWzfcuXMHM2bMQGBgIGxtbfH3338jIiJCZYLr5MmT8dprr2H//v04dOgQPvzwQ0RFReGHH35A69aty427rO+q0r8TJfvbvn27xsTL0lL1q1uX3xFA/fekW7dumD59usa6T/cKatumrpycnMpNsLTdp75/6Ct6T3NychASEgJ7e3ssWLAAfn5+sLa2xm+//YYZM2aoTYA25P0oizbHput7WXLOn74ilP6n2iRIT5PL5YiKisLLL7+MNWvWSP8ZOzo6auyKLO+/A31Mnz4db731FlJSUjB27Fhs27YNHh4e2L17Nw4ePIjo6GgA5f+h37lzJ+rUqYPevXurvdaiRQvUqlVL440wb968WWb2b0znz5/HggULMHLkSJw9exajR4/GhQsX1O5BolQq8ddff6n8Yv35558AIF056OfnhyNHjqBjx446Jz+mZIq4dPkC9vb2BvC/3oCnJSYmqtU9cuQI7t+/r9KLVNJ1X9KWJn5+fnjrrbfw6aefqt1+wsXFBTY2NlrFoC2FQoH+/ftj27ZtyMzMxJ49e/DKK69o3YPi6+sLR0dHpKen67V/AOjUqRMaNmyI+Ph4LF26tMx6fn5+EEKgUaNGan8cnnbhwgX8+eef2Lp1K4YPHy6VHz58uMx2P/jgA3zwwQe4evUqWrVqhY8++ki6iaWjoyNycnJUtikqKtL6mP38/AA8+YdJmx5hQ/j5+SEvL8+o+9E1UQkMDERKSore+/P29oZSqcTVq1elXlcAyMzMRE5OTrm/PyXKe0/j4+ORnZ2NvXv3qlxpZ0jMFSn9T2tSUhKUSmW591/T9b0sif/pc0b/U23mIJXWpUsXtGvXDqtWrZKGu/z8/HDlyhXcvn1bqnfu3Dn8/PPPRt1306ZNERoaCktLSzg6OuKtt95CaGgocnNz0alTJ2n+UceOHTVuf/v2bRw5cgT9+vVD7dq11V63s7PDq6++iuPHj6uMXf/xxx84fvw4unXrZtTjKe3Ro0eIiIiAp6cn/vWvfyE6OhqZmZl4//33NdZfs2aN9LMQAmvWrEGtWrXQtWtXAMDAgQNRXFyMhQsXqm37+PFjtT8UlcUUcZXcn0abbT08PNCqVSts3bpVpQv+8OHDuHz5skrdV199FcXFxSrnGnhyvyyZTIYePXqUu6/Zs2fj0aNHavPX5HI5wsLCsH//fqSmpkrlf/zxh9SDqI+hQ4fi0aNHGDduHG7fvq2xp/TUqVPSPKWnnT59GtnZ2QgICNB7/zKZDKtXr8bcuXMxbNiwMuu9/vrrkMvlmD9/vtp/6UIIZGdnA/jff/ZP1xFC4F//+pfKNgUFBWqXWvv5+cHOzk7lcnI/Pz+1+R6fffZZmT1IpYWFhcHe3h6LFy/WeEuFp78DDTVw4ECcOHFC4+chJydHuiu6LnT5PQGe3EPu4sWLWl2Sr8mrr74KAFi1apVK+cqVKwEAPXv2LHNbbd5TTZ+PoqIirFu3Tq94tVFyq4QSn3zyCQCU+12g63t55swZODg4oFmzZkaIuOaplj1IJaZNm4YBAwYgOjoa48ePx9tvv42VK1ciLCwMo0aNwq1bt7BhwwY0a9ZMbUzYGH7++We8+OKL0n9Dx48fx9SpUyvc7ssvv8Tjx481/tEosXjxYsTFxeGVV16RJuauXr0a9erVw6xZs1TqymQyhISEVHi/HeDJWHhZj2IouYHkokWLcPbsWcTFxcHOzg5BQUGYM2cOZs+ejf79+0tfNsCTuQ2xsbEYMWIEgoOD8d133+Hbb7/FrFmzpJ6ukJAQjBs3DlFRUTh79iy6d++OWrVq4erVq9izZw/+9a9/oX///hXGbmymiKtVq1aQy+VYunQp7t27B4VCgVdeeaXMeU5RUVHo2bMnOnXqhLfffht37tzBJ598gmbNmqk8auO1117Dyy+/jP/7v//DtWvX0LJlS3z//ff4+uuvMXnyZKlHoSwlvUilh4YBYP78+YiNjUXnzp3xzjvv4PHjx1IM58+f1+n4S4SEhKBBgwb4+uuvYWNjg9dff12tzvbt27Fz507069cPbdq0gZWVFf744w9s3rwZ1tbWap9zXfXp0wd9+vQpt46fnx8WLVqEyMhIXLt2DX379oWdnR1SUlKwb98+jB07FlOnTkVgYCD8/PwwdepU/P3337C3t8e///1vtWGfP//8E127dsXAgQPRtGlTWFpaYt++fcjMzFQZYhw9ejTGjx+PN954A926dcO5c+dw6NAhrYcy7O3tsX79egwbNgzPP/88Bg0aBBcXF6SmpuLbb79Fx44d1ZJpfU2bNg0HDhxAr169EBERgTZt2iA/Px8XLlzAV199hWvXruk8BFNy8cq7776LsLCwCodg+/Tpg4ULFyIhIQHdu3fX+RhatmyJESNG4LPPPpOGw06fPo2tW7eib9++ePnll8vcVpv3tEOHDnB0dMSIESPw7rvvQiaTYfv27SYdfk9JSUHv3r0RHh6OEydOYMeOHRgyZAhatmxZ5ja6vpeHDx/Ga6+9xjlIZamsy+XKUtZ9kIQQori4WPj5+Qk/Pz/pEtgdO3YIX19fYWVlJVq1aiUOHTpU5mX+mi7bRBmX32oSGBgoFi5cKIQQ4saNG2XGWdqLL74oXF1dVS7b1eTMmTMiNDRU2NraCjs7O9GnTx+1yzPv378vAIhBgwZVuN+K7t1Uss/S984R4sll8i+88ILw9PSU7g0zYsQIYWtrK5KTk0X37t1F7dq1hZubm5g7d64oLi5W2/9nn30m2rRpI2xsbISdnZ1o0aKFmD59unQJuhCql6iXVtYl0KXPecllsCW3GShREq8x49J0a4mNGzcKX19f6TL5ii75//e//y2ee+45oVAoRNOmTcXevXvVPrNCPHmv33//feHp6Slq1aolGjduLJYvX65yi4PyYr169aoU09OX+QshREJCgmjTpo2wsrISvr6+YsOGDdJ51Ne0adMEADFw4ECNr58/f15MmzZNPP/886JevXrC0tJSeHh4iAEDBojffvtNp31pun2BJprugyTEk/egU6dOwtbWVtja2orAwEAxceJEldsSXL58WYSGhoo6deoIZ2dnMWbMGHHu3DmVy7CzsrLExIkTRWBgoLC1tRUODg4iODhY7N69W2V/xcXFYsaMGcLZ2VnUrl1bhIWFiaSkJK0/408fd1hYmHBwcBDW1tbCz89PREREqNxepKzPfVnnQtPn5/79+yIyMlL4+/sLKysr4ezsLDp06CBWrFgh3d9Il+/Vx48fi3/84x/CxcVFyGQyrT5nQUFBYtSoUSplZf2ul5y3p+8H9ejRIzF//nzRqFEjUatWLeHl5SUiIyNVLsHXRNv39OeffxYvvviisLGxEZ6enmL69OnSZfpPfwfoct6FeHLuJk6cqHbMly9fFv379xd2dnbC0dFRTJo0STx48ECtzac/T0Jo914KIcQff/wh3WKHNJMJUc1noD7jDh48iF69euHcuXNo0aJFpe47IiICX331lU4PFSUi0sf27dsxceJEpKamSo91ehbNmzcP8+fPx+3bt006eXry5Mn48ccfcebMGfYglaHazkGiJ44ePYpBgwZVenJERFSZhg4dioYNG6rNvSHjy87Oxueff45FixYxOSpHtZ6DRE+ecE1kavfu3VN75lhphtznpywPHjyo8HmG9erV0+vBtmReLCwscPHixaoO45ng5OTEkQEtMEEiIrz33nsaJ3g/zRSj8V9++SVGjhxZbp2jR49qfEg1EZEpcQ4SEeHy5cu4efNmuXVMcT+e9PR0tafTl9amTZtyH0NBRGQKTJCIiIiISuEkbSIiIqJSOAdJS0qlEjdv3oSdnR1n/RMRUbmEELh//z48PT1hYWGavoiHDx+iqKjIKG1ZWVnB2traKG3VFEyQtHTz5k21JzETERGVJy0tDQ0aNDB6uw8fPkQj7zrIuKXd42sq4u7ujpSUFCZJT2GCpKWSB4impaXB3t6+iqMhIiJj6+MwvOJKWnqMRziGgyoPnzamoqIiZNwqxvUzPrC3M6yHKve+Et5trqGoqIgJ0lOYIGmpZFjN3t6eCRIRUQ1kKatlvMb+e/mTqadk1LGToY6dYftQgtNGNGGCREREZKaKhRLFBl6LXiyUxgmmhuFVbERERGZKCWGURVd///033nrrLTg5OcHGxgYtWrTAr7/+aoIjrDrPTIL0448/4rXXXoOnpydkMhn2799f1SERERGZnbt376Jjx46oVasWvvvuO1y+fBkfffRRjbuh6zMzxJafn4+WLVvi7bffxuuvv17V4RARERlMCSUMHSDTtYWlS5fCy8sLW7ZskcoaNWpkYBTVzzOTIPXo0QM9evSo6jCIiIiMplgIFBv4QIyS7XNzc1XKFQoFFAqFWv0DBw4gLCwMAwYMQEJCAurXr4933nkHY8aMMSiO6uaZGWLTVWFhIXJzc1UWIiKimsrLywsODg7SEhUVpbHeX3/9hfXr16Nx48Y4dOgQJkyYgHfffbfCB16bm2emB0lXUVFRmD9/flWHQUREVCZ9J1mXbgNQv8+fpt4j4MmTJdq2bYvFixcDAFq3bo2LFy9iw4YNGDFihEGxVCfsQSpDZGQk7t27Jy1paWlVHRIREZEKJQSKDVxKEqSS+/yVLGUlSB4eHmjatKlK2XPPPYfU1FSTH29lYg9SGcoaeyUiInqWdezYEYmJiSplf/75J7y9vasoItNggkRERGSmjDnEpq33338fHTp0wOLFizFw4ECcPn0an332GT777DOD4qhunpkEKS8vD0lJSdJ6SkoKzp49i3r16qFhw4ZVGBkREZF+jHkVm7ZeeOEF7Nu3D5GRkViwYAEaNWqEVatWYejQoQbFUd08MwnSr7/+ipdffllanzJlCgBgxIgRiI6OrqKoiIiIzE+vXr3Qq1evqg7DpJ6ZBKlLly4QBmbZRERE1Ynyv4uhbZC6ZyZBIiIiqmlKrkQztA1SxwSJiIjITBWLJ4uhbZA63geJiIiIqBT2IBERkVkKdx5r1PYOK/cYra3c3Fw4ODgYrb2ycA6S6TBBIiIiMlNKyFAMmcFtkDoOsRERERGVwh4kIiIiM6UUTxZD2yB1TJCIiIjMVLERhtgM3b6m4hAbERERUSnsQSIiIjJT7EEyHSZIREREZkopZFAKA69iM3D7mopDbERERESlsAeJiIjITHGIzXSYIBEREZmpYlig2MDBoGIjxVLTMEEiIiIyU8IIc5AE5yBpxDlIRERERKWwB4mIiMhMcQ6S6TBBIiIiMlPFwgLFwsA5SHzUiEYcYiMiIiIqhT1IREREZkoJGZQG9nUowS4kTZggERERmSnOQTIdJkhERFQpejSaYtT2YrM+M2p7RE9jgkRERGSmjDNJm0NsmjBBIiIiMlNP5iAZ+LBaDrFpxKvYiIiIiEphDxIREZGZUhrhWWy8ik0zJkhERERminOQTIcJEhERkZlSwoL3QTIRzkEiIiIiKoU9SERERGaqWMhQLAy8UaSB29dUTJCIiIjMVLERJmkXc4hNIw6xEREREZXCHiQiIiIzpRQWUBp4FZuSV7FpVC17kNauXQsfHx9YW1sjODgYp0+fLrNuly5dIJPJ1JaePXtKdSIiItReDw8Pr4xDISIiMpmSITZDF1JX7XqQvvzyS0yZMgUbNmxAcHAwVq1ahbCwMCQmJsLV1VWt/t69e1FUVCStZ2dno2XLlhgwYIBKvfDwcGzZskVaVygUpjsIIiIiMmvVLm1cuXIlxowZg5EjR6Jp06bYsGEDateujc2bN2usX69ePbi7u0vL4cOHUbt2bbUESaFQqNRzdHSsjMMhIiIyGSX+dyWbvouyqg+imqpWCVJRURHOnDmD0NBQqczCwgKhoaE4ceKEVm1s2rQJgwYNgq2trUp5fHw8XF1dERAQgAkTJiA7O7vcdgoLC5Gbm6uyEBERVSclN4o0dCF11eqsZGVlobi4GG5ubirlbm5uyMjIqHD706dP4+LFixg9erRKeXh4OLZt24a4uDgsXboUCQkJ6NGjB4qLi8tsKyoqCg4ODtLi5eWl30ERERHVIPPmzVOb1xsYGFhmfXOdK1zt5iAZYtOmTWjRogXatWunUj5o0CDp5xYtWiAoKAh+fn6Ij49H165dNbYVGRmJKVOmSOu5ublMkoiIqFoxzrPYdN++WbNmOHLkiLRuaVl2OmGuc4WrVYLk7OwMuVyOzMxMlfLMzEy4u7uXu21+fj5iYmKwYMGCCvfj6+sLZ2dnJCUllZkgKRSKKn9ziIiIyqOEDEoYdidsfba3tLSs8O9yiXr16qmsx8TElDtXuLqoVgmSlZUV2rRpg7i4OPTt2xcAoFQqERcXh0mTJpW77Z49e1BYWIi33nqrwv3cuHED2dnZ8PDwMEbYREQ1UljruUZt71DKSqO2R1XXg3T16lV4enrC2toa7du3R1RUFBo2bKjVthXNFXZ0dMQrr7yCRYsWwcnJSefYjKVazUECgClTpmDjxo3YunUr/vjjD0yYMAH5+fkYOXIkAGD48OGIjIxU227Tpk3o27ev2snMy8vDtGnTcPLkSVy7dg1xcXHo06cP/P39ERYWVinHREREVN2VvjCpsLBQY73g4GBER0cjNjYW69evR0pKCjp37oz79+9XuA9jzhU2tWrVgwQAb775Jm7fvo05c+YgIyMDrVq1QmxsrDRxOzU1FRYWqnldYmIijh07hu+//16tPblcjvPnz2Pr1q3IycmBp6cnunfvjoULF3IIjYiIzJpxnsX2ZPvS82znzp2LefPmqdXv0aOH9HNQUBCCg4Ph7e2N3bt3Y9SoUeXuy5hzhU2t2iVIADBp0qQyh9Ti4+PVygICAiDKuFW6jY0NDh06ZMzwiIiIqgWlkEEpDJyD9N/t09LSYG9vL5Vr24lQt25dNGnSBElJSeXWM/ZcYVOrdkNsREREVPns7e1VFm0TpLy8PCQnJ1c4r9fc5gozQSIiIjJTSiM8h03XG0VOnToVCQkJuHbtGo4fP45+/fpBLpdj8ODBAGrOXOFqOcRGREREFVMKCygNvIpN1+1v3LiBwYMHIzs7Gy4uLujUqRNOnjwJFxcXADVnrjATJCIiItJaTExMua/XlLnCTJCIiIjMVDFkKDbwRpGGbl9TMUEiIiIyU1UxxPas4FkhIiIiKoU9SERERGaqGIYPkVXdvaqrNyZIREREZopDbKbDBImIiMhMVdXDap8FPCtEREREpbAHiYiIyEwJyKA0cA6S4GX+GjFBIiIiMlMcYjMdnhUiIiKiUtiDRERUQ3Rvv9Co7X3/+3yjtkfGpxQyKIVhQ2SGbl9TMUEiIiIyU8WwQLGBg0GGbl9T8awQERERlcIeJCIiIjPFITbTYYJERERkppSwgNLAwSBDt6+peFaIiIiISmEPEhERkZkqFjIUGzhEZuj2NRUTJCIiIjPFOUimwwSJiIjITAlhAaWBd8IWvJO2RjwrRERERKWwB4mIiMhMFUOGYgMfNmvo9jUVEyQiIiIzpRSGzyFSCiMFU8NwiI2IiIioFPYgERERmSmlESZpG7p9TcUEiYiIyEwpIYPSwDlEhm5fUzFtJCIiIiqFPUhERERminfSNh0mSERERGaKc5BMh2eFiIiIqBSz7UFau3Ytli9fjoyMDLRs2RKffPIJ2rVrp7FudHQ0Ro4cqVKmUCjw8OHDygiViKhMr3RbYrS2fjjxodHaIvOghBGexcZJ2hqZZQ/Sl19+iSlTpmDu3Ln47bff0LJlS4SFheHWrVtlbmNvb4/09HRpuX79eiVGTEREZHziv1exGbIIJkgamWWCtHLlSowZMwYjR45E06ZNsWHDBtSuXRubN28ucxuZTAZ3d3dpcXNzq8SIiYiIjE8pZEZZSJ3ZJUhFRUU4c+YMQkNDpTILCwuEhobixIkTZW6Xl5cHb29veHl5oU+fPrh06VK5+yksLERubq7KQkRERM8Gs0uQsrKyUFxcrNYD5ObmhoyMDI3bBAQEYPPmzfj666+xY8cOKJVKdOjQATdu3ChzP1FRUXBwcJAWLy8vox4HERGRoUquYjN0IXXPxFlp3749hg8fjlatWiEkJAR79+6Fi4sLPv300zK3iYyMxL1796QlLS2tEiMmIiKqGIfYTMfsrmJzdnaGXC5HZmamSnlmZibc3d21aqNWrVpo3bo1kpKSyqyjUCigUCgMipWIiIjMk9n1IFlZWaFNmzaIi4uTypRKJeLi4tC+fXut2iguLsaFCxfg4eFhqjCJiIhMztAr2IzxLLeayux6kABgypQpGDFiBNq2bYt27dph1apVyM/Pl+51NHz4cNSvXx9RUVEAgAULFuDFF1+Ev78/cnJysHz5cly/fh2jR4+uysMgIiIyiDGGyDjEpplZJkhvvvkmbt++jTlz5iAjIwOtWrVCbGysNHE7NTUVFhb/6xy7e/cuxowZg4yMDDg6OqJNmzY4fvw4mjZtWlWHQERERNWY2Q2xlZg0aRKuX7+OwsJCnDp1CsHBwdJr8fHxiI6OltY//vhjqW5GRga+/fZbtG7dugqiJiIiMp6qmKQ9b948yGQylSUwMLDM+tHR0Wr1ra2tDT10kzPLHiQiIiKquiG2Zs2a4ciRI9K6pWX56YS9vT0SExOldZms+g/rMUEiIiIinVhaWmp95Tjwv6dZmBOzHWIjIiJ61hlziK300yMKCwvL3O/Vq1fh6ekJX19fDB06FKmpqeXGqevTLKoDJkhERERmSsDwS/3Ff9vy8vJSeYJEyZXgpQUHByM6OhqxsbFYv349UlJS0LlzZ9y/f19jfX2eZlEdcIiNiIjITBlzDlJaWhrs7e2l8rJultyjRw/p56CgIAQHB8Pb2xu7d+/GqFGj1Oq3b99e5T6FHTp0wHPPPYdPP/0UCxcuNCh2U2KCRERERLC3t1dJkLRVt25dNGnSpNynUzxNm6dZVAccYiMiIjJT1eFZbHl5eUhOTtb66RTm8jQL9iAREemg0xsrjNrescMzjdoePVuq4jL/qVOn4rXXXoO3tzdu3ryJuXPnQi6XY/DgwQBqztMsmCARERGR1m7cuIHBgwcjOzsbLi4u6NSpE06ePAkXFxcANedpFkyQiIiIzFRV9CDFxMSU+3p8fLzK+scff4yPP/5Y17CqHBMkIiIiMyWEDMLABMnQ7WsqTtImIiIiKoU9SERERGaq5GaPhrZB6pggERERmamqeljts4BDbERERESlsAeJiIjITHGStukwQSIiIjJTHGIzHSZIREREZoo9SKbDOUhEREREpbAHiYiIyEwJIwyxsQdJMyZIREREZkoAEMLwNkgdh9iIiIiISmEPEhERkZlSQgYZ76RtEkyQiIiIzBSvYjMdDrERERERlcIeJCKq0YKHrTRqe6f+PdWo7REZQilkkPFGkSbBBImIiMhMCWGEq9h4GZtGHGIjIiIiKoU9SERERGaKk7RNhwkSERGRmWKCZDpMkIiIiMwUJ2mbDucgEREREZXCHiQiIiIzxavYTKda9iCtXbsWPj4+sLa2RnBwME6fPl1m3Y0bN6Jz585wdHSEo6MjQkND1epHRERAJpOpLOHh4aY+DCIiIpN6kiDJDFyq+iiqp2qXIH355ZeYMmUK5s6di99++w0tW7ZEWFgYbt26pbF+fHw8Bg8ejKNHj+LEiRPw8vJC9+7d8ffff6vUCw8PR3p6urR88cUXlXE4REREZIaqXYK0cuVKjBkzBiNHjkTTpk2xYcMG1K5dG5s3b9ZYf+fOnXjnnXfQqlUrBAYG4vPPP4dSqURcXJxKPYVCAXd3d2lxdHSsjMMhIiIyGcN7jwy/Cq6mqlYJUlFREc6cOYPQ0FCpzMLCAqGhoThx4oRWbRQUFODRo0eoV6+eSnl8fDxcXV0REBCACRMmIDs7u9x2CgsLkZubq7IQERFVJ8JIC6mrVglSVlYWiouL4ebmplLu5uaGjIwMrdqYMWMGPD09VZKs8PBwbNu2DXFxcVi6dCkSEhLQo0cPFBcXl9lOVFQUHBwcpMXLy0u/gyIiIiKzU6OuYluyZAliYmIQHx8Pa2trqXzQoEHSzy1atEBQUBD8/PwQHx+Prl27amwrMjISU6ZMkdZzc3OZJBERUbXCG0Wajs4JUmFhIU6dOoXr16+joKAALi4uaN26NRo1amRwMM7OzpDL5cjMzFQpz8zMhLu7e7nbrlixAkuWLMGRI0cQFBRUbl1fX184OzsjKSmpzARJoVBAoVDodgBERESVyRhjZBxj00jrBOnnn3/Gv/71L3zzzTd49OgRHBwcYGNjgzt37qCwsBC+vr4YO3Ysxo8fDzs7O72CsbKyQps2bRAXF4e+ffsCgDThetKkSWVut2zZMvzzn//EoUOH0LZt2wr3c+PGDWRnZ8PDw0OvOImIiKoFY0yyZg+SRlrNQerduzfefPNN+Pj44Pvvv8f9+/eRnZ2NGzduoKCgAFevXsXs2bMRFxeHJk2a4PDhw3oHNGXKFGzcuBFbt27FH3/8gQkTJiA/Px8jR44EAAwfPhyRkZFS/aVLl+LDDz/E5s2b4ePjg4yMDGRkZCAvLw8AkJeXh2nTpuHkyZO4du0a4uLi0KdPH/j7+yMsLEzvOImIiKjm0qoHqWfPnvj3v/+NWrVqaXzd19cXvr6+GDFiBC5fvoz09HS9A3rzzTdx+/ZtzJkzBxkZGWjVqhViY2OlidupqamwsPhfXrd+/XoUFRWhf//+Ku3MnTsX8+bNg1wux/nz57F161bk5OTA09MT3bt3x8KFCzmERkREZo130jYdmRDanZri4mLI5XJTx1Nt5ebmwsHBAffu3YO9vX1Vh0NEWgoettKo7Z3aPqXiSvTMM/XfjJL2fTbPhkVt64o3KIey4CGuvb3IrP++mWJ+tNZzkOrXr4+IiAi8/fbbaNKkid47JCIqT+D8j43a3hUmNEQ1linnR2t9H6SJEyfiq6++wnPPPYfOnTsjOjoaBQUFOh8MERERGYmQGWcxQ6aeH611gvThhx8iKSkJcXFx8PX1xaRJk+Dh4YExY8bg1KlTOh8YERERGaZkDpKhiznq2bMnUlJSsGzZMnTu3Bk2NjYqr5fMjY6NjUVcXJzK/GVt6Hwn7S5dumDr1q3IyMjARx99hD/++APt27dHs2bNsHKlccf6iYiIiDQZN26c1klP06ZNy7zvYVn0ftRInTp1MHr0aBw7dgzffPMNMjIyMG3aNH2bIyIiIl1VwcPY5s2bB5lMprIEBgaWWX/jxo3o3LkzHB0d4ejoiNDQUJw+fVqlTkREhFqb4eHhFcZSv359zJw5E3/++aduB6EFvROkgoICREdHIyQkBL1794aTkxP++c9/GjM2IiIiKkfJo0YMXXTVrFkzpKenS8uxY8fKrBsfH4/Bgwfj6NGjOHHiBLy8vNC9e3f8/fffKvXCw8NV2vziiy8qjMOU86N1TpCOHz+O0aNHw8PDAxMnToSPjw+OHj2KP//8EzNnzjRKUERERFR9WVpawt3dXVqcnZ3LrLtz50688847aNWqFQIDA/H5559LT8l4mkKhUGnT0dGxwjhMOT9a6wRp2bJlUoZ24cIFLF++HBkZGdi6dSteeuklg4IgIiIiPRlpeC03N1dlKSwsLHOXV69ehaenJ3x9fTF06FCkpqZqHW5BQQEePXqEevXqqZTHx8fD1dUVAQEBmDBhArKzs7Vu0xTzo7VOkJYvX47w8HCcO3cOp06dwtixY/V+5hoREREZzphDbF5eXnBwcJCWqKgojfsMDg5GdHQ0YmNjsX79eqSkpKBz5864f/++VjHPmDEDnp6eCA0NlcrCw8Oxbds2xMXFYenSpUhISECPHj1QXFys0/kw5vxorW8UefPmzTIfNUJERERVQI9J1hrbAJCWlqZyJ+2yHsfVo0cP6eegoCAEBwfD29sbu3fvxqhRo8rd1ZIlSxATE4P4+HhYW//vDuCDBg2Sfm7RogWCgoLg5+eH+Ph4na4+KygowO7du7FlyxYcO3YMfn5+eidIWvUgxcTEaJ0cpaWl4eeff9YrGCIiIqoa9vb2Kou2zyutW7cumjRpgqSkpHLrrVixAkuWLMH333+PoKCgcuv6+vrC2dm5wjZLmGJ+tFYJ0vr16/Hcc89h2bJl+OOPP9Rev3fvHg4ePIghQ4bg+eef12nckIiIiPQlM9Kiv7y8PCQnJ8PDw6PMOsuWLcPChQsRGxuLtm3bVtjmjRs3kJ2dXW6bJe2aan60VkNsCQkJOHDgAD755BNERkbC1tYWbm5usLa2xt27d5GRkQFnZ2dERETg4sWLcHNzMygoIiIi0oIRh9i0NXXqVLz22mvw9vbGzZs3MXfuXMjlcgwePBgAMHz4cNSvX1+aw7R06VLMmTMHu3btgo+PDzIyMgA8mS9Up04d5OXlYf78+XjjjTfg7u6O5ORkTJ8+Hf7+/ggLCys3luXLl+Ott97Cnj170Lx5c92PvRxaz0Hq3bs3evfujaysLBw7dgzXr1/HgwcP4OzsjNatW6N169Y638abiIiIzMuNGzcwePBgZGdnw8XFBZ06dcLJkyfh4uICAEhNTVXJB9avX4+ioiL0799fpZ25c+di3rx5kMvlOH/+PLZu3YqcnBx4enqie/fuWLhwYYXDfKacH611glTC2dkZffv2NUEoREREpJMq6EGKiYkp9/X4+HiV9WvXrpVb38bGBocOHdItiP/G8fTk7vKkpaUhNTUVHTt21Lp9dvkQERGZKyEzzmKGTD0/WuceJCIiIqKqZur50UyQiIiIzJQQTxZD2zBXppwfzQSJiAzSdPbHRm3vyqL3jdoeUY1WBXOQqiNTzI/mHCQiIiKiUnRKkNLT07Fjxw4cPHgQRUVFKq/l5+djwYIFRg2OiIiIyvEMT9I2Na0TpF9++QVNmzbFxIkT0b9/fzRr1gyXLl2SXi+50RMRERFVDpkwzkLqtE6QZs2ahX79+uHu3bvIzMxEt27dEBISgt9//92U8REREVFZhJEWUqP1JO0zZ85g7dq1sLCwgJ2dHdatW4eGDRuia9euOHToEBo2bGjKOImIiIgqjU5zkB4+fKiyPnPmTMyaNQvdu3fH8ePHjRoYERERVYBzkMqVlpaGt99+W69ttU6QmjdvrjEJmjp1KiIjI6WH1BEREVEl4RBbue7cuYOtW7fqta3WQ2zDhw9HQkICxo8fr/ba9OnTIYTAhg0b9AqCiIiISFcHDhwo9/W//vpL77a1TpBGjx6N0aNHl/n6jBkzMGPGDL0DISIiIh094zeK7Nu3L2QyGUQ5twOXyfQbQuSNIomIiMzVMz7E5uHhgb1790KpVGpcfvvtN73b1jlByszMxLBhw+Dp6QlLS0vI5XKVhYiIiKgytGnTBmfOnCnz9Yp6l8qj87PYIiIikJqaig8//BAeHh56d10RERGRgYxxFZoZX8U2bdo05Ofnl/m6v78/jh49qlfbOidIx44dw08//YRWrVrptUMiIiIyDmPcCduc76TduXPncl+3tbVFSEiIXm3rPMTm5eWld3cVERERkbHt2LGj3J4kfeicIK1atQozZ87EtWvXjBpIZVi7di18fHxgbW2N4OBgnD59uqpDIiIi0t8zPkm7xPvvvw83NzcMGTIEBw8eRHFxscFtajXE5ujoqDLXKD8/H35+fqhduzZq1aqlUvfOnTsGB2UKX375JaZMmYINGzYgODgYq1atQlhYGBITE+Hq6lrV4REREZGe0tPTERsbiy+++AIDBw5E7dq1MWDAAAwdOhQdOnTQq02tEqRVq1bp1Xh1snLlSowZMwYjR44EAGzYsAHffvstNm/ejJkzZ1ZxdERERLqTwQhzkIwSSdWytLREr1690KtXLxQUFGDfvn3YtWsXXn75ZTRo0ADJycm6t6lNpREjRujccHVSVFSEM2fOIDIyUiqzsLBAaGgoTpw4oXGbwsJCFBYWSuu5ubkmj5OIiIgMU7t2bYSFheHu3bu4fv06/vjjD73a0fkqtoMHD0IulyMsLEyl/Pvvv0dxcTF69OihVyCmlJWVheLiYri5uamUu7m54cqVKxq3iYqKwvz58ysjPKJK1WjNR0ZtL2XRB0Ztj4h08Ixf5v+0kp6jnTt3Ii4uDl5eXhg8eDC++uorvdrTeZL2zJkzNU5+UiqVNWqoKjIyEvfu3ZOWtLS0qg6JiIhIFSdpAwAGDRoEV1dXvP/++/D19UV8fDySkpKwcOFCBAYG6tWmzj1IV69eRdOmTdXKAwMDkZSUpFcQpubs7Ay5XI7MzEyV8szMTLi7u2vcRqFQQKFQVEZ4REREZAC5XI7du3cjLCzMaE/10LkHycHBQePTcZOSkmBra2uUoIzNysoKbdq0QVxcnFSmVCoRFxeH9u3bV2FkREREBmAPEgBg586dePXVV436yDOdE6Q+ffpg8uTJKjPCk5KS8MEHH6B3795GC8zYpkyZgo0bN2Lr1q34448/MGHCBOTn50tXtREREZmbkjtpG7qQOp2H2JYtW4bw8HAEBgaiQYMGAIAbN26gc+fOWLFihdEDNJY333wTt2/fxpw5c5CRkYFWrVohNjZWbeI2ERERkc4JkoODA44fP47Dhw/j3LlzsLGxQVBQEF566SVTxGdUkyZNwqRJk6o6DCIiIuMwxhAZe5A00jlBAgCZTIbu3buje/fuxo6HiIiItMUEyWR0noNEREREVN0kJydj9uzZGDx4MG7dugUA+O6773Dp0iW92mOCREREZKY4SfuJhIQEtGjRAqdOncLevXuRl5cHADh37hzmzp2rV5tMkIiIiMxVyZ20DV3M3MyZM7Fo0SIcPnwYVlZWUvkrr7yCkydP6tUmEyQiIiJzxfsgAQAuXLiAfv36qZW7uroiKytLrzb1SpCMPc5HREREpK+6desiPT1drfz3339H/fr19WpT5wTJFON8REREpDvOQXpi0KBBmDFjBjIyMiCTyaBUKvHzzz9j6tSpGD58uF5t6vWwWmOP8xEREZEeOMQGAFi8eDECAwPh5eWFvLw8NG3aFC+99BI6dOiA2bNn69WmzvdBunDhAnbt2qVWbsg4HxEREZG+rKyssHHjRsyZMwcXLlxAXl4eWrdujcaNG+vdps49SKYY5yMiIiI9GGN4TccepHnz5kEmk6ksgYGBJjk8bS1YsAAFBQXw8vLCq6++ioEDB6Jx48Z48OABFixYoFebOidIphjnIyIiIj1U0RBbs2bNkJ6eLi3Hjh0z+FAMMX/+fGlO9NMKCgowf/58vdrUeYht8eLFmDhxIry8vFBcXIymTZuiuLgYQ4YM0Xucj4jK5r98pVHbS5n2gVHbI6Jnj6WlJdzd3as6DIkQAjKZ+v2czp07h3r16unVps4JkinG+YiIiEgPRnwWW25urkqxQqGAQqHQuMnVq1fh6ekJa2trtG/fHlFRUWjYsKGBgejO0dFRGuZr0qSJSpJUXFyMvLw8jB8/Xq+2dU6QFixYgKlTp8LLywteXl5S+YMHD7B8+XLMmTNHr0CIiIhIN8a4TL9k+6f/pgPA3LlzMW/ePLX6wcHBiI6ORkBAANLT0zF//nx07twZFy9ehJ2dnWHB6GjVqlUQQuDtt9/G/Pnz4eDgIL1mZWUFHx8ftG/fXq+2ZUIInU6tXC5Heno6XF1dVcqzs7Ph6uqK4uJivQKp7nJzc+Hg4IB79+7B3t6+qsOhZ4ixh9iSpk0xantEpM7UfzNK2vebtRhya2uD2ip++BDJi2chLS1NJdbyepCelpOTA29vb6xcuRKjRo0yKBZ9JSQkoEOHDqhVq5bR2tS5B8kU43xERERUtezt7fVK5urWrYsmTZogKSnJBFFpJyQkRPr54cOHKCoqUnldn+PSOkEy5TgfERER6cGIc5D0lZeXh+TkZAwbNszAQPRXUFCA6dOnY/fu3cjOzlZ7XZ/RLa0TJFOO8xEREZHujDkHSVtTp07Fa6+9Bm9vb9y8eRNz586FXC7H4MGDDQvEANOmTcPRo0exfv16DBs2DGvXrsXff/+NTz/9FEuWLNGrTa0TpBEjRgAAGjVqZPRxPiIiIjIPN27cwODBg5GdnQ0XFxd06tQJJ0+ehIuLS5XF9M0332Dbtm3o0qULRo4cic6dO8Pf3x/e3t7YuXMnhg4dqnObOs9BMsU4HxEREempkp+lFhMTU7k71MKdO3fg6+sL4EkecufOHQBAp06dMGHCBL3a1PlO2gUFBZg0aRJcXV1ha2sLR0dHlYWIiIgqCR9WCwDw9fVFSkoKACAwMBC7d+8G8KRnqW7dunq1qXOCNG3aNPzwww9Yv349FAoFPv/8c8yfPx+enp7Ytm2bXkEQERER6WvkyJE4d+4cAGDmzJlYu3YtrK2t8f7772PatGl6tanzEJspxvmIiIhId1UxSbs6ev/996WfQ0NDceXKFZw5cwb+/v4ICgrSq02dEyRTjPMRERGRHqrBZf7Vkbe3N7y9vQ1qQ+cEqWScr2HDhtI4X7t27Qwa5yMiIiLS1YMHDxAXF4devXoBACIjI1FYWCi9LpfLsXDhQljrcbdxnROkknG+kJAQzJw5E6+99hrWrFmDR48eYeVK4z4SgYiIiMr2rA+xbd26Fd9++62UIK1ZswbNmjWDjY0NAODKlSvw9PRUGYLTls4JkinG+YiIiEgPz/gQ286dOzF9+nSVsl27dklTgXbs2IG1a9dWToJUmjHG+YiIiIh0lZSUhBYtWkjr1tbWsLD43wX67dq1w8SJE/VqW+sEyZTjfERERKSHZ7wHKScnRyUXuX37tsrrSqVS5XVdaJ0gmXKcj4iIiHT3rM9BatCgAS5evIiAgACNr58/fx4NGjTQq22tEyRTjvMR1TQ+61cYra1r06YarS0iqmGe8R6kV199FXPmzEHPnj3VRrAePHiA+fPno2fPnnq1rXWCZMpxPiIiIiJdzZo1C7t370ZAQAAmTZqEJk2aAAASExOxZs0aPH78GLNmzdKrba0TJFOO8xEREZEenvEeJDc3Nxw/fhwTJkzAzJkzIcSTg5HJZOjWrRvWrVsHNzc3vdrW+llsJeN8ZTFknK+EEAJz5syBh4cHbGxsEBoaiqtXr5a7TVRUFF544QXY2dnB1dUVffv2RWJiokqdLl26QCaTqSzjx483KFYiIqKqVjIHydDFnDVq1AixsbG4ffs2Tp48iZMnT+L27duIjY2VpgHpQ+sEqWSc7+HDh2qvGTrOV2LZsmVYvXo1NmzYgFOnTsHW1hZhYWEa91kiISEBEydOxMmTJ3H48GE8evQI3bt3R35+vkq9MWPGID09XVqWLVtmUKxERERUfdSrVw/t2rVDu3btUK9ePYPb03qIzZTjfMCT3qNVq1Zh9uzZ6NOnDwBg27ZtcHNzw/79+zFo0CCN28XGxqqsR0dHw9XVFWfOnMFLL70kldeuXRvu7u56x0dERFTtPONDbKakdQ9SyTjfc889h5kzZ6Jfv37o168fIiMj0bRpUxw7dkzvcT4ASElJQUZGBkJDQ6UyBwcHBAcH48SJE1q3c+/ePQBQyx537twJZ2dnNG/eHJGRkSgoKCi3ncLCQuTm5qosRERE1QmH2ExHpztpl4zz3blzB0lJSQAAf39/o3RlZWRkAIBakuXm5ia9VhGlUonJkyejY8eOaN68uVQ+ZMgQeHt7w9PTE+fPn8eMGTOQmJiIvXv3ltlWVFQU5s+fr8eREBERkbnT61EjJeN8hti5cyfGjRsnrX/77bcGtQcAEydOxMWLF3Hs2DGV8rFjx0o/t2jRAh4eHujatSuSk5Ph5+ensa3IyEhMmTJFWs/NzYWXl5fBMRIRERkNh9hMxuBnsemrd+/eCA4OltZLbhGQmZkJDw8PqTwzMxOtWrWqsL1JkybhP//5D3788ccKr6Yr2W9SUlKZCZJCoYBCoahwv0RERFWGCZLJVFmCZGdnBzs7O2ldCAF3d3fExcVJCVFubi5OnTqFCRMmlNmOEAL/+Mc/sG/fPsTHx6NRo0YV7vvs2bMAoJKIEREREZWosgSpNJlMhsmTJ2PRokVo3LgxGjVqhA8//BCenp7o27evVK9r167o168fJk2aBODJsNquXbvw9ddfw87OTpqv5ODgABsbGyQnJ2PXrl149dVX4eTkhPPnz+P999/HSy+9hKCgoKo4VCIiIqOQ/XcxtA1SV20SJACYPn068vPzMXbsWOTk5KBTp06IjY1Veb5KcnIysrKypPX169cDeHIzyKdt2bIFERERsLKywpEjR7Bq1Srk5+fDy8sLb7zxBmbPnl0px0RERGQyHGIzmWqVIMlkMixYsAALFiwos861a9dU1ktuK14WLy8vJCQkGCM8IiKiasUYl+nzMn/NtL4PEhEREdGzolr1IBEREZEOOMRmMkyQiIiIzBkTHJPgEBsRERFRKexBIgLQeM8io7Z3bQKvkiQi0+MkbdNhgkRERGSuOAfJZDjERkRERFQKe5CIiIjMFIfYTIcJEhERkbniEJvJcIiNiIiIqBT2IBEREZkpDrGZDhMkIiIic8UhNpNhgkRERGSumCCZDOcgEREREZXCBImIiMhMlcxBMnTR15IlSyCTyTB58uQy63Tp0gUymUxt6dmzp1QnIiJC7fXw8HD9AzMCDrERERGZqyocYvvll1/w6aefIigoqNx6e/fuRVFRkbSenZ2Nli1bYsCAASr1wsPDsWXLFmldoVDoF5iRMEEiIiIineTl5WHo0KHYuHEjFi0q/1mW9erVU1mPiYlB7dq11RIkhUIBd3d3o8eqLw6xERERmSmZEEZZACA3N1dlKSwsLHO/EydORM+ePREaGqpzzJs2bcKgQYNga2urUh4fHw9XV1cEBARgwoQJyM7O1rltY2KCREREZK6EkRYAXl5ecHBwkJaoqCiNu4yJicFvv/1W5uvlOX36NC5evIjRo0erlIeHh2Pbtm2Ii4vD0qVLkZCQgB49eqC4uFjnfRgLh9iIiIgIaWlpsLe3l9Y1zQFKS0vDe++9h8OHD8Pa2lrnfWzatAktWrRAu3btVMoHDRok/dyiRQsEBQXBz88P8fHx6Nq1q877MQb2IBEREZkpY17FZm9vr7JoSpDOnDmDW7du4fnnn4elpSUsLS2RkJCA1atXw9LSstwen/z8fMTExGDUqFEVHpevry+cnZ2RlJSk97kxFHuQiIiIzFUlX8XWtWtXXLhwQaVs5MiRCAwMxIwZMyCXy8vcds+ePSgsLMRbb71V4X5u3LiB7OxseHh4aB+ckTFBIiIiIq3Y2dmhefPmKmW2trZwcnKSyocPH4769eurzVHatGkT+vbtCycnJ5XyvLw8zJ8/H2+88Qbc3d2RnJyM6dOnw9/fH2FhYaY9oHIwQSKzFPTNHKO2d3XAAqO2R0RUGarjw2pTU1NhYaE6gycxMRHHjh3D999/r1ZfLpfj/Pnz2Lp1K3JycuDp6Ynu3btj4cKFVXovJCZIRERE5qoaPIstPj6+3HUACAgIgBCad2RjY4NDhw4ZFoQJMEEiIiIyU9WxB6mm4FVsRERERKWwB4mIiMhcVYMhtpqKCRIREZEZ4xCZaXCIjYiIiKgU9iARERGZKyGeLIa2QWqYIBEREZkpXsVmOmY3xCaEwJw5c+Dh4QEbGxuEhobi6tWr5W4zb948yGQylSUwMLCSIiYiIiJzY3YJ0rJly7B69Wps2LABp06dgq2tLcLCwvDw4cNyt2vWrBnS09Ol5dixY5UUMRERkYkIIy2kxqyG2IQQWLVqFWbPno0+ffoAALZt2wY3Nzfs378fgwYNKnNbS0tLuLu7V1aoREREJidTPlkMbYPUmVUPUkpKCjIyMhAaGiqVOTg4IDg4GCdOnCh326tXr8LT0xO+vr4YOnQoUlNTTR0uERERmSmz6kHKyMgAALi5uamUu7m5Sa9pEhwcjOjoaAQEBCA9PR3z589H586dcfHiRdjZ2WncprCwEIWFhdJ6bm6uEY6AiIjIiHijSJOp1j1IO3fuRJ06daTl0aNHerXTo0cPDBgwAEFBQQgLC8PBgweRk5OD3bt3l7lNVFQUHBwcpMXLy0vfwyAiIjKJkqvYDF1IXbVOkHr37o2zZ89Ki7OzMwAgMzNTpV5mZqZO84vq1q2LJk2aICkpqcw6kZGRuHfvnrSkpaXpdxBERESmUnIfJEMXUlOth9js7OxUhsCEEHB3d0dcXBxatWoF4MnQ16lTpzBhwgSt283Ly0NycjKGDRtWZh2FQgGFQqF37ERERGS+qnUPUmkymQyTJ0/GokWLcODAAVy4cAHDhw+Hp6cn+vbtK9Xr2rUr1qxZI61PnToVCQkJuHbtGo4fP45+/fpBLpdj8ODBVXAURERExsEhNtOp1j1ImkyfPh35+fkYO3YscnJy0KlTJ8TGxsLa2lqqk5ycjKysLGn9xo0bGDx4MLKzs+Hi4oJOnTrh5MmTcHFxqYpDeCa989tbRm3v/Gs7jNoeEZFZ4iRtkzG7BEkmk2HBggVYsGBBmXWuXbumsh4TE2PiqIiIiKgmMbsEiYiIiJ7gs9hMhwkSERGRuTLGVWi8ik0js5qkTURERFQZ2INERERkpjjEZjpMkIiIiMwVr2IzGQ6xEREREZXCHiQiIiIzxSE202GCREREZK6U4sliaBukhgkSERGRueIcJJPhHCQiIiKiUtiDREREZKZkMMIcJKNEUvMwQSIiIjJXvJO2yXCIjYiIiKgU9iARERGZKV7mbzpMkIiIiMwVr2IzGQ6xEREREZXCHiQiIiIzJRMCMgMnWRu6fU3FBIk0+jLpBaO2t+75X4zaHhERAVD+dzG0DVLDITYiIiKiUtiDREREZKY4xGY67EEiIiIyV8JIi56WLFkCmUyGyZMnl1knOjoaMplMZbG2ttZ/p5WEPUhERETmqgrvpP3LL7/g008/RVBQUIV17e3tkZiYKK3LZNX/ASfsQSIiIiKd5OXlYejQodi4cSMcHR0rrC+TyeDu7i4tbm5ulRClYZggERERmamSO2kbuuhq4sSJ6NmzJ0JDQ7Wqn5eXB29vb3h5eaFPnz64dOmS7jutZBxiIyIiMldGHGLLzc1VKVYoFFAoFGrVY2Ji8Ntvv+GXX7S7fUtAQAA2b96MoKAg3Lt3DytWrECHDh1w6dIlNGjQwLDYTYg9SERERAQvLy84ODhIS1RUlFqdtLQ0vPfee9i5c6fWE63bt2+P4cOHo1WrVggJCcHevXvh4uKCTz/91NiHYFTsQSIiIjJTMuWTxdA2gCfJj729vVSuqffozJkzuHXrFp5//nmprLi4GD/++CPWrFmDwsJCyOXycvdXq1YttG7dGklJSYYFbmJMkIiIiMyVEYfY7O3tVRIkTbp27YoLFy6olI0cORKBgYGYMWNGhckR8CShunDhAl599VX9Y64ETJCIiIhIK3Z2dmjevLlKma2tLZycnKTy4cOHo379+tIQ3YIFC/Diiy/C398fOTk5WL58Oa5fv47Ro0dXevy6YIJERERkrgy80aPUhhGlpqbCwuJ/U5zv3r2LMWPGICMjA46OjmjTpg2OHz+Opk2bGnfHRsYEiYiIyExVh0eNxMfHl7v+8ccf4+OPPzZoH1WBV7ERERERlcIeJCIiInNVhY8aqemqVQ+SEAJz5syBh4cHbGxsEBoaiqtXr5a7jY+Pj9pD8GQyGSZOnCjV6dKli9rr48ePN/XhEBERmZYAoDRwYX6kUbVKkJYtW4bVq1djw4YNOHXqFGxtbREWFoaHDx+Wuc0vv/yC9PR0aTl8+DAAYMCAASr1xowZo1Jv2bJlJj0WIiIiUyuZg2ToQuqqzRCbEAKrVq3C7Nmz0adPHwDAtm3b4Obmhv3792PQoEEat3NxcVFZX7JkCfz8/BASEqJSXrt2bbi7u5sm+Grgh2sBRm3vTf/EiisRERHVUNWmByklJQUZGRkqD75zcHBAcHAwTpw4oVUbRUVF2LFjB95++23IZDKV13bu3AlnZ2c0b94ckZGRKCgoMGr8RERElU7gf/OQ9F6q+iCqp2rTg5SRkQEAcHNzUyl3c3OTXqvI/v37kZOTg4iICJXyIUOGwNvbG56enjh//jxmzJiBxMRE7N27t8y2CgsLUVhYKK2XfogfERFRleMkbZOpsgRp586dGDdunLT+7bffGtzmpk2b0KNHD3h6eqqUjx07Vvq5RYsW8PDwQNeuXZGcnAw/Pz+NbUVFRWH+/PkGx0RERETmp8qG2Hr37o2zZ89Ki7OzMwAgMzNTpV5mZqZWc4euX7+OI0eOaHXr8uDgYAAo90F5kZGRuHfvnrSkpaVV2C4REVGlMvQKtpKF1FRZD5KdnR3s7OykdSEE3N3dERcXh1atWgF4Mqx16tQpTJgwocL2tmzZAldXV/Ts2bPCumfPngUAeHh4lFlHoVBofJIxERFRdVEd7qRdU1WbSdoymQyTJ0/GokWLcODAAVy4cAHDhw+Hp6cn+vbtK9Xr2rUr1qxZo7KtUqnEli1bMGLECFhaquZ8ycnJWLhwIc6cOYNr167hwIEDGD58OF566SUEBQVVxqERERGRmak2k7QBYPr06cjPz8fYsWORk5ODTp06ITY2FtbW1lKd5ORkZGVlqWx35MgRpKam4u2331Zr08rKCkeOHMGqVauQn58PLy8vvPHGG5g9e7bJj4eIiMikOEnbZGRC8MxoIzc3Fw4ODrh37x7s7e2rOhw1xr4P0is+vA8SEZG+TP03o6T9rk2nwlJu2HSQx8WFiLu8otr+fasq1WaIjYiIiKi6qFZDbERERKQDDrGZDBMkIiIic6UEIKuwVsVtkBomSERERGaKl/mbDucgEREREZXCHiQiIiJzxTlIJsMEiYiIyFwpBSAzMMFRMkHShENsRERERKWwB4mIiMhccYjNZJggERERmS0jJEhggqQJE6QqpMxoYrS2XvH502htERERPeuYIBEREZkrDrGZDBMkIiIic6UUMHiIjFexacSr2IiIiIhKYQ8SERGRuRLKJ4uhbZAaJkhERETminOQTIYJEhERkbniHCST4RwkIiIiolLYg0RERGSuOMRmMkyQiIiIzJWAERIko0RS43CIjYiIiKgU9iARERGZKw6xmQwTJCIiInOlVAIw8D5GSt4HSRMOsRERERGVwh4kIiIic8UhNpNhgkRERGSumCCZDIfYiIiISC9LliyBTCbD5MmTy6yzceNGdO7cGY6OjnB0dERoaChOnz6tUiciIgIymUxlCQ8PN3H05WOCREREZK6UwjiLHn755Rd8+umnCAoKKrdefHw8Bg8ejKNHj+LEiRPw8vJC9+7d8ffff6vUCw8PR3p6urR88cUXesVlLBxi01Hy301QJ9c4eWXjBjeN0g4RET2bhFBCCMOuQtNn+7y8PAwdOhQbN27EokWLyq27c+dOlfXPP/8c//73vxEXF4fhw4dL5QqFAu7u7jrHYirsQSIiIjJXwgi9R/+dg5Sbm6uyFBYWlrnbiRMnomfPnggNDdU55IKCAjx69Aj16tVTKY+Pj4erqysCAgIwYcIEZGdn69y2MTFBIiIiInh5ecHBwUFaoqKiNNaLiYnBb7/9VubrFZkxYwY8PT1Vkqvw8HBs27YNcXFxWLp0KRISEtCjRw8UFxfrtQ9j4BAbERGRuRICBj9M7b89SGlpabC3t5eKFQqFWtW0tDS89957OHz4MKytrXXe1ZIlSxATE4P4+HiV7QcNGiT93KJFCwQFBcHPzw/x8fHo2rWrzvsxBvYgERERmSul0jgLAHt7e5VFU4J05swZ3Lp1C88//zwsLS1haWmJhIQErF69GpaWluX2+KxYsQJLlizB999/X+HEbl9fXzg7OyMpKcmw82OAZyJB2rt3L7p37w4nJyfIZDKcPXu2qkMiIiIyO127dsWFCxdw9uxZaWnbti2GDh2Ks2fPQi6Xa9xu2bJlWLhwIWJjY9G2bdsK93Pjxg1kZ2fDw8PD2IegtWdiiC0/Px+dOnXCwIEDMWbMmKoOh4iIyDiMOMSmDTs7OzRv3lylzNbWFk5OTlL58OHDUb9+fWmO0tKlSzFnzhzs2rULPj4+yMjIAADUqVMHderUQV5eHubPn4833ngD7u7uSE5OxvTp0+Hv74+wsDDDjs0Az0SCNGzYMADAtWvXqjYQIiIiIxJKJYSs8i/zL09qaiosLP43QLV+/XoUFRWhf//+KvXmzp2LefPmQS6X4/z589i6dStycnLg6emJ7t27Y+HChRqH+SrLM5Eg6aOwsFDlEsfc3NwqjIaIiKh6io+PL3e9os4JGxsbHDp0yLhBGcEzMQdJH1FRUSqXO3p5eVV1SERERKpKnsVm6EJqalyCtHPnTmlcs06dOvjpp5/0aicyMhL37t2TlrS0NCNHSkREZKAqfNRITVfjhth69+6N4OBgab1+/fp6taNQKKp07JOIiIiqTo1LkOzs7GBnZ1fVYRAREZmeEAAMnGTNITaNalyCpMmdO3eQmpqKmzefPBw2MTERAODu7l6tHoxHRESkC6EUEDLDEhzBBEmjGjcHSZMDBw6gdevW6NmzJ4AntzRv3bo1NmzYUMWRERERGUAojbOQmmeiBykiIgIRERFVHQYRERGZiWciQSIiIqqJOMRmOkyQiIiIzJVQwvBJ2hxi04QJkpZKMuy8PON9kHh3biKimqnk+93UvTOP8cjgR7E9xiPjBFPDMEHS0v379wEAL7W7bcRWHYzYFhERVTf379+Hg4Pxv+utrKzg7u6OYxkHjdKeu7s7rKysjNJWTSETHHzUilKpxM2bN2FnZweZTFZmvdzcXHh5eSEtLQ329vaVGKHhGHvVYOxVg7FXHXOOX9vYhRC4f/8+PD09VR7cakwPHz5EUVGRUdqysrKCtbW1UdqqKdiDpCULCws0aNBA6/r29vZm94tfgrFXDcZeNRh71THn+LWJ3RQ9R0+ztrZmUmNCz8R9kIiIiIh0wQSJiIiIqBQmSEamUCgwd+5cs3zQLWOvGoy9ajD2qmPO8Ztz7KQbTtImIiIiKoU9SERERESlMEEiIiIiKoUJEhEREVEpTJCIiIiISmGCZER79+5F9+7d4eTkBJlMhrNnz1Z1SBBCYM6cOfDw8ICNjQ1CQ0Nx9erVcrfx8fGBTCZTWyZOnCjV6dKli9rr48ePr3bHMm/ePLU4AwMDTRqnvrFGRUXhhRdegJ2dHVxdXdG3b18kJiaq1KmK816etWvXwsfHB9bW1ggODsbp06erLBZd49m4cSM6d+4MR0dHODo6IjQ0VK1+RESE2vkODw839WEA0O1YoqOj1eKszBsI6hKrps+wTCZDz549pTpVed7L8uOPP+K1116Dp6cnZDIZ9u/fX6XxkOkxQTKi/Px8dOrUCUuXLq3qUCTLli3D6tWrsWHDBpw6dQq2trYICwvDw4cPy9zml19+QXp6urQcPnwYADBgwACVemPGjFGpt2zZsmp3LADQrFkzlTiPHTtm0jj1jTUhIQETJ07EyZMncfjwYTx69Ajdu3dHfn6+Sr3KPu9l+fLLLzFlyhTMnTsXv/32G1q2bImwsDDcunXLLOKJj4/H4MGDcfToUZw4cQJeXl7o3r07/v77b5V64eHhKuf7iy++qHbHAjy5s/PTcV6/ft3kceoT6969e1XivHjxIuRyudr3S1Wc9/Lk5+ejZcuWWLt2bZXGQZVIkNGlpKQIAOL333+v0jiUSqVwd3cXy5cvl8pycnKEQqEQX3zxhdbtvPfee8LPz08olUqpLCQkRLz33nvGDLdc+h7L3LlzRcuWLSshwv8x1nm/deuWACASEhKksso+7+Vp166dmDhxorReXFwsPD09RVRUlFnG8/jxY2FnZye2bt0qlY0YMUL06dPH2KFWSNdj2bJli3BwcKik6FQZet4//vhjYWdnJ/Ly8qSyqjrv2gIg9u3bV9VhkImxB6kGS0lJQUZGBkJDQ6UyBwcHBAcH48SJE1q1UVRUhB07duDtt99We0jvzp074ezsjObNmyMyMhIFBQVGjf9phhzL1atX4enpCV9fXwwdOhSpqakmi9PQWJ927949AEC9evVUyivzvJelqKgIZ86cUTlGCwsLhIaG6nSM1SmegoICPHr0SO18x8fHw9XVFQEBAZgwYQKys7ONGntp+h5LXl4evL294eXlhT59+uDSpUsmjdOQWJ+2adMmDBo0CLa2tirllX3eiUrjw2prsIyMDACAm5ubSrmbm5v0WkX279+PnJwcREREqJQPGTIE3t7e8PT0xPnz5zFjxgwkJiZi7969Rom9NH2PJTg4GNHR0QgICEB6ejrmz5+Pzp074+LFi7Czs6tWsT5NqVRi8uTJ6NixI5o3by6VV/Z5L0tWVhaKi4s1HuOVK1cqNRZjxTNjxgx4enqq/LEPDw/H66+/jkaNGiE5ORmzZs1Cjx49cOLECcjlcqMeQwl9jiUgIACbN29GUFAQ7t27hxUrVqBDhw64dOmSTg/ZroxYn3b69GlcvHgRmzZtUimvivNOVBoTJD3t3LkT48aNk9a/++47dO7cuQojUo/p22+/NbjNTZs2oUePHvD09FQpHzt2rPRzixYt4OHhga5duyI5ORl+fn4G79dYx9KjRw/p56CgIAQHB8Pb2xu7d+/GqFGjDI4TMM15nzhxIi5evKg2X8rU5/1ZtWTJEsTExCA+Pl5lcvOgQYOkn1u0aIGgoCD4+fkhPj4eXbt2rYpQNWrfvj3at28vrXfo0AHPPfccPv30UyxcuLAKIyvfpk2b0KJFC7Rr106l3FzOO9VsTJD01Lt3bwQHB0vr9evXr8JonigdU2FhIQAgMzMTHh4eUnlmZiZatWpVYXvXr1/HkSNHtOqdKNlvUlKSUf5QG/tYStStWxdNmjRBUlKSwTGaKtZJkybhP//5D3788ccK//s39nnXlrOzM+RyOTIzM1XKMzMz4e7uXmlxGCOeFStWYMmSJThy5AiCgoLKrevr6wtnZ2ckJSWZ7A+1Mc5trVq10Lp1a6N+zjUxJNb8/HzExMRgwYIFFe6nMs47UWmcg6QnOzs7+Pv7S4uNjU1Vh6QWU9OmTeHu7o64uDipTm5uLk6dOqXy32ZZtmzZAldXV5XLb8tSckuDpxMCQxj7WErk5eUhOTnZaHEaM1YhBCZNmoR9+/bhhx9+QKNGjSrct7HPu7asrKzQpk0blWNUKpWIi4vT6f2o6niWLVuGhQsXIjY2Fm3btq1wPzdu3EB2drZJz7cxzm1xcTEuXLhg8s+FIbHu2bMHhYWFeOuttyrcT2WcdyI1VT1LvCbJzs4Wv//+u/j2228FABETEyN+//13kZ6eXmUxLVmyRNStW1d8/fXX4vz586JPnz6iUaNG4sGDB1KdV155RXzyyScq2xUXF4uGDRuKGTNmqLWZlJQkFixYIH799VeRkpIivv76a+Hr6yteeumlancsH3zwgYiPjxcpKSni559/FqGhocLZ2VncunWr2sU6YcIE4eDgIOLj40V6erq0FBQUCCGq7ryXJSYmRigUChEdHS0uX74sxo4dK+rWrSsyMjKqZTzDhg0TM2fOlOovWbJEWFlZia+++krlfN+/f18IIcT9+/fF1KlTxYkTJ0RKSoo4cuSIeP7550Xjxo3Fw4cPq9WxzJ8/Xxw6dEgkJyeLM2fOiEGDBglra2tx6dIlk8apT6wlOnXqJN5880218qo87+W5f/+++P3338Xvv/8uAIiVK1eK33//XVy/fr3KYiLTYoJkRFu2bBEA1Ja5c+dWWUxKpVJ8+OGHws3NTSgUCtG1a1eRmJioUsfb21stxkOHDgkAanWFECI1NVW89NJLol69ekKhUAh/f38xbdo0ce/ePVMeil7H8uabbwoPDw9hZWUl6tevL958802RlJRk0jj1jVXTZweA2LJlixCi6s57eT755BPRsGFDYWVlJdq1aydOnjxZZbFUFE9ISIgYMWKEtO7t7V3u72tBQYHo3r27cHFxEbVq1RLe3t5izJgxlZYA6nIskydPluq6ubmJV199Vfz222+VEqeusQohxJUrVwQA8f3336u1VdXnvSxHjx7V+HkpfWxUc8iEEKLSuquIiIiIzADnIBERERGVwgSJiIiIqBQmSERERESlMEEiIiIiKoUJEhEREVEpTJCIiIiISmGCRERERFQKEyQiIiKiUpggEZFRREdHo27duiZrf9iwYVi8eLFO28TGxqJVq1ZQKpUmioqIaiomSETVVEZGBt577z34+/vD2toabm5u6NixI9avX4+CggKt2zF14qKLS5cu4Y033oCPjw9kMhlWrVql1Xbnzp3DwYMH8e677wIAWrRogfHjx2usu337digUCmRlZSE8PBy1atXCzp07jXUIRPSMYIJEVA399ddfaN26Nb7//nssXrwYv//+O06cOIHp06fjP//5D44cOVLVIeqloKAAvr6+WLJkCdzd3bXe7pNPPsGAAQNQp04dAMCoUaMQExODBw8eqNXdsmULevfuDWdnZwBAREQEVq9ebZwDIKJnR1U/DI6I1IWFhYkGDRqIvLw8ja8rlUrp548++kg0b95c1K5dWzRo0EBMmDBBeiK9pgdsljyM9eHDh+KDDz4Qnp6eonbt2qJdu3bi6NGj5cZ19+5dMXbsWOHq6ioUCoVo1qyZ+Oabb4QQTx7W7ODgIGJjY0VgYKCwtbUVYWFh4ubNmxrb8vb2Fh9//HGF5+Lx48fCwcFB/Oc//5HKbt++LaysrMT27dtV6v71119CJpOJ7777Tiq7fv26AFApDykmopqDPUhE1Ux2dja+//57TJw4Eba2thrryGQy6WcLCwusXr0aly5dwtatW/HDDz9g+vTpAIAOHTpg1apVsLe3R3p6OtLT0zF16lQAwKRJk3DixAnExMTg/PnzGDBgAMLDw3H16lWN+1QqlejRowd+/vln7NixA5cvX8aSJUsgl8ulOgUFBVixYgW2b9+OH3/8EampqdL+9HX+/Hncu3cPbdu2lcqcnZ3Rp08fbN68WaVudHQ0GjRogO7du0tlDRs2hJubG3766SeD4iCiZ0xVZ2hEpOrkyZMCgNi7d69KuZOTk7C1tRW2trZi+vTpZW6/Z88e4eTkJK2X9Ow87fr160Iul4u///5bpbxr164iMjJSY7uHDh0SFhYWIjExUePrW7ZsUeupWbt2rXBzc9NYX9sepH379gm5XK7SayaEELGxsUImk4m//vpLCPGkV83b21vMnj1brY3WrVuLefPmVbgvIqISllWdoBGRdk6fPg2lUomhQ4eisLBQKj9y5AiioqJw5coV5Obm4vHjx3j48CEKCgpQu3ZtjW1duHABxcXFaNKkiUp5YWEhnJycNG5z9uxZNGjQQG2bp9WuXRt+fn7SuoeHB27duqXLYap58OABFAqFSq8ZAHTr1g0NGjTAli1bsGDBAsTFxSE1NRUjR45Ua8PGxkanie1EREyQiKoZf39/yGQyJCYmqpT7+voCePLHvsS1a9fQq1cvTJgwAf/85z9Rr149HDt2DKNGjUJRUVGZCVJeXh7kcjnOnDmjMkQGQJoIXdrT+y1LrVq1VNZlMhmEEBVuVx5nZ2cUFBSgqKgIVlZWUrmFhQUiIiKwdetWzJs3D1u2bMHLL78snaen3blzBy4uLgbFQUTPFs5BIqpmnJyc0K1bN6xZswb5+fnl1j1z5gyUSiU++ugjvPjii2jSpAlu3rypUsfKygrFxcUqZa1bt0ZxcTFu3boFf39/laWsq8uCgoJw48YN/Pnnn4YdoI5atWoFALh8+bLaayNHjkRaWhr27t2Lffv2YdSoUWp1Hj58iOTkZLRu3drUoRJRDcIEiagaWrduHR4/foy2bdviyy+/xB9//IHExETs2LEDV65ckXp9/P398ejRI3zyySf466+/sH37dmzYsEGlLR8fH+Tl5SEuLg5ZWVkoKChAkyZNMHToUAwfPhx79+5FSkoKTp8+jaioKHz77bcaYwoJCcFLL72EN954A4cPH0ZKSgq+++47xMbGan1cRUVFOHv2LM6ePYuioiL8/fffOHv2LJKSksrcxsXFBc8//zyOHTum9lqjRo3wyiuvYOzYsVAoFHj99dfV6pw8eRIKhQLt27fXOk4iIk7SJqqmbt68KSZNmiQaNWokatWqJerUqSPatWsnli9fLvLz86V6K1euFB4eHsLGxkaEhYWJbdu2CQDi7t27Up3x48cLJycnlcv8i4qKxJw5c4SPj4+oVauW8PDwEP369RPnz58vM6bs7GwxcuRI4eTkJKytrUXz5s2ly+81TQbft2+fePprJiUlRe22AwBESEhIuedi3bp14sUXX9T42q5duwQA8c4772h8fezYsWLcuHHltk9EVJpMCAMnCBARmdiDBw8QEBCAL7/8UqeeoKysLAQEBODXX39Fo0aNTBghEdU0HGIjomrPxsYG27ZtQ1ZWlk7bXbt2DevWrWNyREQ6Yw8SERERUSnsQSIiIiIqhQkSERERUSlMkIiIiIhKYYJEREREVAoTJCIiIqJSmCARERERlcIEiYiIiKgUJkhEREREpTBBIiIiIirl/wFrp0+O8FvC8wAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1436,7 +1522,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqbElEQVR4nO3deVxU1f8/8NeAMCwCLsimCIi5gAumSa64kLjk0mJuqeBu8jMjMykTURO3jFwpc19yKTVLw4XEUlELNfcFBEUTFE0QUNCZ8/vD79yP4wAyC8s4r2eP+8g5c+6573tne3POuffKhBACRERERCbErLwDICIiIiprTICIiIjI5DABIiIiIpPDBIiIiIhMDhMgIiIiMjlMgIiIiMjkMAEiIiIik8MEiIiIiEwOEyAiIiIyOUyAqEKTyWSYNm1aeYdRJjp06IAOHTqUawzBwcHw9PQs1xiIVHJycuDk5IQNGzaUdyhGQ9fvzPPnz6NSpUo4e/as4YOqoMosAVq9ejVkMpm0VKpUCTVr1kRwcDBu3rxZVmEU6/79+zAzM8OePXsAANu3b4dcLkd+fr5avb/++guhoaHw9fWFra0tateujffeew+XL19Wq6dUKrF69Wr06tUL7u7usLW1RaNGjTBz5kw8evRIY/vLli1D3759Ubt2bchkMgQHB+u9T56enmrH/dmla9euerdPwJEjRzBt2jTcv3+/3GJQvaZfffWVxnOqz97ff/9t0G0+fvwYjo6OaNu2bZF1hBBwd3fHq6++KpWlpqYiJCQE3t7esLKygouLC9q3b4+IiAittv/sd8qhQ4eK3LZMJsObb76pVdtkeBs3bkR0dLRW63zzzTews7ND//79Sycokvj4+KBHjx6YOnVqeYdSZiqV9QanT58OLy8vPHr0CEePHsXq1atx6NAhnD17FlZWVmUdjprjx48DAPz9/QEACQkJaNasGeRyuVq9OXPm4PDhw+jbty+aNGmC9PR0LF68GK+++iqOHj2KRo0aAQDy8vIQEhKC119/HWPGjIGTkxMSEhIQERGBuLg4/P7775DJZGrtPnjwAC1btsStW7cMtl9+fn74+OOPNcrd3NwMto3S8vDhQ1SqVOZvU60cOXIEkZGRCA4ORpUqVco1lnnz5mHs2LGwsbEp9W1ZWFigb9+++Pbbb3Ht2jV4eHho1Pnjjz9w48YNfPTRRwCApKQkvPbaa7C2tsawYcPg6emJW7du4cSJE5gzZw4iIyO1jsPKygobN27USMQOHjyIGzduaHx+qXxs3LgRZ8+exYQJE0pU//Hjx/jmm2/w0UcfwdzcvHSDIwDAmDFj0L17dyQnJ8Pb27u8wyl1Zf7L0q1bN7Ro0QIAMGLECDg6OmLOnDnYuXMn3nvvvbIOR83x48dRv3596UcsISFBSoaeFRYWho0bN8LS0lIq69evHxo3bozZs2dj/fr1AABLS0scPnwYrVu3luqNHDkSnp6eUhIUGBgoPXfw4EGp96dy5coG26+aNWvi/fffN1h7pU2pVKKgoABWVlblnhQbEz8/P5w6dQoxMTEICwsrk20OGjQIMTEx+OGHHzB58mSN5zdu3AgzMzPpL/ivv/4aOTk5OHXqlEbCdPv2bZ1i6N69O7Zu3YqFCxeqJcsbN25E8+bNkZmZqVO7FUlubi5sbW3LO4wy9euvv+LOnTvl/rtgSgIDA1G1alWsWbMG06dPL+9wSl25zwFq164dACA5OVkqK2ouxPPzE1JTUyGTyTB//nx899138Pb2hlwux2uvvYa//vqrRNvPyspCZmYmMjMzkZCQgKZNmyIzMxMZGRlITExEgwYNkJmZiaysLGmd1q1bqyU/APDKK6/A19cXFy5ckMosLS3Vkh+Vt956CwDU6gKAh4eHWo9QWbl9+zZq1KiBDh06QAghlSclJcHW1hb9+vWTyjp06IBGjRohMTERrVu3hrW1Nby8vBATE6PRbn5+PiIiIlC3bl3I5XK4u7tj0qRJGkOKMpkMoaGh2LBhA3x9fSGXyxEbGys99+x49rRp0yCTyXD58mW8//77cHBwQI0aNfDFF19ACIG0tDT07t0b9vb2cHFxKXRISNu4duzYgUaNGkEul8PX11eKTRXPJ598AgDw8vKShmRSU1OLPeaq96u1tTVatmyJP//8s9B6t2/fxvDhw+Hs7AwrKys0bdoUa9asKbRumzZt0KlTJ8ydOxcPHz4sdvsApP2ysrJCo0aNsH379heuU9g2PT09sXHjRo3nHj9+jB9//BEdO3aUehuTk5NRq1atQnuLnJyctN4+AAwYMAB3797Fvn37pLKCggL8+OOPGDhwYKHrKJVKREdHw9fXF1ZWVnB2dsbo0aPx33//qdX7+eef0aNHD7i5uUEul8Pb2xszZsyAQqFQq3flyhW88847cHFxgZWVFWrVqoX+/ftL3xuq76rVq1drxFLUe/z8+fMYOHAgqlatqta7tX79ejRv3hzW1taoVq0a+vfvj7S0NLU2VZ/T06dPIyAgADY2Nqhbty5+/PFHAE//2PL394e1tTXq16+P/fv3a8R18+ZNDBs2DM7OztJ7f+XKlWp14uPjIZPJsGXLFnz55ZeoVasWrKys0LlzZyQlJanFs2vXLly7dk36jLxortmOHTvg6emp0RMRHByMypUr4+bNm+jTpw8qV66MGjVqYOLEiRqvS25uLj7++GO4u7tDLpejfv36mD9/vtr3XFFe9JoCwKpVq9CpUyc4OTlBLpfDx8cHy5Yt02jL09MTb775JuLj49GiRQtYW1ujcePGiI+PBwBs27YNjRs3hpWVFZo3b46TJ08Wus9Xr15FUFAQbG1t4ebmhunTp5doX0ryWgJPe3U7dOiAn3/++YVtvhREGVm1apUAIP766y+18sWLFwsAYtmyZVJZQECACAgI0Ghj6NChwsPDQ3qckpIiAIhmzZqJunXrijlz5oi5c+cKR0dHUatWLVFQUPDCuAICAgSAFy6FxfMspVIpatasKbp06fLCbe7du1cAEBs3biyyjq2trRg6dOgL23oRDw8P0aVLF3Hnzh2NJS8vT6q3detWAUB88803QgghFAqFaNOmjXB2dhaZmZlSvYCAAOHm5iacnJxEaGioWLhwoWjbtq0AIFasWCHVUygUokuXLsLGxkZMmDBBfPvttyI0NFRUqlRJ9O7dWy1GAKJhw4aiRo0aIjIyUixZskScPHlSei4iIkKqGxERIQAIPz8/MWDAALF06VLRo0cPAUAsWLBA1K9fX4wdO1YsXbpUtGnTRgAQBw8e1Dmupk2bCldXVzFjxgwRHR0t6tSpI2xsbKRj8s8//4gBAwYIAOLrr78W69atE+vWrRM5OTlFvibff/+9ACBat24tFi5cKCZMmCCqVKki6tSpo/Y+y8vLEw0bNhQWFhbio48+EgsXLhTt2rUTAER0dLRGrOPGjRN//PGHACC++uor6bnCPnt79uwRZmZmolGjRmLBggXi888/Fw4ODsLX11ftM1YSn332mQAgzp49q1a+c+dOAUCsXLlSKhs1apQwNzcXcXFxWm2jMM/uV+vWrcXgwYOl53bs2CHMzMzEzZs3hYeHh+jRo4fauiNGjBCVKlUSI0eOFDExMeLTTz8Vtra24rXXXlP73ujTp4947733xLx588SyZctE3759BQAxceJEqU5+fr7w8vISbm5uYubMmeL7778XkZGR4rXXXhOpqalCiP99V61atUpjP4p6j/v4+IjevXuLpUuXiiVLlgghhJg5c6aQyWSiX79+YunSpSIyMlI4OjoKT09P8d9//0ltqD6n7u7u4pNPPhGLFi0SPj4+wtzcXGzatEm4uLiIadOmiejoaFGzZk3h4OAgsrOzpfXT09NFrVq1hLu7u5g+fbpYtmyZ6NWrl/Q+Vzlw4ID0Hdy8eXPx9ddfi2nTpgkbGxvRsmVLqd7evXuFn5+fcHR0lD4j27dvL/b1rVu3rnj77bc1yocOHSqsrKyEr6+vGDZsmFi2bJl45513BACxdOlSqZ5SqRSdOnUSMplMjBgxQixevFj07NlTABATJkwodtsleU2FEOK1114TwcHB4uuvvxaLFi0SXbp0EQDE4sWL1drz8PAQ9evXF66urmLatGni66+/FjVr1hSVK1cW69evF7Vr1xazZ88Ws2fPFg4ODqJu3bpCoVBo7PMrr7wiBg8eLBYvXizefPNNAUB88cUXatt6/v1U0tdSZebMmcLMzExkZWUVe4xeBmWeAO3fv1/cuXNHpKWliR9//FHUqFFDyOVykZaWJtXVNgGqXr26uHfvnlT+888/CwDil19+eWFcf//9t9i3b59YsmSJACDWr18v9u3bJ4KDg4W7u7vYt2+f2Ldvn/j777+LbWfdunUaSUBRAgMDhb29vdoX1vMMmQAVldRFRUWp1R0wYICwsbERly9fFvPmzRMAxI4dO9TqqBLGZ39g8/PzhZ+fn3BycpJ+PNatWyfMzMzEn3/+qbZ+TEyMACAOHz4slQEQZmZm4ty5cxrxF/XjMGrUKKnsyZMnolatWkImk4nZs2dL5f/995+wtrZWO47axmVpaSmSkpKksn/++UcAEIsWLZLKVMcqJSVFI/7nFRQUCCcnJ+Hn5yfy8/Ol8u+++04j0Y6Ojpbek8+u36pVK1G5cmW1HyxVAiSEEB07dhQuLi5SgltYAuTn5ydcXV3F/fv3pTJVYq5tAnTu3DkBQISHh6uV9+/fX1hZWal9kZ49e1ZYW1tLSeyHH34oduzYIXJzc7Xa5vP7tXjxYmFnZyftc9++fUXHjh2FEEIjAfrzzz8FALFhwwa19mJjYzXKn/0jQWX06NHCxsZGPHr0SAghxMmTJwUAsXXr1iJj1SUBGjBggFq91NRUYW5uLr788ku18jNnzohKlSqplas+p8/+kXXx4kXps3b06FGpfM+ePRqxDR8+XLi6uqr98SPE09fUwcFBOi6qBKhhw4Zq7+dvvvlGABBnzpyRynr06FHi99bjx4+FTCYTH3/8scZzQ4cOFQDE9OnT1cpVSZjKjh07BAAxc+ZMtXrvvvuukMlkap/r55XkNRWi8PdHUFCQqFOnjlqZ6nv4yJEjUpnquFtbW4tr165J5d9++60AIA4cOKCxz//v//0/qUypVIoePXoIS0tLcefOHan8+fdTSV9LlY0bNwoA4tixY8Xu+8ugzIfAAgMDUaNGDbi7u+Pdd9+Fra0tdu7ciVq1auncZr9+/VC1alXpsWpY7erVqy9ct3nz5ggMDMSTJ0/g5uaGQYMGITAwEHfu3EHnzp0RGBiIwMBANG/evMg2Ll68iHHjxqFVq1YYOnRosdubNWsW9u/fj9mzZ5fZhFl/f3/s27dPYxkwYIBavcWLF8PBwQHvvvsuvvjiCwwePBi9e/fWaK9SpUoYPXq09NjS0hKjR4/G7du3kZiYCADYunUrGjZsKA0hqpZOnToBAA4cOKDWZkBAAHx8fEq8TyNGjJD+bW5ujhYtWkAIgeHDh0vlVapUQf369dXeB9rGFRgYqNYF36RJE9jb25fovVWYv//+G7dv38aYMWPUhlGDg4Ph4OCgVnf37t1wcXFRe50sLCwwfvx45OTk4ODBg4VuY9q0aUhPTy90WBIAbt26hVOnTmHo0KFq23zjjTe0eg1UfHx80KxZM2zatEkqy83Nxc6dO/Hmm2/C3t5eKvf19cWpU6fw/vvvIzU1Fd988w369OkDZ2dnLF++XOttq7z33nt4+PAhfv31Vzx48AC//vprkcNfW7duhYODA9544w2190Dz5s1RuXJltfeAtbW19O8HDx4gMzMT7dq1Q15eHi5evAgA0jHcs2cP8vLydN6H540ZM0bt8bZt26BUKvHee++pxe3i4oJXXnlF471buXJltbOnVPMbGzZsqDa3UfVv1XtaCIGffvoJPXv2hBBCbVtBQUHIysrCiRMn1LYVEhKi9n7W5ju4MPfu3YMQQu17/XnPH5927dqpbW/37t0wNzfH+PHj1ep9/PHHEELgt99+K7Ltkr6mz74/VNMpAgICcPXqVbWhMuDp56RVq1bSY9Vx79SpE2rXrq1RXtixCw0Nlf6tGqIvKCgodAgT0O21VB3zl2Hu3IuU+SToJUuWoF69esjKysLKlSvxxx9/6H2WxrNvHuB/L+Dz4/nPy8nJkU5H37dvH15//XVkZmZCqVTizz//xMyZM5GZmQlzc/MiP4jp6eno0aMHHBwc8OOPPxZ7tsLmzZsxZcoUDB8+HGPHjtVmF/Xi6OioNtm6KNWqVcPChQvRt29fODs7Y+HChYXWc3Nz05iQWa9ePQBP5zq8/vrruHLlCi5cuIAaNWoU2sbzE169vLxKsiuS519zBwcHWFlZwdHRUaP87t270mNt43p+O8DT99eL3ltFuXbtGoCnc8aeZWFhgTp16mjUfeWVV2Bmpv53SsOGDdXael779u3RsWNHzJ07V+NHorgYgKc/ks9/IZbEoEGDMHHiRBw5cgStW7fGjh07kJeXh0GDBmnUrVevHtatWweFQoHz58/j119/xdy5czFq1Ch4eXmV6L36vBo1aiAwMBAbN25EXl4eFAoF3n333ULrXrlyBVlZWUXOOXr2PXDu3DlMmTIFv//+O7Kzs9XqqX7gvLy8EBYWhgULFmDDhg1o164devXqJc1R09Xzn4krV65ACFHo6wY8fQ89q1atWhpzCh0cHODu7q5RBvzv+/LOnTu4f/8+vvvuO3z33XeFbutFn5OSfge/iChifouVlZXGZ/j5z+W1a9fg5uYGOzs7tXov+vwAJX9NDx8+jIiICCQkJGgkSllZWWp1C/vOAvDC10PFzMxM4zvi2e/dwujyWqqOeXnMRy1rZZ4AtWzZUjoLrE+fPmjbti0GDhyIS5cuSWc+yWSyQt/4z09wUykq6Sjqw6MSGhqqMaF027Zt0r/Hjx+P8ePHw8PDo9A3WFZWFrp164b79+/jzz//LPa08n379mHIkCHo0aNHkX+ZVwSqayD9999/uHHjhs69VEqlEo0bN8aCBQsKff75D/2zf0mVRGGveUneB9rGpet7q7xFRESgQ4cO+Pbbb8ukp3HAgAGYNGkSNm7ciNatW2Pjxo2oWrUqunfvXuQ65ubmaNy4MRo3boxWrVqhY8eO2LBhg04JEAAMHDgQI0eORHp6Orp161bkfiuVymIvrqf6Yb1//z4CAgJgb2+P6dOnS9ctOnHiBD799FMolUppna+++grBwcH4+eefsXfvXowfPx5RUVE4evRooYmISlHfaYDmZ0KpVEImk+G3334r9H35/JmjRb13X/SeVu3X+++/X2SPdpMmTbRqU1vVqlWDTCYrMoEqi9PiX/SaJicno3PnzmjQoAEWLFgAd3d3WFpaYvfu3fj666/V3h/FxVya3zG6vJaqY/78H5Mvo3K9wIq5uTmioqLQsWNHLF68WDqNtmrVqoV2/xWXseti0qRJeP/995GSkoJRo0Zh7dq1cHV1xZYtW7B7927pjI3CfpwfPXqEnj174vLly9i/f3+xQwfHjh3DW2+9hRYtWmDLli0V9ro2sbGx+P777zFp0iRs2LABQ4cOxbFjxzTi/ffffzVOy1VdBFJ1Zoe3tzf++ecfdO7cuUL9JVEacWnTjurspytXrkjDbsDTM6ZSUlLQtGlTtbqnT5+GUqlU6wVSDb0UdiaVSkBAADp06IA5c+ZoXNjs2Ried+nSpRLvy7Pc3NzQsWNHbN26FV988QX27duH4OBgjbMli6L6o0if61+99dZbGD16NI4ePYrNmzcXWc/b2xv79+9HmzZtik284+PjcffuXWzbtg3t27eXylNSUgqtr0rmpkyZgiNHjqBNmzaIiYnBzJkzpR6R5y+Wqc13mre3N4QQ8PLykv7yLw01atSAnZ0dFAqFzsloYbT5nFSqVAne3t5FHuuS8PDwwP79+/HgwQO1XqCSfH5UintNf/nlF+Tn52Pnzp1qvTvPD0UailKpxNWrV9Ve++e/d5+ny2uZkpICMzOzUn2PVRTlfhp8hw4d0LJlS0RHR0vDUd7e3rh48SLu3Lkj1fvnn39w+PBhg27bx8cHgYGBqFSpEqpWrYr3338fgYGByM7ORtu2baX5P23atFFbT6FQoF+/fkhISMDWrVvVxnWfd+HCBfTo0QOenp749ddfte7pKCv379/HiBEj0LJlS8yaNQvff/89Tpw4gVmzZmnUffLkCb799lvpcUFBAb799lvUqFFDmiv13nvv4ebNm4XO63j48CFyc3NLb2eKURpxqRLBklwJukWLFqhRowZiYmJQUFAgla9evVpj/e7duyM9PV3tx/zJkydYtGgRKleujICAgGK3pZoL9HzXt6urK/z8/LBmzRq1eQr79u3D+fPnX7gPRRk0aBBu376N0aNH4/Hjx4UOf/355594/PixRvnu3bsBPB2C01XlypWxbNkyTJs2DT179iyy3nvvvQeFQoEZM2ZoPPfkyRPpdVD9Zf7sX+IFBQVYunSp2jrZ2dl48uSJWlnjxo1hZmYmXVrB3t4ejo6O+OOPP9TqPd9Wcd5++22Ym5sjMjJSo3dACKE21KsPc3NzvPPOO/jpp58KvS3Cs9/L2rC1tdWYF1OcVq1a6XX18u7du0OhUGDx4sVq5V9//TVkMhm6detW5LoleU0Le39kZWVh1apVOsf8Is/uixACixcvhoWFBTp37lxofV1ey8TERPj6+uo1fGssKkRXxCeffIK+ffti9erVGDNmDIYNG4YFCxYgKCgIw4cPx+3btxETEwNfX1+NcXhDOHz4MF5//XXpL5QjR45g4sSJRdb/+OOPsXPnTvTs2RP37t2TLnyoorro4IMHDxAUFIT//vsPn3zyCXbt2qVWz9vbWy15+uWXX/DPP/8AeNojcPr0acycORMA0KtXL6mrMjU1FV5eXhg6dGih1xV53s2bNzViBJ7+YPTp0wcA8OGHH+Lu3bvYv38/zM3N0bVrV4wYMQIzZ85E79691Xom3NzcMGfOHKSmpqJevXrYvHkzTp06he+++06ahzB48GBs2bIFY8aMwYEDB9CmTRsoFApcvHgRW7ZswZ49e6S/+stSacSlSvo+//xz9O/fHxYWFujZs2ehF66zsLDAzJkzMXr0aHTq1An9+vVDSkoKVq1apTG+P2rUKHz77bcIDg5GYmIiPD098eOPP+Lw4cOIjo7WmNvwvICAAAQEBBQ6WToqKgo9evRA27ZtMWzYMNy7dw+LFi2Cr68vcnJytNp/lXfeeQcffPABfv75Z7i7u6v1mqjMmTMHiYmJePvtt6X384kTJ7B27VpUq1atxFcJLsqLTkIAnh6X0aNHIyoqCqdOnUKXLl1gYWGBK1euYOvWrfjmm2/w7rvvonXr1qhatSqGDh2K8ePHQyaTYd26dRrJx++//47Q0FD07dsX9erVw5MnT7Bu3Trpx0dlxIgRmD17NkaMGIEWLVrgjz/+0Lh9TnG8vb0xc+ZMhIeHIzU1FX369IGdnR1SUlKwfft2jBo1qtjvLW3Mnj0bBw4cgL+/P0aOHAkfHx/cu3cPJ06cwP79+3Hv3j2t22zevDk2b96MsLAwvPbaa6hcuXKxiWrv3r2xbt06XL58WafeiJ49e6Jjx474/PPPkZqaiqZNm2Lv3r34+eefMWHChGKvdFyS17RLly6wtLREz549MXr0aOTk5GD58uVwcnIy6JX8VaysrBAbG4uhQ4fC398fv/32G3bt2oXPPvusyDmNgHav5ePHj3Hw4EF88MEHBo+/Qiqr082Kug6QEE+vzeLt7S28vb3FkydPhBBCrF+/XtSpU0dYWloKPz8/sWfPniJPg583b55Gm3juVMDiNGjQQMyYMUMIIcSNGzeKjFPlRdcOej6+opbnT3NXnepY2PLsKapnzpwRAMTkyZNfuG/FnQavOpaqywY8e2q7EEJkZ2cLDw8P0bRpU+n09oCAAOHr6yv+/vtv0apVK2FlZSU8PDw0rnshxNNTtufMmSN8fX2FXC4XVatWFc2bNxeRkZFqp0bjmVO4n/f866g6RfjZ0z5Vx87W1lZjfVW8hozLw8ND47WbMWOGqFmzpjAzMyvRKfFLly4VXl5eQi6XixYtWog//vij0Ms/ZGRkiJCQEOHo6CgsLS1F48aNizyVurBYVacpF/ae/umnn0TDhg2FXC4XPj4+Ytu2bRqfMW2prpMzadKkQp8/fPiwGDdunGjUqJFwcHAQFhYWonbt2iI4OFgkJydrta3ivlOeVdh1gIR4eumB5s2bC2tra2FnZycaN24sJk2aJP7991+1eF9//XVhbW0t3NzcxKRJk6TTl1WnKV+9elUMGzZMeHt7CysrK1GtWjXRsWNHsX//frXt5eXlieHDhwsHBwdhZ2cn3nvvPXH79u0Sv8dVfvrpJ9G2bVtha2srbG1tRYMGDcS4cePEpUuXpDqFve+LOxaFvX8yMjLEuHHjhLu7u7CwsBAuLi6ic+fO4rvvvpPqqN5fz58uXthp/zk5OWLgwIGiSpUqJbrcQn5+vnB0dJS+m1WK+qyrjtuzHjx4ID766CPh5uYmLCwsxCuvvCLmzZsnlEplsdsu6Wu6c+dO0aRJE2FlZSU8PT3FnDlzxMqVKzW+A7Q57oX9rqn2OTk5WbqOmbOzs4iIiFC7XpCqzed/+0ryWgohxG+//SYAiCtXrhR7fF4WMiEq+GxO0rB06VJMmjQJycnJcHZ2LtNtd+jQAZmZmSZ1x2AiKh8zZszAqlWrcOXKFZO+H1hwcDB+/PFHnXtnS6pPnz6QyWQ6XRXeGJX7HCDS3oEDBzB+/PgyT36IiMrSRx99hJycHLVrTFHpuHDhAn799ddC58a9rCrEHCDSztatW8s7BDIB9+7dU5uo/Txzc/Ni5x7oKicn54V/6daoUcOkewRMReXKlXW+SS5pp2HDhhoTv192TICIqFBvv/12kVebBlDk9bH0NX/+fERGRhZbJyUl5YU30yQiKg7nABFRoRITE4u9kq+1tbXGJSIM4erVqy+8hULbtm1hZWVl8G0TkelgAkREREQmh5OgiYiIyORwDlAJKZVK/Pvvv7Czs6tQt3YgIqKKRwiBBw8ewM3NTeOGxoby6NGjYk9U0IalpaXJDSszASqhf//9V+NGmURERMVJS0tDrVq1DN7uo0eP4OVRGem3i76hrjZcXFyQkpJiUkkQE6ASUt12IC0tDfb29uUcDRERGVpvhyEGa+sJHuMQdr/wljW6KigoQPptBa4lesLeTr8epuwHSng0T0VBQQETINKkGvayt7dnAkRE9BKqJLMwXGP/d3pRaU+ZqGwnQ2U7/bahhGlO62ACREREZKQUQgmFnudyK4TSMMEYGSZARERERkoJASX0y4D0Xd9Ymcxp8H/88Qd69uwJNzc3yGQy7Nixo7xDIiIionJiMglQbm4umjZtiiVLlpR3KERERAahNNB/pshkhsC6deuGbt26lXcYREREBqMQAgo9b+ig7/rGymQSIG3l5+cjPz9fepydnV2O0RAREZEhmcwQmLaioqLg4OAgLbwIIhERVTSqSdD6LqaICVARwsPDkZWVJS1paWnlHRIREZEaJQQUei6mmgBxCKwIcrkccrm8vMMgIiKiUsAEiIiIyEjxOkC6M5kEKCcnB0lJSdLjlJQUnDp1CtWqVUPt2rXLMTIiIiLd8Cww3ZlMAvT333+jY8eO0uOwsDAAwNChQ7F69epyioqIiIjKg8kkQB06dIAw0SyXiIheTsr/W/RtwxSZTAJERET0slGdyaVvG6aICRAREZGRUggY4G7whonF2PA6QERERGRy2ANERERG6Q2zvgZtb59yq8Hays7OhoODg8HaKwrnAOmOCRAREZGRUkIGBWR6t2GKOARGREREJoc9QEREREZKKZ4u+rZhipgAERERGSmFAYbA9F3fWHEIjIiIiEwOEyAiIiIjpeoB0nfRxh9//IGePXvCzc0NMpkMO3bsKJ2dK2VMgIiIiIyUUsgMsmgjNzcXTZs2xZIlS0ppr8oG5wARERFRiXXr1g3dunUr7zD0xgSIiIjISHEStO6YABERERkpBcyg0HM2i+L//p+dna1WLpfLIZfL9Wq7IuMcICIiIiMlDDD/R/zfHCB3d3c4ODhIS1RUVDnvXeliDxAREREhLS0N9vb20uOXufcHYAJERERktAw5B8je3l4tAXrZMQEiIiIyUgphBoXQcw6QlrfCyMnJQVJSkvQ4JSUFp06dQrVq1VC7dm29YilLTICIiIioxP7++2907NhRehwWFgYAGDp0KFavXl1OUWmPCRAREZGRUkIGpZ7nMymhXRdQhw4dIITx30GVCRAREZGR4nWAdMcEiIiIysQbZn0N2t4+5VaDtkemhQkQERGRkTLMJGjjH87SBRMgIiIiI/V0DpB+Q1j6rm+seCVoIiIiMjnsASIiIjJSSgPcC0zbs8BeFkyAiIiIjBTnAOmOCRAREZGRUsKszK8D9LLgHCAiIiIyOewBIiIiMlIKIYNC6HkhRD3XN1ZMgIiIiIyUwgCToBUcAiMiIiIyDewBIiIiMlJKYQalnmeBKU30LLAK2QO0ZMkSeHp6wsrKCv7+/jh+/HiRdTt06ACZTKax9OjRQ6oTHBys8XzXrl3LYleIiIhKjWoITN/FFFW4HqDNmzcjLCwMMTEx8Pf3R3R0NIKCgnDp0iU4OTlp1N+2bRsKCgqkx3fv3kXTpk3Rt6/6Tfe6du2KVatWSY/lcnnp7QQRERFVaBUu7VuwYAFGjhyJkJAQ+Pj4ICYmBjY2Nli5cmWh9atVqwYXFxdp2bdvH2xsbDQSILlcrlavatWqZbE7REREpUaJ/50JpuuiLO+dKCcVKgEqKChAYmIiAgMDpTIzMzMEBgYiISGhRG2sWLEC/fv3h62trVp5fHw8nJycUL9+fYwdOxZ3794ttp38/HxkZ2erLURERBWJ6kKI+i6mqELtdWZmJhQKBZydndXKnZ2dkZ6e/sL1jx8/jrNnz2LEiBFq5V27dsXatWsRFxeHOXPm4ODBg+jWrRsUCkWRbUVFRcHBwUFa3N3dddspIiIiqnAq3BwgfaxYsQKNGzdGy5Yt1cr79+8v/btx48Zo0qQJvL29ER8fj86dOxfaVnh4OMLCwqTH2dnZTIKIiKhCMcy9wCpUX0iZqVB77ejoCHNzc2RkZKiVZ2RkwMXFpdh1c3NzsWnTJgwfPvyF26lTpw4cHR2RlJRUZB25XA57e3u1hYiIqCJRQmaQxRRVqB4gS0tLNG/eHHFxcejTpw8AQKlUIi4uDqGhocWuu3XrVuTn5+P9999/4XZu3LiBu3fvwtXV1RBhExG9lLpY9H9xJS3sU241aHvEHiB9VLi9DgsLw/Lly7FmzRpcuHABY8eORW5uLkJCQgAAQ4YMQXh4uMZ6K1asQJ8+fVC9enW18pycHHzyySc4evQoUlNTERcXh969e6Nu3boICgoqk30iIiKiiqVC9QABQL9+/XDnzh1MnToV6enp8PPzQ2xsrDQx+vr16zAzU8/bLl26hEOHDmHv3r0a7Zmbm+P06dNYs2YN7t+/Dzc3N3Tp0gUzZszgtYCIiMioGeZeYBWuL6RMVLgECABCQ0OLHPKKj4/XKKtfvz5EEZfytra2xp49ewwZHhERUYWgFDIo9bybu77rGyvTTPuIiIjIpFXIHiAiIiJ6MaUBhsBM9UKITICIiIiMlGHuBm+aCZBp7jURERGZNPYAERERGSkFZFDoeSFDfdc3VkyAiIiIjBSHwHRnmntNREREJo09QEREREZKAf2HsBSGCcXoMAEiIiIyUhwC0x0TICIiIiPFm6HqzjT3moiIiEwae4CIiIiMlIAMSj3nAAmeBk9ERETGhENgujPNvSYiIiKTxh4gIqKXRLcaYwza3t7HmwzaHhmeUsigFPoNYem7vrFiAkRERGSkFAa4G7y+6xsr09xrIiIiMmnsASIiIjJSHALTHRMgIiIiI6WEGZR6Dubou76xMs29JiIiIpPGHiAiIiIjpRAyKPQcwtJ3fWPFBIiIiMhIcQ6Q7pgAERERGSlhgLvBC14JmoiIiMg0sAeIiIjISCkgg0LPm5nqu76xYgJERERkpJRC/zk8SmGgYIwMh8CIiIjI5LAHiIiIyEgpDTAJWt/1jRUTICIiIiOlhAxKPefw6Lu+sTLNtI+IiIhMGnuAiIiIjBSvBK07JkBERERGinOAdGeae01EREQmzWh7gJYsWYJ58+YhPT0dTZs2xaJFi9CyZctC665evRohISFqZXK5HI8ePSqLUImIitS5wyyDtRV3J8ZgbZFxUMIA9wLTYRK0Nr/BABAdHY1ly5bh+vXrcHR0xLvvvouoqChYWVnpE7pejLIHaPPmzQgLC0NERAROnDiBpk2bIigoCLdv3y5yHXt7e9y6dUtarl27VoYRExERGZ74v7PA9FmElgmQtr/BGzduxOTJkxEREYELFy5gxYoV2Lx5Mz777DNDHAKdGWUCtGDBAowcORIhISHw8fFBTEwMbGxssHLlyiLXkclkcHFxkRZnZ+cyjJiIiMjwVHeD13fRhra/wUeOHEGbNm0wcOBAeHp6okuXLhgwYACOHz9uiEOgM6NLgAoKCpCYmIjAwECpzMzMDIGBgUhISChyvZycHHh4eMDd3R29e/fGuXPnit1Ofn4+srOz1RYiIiJTpstvcOvWrZGYmCglPFevXsXu3bvRvXv3Mom5KEY3BygzMxMKhUKjB8fZ2RkXL14sdJ369etj5cqVaNKkCbKysjB//ny0bt0a586dQ61atQpdJyoqCpGRkQaPn4iIyFAMeRbY83/oy+VyyOVytTJdfoMHDhyIzMxMtG3bFkIIPHnyBGPGjOEQWFlo1aoVhgwZAj8/PwQEBGDbtm2oUaMGvv322yLXCQ8PR1ZWlrSkpaWVYcREREQvZsghMHd3dzg4OEhLVFSUQWKMj4/HrFmzsHTpUpw4cQLbtm3Drl27MGPGDIO0ryuj6wFydHSEubk5MjIy1MozMjLg4uJSojYsLCzQrFkzJCUlFVmnsMyXiIjoZZWWlgZ7e3vpcWG/gbr8Bn/xxRcYPHgwRowYAQBo3LgxcnNzMWrUKHz++ecwMyufvhij6wGytLRE8+bNERcXJ5UplUrExcWhVatWJWpDoVDgzJkzcHV1La0wiYiISp2+Z4A9ey8xe3t7taWwBEiX3+C8vDyNJMfc3BwAIIQw1KHQmtH1AAFAWFgYhg4dihYtWqBly5aIjo5Gbm6udK2fIUOGoGbNmlL33fTp0/H666+jbt26uH//PubNm4dr165J2SgREZEx0uUsrsLa0Ia2v8E9e/bEggUL0KxZM/j7+yMpKQlffPEFevbsKSVC5cEoE6B+/frhzp07mDp1KtLT0+Hn54fY2FhpUtb169fVss3//vsPI0eORHp6OqpWrYrmzZvjyJEj8PHxKa9dICIiMkra/gZPmTIFMpkMU6ZMwc2bN1GjRg307NkTX375ZXntAgBAJsqz/8mIZGdnw8HBAVlZWWpjpERE+jDolaDjy/esGvqf0v7NULXfLXYkLGwt9WrrcW4Bfuu63OR+34yyB4iIiIjKZwjsZWF0k6CJiIiI9MUeICIiIiPFHiDdMQEiIiIyUgK63c39+TZMERMgIiIiI8UeIN1xDhARERGZHPYAERERGSn2AOmOCRARkRbqzvnaoO0l8do9pAcmQLrjEBgRERGZHPYAERERGSn2AOmOCRAREZGREkIGoWcCo+/6xopDYERERGRy2ANERERkpJSQ6X0hRH3XN1ZMgIiIiIwU5wDpjkNgREREZHLYA0RERGSkOAlad0yAiIiIjBSHwHTHBIiIiMhIsQdId5wDRERERCaHPUBERERGShhgCMxUe4CYABERERkpAUAI/dswRRwCIyIiIpPDHiAiIiIjpYQMMl4JWidMgIiIiIwUzwLTHYfAiIiIyOSwB4iIXmpfnnvToO0lffqrQdsj0odSyCDjhRB1wgSIiIjISAlhgLPATPQ0MA6BERERkclhDxAREZGR4iRo3TEBIiIiMlJMgHTHBIiIiMhIcRK07jgHiIiIiEwOe4CIiIiMFM8C012F7AFasmQJPD09YWVlBX9/fxw/frzIusuXL0e7du1QtWpVVK1aFYGBgRr1g4ODIZPJ1JauXbuW9m4QERGVqqcJkEzPpbz3onxUuARo8+bNCAsLQ0REBE6cOIGmTZsiKCgIt2/fLrR+fHw8BgwYgAMHDiAhIQHu7u7o0qULbt68qVava9euuHXrlrT88MMPZbE7REREVAFVuARowYIFGDlyJEJCQuDj44OYmBjY2Nhg5cqVhdbfsGEDPvjgA/j5+aFBgwb4/vvvoVQqERcXp1ZPLpfDxcVFWqpWrVoWu0NERFRq9O/90f8sMmNVoRKggoICJCYmIjAwUCozMzNDYGAgEhISStRGXl4eHj9+jGrVqqmVx8fHw8nJCfXr18fYsWNx9+7dYtvJz89Hdna22kJERFSRCAMtpqhCJUCZmZlQKBRwdnZWK3d2dkZ6enqJ2vj000/h5uamlkR17doVa9euRVxcHObMmYODBw+iW7duUCgURbYTFRUFBwcHaXF3d9dtp4iIiKjCeanOAps9ezY2bdqE+Ph4WFlZSeX9+/eX/t24cWM0adIE3t7eiI+PR+fOnQttKzw8HGFhYdLj7OxsJkFERFSh8EKIutM6AcrPz8exY8dw7do15OXloUaNGmjWrBm8vLz0DsbR0RHm5ubIyMhQK8/IyICLi0ux686fPx+zZ8/G/v370aRJk2Lr1qlTB46OjkhKSioyAZLL5ZDL5drtABERUVkyxBiWiY6BlTgBOnz4ML755hv88ssvePz4MRwcHGBtbY179+4hPz8fderUwahRozBmzBjY2dnpFIylpSWaN2+OuLg49OnTBwCkCc2hoaFFrjd37lx8+eWX2LNnD1q0aPHC7dy4cQN3796Fq6urTnESERFVCIaYxGyiPUAlmgPUq1cv9OvXD56enti7dy8ePHiAu3fv4saNG8jLy8OVK1cwZcoUxMXFoV69eti3b5/OAYWFhWH58uVYs2YNLly4gLFjxyI3NxchISEAgCFDhiA8PFyqP2fOHHzxxRdYuXIlPD09kZ6ejvT0dOTk5AAAcnJy8Mknn+Do0aNITU1FXFwcevfujbp16yIoKEjnOImIiMh4lagHqEePHvjpp59gYWFR6PN16tRBnTp1MHToUJw/fx63bt3SOaB+/frhzp07mDp1KtLT0+Hn54fY2FhpYvT169dhZva/vG3ZsmUoKCjAu+++q9ZOREQEpk2bBnNzc5w+fRpr1qzB/fv34ebmhi5dumDGjBkc4iIiIqPGK0HrTiZEyXZdoVDA3Ny8tOOpsLKzs+Hg4ICsrCzY29uXdzhEVEJfnnvToO197vurQdujl1Np/2ao2vdcOQVmNlYvXqEYyrxHSB02s8L/vl2/fl1t/rGvr69eHRklngNUs2ZNBAcHY9iwYahXr57OGyQiKo4y3bDfL5/7XjZoe0RUdlJTU7Fs2TJs2rQJN27cwLN9NpaWlmjXrh1GjRqFd955R210qCRKXHvcuHH48ccf0bBhQ7Rr1w6rV69GXl6eVhsjIiIiAxIywywV0Pjx49G0aVOkpKRg5syZOH/+PLKyslBQUID09HTs3r0bbdu2xdSpU9GkSRP89ddfWrVf4gToiy++QFJSEuLi4lCnTh2EhobC1dUVI0eOxLFjx7TeMSIiItKPag6QvktFZGtri6tXr2LLli0YPHgw6tevDzs7O1SqVAlOTk7o1KkTIiIicOHCBcyfPx9paWlata/1laA7dOiANWvWID09HV999RUuXLiAVq1awdfXFwsWLNC2OSIiIiINUVFRqF69eonqdu3aFW+//bZW7et8K4zKlStjxIgROHToEH755Rekp6fjk08+0bU5IiIi0tZLfjOwFi1aICYmplTux6lzApSXl4fVq1cjICAAvXr1QvXq1fHll18aMjYiIiIqxst+N/imTZti0qRJcHV1xeDBgxEfH2+wtrVOgI4cOYIRI0bA1dUV48aNg6enJw4cOIDLly9j8uTJBguMiIiITNuKFSuQnp6OJUuWIC0tDZ07d0bdunUxa9Ys3Lx5U6+2S5wAzZ07VzoD7MyZM5g3bx7S09OxZs0atG/fXq8giIiISEcv6fCXio2NDYKDgxEfH4/Lly+jf//++Pbbb+Hp6YkePXpg27ZtOrVb4gRo3rx56Nq1K/755x8cO3YMo0aN0vmeX0RERKS/l30I7Hne3t6YOXMmUlNT8cMPP+Do0aPo27evTm2V+EKI//77b5G3wiAiIqJyYIJ3g4+Pj8eqVavw008/oVKlShg5cqRO7ZSoB2jTpk0lTn7S0tJw+PBhnYIhIiIiet6NGzcwc+ZM1K1bF506dUJqaiqWLl2KW7duISYmRqc2S5QALVu2DA0bNsTcuXNx4cIFjeezsrKwe/duDBw4EK+++iru3r2rUzBERESkDZmBloppy5Yt6Nq1K7y8vLBs2TK89957uHz5Mg4ePIghQ4bA2tpa57ZLNAR28OBB7Ny5E4sWLUJ4eDhsbW3h7OwMKysr/Pfff0hPT4ejoyOCg4Nx9uxZ6c7tREREVIpe8iGw999/Hz169MD27dvRvXt3re/3VZwSzwHq1asXevXqhczMTBw6dAjXrl3Dw4cP4ejoiGbNmqFZs2YGDYyIiIgqpiVLlkhngzdt2hSLFi1Cy5Yti6x///59fP7559i2bRvu3bsHDw8PREdHo3v37sVu58aNG3BycjJ0+AC0SIBUHB0d0adPn1IIhYiIiLRSDj1AmzdvRlhYGGJiYuDv74/o6GgEBQXh0qVLhSYrBQUFeOONN+Dk5IQff/wRNWvWxLVr11ClSpVit3P06FG8/vrrJYopLy8PKSkp8PX1LfF+sMuGiIjIWJXD3eAXLFiAkSNHIiQkBD4+PoiJiYGNjQ1WrlxZaP2VK1fi3r172LFjB9q0aQNPT08EBASgadOmxW5n8ODBCAoKwtatW5Gbm1tonfPnz+Ozzz6Dt7c3EhMTtdoPJkBERERUIgUFBUhMTERgYKBUZmZmhsDAQCQkJBS6zs6dO9GqVSuMGzcOzs7OaNSoEWbNmgWFQlHsts6fP48ePXpgypQpqFKlCnx9ffHGG2+gZ8+eaNu2LRwdHfHqq68iJSUFe/fuxZAhQ7TaF62HwIiIiKhiEOLpom8bADRuOCqXyyGXy9XKMjMzoVAoNE52cnZ2xsWLFwtt/+rVq/j9998xaNAg7N69G0lJSfjggw/w+PFjREREFBmXhYUFxo8fj/Hjx+Pvv/9Wm3/ctGlTfPTRR+jYsSOqVaumw14zASIiPa27UrIx+pIa/Mplg7ZH9FIz4Bwgd3d3teKIiAhMmzZNz8YBpVIJJycnfPfddzA3N0fz5s1x8+ZNzJs3r9gE6FktWrRAixYt9I7lWUyAiIiICGlpabC3t5ceP9/7Azw9Ecrc3BwZGRlq5RkZGXBxcSm0XVdXV1hYWMDc3Fwqa9iwIdLT01FQUABLS0sD7YF2tJoDdOvWLaxfvx67d+9GQUGB2nO5ubmYPn26QYMjIiKiYhhwErS9vb3aUlgCZGlpiebNmyMuLk4qUyqViIuLQ6tWrQoNsU2bNkhKSoJSqZTKLl++DFdX13JLfgAtEqC//voLPj4+GDduHN599134+vri3Llz0vM5OTmIjIwslSCJiIhIk0wYZtFGWFgYli9fjjVr1uDChQsYO3YscnNzERISAgAYMmQIwsPDpfpjx47FvXv38OGHH+Ly5cvYtWsXZs2ahXHjxhnyUGitxAnQZ599hrfeegv//fcfMjIy8MYbbyAgIAAnT54szfiIiIioKMJAixb69euH+fPnY+rUqfDz88OpU6cQGxsrTYy+fv06bt26JdV3d3fHnj178Ndff6FJkyYYP348PvzwQ0yePFmPHddfiecAJSYmYsmSJTAzM4OdnR2WLl2K2rVro3PnztizZw9q165dmnESERFRBREaGorQ0NBCn4uPj9coa9WqFY4ePVrKUWlHqzlAjx49Uns8efJkfPbZZ+jSpQuOHDli0MCIiIjoBcrhQohl7eHDhzh06BDOnz+v8dyjR4+wdu1andotcQLUqFGjQpOciRMnIjw8HAMGDNApACIiItJROQyBlaXLly+jYcOGaN++PRo3boyAgAC14bWsrCxp7pG2SpwADRkyBIcPHy70uUmTJiEyMpLDYERERGQwn376KRo1aoTbt2/j0qVLsLOzQ5s2bXD9+nW92y5xAjRixAisW7eu2CBTUlL0DoiIiIhK6CXvATpy5AiioqLg6OiIunXr4pdffkFQUBDatWuHq1ev6tU27wVGRERkrF7yBOjhw4eoVOl/52vJZDIsW7YMPXv2REBAAC5f1v3K8VonQBkZGRg8eDDc3NxQqVIlmJubqy1EREREhtCgQQP8/fffGuWLFy9G79690atXL53b1vpWGMHBwbh+/Tq++OILuLq6Qiar2LPHiYiIXlqGOIurAp8F9tZbb+GHH37A4MGDNZ5bvHgxlEolYmJidGpbJoR295G1s7PDn3/+CT8/P502aKyys7Ph4OCArKwstXulEJk6w98MtWJdK4RIF6X9m6Fqv/bcmTCzttKrLeXDR7g+aYrJ/b5pPQTm7u4OLXMmIiIiIp2tX78eubm5Bm1T6wQoOjoakydPRmpqqkEDKQtLliyBp6cnrKys4O/vj+PHj5d3SERERLp7ySdBq3z00UdwdnbGwIEDsXv3bigUCr3bLNEcoKpVq6rN9cnNzYW3tzdsbGxgYWGhVvfevXt6B1UaNm/ejLCwMMTExMDf3x/R0dEICgrCpUuX4OTkVN7hERERURFu3bqF2NhY/PDDD3jvvfdgY2ODvn37YtCgQWjdurVObZYoAYqOjtap8YpkwYIFGDlypHTFyJiYGOzatQsrV64s9xuyERER6UIG7e/mXlgbFV2lSpXw5ptv4s0330ReXh62b9+OjRs3omPHjqhVqxaSk5O1b7MklYYOHap1wxVJQUEBEhMTER4eLpWZmZkhMDAQCQkJha6Tn5+P/Px86XF2dnapx0lERETFs7GxQVBQEP777z9cu3YNFy5c0KkdrU+D3717N8zNzREUFKRWvnfvXigUCnTr1k2nQEpTZmYmFAoFnJ2d1cqdnZ1x8eLFQteJiopCZGRkWYRHVKY8l843aHupH/CsLaJy85KfBv8sVc/Phg0bEBcXB3d3dwwYMAA//vijTu1pPQl68uTJhU4+UiqVL9VQUnh4OLKysqQlLS2tvEMiIiJSZyKToPv37w8nJyd89NFHqFOnDuLj45GUlIQZM2agQYMGOrWpdQ/QlStX4OPjo1HeoEEDJCUl6RREaXN0dIS5uTkyMjLUyjMyMuDi4lLoOnK5HHK5vCzCIyIiomKYm5tjy5YtCAoKMthdJ7TuAXJwcCj0BmRJSUmwtbU1SFCGZmlpiebNmyMuLk4qUyqViIuLQ6tWrcoxMiIiIj2YSA/Qhg0b0L17d4PeckvrBKh3796YMGGC2ozrpKQkfPzxx3rdk6O0hYWFYfny5VizZg0uXLiAsWPHIjc3VzorjIiIyNjIhGEWU6T1ENjcuXPRtWtXNGjQALVq1QIA3LhxA+3atcP8+YadXGlI/fr1w507dzB16lSkp6fDz88PsbGxGhOjiYiI6OWndQLk4OCAI0eOYN++ffjnn39gbW2NJk2aoH379qURn0GFhoYiNDS0vMMgIiIyDEMMYbEHqORkMhm6dOmCLl26GDoeIiIiKikmQDrTeg4QERERUVlLTk7GlClTMGDAANy+fRsA8Ntvv+HcuXM6tccEiIiIyEiZyiTogwcPonHjxjh27Bi2bduGnJwcAMA///yDiIgIndpkAkRERGSsVFeC1nep4CZPnoyZM2di3759sLS0lMo7deqEo0d1uxo9EyAiIiJjZSLXATpz5gzeeustjXInJydkZmbq1KZOCZChx+GIiIiIilKlShXcunVLo/zkyZOoWbOmTm1qnQCVxjgcERERac9U5gD1798fn376KdLT0yGTyaBUKnH48GFMnDgRQ4YM0alNnW6GauhxOCIiItKBiQyBzZo1Cw0aNIC7uztycnLg4+OD9u3bo3Xr1pgyZYpObWp9HaAzZ85g48aNGuX6jMMRERERFcXS0hLLly/H1KlTcebMGeTk5KBZs2Z45ZVXdG5T6x6g0hiHIyIiIh0YYvjLCHqApk+fjry8PLi7u6N79+5477338Morr+Dhw4eYPn26Tm1qnQCVxjgcERER6cBEhsAiIyOlOcfPysvLQ2RkpE5taj0ENmvWLIwbNw7u7u5QKBTw8fGBQqHAwIEDdR6HI6KiBXSfa9D2UndPMmh7RESlTQgBmUzzekX//PMPqlWrplObWidApTEOR0RERDp4ye8FVrVqVchkMshkMtSrV08tCVIoFMjJycGYMWN0alvrBGj69OmYOHEi3N3d4e7uLpU/fPgQ8+bNw9SpU3UKhIiIiLRjiNPYK/Jp8NHR0RBCYNiwYYiMjISDg4P0nKWlJTw9PdGqVSud2tY6AYqMjMSYMWNgY2OjVq4ah2MCRERERIYwdOhQAICXlxdat24NCwsLg7WtdQJUGuNwREREREUJCAiQ/v3o0SMUFBSoPW9vb691myVOgEpzHI6IiIh08JLPAVLJy8vDpEmTsGXLFty9e1fjeYVCoXWbJU6ASnMcjoiIiLT3ss8BUvnkk09w4MABLFu2DIMHD8aSJUtw8+ZNfPvtt5g9e7ZObZY4ASrNcTgiIiKiovzyyy9Yu3YtOnTogJCQELRr1w5169aFh4cHNmzYgEGDBmndptZzgEpjHI6IiIh0ZAQ9OPq6d+8e6tSpA+BpnnHv3j0AQNu2bTF27Fid2tT6StB5eXkIDQ2Fk5MTbG1tUbVqVbWFiIiIyoiJXAm6Tp06SElJAQA0aNAAW7ZsAfC0Z6hKlSo6tal1AvTJJ5/g999/x7JlyyCXy/H9998jMjISbm5uWLt2rU5BEBERERUlJCQE//zzDwBg8uTJWLJkCaysrPDRRx/hk08+0alNrYfASmMcjoiIiLRnKpOgP/roI+nfgYGBuHjxIhITE1G3bl00adJEpza1ToBKYxyOiIiIdGAip8E/z8PDAx4eHnq1oXUCpBqHq127tjQO17JlS73G4YiIiIie9/DhQ8TFxeHNN98EAISHhyM/P1963tzcHDNmzICVlZXWbWudAKnG4QICAjB58mT07NkTixcvxuPHj7FgwQKtAyAiIiLdvOxDYGvWrMGuXbukBGjx4sXw9fWFtbU1AODixYtwc3NTGyIrKa0ToNIYhyMiIiIdvORDYBs2bMCkSZPUyjZu3ChNxVm/fj2WLFlSNgnQ8wwxDkdERET0vKSkJDRu3Fh6bGVlBTOz/53A3rJlS4wbN06ntkucAJXmOBwRERHp4CXvAbp//75arnHnzh2155VKpdrz2ihxAlSa43BERESkvZd9DlCtWrVw9uxZ1K9fv9DnT58+jVq1aunUdokToNIchyN62XRz1a1LtjAHby0xWFtE9JJ5yXuAunfvjqlTp6JHjx4aI0wPHz5EZGQkevTooVPbJU6ASnMcjoiIiOh5n332GbZs2YL69esjNDQU9erVAwBcunQJixcvxpMnT/DZZ5/p1HaJE6DSHIcjIiIiHbzkPUDOzs44cuQIxo4di8mTJ0OIp8HKZDK88cYbWLp0KZydnXVqu8T3AlONwxVFn3E4FSEEpk6dCldXV1hbWyMwMBBXrlwpdp2oqCi89tprsLOzg5OTE/r06YNLly6p1enQoQNkMpnaMmbMGL1iJSIiKm+qOUD6LhWZl5cXYmNjcefOHRw9ehRHjx7FnTt3EBsbK03D0UWJEyDVONyjR480ntN3HE5l7ty5WLhwIWJiYnDs2DHY2toiKCio0G2qHDx4EOPGjcPRo0exb98+PH78GF26dEFubq5avZEjR+LWrVvSMnfuXL1iJSIiorJTrVo1tGzZEi1btkS1atX0bq/EQ2ClOQ4HPO39iY6OxpQpU9C7d28AwNq1a+Hs7IwdO3agf//+ha4XGxur9nj16tVwcnJCYmIi2rdvL5Xb2NjAxcVF5/iIiIgqnJd8CKw0lbgHSDUO17BhQ0yePBlvvfUW3nrrLYSHh8PHxweHDh3SeRwOAFJSUpCeno7AwECpzMHBAf7+/khISChxO1lZWQCgkR1u2LABjo6OaNSoEcLDw5GXl1dsO/n5+cjOzlZbiIiIKhJTGAIrLSVOgIDSG4cDgPT0dADQSKKcnZ2l515EqVRiwoQJaNOmDRo1aiSVDxw4EOvXr8eBAwcQHh6OdevW4f333y+2raioKDg4OEiLu7u7lntERET0clqyZAk8PT1hZWUFf39/HD9+vETrbdq0CTKZDH369CndAEtAp1thqMbh9LFhwwaMHj1aerxr1y692gOAcePG4ezZszh06JBa+ahRo6R/N27cGK6urujcuTOSk5Ph7e1daFvh4eEICwuTHmdnZzMJIiKiiqUchsA2b96MsLAwxMTEwN/fH9HR0QgKCsKlS5fg5ORU5HqpqamYOHEi2rVrp2fAhqFVD5Ah9erVC6dOnZIWR0dHAEBGRoZavYyMjBLN3QkNDcWvv/6KAwcOvPBsNH9/fwBPr21UFLlcDnt7e7WFiIioQhEGWrSwYMECjBw5EiEhIfDx8UFMTAxsbGywcuXKItdRKBQYNGgQIiMj9R4xMpRyS4Ds7OxQt25dafHx8YGLiwvi4uKkOtnZ2Th27BhatWpVZDtCCISGhmL79u34/fff4eXl9cJtnzp1CgDg6uqq934QERGZioKCAiQmJqrN1zUzM0NgYGCx83WnT58OJycnDB8+vCzCLBG97wZvKDKZDBMmTMDMmTPxyiuvwMvLC1988QXc3NzUxgo7d+6Mt956C6GhoQCeDntt3LgRP//8M+zs7KT5Qg4ODrC2tkZycjI2btyI7t27o3r16jh9+jQ++ugjtG/fHk2aNCmPXSUiIjII2f8t+rYBQONkH7lcDrlcrlaWmZkJhUJR6HzdixcvFtr+oUOHsGLFCqnzoaKoMAkQAEyaNAm5ubkYNWoU7t+/j7Zt2yI2Nlbt/h/JycnIzMyUHi9btgzA04sdPmvVqlUIDg6GpaUl9u/fj+joaOTm5sLd3R3vvPMOpkyZUib7REREVGoMOAfo+XmuERERmDZtml5NP3jwAIMHD8by5culqS4VRYVKgGQyGaZPn47p06cXWSc1NVXtseqy2EVxd3fHwYMHDREeERFRhWLIu8GnpaWpzXd9vvcHABwdHWFubl7i+brJyclITU1Fz549pTKlUgkAqFSpEi5dulTkyUilrdzmABEREVHF8fyJP4UlQJaWlmjevLnafF2lUom4uLhC5+s2aNAAZ86cUTvpqVevXujYsSNOnTpVrmdXV6geICIiItJCOZwGHxYWhqFDh6JFixZo2bKlNMUkJCQEADBkyBDUrFkTUVFRsLKyUrsuHwBUqVIFADTKyxoTICIiImNWxldy7tevH+7cuYOpU6ciPT0dfn5+iI2NlSZGX79+HWZmFX+AiQkQERERaSU0NFQ6G/t58fHxxa67evVqwwekAyZARAC6WA40aHt7CzYatD0iosIYchK0qWECREREZKx4N3idVfxBOiIiIiIDYw8QERGRkeIQmO6YABERERkrDoHpjENgREREZHLYA0RERGSkOASmOyZARERExopDYDpjAkRERGSsmADpjHOAiIiIyOSwB4iIiMhIcQ6Q7pgAERERGSsOgemMQ2BERERkctgDREREZKRkQkAm9OvC0Xd9Y8UEiIiIyFhxCExnHAIjIiIik8MeICIiIiPFs8B0xwSIiIjIWHEITGccAiMiIiKTwx4gMkpvmPU1aHv7lFsN2h4RUVngEJjumAAREREZKw6B6YwJEBERkZFiD5DuOAeIiIiITA57gIiIiIwVh8B0xgSIiIjIiJnqEJa+OARGREREJoc9QERERMZKiKeLvm2YICZARERERopngenO6IbAhBCYOnUqXF1dYW1tjcDAQFy5cqXYdaZNmwaZTKa2NGjQoIwiJiIioorG6BKguXPnYuHChYiJicGxY8dga2uLoKAgPHr0qNj1fH19cevWLWk5dOhQGUVMRERUSoSBFhNkVENgQghER0djypQp6N27NwBg7dq1cHZ2xo4dO9C/f/8i161UqRJcXFzKKlQiIqJSJ1M+XfRtwxQZVQ9QSkoK0tPTERgYKJU5ODjA398fCQkJxa575coVuLm5oU6dOhg0aBCuX79e2uESERFRBWVUPUDp6ekAAGdnZ7VyZ2dn6bnC+Pv7Y/Xq1ahfvz5u3bqFyMhItGvXDmfPnoWdnV2h6+Tn5yM/P196nJ2dbYA9ICIiMiBeCFFnFboHaMOGDahcubK0PH78WKd2unXrhr59+6JJkyYICgrC7t27cf/+fWzZsqXIdaKiouDg4CAt7u7uuu4GERFRqVCdBabvYooqdALUq1cvnDp1SlocHR0BABkZGWr1MjIytJrfU6VKFdSrVw9JSUlF1gkPD0dWVpa0pKWl6bYTREREpUV1HSB9FxNUoYfA7Ozs1IaohBBwcXFBXFwc/Pz8ADwdmjp27BjGjh1b4nZzcnKQnJyMwYMHF1lHLpdDLpfrHDsRERFVXBW6B+h5MpkMEyZMwMyZM7Fz506cOXMGQ4YMgZubG/r06SPV69y5MxYvXiw9njhxIg4ePIjU1FQcOXIEb731FszNzTFgwIBy2AsiIiLD4BCY7ip0D1BhJk2ahNzcXIwaNQr3799H27ZtERsbCysrK6lOcnIyMjMzpcc3btzAgAEDcPfuXdSoUQNt27bF0aNHUaNGjfLYBZP0hllfg7a3T7nVoO0RERklToLWmdElQDKZDNOnT8f06dOLrJOamqr2eNOmTaUcFRERERkTo0uAiIiI6CneC0x3TICIiIiMFe8GrzOjmgRNREREZAjsASIiIjJSHALTHRMgIiIiY8WzwHTGITAiIiIyOewBIiIiMlIcAtMdEyAiIiJjpRRPF33bMEFMgIiIiIwV5wDpjHOAiIiIyOSwB4iIiMhIyWCAOUAGicT4MAEiIiIyVrwStM44BEZEREQmhz1ARERERoqnweuOCRAREZGx4llgOuMQGBEREZkc9gAREREZKZkQkOk5iVnf9Y0VEyAq1BtmfQ3a3j7lVoO2R0REAJT/t+jbhgniEBgRERFpZcmSJfD09ISVlRX8/f1x/PjxIusuX74c7dq1Q9WqVVG1alUEBgYWW7+sMAEiIiIyUqohMH0XbWzevBlhYWGIiIjAiRMn0LRpUwQFBeH27duF1o+Pj8eAAQNw4MABJCQkwN3dHV26dMHNmzcNcQh0xgSIiIjIWAkDLVpYsGABRo4ciZCQEPj4+CAmJgY2NjZYuXJlofU3bNiADz74AH5+fmjQoAG+//57KJVKxMXFab+/BsQEiIiIyFiprgSt71JCBQUFSExMRGBgoFRmZmaGwMBAJCQklKiNvLw8PH78GNWqVdN6dw2Jk6CJiIgI2dnZao/lcjnkcrlaWWZmJhQKBZydndXKnZ2dcfHixRJt59NPP4Wbm5taElUe2ANERERkpFRXgtZ3AQB3d3c4ODhIS1RUlMHjnT17NjZt2oTt27fDysrK4O1rgz1ARERExsqAN0NNS0uDvb29VPx87w8AODo6wtzcHBkZGWrlGRkZcHFxKXYz8+fPx+zZs7F//340adJEv5gNgD1AREREBHt7e7WlsATI0tISzZs3V5vArJrQ3KpVqyLbnjt3LmbMmIHY2Fi0aNGiVOLXFnuAiIiIjJRM+XTRtw1thIWFYejQoWjRogVatmyJ6Oho5ObmIiQkBAAwZMgQ1KxZUxpCmzNnDqZOnYqNGzfC09MT6enpAIDKlSujcuXK+gWvByZARERExsqAQ2Al1a9fP9y5cwdTp05Feno6/Pz8EBsbK02Mvn79OszM/jfAtGzZMhQUFODdd99VayciIgLTpk3TL3Y9MAEiIiIirYSGhiI0NLTQ5+Lj49Uep6amln5AOmACREREZKx0uJBhoW2YICZARERERop3g9cdzwIjIiIik8MeICIiImNVDpOgXxYVqgdICIGpU6fC1dUV1tbWCAwMxJUrV4pdx9PTEzKZTGMZN26cVKdDhw4az48ZM6a0d4eIiKh0CQBKPRfTzH8qVgI0d+5cLFy4EDExMTh27BhsbW0RFBSER48eFbnOX3/9hVu3bknLvn37AAB9+/ZVqzdy5Ei1enPnzi3VfSEiIiptqjlA+i6mqMIMgQkhEB0djSlTpqB3794AgLVr18LZ2Rk7duxA//79C12vRo0aao9nz54Nb29vBAQEqJXb2Ni88DLdxuwNs74vrqSFfcqtBm2PiIioIqkwPUApKSlIT09Xuzusg4MD/P39kZCQUKI2CgoKsH79egwbNgwymUztuQ0bNsDR0RGNGjVCeHg48vLyDBo/ERFRmRP43zwgnZfy3onyUWF6gFSXxlZdSVLF2dlZeu5FduzYgfv37yM4OFitfODAgfDw8ICbmxtOnz6NTz/9FJcuXcK2bduKbCs/Px/5+fnS4+zs7BLuCRERURnhJGidlVsCtGHDBowePVp6vGvXLr3bXLFiBbp16wY3Nze18lGjRkn/bty4MVxdXdG5c2ckJyfD29u70LaioqIQGRmpd0xERERU8ZTbEFivXr1w6tQpaXF0dAQAZGRkqNXLyMgo0dyda9euYf/+/RgxYsQL6/r7+wMAkpKSiqwTHh6OrKwsaUlLS3thu0RERGVK3zPAVIsJKrceIDs7O9jZ2UmPhRBwcXFBXFwc/Pz8ADwddjp27BjGjh37wvZWrVoFJycn9OjR44V1T506BQBwdXUtso5cLodcLn9hW0REROWFV4LWXYWZBC2TyTBhwgTMnDkTO3fuxJkzZzBkyBC4ubmhT58+Ur3OnTtj8eLFausqlUqsWrUKQ4cORaVK6jldcnIyZsyYgcTERKSmpmLnzp0YMmQI2rdvjyZNmpTFrhEREVEFU2EmQQPApEmTkJubi1GjRuH+/fto27YtYmNjYWVlJdVJTk5GZmam2nr79+/H9evXMWzYMI02LS0tsX//fkRHRyM3Nxfu7u545513MGXKlFLfHyIiolLFSdA6kwlhonuupezsbDg4OCArKwv29vblHY4GXgeIiKjiKO3fDFX7nX0mopK5ftM1nijyEXd+foX9fSstFWYIjIiIiKisVKghMCIiItICh8B0xgSIiIjIWCkByF5Y68VtmCAmQEREREaKp8HrjnOAiIiIyOSwB4iIiMhYcQ6QzpgAERERGSulAGR6JjBK00yAOARGREREJoc9QERERMaKQ2A6YwJERERktAyQAIEJEJUxQ96+greuICIiKjkmQERERMaKQ2A6YwJERERkrJQCeg9h8SwwIiIiItPAHiAiIiJjJZRPF33bMEFMgIiIiIwV5wDpjAkQERGRseIcIJ1xDhARERGZHPYAERERGSsOgemMCRAREZGxEjBAAmSQSIwOh8CIiIjI5LAHiIiIyFhxCExnTICIiIiMlVIJQM/r+ChN8zpAHAIjIiIik8MeICIiImPFITCdMQEiIiIyVkyAdMYhMCIiIjI57AEiIiIyVrwVhs6YAGmpt8MQVJJZGKStfcqtBmmHiIhMkxBKCD3v5q7v+saKCRAREZGxEkL/HhzOASIiIiIyDewBIiIiMlbCAHOATLQHiAkQERGRsVIqAZmec3hMdA6QSQyBbdu2DV26dEH16tUhk8lw6tSp8g6JiIiIypFJJEC5ublo27Yt5syZU96hEBERGY7qQoj6LibIJIbABg8eDABITU0t30CIiIgMSCiVEHoOgfE0eFKTn5+P/Px86XF2dnY5RkNERESGZBJDYLqIioqCg4ODtLi7u5d3SEREROo4BKazly4B2rBhAypXriwtf/75p07thIeHIysrS1rS0tIMHCkREZGelMIwiwl66YbAevXqBX9/f+lxzZo1dWpHLpdDLpcbKiwiIiKqQF66BMjOzg52dnblHQYREVHpEwKAvtcBYg/QS+vevXu4fv06/v33XwDApUuXAAAuLi5wcXEpz9CIiIh0JpQCQqZfAiNMNAF66eYAFWbnzp1o1qwZevToAQDo378/mjVrhpiYmHKOjIiISA9CaZhFS0uWLIGnpyesrKzg7++P48ePl8LOlS6TSICCg4MhhNBYpk2bVt6hERERGZXNmzcjLCwMEREROHHiBJo2bYqgoCDcvn27vEPTikkkQERERC8joRQGWbSxYMECjBw5EiEhIfDx8UFMTAxsbGywcuXKUtrL0sEEiIiIyFiV8RBYQUEBEhMTERgYKJWZmZkhMDAQCQkJpbGHpcYkJkEbgmqS2BM8Bgw0X4xXlyYiejmpvt9Le4KxIX6TnuAxAM3fpMIuB5OZmQmFQgFnZ2e1cmdnZ1y8eFG/QMoYE6ASevDgAQDgEHYbrE0HBweDtUVERBXPgwcPSuW73tLSEi4uLjiUbpjfpMqVK2vc8SAiIuKlnivLBKiE3NzckJaWBjs7O8hksiLrZWdnw93dHWlpabC3ty/DCPXH2MsHYy8fjL38GHP8JY1dCIEHDx7Azc2tVOKwsrJCSkoKCgoKDNKeEELjt62wiwE7OjrC3NwcGRkZauUZGRlGd1kZJkAlZGZmhlq1apW4vr29vdF9sFUYe/lg7OWDsZcfY46/JLGXdi+/lZUVrKysSnUbz7O0tETz5s0RFxeHPn36AACUSiXi4uIQGhpaprHoiwkQERERlVhYWBiGDh2KFi1aoGXLloiOjkZubi5CQkLKOzStMAEiIiKiEuvXrx/u3LmDqVOnIj09HX5+foiNjdWYGF3RMQEyMLlcjoiICKO8kSpjLx+MvXww9vJjzPEbc+yGFBoaanRDXs+TCVO9CQgRERGZLF4IkYiIiEwOEyAiIiIyOUyAiIiIyOQwASIiIiKTwwTIgLZt24YuXbqgevXqkMlkOHXqVHmHBCEEpk6dCldXV1hbWyMwMBBXrlwpdh1PT0/IZDKNZdy4cVKdDh06aDw/ZsyYCrcv06ZN04izQYMGpRqnrrFGRUXhtddeg52dHZycnNCnTx9cunRJrU55HPfiLFmyBJ6enrCysoK/vz+OHz9ebrFoG8/y5cvRrl07VK1aFVWrVkVgYKBG/eDgYI3j3bVr19LeDQDa7cvq1as14izLC+RpE2th72GZTIYePXpIdcrzuBfljz/+QM+ePeHm5gaZTIYdO3aUazykPyZABpSbm4u2bdtizpw55R2KZO7cuVi4cCFiYmJw7Ngx2NraIigoCI8ePSpynb/++gu3bt2Sln379gEA+vbtq1Zv5MiRavXmzp1b4fYFAHx9fdXiPHToUKnGqWusBw8exLhx43D06FHs27cPjx8/RpcuXZCbm6tWr6yPe1E2b96MsLAwRERE4MSJE2jatCmCgoJw+/Zto4gnPj4eAwYMwIEDB5CQkAB3d3d06dIFN2/eVKvXtWtXteP9ww8/VLh9AZ5emfjZOK9du1bqceoS67Zt29TiPHv2LMzNzTW+X8rjuBcnNzcXTZs2xZIlS8o1DjIgQQaXkpIiAIiTJ0+WaxxKpVK4uLiIefPmSWX3798Xcrlc/PDDDyVu58MPPxTe3t5CqVRKZQEBAeLDDz80ZLjF0nVfIiIiRNOmTcsgwv8x1HG/ffu2ACAOHjwolZX1cS9Oy5Ytxbhx46THCoVCuLm5iaioKKOM58mTJ8LOzk6sWbNGKhs6dKjo3bu3oUN9IW33ZdWqVcLBwaGMolOn73H/+uuvhZ2dncjJyZHKyuu4lxQAsX379vIOg/TEHqCXWEpKCtLT0xEYGCiVOTg4wN/fHwkJCSVqo6CgAOvXr8ewYcM0bpS3YcMGODo6olGjRggPD0deXp5B43+WPvty5coVuLm5oU6dOhg0aBCuX79eanHqG+uzsrKyAADVqlVTKy/L416UgoICJCYmqu2jmZkZAgMDtdrHihRPXl4eHj9+rHG84+Pj4eTkhPr162Ps2LG4e/euQWN/nq77kpOTAw8PD7i7u6N37944d+5cqcapT6zPWrFiBfr37w9bW1u18rI+7mR6eCXol1h6ejoAaFye3NnZWXruRXbs2IH79+8jODhYrXzgwIHw8PCAm5sbTp8+jU8//RSXLl3Ctm3bDBL783TdF39/f6xevRr169fHrVu3EBkZiXbt2uHs2bOws7OrULE+S6lUYsKECWjTpg0aNWoklZf1cS9KZmYmFApFoft48eLFMo3FUPF8+umncHNzU/sx79q1K95++214eXkhOTkZn332Gbp164aEhASYm5sbdB9UdNmX+vXrY+XKlWjSpAmysrIwf/58tG7dGufOndPqJs5lEeuzjh8/jrNnz2LFihVq5eVx3Mn0MAHS0YYNGzB69Gjp8W+//YZ27dqVY0SaMe3atUvvNlesWIFu3brBzc1NrXzUqFHSvxs3bgxXV1d07twZycnJ8Pb21nu7htqXbt26Sf9u0qQJ/P394eHhgS1btmD48OF6xwmUznEfN24czp49qzFfqbSPu6maPXs2Nm3ahPj4eLXJw/3795f+3bhxYzRp0gTe3t6Ij49H586dyyPUQrVq1QqtWrWSHrdu3RoNGzbEt99+ixkzZpRjZMVbsWIFGjdujJYtW6qVG8txJ+PGBEhHvXr1gr+/v/S4Zs2a5RjNU8/HlJ+fDwDIyMiAq6urVJ6RkQE/P78Xtnft2jXs37+/RL0Lqu0mJSUZ5IfY0PuiUqVKFdSrVw9JSUl6x1hasYaGhuLXX3/FH3/88cK/3g193EvK0dER5ubmyMjIUCvPyMiAi4tLmcVhiHjmz5+P2bNnY//+/WjSpEmxdevUqQNHR0ckJSWV2g+xIY6thYUFmjVrZtD3eWH0iTU3NxebNm3C9OnTX7idsjjuZHo4B0hHdnZ2qFu3rrRYW1uXd0gaMfn4+MDFxQVxcXFSnezsbBw7dkztr8WirFq1Ck5OTmqnpxZFdcr/sz/4+jD0vqjk5OQgOTnZYHEaMlYhBEJDQ7F9+3b8/vvv8PLyeuG2DX3cS8rS0hLNmzdX20elUom4uDitXo/yjmfu3LmYMWMGYmNj0aJFixdu58aNG7h7926pHm9DHFuFQoEzZ86U+vtCn1i3bt2K/Px8vP/++y/cTlkcdzJB5T0L+2Vy9+5dcfLkSbFr1y4BQGzatEmcPHlS3Lp1q9ximj17tqhSpYr4+eefxenTp0Xv3r2Fl5eXePjwoVSnU6dOYtGiRWrrKRQKUbt2bfHpp59qtJmUlCSmT58u/v77b5GSkiJ+/vlnUadOHdG+ffsKty8ff/yxiI+PFykpKeLw4cMiMDBQODo6itu3b1e4WMeOHSscHBxEfHy8uHXrlrTk5eUJIcrvuBdl06ZNQi6Xi9WrV4vz58+LUaNGiSpVqoj09PQKGc/gwYPF5MmTpfqzZ88WlpaW4scff1Q73g8ePBBCCPHgwQMxceJEkZCQIFJSUsT+/fvFq6++Kl555RXx6NGjCrUvkZGRYs+ePSI5OVkkJiaK/v37CysrK3Hu3LlSjVOXWFXatm0r+vXrp1Fense9OA8ePBAnT54UJ0+eFADEggULxMmTJ8W1a9fKLSbSDxMgA1q1apUAoLFERESUW0xKpVJ88cUXwtnZWcjlctG5c2dx6dIltToeHh4aMe7Zs0cA0KgrhBDXr18X7du3F9WqVRNyuVzUrVtXfPLJJyIrK6s0d0WnfenXr59wdXUVlpaWombNmqJfv34iKSmpVOPUNdbC3jsAxKpVq4QQ5Xfci7No0SJRu3ZtYWlpKVq2bCmOHj1abrG8KJ6AgAAxdOhQ6bGHh0exn9e8vDzRpUsXUaNGDWFhYSE8PDzEyJEjyyzB02ZfJkyYINV1dnYW3bt3FydOnCiTOLWNVQghLl68KACIvXv3arRV3se9KAcOHCj0/fL8vpHxkAkhRJl1NxERERFVAJwDRERERCaHCRARERGZHCZAREREZHKYABEREZHJYQJEREREJocJEBEREZkcJkBERERkcpgAERERkclhAkREBrF69WpUqVKl1NofPHgwZs2apdU6sbGx8PPzg1KpLKWoiMhYMQEiqqDS09Px4Ycfom7durCysoKzszPatGmDZcuWIS8vr8TtlHZioo1z587hnXfegaenJ2QyGaKjo0u03j///IPdu3dj/PjxAIDGjRtjzJgxhdZdt24d5HI5MjMz0bVrV1hYWGDDhg2G2gUiekkwASKqgK5evYpmzZph7969mDVrFk6ePImEhARMmjQJv/76K/bv31/eIeokLy8PderUwezZs+Hi4lLi9RYtWoS+ffuicuXKAIDhw4dj06ZNePjwoUbdVatWoVevXnB0dAQABAcHY+HChYbZASJ6eZT3zciISFNQUJCoVauWyMnJKfR5pVIp/furr74SjRo1EjY2NqJWrVpi7Nix0h3NC7uBo+pmn48ePRIff/yxcHNzEzY2NqJly5biwIEDxcb133//iVGjRgknJychl8uFr6+v+OWXX4QQT28G7ODgIGJjY0WDBg2Era2tCAoKEv/++2+hbXl4eIivv/76hcfiyZMnwsHBQfz6669S2Z07d4SlpaVYt26dWt2rV68KmUwmfvvtN6ns2rVrAkCZ3ASXiIwHe4CIKpi7d+9i7969GDduHGxtbQutI5PJpH+bmZlh4cKFOHfuHNasWYPff/8dkyZNAgC0bt0a0dHRsLe3x61bt3Dr1i1MnDgRABAaGoqEhARs2rQJp0+fRt++fdG1a1dcuXKl0G0qlUp069YNhw8fxvr163H+/HnMnj0b5ubmUp28vDzMnz8f69atwx9//IHr169L29PV6dOnkZWVhRYtWkhljo6O6N27N1auXKlWd/Xq1ahVqxa6dOkildWuXRvOzs74888/9YqDiF4y5Z2BEZG6o0ePCgBi27ZtauXVq1cXtra2wtbWVkyaNKnI9bdu3SqqV68uPVb1zDzr2rVrwtzcXNy8eVOtvHPnziI8PLzQdvfs2SPMzMzEpUuXCn1+1apVGj0tS5YsEc7OzoXWL2kP0Pbt24W5ublar5cQQsTGxgqZTCauXr0qhHjaK+bh4SGmTJmi0UazZs3EtGnTXrgtIjIdlco7ASOikjl+/DiUSiUGDRqE/Px8qXz//v2IiorCxYsXkZ2djSdPnuDRo0fIy8uDjY1NoW2dOXMGCoUC9erVUyvPz89H9erVC13n1KlTqFWrlsY6z7KxsYG3t7f02NXVFbdv39ZmNzU8fPgQcrlcrdcLAN544w3UqlULq1atwvTp0xEXF4fr168jJCREow1ra2utJo4T0cuPCRBRBVO3bl3IZDJcunRJrbxOnToAnv6Yq6SmpuLNN9/E2LFj8eWXX6JatWo4dOgQhg8fjoKCgiIToJycHJibmyMxMVFtCAuANNH4ec9utygWFhZqj2UyGYQQL1yvOI6OjsjLy0NBQQEsLS2lcjMzMwQHB2PNmjWYNm0aVq1ahY4dO0rH6Vn37t1DjRo19IqDiF4unANEVMFUr14db7zxBhYvXozc3Nxi6yYmJkKpVOKrr77C66+/jnr16uHff/9Vq2NpaQmFQqFW1qxZMygUCty+fRt169ZVW4o6O6tJkya4ceMGLl++rN8OasnPzw8AcP78eY3nQkJCkJaWhm3btmH79u0YPny4Rp1Hjx4hOTkZzZo1K+1QiciIMAEiqoCWLl2KJ0+eoEWLFti8eTMuXLiAS5cuYf369bh48aLUa1O3bl08fvwYixYtwtWrV7Fu3TrExMSoteXp6YmcnBzExcUhMzMTeXl5qFevHgYNGoQhQ4Zg27ZtSElJwfHjxxEVFYVdu3YVGlNAQADat2+Pd955B/v27UNKSgp+++03xMbGlni/CgoKcOrUKZw6dQoFBQW4efMmTp06haSkpCLXqVGjBl599VUcOnRI4zkvLy906tQJo0aNglwux9tvv61R5+jRo5DL5WjVqlWJ4yQiE1Dek5CIqHD//vuvCA0NFV5eXsLCwkJUrlxZtGzZUsybN0/k5uZK9RYsWCBcXV2FtbW1CAoKEmvXrhUAxH///SfVGTNmjKhevbraafAFBQVi6tSpwtPTU1hYWAhXV1fx1ltvidOnTxcZ0927d0VISIioXr26sLKyEo0aNZJOTy9ssvX27dvFs18zKSkpGqflAxABAQHFHoulS5eK119/vdDnNm7cKACIDz74oNDnR40aJUaPHl1s+0RkemRC6DlAT0RUyh4+fIj69etj8+bNWvXkZGZmon79+vj777/h5eVVihESkbHhEBgRVXjW1tZYu3YtMjMztVovNTUVS5cuZfJDRBrYA0REREQmhz1AREREZHKYABEREZHJYQJEREREJocJEBEREZkcJkBERERkcpgAERERkclhAkREREQmhwkQERERmRwmQERERGRy/j/h8o494ZWbhgAAAABJRU5ErkJggg==\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1468,21 +1554,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 222. \n",
-      "Starting experimental run with id: 223. \n"
+      "Starting experimental run with id: 77. Using 'qcodes.dataset.dond'\n",
+      "Starting experimental run with id: 78. Using 'qcodes.dataset.dond'\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c317733a64cb4b95849e75f21c94c4b0",
+       "model_id": "f7be54b0e0ab4020a7e57bd0e43d2229",
        "version_major": 2,
        "version_minor": 0
       },
@@ -1495,7 +1581,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1505,7 +1591,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxcElEQVR4nO3dd3gU1foH8O/sJtn0TQ9pJCSUQKhSQhXUQFBE8F6aKM2Kgg1FwKsg4qWIerlSlauACoL4Q7EgCEgRCCK9hxZIKKmQ3nfP74+wQ5YUUjaZ7O738zz7QGZndt7Z2Z28OeedcyQhhAARERGRhVApHQARERGRKTG5ISIiIovC5IaIiIgsCpMbIiIisihMboiIiMiiMLkhIiIii8LkhoiIiCwKkxsiIiKyKExuiIiIyKIwuSGqQEhICMaOHat0GPVi7NixCAkJUTSG9957D5IkKRoDkYFer0fr1q3x73//W+lQzEZNr5lpaWlwcnLCpk2bTBYLk5u7rFy5EpIkyQ8bGxsEBARg7NixuHbtmtLhAQDS09OhUqmwZcsWAMAPP/wAjUaDgoICo/XGjh1rdCx3P0ofj16vx7Jly9C+fXs4OzvD19cXDz/8MPbt21fjOPv06VPhvsPDw2v8unTH6dOn8d577+Hy5cuKxRASEgJJkvDyyy+XeW7nzp2QJAnff/+9yffbtm1bNG7cGJXNINOjRw/4+vqiuLgYAJCSkoJXX30V4eHhcHBwgI+PD7p06YIpU6YgOzu7yvs2HJckSfjmm28q3LckSWjdunX1DoxMbtOmTXjvvfeqtc23336LhIQETJw4sW6CIpmnpyeeffZZvPvuuyZ7TRuTvZKFef/999GkSRPk5+dj//79WLlyJfbs2YOTJ0/C3t5e0dgOHDgAAIiMjAQAxMTEoEOHDtBoNEbrvfDCC4iKijJaJoTA+PHjERISgoCAAHn55MmT8cknn+Cpp57CSy+9hPT0dHz22Wfo3bs39u7diy5dutQo1sDAQMyZM6fMcq1WW6PXq0+xsbFQqRp2/n/69GnMnDkTffr0UbzlZfny5Zg2bRr8/f3rZX9PPvkkpk6dij///BP3339/mecvX76MmJgYTJw4ETY2Nrh58yY6deqEzMxMPP300wgPD0daWhqOHz+OpUuX4sUXX4Szs3O1YrC3t8eaNWvw1FNPldn3vn37FL9WUIlNmzZh8eLF1Upw5s+fjxEjRpjFtcoSjB8/Hp9++in++OMPPPjgg7V+PSY3FXj44YfRqVMnAMCzzz4LLy8vzJs3Dz/99BOGDRumaGwHDhxAixYt4ObmBqAkuTEkOqV169YN3bp1M1q2Z88e5Obm4sknn5SXFRcXY+nSpRgyZAi+/vprefnQoUMRGhqK1atX1zi50Wq1ZS78DZkQAvn5+XBwcCiTLFLFIiIiEBsbi7lz5+LTTz+tl32OHDkS06ZNw5o1a8pNbr799lsIIeTP+hdffIH4+Hjs3bsX3bt3N1o3MzMTdnZ21Y7hkUcewU8//YTU1FR4eXnJy9esWQNfX180a9YMt27dqvbrNiQ5OTlwcnJSOox6deTIERw7dgwff/yx0qFYjZYtW6J169ZYuXKlSZKbhv1naQPSq1cvAMDFixflZX369EGfPn3KrHt3/cLly5chSRI++ugjfP755wgLC4NGo0Hnzp3x999/V2n/GRkZSE1NRWpqKmJiYtCuXTukpqYiKSkJhw4dQnh4OFJTU5GRkVHp66xZswaSJGHkyJHysqKiIuTl5cHX19doXR8fH6hUKjg4OFQpxprIy8tDeHg4wsPDkZeXJy+/efMm/Pz80L17d+h0OgAl76uzszMuXbqE6OhoODk5wd/fH++//36Zrgm9Xo8FCxYgIiIC9vb28PX1xQsvvFDmF01ISAgeffRRbNmyBZ06dYKDgwM+++wz+bnS/ceGLss9e/bglVdegbe3N9zc3PDCCy+gsLAQ6enpGD16NNzd3eHu7o633nqr1nHt2bMHXbp0gb29PUJDQ/HVV18ZxTN06FAAwAMPPCB3k+zcubPS9/zHH39E69atYW9vj9atW+OHH34od72cnBy88cYbCAoKgkajQYsWLfDRRx+V2w0UEhKC0aNHY/ny5bh+/Xql+wdKkuzOnTvD3t4eYWFh8nteHUFBQbj//vvx/fffo6ioqMzza9asQVhYmJz4X7x4EWq1Gl27di2zrqura41aWQYNGgSNRoP169eX2fewYcOgVqvL3e6bb75Bx44d4eDgAA8PD4wYMQIJCQlG6/z5558YOnQoGjduDI1Gg6CgILz++utG3xMASExMxLhx4xAYGAiNRgM/Pz8MGjTIqKtSkqRyWy0q+ozv2rULL730Enx8fBAYGCg//9tvv6FXr15wcnKCi4sLBgwYgFOnThm9puF7Gh8fj0cffRTOzs4ICAjA4sWLAQAnTpzAgw8+CCcnJwQHB2PNmjVl4kpPT8drr70mf/aaNm2KefPmQa/Xy+tU9bo6duxYed+lu8Yr8+OPP8LOzq5M0myoC7tw4QLGjh0LNzc3aLVajBs3Drm5uUbrFhcXY9asWXJcISEhePvtt8uUD5SnKud048aNGDBgAPz9/aHRaBAWFoZZs2bJ10uDPn36oHXr1jh+/Dh69+4NR0dHNG3aVO4q3rVrFyIjI+Hg4IAWLVpg27Zt5R7z2bNnMWzYMLi6usLT0xOvvvoq8vPz73ksVTmXBn379sXPP/9caVdzlQkysmLFCgFA/P3330bLFy1aJACIpUuXyst69+4tevfuXeY1xowZI4KDg+Wf4+LiBADRoUMH0bRpUzFv3jzx4YcfCi8vLxEYGCgKCwvvGVfv3r0FgHs+yovHoLCwUHh6eooePXqUeS4yMlI4OTmJb775Rly5ckUcO3ZMDBkyRHh6eoqLFy/eM76KYg4PDxcpKSllHtnZ2fJ6+/fvF2q1Wrz++uvyshEjRggHBwcRGxsrLxszZoywt7cXzZo1E6NGjRKLFi0Sjz76qAAg3n33XaN9P/vss8LGxkY899xzYtmyZWLKlCnCyclJdO7c2ej9Dg4OFk2bNhXu7u5i6tSpYtmyZWLHjh3yc2PGjJHXNXw22rdvL/r37y8WL14sRo0aJQCIt956S/Ts2VOMHDlSLFmyRI5r1apVNY6rRYsWwtfXV7z99tti0aJF4r777hOSJImTJ08KIYS4ePGieOWVVwQA8fbbb4uvv/5afP311yIxMbHCc7JlyxahUqlE69atxSeffCL+9a9/Ca1WKyIiIow+s3q9Xjz44INCkiTx7LPPikWLFomBAwcKAOK1114zes3g4GAxYMAAcfHiRWFjYyNefvll+bkdO3YIAGL9+vXysuPHjwsHBwfRuHFjMWfOHDFr1izh6+sr2rZtK6p7Sfr8888FAPHzzz8bLT9+/LgAIKZPny4vmz17tgAgVq5cWa19lKf0cY0cOVL06tVLfu7o0aMCgIiJiRG9e/cWERERRtt+8MEHQpIkMXz4cLFkyRIxc+ZM4eXlJUJCQsStW7fk9V5++WXxyCOPiNmzZ4vPPvtMPPPMM0KtVoshQ4YYvV737t2FVqsV77zzjvjf//4nZs+eLR544AGxa9cueR0AYsaMGWWOo6LPeKtWrUTv3r3FwoULxdy5c4UQQnz11VdCkiTRv39/sXDhQjFv3jwREhIi3NzcRFxcnPwahu9pq1atxPjx48XixYtF9+7dBQCxYsUK4e/vLyZPniwWLlwoIiIihFqtFpcuXZK3z8nJEW3bthWenp7i7bffFsuWLROjR48WkiSJV199VV6vqtfVffv2ib59+woA8nfk66+/rvT8RkVFifvuu6/M8hkzZsj7/Mc//iGWLFkinn32WfkaUNqYMWMEADFkyBCxePFiMXr0aAFADB48uNJ9C1G1czp48GAxbNgwMX/+fLF06VIxdOhQAUC8+eabRq/Vu3dv4e/vL4KCguT3vVWrVkKtVou1a9eKRo0aiffee08sWLBABAQECK1WKzIzM8scc5s2bcTAgQPFokWLxFNPPSUAiFGjRhnt6+7PU1XPpcE333wjAIgTJ07c8z26FyY3dzF8ubdt2yZSUlJEQkKC+P7774W3t7fQaDQiISFBXre6yY2np6e4efOmvHzjxo3lXpjLc/DgQbF161axePFiAUB88803YuvWrWLs2LEiKChIbN26VWzdulUcPHiwwtf4+eefBQCxZMmSMs+dP39e3HfffUaJUmhoqDh79uw9Y6tIZQnZCy+8YLTutGnThEqlErt37xbr168XAMSCBQuM1jFcLEr/8tTr9WLAgAHCzs5OpKSkCCGE+PPPPwUAsXr1aqPtN2/eXGZ5cHCwACA2b95cJv6KLvzR0dFCr9fLy7t16yYkSRLjx4+XlxUXF4vAwECjz0dN4tq9e7e8LDk5WWg0GvHGG2/IywzvlSEhu5f27dsLPz8/kZ6eLi/7/fffBQCjz+yPP/4oAIgPPvjAaPshQ4YISZLEhQsXjGIdMGCAEEKIcePGCXt7e3H9+nUhRPnJzeDBg4W9vb24cuWKvOz06dNCrVZXO7m5efOm0Gg04oknnjBaPnXqVAHAKDlOTEwU3t7eAoAIDw8X48ePF2vWrDF6L6qq9HH98ssvQpIkER8fL4QQYvLkySI0NFQIIcokN5cvXxZqtVr8+9//Nnq9EydOCBsbG6Plubm5ZfY7Z84cIUmS/N7dunVLABDz58+vNN7qJjc9e/YUxcXF8vKsrCzh5uYmnnvuOaPtExMThVarNVpu+J7Onj1bXnbr1i3h4OAgJEkSa9eulZefPXu2TGyzZs0STk5O4ty5c0b7mjp1qlCr1fL7XJ3r6oQJE6r12QoMDBT//Oc/yyw3/KJ/+umnjZY//vjjwtPTU/7ZkOA+++yzRuu9+eabAoD4448/Ktx3Vc9peZ+PF154QTg6Oor8/Hx5meE6vGbNGnmZ4X1XqVRi//798vItW7bISejdx/zYY48Z7eull14SAMSxY8fkZXd/nqp6Lg327dsnAIh169ZVeuxVwW6pCkRFRcHb2xtBQUEYMmQInJyc8NNPPxk10VbX8OHD4e7uLv9s6Oq6dOnSPbft2LEjoqKiUFxcDH9/fzz55JOIiopCSkoKHnroIURFRSEqKgodO3as8DXWrFkDW1vbcmuGXFxcEBERgQkTJmDDhg1YsmQJiouLMXjwYKSmptbgaEuEhIRg69atZR6vvfaa0XrvvfceIiIiMGbMGLz00kvo3bs3XnnllXJfs/TdC5IkYeLEiSgsLJSbU9evXw+tVou+ffvKXXmpqano2LEjnJ2dsWPHDqPXa9KkCaKjo6t8TM8884xRs3ZkZCSEEHjmmWfkZWq1Gp06dTI6t9WNq1WrVvJnBAC8vb3RokWLKn1eynPjxg0cPXoUY8aMMSqS7Nu3L1q1amW07qZNm6BWq8ucgzfeeANCCPz222/l7uOdd95BcXEx5s6dW+7zOp0OW7ZsweDBg9G4cWN5ecuWLat1Dgzc3d3lupecnBwAJXVTa9euRadOndC8eXN5XV9fXxw7dgzjx4/HrVu3sGzZMowcORI+Pj6YNWtWjZvC+/XrBw8PD6xdu1be9xNPPFHuuhs2bIBer8ewYcOMPgONGjVCs2bNjD4DpbuDc3JykJqaiu7du0MIgSNHjsjr2NnZYefOnSat7XnuueeMutS2bt2K9PR0PPHEE0Zxq9VqREZGlvnsAiW1igZubm5o0aIFnJycjK4/htrBu78nvXr1gru7u9G+oqKioNPpsHv3bqP91Oa6WpG0tDSj17zb+PHjjX7u1asX0tLSkJmZCQDyLc2TJk0yWu+NN94AAPz6668VvnZVz2npz0dWVhZSU1PRq1cv5Obm4uzZs0brOjs7Y8SIEfLPhve9ZcuWRvWahv+X995NmDDB6GfD3ZGV3b5d3XNpeM9r8zvHgAXFFVi8eDGaN2+OjIwMfPnll9i9e3etC0xLX8yBOyfyXhel7OxsuW9z69at6Nq1K1JTU6HX6/Hnn3/igw8+kC80FX0hs7OzsXHjRkRHR8PT09PoueLiYkRFRaFPnz5YuHChvDwqKgoRERGYP38+5s2bV+3jBQAnJ6cyd2yVx87ODl9++aVch7FixYpy+8VVKhVCQ0ONlhl+gRn6o8+fP4+MjAz4+PiUu6/k5GSjn5s0aVKVQ5HdfR4NiUJQUFCZ5aXPbXXjuns/QMlnpqa/xK5cuQIAaNasWZnnWrRogcOHDxut6+/vDxcXF6P1WrZsafRadwsNDcWoUaPw+eefY+rUqWWeT0lJQV5eXoUx1GSciyeffBI//PADNm7ciJEjR2Lfvn24fPkyXn311TLr+vn5YenSpViyZAnOnz+PLVu2YN68eZg+fTr8/PyMfiFXla2tLYYOHYo1a9agS5cuSEhIMKppK+38+fMQQpR7/IbXMoiPj8f06dPx008/lTnnhto6jUaDefPm4Y033oCvry+6du2KRx99FKNHj0ajRo2qfSwGd38nzp8/DwAVFnq6uroa/Wxvbw9vb2+jZVqtFoGBgWW+1+V9T44fP15me4N7fU+qel29l8qS3cr26erqiitXrkClUqFp06ZG6zVq1Ahubm4Vfn+Aqp/TU6dO4Z133sEff/whJ1UGd9deVvS+l3fNMhzH3e7+zIaFhUGlUlU6DEV1z6XhPTfFeFdMbirQpUsX+W6pwYMHo2fPnhg5ciRiY2Pl20UlSSr3C3B3QZdBRcWF9/qLceLEiVi1apXRsg0bNsj/f+WVV/DKK68gODi4wg/ajz/+WOYuKYPdu3fj5MmT+OSTT4yWN2vWDC1btsTevXsrjc9UDOP25Ofn4/z589VOOgz0ej18fHywevXqcp+/+4tW3YLpis5jectLn9vqxlXTz4vS/vWvf+Hrr7/GvHnzMHjw4Drf36OPPgqtVos1a9Zg5MiRWLNmDdRqtdFfqneTJAnNmzdH8+bNMWDAADRr1gyrV6+uUXIDlNy5tWzZMrz33nto165dmZYwA71eD0mS8Ntvv5V7fg3XFp1Oh759++LmzZuYMmUKwsPD4eTkhGvXrmHs2LFGxZivvfYaBg4ciB9//BFbtmzBu+++izlz5uCPP/5Ahw4dKo27omvV3d8Jw/6+/vrrcpMmGxvjXyXV+Y4AZb8nffv2xVtvvVXuuqVb46r6mtXl6elZaXJU1X3W9Jf0vc5peno6evfuDVdXV7z//vsICwuDvb09Dh8+jClTppQp1q3N+ahIVY6tuufS8J6XvvOwppjcVIFarcacOXPwwAMPYNGiRfJfpO7u7uU231WWldfEW2+9haeeegpxcXF4/vnn8dVXX8HPzw/fffcdNm3ahJUrVwKo/Jf06tWr4ezsjMcee6zMc0lJSQDKv9AVFRXJA6DVpePHj+P999/HuHHjcPToUTz77LM4ceJEmTEm9Ho9Ll26ZPSlOHfuHADId6iFhYVh27Zt6NGjR53e6VVddRFXdS6ewcHBAO78FV5abGxsmXW3bduGrKwso9YbQ3O34bXKExYWhqeeegqfffZZmSEKvL294eDgUKUYqkqj0WDIkCH46quvkJSUhPXr1+PBBx+scstFaGgo3N3dcePGjRrtHwB69uyJxo0bY+fOnZW2coaFhUEIgSZNmpS5sJd24sQJnDt3DqtWrcLo0aPl5Vu3bq3wdd944w288cYbOH/+PNq3b4+PP/5YHmDQ3d0d6enpRtsUFhZW+ZjDwsIAlNxBWZWW2NoICwtDdna2SfdT3SQjPDwccXFxNd5fcHAw9Ho9zp8/L7d2AiXX2vT09Eq/PwaVndOdO3ciLS0NGzZsMLqjqzYx38vdf3BeuHABer2+0vG1qnsuDfGXfs9qijU3VdSnTx906dIFCxYskLuIwsLCcPbsWaSkpMjrHTt2zOQtHa1atUJUVBRsbGzg7u6Op556ClFRUcjMzETPnj3lepsePXqUu31KSgq2bduGxx9/HI6OjmWeN1xk165da7T88OHDiI2Nvedff7VVVFSEsWPHwt/fH//973+xcuVKJCUl4fXXXy93/UWLFsn/F0Jg0aJFsLW1xUMPPQQAGDZsGHQ6HWbNmlVm2+Li4jIX+fpSF3EZxh+pyrZ+fn5o3749Vq1aZdRsvXXrVpw+fdpo3UceeQQ6nc7ovQaA//znP5AkCQ8//HCl+3rnnXdQVFSEDz/80Gi5Wq1GdHQ0fvzxR8THx8vLz5w5I7fc1cSTTz6JoqIivPDCC0hJSSm3hfKvv/6S63JKO3DgANLS0tCiRYsa71+SJHz66aeYMWMGRo0aVeF6//jHP6BWqzFz5swyfx0LIZCWlgbgzl/UpdcRQuC///2v0Ta5ubllbscNCwuDi4uL0S3HYWFhZeobPv/88wpbbu4WHR0NV1dXzJ49u9zb7ktfA2tr2LBhiImJKffzkJ6eXqM/tqrzPQFKxgg7efJklW7bLs8jjzwCAFiwYIHRckPr+IABAyrctirntLzPR2FhIZYsWVKjeKvCcDu9gaGEobJrQXXP5aFDh6DVahEREVHreNlyUw2TJ0/G0KFDsXLlSowfPx5PP/00PvnkE0RHR+OZZ55BcnIyli1bhoiIiDJ9oKawd+9edO3aVf4rZN++fXjzzTfvud26detQXFxc7gUfKClW7tu3L1atWoXMzEz069cPN27cwMKFC+Hg4FCm+FeSJPTu3fue46kAJX2/FQ1Pbxjc74MPPsDRo0exfft2uLi4oG3btpg+fTreeecdDBkyRL5QACV9+Zs3b8aYMWMQGRmJ3377Db/++ivefvttuVund+/eeOGFFzBnzhwcPXoU/fr1g62tLc6fP4/169fjv//9L4YMGXLP2E2tLuJq37491Go15s2bh4yMDGg0Gjz44IMV1vXMmTMHAwYMQM+ePfH000/j5s2bWLhwISIiIoymHxg4cCAeeOAB/Otf/8Lly5fRrl07/P7779i4cSNee+01+S/5ihhab+7uTgWAmTNnYvPmzejVqxdeeuklFBcXyzEcP368Wsdv0Lt3bwQGBmLjxo1wcHDAP/7xjzLrfP3111i9ejUef/xxdOzYEXZ2djhz5gy+/PJL2Nvb4+23367Rvg0GDRqEQYMGVbpOWFgYPvjgA0ybNg2XL1/G4MGD4eLigri4OPzwww94/vnn8eabbyI8PBxhYWF48803ce3aNbi6uuL//u//ynSVnDt3Dg899BCGDRuGVq1awcbGBj/88AOSkpKMuuWeffZZjB8/Hv/85z/Rt29fHDt2DFu2bKly87+rqyuWLl2KUaNG4b777sOIESPg7e2N+Ph4/Prrr+jRo0eZRLimJk+ejJ9++gmPPvooxo4di44dOyInJwcnTpzA999/j8uXL1e728Jwo8Urr7yC6Ojoe3ZbDho0CLNmzcKuXbvQr1+/ah9Du3btMGbMGHz++edyF9KBAwewatUqDB48GA888ECF21blnHbv3h3u7u4YM2YMXnnlFUiShK+//rpOu6zj4uLw2GOPoX///oiJicE333yDkSNHol27dhVuU91zuXXrVgwcONA0c8zV+n4rC1PRODdCCKHT6URYWJgICwuTb5P85ptvRGhoqLCzsxPt27cXW7ZsqfBW8PJu7UMFt2iWJzw8XMyaNUsIIcTVq1crjPNuXbt2FT4+Pka3dt4tNzdXvP/++6JVq1bCwcFBaLVa8eijj4ojR44YrZeVlSUAiBEjRtxzv/cam0cIIQ4dOlRmbBQhSm6l7ty5s/D395fH/hgzZoxwcnISFy9eFP369ROOjo7C19dXzJgxQ+h0ujL7//zzz0XHjh2Fg4ODcHFxEW3atBFvvfWWfJuyEMa3Md+tottk737PDbdKGm5FNzDEa8q4yht+YPny5SI0NFS+lfpet4X/3//9n2jZsqXQaDSiVatWYsOGDWU+s0KUnOvXX39d+Pv7C1tbW9GsWTMxf/58o9vgK4v1/PnzckylbwUXQohdu3aJjh07Cjs7OxEaGiqWLVsmv481NXnyZAFADBs2rNznjx8/LiZPnizuu+8+4eHhIWxsbISfn58YOnSoOHz4cLX2Vd4t7uUpb5wbIUrOQc+ePYWTk5NwcnIS4eHhYsKECUa3rp8+fVpERUUJZ2dn4eXlJZ577jlx7Ngxo1t1U1NTxYQJE0R4eLhwcnISWq1WREZGiu+++85ofzqdTkyZMkV4eXkJR0dHER0dLS5cuFDlz3jp446OjhZarVbY29uLsLAwMXbsWKMhKCr63Ff0XpT3+cnKyhLTpk0TTZs2FXZ2dsLLy0t0795dfPTRR/L4NdW5rhYXF4uXX35ZeHt7C0mSqvQ5a9u2rXjmmWeMllX0XTe8b6XH+ykqKhIzZ84UTZo0Eba2tiIoKEhMmzbN6Dbt8lT1nO7du1d07dpVODg4CH9/f/HWW2/Jt3KXvgZU530XouS9mzBhQpljPn36tBgyZIhwcXER7u7uYuLEiSIvL6/Ma5b+PAlRtXMphBBnzpyRh2ExBen2wRBVyaZNm/Doo4/i2LFjaNOmTb3ue+zYsfj++++rNcEhEVFNfP3115gwYQLi4+PlqW6s0XvvvYeZM2ciJSXFJIW+FXnttdewe/duHDp0yCQtN6y5oWrZsWMHRowYUe+JDRFRfXryySfRuHHjMrUmZHppaWn43//+hw8++MA0XVJgzQ1V0/z585UOgaxARkZGmTmU7labcVwqkpeXd8/52Tw8PGo0ySaZF5VKhZMnTyodhlXw9PQ0eYs8kxsianBeffXVcouRS6uLHvV169Zh3Lhxla6zY8eOcifMJaKGgzU3RNTgnD59+p6zi9fFeCs3btwoM8v13Tp27Fjp0PxEpDwmN0RERGRRWFBMREREFsXqam70ej2uX78OFxcXk1VlExERUd0SQiArKwv+/v5QqSpvm7G65Ob69etlZkIlIiIi85CQkIDAwMBK17G65MYwCWBCQgJcXV0VjoaIiIiqIjMzE0FBQUaT+VbE6pIbQ1eUq6srkxsiIiIzU5WSEhYUExERkUVhckNEREQWhckNERERWRQmN0RERGRRmNwQERGRRWFyQ0RERBaFyQ0RERFZFCY3REREZFGY3BAREZFFYXJDREREFoXJDREREVkUJjdERERkUZjcEBHVkYJiHXR6oXQYRFaHyQ0RUR24kZGHHnP/wMjl+yEEExyi+sTkhoioDizecQGp2YX4K+4mjl3NUDocIqvC5IaIyMSupedh3d8J8s+l/09EdY/JDRGRiS364wKKdAJ+WnsAwM/HriOvUKdwVETWg8kNEZEJJdzMxfqDJS01C4a3R5CHA7ILivHbyRsKR0ZkPZjcEBGZ0OIdF1CsF+jZ1AuRoZ4Y1jEIALumiOoTkxsiIhOJT8vF94euAgBe79sMAPDPjoGQJOCvuJu4nJqjZHhEVoPJDRGRiSz84zyK9QK9mnmhY7AHAMDfzQG9mnkDgJz4EFHdYnJDRGQCl1NzsOHINQDA632bGz03vFNJ19T3h65yUD+iesDkhojIBBb+cQE6vUCfFt64r7G70XNRrXzg5miLxMx87D6folCERNaDyQ0RUS3FpebghyMlXU6vRTUv87zGRo3B7QMAQL6TiojqDpMbIqJa+nT7eegF8GC4D9oHuZW7zrDbXVNbTychLbugHqMjsj5MboiIauFiSjY2Hi2ptXktqlmF67Xyd0WbAC2KdAI/Hr1eX+ERWSUmN0REtWBotYlq6Yu2gW6VrjusUyCAkq4pTqZJVHeY3BAR1dCF5Cz8dKykFaayVhuDx9oHQGOjwtnELJy4xsk0ieoKkxsiohr67/YLEALo18oXrQO091xf62CL/q0bAeCIxUR1ickNEVENnEvKwi/HDa02Ze+QqoihsPino5xMk6iuMLkhIqqB/247DyGA/hGN0MrftcrbdQv1RKC7A7IKirHlVGIdRkhkvZjcEBFV09nETPx6omSW79f63rvWpjSVSsJQTqZJVKeY3BARVdN/t50HAAxo44fwRlVvtTH4Z8cASBIQcykN8Wm5pg6PyOoxuSEiqoZT1zPw28lESBLwahXukCpPoLsjejb1AgB8f4itN0SmxuSGiKgaSrfaNPd1qfHrGAqL13MyTSKTY3JDRFRFJ69l4PfTSZCkqo1rU5m+rXyhdbDFjYx87LmQaqIIiQhgckNEVGULbrfaPNbOH019at5qAwD2tmoMbu8PAPiOk2kSmZTZJTe7d+/GwIED4e/vD0mS8OOPPyodEhFZgeNX07HtTBJUEvDKQ7VrtTEY1vn2ZJqnknArp9Akr0lEZpjc5OTkoF27dli8eLHSoRCRFTG02gxqH4Awb2eTvGaEvxYR/q4o1Onx4+3JN4mo9swuuXn44YfxwQcf4PHHH1c6FCKyEkcT0vHH2WSoVZLJWm0MDIXF6/7mZJpEpmJ2yU11FRQUIDMz0+hBRFQdC7adAwAMbh+AJl5OJn3tQe39YXd7Ms2T13h9IjIFi09u5syZA61WKz+CgoKUDomIzMjh+FvYGZtyu9Wmqclf383RDtERJZNpsrCYyDQsPrmZNm0aMjIy5EdCAi8eRFR1/9la0mrzjw4BCPY0bauNwbBOgQCAjUevIb+Ik2kS1ZbFJzcajQaurq5GDyKiqjh05Sb+PJ8KG5WElx80ba1NaT3CvBDg5oDMfE6mSWQKFp/cEBHV1H+2ltwhNaRjIBp7OtbZflQqCUM6lrTesGuKqPbMLrnJzs7G0aNHcfToUQBAXFwcjh49ivj4eGUDIyKLciDuJvZcKGm1mfCA6Wtt7jakYyAkCdh7IQ0JNzmZJlFtmF1yc/DgQXTo0AEdOnQAAEyaNAkdOnTA9OnTFY6MiCyJodZmaKcgBHnUXauNQZCHI3qEGSbTvFrn+yOyZGaX3PTp0wdCiDKPlStXKh0aEVmI/ZfSEHMpDbZqCRMfrPtWG4OhtwuLv+dkmkS1YnbJDRFRXTO02gzvHIQAN4d62290RCO42tvgWnoe9l3kZJpENcXkhoiolH0XU/FX3E3YqVX1UmtTmr2tGoPaBwAAvjvIrimimmJyQ0R0mxBCbrUZ0SUIftr6a7UxGH57Ms0tpxKRnsvJNIlqgskNEdFtey+k4e/Lt2Bno8JLfeq31cYgwt8VLf1cUVisx8aj1xWJgcjcMbkhIsLtVpvbc0iN7NIYjbT2isQhSZI8YjHHvCGqGSY3REQA/jyfikNXbkFjo8JLfcIUjWVw+wDYqVU4dT0TJ69lKBoLkTlickNEVk8IgU9u19o8GRkMH1dlWm0M3J3s0DfCFwCwnq03RNXG5IaIrN7Ocyk4mpAOe1sVxvcJVTocAMCwTiWFxT8evc7JNImqickNEVk1IQQW3G61GdU1GD4uyrbaGPRs6gV/rT0y8orw++kkpcMhMitMbojIqu2ITcaxqxlwsFXjhd7K1tqUpi41mSa7poiqh8kNEVmtknFtSmb+Ht0tGF7OGoUjMjakY0nX1J4Lqbh6i5NpElUVkxsislrbziTjxLUMONqp8fz9DaPWprTGno7oHuYJITiZJlF1MLkhIqu1ZOcFAMCY7iHwbGCtNgaGwuL1B69Cz8k0iaqEyQ0RWaXsgmIcTUgHAIztHqJoLJXp37oRXG5PphlzKU3pcIjMApMbIrJKJ65mQAjAX2sPX4XHtalMyWSa/gCAdX+zsJioKpjcEJFVOn41HQDQNtBN0TiqwtA1tflUIjJyixSOhqjhY3JDRFbp+NWSaQ3aBmkVjuTe2gRoEd7IBYXFevx07JrS4RA1eExuiMgqHbvdctPODFpuSibTLGm9+e4g75oiuhcmN0RkddKyC3D1Vh4AoHVAw2+5AYDBHQJgq5Zw4loGTl/PVDocogaNyQ0RWZ3jt2faDvV2gtbBVuFoqsbDyQ59W5VMpvkdRywmqhSTGyKyOscTSpIbc+iSKm2oPJnmNRQUczJNooowuSEiq3PnTinz6JIyuL+ZNxq52iM9twhbOZkmUYWY3BCRVRFCyMXE5nAbeGmlJ9NkYTFRxZjcEJFVuZ6Rj9TsQtioJET4uyodTrUN7VSS3Px5PgXX0/MUjoaoYWJyQ0RW5fjtKRea+7rA3latbDA1EOzphK6hHpxMk6gSTG6IyKocuz14XzszGLyvIvJkmocSOJkmUTmY3BCRVTGnaRcq8nBrP7hobJBwMw/74ziZJtHdmNwQkdXQ6wVOXDXP28BLc7BTY+DtyTQ3HrmucDREDQ+TGyKyGnFpOcgqKIa9rQrNfZ2VDqdWHgr3AQAcSbilcCREDQ+TGyKyGoYuqQh/LWzU5n35a3N72ogLydnILSxWOBqihsW8v91ERNVw7PbIxOY2eF95fFzt4euqgV6Ac00R3YXJDRFZDXOaCbwq2gS4AQCO364jIqISTG6IyCoU6fRyC4cltNwAd47jxDUmN0SlMbkhIqsQm5iFgmI9XOxtEOLppHQ4JtHmdnJjqCUiohJMbojIKhi6btoGaqFSSQpHYxqGouJLqTnILmBRMZEBkxsisgqWMHjf3bycNfDX2kMI4BS7pohkTG6IyCocs4DB+8rThnU3RGUwuSEii5dXqMO5pCwA5j2nVHkMLVG8Y4roDiY3RGTxTt/IgE4v4O2iQSNXe6XDMSlD3Q1bbojuYHJDRBbvaIKhS0oLSbKMYmIDQ3ITl5qDzPwihaMhahiY3BCRxbPEYmIDdyc7BLo7AABOsvWGCACTGyKyAqVvA7dE8mB+rLshAsDkhogsXEZeEeJScwBYZssNUGoaBrbcEAFgckNEFs7QmhHk4QAPJzuFo6kbbLkhMsbkhogsmqVNllme1v4lyU38zVyk5xYqHA2R8pjcEJFFO24FyY3W0RbBno4AgJPXMhWOhkh5TG6IyKJZejGxgeGW8OPX0pUNhKgBYHJDRBYrOTMfNzLyoZKA1gGWndyw7oboDiY3RGSxDPNJNfVxhpPGRuFo6pZ8xxSTGyImN0RkuSx58L67tQ5wBQBcS8/DzRwWFZN1Uzy5Wbx4MUJCQmBvb4/IyEgcOHCg0vUXLFiAFi1awMHBAUFBQXj99deRn59fT9ESkTm5MxO4ZXdJAYCLvS1CvZwAcJ4pIkWTm3Xr1mHSpEmYMWMGDh8+jHbt2iE6OhrJycnlrr9mzRpMnToVM2bMwJkzZ/DFF19g3bp1ePvtt+s5ciJq6IQQVtVyAwBt5LqbdGUDIVKYosnNJ598gueeew7jxo1Dq1atsGzZMjg6OuLLL78sd/19+/ahR48eGDlyJEJCQtCvXz888cQT92ztISLrk3AzD+m5RbBTqxDu56J0OPVCvmOKdTdk5RRLbgoLC3Ho0CFERUXdCUalQlRUFGJiYsrdpnv37jh06JCczFy6dAmbNm3CI488Ui8xE5H5MAze19LPBRobtbLB1BNDCxW7pcjaKXb7QGpqKnQ6HXx9fY2W+/r64uzZs+VuM3LkSKSmpqJnz54QQqC4uBjjx4+vtFuqoKAABQUF8s+ZmRzgisgaWFuXFABE+LtCkoAbGflIzsqHj4u90iERKULxguLq2LlzJ2bPno0lS5bg8OHD2LBhA3799VfMmjWrwm3mzJkDrVYrP4KCguoxYiJSyjErGbyvNCeNDcK8nQEAJ9l6Q1ZMseTGy8sLarUaSUlJRsuTkpLQqFGjcrd59913MWrUKDz77LNo06YNHn/8ccyePRtz5syBXq8vd5tp06YhIyNDfiQkJJj8WIioYdHphfzLvV2Qm7LB1LO2AYaiYrZSk/VSLLmxs7NDx44dsX37dnmZXq/H9u3b0a1bt3K3yc3NhUplHLJaXdKXLoQodxuNRgNXV1ejBxFZtgvJ2cgt1MHRTi23ZFgL+Y4pTsNAVkzRITsnTZqEMWPGoFOnTujSpQsWLFiAnJwcjBs3DgAwevRoBAQEYM6cOQCAgQMH4pNPPkGHDh0QGRmJCxcu4N1338XAgQPlJIeIyFBM3DpAC7VKUjaYembohuMdU2TNFE1uhg8fjpSUFEyfPh2JiYlo3749Nm/eLBcZx8fHG7XUvPPOO5AkCe+88w6uXbsGb29vDBw4EP/+97+VOgQiaoDuzARuPfU2Bq38tFBJQHJWAZIy8+HryqJisj6SqKg/x0JlZmZCq9UiIyODXVREFuqxRXtw/GoGFj7RAQPb+SsdTr3rv2A3ziZmYfnoTujbyvfeGxCZger8/jaru6WIiO6loFiHMzdKimnbW1kxsYFhBnSOd0PWiskNEVmUszeyUKQTcHe0RaC7g9LhKKItp2EgK8fkhogsSunB+yTJuoqJDdqUarmxssoDIgBMbojIwhxNsJ6ZwCvS0s8VNioJqdmFuJGRr3Q4RPWOyQ0RWRRrnHbhbva2ajT3LZkslLeEkzVickNEFiO7oBgXUrIBAG2DrLflBrjTNcVpGMgaMbkhIotx8loGhAD8tPZWP2mkYaTi40xuyAoxuSEii3GnS8q6W20A4zumWFRM1obJDRFZDMNM4NY2WWZ5WjRyga1awq3cIly9lad0OET1iskNEVmMO9MuuCkaR0OgsVEjvFHJKK4czI+sDZMbIrIIN3MKkXCzpIXCMEKvtTO8D7xjiqwNkxsisgiGmcBDvZygdbBVNpgGwlB3wzumyNowuSEii3D89uB9LCa+o43ccsOiYrIuTG6IyCJw8L6ymvu6wM5Ghcz8YsTfzFU6HKJ6w+SGiMyeEKLUnVJsuTGws1GhpV9JUTHrbsiaMLkhIrN3IyMfqdkFUKsktPJjclNa21KTaBJZCyY3RGT2DF1SzX1d4GCnVjaYBkaeIZwtN2RFmNwQkdkzdEm1Z5dUGW1K3TGl17OomKwDkxsiMnssJq5YMx9naGxUyCooxuW0HKXDIaoXTG6IyKzp9UIuluVt4GXZqFWI8OdIxWRdmNwQkVmLS8tBVn4xNDYqNPd1UTqcBsnQosU7pshaMLkhIrNm6JKK8HeFrZqXtPK05h1TZGV4JSAis3ZMHpnYTdlAGjBDd92paxnQsaiYrACTGyIya/JM4LxTqkJh3s5wsFUjp1CHuNRspcMhqnNMbojIbBXp9Dh1PRMAW24qo1ZJaB3AkYrJejC5ISKzdS4pCwXFerjY26CJp5PS4TRobQLcADC5IevA5IaIzFbpW8BVKknhaBq2NoG8HZysB5MbIjJbHLyv6gwtN6evZ6JYp1c2GKI6xuSGiMzW0dt3SrXj4H33FOrlBCc7NfKKdLiYwpGKybIxuSEis5RXqMO5pCwAbLmpCpVKkse7MbR4EVkqJjdEZJZO3ygZs8XLWQM/rb3S4ZgFw3g3rLshS8fkhojM0rFSXVKSxGLiqmjDaRjISjC5ISKzxGLi6mtzu1vqzI1MFLGomCwYkxsiMkvybeAcmbjKgj0c4WJvg4JiPc4ncaRislxMbojI7GTkFeFSaskdP+3YclNlKpUkt96cuJaubDBEdajGyU18fDz+/PNPbNmyBYcPH0ZBQYEp4yIiqtDJ2wWxQR4O8HCyUzga89Im0HDHFOtuyHLZVGfly5cvY+nSpVi7di2uXr0KIe7MLmtnZ4devXrh+eefxz//+U+oVGwUIqK6cTQhHQDrbWqi7e3B/HjHFFmyKmcgr7zyCtq1a4e4uDh88MEHOH36NDIyMlBYWIjExERs2rQJPXv2xPTp09G2bVv8/fffdRk3EVkxeSZwDt5XbYZuqbM3slBYzKJiskxVbrlxcnLCpUuX4OnpWeY5Hx8fPPjgg3jwwQcxY8YMbN68GQkJCejcubNJgyUiAkrPKeWmbCBmKMjDAVoHW2TkFeFcUpY8sB+RJalycjNnzpwqv2j//v1rFAwR0b0kZ+XjRkY+JAn8xVwDkiShbaAWf55PxfGrGXwPySJVqzCmU6dOWLZsGTIzM+sqHiKiSh2/PXhfU29nOGuqVTZIt/GOKbJ01Upu2rVrh7feegt+fn4YNWoUdu7cWUdhERGVj4P31V5b3jFFFq5ayc0XX3yBxMRELF68GAkJCXjooYfQtGlTzJ49G9euXaurGImIZMdu/0Juz8H7aszQFRWbmIX8Ip3C0RCZXrXv13Z0dMTYsWOxc+dOnDt3DiNGjMBnn32GkJAQDBgwABs2bKiLOImIIIRgy40JBLiVjA9UrBeITcxSOhwik6vVYDRhYWH44IMPcPnyZXz77bfYv38/hg4daqrYiIiMXL2Vh1u5RbBVSwj3c1E6HLMlSXdGKj7O8W7IAtV6pL2dO3di7NixGDt2LHQ6HZ577jlTxEVEVIZh8L6Wfq7Q2KiVDcbMGepuTtxuCSOyJDW61eDq1atYuXIlVq5ciUuXLqFXr15YsmQJhg4dCgcHB1PHSEQEoHQxMettaktuuWFRMVmgaiU33333Hb788kts374dPj4+GDNmDJ5++mk0bdq0ruIjIpId4+B9JmN4D88nZyO/SAd7W7aEkeWoVnLz1FNPYcCAAfjhhx/wyCOPcP4oIqo3Or2QJ8zkTOC15+uqgZezBqnZBTh9IxP3NXZXOiQik6lWcnP16lX4+PjUVSxERBW6mJKN3EIdHO3UaOrjrHQ4Zs8wUvEfZ5Nx4moGkxuyKFVuetm/f3+VE5vc3FycOnWqxkEREd3t2O1i4tYBWqhVkrLBWAjW3ZClqnJyM2rUKERHR2P9+vXIyckpd53Tp0/j7bffRlhYGA4dOlSl1128eDFCQkJgb2+PyMhIHDhwoNL109PTMWHCBPj5+UGj0aB58+bYtGlTVQ+DiMyU4RcwZwI3HfmOKU7DQBamyt1Sp0+fxtKlS/HOO+9g5MiRaN68Ofz9/WFvb49bt27h7NmzyM7OxuOPP47ff/8dbdq0uedrrlu3DpMmTcKyZcsQGRmJBQsWIDo6GrGxseW2EhUWFqJv377w8fHB999/j4CAAFy5cgVubm7VOmgiMj8cvM/0DC03F5KzkVtYDEc7ztVFlkESQojqbnTw4EHs2bMHV65cQV5eHry8vNChQwc88MAD8PDwqPLrREZGonPnzli0aBEAQK/XIygoCC+//DKmTp1aZv1ly5Zh/vz5OHv2LGxtbasbNgAgMzMTWq0WGRkZcHV1rdFrEFH9KijWofWMLSjSCeye/AAaezoqHZLFiJy9DUmZBfh+fDd0Cqn69ZuovlXn93eN0vROnTqhU6dONQrOoLCwEIcOHcK0adPkZSqVClFRUYiJiSl3m59++gndunXDhAkTsHHjRnh7e2PkyJGYMmUK1Oryb2MsKChAQUGB/DNnNCcyP2dvZKFIJ+DuaIsgD46lZUptAtyQlJmE41czmNyQxVDsXu7U1FTodDr4+voaLff19UViYmK521y6dAnff/89dDodNm3ahHfffRcff/wxPvjggwr3M2fOHGi1WvkRFBRk0uMgorpn6JJqE+gGSWIxsSndqbthUTFZDrMaqEav18PHxweff/45OnbsiOHDh+Nf//oXli1bVuE206ZNQ0ZGhvxISEiox4iJyBSOsZi4zrQJNNwxla5sIEQmpFj1mJeXF9RqNZKSkoyWJyUloVGjRuVu4+fnB1tbW6MuqJYtWyIxMRGFhYWws7Mrs41Go4FGozFt8ERUr1hMXHcMRcWXUnOQlV8EF/ua1TMSNSSKtdzY2dmhY8eO2L59u7xMr9dj+/bt6NatW7nb9OjRAxcuXIBer5eXnTt3Dn5+fuUmNkRk/nIKinEhORsAW27qgpezBv5aewgBnLrOmkSyDIp2S02aNAnLly/HqlWrcObMGbz44ovIycnBuHHjAACjR482Kjh+8cUXcfPmTbz66qs4d+4cfv31V8yePRsTJkxQ6hCIqI6dvJYBvQD8tPbwcbVXOhyLZOiaOsm6G7IQ1e6WysvLw6FDh+Dh4YFWrVoZPZefn4/vvvsOo0ePrtJrDR8+HCkpKZg+fToSExPRvn17bN68WS4yjo+PN5q/KigoCFu2bMHrr7+Otm3bIiAgAK+++iqmTJlS3cMgIjNxXJ4sk602daVtoBu2nEriSMVkMao1zs25c+fQr18/xMfHQ5Ik9OzZE2vXroWfnx+AknoZf39/6HS6Ogu4tjjODZF5mbDmMH49fgOTo1tgwgNNlQ7HIu0+l4LRXx5AEy8n7Hizj9LhEJWrOr+/q9UtNWXKFLRu3RrJycmIjY2Fi4sLevTogfj4+FoFTERUEUMxMWcCrzuGouK41Bxk5BUpHA1R7VUrudm3bx/mzJkDLy8vNG3aFD///DOio6PRq1cvXLp0qa5iJCIrdTOnEAk38wDcqQsh03N3spMHRzzFuhuyANVKbvLy8mBjc6dMR5IkLF26FAMHDkTv3r1x7tw5kwdIRNbL0GrTxMsJWgfeolyXDK03HMyPLEG1kpvw8HAcPHiwzPJFixZh0KBBeOyxx0wWGBERi4nrT5sANwDAcSY3ZAGqldw8/vjj+Pbbb8t9btGiRXjiiSdQg3k4iYjKdST+FgDW29QHeRoG3jFFFqBayc20adOwadOmCp9fsmSJ0QB7REQ1pdcLHLxSktx05oSOda61f0lyE38zF+m5hQpHQ1Q7NRrE75tvvkFOTo6pYyEikp1LzkJWfjEc7dRo6eeidDgWT+toixBPRwCsuyHzV6Pk5vXXX4evry9GjhyJTZs2NehxbYjIPP19uaTV5r7G7rBRm9Ucv2arNYuKyULU6Ipx48YNrF27FpIkYdiwYfDz88OECROwb98+U8dHRFbq77ibAIBOIe4KR2I9WHdDlqJGyY2NjQ0effRRrF69GsnJyfjPf/6Dy5cv44EHHkBYWJipYyQiK3Twckly04X1NvVGvmOKyQ2ZuWrPLXU3R0dHREdH49atW7hy5QrOnDljiriIyIpdS8/D9Yx8qFUS2jd2Uzocq9E6oGRI+2vpeUjLLoCns0bhiIhqpsYd2bm5uVi9ejUeeeQRBAQEYMGCBXj88cdx6tQpU8ZHRFbI0GrT2t8Vjna1/huMqsjF3hah3k4AWHdD5q1GV40RI0bgl19+gaOjI4YNG4Z3330X3bp1M3VsRGSl/r5sqLdhl1R9axOgxaWUHJy4moE+LXyUDoeoRmqU3KjVanz33XeIjo6GWq02dUxEZOX+jjOMb8Ni4vrWJkCLjUevs+WGzFqNkpvVq1ebOg4iIgBARm4RYpOyALDlRgltb48GzeSGzBkHjyCiBuVQfEmXVKiXE7xY0FrvIvxdIUnAjYx8JGflKx0OUY0wuSGiBsUweB/Ht1GGk8YGTb2dAQAn2XpDZorJDRE1KAdZTKy4NrcH8+N4N2SumNwQUYORX6TDsYSSX6icLFM5bW5Pw8CWGzJXNU5uLl68iHfeeQdPPPEEkpOTAQC//fYbx7khoho7cS0DhTo9vJw18iSOVP/asuWGzFyNkptdu3ahTZs2+Ouvv7BhwwZkZ2cDAI4dO4YZM2aYNEAish6G8W06h7hDkiSFo7Ferfy0UElAclYBkjJZVEzmp0bJzdSpU/HBBx9g69atsLOzk5c/+OCD2L9/v8mCIyLrclAuJmaXlJIc7NRo7usCADiWkK5sMEQ1UKPk5sSJE3j88cfLLPfx8UFqamqtgyIi66PXC7mYmIP3Ka/D7Tm9DK1pROakRsmNm5sbbty4UWb5kSNHEBAQUOugiMj6nEvOQmZ+MRzt1Gjl56p0OFava6gnACDmUprCkRBVX42SmxEjRmDKlClITEyEJEnQ6/XYu3cv3nzzTYwePdrUMRKRFTCMb3NfY3fYqHkjp9IMyc2p65nIyCtSOBqi6qnRFWT27NkIDw9HUFAQsrOz0apVK9x///3o3r073nnnHVPHSERW4M74NuySagh8Xe0R6uUEIYADceyaIvNSo7ml7OzssHz5ckyfPh0nTpxAdnY2OnTogGbNmpk6PiKyEoZiYo5v03B0DfPEpdQcxFxMQ99WvkqHQ1RlNWq5ef/995Gbm4ugoCA88sgjGDZsGJo1a4a8vDy8//77po6RiCzctfQ8XEvPg1oloX2Qm9Lh0G3dWHdDZqpGyc3MmTPlsW1Ky83NxcyZM2sdFBFZF0OXVIS/K5w0NWpQpjpgqLs5m5iJ9NxChaMhqroaJTdCiHIH2Dp27Bg8PNikTETVc2fwPl4/GhJvFw2a+ThDCGD/JdbdkPmo1p9I7u4lo4ZKkoTmzZsbJTg6nQ7Z2dkYP368yYMkIst2p96GxcQNTddQT5xPzsb+S2no37qR0uEQVUm1kpsFCxZACIGnn34aM2fOhFarlZ+zs7NDSEgIunXrZvIgichyZeQWITYpCwDQMZgtNw1NtzBPfL3/CmIusu6GzEe1kpsxY8YAAJo0aYLu3bvD1ta2ToIiIutxOP4WhACaeDnB20WjdDh0F0PdTWxSFtKyC+DpzHNEDV+Nam569+4tJzb5+fnIzMw0ehARVdUBw/g2weySaog8nOwQ3qhknqm/ON4NmYkaJTe5ubmYOHEifHx84OTkBHd3d6MHEVFVyfNJNWGXVEMlT8XArikyEzVKbiZPnow//vgDS5cuhUajwf/+9z/MnDkT/v7++Oqrr0wdIxFZqPwiHY4lZADgnVINGeeZInNTowElfv75Z3z11Vfo06cPxo0bh169eqFp06YIDg7G6tWr8eSTT5o6TiKyQCevZaBQp4eXsx1CPB2VDocq0DXUA5IEXEjORnJWPnxc7JUOiahSNWq5uXnzJkJDQwEArq6uuHmzpFm5Z8+e2L17t+miIyKLZpgss1OwR7ljZ1HD4OZoh5aNSmZq53g3ZA5qlNyEhoYiLi4OABAeHo7vvvsOQEmLjpubm8mCIyLL9jcnyzQb3cJKuqb2s2uKzECNkptx48bh2LFjAICpU6di8eLFsLe3x+uvv47JkyebNEAiskx6vZCLibuwmLjBM9Td7GdRMZmBGtXcvP766/L/o6KicPbsWRw6dAhNmzZF27ZtTRYcEVmu88nZyMwvhqOdGq38XJUOh+6hSxMPqCTgUmoOkjLz4evKuhtquEwyQ11wcDCCg4NN8VJEZCUMXVIdGrvBRl2jRmSqR1oHW0T4a3HiWgZiLqZhcIcApUMiqlC1kpu8vDxs374djz76KABg2rRpKCgokJ9Xq9WYNWsW7O2Z0RNR5Q7Kg/exS8pcdAvzxIlrGdh/ickNNWzVSm5WrVqFX3/9VU5uFi1ahIiICDg4OAAAzp49C39/f6NuKyKi8hjulGK9jfnoFuqJz3df4ng31OBVqy149erVeP75542WrVmzBjt27MCOHTswf/58+c4pIqKKXEvPw7X0PKhVEtoHuSkdDlVRpxB3qFUSrqTl4np6ntLhEFWoWsnNhQsX0KZNG/lne3t7qFR3XqJLly44ffq06aIjIotk6JKK8HeFk8YkpX9UD1zsbdE6QAuAUzFQw1at5CY9Pd2oxiYlJQUhISHyz3q93uh5IqLyHCw1eB+Zl26cioHMQLWSm8DAQJw8ebLC548fP47AwMBaB0VEls1wp1RnDt5ndjiYH5mDaiU3jzzyCKZPn478/Pwyz+Xl5WHmzJkYMGCAyYIjIsuTkVeE2KQsAEAnTpZpdjoFu8NGJeHqrTwk3MxVOhyiclWrs/vtt9/Gd999hxYtWmDixIlo3rw5ACA2NhaLFi1CcXEx3n777ToJlIgsw+ErtyAE0MTLCd4uGqXDoWpy0tigbaAWh+PTEXMpDUEenPCUGp5qJTe+vr7Yt28fXnzxRUydOhVCCACAJEno27cvlixZAl9f3zoJlIgsgzyfVDC7pMxVtzBPHI5Px/6LaRjWKUjpcIjKqPawoE2aNMHmzZuRkpKC/fv3Y//+/UhJScHmzZvlmcKra/HixQgJCYG9vT0iIyNx4MCBKm23du1aSJKEwYMH12i/RFT/DMXEndklZba6hXoBKKm7MfyRS9SQ1HjMcw8PD3Tp0gVdunSBh0fNL1Lr1q3DpEmTMGPGDBw+fBjt2rVDdHQ0kpOTK93u8uXLePPNN9GrV68a75uI6ldBsQ5Hr6YD4Ezg5qxjsDts1RKuZ+QjnnU31AApPqHLJ598gueeew7jxo1Dq1atsGzZMjg6OuLLL7+scBudTocnn3wSM2fOrHFrERHVvxNXM1BYrIeXsx2aeDkpHQ7VkIOdWh58kePdUEOkaHJTWFiIQ4cOISoqSl6mUqkQFRWFmJiYCrd7//334ePjg2eeeeae+ygoKEBmZqbRg4iU8Xep8W0kSVI4GqoNjndDDZmiyU1qaip0Ol2ZImRfX18kJiaWu82ePXvwxRdfYPny5VXax5w5c6DVauVHUBCL34iUIk+WyS4ps9f19ng3MRdZd0MNj+LdUtWRlZWFUaNGYfny5fDy8qrSNtOmTUNGRob8SEhIqOMoiag8er3AwSssJrYU9zV2h52NCslZBYhLzVE6HCIjik7q4uXlBbVajaSkJKPlSUlJaNSoUZn1L168iMuXL2PgwIHyMr1eDwCwsbFBbGwswsLCjLbRaDTQaDiWBpHSzidnIyOvCA62arTyd1U6HKole1s17mvshv2XbiLmUhpCvZ2VDolIpmjLjZ2dHTp27Ijt27fLy/R6PbZv345u3bqVWT88PBwnTpzA0aNH5cdjjz2GBx54AEePHmWXE1EDZhjf5r5gN9iqzarRmCrQNfRO1xRRQ6L4dLyTJk3CmDFj0KlTJ3Tp0gULFixATk4Oxo0bBwAYPXo0AgICMGfOHNjb26N169ZG27u5uQFAmeVE1LDI9TacLNNidAv1xAKcx/5LNyGEYJE4NRiKJzfDhw9HSkoKpk+fjsTERLRv3x6bN2+Wi4zj4+OhUvGvPCJz9zcH77M47Ru7QWOjQmp2AS4kZ6OZr4vSIREBACRhZWXumZmZ0Gq1yMjIgKsr+/2J6sP19Dx0n/sH1CoJx2b0g7NG8b+ryESe/N9+7L2QhlmDIjCqW4jS4ZAFq87vbzaJEFGdM9TbtPJzZWJjYbo24Xg31PAwuSGiOsf5pCxXt9vj3ey/dBN6vVV1BFADxuSGiOqcoeWmMwfvszhtA93gYKvGzZxCnEvOUjocIgBMboiojmXkFSE2qeSXXkcmNxbHzkYljzi9n7eEUwPB5IaI6tTh+FsQAgjxdISPi73S4VAdMHRNse6GGgomN0RUp/6OM8wnxXobS2UYzO+vONbdUMPA5IaI6pShmLgLkxuL1SZACyc7NdJzi3AmMVPpcIiY3BBR3Sko1uHo1XQAnAncktmqVejcpCR55VQM1BAwuSGiOnPyWgYKi/XwdLJDEy8npcOhOtQt9M4t4URKY3JDRHXGMOVCpxB3zjtk4e7U3aRBx7obUhiTGyKqM4ZiYg7eZ/ki/F3horFBVn4xTl9n3Q0pi8kNEdUJvV7g4BWOTGwtbNQqdDHU3VxKVTgasnZMboioTlxIyUZGXhEcbNVo5c9Jaq2BPN4Ni4pJYUxuiKhOGKZc6NDYDbZqXmqsgaHu5u/Lt1Cs0yscDVkzXnGIqE4clIuJ2SVlLVr6ucLV3gbZBcU4ybobUhCTGyKqEwfiOFmmtVGrJESGsmuKlMfkhohM7np6Hq6l50GtktChMZMba2IY74bzTJGSmNwQkckZ7pJq5ecKZ42NwtFQfTIUFR+8fBNFrLshhTC5ISKTO3jZMFkmW22sTQtfF7g72iK3UIfjVzOUDoesFJMbIjI5w8jEHN/G+qhUEiKbGKZiYNcUKYPJDRGZVEZeEc7enhmaLTfWiePdkNKY3BCRSR2OvwUhgBBPR/i42CsdDilArru5chMFxTqFoyFrxOSGiEzqTr0Nu6SsVTMfZ3g62SG/SM+6G1IEkxsiMqk79TbskrJWkiTJoxWza4qUwOSGiEymoFiHYwnpANhyY+26su6GFMTkhohM5uS1DBQU6+HpZIdQLyelwyEFGQbzOxR/C/lFrLuh+sXkhohM5m95Pil3SJKkcDSkpDBvJ3i7aFBYrMeR+HSlwyErw+SGiEzGUEzM8W1IkiS59Ybj3VB9Y3JDRCah1wt52gXW2xCAO0XFTG6onjG5ISKTuJiSjfTcIjjYqhHh76p0ONQAGMa7ORqfzrobqldMbojIJA7c7pLq0NgNtmpeWqhkIMdGrvYo1Olx6HarHlF94BWIiEzi4GV2SZExSZLk1hvW3VB9YnJDRCbxt1xMzMH76I5uHMyPFMDkhohq7UZGHq7eyoNKAjo0ZnJDdxiKio9dTUduYbHC0ZC1YHJDRLVm6JJq5e8KZ42NwtFQQxLk4YAANwcU6YT8OSGqa0xuiKjW/ub4NlQBo3mmWHdD9YTJDRHV2p3JMpncUFksKqb6xuSGiGolM78IZxMzAQCdgllvQ2V1DS1Jeo9fzUB2AetuqO4xuSGiWjl85RaEAII9HeHjaq90ONQABbo7IsjDATq9kLswieoSkxsiqhV5fJtgdklRxeR5pnhLONUDJjdEVCuGkYm7NGGXFFXMUHfDomKqD0xuiKjGCop1OJaQDoAjE1PlDHdMnbyWgcz8IoWjIUvH5IaIauzktQwUFOvh4WSHUC8npcOhBsxP64AQT0foBfB3HOtuqG4xuSGiGvv+0DUAJV0OkiQpHA01dHLXFOtuqI4xuSGiGknOysf/Hb4KABjbPUTZYMgscDA/qi9MboioRlbtu4zCYj3ua+zG8W2oSgx3TJ2+kYmMXNbdUN1hckNE1ZZdUIyvY64AAF7oHcYuKaoSH1d7hHo7QQjgrzi23lDdYXJDRNW27u8EZOYXI9TLCX1b+iodDpmRbuyaonrA5IaIqqVIp8cXf14CADx3fyhUKrbaUNWxqJjqA5MbIqqWX45fx/WMfHg5a/B4hwClwyEzYygqPpuYhZs5hQpHQ5aKyQ0RVZkQAp/tKmm1GdcjBPa2aoUjInPj5axBc19nAMAB1t1QHWkQyc3ixYsREhICe3t7REZG4sCBAxWuu3z5cvTq1Qvu7u5wd3dHVFRUpesTkensPp+Ks4lZcLRT46nIYKXDITMl3xLOrimqI4onN+vWrcOkSZMwY8YMHD58GO3atUN0dDSSk5PLXX/nzp144oknsGPHDsTExCAoKAj9+vXDtWvX6jlyIuvz2a6LAIAnujSG1tFW4WjIXLGomOqaJIQQSgYQGRmJzp07Y9GiRQAAvV6PoKAgvPzyy5g6deo9t9fpdHB3d8eiRYswevToe66fmZkJrVaLjIwMuLq61jp+Imtx/Go6Hlu0FzYqCbveegABbg5Kh0Rm6mZOIe6btRUAsPPNPgjh1B1UBdX5/a1oy01hYSEOHTqEqKgoeZlKpUJUVBRiYmKq9Bq5ubkoKiqCh0f5k/YVFBQgMzPT6EFE1ffZ7pJam8fa+TOxoVrxcLJDnxbeAIAF284pHA1ZIkWTm9TUVOh0Ovj6Go+T4evri8TExCq9xpQpU+Dv72+UIJU2Z84caLVa+REUFFTruImsTXxaLn47cQNAye3fRLX1Zr8WAICNx67jbCL/6CTTUrzmpjbmzp2LtWvX4ocffoC9vX2560ybNg0ZGRnyIyEhoZ6jJDJ//9tzCXoB9G7ujZZ+7M6l2msdoMWAtn4QAvhoS6zS4ZCFUTS58fLyglqtRlJSktHypKQkNGrUqNJtP/roI8ydOxe///472rZtW+F6Go0Grq6uRg8iqrq07AJ8d7Dkj4IXerPVhkznjb7NoVZJ2HYmGYeu3FQ6HLIgiiY3dnZ26NixI7Zv3y4v0+v12L59O7p161bhdh9++CFmzZqFzZs3o1OnTvURKpHV+irmCvKL9GgbqJXvciEyhVBvZwztGAgA+HBzLBS+v4UsiOLdUpMmTcLy5cuxatUqnDlzBi+++CJycnIwbtw4AMDo0aMxbdo0ef158+bh3XffxZdffomQkBAkJiYiMTER2dnZSh0CkcXKK9Thq5jLAIDn7w/lBJlkcq9GNYOdjQp/xd3E7vOpSodDFkLx5Gb48OH46KOPMH36dLRv3x5Hjx7F5s2b5SLj+Ph43LhxQ15/6dKlKCwsxJAhQ+Dn5yc/PvroI6UOgchirT+UgFu5RWjs4Yj+EZV3FRPVhJ/WAaO7lgwIOX/LWej1bL2h2lN8nJv6xnFuiKqmWKfHAx/vRMLNPMwaFIFR3UKUDoksVFp2Ae7/cAdyCnVYPPI+DGjrp3RI1ACZzTg3RNRw/XYyEQk38+DhZIchHTmEAtUdT2cNnu1VUqz+8dZYFOv0CkdE5o7JDRGVIYTAZ7tLploY3S0YDnacIJPq1rO9msDd0RaXUnLwf4evKh0OmTkmN0RURszFNJy8lgl7WxVGszuK6oGLvS0mPNAUALBg23nkF+kUjojMGZMbIipj2e2pFoZ3CoKHk53C0ZC1eKprMPy09riRkY9v9l9ROhwyY0xuiMjI6euZ2H0uBSoJch0EUX2wt1Xj1YeaAQCW7LyI7IJihSMic8XkhoiMfH671uaRNn4I8nBUOBqyNkM6BiLUywk3cwrxvz8vKR0OmSkmN0Qku3orFz8fLxlX6oX7wxSOhqyRjVqFSf2aAwD+92ccbuYUKhwRmSMmN0Qk+3LPZej0Aj2aeqJNoFbpcMhKPdLaDxH+rsguKMaSHReUDofMEJMbIgIApOcWYu3f8QDYakPKUqkkTI5uAQD4av8VXE/PUzgiMjdMbogIAPDN/ivILdShpZ8rejXzUjocsnK9m3ujSxMPFBbrsfCP80qHQ2aGyQ0RIb9Ih5X7LgMAXuAEmdQASJKEKf1LWm++O3gVl1I4OTJVHZMbIsKGw9eQml2IADcHzutDDUbHYA88FO4DnV7gk63nlA6HzAiTGyIrp9MLLL99y+0zPZvAVs3LAjUcb0a3gCQBvxy/gZPXMpQOh8wEr2JEVm7r6UTEpeZA62CL4Z05QSY1LC39XPFYO38AwEe/xyocDZkLJjdEVkwIgWW7SlptRnUNhpPGRuGIiMqa1Lc5bFQSdsam4EDcTaXDITPA5IbIiv19+RaOJqTDzkaFMd1DlA6HqFzBnk5yq+KHm89CCKFwRNTQMbkhsmKf7SqZamFIx0B4u2gUjoaoYq881Az2tiocvHILO2KTlQ6HGjgmN0RW6lxSFrafTYYkAc9xgkxq4Hxd7eXWxflbzkGvZ+sNVYzJDZGV+nx3Sa1NdKtGaOLlpHA0RPf2Yu8wuNjb4MyNTPx8/LrS4VADxuSGyAolZuRj49FrAIAXerPVhsyDm6MdXri/5PP6ydZzKNLpFY6IGiomN0RWaMXeOBTpBLo08UCHxu5Kh0NUZeN6NIGXsx2upOXiu4MJSodDDRSTGyIrk5lfhNV/GSbIZKsNmRcnjQ0mPNAUAPDp9vPIL9IpHBE1RExuiKzMmr/ikV1QjGY+znighY/S4RBV28jIxghwc0BSZgFW3Z4Tjag0JjdEVqSgWIcVe+MAAM/fHwqVihNkkvnR2KjxWlQzAMDSXReRmV+kcETU0DC5IbIiG49eR1JmAXxdNRjUPkDpcIhq7B/3BaKpjzPSc4uw/Padf0QGTG6IrIReL+Tbv5/u0QR2Nvz6k/lSqyS82a85AOCLPXFIySpQOCJqSHh1I7ISf5xNxoXkbLhobPBEZGOlwyGqteiIRmgXqEVuoQ6Ld1xQOhxqQJjcEFkJQ6vNyK6N4Wpvq3A0RLUnSRImR4cDKCmUv3orV+GIqKFgckNkBQ5duYUDl2/CVi3h6R5NlA6HyGR6NvNC9zBPFOr0WLDtvNLhUAPB5IbICny+u2SCzMHtA+Draq9wNESmNTm6BQBgw+GrOJ+UpXA01BAwuSGycBdTsvH76SQAJbd/E1maDo3d0a+VL/QC+Pj3c0qHQw0AkxsiC/e/Py9BCCCqpQ+a+booHQ5RnXgzugUkCdh8KhHHEtKVDocUxuSGyEIJIbBybxzWH7wKAHihd5jCERHVnea+Lni8Q8nYTR/9HqtwNKQ0JjdEFuhmTiGeXXUQ7/18GsV6gUHt/dEpmBNkkmV7Pao5bNUS/jyfin0XU5UOhxTE5IbIwuy7kIr+C3Zj+9lk2NmoMPOxCCwY3h6SxKkWyLIFeThiZJeSMZw+3BwLIYTCEZFSmNwQWYginR7zt5zFk1/8heSsAoR5O+HHl3pgTPcQJjZkNSY+2AwOtmocTUjH1tuF9GR9mNwQWYCEm7kY9lkMFu+4CCGAEZ2D8PPLPdHK31Xp0IjqlbeLBk/3DAEAvLH+GFbtu4xinV7ZoKjeMbkhMnM/H7uOR/77J47Ep8PF3gaLRnbA3H+2haOdjdKhESnihd5haB/khqz8Ysz46RQeW7QXh67cUjosqkeSsLJOyczMTGi1WmRkZMDVlX/VkvnKLSzGzJ9OY93BBADAfY3d8N8RHRDk4ahwZETK0+kFvj0Qj/lbYpGRVwQAGNYpEFP6h8PTWaNwdFQT1fn9zeSGyAydup6Bl789gkspOZAkYOIDTfHqQ81go2ZjLFFpadkFmLf5LL67PSSCq70NJvcPx8gujaFWsRbNnDC5qQSTGzJnQgis3HcZczadRaFOD19XDf4zvD26h3kpHRpRg3boyi28++NJnL6RCQBoE6DFrMGt0T7ITdnAqMqY3FSCyQ2Zq5s5hZi8/hi2n00GUDLi8IdD2sHDyU7hyIjMQ7FOj9V/xeOj32ORlV8MSSopvn8rOhzu/B41eExuKsHkhszRvgupeG3dUSRnFcDORoV/PdISo7sF8xZvohpIySrA3N/O4v8Ol3RVuTnaYkr/cAzvFAQVu6oaLCY3lWByQ+akSKfHgm3nsGRnyS3eYd5OWPjEfbzFm8gEDsTdxPSNJ3E2sWQm8XZBbpg1KAJtA92UDYzKxeSmEkxuyFwk3MzFK2uP4Eh8OoCS5vPpA1vxFm8iEyrW6fFVzBV8svUcsgtKuqpGdmmMydEt4ObIrqqGhMlNJZjckDn4+dh1vL3hBLIKiuFib4M5/2iDR9v6Kx0WkcVKzszH7E1n8OPR6wAADyc7TO0fjiEdA9lV1UAwuakEkxtqyDh2DZGy9l9Kw/SNJ3EuKRtAyXfw/UGt0TpAq3BkxOSmEkxuqKHi2DVEDUORTo+Vey9jwbZzyCnUQSUBo7oGY1K/FtA62CodntViclMJJjfU0HDsGqKGKTEjH//edAY/HyvpqvJytsPUh1vin/cF8E5FBTC5qQSTG1JSkU6PuNQcnE3MwrnELJxNzMKZG5m4lp4HgGPXEDVEey+kYvrGk7iYkgMA6BzijvcHtUZLP/4OqU9WkdwsXrwY8+fPR2JiItq1a4eFCxeiS5cu99yOyQ3VByEErqXnITYxC7FJWSX/JmbhYko2inRlv3Icu4aoYSss1uPLvXH477bzyCsq6aoK83ZGqLcTQr2dEepV8m+YtxPvsqojFp/crFu3DqNHj8ayZcsQGRmJBQsWYP369YiNjYWPj0+l2zK5IVO7lVOIs4lZiE3MRGxSNmITM3EuKRvZBcXlru+ssUFzX2e0aOSCFr4uaN7IBRF+Wmgd2ZdP1NBdT8/DB7+exqYTiRWu4+FkhzBvJ4R6lUp+vJ3Q2MMRtqyhqzGLT24iIyPRuXNnLFq0CACg1+sRFBSEl19+GVOnTq10WyY3VFN5hTqcT86Su5Rik0r+n5JVUO76tmoJYd7OaO7rghaNXBDeyAXNfV0Q6O7A1hkiM3c9PQ/nk7NxKSUbl1JycCm15N8bGfkVbmOjktDYw1FOeMJKtfp4ONnxunAP1fn9bXajgRUWFuLQoUOYNm2avEylUiEqKgoxMTGKxXUrpxC7z6dAJUmQJJT8C0C6/bMEGD2HUusYlpcsLrW9BJQMryBBJZW8lk4voBei5F+9gM7wfyGg0wM6fcnPOnH7+dL/N1oGo+11eoG709zS3zOpouUVfBmNty35QcCwf0AnBIQwjk8vYHx8QkB/e93SsYrb693ZruR4hCh5TqDkX738MwDDz7i9HgB9yQ+3lxnig7wOcOc18ot1uHorr8x7ZBDk4YAWvq5o0cgZLRq5ooWvC5p4OcHOhn+lEVkifzcH+Ls5oHdzb6PlOQXFiEvNwUU56cnBpZRsxKXmILdQV/Jzag5wJtloO62DbUnSc7u1J8DNAQICxbo710md/s7PxbevfSU/61Gsv3MtLzb6V3/7d4PeaLmEku5wO7UKtmoVbG0k2KpVxsvUKtiqpbvWU8FOLcnP29nc/rf0a6hVcLBTw8tZU49nxJjZJTepqanQ6XTw9fU1Wu7r64uzZ8+WWb+goAAFBXf+ss7MzKyTuOLScvDq2qN18trUcHg62aHF7RaY8EYlLTLNfF3grDG7rxIR1QEnjQ1aB2jLjIsjhEBiZn5JwpOSjYspdxKg6xl5yMgrwpH4dHlEcnPXPsgNP07oodj+Lf6KPGfOHMycObPO9+OisUH3MM87LQa405Kgv6ulQF9OK4HxesKopUFugRCASgWoJQkqlQS1JEGtuvNQGX6WpJL1bi+zuev50tuWLAPUKhUMg3CWbpwwbqkQZZYZ/b+85+96n+TYSx2H6u5YJAmSdPdxlbRmlT2GO8tVqjstX5LcclayTCUZWpPKtqSVbjErbztIgK1ahRBPJ3i7KPeXCBGZL0mS4Kd1gJ/WAT2aGg/zkF+kQ1xqjpz4XErNQVJmPtSqO9fvkv+rjK75pZ+787NKvqbblLOeze3rpxAld2+WPAQKi0v+L/+rE6We16OwWBg9X2adYj0K5ecF7G2VbbU2u5qbwsJCODo64vvvv8fgwYPl5WPGjEF6ejo2btxotH55LTdBQUGsuSEiIjIj1am5MbuCADs7O3Ts2BHbt2+Xl+n1emzfvh3dunUrs75Go4Grq6vRg4iIiCyXWXZLTZo0CWPGjEGnTp3QpUsXLFiwADk5ORg3bpzSoREREZHCzDK5GT58OFJSUjB9+nQkJiaiffv22Lx5c5kiYyIiIrI+ZldzU1sc54aIiMj8WHTNDREREVFlmNwQERGRRWFyQ0RERBaFyQ0RERFZFCY3REREZFGY3BAREZFFYXJDREREFoXJDREREVkUJjdERERkUZjcEBERkUUxy7mlasMw20RmZqbCkRAREVFVGX5vV2XWKKtLbrKysgAAQUFBCkdCRERE1ZWVlQWtVlvpOlY3caZer8f169fh4uICSZJM+tqZmZkICgpCQkKCRU7KaenHB1j+MfL4zJ+lHyOPz/zV1TEKIZCVlQV/f3+oVJVX1Vhdy41KpUJgYGCd7sPV1dViP7SA5R8fYPnHyOMzf5Z+jDw+81cXx3ivFhsDFhQTERGRRWFyQ0RERBaFyY0JaTQazJgxAxqNRulQ6oSlHx9g+cfI4zN/ln6MPD7z1xCO0eoKiomIiMiyseWGiIiILAqTGyIiIrIoTG6IiIjIojC5ISIiIovC5MaENmzYgH79+sHT0xOSJOHo0aNKh3RPQghMnz4dfn5+cHBwQFRUFM6fP1/pNiEhIZAkqcxjwoQJ8jp9+vQp8/z48ePr+nCqpCbH/N5775U5nvDw8HqKuHI1OZ45c+agc+fOcHFxgY+PDwYPHozY2FijdRryOazI4sWLERISAnt7e0RGRuLAgQNKh3RP1Yl5+fLl6NWrF9zd3eHu7o6oqKgy648dO7bMeevfv39dH0a1VOeYV65cWeZ47O3t6zHae6vO8ZT3vZIkCQMGDJDXMYdzWJ7du3dj4MCB8Pf3hyRJ+PHHHxWLhcmNCeXk5KBnz56YN2+e0qFU2YcffohPP/0Uy5Ytw19//QUnJydER0cjPz+/wm3+/vtv3LhxQ35s3boVADB06FCj9Z577jmj9T788MM6PZaqqskxA0BERITR8ezZs6eeIq5cTY5n165dmDBhAvbv34+tW7eiqKgI/fr1Q05OjtF6DfUclmfdunWYNGkSZsyYgcOHD6Ndu3aIjo5GcnKy0qFVqLox79y5E0888QR27NiBmJgYBAUFoV+/frh27ZrRev379zc6b99++219HE6V1OQ8ubq6Gh3PlStX6jHiylX3eDZs2GB0LCdPnoRarS5z/WzI57AiOTk5aNeuHRYvXqx0KIAgk4uLixMAxJEjR5QOpVJ6vV40atRIzJ8/X16Wnp4uNBqN+Pbbb6v8Oq+++qoICwsTer1eXta7d2/x6quvmjJck6jpMc+YMUO0a9euHiKsHlOdw+TkZAFA7Nq1S17WUM9hRbp06SImTJgg/6zT6YS/v7+YM2eOglFVrrYxFxcXCxcXF7Fq1Sp52ZgxY8SgQYNMHarJVPeYV6xYIbRabT1FV321PYf/+c9/hIuLi8jOzpaXNfRzWBUAxA8//KDY/tlyY8Xi4uKQmJiIqKgoeZlWq0VkZCRiYmKq9BqFhYX45ptv8PTTT5eZiHT16tXw8vJC69atMW3aNOTm5po0/pqozTGfP38e/v7+CA0NxZNPPon4+Pi6DveeTHEOASAjIwMA4OHhYbS8IZ7D8hQWFuLQoUNG74NKpUJUVFS13of6ZIqYc3NzUVRUVOa87dy5Ez4+PmjRogVefPFFpKWlmTT2mqrpMWdnZyM4OBhBQUEYNGgQTp06VR/h3pMpzuEXX3yBESNGwMnJyWh5Qz2H5sLqJs6kOxITEwEAvr6+Rst9fX3l5+7lxx9/RHp6OsaOHWu0fOTIkQgODoa/vz+OHz+OKVOmIDY2Fhs2bDBJ7DVV02OOjIzEypUr0aJFC9y4cQMzZ85Er169cPLkSbi4uNRpzJUxxTnU6/V47bXX0KNHD7Ru3Vpe3lDPYXlSU1Oh0+nKfR/Onj2rUFSVM0XMU6ZMgb+/v9Ev1/79++Mf//gHmjRpgosXL+Ltt9/Gww8/jJiYGKjVapMeQ3XV5JhbtGiBL7/8Em3btkVGRgY++ugjdO/eHadOnarzSZDvpbbn8MCBAzh58iS++OILo+UN+RyaCyY3NbR69Wq88MIL8s+//fYbevXqpWBE93Z3zL/++mutX/OLL77Aww8/DH9/f6Plzz//vPz/Nm3awM/PDw899BAuXryIsLCwWu+3qkx1zA8//LD8/7Zt2yIyMhLBwcH47rvv8Mwzz9Q6zqqqi3M4YcIEnDx5skwNUUM5h1S+uXPnYu3atdi5c6dRge2IESPk/7dp0wZt27ZFWFgYdu7ciYceekiJUGulW7du6Natm/xz9+7d0bJlS3z22WeYNWuWgpHV3hdffIE2bdqgS5cuRsst7RwqgclNDT322GOIjIyUfw4ICFAwmqq5O+aCggIAQFJSEvz8/OTlSUlJaN++/T1f78qVK9i2bVuV/pI37PfChQv1+ovR1Mds4ObmhubNm+PChQsmi7UqTH08EydOxC+//ILdu3ff869gpc5hVXh5eUGtViMpKcloeVJSEho1aqRQVJWrTcwfffQR5s6di23btqFt27aVrhsaGgovLy9cuHBB8V+MpjhPtra26NChQ71/98pTm+PJycnB2rVr8f77799zPw3pHJoL1tzUkIuLC5o2bSo/HBwclA7pnu6OuVWrVmjUqBG2b98ur5OZmYm//vrL6C+liqxYsQI+Pj5GtzBWxHBbfOlfwPXB1MdskJ2djYsXL5rt8QghMHHiRPzwww/4448/0KRJk3vuW6lzWBV2dnbo2LGj0fug1+uxffv2ap3X+lTTmD/88EPMmjULmzdvRqdOne65n6tXryItLa1BnDdTnCedTocTJ06Y/fGsX78eBQUFeOqpp+65n4Z0Ds2GYqXMFigtLU0cOXJE/PrrrwKAWLt2rThy5Ii4ceOG0qFVaO7cucLNzU1s3LhRHD9+XAwaNEg0adJE5OXlyes8+OCDYuHChUbb6XQ60bhxYzFlypQyr3nhwgXx/vvvi4MHD4q4uDixceNGERoaKu6///46P56qqMkxv/HGG2Lnzp0iLi5O7N27V0RFRQkvLy+RnJysxCEYqcnxvPjii0Kr1YqdO3eKGzduyI/c3FwhRMM/h+VZu3at0Gg0YuXKleL06dPi+eefF25ubiIxMVHp0Cp0r5hHjRolpk6dKq8/d+5cYWdnJ77//nuj85aVlSWEECIrK0u8+eabIiYmRsTFxYlt27aJ++67TzRr1kzk5+crcox3q+4xz5w5U2zZskVcvHhRHDp0SIwYMULY29uLU6dOKXUIRqp7PAY9e/YUw4cPL7PcHM5hRbKyssSRI0fEkSNHBADxySefiCNHjogrV67UeyxMbkxoxYoVAkCZx4wZM5QOrUJ6vV68++67wtfXV2g0GvHQQw+J2NhYo3WCg4PLHMOWLVsEgDLrCiFEfHy8uP/++4WHh4fQaDSiadOmYvLkySIjI6MuD6XKanLMw4cPF35+fsLOzk4EBASI4cOHiwsXLtRz5OWryfGU9zkFIFasWCGEaPjnsCILFy4UjRs3FnZ2dqJLly5i//79Sod0T5XF3Lt3bzFmzBj55+Dg4EqvMbm5uaJfv37C29tb2NraiuDgYPHcc881uASvOsf82muvyev6+vqKRx55RBw+fFiBqCtWneMRQoizZ88KAOL3338v81rmcg7Ls2PHjnI/n3cff32QhBCi3pqJiIiIiOoYa26IiIjIojC5ISIiIovC5IaIiIgsCpMbIiIisihMboiIiMiiMLkhIiIii8LkhoiIiCwKkxsiIiKyKExuiMgirVy5Em5ubnX2+vfffz/WrFlTrW2WLVuGgQMH1lFERGTA5IaIqiQxMRGvvvoqmjZtCnt7e/j6+qJHjx5YunQpcnNzq/w6dZ10VMfy5cvRq1cvuLu7w93dHVFRUThw4MA9t/vpp5+QlJSEESNGoLCwEF5eXpg7d265686aNQu+vr4oKirC008/jcOHD+PPP/809aEQUSlMbojoni5duoQOHTrg999/x+zZs3HkyBHExMTgrbfewi+//IJt27YpHWKN7Ny5E0888QR27NiBmJgYBAUFoV+/frh27Vql23366acYN24cVCoV7Ozs8NRTT2HFihVl1hNCYOXKlRg9ejRsbW1hZ2eHkSNH4tNPP62rQyIigLOCE9G9RUdHi8DAQJGdnV3u83q9Xv7/xx9/LFq3bi0cHR1FYGCgePHFF+VZq8ubWM8w6WN+fr544403hL+/v3B0dBRdunQRO3bsqDSuW7duieeff174+PgIjUYjIiIixM8//yyEKJnIVqvVis2bN4vw8HDh5OQkoqOjxfXr1yt8veLiYuHi4iJWrVpV4TrJyclCkiRx8uRJednx48cFAPHnn38arWs43jNnzsjLdu3aJezs7OQZ2InI9NhyQ0SVSktLw++//44JEybAycmp3HUkSZL/r1Kp8Omnn+LUqVNYtWoV/vjjD7z11lsAgO7du2PBggVwdXXFjRs3cOPGDbz55psAgIkTJyImJgZr167F8ePHMXToUPTv3x/nz58vd596vR4PP/ww9u7di2+++QanT5/G3LlzoVar5XVyc3Px0Ucf4euvv8bu3bsRHx8v7688ubm5KCoqgoeHR4Xr7NmzB46OjmjZsqW8rE2bNujcuTO+/PJLo3VXrFiB7t27Izw8XF7WqVMnFBcX46+//qpwH0RUS0pnV0TUsO3fv18AEBs2bDBa7unpKZycnISTk5N46623Ktx+/fr1wtPTU/7Z0KJS2pUrV4RarRbXrl0zWv7QQw+JadOmlfu6W7ZsESqVSsTGxpb7/IoVKwQAceHCBXnZ4sWLha+vb4WxvvjiiyI0NFTk5eVVuM5//vMfERoaWmb5smXLhLOzs9xKlZmZKRwdHcX//ve/Muu6u7uLlStXVrgPIqodttwQUY0cOHAAR48eRUREBAoKCuTl27Ztw0MPPYSAgAC4uLhg1KhRSEtLq7To+MSJE9DpdGjevDmcnZ3lx65du3Dx4sVytzl69CgCAwPRvHnzCl/X0dERYWFh8s9+fn5ITk4ud925c+di7dq1+OGHH2Bvb1/ha+bl5ZX7/BNPPAGdTofvvvsOALBu3TqoVCoMHz68zLoODg7VKsImouqxUToAImrYmjZtCkmSEBsba7Q8NDQUQMkvaoPLly/j0UcfxYsvvoh///vf8PDwwJ49e/DMM8+gsLAQjo6O5e4jOzsbarUahw4dMupWAgBnZ+dytym934rY2toa/SxJEoQQZdb76KOPMHfuXGzbtg1t27at9DW9vLxw69atMstdXV0xZMgQrFixAk8//TRWrFiBYcOGlRv/zZs34e3tfc/4iahm2HJDRJXy9PRE3759sWjRIuTk5FS67qFDh6DX6/Hxxx+ja9euaN68Oa5fv260jp2dHXQ6ndGyDh06QKfTITk5GU2bNjV6NGrUqNx9tW3bFlevXsW5c+dqdXwffvghZs2ahc2bN6NTp073XL9Dhw5ITEwsN8F55plnsGfPHvzyyy/Yt28fnnnmmTLrXLx4Efn5+ejQoUOt4iaiijG5IaJ7WrJkCYqLi9GpUyesW7cOZ86cQWxsLL755hucPXtWbm1p2rQpioqKsHDhQly6dAlff/01li1bZvRaISEhyM7Oxvbt25Gamorc3Fw0b94cTz75JEaPHo0NGzYgLi4OBw4cwJw5c/Drr7+WG1Pv3r1x//3345///Ce2bt2KuLg4/Pbbb9i8eXOVj2vevHl499138eWXXyIkJASJiYlITExEdnZ2hdt06NABXl5e2Lt3b5nn7r//fjRt2hSjR49GeHg4unfvXmadP//8E6GhoUbdZURkYkoX/RCRebh+/bqYOHGiaNKkibC1tRXOzs6iS5cuYv78+SInJ0de75NPPhF+fn7CwcFBREdHi6+++koAELdu3ZLXGT9+vPD09DS6FbywsFBMnz5dhISECFtbW+Hn5ycef/xxcfz48QpjSktLE+PGjROenp7C3t5etG7dWvzyyy9CiPILl3/44QdR+rIXHBxc5tb00jFV5K233hIjRowo97nZs2cLAOLDDz8s9/l+/fqJOXPmVPr6RFQ7khDldEATEVGFEhMTERERgcOHDyM4OLjK2506dQoPPvggzp07B61WW4cRElk3dksREVVTo0aN8MUXXyA+Pr5a2924cQNfffUVExuiOsaWGyIiIrIobLkhIiIii8LkhoiIiCwKkxsiIiKyKExuiIiIyKIwuSEiIiKLwuSGiIiILAqTGyIiIrIoTG6IiIjIojC5ISIiIovy/wM7jZis/dM6AAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1522,12 +1608,182 @@
     "    do_plot=True,\n",
     "    show_progress=True,\n",
     "    dataset_dependencies={\n",
-    "        \"ds1\": (dac.ch1, dmm.v1), \n",
+    "        \"ds1\": (dac.ch1, dmm.v1),\n",
     "        \"ds2\": (dac.ch2, dmm.v2),\n",
-    "    }\n",
+    "    },\n",
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Getting a value after setting it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Looking at the examples of using the measurement context manager above you can see that we typically store the value set on the instrument as the setpoint.\n",
+    "For most instruments we know that once the instrument has been set to a given value that is the actual value applied. However for some instruments it may not be able to reach exactly the value specified \n",
+    "and one may want to ask the instrument for the exact value acchived. With the measurement context manger this is relatively simple to implement as seen in the example below.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 79. \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Setting up Measurement\n",
+    "meas = Measurement(name=\"1d_measurement of dmm from dac sweep\", exp=tutorial_exp)\n",
+    "meas.register_parameter(dac.ch1)\n",
+    "meas.register_parameter(dmm.v1, setpoints=(dac.ch1,))\n",
+    "meas.register_parameter(dmm.v2, setpoints=(dac.ch1,))\n",
+    "\n",
+    "# Running Measurement\n",
+    "with meas.run() as datasaver:\n",
+    "    for dac_sweep in np.linspace(0, 1, 10):  # sweep points\n",
+    "        dac.ch1(dac_sweep)\n",
+    "        datasaver.add_result(\n",
+    "            (dac.ch1, dac.ch1()), (dmm.v1, dmm.v1()), (dmm.v2, dmm.v2())\n",
+    "        )\n",
+    "        time.sleep(0.01)  # Can be removed if there is no intention to see a live plot\n",
+    "\n",
+    "    dataset1 = datasaver.dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To do the same using doNd we can make use of the get_after_set argument to the Sweep as shown here.\n",
+    "To illustrate the difference we make use of the `console_level` and `filter_instrument` context managers to show log debug messages from the mock dac instrument.\n",
+    "See this notebook [here](../logging/logging_example.ipynb)  for more examples of logging and how it can be controlled."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "set_and_get_sweep = LinSweep(dac.ch1, -1, 1, 11, 0.01, get_after_set=True)\n",
+    "set_only_sweep = LinSweep(dac.ch1, -1, 1, 11, 0.01, get_after_set=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see below when get_after_set is False (the default) we do not perform a get command on the dac.ch1 parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-10-28 11:45:29,671 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -1.0\n",
+      "2022-10-28 11:45:29,683 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.8\n",
+      "2022-10-28 11:45:29,698 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.6\n",
+      "2022-10-28 11:45:29,714 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.3999999999999999\n",
+      "2022-10-28 11:45:29,728 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.19999999999999996\n",
+      "2022-10-28 11:45:29,744 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.0\n",
+      "2022-10-28 11:45:29,760 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.20000000000000018\n",
+      "2022-10-28 11:45:29,776 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.40000000000000013\n",
+      "2022-10-28 11:45:29,790 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.6000000000000001\n",
+      "2022-10-28 11:45:29,806 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.8\n",
+      "2022-10-28 11:45:29,822 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 1.0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 80. Using 'qcodes.dataset.dond'\n"
+     ]
+    }
+   ],
+   "source": [
+    "with qcodes.logger.console_level(\"DEBUG\"):\n",
+    "    with qcodes.logger.filter_instrument(dac):\n",
+    "        dond(set_only_sweep, dmm.v1, dmm.v2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But when we set get_after_set to True we perform a get after each set of the parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-10-28 11:45:29,883 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -1.0\n",
+      "2022-10-28 11:45:29,899 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as -1.0\n",
+      "2022-10-28 11:45:29,901 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.8\n",
+      "2022-10-28 11:45:29,914 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as -0.8\n",
+      "2022-10-28 11:45:29,919 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.6\n",
+      "2022-10-28 11:45:29,944 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as -0.6\n",
+      "2022-10-28 11:45:29,948 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.3999999999999999\n",
+      "2022-10-28 11:45:29,960 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as -0.3999999999999999\n",
+      "2022-10-28 11:45:29,964 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to -0.19999999999999996\n",
+      "2022-10-28 11:45:29,992 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as -0.19999999999999996\n",
+      "2022-10-28 11:45:29,995 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.0\n",
+      "2022-10-28 11:45:30,007 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 0.0\n",
+      "2022-10-28 11:45:30,010 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.20000000000000018\n",
+      "2022-10-28 11:45:30,023 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 0.20000000000000018\n",
+      "2022-10-28 11:45:30,026 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.40000000000000013\n",
+      "2022-10-28 11:45:30,038 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 0.40000000000000013\n",
+      "2022-10-28 11:45:30,040 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.6000000000000001\n",
+      "2022-10-28 11:45:30,053 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 0.6000000000000001\n",
+      "2022-10-28 11:45:30,054 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 0.8\n",
+      "2022-10-28 11:45:30,068 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 0.8\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 81. Using 'qcodes.dataset.dond'\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2022-10-28 11:45:30,071 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _set_manual_parameter ¦ 199 ¦ [dac(DummyInstrument)] Setting raw value of parameter: dac_ch1 to 1.0\n",
+      "2022-10-28 11:45:30,084 ¦ qcodes.instrument.instrument_base ¦ DEBUG ¦ parameter ¦ _get_manual_parameter ¦ 187 ¦ [dac(DummyInstrument)] Getting raw value of parameter: dac_ch1 as 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "with qcodes.logger.console_level(\"DEBUG\"):\n",
+    "    with qcodes.logger.filter_instrument(dac):\n",
+    "        dond(set_and_get_sweep, dmm.v1, dmm.v2)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1546,7 +1802,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1554,6 +1810,7 @@
     "    print(\"dac channel 1 is set\")\n",
     "    print(\"********************\")\n",
     "\n",
+    "\n",
     "def action_2():\n",
     "    print(\"dac channel 2 is set\")\n",
     "    print(\"++++++++++++++++++++\")"
@@ -1568,7 +1825,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1585,14 +1842,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 224. \n",
+      "Starting experimental run with id: 82. Using 'qcodes.dataset.dond'\n",
       "dac channel 1 is set\n",
       "********************\n",
       "dac channel 2 is set\n",
@@ -1610,8 +1867,8 @@
     {
      "data": {
       "text/plain": [
-       "(results #224@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #82@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric,\n",
@@ -1619,7 +1876,7 @@
        " [None])"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1637,7 +1894,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1648,7 +1905,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1658,14 +1915,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Starting experimental run with id: 225. \n",
+      "Starting experimental run with id: 83. Using 'qcodes.dataset.dond'\n",
       "dac channel 1 is set\n",
       "********************\n",
       "wait after setting dac channel 1\n",
@@ -1679,8 +1936,8 @@
     {
      "data": {
       "text/plain": [
-       "(results #225@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
-       " -----------------------------------------------------------------------------------------\n",
+       "(results #83@C:\\Users\\jenielse\\source\\repos\\Qcodes\\docs\\examples\\DataSet\\tutorial_doNd.db\n",
+       " ----------------------------------------------------------------------------------------\n",
        " dac_ch1 - numeric\n",
        " dac_ch2 - numeric\n",
        " dmm_v1 - numeric,\n",
@@ -1688,7 +1945,7 @@
        " [None])"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1707,7 +1964,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3.10.6 ('qcodespip310')",
    "language": "python",
    "name": "python3"
   },
@@ -1721,7 +1978,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.10.6"
   },
   "toc": {
    "base_numbering": 1,
@@ -1765,2580 +2022,2469 @@
    ],
    "window_display": false
   },
+  "vscode": {
+   "interpreter": {
+    "hash": "2643ef1ecb4e72f15331668d402315679b29a004e65b7ec963f6cfe589581b49"
+   }
+  },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {
     "state": {
-     "00c2d98174e3442cb53cede504f5461e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_e8756b4d138f4c29a3c89c55606d02cc",
-       "max": 20,
-       "style": "IPY_MODEL_0cf14fed04f5453ba756a4a977270704",
-       "value": 20
-      }
-     },
-     "00e3a56c7d3a467ab1a928f1c590367c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "010a8fdfda9c4127afde5fefa7b00bc2": {
+     "0025836395b540e5a28bb3e676047ec9": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_8e6e48a232f44bb892db9de67279cb7a",
-       "style": "IPY_MODEL_5c56eb3ce2b747979d2adaff7690e45e",
-       "value": " 20/20 [00:00&lt;00:00, 31.69it/s]"
+       "layout": "IPY_MODEL_c103bd3c105f4c28b88e3b71044fb7f1",
+       "style": "IPY_MODEL_e8e3c48dd49a48f39577292d5e92f215",
+       "value": "100%"
       }
      },
-     "013021899ae140b3ab19cbb850b4ba19": {
+     "00620ebaf2c54aff99f9fc5ee3e27149": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_a8486808a7154641a4c756649718d8c6",
-       "style": "IPY_MODEL_1abc739f7f95454591fe9021aa5f2448",
-       "value": " 20/20 [00:00&lt;00:00, 62.05it/s]"
+       "layout": "IPY_MODEL_7bab947042b540efaf498346b83880d5",
+       "style": "IPY_MODEL_37e2e5818c9940e69bcb98e0261e67ce",
+       "value": "100%"
       }
      },
-     "013f82fff78c4f23b086a4c5806b23d2": {
+     "00820fb2f8894fa38f2f88ea1bcf450f": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "01ce70236940473998203d0671538b15": {
+     "00a423de9d714ee28699fae2f8c8696d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "02ddb628bb4d460ca35d6aa242e61756": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "04bd8dd4de204602b62cd39669965cd4": {
+     "0190ce522dcf4d59b7e8986472f425d5": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_3e8484ed8e854f749446e9341165fba4",
-       "style": "IPY_MODEL_ff506b3a47814b229ad2bab10a4dc528",
-       "value": "100%"
+       "layout": "IPY_MODEL_3d4a66c3e090415cb7c6f309a2d5dc1f",
+       "style": "IPY_MODEL_1e7974757bb34201843ebc0d73795961",
+       "value": " 19/20 [00:00&lt;00:00, 59.95it/s]"
       }
      },
-     "05bf0665baac4c9e8be9f3272d22ed96": {
+     "0251abfff957407eba9b240618313e0c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0378537e69dd4cfc8beb05ab6742ffcf": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0379c4e854684f4eaa49cdab48f5d7e0": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "042025c1ce874ddb8bf58be5925dcd21": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_93a4cc38550143b4b98a2054cc7369e2",
+       "layout": "IPY_MODEL_8ced257c358241b6af032b5883655fbb",
        "max": 20,
-       "style": "IPY_MODEL_56bf2a8e15bc49dca944418bc7c090cb",
+       "style": "IPY_MODEL_71d85d586c5c41d1bfbb67a471219f9b",
        "value": 20
       }
      },
-     "0708eeb12d0945d6a6ec1343957557d0": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+     "062ec452220640b4a1b80f9cf0dde981": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "layout": "IPY_MODEL_8ad67d447a42444ea063eb77f1500ec4",
-       "style": "IPY_MODEL_3ecb5093e49545f7a8b28f1b58a819b8",
-       "value": " 10/10 [00:00&lt;00:00, 52.77it/s]"
+       "visibility": "hidden"
       }
      },
-     "07aa36e55dc149f6bdc89c93d0b262cd": {
+     "06f59874b47747daae0c755c1153cf8a": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "07d452db1d9443ff89efa0cb9a343d8e": {
+     "078f377d1c044f589bfafa4a1dcf9e88": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_de52b5d4314a45ab94b17ad151769ed9",
-       "max": 20,
-       "style": "IPY_MODEL_760bff366765422ba7f286b94eb68f3f",
-       "value": 20
+       "description_width": ""
       }
      },
-     "08af5fd481f54c038f5e6886a94a49c8": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+     "07cf32afa31145b7a36ada3aff7e9553": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0b145d3f3ac54acaa40f73de1566647d": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0c215d5b062e4bd8b817dd7e9818cb84": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_1eeeeadf05a847efa06e0ace5b7e7834",
-       "max": 20,
-       "style": "IPY_MODEL_610b841201994cfaba31feefc13ff7ed",
-       "value": 20
+       "layout": "IPY_MODEL_0379c4e854684f4eaa49cdab48f5d7e0",
+       "style": "IPY_MODEL_c5c37c89337e4a4390ae6dbe42ff923d",
+       "value": "100%"
       }
      },
-     "093280bcc01143c187b590a1cec658ad": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+     "0c77635e88db42f9b00c6accfe789c84": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "visibility": "hidden"
       }
      },
-     "0aeeb3b4f4564222a2c6e726444f5d56": {
+     "0d15b755d8d142df9d8951bbaf5bb038": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0d4688c5569e45eb815cb8f3f18fd628": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "0bc04d9b49ce4c2e907c3aad7bc14179": {
+     "0db023e0b4c04517b1572e0016fd6097": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "0c4d78a6b3974016800dee8ad9d89509": {
+     "0e27c837d07949e88bd57f35a93535f3": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "0cf14fed04f5453ba756a4a977270704": {
+     "0fac0bb47214452eaab6dca844f9ed16": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "0d672a53b4cc4686979aada5d2afe122": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0d67dc1bb3db48ff8974906666d0e1a1": {
+     "0fae9d6d47ef4f1596eb208504dc4961": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_98fd529481104ec89267b3909b3e152a",
-       "max": 400,
-       "style": "IPY_MODEL_994d71f25ffb4d90ac758eb2016a933e",
-       "value": 400
+       "layout": "IPY_MODEL_8a9995a5e11a40b89cc72c265e0cb26e",
+       "max": 20,
+       "style": "IPY_MODEL_b49cb6e80e314b13a821d9e5031aba44",
+       "value": 20
       }
      },
-     "0d85209023cc47a89da206f653056e99": {
+     "10b4363f69f043cb8623f65e03ef1d88": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "0df02c84178e4f7fbfb2fa29a591d787": {
+     "113135000080412bbf1d8aaea28e6dfb": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
+      "state": {}
      },
-     "0e3b59aa2bd74a39ad3f654ec5f8d854": {
+     "11d134b24dbe4e58bf948649c437d793": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_11d9394da6ae41cd921b7eb54eb40a0a",
-       "style": "IPY_MODEL_c046484e2ce8404b97f18773e017345d",
-       "value": " 400/400 [00:06&lt;00:00, 59.47it/s]"
+       "layout": "IPY_MODEL_e8caf93443974e8b88b2182329a0c4da",
+       "style": "IPY_MODEL_91ec8c653a2e432fac257deb8aaa5633",
+       "value": " 95%"
       }
      },
-     "0eb80399eeb841339f13ac3ebbb961bd": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0ef1e893eff34ec7b78694957c18a67f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "10fb4e3293894ff2906c3fafd923f0a8": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "112fa44c0fbe49fabd19557c48352959": {
+     "11fd5f7647cb42d9b09a30606c0e139f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_f592530374a749a89a4c98a0602bafe0",
+       "max": 20,
+       "style": "IPY_MODEL_7d959d4ddeb04b06bd476ea6be819d8e",
+       "value": 20
       }
      },
-     "11d9394da6ae41cd921b7eb54eb40a0a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "137941f5fa9b487287db6d8e0cd98d37": {
+     "13c63d3a53834e78ac7c33968a8b92ff": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "138223163d8e4b68b2a64a9b7a05a14f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
+     "13e18a3a2b97435fa56a7edf6c0a1ce3": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
      },
-     "141c93a0c2a046b59cb963a971390fa8": {
+     "1468759bf4dc44fba11b028aa1873cee": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_9d464d8970aa48319ccff0d618ebe190",
+       "layout": "IPY_MODEL_e5bb5b15444642ea86f86e62a361b959",
        "max": 20,
-       "style": "IPY_MODEL_0c4d78a6b3974016800dee8ad9d89509",
+       "style": "IPY_MODEL_96e207c3e2774a928b72c44613f0e3f5",
        "value": 20
       }
      },
-     "163a4b887d384f12aa0e67629c0e8cc0": {
+     "14fe0b96ad024a67b0433701fc410228": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_68c0c5d9c70d455e810527c5140ac4ba",
+       "layout": "IPY_MODEL_e7b34ebd626443458c1eccfa80611992",
        "max": 20,
-       "style": "IPY_MODEL_c68375ce45c64f289c2af4ce6fe38ce5",
+       "style": "IPY_MODEL_dab99855ef0e44d1999f1902a60a8c42",
        "value": 20
       }
      },
-     "16b00410ae494e70ba4cb5c380edb1d7": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "16bb2a454d194503adca31ee9b0ef39a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "1729cb7e977d430fb4010569c0a1d507": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_ee16dc27cbe84d3ea3166c9faa30b4f1",
-       "style": "IPY_MODEL_cae4a01a80364702ba97aa6c18835cc2",
-       "value": " 95%"
-      }
-     },
-     "174bc746183948c8a9e643156ee4b2e8": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "178fb1f0cd5a4c309c5eba6e9543fabe": {
+     "15b506a240a54366874760d97e60f774": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "18ac03ae3af545d2accf43ece3e31eba": {
+     "160706bc827e4f5d852adfc96cc30c3e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "1abc739f7f95454591fe9021aa5f2448": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "1bee4fe6c35d469ab69ab6f9be524457": {
+     "16bbd1ecfcde4e10972fa8e8289c784a": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "1c46b682de704aecaa2749f3574db703": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_a56a1830a20449ec9d58cc4b0d45514f",
-       "style": "IPY_MODEL_07aa36e55dc149f6bdc89c93d0b262cd",
-       "value": "100%"
-      }
-     },
-     "1c7266d683a8429c9a3f04cf44b7ff23": {
+     "16cf2e2fd05144ffbd0a7058ecb46166": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "1eb064bcd68d49f98fcdcabd410b24b7": {
+     "1813196e82b34e2e8c6ad657040164be": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "1eeeeadf05a847efa06e0ace5b7e7834": {
+     "1844ab8cb0614eaeb9b798d583273f8d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "1f1704e81db849b9808f426d5da8fca2": {
+     "1a1b079608c04df48f418e25a7e136da": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "1f6e7e24698745c5bca7d5d76977048f": {
+     "1ad32f6a9ef64ef3aae6bcae8151f08f": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "201f761c93d446aeb7f3b868619170d4": {
+     "1b78996363e04c619de1943d9c64b083": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "1c15ffc0573044b3bb4067b8713241e4": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_80a1ac66a186411095f857cc7c37a8d5",
-       "max": 20,
-       "style": "IPY_MODEL_e3c52b67639c468d9120422f4cb7cfbe",
-       "value": 20
+       "description_width": ""
       }
      },
-     "20d7ed3aaa3041f98e4f291b5188bfa3": {
+     "1d2c9b832f18450d96db9099b1b982ac": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_2498be56c25c4e60ae7985ef5a168228",
-       "style": "IPY_MODEL_9d0125010f3c4a1fbeb7cea475c81360",
-       "value": "100%"
+       "layout": "IPY_MODEL_00820fb2f8894fa38f2f88ea1bcf450f",
+       "style": "IPY_MODEL_7228c9a58e1c492ea92ffcd8df0cb983",
+       "value": " 95%"
       }
      },
-     "214f9b0ef8f44725a9c6ac532f55c5e9": {
+     "1e7974757bb34201843ebc0d73795961": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_1bee4fe6c35d469ab69ab6f9be524457",
-       "style": "IPY_MODEL_85fbd48c91ad43d591900d609d95827d",
-       "value": " 400/400 [00:06&lt;00:00, 61.93it/s]"
+       "description_width": ""
       }
      },
-     "23fe2d729fa544b7bbe582dbe25dd350": {
+     "1e86322883014f17a94aef265a972b98": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "248c79c404e14f40acc8d0d159a52f41": {
+     "1e8edddaad964339aa3f3d986dddea83": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "1eab564e47124f5d8caf5adfc1d5f20e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_e68512a5d164435a81de962de333b97f",
+       "layout": "IPY_MODEL_33f594200d0041008d37b031c0c9bcf6",
        "max": 20,
-       "style": "IPY_MODEL_01ce70236940473998203d0671538b15",
+       "style": "IPY_MODEL_ac50bddccd62413289dd9e4fb0c81133",
        "value": 20
       }
      },
-     "2498be56c25c4e60ae7985ef5a168228": {
+     "1f03c566660e4c11b0da377007351708": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "24abfc0efe134c6088835ff6f8cebe59": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "257e85ffd3e44119b921e99c4f47545e": {
+     "1f2a002a5a5f4614ad615ad02094f306": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_d773dad7c97141ed87a77d75c733c737",
-       "style": "IPY_MODEL_137941f5fa9b487287db6d8e0cd98d37",
-       "value": " 90%"
-      }
-     },
-     "267e93c69c9a4abc8e5788389e1103fa": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
+       "layout": "IPY_MODEL_1b78996363e04c619de1943d9c64b083",
+       "style": "IPY_MODEL_e26270d9e03d49bb85b2b68a3df99cbd",
+       "value": " 19/20 [00:00&lt;00:00, 56.57it/s]"
       }
      },
-     "2724a0b60eb54cff8fd8d569bca071a8": {
+     "21cd1c3cc09547dda54ca04bd6383d64": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_38ccb1286d744b489bba4ea31e9113c6",
+       "style": "IPY_MODEL_406219f03f8f4f11b7be92d445cbaa02",
+       "value": " 10/10 [00:00&lt;00:00, 49.91it/s]"
       }
      },
-     "2860f54a3f3e4c41a96f5647f88bb496": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2b1a16b343d64c42aac226331b58f237": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2bbafa8428ff4bd6bea61e71bd05d212": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2cd1c5afd42748f48a3d4e74779d934b": {
+     "22cdac5099ab4a9e8bc06de49e166132": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "2e6ed0d772804924a17fa3b465967907": {
+     "244e6198d45040c490758f440a80999c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_fb51251b9df04721bada4cc984f0088d",
-       "style": "IPY_MODEL_02ddb628bb4d460ca35d6aa242e61756",
-       "value": "100%"
+       "layout": "IPY_MODEL_0d4688c5569e45eb815cb8f3f18fd628",
+       "style": "IPY_MODEL_6de446e187184118a580f5a68c4f26ad",
+       "value": " 70%"
       }
      },
-     "2ee47ce3639b4ff185d2f5274e45b96e": {
+     "246cc76521d54d1284405f56c122f332": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "24d8d594870b4c75af8f1bd360de5a38": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "bar_style": "success",
+       "layout": "IPY_MODEL_9e0285285073405db113bf4d6ff7e098",
+       "max": 400,
+       "style": "IPY_MODEL_aaeb9d0cd6124e43b0d299417e2a5d5c",
+       "value": 400
       }
      },
-     "2ef4ca12b4d84324abc3b255a0bc86a7": {
+     "27ba2a5ca62845bf8f73d947391ad22e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_882d9577b1b3416a913ca3f484f13dac",
-       "max": 20,
-       "style": "IPY_MODEL_a36de466a3484a79bfbd562eb4455ba3",
-       "value": 20
+       "description_width": ""
       }
      },
-     "329656b2f7a3449b8250ac3a2bef42b9": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "36e568b08f2c4147a9ed121af63f0635": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "378eb3165ccc48158da3fff83b0aab38": {
+     "27cb4e98ffb441f5b17bfa25474b669c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "37f323cf28934b98a2377f5de541cbc4": {
+     "293f30f6b3fe4aed99f3e317651d07e0": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "38b72f4f9e694a2c8795a3a579e97106": {
+     "2a7dd2f362b14fea91edf45406728029": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "39ae834bdb0a4b3bbba7abf4d9dceec5": {
+     "2b41856ed2bc4c79839d262ae43ddad8": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "3c553775e4d84174960ea13ebc021d79": {
+     "2b98fdadef774350bf0350a6f5a54449": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "2bff27af97db420d8661085faa21328b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_f556e7d31b5243de99d81dd41fd3b65b",
-       "style": "IPY_MODEL_138223163d8e4b68b2a64a9b7a05a14f",
+       "layout": "IPY_MODEL_c8a69a2b5dbf4bf791623a10aeab6f8f",
+       "style": "IPY_MODEL_54a80318f86a4a7cbf5877dbfc9dbabf",
        "value": "100%"
       }
      },
-     "3c88a0299be2429fb3f0df6606fdf583": {
+     "2cd4ae025bc94c7d9aa8c9cfadfa705f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_9d22eddd792840f08476429c262c6668",
+       "layout": "IPY_MODEL_aadc7705c2374eb083c9eb047ac50e84",
        "max": 20,
-       "style": "IPY_MODEL_d08c0fdaf8664ac49fcc3965e607e828",
+       "style": "IPY_MODEL_a7d51bfc34c5420b9766dba17db42ce0",
        "value": 20
       }
      },
-     "3d7870d01c8342b38b4e8534811f44ba": {
+     "2eb6f77849ad425994e67651adc4687c": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "3e8484ed8e854f749446e9341165fba4": {
+     "2f4a3f5a9bff46aaa41d6baabeb7666e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "3ecb5093e49545f7a8b28f1b58a819b8": {
+     "2f5f08992f7745b0b5452b2c22c8e015": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_99b595603c1d45dca3b8e5d3f9a90e1e",
+       "style": "IPY_MODEL_cd5e8e6e6dba4f018b03787d9fc04c59",
+       "value": " 18/20 [00:00&lt;00:00, 56.82it/s]"
       }
      },
-     "3fc88007650f4256934c240ba3ecbc0f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "410d43e069b4403180bcb53e1fcdd231": {
+     "33dc10e898b545fd95f6c1d0c70cf37d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "449b2980b030413bbd16e6a3d0747b63": {
+     "33f594200d0041008d37b031c0c9bcf6": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "47938a7a01b541d59b53946e2011e257": {
+     "35a0593e3d5842ba8d28a533abcf1046": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_cbf566af0d1440479c555c8181f69972",
-       "style": "IPY_MODEL_b2e7b2bd87924c949179b684777ec4a6",
-       "value": " 19/20 [00:00&lt;00:00, 60.56it/s]"
+       "layout": "IPY_MODEL_1813196e82b34e2e8c6ad657040164be",
+       "max": 20,
+       "style": "IPY_MODEL_1c15ffc0573044b3bb4067b8713241e4",
+       "value": 20
       }
      },
-     "483864d67a9a45c39cc64210b42f1efa": {
+     "360a899b4aee466688246f064df82c72": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": ""
+       "bar_style": "success",
+       "layout": "IPY_MODEL_dc74a6082a61499398c11d19bbb7308b",
+       "max": 20,
+       "style": "IPY_MODEL_22cdac5099ab4a9e8bc06de49e166132",
+       "value": 20
       }
      },
-     "48578378671145168dceb296df1dda3c": {
+     "360c99bcc6bb46958d5910bf8acb157f": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {}
+      "state": {
+       "visibility": "hidden"
+      }
      },
-     "4b8598ca6be2422db87f6246815ed5bf": {
+     "37e2e5818c9940e69bcb98e0261e67ce": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_9b8be44be04a43c99b2b36d07e691705",
-       "style": "IPY_MODEL_37f323cf28934b98a2377f5de541cbc4",
-       "value": " 20/20 [00:07&lt;00:00,  2.77it/s]"
+       "description_width": ""
       }
      },
-     "4be021eb37e24c3e96716f73137e56af": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "4c83604b800448e1b587899b872ed000": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "38c7296d85344116a5d0f66e8725dcf4": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "visibility": "hidden"
+       "description_width": ""
       }
      },
-     "4cb3e41e200c4a1e92f9f898a658069f": {
+     "38ccb1286d744b489bba4ea31e9113c6": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
+      "state": {}
      },
-     "4e4b0498a7cb42fcba1bb77fdf803ee9": {
+     "39b8055d531a4d2da11d4a2ad7e5982e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "4eec30445da147efa5c30d5f434d19b5": {
+     "3b5af7b3982d413e97866a5737181a7f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_bab3616dc353426fb3ae3292196c1521",
+       "max": 20,
+       "style": "IPY_MODEL_9636c1be747f4ed58c79e4c73f37fc06",
+       "value": 20
       }
      },
-     "4f140b9464e943f7ac53d9c31ddcea13": {
+     "3bb06145583f43658bd60c15a8416354": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_faafa1efaea74624be0551e9fdbfb577",
-       "style": "IPY_MODEL_56bffb855034457690f29fec78eb8d2c",
-       "value": " 20/20 [00:00&lt;00:00, 62.72it/s]"
+       "bar_style": "success",
+       "layout": "IPY_MODEL_0378537e69dd4cfc8beb05ab6742ffcf",
+       "max": 20,
+       "style": "IPY_MODEL_0db023e0b4c04517b1572e0016fd6097",
+       "value": 20
       }
      },
-     "5046999895a74f0182e4de2c0fc02711": {
+     "3bc2f9cc8ad640f3853e4f830418473f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "3c30fc657f7142fbb00b7c6dccf69863": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_d0d6e3cf71aa40f29aeee7607fd75987",
+       "max": 20,
+       "style": "IPY_MODEL_3e634a971a60499ea60b16f0d698b1fa",
+       "value": 20
       }
      },
-     "50e86c184fc446ec9ae7e768adba40d3": {
+     "3c57796efab14d288f6d4ff0fa4d1d5c": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {}
-     },
-     "5147e451170047398934f3475550aaac": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "visibility": "hidden"
       }
      },
-     "54600ca96e784155afd63e8590573803": {
+     "3d4a66c3e090415cb7c6f309a2d5dc1f": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "549819eed0c244c2a9ba38dff51a2423": {
+     "3d9481641482475cbf3a39daf55d5e17": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_ba2b1e11257a49318ac498606ef2e072",
-       "max": 400,
-       "style": "IPY_MODEL_2cd1c5afd42748f48a3d4e74779d934b",
-       "value": 400
+       "description_width": ""
       }
      },
-     "5589e5de36524057a6fae80a55f3611b": {
+     "3df356d0c6eb422abbb2bd15d62748d6": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "56ba97ec8c134b30b4a2f83aa1468d9d": {
+     "3e5c390dbe2340e7bcc16c308a0526ac": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_ec81aa182cc8434f856e3a5655ba14c5",
+       "style": "IPY_MODEL_3df356d0c6eb422abbb2bd15d62748d6",
+       "value": " 95%"
       }
      },
-     "56bf2a8e15bc49dca944418bc7c090cb": {
+     "3e634a971a60499ea60b16f0d698b1fa": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "56bffb855034457690f29fec78eb8d2c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
-      }
-     },
-     "586a5b6c66f24569ac422a4d98551e2e": {
+     "406219f03f8f4f11b7be92d445cbaa02": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "children": [
-        "IPY_MODEL_b908cc166330450fb68c6f507dba17ea",
-        "IPY_MODEL_f15bc2efb4a54b49a717ce8af654e91b",
-        "IPY_MODEL_827e5cb47cb548b1856185f1b1cd8d84"
-       ],
-       "layout": "IPY_MODEL_aa23ed2b688145d5ba97ea7480689042"
+       "description_width": ""
       }
      },
-     "599136a66d324b3086fcc808224e87be": {
+     "4581de95d1b14b5eb4cf54dedf362611": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "5bd6cf2ea1b94029bbb6c3aadf6c74f7": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "468745258da649e7b3739e5c5922364d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "visibility": "hidden"
+       "description_width": ""
       }
      },
-     "5c56eb3ce2b747979d2adaff7690e45e": {
+     "4749b6ff817047fc9c1364d7ba49ed74": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "children": [
+        "IPY_MODEL_aa8f9ad35948479fbdb929648657e8fc",
+        "IPY_MODEL_b3d0ae2ccc9941adab0bf96aef018c49",
+        "IPY_MODEL_d221a2ed8e4d4747b389dfb2edfc3fdb"
+       ],
+       "layout": "IPY_MODEL_1e8edddaad964339aa3f3d986dddea83"
       }
      },
-     "5cac119e961e47b396d78c015a5b956f": {
+     "48c4e96b636c41cc95e826dce8092485": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "5cb499e3a68f473e8c4d6da292b097e8": {
+     "4c90876e84d342c98a58e2b33498ebfd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_aef2fa1b401f456791bfa49b761f1d4c",
+       "style": "IPY_MODEL_55dbc208d79e4e14a6e1d7e71a3a4ebd",
+       "value": " 20/20 [00:00&lt;00:00, 58.36it/s]"
       }
      },
-     "5ce876134967494cbbc6cfb66d435821": {
+     "4dabd9b6919145ebad699491d2f71192": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "5da13443125047ada5fe59781418a55e": {
+     "5003373f58b94ec1ad825039cea1a9ee": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_88fc64cb9fca4d508ed0b388aa1ff0ee",
-       "style": "IPY_MODEL_c6e04308e69244cdabbadab1aa0d4eaf",
-       "value": " 95%"
+       "layout": "IPY_MODEL_e40e3ce50a2c47c1a7217b178bfec173",
+       "style": "IPY_MODEL_64bb2daf89164b59b98a5b8212ed2ea8",
+       "value": "100%"
+      }
+     },
+     "515dec0366e648aead0d9023dee598e6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_53e6d3f651794a319e5e53d746b6a259",
+       "style": "IPY_MODEL_c1d353df9fd24e909169a1c7c15b861b",
+       "value": " 18/20 [00:00&lt;00:00, 57.54it/s]"
       }
      },
-     "606d1273eb7641b0af9e96e2d754a784": {
+     "53e6d3f651794a319e5e53d746b6a259": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "60fe099d06954b47956b6d1b10e7dc90": {
+     "54a80318f86a4a7cbf5877dbfc9dbabf": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_7eb9fdf637a9401a9104110ca63b8dba",
-       "style": "IPY_MODEL_a445e8a8fa5d4ae2a9849d0d10fc4528",
-       "value": " 20/20 [00:00&lt;00:00, 62.71it/s]"
+       "description_width": ""
       }
      },
-     "610b841201994cfaba31feefc13ff7ed": {
+     "55dbc208d79e4e14a6e1d7e71a3a4ebd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "611ffacd55e0427bbc23f27f8065280c": {
+     "56e383da6e6f42efbfb67564709c64ac": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "5775f3cdfb6b40729f507c23825146f4": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_c44c5cc6f5c340ef8ab71828df5fd31b",
+       "style": "IPY_MODEL_789fa7b80b1c4484a271358a0a62149b",
+       "value": "100%"
       }
      },
-     "61258f2d18744df0b2d8b9a4d1a68760": {
+     "59f97ef7c6984af69593bc7c3dd8183a": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "children": [
-        "IPY_MODEL_f16939dd44284cd997d4d08c5f67e5d7",
-        "IPY_MODEL_f13475935b20445ab7fa3c084e779dce",
-        "IPY_MODEL_0e3b59aa2bd74a39ad3f654ec5f8d854"
-       ],
-       "layout": "IPY_MODEL_9595f9aa11fb425f8c3c4aaa92fe95af"
+       "layout": "IPY_MODEL_f412a75adeae4dd8a1d15c81203934b7",
+       "style": "IPY_MODEL_bdc57f6b8b344263aa6fe293c466e349",
+       "value": " 20/20 [00:00&lt;00:00, 58.89it/s]"
       }
      },
-     "64134e5969be4176873db01f8f94ba72": {
+     "5a314f9984d0470d8f9dc3b48016c04d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_160706bc827e4f5d852adfc96cc30c3e",
+       "style": "IPY_MODEL_b1123e7c1b77420cae0ec3d8234602b1",
+       "value": " 19/20 [00:00&lt;00:00, 49.87it/s]"
       }
      },
-     "64abc9733c0846f7a811f528737b118b": {
+     "5a6e17f48dd249c2981d0da672f84446": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "layout": "IPY_MODEL_329656b2f7a3449b8250ac3a2bef42b9",
-       "style": "IPY_MODEL_56ba97ec8c134b30b4a2f83aa1468d9d",
-       "value": " 20/20 [00:00&lt;00:00, 62.61it/s]"
+       "children": [
+        "IPY_MODEL_5775f3cdfb6b40729f507c23825146f4",
+        "IPY_MODEL_d598e54836f140a89a9a993b83b6504c",
+        "IPY_MODEL_b06d9b42c7d34d7b819e42c9d497b1b2"
+       ],
+       "layout": "IPY_MODEL_8f352f46c9464e5984b778338fe2d92d"
       }
      },
-     "662b8f036e0f408b880a73869464c58d": {
+     "5c057b9e4a094138959779154aebb9de": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "68b9cb7f26cd44d081ee4215f36022fb": {
+     "5c13cfbcfde648a793753b9508551491": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_d8387558b3d74b938cf7aa66665f7822",
+       "max": 20,
+       "style": "IPY_MODEL_8c9b5977d63645759aeb60e98c93e478",
+       "value": 20
       }
      },
-     "68c0c5d9c70d455e810527c5140ac4ba": {
+     "5f25794d950b491f8ff602e32824ed00": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "698a86e02cee44759b3726620097a290": {
+     "5f89abcfb66a497f827948939e352d92": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "visibility": "hidden"
+      }
+     },
+     "61085fae5c3f4f14ae55b9dcf6d15091": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_3fc88007650f4256934c240ba3ecbc0f",
-       "style": "IPY_MODEL_82930f6d1584471ea729a8285297daeb",
-       "value": " 95%"
+       "layout": "IPY_MODEL_5f25794d950b491f8ff602e32824ed00",
+       "style": "IPY_MODEL_38c7296d85344116a5d0f66e8725dcf4",
+       "value": " 19/20 [00:00&lt;00:00, 57.49it/s]"
       }
      },
-     "6a3317fc6a1545b8aa948806e655db61": {
+     "61d0b03fb5894eae89991e0e53b2ee89": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "62f8308ae58d417489c882051520898e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "6a8174332efd4bc7a497e355f4db1e49": {
+     "63340a6c0b6c4589a641386ae67a69bb": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_be1cf1c1e96a47798e160723dee6f31c",
+       "style": "IPY_MODEL_909e2ac0f69e4982877128c1e268ae79",
+       "value": "100%"
+      }
+     },
+     "634847862f0542d390fc37cd5fbcd713": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "6b0b31585c6844c7a839b352fba5494f": {
+     "64bb2daf89164b59b98a5b8212ed2ea8": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "6c6ab6bc5c764cc28ebab0e900a3777d": {
+     "650a65150c694b2996f85bb7cd1b8db4": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_5ce876134967494cbbc6cfb66d435821",
-       "style": "IPY_MODEL_f948b536b8544df89173165784b2d29b",
-       "value": " 90%"
+       "layout": "IPY_MODEL_c6783899f76d49d5a4f3815bf1edbbde",
+       "style": "IPY_MODEL_d9a4d571993d4240b538df9f86e2f172",
+       "value": " 19/20 [00:00&lt;00:00, 59.58it/s]"
       }
      },
-     "6da98046cbb948f7a915cee8373bdf33": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "6dfcfdb33741456c8ba6863d870ba318": {
+     "67489466332942c5996de61f223003e2": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "6f4079c2790b428d84fcb6c088278863": {
+     "69e78be767164eb6871e72286a4df106": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "71d6294930324a238aa89058b81219eb": {
+     "6a643f694fc24c459b32d5efab6866ad": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_a6933d6781164693a521a438c1a509ef",
-       "max": 20,
-       "style": "IPY_MODEL_378eb3165ccc48158da3fff83b0aab38",
-       "value": 20
+       "description_width": ""
       }
      },
-     "7248d98fa20748e69269d5362bfacc0c": {
+     "6a6d93f09b234586988c4d260039363d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {}
+      "state": {
+       "visibility": "hidden"
+      }
      },
-     "73ecbf3f41494c4bb125e82834ecce9c": {
+     "6a7ea74042704bb39511701116e63fad": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_a762dce447964f42a962940a93e344c8",
+       "style": "IPY_MODEL_f083caacc043492fb5ca63fc30b0328c",
+       "value": " 20/20 [00:00&lt;00:00, 61.58it/s]"
       }
      },
-     "75474d2df90b4b67a022084ccbd196a5": {
+     "6adb061cfc7845e7919e940fa62f531e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "756dee4b72b2412ba9ddb22d1c4a4d8d": {
+     "6ce7dc29016946caa8b6133a3b3e6e92": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_16bbd1ecfcde4e10972fa8e8289c784a",
+       "style": "IPY_MODEL_f7d2d299cca643789df638e0d886dba9",
+       "value": " 400/400 [00:07&lt;00:00, 58.43it/s]"
       }
      },
-     "75a9fef8c6354483b89636de1a9ac987": {
+     "6dda613029c84f1586b2df76ef342187": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_9c2310e8cc7b466e89080661badca172",
-       "style": "IPY_MODEL_b3a85650635440df86d95ad23aa748ce",
-       "value": " 400/400 [00:06&lt;00:00, 61.71it/s]"
+       "bar_style": "success",
+       "layout": "IPY_MODEL_e92536cb0c204a669bad5d5296422ac1",
+       "max": 20,
+       "style": "IPY_MODEL_16cf2e2fd05144ffbd0a7058ecb46166",
+       "value": 20
       }
      },
-     "760bff366765422ba7f286b94eb68f3f": {
+     "6de446e187184118a580f5a68c4f26ad": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "7617a31728cb43da9a5859861e4334db": {
+     "7076cd7669ba423ea56c5d22752409aa": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "7155e0b738344e269371852eb9473110": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "778e5497f5cb4da5b33e7054a51804ad": {
+     "71d85d586c5c41d1bfbb67a471219f9b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "children": [
-        "IPY_MODEL_04bd8dd4de204602b62cd39669965cd4",
-        "IPY_MODEL_9ef5a39b271e4b539689a9e10db0da03",
-        "IPY_MODEL_b45cea895e6340e59b82a5ad1f5b076c"
-       ],
-       "layout": "IPY_MODEL_e12740eb48e24a49b95a066099a18ee1"
+       "description_width": ""
       }
      },
-     "7834d9635e9b430985d40a556f8ac8e0": {
+     "7228c9a58e1c492ea92ffcd8df0cb983": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "783f26226d354bd09cd3649fdf42db20": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "785c3b38cfca489f98b9df8cbb80bf76": {
+     "74d995d46e074c6bac03728412284c58": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "7b5197d764784592bc4c82b95ed0122b": {
+     "766da6bdd0fb45aa9812cf252ec80d35": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_74d995d46e074c6bac03728412284c58",
+       "style": "IPY_MODEL_2a7dd2f362b14fea91edf45406728029",
+       "value": " 19/20 [00:00&lt;00:00, 59.05it/s]"
       }
      },
-     "7b64ae3a1ee244c8b6088d453455f754": {
+     "7686e4f7db8545d38f5267d5bec25596": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_8e5e7130d99a41b69e58e5df4ac9f3e0",
-       "style": "IPY_MODEL_112fa44c0fbe49fabd19557c48352959",
-       "value": " 18/20 [00:00&lt;00:00, 57.41it/s]"
+       "description_width": ""
       }
      },
-     "7c2f5d76e62e45b185f7fab9c5486999": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "7eb9fdf637a9401a9104110ca63b8dba": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "789fa7b80b1c4484a271358a0a62149b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
      },
-     "7f59bea0ddd943dca0d45221dd810112": {
+     "79dfdb9f25854c549baf9a5741b81910": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "80a1ac66a186411095f857cc7c37a8d5": {
+     "7bab947042b540efaf498346b83880d5": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "8150e6ab760342c29d364967e862eaba": {
+     "7bedd22693a14b85b899ba215d9419fc": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_eaeb01e73f4745b9b3fb7dbcb778c4cd",
+       "layout": "IPY_MODEL_f953696dc9764d10b579151cd22863b5",
        "max": 20,
-       "style": "IPY_MODEL_73ecbf3f41494c4bb125e82834ecce9c",
+       "style": "IPY_MODEL_ce60ac23f4d54dc3a284865755de921d",
        "value": 20
       }
      },
-     "815bff7688944746b4cfdac61207c492": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "81ef049cde1a4610beb4c54a36003073": {
+     "7d959d4ddeb04b06bd476ea6be819d8e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "821e74bef6c24fc68b712b12c247409c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_174bc746183948c8a9e643156ee4b2e8",
-       "style": "IPY_MODEL_1f1704e81db849b9808f426d5da8fca2",
-       "value": " 20/20 [00:00&lt;00:00, 62.50it/s]"
-      }
-     },
-     "826a9d592b5547dcbd9e492c42e88b1c": {
+     "81ef3571ab38486ba39e7dbc2db868df": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "8273e0d29dd04e6da2594da7d8ada867": {
+     "82c65b5927154111b6b7582ea3d111ad": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_48578378671145168dceb296df1dda3c",
-       "style": "IPY_MODEL_756dee4b72b2412ba9ddb22d1c4a4d8d",
-       "value": "100%"
+       "layout": "IPY_MODEL_62f8308ae58d417489c882051520898e",
+       "style": "IPY_MODEL_d5ccc83fdf574d6d96ccc3d6df10fbaf",
+       "value": " 20/20 [00:00&lt;00:00, 61.15it/s]"
       }
      },
-     "827e5cb47cb548b1856185f1b1cd8d84": {
+     "841ff5b845044cf4bf2cff9ad02e1f9b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_0d85209023cc47a89da206f653056e99",
-       "style": "IPY_MODEL_6f4079c2790b428d84fcb6c088278863",
-       "value": " 20/20 [00:00&lt;00:00, 53.43it/s]"
+       "layout": "IPY_MODEL_2eb6f77849ad425994e67651adc4687c",
+       "style": "IPY_MODEL_a09b7859737240979a15c3b5f4644c30",
+       "value": " 14/20 [00:00&lt;00:00, 63.78it/s]"
       }
      },
-     "82930f6d1584471ea729a8285297daeb": {
+     "85b71fd87bf143a18603928c2479b4f0": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "83b910527c3b4c168e028d127eefabe1": {
+     "86bb885bec84460d8482dfcd09ee6cc7": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "85fbd48c91ad43d591900d609d95827d": {
+     "86f6675020314335a7e2202e5ee52b56": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "869354bcbb954db6bbcb0137ba76552a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_4be021eb37e24c3e96716f73137e56af",
-       "style": "IPY_MODEL_9f71143b4fc748ecbee896e851277805",
-       "value": " 18/20 [00:00&lt;00:00, 55.84it/s]"
-      }
+     "8a50b6c36fe147e6a5e11fdea54ceb79": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
      },
-     "870f643919ae464a8dd456878e19239f": {
+     "8a9995a5e11a40b89cc72c265e0cb26e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "87174324fd1c4c44bda21afa78696ce4": {
+     "8c9b5977d63645759aeb60e98c93e478": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_783f26226d354bd09cd3649fdf42db20",
-       "style": "IPY_MODEL_cd780eede04943689a2b0b056c1f335b",
-       "value": " 20/20 [00:00&lt;00:00, 30.78it/s]"
+       "description_width": ""
       }
      },
-     "882d9577b1b3416a913ca3f484f13dac": {
+     "8ced257c358241b6af032b5883655fbb": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "88fc64cb9fca4d508ed0b388aa1ff0ee": {
+     "8f352f46c9464e5984b778338fe2d92d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "89519dc0bf1a431d960c2be04f2c3f4b": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "909e2ac0f69e4982877128c1e268ae79": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
      },
-     "89f134c849d54a52b171c5094464576b": {
+     "90bac4b9cf9944eda1a6bba1e2b0cf7a": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "8a9525e77c9a42fcb4dfde761097ffcf": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8ad67d447a42444ea063eb77f1500ec4": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8c3cfd44650d402e8128eb868b176419": {
+     "914b7d8a07d24c749b324e292501b9fa": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_9243efe7025d48458d5496d84806ee7a",
-       "style": "IPY_MODEL_9620db68c56e49a4ab8c9fbe8a899e92",
-       "value": " 19/20 [00:00&lt;00:00, 59.99it/s]"
+       "description_width": ""
       }
      },
-     "8cf0aadbc7da48de9a99563f7c87ba6b": {
+     "91ec8c653a2e432fac257deb8aaa5633": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "8da47634af9f4d1bb6fd92da3bdd54af": {
+     "9315b47ef65647f485067d87f9c806cd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_2bbafa8428ff4bd6bea61e71bd05d212",
-       "max": 20,
-       "style": "IPY_MODEL_ea146a08f011474ca22b90ab3c2cfaec",
-       "value": 20
+       "layout": "IPY_MODEL_2f4a3f5a9bff46aaa41d6baabeb7666e",
+       "style": "IPY_MODEL_48c4e96b636c41cc95e826dce8092485",
+       "value": " 20/20 [00:00&lt;00:00, 62.71it/s]"
       }
      },
-     "8e5e7130d99a41b69e58e5df4ac9f3e0": {
+     "932f1e4dbf674f21a43362a9fd959278": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8e6e48a232f44bb892db9de67279cb7a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+      "state": {
+       "visibility": "hidden"
+      }
      },
-     "8f4c18525d8e4310bfb18836e03332dd": {
+     "95b040cabe4a41d88ea231eaad666896": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_013f82fff78c4f23b086a4c5806b23d2",
-       "max": 20,
-       "style": "IPY_MODEL_ceafb25f1905481c819760fe7c5c7917",
-       "value": 20
+       "layout": "IPY_MODEL_b4ce66fb28dc4e05807d1250fd0fcda9",
+       "style": "IPY_MODEL_69e78be767164eb6871e72286a4df106",
+       "value": " 20/20 [00:07&lt;00:00,  2.63it/s]"
       }
      },
-     "908d9817b5b841c49a1933461f977248": {
+     "9636c1be747f4ed58c79e4c73f37fc06": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "children": [
-        "IPY_MODEL_3c553775e4d84174960ea13ebc021d79",
-        "IPY_MODEL_b67a1d490012494383abca28630cbe37",
-        "IPY_MODEL_4b8598ca6be2422db87f6246815ed5bf"
-       ],
-       "layout": "IPY_MODEL_785c3b38cfca489f98b9df8cbb80bf76"
+       "description_width": ""
       }
      },
-     "9125fa5d89af473f9251c5acd55ccca4": {
+     "96e207c3e2774a928b72c44613f0e3f5": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_fa6c542c2c144cf9a13963702cd220c8",
-       "style": "IPY_MODEL_38b72f4f9e694a2c8795a3a579e97106",
-       "value": " 19/20 [00:00&lt;00:00, 58.98it/s]"
+       "description_width": ""
       }
      },
-     "91743e153f0f475f9db5f9dfe5ae63f5": {
+     "97eba679b30147a3b6ad77026f56f16c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_eef95a7f98c5435faae73df38e12e5f9",
-       "style": "IPY_MODEL_16b00410ae494e70ba4cb5c380edb1d7",
-       "value": " 20/20 [00:00&lt;00:00, 62.47it/s]"
+       "description_width": ""
       }
      },
-     "9243efe7025d48458d5496d84806ee7a": {
+     "9852e2768873485190a0902b121f52db": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "99b595603c1d45dca3b8e5d3f9a90e1e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "927a73fd49d346e6bd44199dce144217": {
+     "9b7d0d972a0a43edb043491a44a9ff7a": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "93a4cc38550143b4b98a2054cc7369e2": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "9d771bdcbc1642d7a86dd80a16c621f1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f9211e9657204bf2be2b419b9496c0a2",
+       "style": "IPY_MODEL_86bb885bec84460d8482dfcd09ee6cc7",
+       "value": " 95%"
+      }
      },
-     "9595f9aa11fb425f8c3c4aaa92fe95af": {
+     "9e0285285073405db113bf4d6ff7e098": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "95cfd5212a4049a181e7453f9ab6b21d": {
+     "9f9b0458fdaf4e719a9aad940ef0e128": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "children": [
-        "IPY_MODEL_2e6ed0d772804924a17fa3b465967907",
-        "IPY_MODEL_549819eed0c244c2a9ba38dff51a2423",
-        "IPY_MODEL_75a9fef8c6354483b89636de1a9ac987"
-       ],
-       "layout": "IPY_MODEL_7248d98fa20748e69269d5362bfacc0c"
+       "layout": "IPY_MODEL_0251abfff957407eba9b240618313e0c",
+       "style": "IPY_MODEL_c64624c677f24f6e95cc1aeb92bf7abd",
+       "value": " 20/20 [00:00&lt;00:00, 57.72it/s]"
       }
      },
-     "9620db68c56e49a4ab8c9fbe8a899e92": {
+     "a020f6eb56c6426fa67b8536bede9175": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "96491c033b93446db2e389175c5569c8": {
+     "a09b7859737240979a15c3b5f4644c30": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_815bff7688944746b4cfdac61207c492",
-       "max": 20,
-       "style": "IPY_MODEL_75474d2df90b4b67a022084ccbd196a5",
-       "value": 20
+       "description_width": ""
+      }
+     },
+     "a2fef1373f75488aa2aae8b1e8bb0309": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_b7b0f15b458e46c6bc07db1db517482f",
+        "IPY_MODEL_c6c562bb2f23403093bbb0840a67b3d5",
+        "IPY_MODEL_21cd1c3cc09547dda54ca04bd6383d64"
+       ],
+       "layout": "IPY_MODEL_cb32e7c112c848c4bcd50e7bf92ad9be"
+      }
+     },
+     "a47566f763e84971b348fad0f3045e2b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_eb63b0e5804d4ae986f52b40791ec081",
+        "IPY_MODEL_b72d472c18a645e5a6aab68b80a2d96a",
+        "IPY_MODEL_daceb5a73b81477086f42bf604ff354e"
+       ],
+       "layout": "IPY_MODEL_7076cd7669ba423ea56c5d22752409aa"
       }
      },
-     "988869fc44c54faa918316e60f20bb6b": {
+     "a56ce16f9d03474ba8f19af6b3c48495": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_6a3317fc6a1545b8aa948806e655db61",
-       "style": "IPY_MODEL_5cac119e961e47b396d78c015a5b956f",
-       "value": " 90%"
+       "layout": "IPY_MODEL_113135000080412bbf1d8aaea28e6dfb",
+       "style": "IPY_MODEL_27ba2a5ca62845bf8f73d947391ad22e",
+       "value": " 95%"
       }
      },
-     "98fd529481104ec89267b3909b3e152a": {
+     "a5c5f176648b40c98943b82e70311129": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "994d71f25ffb4d90ac758eb2016a933e": {
+     "a5cb87cf8eb34ecfaee717f660e88db3": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "99be57d2f6464fb38eb0bf6f0aa3afb9": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_2b1a16b343d64c42aac226331b58f237",
-       "style": "IPY_MODEL_c338bba6fdf847afb7f3767822d58405",
-       "value": "100%"
-      }
-     },
-     "9abf339411894c12aa643b0b788192c6": {
+     "a6e41b2254084f81a722c80be7ccbdf5": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_24abfc0efe134c6088835ff6f8cebe59",
+       "layout": "IPY_MODEL_b70ff1aac4b34686b1a8e55912abb4d2",
        "max": 20,
-       "style": "IPY_MODEL_0bc04d9b49ce4c2e907c3aad7bc14179",
+       "style": "IPY_MODEL_c44ffb313d734462b4c7484022a5f4fc",
        "value": 20
       }
      },
-     "9b8be44be04a43c99b2b36d07e691705": {
+     "a762dce447964f42a962940a93e344c8": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "9c2310e8cc7b466e89080661badca172": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "a7d51bfc34c5420b9766dba17db42ce0": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
      },
-     "9c914f8c2a1a4c86b8a2c70e028ea767": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "a86975aac7e7429195289bb01485879b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "visibility": "hidden"
+       "description_width": ""
       }
      },
-     "9cff84008ee842aca9c40b78d431db22": {
+     "a88d68e130fc4051889df9fdad9a1f5e": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "9d0125010f3c4a1fbeb7cea475c81360": {
+     "a8fae22cb6be4d3aad37559f6e859d98": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_4dabd9b6919145ebad699491d2f71192",
+       "style": "IPY_MODEL_00a423de9d714ee28699fae2f8c8696d",
+       "value": " 20/20 [00:00&lt;00:00, 61.55it/s]"
       }
      },
-     "9d22eddd792840f08476429c262c6668": {
+     "a9a6ce00ca3a4d8fa0e4ad618943b86d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "9d464d8970aa48319ccff0d618ebe190": {
+     "aa8f9ad35948479fbdb929648657e8fc": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_dee4c0f43fe44c288ea19337cfefb458",
+       "style": "IPY_MODEL_deeed6cf997f4a2c84a572f8fc4dd57c",
+       "value": "100%"
+      }
+     },
+     "aadc7705c2374eb083c9eb047ac50e84": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "9e843b329d034fdca65472a9c40017ba": {
+     "aaeb9d0cd6124e43b0d299417e2a5d5c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "9ef5a39b271e4b539689a9e10db0da03": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_178fb1f0cd5a4c309c5eba6e9543fabe",
-       "max": 20,
-       "style": "IPY_MODEL_81ef049cde1a4610beb4c54a36003073",
-       "value": 20
-      }
-     },
-     "9f71143b4fc748ecbee896e851277805": {
+     "ac50bddccd62413289dd9e4fb0c81133": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "a1e299e5adfd46d087a86b377286507d": {
+     "aef2fa1b401f456791bfa49b761f1d4c": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "a25f6f156d654ddd905700add2703fc8": {
+     "af68e481505441c7858f89b9997c1957": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "a36de466a3484a79bfbd562eb4455ba3": {
+     "af9925deb88c4cb1bf3e9bb3a5282c27": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_bbb081740d7f41c3aa7f57d0fcac7596",
+       "style": "IPY_MODEL_b244245d682841d0bb985a99cb21b033",
+       "value": "100%"
       }
      },
-     "a41a19a51d9b41928c5b9697b04fc88e": {
+     "afc74f3725b6486db926fea82da41a63": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "layout": "IPY_MODEL_eb29e815160d4f2ca75323c77ddaea05",
-       "max": 20,
-       "style": "IPY_MODEL_6a8174332efd4bc7a497e355f4db1e49",
-       "value": 20
+       "children": [
+        "IPY_MODEL_c1585d1507d34350936295cb3e1e10ef",
+        "IPY_MODEL_6dda613029c84f1586b2df76ef342187",
+        "IPY_MODEL_9f9b0458fdaf4e719a9aad940ef0e128"
+       ],
+       "layout": "IPY_MODEL_67489466332942c5996de61f223003e2"
       }
      },
-     "a445e8a8fa5d4ae2a9849d0d10fc4528": {
+     "b03840ab0fd740938e45d68480e91b5d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "children": [
+        "IPY_MODEL_e847b2925c9440028013b8319b93c86b",
+        "IPY_MODEL_be85d91ad53f4088a557c4fa8e8c41a3",
+        "IPY_MODEL_59f97ef7c6984af69593bc7c3dd8183a"
+       ],
+       "layout": "IPY_MODEL_ed4e007100c54243ae05c9e3f17a947b"
       }
      },
-     "a4bc6487b3634a4cb2141eb6843662b2": {
+     "b06d9b42c7d34d7b819e42c9d497b1b2": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_6da98046cbb948f7a915cee8373bdf33",
-       "max": 10,
-       "style": "IPY_MODEL_483864d67a9a45c39cc64210b42f1efa",
-       "value": 10
+       "layout": "IPY_MODEL_33dc10e898b545fd95f6c1d0c70cf37d",
+       "style": "IPY_MODEL_078f377d1c044f589bfafa4a1dcf9e88",
+       "value": " 400/400 [00:07&lt;00:00, 57.40it/s]"
       }
      },
-     "a4d20ea48295415a86ad8d272be456a1": {
+     "b0a8809af2c94ff4b7e52dd5e798933f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_449b2980b030413bbd16e6a3d0747b63",
-       "style": "IPY_MODEL_2ee47ce3639b4ff185d2f5274e45b96e",
+       "layout": "IPY_MODEL_ed2bf7a1057e4e94b001d4c74a4a12fa",
+       "style": "IPY_MODEL_97eba679b30147a3b6ad77026f56f16c",
        "value": " 95%"
       }
      },
-     "a558ba9585c94addab82e17512e73598": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "b1123e7c1b77420cae0ec3d8234602b1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
      },
-     "a56a1830a20449ec9d58cc4b0d45514f": {
+     "b1f799f773ce4d8982e05894a679e9f2": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {}
+      "state": {
+       "visibility": "hidden"
+      }
      },
-     "a6933d6781164693a521a438c1a509ef": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "b244245d682841d0bb985a99cb21b033": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
      },
-     "a7250b846a12484c9fd40d211e765d85": {
+     "b25347fb16ad4bf092d3abb8c4ec9286": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "a8486808a7154641a4c756649718d8c6": {
+     "b3489dfd4b5742bab38910d1e881870f": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "a9f9435e398843c2a9991a79a13d3e8f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_fb25d6575227404f9902b4186eb73b5b",
-        "IPY_MODEL_0d67dc1bb3db48ff8974906666d0e1a1",
-        "IPY_MODEL_214f9b0ef8f44725a9c6ac532f55c5e9"
-       ],
-       "layout": "IPY_MODEL_e0f4cb55cec844a3b2333a1cd2bc8f91"
-      }
-     },
-     "aa23ed2b688145d5ba97ea7480689042": {
+     "b3610503864c4e3bbcc60f270810509d": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "ac479868b12744cf867fe21e3f8c636a": {
+     "b3d0ae2ccc9941adab0bf96aef018c49": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_0ef1e893eff34ec7b78694957c18a67f",
-       "style": "IPY_MODEL_8cf0aadbc7da48de9a99563f7c87ba6b",
-       "value": "100%"
+       "bar_style": "success",
+       "layout": "IPY_MODEL_10b4363f69f043cb8623f65e03ef1d88",
+       "max": 400,
+       "style": "IPY_MODEL_b558615010ba4c73a42a5299c65c9bd9",
+       "value": 400
       }
      },
-     "ae6a952cf19648d697760320505bcd2d": {
+     "b49cb6e80e314b13a821d9e5031aba44": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_599136a66d324b3086fcc808224e87be",
-       "style": "IPY_MODEL_5cb499e3a68f473e8c4d6da292b097e8",
-       "value": "100%"
+       "description_width": ""
       }
      },
-     "b0cec113b9ab4a379fc881c800cc279b": {
+     "b4b53743fafe4c499c699f5711ace9d7": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_61d0b03fb5894eae89991e0e53b2ee89",
+       "style": "IPY_MODEL_7155e0b738344e269371852eb9473110",
+       "value": " 90%"
       }
      },
-     "b269913f910e48eb9afcae50cb8c2c5d": {
+     "b4ce66fb28dc4e05807d1250fd0fcda9": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "b558615010ba4c73a42a5299c65c9bd9": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_0aeeb3b4f4564222a2c6e726444f5d56",
-       "style": "IPY_MODEL_16bb2a454d194503adca31ee9b0ef39a",
-       "value": "100%"
+       "description_width": ""
       }
      },
-     "b2e7b2bd87924c949179b684777ec4a6": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+     "b5a201f491544b0a9833f38d2fc7ca98": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "visibility": "hidden"
       }
      },
-     "b327cdb5add44dc8931b594e4a9c15c3": {
+     "b5e48071537b4cb38524c16f574cb87a": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_7c2f5d76e62e45b185f7fab9c5486999",
-       "style": "IPY_MODEL_7617a31728cb43da9a5859861e4334db",
-       "value": "100%"
+       "layout": "IPY_MODEL_eb02e689b6ef47bba734e92686f8fa82",
+       "style": "IPY_MODEL_6adb061cfc7845e7919e940fa62f531e",
+       "value": " 20/20 [00:00&lt;00:00, 29.43it/s]"
       }
      },
-     "b3a85650635440df86d95ad23aa748ce": {
+     "b62ec6a3ea004a25b51a34d27b73e79d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "children": [
+        "IPY_MODEL_00620ebaf2c54aff99f9fc5ee3e27149",
+        "IPY_MODEL_3bb06145583f43658bd60c15a8416354",
+        "IPY_MODEL_95b040cabe4a41d88ea231eaad666896"
+       ],
+       "layout": "IPY_MODEL_07cf32afa31145b7a36ada3aff7e9553"
       }
      },
-     "b45cea895e6340e59b82a5ad1f5b076c": {
+     "b645f76a69604053b35091f8f3702a82": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_bbf5ad8f96f345409e71a90e465cd9bc",
-       "style": "IPY_MODEL_1c7266d683a8429c9a3f04cf44b7ff23",
-       "value": " 20/20 [00:00&lt;00:00, 60.50it/s]"
-      }
-     },
-     "b4882d4e7c9343c79210b1b58b4a0833": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_cf4ac5479c19487db0d3926a2255efb3",
+       "style": "IPY_MODEL_06f59874b47747daae0c755c1153cf8a",
+       "value": " 95%"
       }
      },
-     "b4faab16701342dbac5a4985c840cfa0": {
+     "b6902bd09822465cbca623f6b057f9c7": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "b62a1cbcdddd496181f66f443bf07062": {
+     "b70ff1aac4b34686b1a8e55912abb4d2": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "b67a1d490012494383abca28630cbe37": {
+     "b72d472c18a645e5a6aab68b80a2d96a": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
        "bar_style": "success",
-       "layout": "IPY_MODEL_2860f54a3f3e4c41a96f5647f88bb496",
+       "layout": "IPY_MODEL_0b145d3f3ac54acaa40f73de1566647d",
        "max": 20,
-       "style": "IPY_MODEL_9e843b329d034fdca65472a9c40017ba",
+       "style": "IPY_MODEL_3d9481641482475cbf3a39daf55d5e17",
        "value": 20
       }
      },
-     "b76631e94e2140c08814313dbe1f594f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "b908cc166330450fb68c6f507dba17ea": {
+     "b7b0f15b458e46c6bc07db1db517482f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_50e86c184fc446ec9ae7e768adba40d3",
-       "style": "IPY_MODEL_a7250b846a12484c9fd40d211e765d85",
+       "layout": "IPY_MODEL_56e383da6e6f42efbfb67564709c64ac",
+       "style": "IPY_MODEL_0fac0bb47214452eaab6dca844f9ed16",
        "value": "100%"
       }
      },
-     "ba2b1e11257a49318ac498606ef2e072": {
+     "bab3616dc353426fb3ae3292196c1521": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "ba35e5f805c34655b9f9096537670437": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "ba4761147de449dd8babd8916820f645": {
+     "bab5ad93e9084387a77df8894729e0ca": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_a558ba9585c94addab82e17512e73598",
-       "style": "IPY_MODEL_83b910527c3b4c168e028d127eefabe1",
-       "value": " 95%"
+       "layout": "IPY_MODEL_0d15b755d8d142df9d8951bbaf5bb038",
+       "max": 20,
+       "style": "IPY_MODEL_81ef3571ab38486ba39e7dbc2db868df",
+       "value": 20
       }
      },
-     "bbf5ad8f96f345409e71a90e465cd9bc": {
+     "bbb081740d7f41c3aa7f57d0fcac7596": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "bbfb250cf44c48829cb1b385d08673fd": {
+     "bdc57f6b8b344263aa6fe293c466e349": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_39ae834bdb0a4b3bbba7abf4d9dceec5",
-       "style": "IPY_MODEL_00e3a56c7d3a467ab1a928f1c590367c",
-       "value": " 20/20 [00:00&lt;00:00, 62.51it/s]"
+       "description_width": ""
       }
      },
-     "bc730c8b933d432ab9a5f33512eef414": {
+     "be1cf1c1e96a47798e160723dee6f31c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "be85d91ad53f4088a557c4fa8e8c41a3": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "bar_style": "success",
+       "layout": "IPY_MODEL_13e18a3a2b97435fa56a7edf6c0a1ce3",
+       "max": 20,
+       "style": "IPY_MODEL_e3589a2f3a8c4e2abf0d85bac9c00894",
+       "value": 20
       }
      },
-     "c046484e2ce8404b97f18773e017345d": {
+     "c03f3587b7374bfd874f71863de066d1": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "c103bd3c105f4c28b88e3b71044fb7f1": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "c1585d1507d34350936295cb3e1e10ef": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_b3610503864c4e3bbcc60f270810509d",
+       "style": "IPY_MODEL_293f30f6b3fe4aed99f3e317651d07e0",
+       "value": "100%"
       }
      },
-     "c168803eb1764be4ae8d7282dfdbd2af": {
+     "c1d353df9fd24e909169a1c7c15b861b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_18ac03ae3af545d2accf43ece3e31eba",
-       "style": "IPY_MODEL_7b5197d764784592bc4c82b95ed0122b",
-       "value": " 20/20 [00:00&lt;00:00, 62.45it/s]"
+       "description_width": ""
       }
      },
-     "c317733a64cb4b95849e75f21c94c4b0": {
+     "c2ce20e0500042e4b7f98acf8e6cc60b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "children": [
-        "IPY_MODEL_8273e0d29dd04e6da2594da7d8ada867",
-        "IPY_MODEL_9abf339411894c12aa643b0b788192c6",
-        "IPY_MODEL_87174324fd1c4c44bda21afa78696ce4"
-       ],
-       "layout": "IPY_MODEL_b62a1cbcdddd496181f66f443bf07062"
+       "description_width": ""
       }
      },
-     "c338bba6fdf847afb7f3767822d58405": {
+     "c44c5cc6f5c340ef8ab71828df5fd31b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "c44ffb313d734462b4c7484022a5f4fc": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "c3ed902f928648e89038984ad9117906": {
+     "c570a1bf49a544b19e064944b711807e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_7f59bea0ddd943dca0d45221dd810112",
-       "style": "IPY_MODEL_68b9cb7f26cd44d081ee4215f36022fb",
-       "value": "100%"
+       "layout": "IPY_MODEL_1844ab8cb0614eaeb9b798d583273f8d",
+       "style": "IPY_MODEL_a86975aac7e7429195289bb01485879b",
+       "value": " 20/20 [00:00&lt;00:00, 61.84it/s]"
       }
      },
-     "c43089dd927440f3a00ab8f1fdec5939": {
+     "c5c37c89337e4a4390ae6dbe42ff923d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_606d1273eb7641b0af9e96e2d754a784",
-       "max": 20,
-       "style": "IPY_MODEL_7834d9635e9b430985d40a556f8ac8e0",
-       "value": 20
+       "description_width": ""
       }
      },
-     "c435a97683e141798c9d99a40fd48817": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+     "c63e9a27effa416daefb13384904543f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "layout": "IPY_MODEL_870f643919ae464a8dd456878e19239f",
-       "max": 20,
-       "style": "IPY_MODEL_6b0b31585c6844c7a839b352fba5494f",
-       "value": 20
+       "visibility": "hidden"
       }
      },
-     "c47a2fe3418c42cab5179d3ff11a797b": {
+     "c64624c677f24f6e95cc1aeb92bf7abd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "c4cddef9d831418d9f1104348879c68a": {
+     "c6783899f76d49d5a4f3815bf1edbbde": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "c69bdf03055343018eae550f2b903355": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "c6c562bb2f23403093bbb0840a67b3d5": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_662b8f036e0f408b880a73869464c58d",
-       "style": "IPY_MODEL_b0cec113b9ab4a379fc881c800cc279b",
-       "value": " 95%"
+       "bar_style": "success",
+       "layout": "IPY_MODEL_eeab145eec544abf8a4453fc1635d093",
+       "max": 10,
+       "style": "IPY_MODEL_85b71fd87bf143a18603928c2479b4f0",
+       "value": 10
       }
      },
-     "c533a840a8dd4371898edfdcc03537b0": {
+     "c7009248b32743a5b8a0670589b83f26": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "c5c36417f31c4abe8be94eb1cd0fba14": {
+     "c868b1bb1d574805a73a9fc9ae7bc44a": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
+      "state": {}
+     },
+     "c88eb093afd04978b32431b4d6ae24d3": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
      },
-     "c61c6e1fd82541f5992b6dfaf9c4a7ea": {
+     "c8a69a2b5dbf4bf791623a10aeab6f8f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "cb2f30eef37c442ea4e2f1c0ebb9c403": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_a1e299e5adfd46d087a86b377286507d",
-       "style": "IPY_MODEL_64134e5969be4176873db01f8f94ba72",
-       "value": " 19/20 [00:00&lt;00:00, 57.42it/s]"
+       "layout": "IPY_MODEL_c88eb093afd04978b32431b4d6ae24d3",
+       "style": "IPY_MODEL_a5cb87cf8eb34ecfaee717f660e88db3",
+       "value": "100%"
       }
      },
-     "c63ac25de5cc4f98b10bc2c1fe89417a": {
+     "cb32e7c112c848c4bcd50e7bf92ad9be": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
+      "state": {}
+     },
+     "ccb5b50955ac42e5a646f97e2edfcee7": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "visibility": "hidden"
+       "layout": "IPY_MODEL_a9a6ce00ca3a4d8fa0e4ad618943b86d",
+       "style": "IPY_MODEL_cce69aed6fa04054806dd2fc8c2eb619",
+       "value": " 20/20 [00:00&lt;00:00, 61.67it/s]"
       }
      },
-     "c68375ce45c64f289c2af4ce6fe38ce5": {
+     "cce69aed6fa04054806dd2fc8c2eb619": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "c6e04308e69244cdabbadab1aa0d4eaf": {
+     "cd5e8e6e6dba4f018b03787d9fc04c59": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "c96b29969769449897f37f84bd197b59": {
+     "ce60ac23f4d54dc3a284865755de921d": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_54600ca96e784155afd63e8590573803",
-       "style": "IPY_MODEL_4e4b0498a7cb42fcba1bb77fdf803ee9",
-       "value": " 19/20 [00:00&lt;00:00, 58.92it/s]"
+       "description_width": ""
       }
      },
-     "cae4a01a80364702ba97aa6c18835cc2": {
+     "ce6e42c96e3248a8a4dc653819bb74e4": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_1f03c566660e4c11b0da377007351708",
+       "style": "IPY_MODEL_f26db57ad53746c785f532cab5faba40",
+       "value": "100%"
       }
      },
-     "cbf566af0d1440479c555c8181f69972": {
+     "cf3d468131ae42019b776f1d5cc40538": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "cc084bb3f19d4d249d9700bbcb024bca": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_e84c9fcd916c490291eca5ace3de7845",
-       "style": "IPY_MODEL_b4882d4e7c9343c79210b1b58b4a0833",
-       "value": "100%"
-      }
+     "cf4ac5479c19487db0d3926a2255efb3": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
      },
-     "cc44252a5bbe4aaa8ee9239eab2915a5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+     "d0d6e3cf71aa40f29aeee7607fd75987": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "d1d85b14a2cf43d5a84a56503ee3ea51": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "layout": "IPY_MODEL_9cff84008ee842aca9c40b78d431db22",
-       "style": "IPY_MODEL_e7c020e1a54f4e37b89bc44f1c014afd",
-       "value": "100%"
+       "visibility": "hidden"
       }
      },
-     "cd780eede04943689a2b0b056c1f335b": {
+     "d221a2ed8e4d4747b389dfb2edfc3fdb": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_fc9441e95e5448e3b86f683e80131942",
+       "style": "IPY_MODEL_ff369ca6125543c3877e1c31fa79dc87",
+       "value": " 400/400 [00:07&lt;00:00, 57.01it/s]"
       }
      },
-     "ceafb25f1905481c819760fe7c5c7917": {
+     "d380ffebdab94a668a01e8def8aa1561": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_8a50b6c36fe147e6a5e11fdea54ceb79",
+       "max": 20,
+       "style": "IPY_MODEL_39b8055d531a4d2da11d4a2ad7e5982e",
+       "value": 20
       }
      },
-     "d08c0fdaf8664ac49fcc3965e607e828": {
+     "d5494206f8c44affba19ec672f97bbaf": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_c69bdf03055343018eae550f2b903355",
+       "max": 20,
+       "style": "IPY_MODEL_e24dfe286a4e465cacbdd82475e3809e",
+       "value": 20
       }
      },
-     "d2ae64b1a4dc4dbcb9275542fdfef5d0": {
+     "d598e54836f140a89a9a993b83b6504c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_1eb064bcd68d49f98fcdcabd410b24b7",
-       "style": "IPY_MODEL_4eec30445da147efa5c30d5f434d19b5",
-       "value": " 20/20 [00:00&lt;00:00, 62.50it/s]"
+       "bar_style": "success",
+       "layout": "IPY_MODEL_c03f3587b7374bfd874f71863de066d1",
+       "max": 400,
+       "style": "IPY_MODEL_a020f6eb56c6426fa67b8536bede9175",
+       "value": 400
       }
      },
-     "d38cd18ed9f34ea68dcfbc7714315f3d": {
+     "d5ccc83fdf574d6d96ccc3d6df10fbaf": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "d600d8ba444c4795bbef57a1adf48c61": {
+     "d759c9feffdb4b6a9688f1966e1b2169": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "layout": "IPY_MODEL_f124d269872d4cf6be80f2f98db79d6f",
-       "style": "IPY_MODEL_b4faab16701342dbac5a4985c840cfa0",
-       "value": "100%"
+       "children": [
+        "IPY_MODEL_f1b8bc39f34244f597553a6241a3bb7b",
+        "IPY_MODEL_24d8d594870b4c75af8f1bd360de5a38",
+        "IPY_MODEL_6ce7dc29016946caa8b6133a3b3e6e92"
+       ],
+       "layout": "IPY_MODEL_246cc76521d54d1284405f56c122f332"
       }
      },
-     "d6581cee770d4a77b758ac1aef9bd33d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "d773dad7c97141ed87a77d75c733c737": {
+     "d8387558b3d74b938cf7aa66665f7822": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "d8ce05184ce64acd997a191498ed5b33": {
+     "d9a4d571993d4240b538df9f86e2f172": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "children": [
-        "IPY_MODEL_b327cdb5add44dc8931b594e4a9c15c3",
-        "IPY_MODEL_a4bc6487b3634a4cb2141eb6843662b2",
-        "IPY_MODEL_0708eeb12d0945d6a6ec1343957557d0"
-       ],
-       "layout": "IPY_MODEL_b76631e94e2140c08814313dbe1f594f"
+       "description_width": ""
       }
      },
-     "d91daafc62434bfdba135e093912dc73": {
+     "d9c0410a0b0647e88766ed621ea64517": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_0d672a53b4cc4686979aada5d2afe122",
-       "style": "IPY_MODEL_093280bcc01143c187b590a1cec658ad",
-       "value": " 20/20 [00:00&lt;00:00, 62.32it/s]"
+       "layout": "IPY_MODEL_dd0b0e9d078e45bca3c0b00a49e2a196",
+       "style": "IPY_MODEL_b6902bd09822465cbca623f6b057f9c7",
+       "value": " 90%"
       }
      },
-     "d99670adafed463c88c0b65411b0c6d5": {
+     "dab99855ef0e44d1999f1902a60a8c42": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
       "state": {
-       "layout": "IPY_MODEL_f8e1034ea994430d8797ebc8fe79d73a",
-       "style": "IPY_MODEL_5147e451170047398934f3475550aaac",
-       "value": "100%"
+       "description_width": ""
       }
      },
-     "db43c11f176540a5bc06f1402cfa0afb": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "daceb5a73b81477086f42bf604ff354e": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "visibility": "hidden"
+       "layout": "IPY_MODEL_e3c570c5e77944f2a551855d435d3def",
+       "style": "IPY_MODEL_c2ce20e0500042e4b7f98acf8e6cc60b",
+       "value": " 20/20 [00:00&lt;00:00, 29.53it/s]"
       }
      },
-     "de52b5d4314a45ab94b17ad151769ed9": {
+     "dc74a6082a61499398c11d19bbb7308b": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "de5db69c39ff4d7aad4164cab22ea345": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_3d7870d01c8342b38b4e8534811f44ba",
-       "style": "IPY_MODEL_d38cd18ed9f34ea68dcfbc7714315f3d",
-       "value": " 18/20 [00:00&lt;00:00, 57.61it/s]"
-      }
-     },
-     "e0f4cb55cec844a3b2333a1cd2bc8f91": {
+     "dd0b0e9d078e45bca3c0b00a49e2a196": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "e12740eb48e24a49b95a066099a18ee1": {
+     "dded914a091e466db615f659b78a6094": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "e347e478bb3745608426e4a5471cecf3": {
+     "de67a7d8e91d414fb3b36dc1f6da6279": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_89519dc0bf1a431d960c2be04f2c3f4b",
+       "layout": "IPY_MODEL_b3489dfd4b5742bab38910d1e881870f",
        "max": 20,
-       "style": "IPY_MODEL_611ffacd55e0427bbc23f27f8065280c",
+       "style": "IPY_MODEL_27cb4e98ffb441f5b17bfa25474b669c",
        "value": 20
       }
      },
-     "e3c52b67639c468d9120422f4cb7cfbe": {
+     "dee4c0f43fe44c288ea19337cfefb458": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "deeed6cf997f4a2c84a572f8fc4dd57c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "e24dfe286a4e465cacbdd82475e3809e": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "ProgressStyleModel",
       "state": {
        "description_width": ""
       }
      },
-     "e4600370f42d4e458d9d5d2924cae790": {
+     "e26270d9e03d49bb85b2b68a3df99cbd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_6dfcfdb33741456c8ba6863d870ba318",
-       "max": 20,
-       "style": "IPY_MODEL_5589e5de36524057a6fae80a55f3611b",
-       "value": 20
+       "description_width": ""
+      }
+     },
+     "e293b6c0097d47aab36622e159fa6f56": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_4581de95d1b14b5eb4cf54dedf362611",
+       "style": "IPY_MODEL_914b7d8a07d24c749b324e292501b9fa",
+       "value": " 14/20 [00:00&lt;00:00, 62.89it/s]"
+      }
+     },
+     "e3589a2f3a8c4e2abf0d85bac9c00894": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
       }
      },
-     "e64d6dc315484cd5b85e9c8775e4f4bc": {
+     "e3c570c5e77944f2a551855d435d3def": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "e68512a5d164435a81de962de333b97f": {
+     "e3c61d2f31824cd0b4ed1d36b6f18cd9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e5d62acb2c6f498294660f1f303c2ce6",
+       "style": "IPY_MODEL_634847862f0542d390fc37cd5fbcd713",
+       "value": " 70%"
+      }
+     },
+     "e40e3ce50a2c47c1a7217b178bfec173": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "e6b5fbf59508437fb24983e8a3af5c2a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "e4a3e2a9082c48f6a321f3eb602a2f34": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "visibility": "hidden"
+       "layout": "IPY_MODEL_2b41856ed2bc4c79839d262ae43ddad8",
+       "style": "IPY_MODEL_b25347fb16ad4bf092d3abb8c4ec9286",
+       "value": "100%"
       }
      },
-     "e787a41e97b2477dadd3def13a4b616a": {
+     "e506ab46b34f47e68f4ccda3e48f9563": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_9852e2768873485190a0902b121f52db",
+       "style": "IPY_MODEL_eb295c66651c4550b6d2e2ec992de7d3",
+       "value": " 19/20 [00:00&lt;00:00, 60.52it/s]"
       }
      },
-     "e7c020e1a54f4e37b89bc44f1c014afd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+     "e57f6e2b497f413096ea11c0b769a80e": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "visibility": "hidden"
       }
      },
-     "e84c9fcd916c490291eca5ace3de7845": {
+     "e5bb5b15444642ea86f86e62a361b959": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "e8756b4d138f4c29a3c89c55606d02cc": {
+     "e5d62acb2c6f498294660f1f303c2ce6": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "ea146a08f011474ca22b90ab3c2cfaec": {
+     "e604c7725bfc48a38474676ae4bd612c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "ProgressStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "description_width": ""
+       "layout": "IPY_MODEL_a5c5f176648b40c98943b82e70311129",
+       "style": "IPY_MODEL_7686e4f7db8545d38f5267d5bec25596",
+       "value": " 20/20 [00:00&lt;00:00, 60.84it/s]"
       }
      },
-     "eaa19074afeb4228942c219d62466cda": {
+     "e7b34ebd626443458c1eccfa80611992": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "eaeb01e73f4745b9b3fb7dbcb778c4cd": {
+     "e847b2925c9440028013b8319b93c86b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_3bc2f9cc8ad640f3853e4f830418473f",
+       "style": "IPY_MODEL_13c63d3a53834e78ac7c33968a8b92ff",
+       "value": "100%"
+      }
+     },
+     "e8caf93443974e8b88b2182329a0c4da": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "eb29e815160d4f2ca75323c77ddaea05": {
+     "e8e3c48dd49a48f39577292d5e92f215": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "e92536cb0c204a669bad5d5296422ac1": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "ed3285395a3d45648bfdc1c4584155d5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+     "eac9c8395935427aa0571bb0ee8eb55c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
       "state": {
-       "layout": "IPY_MODEL_f258440b46ee49828c20d3bc9c8917f8",
-       "style": "IPY_MODEL_bc730c8b933d432ab9a5f33512eef414",
-       "value": "100%"
+       "visibility": "hidden"
       }
      },
-     "ee16dc27cbe84d3ea3166c9faa30b4f1": {
+     "eb02e689b6ef47bba734e92686f8fa82": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "ee2c2868bdea47d599ec60b6d412aa35": {
+     "eb295c66651c4550b6d2e2ec992de7d3": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      },
-     "eec17bd8116b4b2ab64b7ff6c3c543ec": {
+     "eb63b0e5804d4ae986f52b40791ec081": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HBoxModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "children": [
-        "IPY_MODEL_99be57d2f6464fb38eb0bf6f0aa3afb9",
-        "IPY_MODEL_201f761c93d446aeb7f3b868619170d4",
-        "IPY_MODEL_010a8fdfda9c4127afde5fefa7b00bc2"
-       ],
-       "layout": "IPY_MODEL_e64d6dc315484cd5b85e9c8775e4f4bc"
+       "layout": "IPY_MODEL_5c057b9e4a094138959779154aebb9de",
+       "style": "IPY_MODEL_2b98fdadef774350bf0350a6f5a54449",
+       "value": "100%"
       }
      },
-     "eef95a7f98c5435faae73df38e12e5f9": {
+     "ec81aa182cc8434f856e3a5655ba14c5": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "f124d269872d4cf6be80f2f98db79d6f": {
+     "ed2bf7a1057e4e94b001d4c74a4a12fa": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "f13475935b20445ab7fa3c084e779dce": {
+     "ed4e007100c54243ae05c9e3f17a947b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "edda46662c2441419811b449884baed8": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "FloatProgressModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_eaa19074afeb4228942c219d62466cda",
-       "max": 400,
-       "style": "IPY_MODEL_826a9d592b5547dcbd9e492c42e88b1c",
-       "value": 400
+       "layout": "IPY_MODEL_79dfdb9f25854c549baf9a5741b81910",
+       "max": 20,
+       "style": "IPY_MODEL_1a1b079608c04df48f418e25a7e136da",
+       "value": 20
       }
      },
-     "f15bc2efb4a54b49a717ce8af654e91b": {
+     "eeab145eec544abf8a4453fc1635d093": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "f083caacc043492fb5ca63fc30b0328c": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_0eb80399eeb841339f13ac3ebbb961bd",
-       "max": 20,
-       "style": "IPY_MODEL_e787a41e97b2477dadd3def13a4b616a",
-       "value": 20
+       "description_width": ""
       }
      },
-     "f16939dd44284cd997d4d08c5f67e5d7": {
+     "f1b8bc39f34244f597553a6241a3bb7b": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.5.0",
       "model_name": "HTMLModel",
       "state": {
-       "layout": "IPY_MODEL_8a9525e77c9a42fcb4dfde761097ffcf",
-       "style": "IPY_MODEL_ee2c2868bdea47d599ec60b6d412aa35",
+       "layout": "IPY_MODEL_15b506a240a54366874760d97e60f774",
+       "style": "IPY_MODEL_468745258da649e7b3739e5c5922364d",
        "value": "100%"
       }
      },
-     "f185daaa38c04c538327efceccf8bcd7": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "f2447d9f74884497a04699e0d6899179": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
       "state": {
-       "visibility": "hidden"
+       "layout": "IPY_MODEL_f9a3f32a739a4332a2240e36c2f3eff7",
+       "style": "IPY_MODEL_fba40572a8f740b1aaad454c99f8380c",
+       "value": " 20/20 [00:00&lt;00:00, 61.86it/s]"
       }
      },
-     "f1c1b4b5034343619019e7fdfdd949cd": {
+     "f26db57ad53746c785f532cab5faba40": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "FloatProgressModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_10fb4e3293894ff2906c3fafd923f0a8",
-       "max": 20,
-       "style": "IPY_MODEL_2724a0b60eb54cff8fd8d569bca071a8",
-       "value": 20
+       "description_width": ""
       }
      },
-     "f258440b46ee49828c20d3bc9c8917f8": {
+     "f412a75adeae4dd8a1d15c81203934b7": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "f3b11047b94e4bde8f6b85a4b81d918c": {
+     "f4841d7499924e2e87e04d7a79792a68": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {
        "visibility": "hidden"
       }
      },
-     "f556e7d31b5243de99d81dd41fd3b65b": {
+     "f592530374a749a89a4c98a0602bafe0": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "f8e1034ea994430d8797ebc8fe79d73a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
-      "state": {}
+     "f5f579a5844649a49082c4b265cc2f12": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_c868b1bb1d574805a73a9fc9ae7bc44a",
+       "style": "IPY_MODEL_6a643f694fc24c459b32d5efab6866ad",
+       "value": "100%"
+      }
      },
-     "f948b536b8544df89173165784b2d29b": {
+     "f7be54b0e0ab4020a7e57bd0e43d2229": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "HBoxModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "children": [
+        "IPY_MODEL_0c215d5b062e4bd8b817dd7e9818cb84",
+        "IPY_MODEL_360a899b4aee466688246f064df82c72",
+        "IPY_MODEL_b5e48071537b4cb38524c16f574cb87a"
+       ],
+       "layout": "IPY_MODEL_dded914a091e466db615f659b78a6094"
       }
      },
-     "f9ebf0df54c7480db5c7e70f705e48c5": {
+     "f7d2d299cca643789df638e0d886dba9": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_d6581cee770d4a77b758ac1aef9bd33d",
-       "style": "IPY_MODEL_fabfb0da109f43e6a5f7460830c65107",
-       "value": " 20/20 [00:00&lt;00:00, 62.43it/s]"
+       "description_width": ""
       }
      },
-     "fa6c542c2c144cf9a13963702cd220c8": {
+     "f9211e9657204bf2be2b419b9496c0a2": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "1.2.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "f953696dc9764d10b579151cd22863b5": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "faafa1efaea74624be0551e9fdbfb577": {
+     "f9a3f32a739a4332a2240e36c2f3eff7": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "fabfb0da109f43e6a5f7460830c65107": {
+     "f9bcb3a805b346459cde4f9928fcb40f": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "layout": "IPY_MODEL_a88d68e130fc4051889df9fdad9a1f5e",
+       "max": 20,
+       "style": "IPY_MODEL_0e27c837d07949e88bd57f35a93535f3",
+       "value": 20
       }
      },
-     "fb25d6575227404f9902b4186eb73b5b": {
+     "fa402417a4a941c6bb0fc824993b34fd": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "FloatProgressModel",
       "state": {
-       "layout": "IPY_MODEL_36e568b08f2c4147a9ed121af63f0635",
-       "style": "IPY_MODEL_5046999895a74f0182e4de2c0fc02711",
-       "value": "100%"
+       "layout": "IPY_MODEL_cf3d468131ae42019b776f1d5cc40538",
+       "max": 20,
+       "style": "IPY_MODEL_86f6675020314335a7e2202e5ee52b56",
+       "value": 20
       }
      },
-     "fb2d8d04ef9b443f9e72eb838de01891": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
-      "model_name": "LayoutModel",
+     "fba40572a8f740b1aaad454c99f8380c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "visibility": "hidden"
+       "description_width": ""
       }
      },
-     "fb51251b9df04721bada4cc984f0088d": {
+     "fc9441e95e5448e3b86f683e80131942": {
       "model_module": "@jupyter-widgets/base",
-      "model_module_version": "2.0.0",
+      "model_module_version": "1.2.0",
       "model_name": "LayoutModel",
       "state": {}
      },
-     "fef5867fdcc84d6fa458aae39f68257c": {
+     "ff369ca6125543c3877e1c31fa79dc87": {
       "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLModel",
+      "model_module_version": "1.5.0",
+      "model_name": "DescriptionStyleModel",
       "state": {
-       "layout": "IPY_MODEL_410d43e069b4403180bcb53e1fcdd231",
-       "style": "IPY_MODEL_c47a2fe3418c42cab5179d3ff11a797b",
-       "value": " 19/20 [00:00&lt;00:00, 60.04it/s]"
-      }
-     },
-     "ff506b3a47814b229ad2bab10a4dc528": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "2.0.0",
-      "model_name": "HTMLStyleModel",
-      "state": {
-       "description_width": "",
-       "font_size": null,
-       "text_color": null
+       "description_width": ""
       }
      }
     },

From a9b8b11286437ea4a5e5e1c39053ec20e6efa843 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 12:59:07 +0200
Subject: [PATCH 07/14] add test that get_after_set stores gotten data

---
 qcodes/tests/dataset/dond/test_doNd.py | 51 ++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/qcodes/tests/dataset/dond/test_doNd.py b/qcodes/tests/dataset/dond/test_doNd.py
index 099355bb37f3..a1ba9b344ca9 100644
--- a/qcodes/tests/dataset/dond/test_doNd.py
+++ b/qcodes/tests/dataset/dond/test_doNd.py
@@ -55,6 +55,29 @@ def reset_count(self) -> None:
         self.set_count = 0
 
 
+class GetReturnsCountParameter(Parameter):
+    """Parameter that keeps track of number of get and set operations
+    Allows you to set a value but returns the get count rather
+    than the value"""
+
+    def __init__(self, *args, **kwargs):
+        self.set_count = 0
+        self.get_count = 0
+        super().__init__(*args, **kwargs)
+
+    def set_raw(self, value):
+        self.set_count += 1
+        self.cache._set_from_raw_value(value)
+
+    def get_raw(self):
+        self.get_count += 1
+        return self.get_count
+
+    def reset_count(self) -> None:
+        self.get_count = 0
+        self.set_count = 0
+
+
 def test_linear_sweep_get_setpoints(_param):
     start = 0
     stop = 1
@@ -1656,3 +1679,31 @@ def test_dond_no_get_after_set(_param_set, _param_set_2, _param):
     assert a.set_count == n_points
     assert b.get_count == n_points
     assert b.set_count == 0
+
+
+def test_dond_get_after_set_stores_get_value(_param_set, _param_set_2, _param):
+
+    n_points = 11
+
+    a = GetReturnsCountParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    ds, _, _ = dond(LinSweep(a, -10, -20, n_points, get_after_set=True), b)
+
+    # since we are using the GetReturnsCountParameter the sweep should be count e.g. 0, 1, ... 11
+    # not the set parameters -10, .. - 20
+    np.testing.assert_array_equal(
+        ds.get_parameter_data()["b"]["a"], np.linspace(1, 11, n_points)
+    )
+    assert a.get_count == n_points
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0

From b156d45d395bad336da91a2070efbe2876be2bc9 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 13:03:11 +0200
Subject: [PATCH 08/14] add changes fro 4759

---
 docs/changes/newsfragments/4759.improved | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 docs/changes/newsfragments/4759.improved

diff --git a/docs/changes/newsfragments/4759.improved b/docs/changes/newsfragments/4759.improved
new file mode 100644
index 000000000000..6d75a82b5c85
--- /dev/null
+++ b/docs/changes/newsfragments/4759.improved
@@ -0,0 +1,2 @@
+The sweeps used by doNd has gained the ability to perform a get call after setting the parameter and storing
+that value in the dataset rather than the value set.

From cf8205c0c5c380717a55ec79bf60764cbed484f5 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 13:25:05 +0200
Subject: [PATCH 09/14] add explicit type for instrument.log to help mypy

---
 qcodes/instrument/instrument_base.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qcodes/instrument/instrument_base.py b/qcodes/instrument/instrument_base.py
index ba5c17e1a724..31a1ea6c2fa0 100644
--- a/qcodes/instrument/instrument_base.py
+++ b/qcodes/instrument/instrument_base.py
@@ -16,6 +16,7 @@
 
 if TYPE_CHECKING:
     from qcodes.instrument.channel import ChannelTuple, InstrumentModule
+    from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
 
 from qcodes.utils import QCoDeSDeprecationWarning
 
@@ -82,7 +83,7 @@ def __init__(
         # This is needed for snapshot method to work
         self._meta_attrs = ["name", "label"]
 
-        self.log = get_instrument_logger(self, __name__)
+        self.log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
 
     @property
     def label(self) -> str:

From 8b106f4e079b3891923ac084d033836651d5f7ab Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Fri, 28 Oct 2022 13:32:29 +0200
Subject: [PATCH 10/14] add type to mylogger

---
 qcodes/parameters/parameter.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/qcodes/parameters/parameter.py b/qcodes/parameters/parameter.py
index 4be3a5c580cb..95f912aa02c8 100644
--- a/qcodes/parameters/parameter.py
+++ b/qcodes/parameters/parameter.py
@@ -13,6 +13,7 @@
 
 if TYPE_CHECKING:
     from qcodes.instrument.base import InstrumentBase
+    from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
     from qcodes.validators import Validator
 
 
@@ -181,7 +182,9 @@ def __init__(
     ) -> None:
         def _get_manual_parameter() -> ParamRawDataType:
             if self.root_instrument is not None:
-                mylogger = self.root_instrument.log
+                mylogger: InstrumentLoggerAdapter | logging.Logger = (
+                    self.root_instrument.log
+                )
             else:
                 mylogger = log
             mylogger.debug(
@@ -193,7 +196,9 @@ def _get_manual_parameter() -> ParamRawDataType:
 
         def _set_manual_parameter(x: ParamRawDataType) -> ParamRawDataType:
             if self.root_instrument is not None:
-                mylogger = self.root_instrument.log
+                mylogger: InstrumentLoggerAdapter | logging.Logger = (
+                    self.root_instrument.log
+                )
             else:
                 mylogger = log
             mylogger.debug(

From a0c6ed1d127a0c0ad93a56b0e26348652977a9de Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Mon, 31 Oct 2022 10:52:52 +0100
Subject: [PATCH 11/14] add note about what we store

---
 ..._manager_for_performing_measurements.ipynb | 2464 +----------------
 1 file changed, 3 insertions(+), 2461 deletions(-)

diff --git a/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb b/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
index 585125af6ac0..d58b0d871eff 100644
--- a/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
+++ b/docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb
@@ -1728,7 +1728,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "But when we set get_after_set to True we perform a get after each set of the parameter."
+    "But when we set get_after_set to True we perform a get after each set of the parameter and we store the output returned from get rather than the set value as the setpoint value in the dataset."
    ]
   },
   {
@@ -1964,7 +1964,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.10.6 ('qcodespip310')",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -2029,2465 +2029,7 @@
   },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {
-    "state": {
-     "0025836395b540e5a28bb3e676047ec9": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c103bd3c105f4c28b88e3b71044fb7f1",
-       "style": "IPY_MODEL_e8e3c48dd49a48f39577292d5e92f215",
-       "value": "100%"
-      }
-     },
-     "00620ebaf2c54aff99f9fc5ee3e27149": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_7bab947042b540efaf498346b83880d5",
-       "style": "IPY_MODEL_37e2e5818c9940e69bcb98e0261e67ce",
-       "value": "100%"
-      }
-     },
-     "00820fb2f8894fa38f2f88ea1bcf450f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "00a423de9d714ee28699fae2f8c8696d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "0190ce522dcf4d59b7e8986472f425d5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_3d4a66c3e090415cb7c6f309a2d5dc1f",
-       "style": "IPY_MODEL_1e7974757bb34201843ebc0d73795961",
-       "value": " 19/20 [00:00&lt;00:00, 59.95it/s]"
-      }
-     },
-     "0251abfff957407eba9b240618313e0c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0378537e69dd4cfc8beb05ab6742ffcf": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0379c4e854684f4eaa49cdab48f5d7e0": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "042025c1ce874ddb8bf58be5925dcd21": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_8ced257c358241b6af032b5883655fbb",
-       "max": 20,
-       "style": "IPY_MODEL_71d85d586c5c41d1bfbb67a471219f9b",
-       "value": 20
-      }
-     },
-     "062ec452220640b4a1b80f9cf0dde981": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "06f59874b47747daae0c755c1153cf8a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "078f377d1c044f589bfafa4a1dcf9e88": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "07cf32afa31145b7a36ada3aff7e9553": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0b145d3f3ac54acaa40f73de1566647d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0c215d5b062e4bd8b817dd7e9818cb84": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_0379c4e854684f4eaa49cdab48f5d7e0",
-       "style": "IPY_MODEL_c5c37c89337e4a4390ae6dbe42ff923d",
-       "value": "100%"
-      }
-     },
-     "0c77635e88db42f9b00c6accfe789c84": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "0d15b755d8d142df9d8951bbaf5bb038": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0d4688c5569e45eb815cb8f3f18fd628": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "0db023e0b4c04517b1572e0016fd6097": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "0e27c837d07949e88bd57f35a93535f3": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "0fac0bb47214452eaab6dca844f9ed16": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "0fae9d6d47ef4f1596eb208504dc4961": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_8a9995a5e11a40b89cc72c265e0cb26e",
-       "max": 20,
-       "style": "IPY_MODEL_b49cb6e80e314b13a821d9e5031aba44",
-       "value": 20
-      }
-     },
-     "10b4363f69f043cb8623f65e03ef1d88": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "113135000080412bbf1d8aaea28e6dfb": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "11d134b24dbe4e58bf948649c437d793": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_e8caf93443974e8b88b2182329a0c4da",
-       "style": "IPY_MODEL_91ec8c653a2e432fac257deb8aaa5633",
-       "value": " 95%"
-      }
-     },
-     "11fd5f7647cb42d9b09a30606c0e139f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_f592530374a749a89a4c98a0602bafe0",
-       "max": 20,
-       "style": "IPY_MODEL_7d959d4ddeb04b06bd476ea6be819d8e",
-       "value": 20
-      }
-     },
-     "13c63d3a53834e78ac7c33968a8b92ff": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "13e18a3a2b97435fa56a7edf6c0a1ce3": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1468759bf4dc44fba11b028aa1873cee": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_e5bb5b15444642ea86f86e62a361b959",
-       "max": 20,
-       "style": "IPY_MODEL_96e207c3e2774a928b72c44613f0e3f5",
-       "value": 20
-      }
-     },
-     "14fe0b96ad024a67b0433701fc410228": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_e7b34ebd626443458c1eccfa80611992",
-       "max": 20,
-       "style": "IPY_MODEL_dab99855ef0e44d1999f1902a60a8c42",
-       "value": 20
-      }
-     },
-     "15b506a240a54366874760d97e60f774": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "160706bc827e4f5d852adfc96cc30c3e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "16bbd1ecfcde4e10972fa8e8289c784a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "16cf2e2fd05144ffbd0a7058ecb46166": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "1813196e82b34e2e8c6ad657040164be": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1844ab8cb0614eaeb9b798d583273f8d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1a1b079608c04df48f418e25a7e136da": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "1ad32f6a9ef64ef3aae6bcae8151f08f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "1b78996363e04c619de1943d9c64b083": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1c15ffc0573044b3bb4067b8713241e4": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "1d2c9b832f18450d96db9099b1b982ac": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_00820fb2f8894fa38f2f88ea1bcf450f",
-       "style": "IPY_MODEL_7228c9a58e1c492ea92ffcd8df0cb983",
-       "value": " 95%"
-      }
-     },
-     "1e7974757bb34201843ebc0d73795961": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "1e86322883014f17a94aef265a972b98": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "1e8edddaad964339aa3f3d986dddea83": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1eab564e47124f5d8caf5adfc1d5f20e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_33f594200d0041008d37b031c0c9bcf6",
-       "max": 20,
-       "style": "IPY_MODEL_ac50bddccd62413289dd9e4fb0c81133",
-       "value": 20
-      }
-     },
-     "1f03c566660e4c11b0da377007351708": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "1f2a002a5a5f4614ad615ad02094f306": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_1b78996363e04c619de1943d9c64b083",
-       "style": "IPY_MODEL_e26270d9e03d49bb85b2b68a3df99cbd",
-       "value": " 19/20 [00:00&lt;00:00, 56.57it/s]"
-      }
-     },
-     "21cd1c3cc09547dda54ca04bd6383d64": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_38ccb1286d744b489bba4ea31e9113c6",
-       "style": "IPY_MODEL_406219f03f8f4f11b7be92d445cbaa02",
-       "value": " 10/10 [00:00&lt;00:00, 49.91it/s]"
-      }
-     },
-     "22cdac5099ab4a9e8bc06de49e166132": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "244e6198d45040c490758f440a80999c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_0d4688c5569e45eb815cb8f3f18fd628",
-       "style": "IPY_MODEL_6de446e187184118a580f5a68c4f26ad",
-       "value": " 70%"
-      }
-     },
-     "246cc76521d54d1284405f56c122f332": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "24d8d594870b4c75af8f1bd360de5a38": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_9e0285285073405db113bf4d6ff7e098",
-       "max": 400,
-       "style": "IPY_MODEL_aaeb9d0cd6124e43b0d299417e2a5d5c",
-       "value": 400
-      }
-     },
-     "27ba2a5ca62845bf8f73d947391ad22e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "27cb4e98ffb441f5b17bfa25474b669c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "293f30f6b3fe4aed99f3e317651d07e0": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "2a7dd2f362b14fea91edf45406728029": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "2b41856ed2bc4c79839d262ae43ddad8": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2b98fdadef774350bf0350a6f5a54449": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "2bff27af97db420d8661085faa21328b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c8a69a2b5dbf4bf791623a10aeab6f8f",
-       "style": "IPY_MODEL_54a80318f86a4a7cbf5877dbfc9dbabf",
-       "value": "100%"
-      }
-     },
-     "2cd4ae025bc94c7d9aa8c9cfadfa705f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_aadc7705c2374eb083c9eb047ac50e84",
-       "max": 20,
-       "style": "IPY_MODEL_a7d51bfc34c5420b9766dba17db42ce0",
-       "value": 20
-      }
-     },
-     "2eb6f77849ad425994e67651adc4687c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2f4a3f5a9bff46aaa41d6baabeb7666e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "2f5f08992f7745b0b5452b2c22c8e015": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_99b595603c1d45dca3b8e5d3f9a90e1e",
-       "style": "IPY_MODEL_cd5e8e6e6dba4f018b03787d9fc04c59",
-       "value": " 18/20 [00:00&lt;00:00, 56.82it/s]"
-      }
-     },
-     "33dc10e898b545fd95f6c1d0c70cf37d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "33f594200d0041008d37b031c0c9bcf6": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "35a0593e3d5842ba8d28a533abcf1046": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_1813196e82b34e2e8c6ad657040164be",
-       "max": 20,
-       "style": "IPY_MODEL_1c15ffc0573044b3bb4067b8713241e4",
-       "value": 20
-      }
-     },
-     "360a899b4aee466688246f064df82c72": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_dc74a6082a61499398c11d19bbb7308b",
-       "max": 20,
-       "style": "IPY_MODEL_22cdac5099ab4a9e8bc06de49e166132",
-       "value": 20
-      }
-     },
-     "360c99bcc6bb46958d5910bf8acb157f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "37e2e5818c9940e69bcb98e0261e67ce": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "38c7296d85344116a5d0f66e8725dcf4": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "38ccb1286d744b489bba4ea31e9113c6": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "39b8055d531a4d2da11d4a2ad7e5982e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "3b5af7b3982d413e97866a5737181a7f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_bab3616dc353426fb3ae3292196c1521",
-       "max": 20,
-       "style": "IPY_MODEL_9636c1be747f4ed58c79e4c73f37fc06",
-       "value": 20
-      }
-     },
-     "3bb06145583f43658bd60c15a8416354": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_0378537e69dd4cfc8beb05ab6742ffcf",
-       "max": 20,
-       "style": "IPY_MODEL_0db023e0b4c04517b1572e0016fd6097",
-       "value": 20
-      }
-     },
-     "3bc2f9cc8ad640f3853e4f830418473f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "3c30fc657f7142fbb00b7c6dccf69863": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_d0d6e3cf71aa40f29aeee7607fd75987",
-       "max": 20,
-       "style": "IPY_MODEL_3e634a971a60499ea60b16f0d698b1fa",
-       "value": 20
-      }
-     },
-     "3c57796efab14d288f6d4ff0fa4d1d5c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "3d4a66c3e090415cb7c6f309a2d5dc1f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "3d9481641482475cbf3a39daf55d5e17": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "3df356d0c6eb422abbb2bd15d62748d6": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "3e5c390dbe2340e7bcc16c308a0526ac": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_ec81aa182cc8434f856e3a5655ba14c5",
-       "style": "IPY_MODEL_3df356d0c6eb422abbb2bd15d62748d6",
-       "value": " 95%"
-      }
-     },
-     "3e634a971a60499ea60b16f0d698b1fa": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "406219f03f8f4f11b7be92d445cbaa02": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "4581de95d1b14b5eb4cf54dedf362611": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "468745258da649e7b3739e5c5922364d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "4749b6ff817047fc9c1364d7ba49ed74": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_aa8f9ad35948479fbdb929648657e8fc",
-        "IPY_MODEL_b3d0ae2ccc9941adab0bf96aef018c49",
-        "IPY_MODEL_d221a2ed8e4d4747b389dfb2edfc3fdb"
-       ],
-       "layout": "IPY_MODEL_1e8edddaad964339aa3f3d986dddea83"
-      }
-     },
-     "48c4e96b636c41cc95e826dce8092485": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "4c90876e84d342c98a58e2b33498ebfd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_aef2fa1b401f456791bfa49b761f1d4c",
-       "style": "IPY_MODEL_55dbc208d79e4e14a6e1d7e71a3a4ebd",
-       "value": " 20/20 [00:00&lt;00:00, 58.36it/s]"
-      }
-     },
-     "4dabd9b6919145ebad699491d2f71192": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "5003373f58b94ec1ad825039cea1a9ee": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_e40e3ce50a2c47c1a7217b178bfec173",
-       "style": "IPY_MODEL_64bb2daf89164b59b98a5b8212ed2ea8",
-       "value": "100%"
-      }
-     },
-     "515dec0366e648aead0d9023dee598e6": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_53e6d3f651794a319e5e53d746b6a259",
-       "style": "IPY_MODEL_c1d353df9fd24e909169a1c7c15b861b",
-       "value": " 18/20 [00:00&lt;00:00, 57.54it/s]"
-      }
-     },
-     "53e6d3f651794a319e5e53d746b6a259": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "54a80318f86a4a7cbf5877dbfc9dbabf": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "55dbc208d79e4e14a6e1d7e71a3a4ebd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "56e383da6e6f42efbfb67564709c64ac": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "5775f3cdfb6b40729f507c23825146f4": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c44c5cc6f5c340ef8ab71828df5fd31b",
-       "style": "IPY_MODEL_789fa7b80b1c4484a271358a0a62149b",
-       "value": "100%"
-      }
-     },
-     "59f97ef7c6984af69593bc7c3dd8183a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_f412a75adeae4dd8a1d15c81203934b7",
-       "style": "IPY_MODEL_bdc57f6b8b344263aa6fe293c466e349",
-       "value": " 20/20 [00:00&lt;00:00, 58.89it/s]"
-      }
-     },
-     "5a314f9984d0470d8f9dc3b48016c04d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_160706bc827e4f5d852adfc96cc30c3e",
-       "style": "IPY_MODEL_b1123e7c1b77420cae0ec3d8234602b1",
-       "value": " 19/20 [00:00&lt;00:00, 49.87it/s]"
-      }
-     },
-     "5a6e17f48dd249c2981d0da672f84446": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_5775f3cdfb6b40729f507c23825146f4",
-        "IPY_MODEL_d598e54836f140a89a9a993b83b6504c",
-        "IPY_MODEL_b06d9b42c7d34d7b819e42c9d497b1b2"
-       ],
-       "layout": "IPY_MODEL_8f352f46c9464e5984b778338fe2d92d"
-      }
-     },
-     "5c057b9e4a094138959779154aebb9de": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "5c13cfbcfde648a793753b9508551491": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_d8387558b3d74b938cf7aa66665f7822",
-       "max": 20,
-       "style": "IPY_MODEL_8c9b5977d63645759aeb60e98c93e478",
-       "value": 20
-      }
-     },
-     "5f25794d950b491f8ff602e32824ed00": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "5f89abcfb66a497f827948939e352d92": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "61085fae5c3f4f14ae55b9dcf6d15091": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_5f25794d950b491f8ff602e32824ed00",
-       "style": "IPY_MODEL_38c7296d85344116a5d0f66e8725dcf4",
-       "value": " 19/20 [00:00&lt;00:00, 57.49it/s]"
-      }
-     },
-     "61d0b03fb5894eae89991e0e53b2ee89": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "62f8308ae58d417489c882051520898e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "63340a6c0b6c4589a641386ae67a69bb": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_be1cf1c1e96a47798e160723dee6f31c",
-       "style": "IPY_MODEL_909e2ac0f69e4982877128c1e268ae79",
-       "value": "100%"
-      }
-     },
-     "634847862f0542d390fc37cd5fbcd713": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "64bb2daf89164b59b98a5b8212ed2ea8": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "650a65150c694b2996f85bb7cd1b8db4": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c6783899f76d49d5a4f3815bf1edbbde",
-       "style": "IPY_MODEL_d9a4d571993d4240b538df9f86e2f172",
-       "value": " 19/20 [00:00&lt;00:00, 59.58it/s]"
-      }
-     },
-     "67489466332942c5996de61f223003e2": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "69e78be767164eb6871e72286a4df106": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "6a643f694fc24c459b32d5efab6866ad": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "6a6d93f09b234586988c4d260039363d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "6a7ea74042704bb39511701116e63fad": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_a762dce447964f42a962940a93e344c8",
-       "style": "IPY_MODEL_f083caacc043492fb5ca63fc30b0328c",
-       "value": " 20/20 [00:00&lt;00:00, 61.58it/s]"
-      }
-     },
-     "6adb061cfc7845e7919e940fa62f531e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "6ce7dc29016946caa8b6133a3b3e6e92": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_16bbd1ecfcde4e10972fa8e8289c784a",
-       "style": "IPY_MODEL_f7d2d299cca643789df638e0d886dba9",
-       "value": " 400/400 [00:07&lt;00:00, 58.43it/s]"
-      }
-     },
-     "6dda613029c84f1586b2df76ef342187": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_e92536cb0c204a669bad5d5296422ac1",
-       "max": 20,
-       "style": "IPY_MODEL_16cf2e2fd05144ffbd0a7058ecb46166",
-       "value": 20
-      }
-     },
-     "6de446e187184118a580f5a68c4f26ad": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "7076cd7669ba423ea56c5d22752409aa": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "7155e0b738344e269371852eb9473110": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "71d85d586c5c41d1bfbb67a471219f9b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "7228c9a58e1c492ea92ffcd8df0cb983": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "74d995d46e074c6bac03728412284c58": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "766da6bdd0fb45aa9812cf252ec80d35": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_74d995d46e074c6bac03728412284c58",
-       "style": "IPY_MODEL_2a7dd2f362b14fea91edf45406728029",
-       "value": " 19/20 [00:00&lt;00:00, 59.05it/s]"
-      }
-     },
-     "7686e4f7db8545d38f5267d5bec25596": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "789fa7b80b1c4484a271358a0a62149b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "79dfdb9f25854c549baf9a5741b81910": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "7bab947042b540efaf498346b83880d5": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "7bedd22693a14b85b899ba215d9419fc": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_f953696dc9764d10b579151cd22863b5",
-       "max": 20,
-       "style": "IPY_MODEL_ce60ac23f4d54dc3a284865755de921d",
-       "value": 20
-      }
-     },
-     "7d959d4ddeb04b06bd476ea6be819d8e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "81ef3571ab38486ba39e7dbc2db868df": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "82c65b5927154111b6b7582ea3d111ad": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_62f8308ae58d417489c882051520898e",
-       "style": "IPY_MODEL_d5ccc83fdf574d6d96ccc3d6df10fbaf",
-       "value": " 20/20 [00:00&lt;00:00, 61.15it/s]"
-      }
-     },
-     "841ff5b845044cf4bf2cff9ad02e1f9b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_2eb6f77849ad425994e67651adc4687c",
-       "style": "IPY_MODEL_a09b7859737240979a15c3b5f4644c30",
-       "value": " 14/20 [00:00&lt;00:00, 63.78it/s]"
-      }
-     },
-     "85b71fd87bf143a18603928c2479b4f0": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "86bb885bec84460d8482dfcd09ee6cc7": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "86f6675020314335a7e2202e5ee52b56": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "8a50b6c36fe147e6a5e11fdea54ceb79": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8a9995a5e11a40b89cc72c265e0cb26e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8c9b5977d63645759aeb60e98c93e478": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "8ced257c358241b6af032b5883655fbb": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "8f352f46c9464e5984b778338fe2d92d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "909e2ac0f69e4982877128c1e268ae79": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "90bac4b9cf9944eda1a6bba1e2b0cf7a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "914b7d8a07d24c749b324e292501b9fa": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "91ec8c653a2e432fac257deb8aaa5633": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "9315b47ef65647f485067d87f9c806cd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_2f4a3f5a9bff46aaa41d6baabeb7666e",
-       "style": "IPY_MODEL_48c4e96b636c41cc95e826dce8092485",
-       "value": " 20/20 [00:00&lt;00:00, 62.71it/s]"
-      }
-     },
-     "932f1e4dbf674f21a43362a9fd959278": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "95b040cabe4a41d88ea231eaad666896": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_b4ce66fb28dc4e05807d1250fd0fcda9",
-       "style": "IPY_MODEL_69e78be767164eb6871e72286a4df106",
-       "value": " 20/20 [00:07&lt;00:00,  2.63it/s]"
-      }
-     },
-     "9636c1be747f4ed58c79e4c73f37fc06": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "96e207c3e2774a928b72c44613f0e3f5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "97eba679b30147a3b6ad77026f56f16c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "9852e2768873485190a0902b121f52db": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "99b595603c1d45dca3b8e5d3f9a90e1e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "9b7d0d972a0a43edb043491a44a9ff7a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "9d771bdcbc1642d7a86dd80a16c621f1": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_f9211e9657204bf2be2b419b9496c0a2",
-       "style": "IPY_MODEL_86bb885bec84460d8482dfcd09ee6cc7",
-       "value": " 95%"
-      }
-     },
-     "9e0285285073405db113bf4d6ff7e098": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "9f9b0458fdaf4e719a9aad940ef0e128": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_0251abfff957407eba9b240618313e0c",
-       "style": "IPY_MODEL_c64624c677f24f6e95cc1aeb92bf7abd",
-       "value": " 20/20 [00:00&lt;00:00, 57.72it/s]"
-      }
-     },
-     "a020f6eb56c6426fa67b8536bede9175": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "a09b7859737240979a15c3b5f4644c30": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "a2fef1373f75488aa2aae8b1e8bb0309": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_b7b0f15b458e46c6bc07db1db517482f",
-        "IPY_MODEL_c6c562bb2f23403093bbb0840a67b3d5",
-        "IPY_MODEL_21cd1c3cc09547dda54ca04bd6383d64"
-       ],
-       "layout": "IPY_MODEL_cb32e7c112c848c4bcd50e7bf92ad9be"
-      }
-     },
-     "a47566f763e84971b348fad0f3045e2b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_eb63b0e5804d4ae986f52b40791ec081",
-        "IPY_MODEL_b72d472c18a645e5a6aab68b80a2d96a",
-        "IPY_MODEL_daceb5a73b81477086f42bf604ff354e"
-       ],
-       "layout": "IPY_MODEL_7076cd7669ba423ea56c5d22752409aa"
-      }
-     },
-     "a56ce16f9d03474ba8f19af6b3c48495": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_113135000080412bbf1d8aaea28e6dfb",
-       "style": "IPY_MODEL_27ba2a5ca62845bf8f73d947391ad22e",
-       "value": " 95%"
-      }
-     },
-     "a5c5f176648b40c98943b82e70311129": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "a5cb87cf8eb34ecfaee717f660e88db3": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "a6e41b2254084f81a722c80be7ccbdf5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_b70ff1aac4b34686b1a8e55912abb4d2",
-       "max": 20,
-       "style": "IPY_MODEL_c44ffb313d734462b4c7484022a5f4fc",
-       "value": 20
-      }
-     },
-     "a762dce447964f42a962940a93e344c8": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "a7d51bfc34c5420b9766dba17db42ce0": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "a86975aac7e7429195289bb01485879b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "a88d68e130fc4051889df9fdad9a1f5e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "a8fae22cb6be4d3aad37559f6e859d98": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_4dabd9b6919145ebad699491d2f71192",
-       "style": "IPY_MODEL_00a423de9d714ee28699fae2f8c8696d",
-       "value": " 20/20 [00:00&lt;00:00, 61.55it/s]"
-      }
-     },
-     "a9a6ce00ca3a4d8fa0e4ad618943b86d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "aa8f9ad35948479fbdb929648657e8fc": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_dee4c0f43fe44c288ea19337cfefb458",
-       "style": "IPY_MODEL_deeed6cf997f4a2c84a572f8fc4dd57c",
-       "value": "100%"
-      }
-     },
-     "aadc7705c2374eb083c9eb047ac50e84": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "aaeb9d0cd6124e43b0d299417e2a5d5c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "ac50bddccd62413289dd9e4fb0c81133": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "aef2fa1b401f456791bfa49b761f1d4c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "af68e481505441c7858f89b9997c1957": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "af9925deb88c4cb1bf3e9bb3a5282c27": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_bbb081740d7f41c3aa7f57d0fcac7596",
-       "style": "IPY_MODEL_b244245d682841d0bb985a99cb21b033",
-       "value": "100%"
-      }
-     },
-     "afc74f3725b6486db926fea82da41a63": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_c1585d1507d34350936295cb3e1e10ef",
-        "IPY_MODEL_6dda613029c84f1586b2df76ef342187",
-        "IPY_MODEL_9f9b0458fdaf4e719a9aad940ef0e128"
-       ],
-       "layout": "IPY_MODEL_67489466332942c5996de61f223003e2"
-      }
-     },
-     "b03840ab0fd740938e45d68480e91b5d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_e847b2925c9440028013b8319b93c86b",
-        "IPY_MODEL_be85d91ad53f4088a557c4fa8e8c41a3",
-        "IPY_MODEL_59f97ef7c6984af69593bc7c3dd8183a"
-       ],
-       "layout": "IPY_MODEL_ed4e007100c54243ae05c9e3f17a947b"
-      }
-     },
-     "b06d9b42c7d34d7b819e42c9d497b1b2": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_33dc10e898b545fd95f6c1d0c70cf37d",
-       "style": "IPY_MODEL_078f377d1c044f589bfafa4a1dcf9e88",
-       "value": " 400/400 [00:07&lt;00:00, 57.40it/s]"
-      }
-     },
-     "b0a8809af2c94ff4b7e52dd5e798933f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_ed2bf7a1057e4e94b001d4c74a4a12fa",
-       "style": "IPY_MODEL_97eba679b30147a3b6ad77026f56f16c",
-       "value": " 95%"
-      }
-     },
-     "b1123e7c1b77420cae0ec3d8234602b1": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b1f799f773ce4d8982e05894a679e9f2": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "b244245d682841d0bb985a99cb21b033": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b25347fb16ad4bf092d3abb8c4ec9286": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b3489dfd4b5742bab38910d1e881870f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "b3610503864c4e3bbcc60f270810509d": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "b3d0ae2ccc9941adab0bf96aef018c49": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_10b4363f69f043cb8623f65e03ef1d88",
-       "max": 400,
-       "style": "IPY_MODEL_b558615010ba4c73a42a5299c65c9bd9",
-       "value": 400
-      }
-     },
-     "b49cb6e80e314b13a821d9e5031aba44": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b4b53743fafe4c499c699f5711ace9d7": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_61d0b03fb5894eae89991e0e53b2ee89",
-       "style": "IPY_MODEL_7155e0b738344e269371852eb9473110",
-       "value": " 90%"
-      }
-     },
-     "b4ce66fb28dc4e05807d1250fd0fcda9": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "b558615010ba4c73a42a5299c65c9bd9": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b5a201f491544b0a9833f38d2fc7ca98": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "b5e48071537b4cb38524c16f574cb87a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_eb02e689b6ef47bba734e92686f8fa82",
-       "style": "IPY_MODEL_6adb061cfc7845e7919e940fa62f531e",
-       "value": " 20/20 [00:00&lt;00:00, 29.43it/s]"
-      }
-     },
-     "b62ec6a3ea004a25b51a34d27b73e79d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_00620ebaf2c54aff99f9fc5ee3e27149",
-        "IPY_MODEL_3bb06145583f43658bd60c15a8416354",
-        "IPY_MODEL_95b040cabe4a41d88ea231eaad666896"
-       ],
-       "layout": "IPY_MODEL_07cf32afa31145b7a36ada3aff7e9553"
-      }
-     },
-     "b645f76a69604053b35091f8f3702a82": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_cf4ac5479c19487db0d3926a2255efb3",
-       "style": "IPY_MODEL_06f59874b47747daae0c755c1153cf8a",
-       "value": " 95%"
-      }
-     },
-     "b6902bd09822465cbca623f6b057f9c7": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "b70ff1aac4b34686b1a8e55912abb4d2": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "b72d472c18a645e5a6aab68b80a2d96a": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_0b145d3f3ac54acaa40f73de1566647d",
-       "max": 20,
-       "style": "IPY_MODEL_3d9481641482475cbf3a39daf55d5e17",
-       "value": 20
-      }
-     },
-     "b7b0f15b458e46c6bc07db1db517482f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_56e383da6e6f42efbfb67564709c64ac",
-       "style": "IPY_MODEL_0fac0bb47214452eaab6dca844f9ed16",
-       "value": "100%"
-      }
-     },
-     "bab3616dc353426fb3ae3292196c1521": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "bab5ad93e9084387a77df8894729e0ca": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_0d15b755d8d142df9d8951bbaf5bb038",
-       "max": 20,
-       "style": "IPY_MODEL_81ef3571ab38486ba39e7dbc2db868df",
-       "value": 20
-      }
-     },
-     "bbb081740d7f41c3aa7f57d0fcac7596": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "bdc57f6b8b344263aa6fe293c466e349": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "be1cf1c1e96a47798e160723dee6f31c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "be85d91ad53f4088a557c4fa8e8c41a3": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_13e18a3a2b97435fa56a7edf6c0a1ce3",
-       "max": 20,
-       "style": "IPY_MODEL_e3589a2f3a8c4e2abf0d85bac9c00894",
-       "value": 20
-      }
-     },
-     "c03f3587b7374bfd874f71863de066d1": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c103bd3c105f4c28b88e3b71044fb7f1": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c1585d1507d34350936295cb3e1e10ef": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_b3610503864c4e3bbcc60f270810509d",
-       "style": "IPY_MODEL_293f30f6b3fe4aed99f3e317651d07e0",
-       "value": "100%"
-      }
-     },
-     "c1d353df9fd24e909169a1c7c15b861b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "c2ce20e0500042e4b7f98acf8e6cc60b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "c44c5cc6f5c340ef8ab71828df5fd31b": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c44ffb313d734462b4c7484022a5f4fc": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "c570a1bf49a544b19e064944b711807e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_1844ab8cb0614eaeb9b798d583273f8d",
-       "style": "IPY_MODEL_a86975aac7e7429195289bb01485879b",
-       "value": " 20/20 [00:00&lt;00:00, 61.84it/s]"
-      }
-     },
-     "c5c37c89337e4a4390ae6dbe42ff923d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "c63e9a27effa416daefb13384904543f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "c64624c677f24f6e95cc1aeb92bf7abd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "c6783899f76d49d5a4f3815bf1edbbde": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c69bdf03055343018eae550f2b903355": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c6c562bb2f23403093bbb0840a67b3d5": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_eeab145eec544abf8a4453fc1635d093",
-       "max": 10,
-       "style": "IPY_MODEL_85b71fd87bf143a18603928c2479b4f0",
-       "value": 10
-      }
-     },
-     "c7009248b32743a5b8a0670589b83f26": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "c868b1bb1d574805a73a9fc9ae7bc44a": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c88eb093afd04978b32431b4d6ae24d3": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "c8a69a2b5dbf4bf791623a10aeab6f8f": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "cb2f30eef37c442ea4e2f1c0ebb9c403": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c88eb093afd04978b32431b4d6ae24d3",
-       "style": "IPY_MODEL_a5cb87cf8eb34ecfaee717f660e88db3",
-       "value": "100%"
-      }
-     },
-     "cb32e7c112c848c4bcd50e7bf92ad9be": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "ccb5b50955ac42e5a646f97e2edfcee7": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_a9a6ce00ca3a4d8fa0e4ad618943b86d",
-       "style": "IPY_MODEL_cce69aed6fa04054806dd2fc8c2eb619",
-       "value": " 20/20 [00:00&lt;00:00, 61.67it/s]"
-      }
-     },
-     "cce69aed6fa04054806dd2fc8c2eb619": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "cd5e8e6e6dba4f018b03787d9fc04c59": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "ce60ac23f4d54dc3a284865755de921d": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "ce6e42c96e3248a8a4dc653819bb74e4": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_1f03c566660e4c11b0da377007351708",
-       "style": "IPY_MODEL_f26db57ad53746c785f532cab5faba40",
-       "value": "100%"
-      }
-     },
-     "cf3d468131ae42019b776f1d5cc40538": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "cf4ac5479c19487db0d3926a2255efb3": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "d0d6e3cf71aa40f29aeee7607fd75987": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "d1d85b14a2cf43d5a84a56503ee3ea51": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "d221a2ed8e4d4747b389dfb2edfc3fdb": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_fc9441e95e5448e3b86f683e80131942",
-       "style": "IPY_MODEL_ff369ca6125543c3877e1c31fa79dc87",
-       "value": " 400/400 [00:07&lt;00:00, 57.01it/s]"
-      }
-     },
-     "d380ffebdab94a668a01e8def8aa1561": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_8a50b6c36fe147e6a5e11fdea54ceb79",
-       "max": 20,
-       "style": "IPY_MODEL_39b8055d531a4d2da11d4a2ad7e5982e",
-       "value": 20
-      }
-     },
-     "d5494206f8c44affba19ec672f97bbaf": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_c69bdf03055343018eae550f2b903355",
-       "max": 20,
-       "style": "IPY_MODEL_e24dfe286a4e465cacbdd82475e3809e",
-       "value": 20
-      }
-     },
-     "d598e54836f140a89a9a993b83b6504c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "bar_style": "success",
-       "layout": "IPY_MODEL_c03f3587b7374bfd874f71863de066d1",
-       "max": 400,
-       "style": "IPY_MODEL_a020f6eb56c6426fa67b8536bede9175",
-       "value": 400
-      }
-     },
-     "d5ccc83fdf574d6d96ccc3d6df10fbaf": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "d759c9feffdb4b6a9688f1966e1b2169": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_f1b8bc39f34244f597553a6241a3bb7b",
-        "IPY_MODEL_24d8d594870b4c75af8f1bd360de5a38",
-        "IPY_MODEL_6ce7dc29016946caa8b6133a3b3e6e92"
-       ],
-       "layout": "IPY_MODEL_246cc76521d54d1284405f56c122f332"
-      }
-     },
-     "d8387558b3d74b938cf7aa66665f7822": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "d9a4d571993d4240b538df9f86e2f172": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "d9c0410a0b0647e88766ed621ea64517": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_dd0b0e9d078e45bca3c0b00a49e2a196",
-       "style": "IPY_MODEL_b6902bd09822465cbca623f6b057f9c7",
-       "value": " 90%"
-      }
-     },
-     "dab99855ef0e44d1999f1902a60a8c42": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "daceb5a73b81477086f42bf604ff354e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_e3c570c5e77944f2a551855d435d3def",
-       "style": "IPY_MODEL_c2ce20e0500042e4b7f98acf8e6cc60b",
-       "value": " 20/20 [00:00&lt;00:00, 29.53it/s]"
-      }
-     },
-     "dc74a6082a61499398c11d19bbb7308b": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "dd0b0e9d078e45bca3c0b00a49e2a196": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "dded914a091e466db615f659b78a6094": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "de67a7d8e91d414fb3b36dc1f6da6279": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_b3489dfd4b5742bab38910d1e881870f",
-       "max": 20,
-       "style": "IPY_MODEL_27cb4e98ffb441f5b17bfa25474b669c",
-       "value": 20
-      }
-     },
-     "dee4c0f43fe44c288ea19337cfefb458": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "deeed6cf997f4a2c84a572f8fc4dd57c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "e24dfe286a4e465cacbdd82475e3809e": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "e26270d9e03d49bb85b2b68a3df99cbd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "e293b6c0097d47aab36622e159fa6f56": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_4581de95d1b14b5eb4cf54dedf362611",
-       "style": "IPY_MODEL_914b7d8a07d24c749b324e292501b9fa",
-       "value": " 14/20 [00:00&lt;00:00, 62.89it/s]"
-      }
-     },
-     "e3589a2f3a8c4e2abf0d85bac9c00894": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "ProgressStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "e3c570c5e77944f2a551855d435d3def": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e3c61d2f31824cd0b4ed1d36b6f18cd9": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_e5d62acb2c6f498294660f1f303c2ce6",
-       "style": "IPY_MODEL_634847862f0542d390fc37cd5fbcd713",
-       "value": " 70%"
-      }
-     },
-     "e40e3ce50a2c47c1a7217b178bfec173": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e4a3e2a9082c48f6a321f3eb602a2f34": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_2b41856ed2bc4c79839d262ae43ddad8",
-       "style": "IPY_MODEL_b25347fb16ad4bf092d3abb8c4ec9286",
-       "value": "100%"
-      }
-     },
-     "e506ab46b34f47e68f4ccda3e48f9563": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_9852e2768873485190a0902b121f52db",
-       "style": "IPY_MODEL_eb295c66651c4550b6d2e2ec992de7d3",
-       "value": " 19/20 [00:00&lt;00:00, 60.52it/s]"
-      }
-     },
-     "e57f6e2b497f413096ea11c0b769a80e": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "e5bb5b15444642ea86f86e62a361b959": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e5d62acb2c6f498294660f1f303c2ce6": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e604c7725bfc48a38474676ae4bd612c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_a5c5f176648b40c98943b82e70311129",
-       "style": "IPY_MODEL_7686e4f7db8545d38f5267d5bec25596",
-       "value": " 20/20 [00:00&lt;00:00, 60.84it/s]"
-      }
-     },
-     "e7b34ebd626443458c1eccfa80611992": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e847b2925c9440028013b8319b93c86b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_3bc2f9cc8ad640f3853e4f830418473f",
-       "style": "IPY_MODEL_13c63d3a53834e78ac7c33968a8b92ff",
-       "value": "100%"
-      }
-     },
-     "e8caf93443974e8b88b2182329a0c4da": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "e8e3c48dd49a48f39577292d5e92f215": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "e92536cb0c204a669bad5d5296422ac1": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "eac9c8395935427aa0571bb0ee8eb55c": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "eb02e689b6ef47bba734e92686f8fa82": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "eb295c66651c4550b6d2e2ec992de7d3": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "eb63b0e5804d4ae986f52b40791ec081": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_5c057b9e4a094138959779154aebb9de",
-       "style": "IPY_MODEL_2b98fdadef774350bf0350a6f5a54449",
-       "value": "100%"
-      }
-     },
-     "ec81aa182cc8434f856e3a5655ba14c5": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "ed2bf7a1057e4e94b001d4c74a4a12fa": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "ed4e007100c54243ae05c9e3f17a947b": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "edda46662c2441419811b449884baed8": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_79dfdb9f25854c549baf9a5741b81910",
-       "max": 20,
-       "style": "IPY_MODEL_1a1b079608c04df48f418e25a7e136da",
-       "value": 20
-      }
-     },
-     "eeab145eec544abf8a4453fc1635d093": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f083caacc043492fb5ca63fc30b0328c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "f1b8bc39f34244f597553a6241a3bb7b": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_15b506a240a54366874760d97e60f774",
-       "style": "IPY_MODEL_468745258da649e7b3739e5c5922364d",
-       "value": "100%"
-      }
-     },
-     "f2447d9f74884497a04699e0d6899179": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_f9a3f32a739a4332a2240e36c2f3eff7",
-       "style": "IPY_MODEL_fba40572a8f740b1aaad454c99f8380c",
-       "value": " 20/20 [00:00&lt;00:00, 61.86it/s]"
-      }
-     },
-     "f26db57ad53746c785f532cab5faba40": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "f412a75adeae4dd8a1d15c81203934b7": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f4841d7499924e2e87e04d7a79792a68": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {
-       "visibility": "hidden"
-      }
-     },
-     "f592530374a749a89a4c98a0602bafe0": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f5f579a5844649a49082c4b265cc2f12": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HTMLModel",
-      "state": {
-       "layout": "IPY_MODEL_c868b1bb1d574805a73a9fc9ae7bc44a",
-       "style": "IPY_MODEL_6a643f694fc24c459b32d5efab6866ad",
-       "value": "100%"
-      }
-     },
-     "f7be54b0e0ab4020a7e57bd0e43d2229": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "HBoxModel",
-      "state": {
-       "children": [
-        "IPY_MODEL_0c215d5b062e4bd8b817dd7e9818cb84",
-        "IPY_MODEL_360a899b4aee466688246f064df82c72",
-        "IPY_MODEL_b5e48071537b4cb38524c16f574cb87a"
-       ],
-       "layout": "IPY_MODEL_dded914a091e466db615f659b78a6094"
-      }
-     },
-     "f7d2d299cca643789df638e0d886dba9": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "f9211e9657204bf2be2b419b9496c0a2": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f953696dc9764d10b579151cd22863b5": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f9a3f32a739a4332a2240e36c2f3eff7": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "f9bcb3a805b346459cde4f9928fcb40f": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_a88d68e130fc4051889df9fdad9a1f5e",
-       "max": 20,
-       "style": "IPY_MODEL_0e27c837d07949e88bd57f35a93535f3",
-       "value": 20
-      }
-     },
-     "fa402417a4a941c6bb0fc824993b34fd": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "FloatProgressModel",
-      "state": {
-       "layout": "IPY_MODEL_cf3d468131ae42019b776f1d5cc40538",
-       "max": 20,
-       "style": "IPY_MODEL_86f6675020314335a7e2202e5ee52b56",
-       "value": 20
-      }
-     },
-     "fba40572a8f740b1aaad454c99f8380c": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     },
-     "fc9441e95e5448e3b86f683e80131942": {
-      "model_module": "@jupyter-widgets/base",
-      "model_module_version": "1.2.0",
-      "model_name": "LayoutModel",
-      "state": {}
-     },
-     "ff369ca6125543c3877e1c31fa79dc87": {
-      "model_module": "@jupyter-widgets/controls",
-      "model_module_version": "1.5.0",
-      "model_name": "DescriptionStyleModel",
-      "state": {
-       "description_width": ""
-      }
-     }
-    },
+    "state": {},
     "version_major": 2,
     "version_minor": 0
    }

From 8a34c53cff664c30cf2668f35f1be99b5d1128bd Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 1 Nov 2022 01:21:39 +0000
Subject: [PATCH 12/14] [pre-commit.ci] pre-commit autoupdate
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

updates:
- [github.com/asottile/pyupgrade: v3.1.0 → v3.2.0](https://github.com/asottile/pyupgrade/compare/v3.1.0...v3.2.0)
---
 .pre-commit-config.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 26aa89ec25fd..1bd2ecc0ffd7 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -18,7 +18,7 @@ repos:
     hooks:
       - id: isort
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.1.0
+    rev: v3.2.0
     hooks:
     - id: pyupgrade
       args: ['--py38-plus']

From 6a971a634452f9ee042be89494b747ca6d8ef02b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 1 Nov 2022 04:04:29 +0000
Subject: [PATCH 13/14] Update google-auth requirement from ~=2.13.0 to
 ~=2.14.0

Updates the requirements on [google-auth](https://github.com/googleapis/google-auth-library-python) to permit the latest version.
- [Release notes](https://github.com/googleapis/google-auth-library-python/releases)
- [Changelog](https://github.com/googleapis/google-auth-library-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/googleapis/google-auth-library-python/compare/v2.13.0...v2.14.0)

---
updated-dependencies:
- dependency-name: google-auth
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index f32307ede4e9..94cea7721c7d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -35,7 +35,7 @@ fastjsonschema~=2.16.2
 fonttools~=4.38.0
 future~=0.18.2
 google-api-core~=2.10.2
-google-auth~=2.13.0
+google-auth~=2.14.0
 googleapis-common-protos~=1.56.4
 h5netcdf~=1.0.2
 h5py~=3.7.0

From c85314ad7acda1e4da6fab4151d00324e64746c8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 1 Nov 2022 04:04:38 +0000
Subject: [PATCH 14/14] Update ipykernel requirement from ~=6.16.1 to ~=6.17.0

Updates the requirements on [ipykernel]() to permit the latest version.

---
updated-dependencies:
- dependency-name: ipykernel
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index f32307ede4e9..9a7464203c25 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -46,7 +46,7 @@ importlib-metadata~=5.0.0; python_version < '3.10'
 importlib-resources~=5.9.0; python_version < '3.9'
 incremental~=22.10.0
 iniconfig~=1.1.1
-ipykernel~=6.16.1
+ipykernel~=6.17.0
 ipython~=8.6.0
 ipython-genutils~=0.2.0
 ipywidgets~=8.0.2