From 1bb0298af2bacd6ba64150cd777b21ecfd98be11 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 6 Feb 2026 13:12:36 -0800 Subject: [PATCH 01/22] Refactor fast sweep to use parameter with setpoints --- .../Keithley/_Keithley_2600.py | 257 ++++++++---------- 1 file changed, 120 insertions(+), 137 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index fcba7c7ae539..fd31039284a9 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -4,7 +4,7 @@ import struct import warnings from enum import StrEnum -from typing import TYPE_CHECKING, Any, Literal +from typing import TYPE_CHECKING, Any import numpy as np import numpy.typing as npt @@ -17,7 +17,6 @@ VisaInstrumentKWArgs, ) from qcodes.parameters import ( - ArrayParameter, Parameter, ParameterWithSetpoints, ParamRawDataType, @@ -27,14 +26,13 @@ if TYPE_CHECKING: from collections.abc import Sequence - from qcodes_loop.data.data_set import DataSet from typing_extensions import Unpack log = logging.getLogger(__name__) -class LuaSweepParameter(ArrayParameter): +class LuaSweepParameter(ParameterWithSetpoints): """ Parameter class to hold the data from a deployed Lua script sweep. @@ -49,25 +47,7 @@ def __init__(self, name: str, instrument: Instrument, **kwargs: Any) -> None: **kwargs, ) - def prepareSweep(self, start: float, stop: float, steps: int, mode: str) -> None: - """ - Builds setpoints and labels - - Args: - start: Starting point of the sweep - stop: Endpoint of the sweep - steps: No. of sweep steps - mode: Type of sweep, either 'IV' (voltage sweep), - 'VI' (current sweep two probe setup) or - 'VIfourprobe' (current sweep four probe setup) - - """ - - if mode not in ["IV", "VI", "VIfourprobe"]: - raise ValueError('mode must be either "VI", "IV" or "VIfourprobe"') - - self.shape = (steps,) - + def _set_mode(self, mode: str) -> None: if mode == "IV": self.unit = "A" self.setpoint_names = ("Voltage",) @@ -89,24 +69,87 @@ def prepareSweep(self, start: float, stop: float, steps: int, mode: str) -> None self.label = "voltage" self._short_name = "vi_sweep_four_probe" - self.setpoints = (tuple(np.linspace(start, stop, steps)),) + def _fast_sweep(self) -> npt.NDArray: + if self.instrument is None: + raise RuntimeError("No instrument attached to Parameter.") - self.start = start - self.stop = stop - self.steps = steps - self.mode = mode + channel = self.instrument.channel - def get_raw(self) -> npt.NDArray: - if self.instrument is not None: - data = self.instrument._fast_sweep( - self.start, self.stop, self.steps, self.mode - ) + # an extra visa query, a necessary precaution + # to avoid timing out when waiting for long + # measurements + nplc = self.instrument.nplc() + + mode = self.instrument.fastsweep_mode() + start = self.instrument.fastsweep_start() + stop = self.instrument.fastsweep_stop() + steps = self.instrument.fastsweep_npts() + + dV = (stop - start) / (steps - 1) + + if mode == "IV": + meas = "i" + source = "v" + func = "1" + sense_mode = "0" + elif mode == "VI": + meas = "v" + source = "i" + func = "0" + sense_mode = "0" + elif mode == "VIfourprobe": + meas = "v" + source = "i" + func = "0" + sense_mode = "1" else: - raise RuntimeError("No instrument attached to Parameter.") + raise ValueError(f"Invalid fastsweep mode {mode}") + + script = [ + f"{channel}.measure.nplc = {nplc:.12f}", + f"{channel}.source.output = 1", + f"startX = {start:.12f}", + f"dX = {dV:.12f}", + f"{channel}.sense = {sense_mode}", + f"{channel}.source.output = 1", + f"{channel}.source.func = {func}", + f"{channel}.measure.count = 1", + f"{channel}.nvbuffer1.clear()", + f"{channel}.nvbuffer1.appendmode = 1", + f"for index = 1, {steps} do", + " target = startX + (index-1)*dX", + f" {channel}.source.level{source} = target", + f" {channel}.measure.{meas}({channel}.nvbuffer1)", + "end", + "format.data = format.REAL32", + "format.byteorder = format.LITTLEENDIAN", + f"printbuffer(1, {steps}, {channel}.nvbuffer1.readings)", + ] + + return self.instrument._execute_lua(script, steps) + + def get_raw(self) -> npt.NDArray: + data = self._fast_sweep() return data +class FastSweepSetpoints(Parameter): + """ + A simple :class:`.Parameter` that holds all the setpoints (relative to the + measurement start) at which the points of the time trace were acquired. + """ + + def get_raw(self) -> npt.NDArray: + if self.instrument is None: + raise RuntimeError("No instrument attached to Parameter.") + + npts = self.instrument.fastsweep_npts() + start = self.instrument.fastsweep_start() + stop = self.instrument.fastsweep_stop() + return np.linspace(start, stop, npts) + + class TimeTrace(ParameterWithSetpoints): """ A parameter class that holds the data corresponding to the time dependence of @@ -576,10 +619,51 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Current limit e.g. the maximum current allowed in voltage mode. If exceeded the voltage will be clipped.""" + self.fastsweep_npts: Parameter = self.add_parameter( + "fastsweep_npts", + initial_value=20, + label="Number of fastweep points", + get_cmd=None, + set_cmd=None, + ) + """Parameter fastweep_npts""" + + self.fastsweep_start: Parameter = self.add_parameter( + "fastsweep_start", label="fastsweep start", get_cmd=None, set_cmd=None + ) + """Starting value of fastsweep. Can be current or voltage.""" + + self.fastsweep_stop: Parameter = self.add_parameter( + "fastsweep_stop", label="fastsweep stop", get_cmd=None, set_cmd=None + ) + """Stopping value of fastsweep. Can be current or voltage.""" + + self.fastsweep_axis: FastSweepSetpoints = self.add_parameter( + name="fastsweep_axis", + label="Fastsweep", + snapshot_value=False, + vals=vals.Arrays(shape=(self.fastsweep_npts,)), + parameter_class=FastSweepSetpoints, + ) + """Holds array of setpoints for doing a fastsweep. Can + be of units V or I depending on `Keithley2600Channel.fastsweep_mode`""" + self.fastsweep: LuaSweepParameter = self.add_parameter( - "fastsweep", parameter_class=LuaSweepParameter + "fastsweep", + vals=vals.Arrays(shape=(self.fastsweep_npts,)), + setpoints=(self.fastsweep_axis,), + parameter_class=LuaSweepParameter, + ) + """Performs buffered readout of desired sweep mode.""" + + self.fastsweep_mode: Parameter = self.add_parameter( + "fastsweep_mode", + initial_value="IV", + get_cmd=None, + set_cmd=self.fastsweep._set_mode, + vals=vals.Enum("IV", "VI", "VIfourprobe"), ) - """Parameter fastsweep""" + """Parameter fastsweep_mode""" self.timetrace_npts: Parameter = self.add_parameter( "timetrace_npts", @@ -645,107 +729,6 @@ def reset(self) -> None: log.debug(f"Reset channel {self.channel}. Updating settings...") self.snapshot(update=True) - def doFastSweep(self, start: float, stop: float, steps: int, mode: str) -> DataSet: - """ - Perform a fast sweep using a deployed lua script and - return a QCoDeS DataSet with the sweep. - - Args: - start: starting sweep value (V or A) - stop: end sweep value (V or A) - steps: number of steps - mode: Type of sweep, either 'IV' (voltage sweep), - 'VI' (current sweep two probe setup) or - 'VIfourprobe' (current sweep four probe setup) - - """ - try: - # lazy import to avoid a geneal dependency on qcodes_loop - from qcodes_loop.measure import Measure - except ImportError as e: - raise ImportError( - "The doFastSweep method requires the " - "qcodes_loop package to be installed." - ) from e - # prepare setpoints, units, name - self.fastsweep.prepareSweep(start, stop, steps, mode) - - data = Measure(self.fastsweep).run() - - return data - - def _fast_sweep( - self, - start: float, - stop: float, - steps: int, - mode: Literal["IV", "VI", "VIfourprobe"] = "IV", - ) -> npt.NDArray: - """ - Perform a fast sweep using a deployed Lua script. - This is the engine that forms the script, uploads it, - runs it, collects the data, and casts the data correctly. - - Args: - start: starting voltage - stop: end voltage - steps: number of steps - mode: Type of sweep, either 'IV' (voltage sweep), - 'VI' (current sweep two probe setup) or - 'VIfourprobe' (current sweep four probe setup) - - """ - - channel = self.channel - - # an extra visa query, a necessary precaution - # to avoid timing out when waiting for long - # measurements - nplc = self.nplc() - - dV = (stop - start) / (steps - 1) - - if mode == "IV": - meas = "i" - sour = "v" - func = "1" - sense_mode = "0" - elif mode == "VI": - meas = "v" - sour = "i" - func = "0" - sense_mode = "0" - elif mode == "VIfourprobe": - meas = "v" - sour = "i" - func = "0" - sense_mode = "1" - else: - raise ValueError(f"Invalid mode {mode}") - - script = [ - f"{channel}.measure.nplc = {nplc:.12f}", - f"{channel}.source.output = 1", - f"startX = {start:.12f}", - f"dX = {dV:.12f}", - f"{channel}.sense = {sense_mode}", - f"{channel}.source.output = 1", - f"{channel}.source.func = {func}", - f"{channel}.measure.count = 1", - f"{channel}.nvbuffer1.clear()", - f"{channel}.nvbuffer1.appendmode = 1", - f"for index = 1, {steps} do", - " target = startX + (index-1)*dX", - f" {channel}.source.level{sour} = target", - f" {channel}.measure.{meas}({channel}.nvbuffer1)", - "end", - "format.data = format.REAL32", - "format.byteorder = format.LITTLEENDIAN", - f"printbuffer(1, {steps}, {channel}.nvbuffer1.readings)", - ] - - return self._execute_lua(script, steps) - def _execute_lua(self, _script: list[str], steps: int) -> npt.NDArray: """ This is the function that sends the Lua script to be executed and From 23866bbdfa232b82cef35926c337ebcc79b6443c Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 6 Feb 2026 13:41:51 -0800 Subject: [PATCH 02/22] Remove "shape" from LuaSweepParameter init --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index fd31039284a9..4f5da6f4bda2 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -41,7 +41,6 @@ class LuaSweepParameter(ParameterWithSetpoints): def __init__(self, name: str, instrument: Instrument, **kwargs: Any) -> None: super().__init__( name=name, - shape=(1,), docstring="Holds a sweep", instrument=instrument, **kwargs, From be02471c33816fd9a060e4c6b4194b3b9269671a Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 6 Feb 2026 13:42:54 -0800 Subject: [PATCH 03/22] Remove unnecessary init block in LuaSweepParameter --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 4f5da6f4bda2..317db68c79cf 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -38,14 +38,6 @@ class LuaSweepParameter(ParameterWithSetpoints): deployed Lua script sweep. """ - def __init__(self, name: str, instrument: Instrument, **kwargs: Any) -> None: - super().__init__( - name=name, - docstring="Holds a sweep", - instrument=instrument, - **kwargs, - ) - def _set_mode(self, mode: str) -> None: if mode == "IV": self.unit = "A" From 8c5ada5ac1e07b2b0b980f560a37bd0eb2237cfe Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 6 Feb 2026 15:38:36 -0800 Subject: [PATCH 04/22] Rename parameter for clarity --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 317db68c79cf..2bac230fea30 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -629,9 +629,9 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Stopping value of fastsweep. Can be current or voltage.""" - self.fastsweep_axis: FastSweepSetpoints = self.add_parameter( - name="fastsweep_axis", - label="Fastsweep", + self.fastsweep_setpoints: FastSweepSetpoints = self.add_parameter( + name="fastsweep_setpoints", + label="Fastsweep setpoints", snapshot_value=False, vals=vals.Arrays(shape=(self.fastsweep_npts,)), parameter_class=FastSweepSetpoints, @@ -642,7 +642,7 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: self.fastsweep: LuaSweepParameter = self.add_parameter( "fastsweep", vals=vals.Arrays(shape=(self.fastsweep_npts,)), - setpoints=(self.fastsweep_axis,), + setpoints=(self.fastsweep_setpoints,), parameter_class=LuaSweepParameter, ) """Performs buffered readout of desired sweep mode.""" From 893c7bd48bbafe4095e735a45f3051dbaa049a19 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 6 Feb 2026 15:41:09 -0800 Subject: [PATCH 05/22] Add tests for new fastsweep parameters. --- tests/drivers/test_keithley_26xx.py | 60 +++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/tests/drivers/test_keithley_26xx.py b/tests/drivers/test_keithley_26xx.py index 5d935728af8a..18bd8bbd4ca0 100644 --- a/tests/drivers/test_keithley_26xx.py +++ b/tests/drivers/test_keithley_26xx.py @@ -1,9 +1,12 @@ from collections import Counter +from typing import cast +from unittest.mock import patch import numpy as np import pytest from qcodes.instrument_drivers.Keithley import ( + Keithley2600Channel, Keithley2600MeasurementStatus, Keithley2614B, ) @@ -176,3 +179,60 @@ def test_setting_measure_current_range_disables_autorange(smus) -> None: some_valid_measurerange_i = smu.root_instrument._iranges[smu.model][2] smu.measurerange_i(some_valid_measurerange_i) assert smu.measure_autorange_i_enabled() is False + + +def test_fast_sweep_parameters(smus) -> None: + for smu in smus: + smu = cast("Keithley2600Channel", smu) + + start_val = 0.0001 + stop_val = 0.001 + npts = 50 + + # Test IV mode + smu.fastsweep_mode("IV") + assert smu.fastsweep.unit == "A" + assert smu.fastsweep.label == "current" + + # Test VI mode + smu.fastsweep_mode("VI") + assert smu.fastsweep.unit == "V" + assert smu.fastsweep.label == "voltage" + + # Test VIfourprobe mode + smu.fastsweep_mode("VIfourprobe") + assert smu.fastsweep.unit == "V" + assert smu.fastsweep.label == "voltage" + + smu.fastsweep_start(start_val) + assert smu.fastsweep_start() == start_val + + smu.fastsweep_stop(stop_val) + assert smu.fastsweep_stop() == stop_val + + smu.fastsweep_npts(npts) + assert smu.fastsweep_npts() == npts + + # Test the setpoints (fastsweep_setpoints) + setpoints = smu.fastsweep_setpoints() + expected_setpoints = np.linspace(start_val, stop_val, npts) + np.testing.assert_array_almost_equal(setpoints, expected_setpoints) + + +def test_fastsweep(driver) -> None: + smu = driver.smua + + # Configure the fastsweep + smu.fastsweep_mode("IV") + smu.fastsweep_start(0.0) + smu.fastsweep_stop(1.0) + smu.fastsweep_npts(10) + + # Mock _execute_lua to return fake measurement data + fake_data = np.linspace(0, 0.001, 10) # Fake current readings + + with patch.object(smu, "_execute_lua", return_value=fake_data): + result = smu.fastsweep() + + assert len(result) == 10 + np.testing.assert_array_equal(result, fake_data) From 9939e2abbbc3febc33d1371e3364977f280b15f7 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Mon, 9 Feb 2026 13:30:00 -0800 Subject: [PATCH 06/22] Apply suggested changes from PR review --- .../Keithley/_Keithley_2600.py | 102 +++++++++--------- 1 file changed, 52 insertions(+), 50 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 2bac230fea30..d8e15591d4e8 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -4,7 +4,7 @@ import struct import warnings from enum import StrEnum -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING, Any, Literal, Self import numpy as np import numpy.typing as npt @@ -32,33 +32,32 @@ log = logging.getLogger(__name__) -class LuaSweepParameter(ParameterWithSetpoints): +class LuaSweepParameter(ParameterWithSetpoints[npt.NDArray, "Keithley2600Channel"]): """ Parameter class to hold the data from a deployed Lua script sweep. """ - def _set_mode(self, mode: str) -> None: - if mode == "IV": - self.unit = "A" - self.setpoint_names = ("Voltage",) - self.setpoint_units = ("V",) - self.label = "current" - self._short_name = "iv_sweep" - - if mode == "VI": - self.unit = "V" - self.setpoint_names = ("Current",) - self.setpoint_units = ("A",) - self.label = "voltage" - self._short_name = "vi_sweep" - - if mode == "VIfourprobe": - self.unit = "V" - self.setpoint_names = ("Current",) - self.setpoint_units = ("A",) - self.label = "voltage" - self._short_name = "vi_sweep_four_probe" + def _set_mode(self, mode: Literal["IV", "VI", "VIfourprobe"]) -> None: + match mode: + case "IV": + self.unit = "A" + self.setpoint_names = ("Voltage",) + self.setpoint_units = ("V",) + self.label = "current" + self._short_name = "iv_sweep" + case "VI": + self.unit = "V" + self.setpoint_names = ("Current",) + self.setpoint_units = ("A",) + self.label = "voltage" + self._short_name = "vi_sweep" + case "VIfourprobe": + self.unit = "V" + self.setpoint_names = ("Current",) + self.setpoint_units = ("A",) + self.label = "voltage" + self._short_name = "vi_sweep_four_probe" def _fast_sweep(self) -> npt.NDArray: if self.instrument is None: @@ -78,23 +77,24 @@ def _fast_sweep(self) -> npt.NDArray: dV = (stop - start) / (steps - 1) - if mode == "IV": - meas = "i" - source = "v" - func = "1" - sense_mode = "0" - elif mode == "VI": - meas = "v" - source = "i" - func = "0" - sense_mode = "0" - elif mode == "VIfourprobe": - meas = "v" - source = "i" - func = "0" - sense_mode = "1" - else: - raise ValueError(f"Invalid fastsweep mode {mode}") + match mode: + case "IV": + meas = "i" + source = "v" + func = "1" + sense_mode = "0" + case "VI": + meas = "v" + source = "i" + func = "0" + sense_mode = "0" + case "VIfourprobe": + meas = "v" + source = "i" + func = "0" + sense_mode = "1" + case _: + raise ValueError(f"Invalid fastsweep mode {mode}") script = [ f"{channel}.measure.nplc = {nplc:.12f}", @@ -125,7 +125,7 @@ def get_raw(self) -> npt.NDArray: return data -class FastSweepSetpoints(Parameter): +class FastSweepSetpoints(Parameter[npt.NDArray, "Keithley2600Channel"]): """ A simple :class:`.Parameter` that holds all the setpoints (relative to the measurement start) at which the points of the time trace were acquired. @@ -610,7 +610,7 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Current limit e.g. the maximum current allowed in voltage mode. If exceeded the voltage will be clipped.""" - self.fastsweep_npts: Parameter = self.add_parameter( + self.fastsweep_npts: Parameter[int, Self] = self.add_parameter( "fastsweep_npts", initial_value=20, label="Number of fastweep points", @@ -619,12 +619,12 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Parameter fastweep_npts""" - self.fastsweep_start: Parameter = self.add_parameter( + self.fastsweep_start: Parameter[float, Self] = self.add_parameter( "fastsweep_start", label="fastsweep start", get_cmd=None, set_cmd=None ) """Starting value of fastsweep. Can be current or voltage.""" - self.fastsweep_stop: Parameter = self.add_parameter( + self.fastsweep_stop: Parameter[float, Self] = self.add_parameter( "fastsweep_stop", label="fastsweep stop", get_cmd=None, set_cmd=None ) """Stopping value of fastsweep. Can be current or voltage.""" @@ -647,12 +647,14 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Performs buffered readout of desired sweep mode.""" - self.fastsweep_mode: Parameter = self.add_parameter( - "fastsweep_mode", - initial_value="IV", - get_cmd=None, - set_cmd=self.fastsweep._set_mode, - vals=vals.Enum("IV", "VI", "VIfourprobe"), + self.fastsweep_mode: Parameter[Literal["IV", "VI", "VIfourprobe"], Self] = ( + self.add_parameter( + "fastsweep_mode", + initial_value="IV", + get_cmd=None, + set_cmd=self.fastsweep._set_mode, + vals=vals.Enum("IV", "VI", "VIfourprobe"), + ) ) """Parameter fastsweep_mode""" From 22eb5079b20844c1ee6ac7e6a9e23b4025588233 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Mon, 9 Feb 2026 13:47:34 -0800 Subject: [PATCH 07/22] Add newsfragment for Keithley2600 driver updates --- docs/changes/newsfragments/7851.improved_driver | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 docs/changes/newsfragments/7851.improved_driver diff --git a/docs/changes/newsfragments/7851.improved_driver b/docs/changes/newsfragments/7851.improved_driver new file mode 100644 index 000000000000..95344e832f54 --- /dev/null +++ b/docs/changes/newsfragments/7851.improved_driver @@ -0,0 +1,2 @@ +Refactored ``Keithley2600`` driver to use `ParameterWithSetpoints` instead +of relying on deprecated `qcodes_loop` code. From 4fdb97b605c776ec4cde91d73d35985b39aa1b8f Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Wed, 11 Feb 2026 15:54:47 -0800 Subject: [PATCH 08/22] Add note on breaking change --- docs/changes/newsfragments/7851.improved_driver | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/changes/newsfragments/7851.improved_driver b/docs/changes/newsfragments/7851.improved_driver index 95344e832f54..cc932deb1988 100644 --- a/docs/changes/newsfragments/7851.improved_driver +++ b/docs/changes/newsfragments/7851.improved_driver @@ -1,2 +1,3 @@ Refactored ``Keithley2600`` driver to use `ParameterWithSetpoints` instead -of relying on deprecated `qcodes_loop` code. +of relying on deprecated `qcodes_loop` code. Contains breaking change since +method `doFastSweep` has been replaced with `fastweep`. From cba622b9600d80e14939675ca39c9d4f85cc6a23 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Wed, 11 Feb 2026 16:18:09 -0800 Subject: [PATCH 09/22] Update Keithley2600 example notebook with usage on new fastweep parameter --- .../Qcodes example with Keithley 2600.ipynb | 162 +++--------------- 1 file changed, 26 insertions(+), 136 deletions(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index 7c7673da651d..89af5ec33e84 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -15,7 +15,7 @@ "outputs": [], "source": [ "import qcodes as qc\n", - "from qcodes.dataset import do0d, initialise_database, new_experiment, plot_dataset\n", + "from qcodes.dataset import initialise_database, new_experiment, plot_dataset\n", "from qcodes.instrument_drivers.Keithley import Keithley2614B" ] }, @@ -188,7 +188,7 @@ "source": [ "## Fast IV or VI curves\n", "\n", - "Onboard the Keithley 2600 sits a small computer that can interpret `Lua` scripts. This can be used to make fast IV- or VI-curves and is supported by the QCoDeS driver. To make IV- or VI-curves the driver has the ArrayParameter fastsweep, which have 3 modes: 'IV','VI' and 'VIfourprobe'. The Modes 'IV' and 'VI'are two probe measurements, while the mode 'VIfourprobe' makes a four probe measuremnt." + "Onboard the Keithley 2600 sits a small computer that can interpret `Lua` scripts. This can be used to make fast IV- or VI-curves and is supported by the QCoDeS driver. To make IV- or VI-curves the driver has the ParameterWithSetpoints fastsweep, which has 3 modes: 'IV', 'VI' and 'VIfourprobe'. The Modes 'IV' and 'VI'are two probe measurements, while the mode 'VIfourprobe' makes a four probe measurement." ] }, { @@ -203,164 +203,43 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First we need to prepare the sweep by spesifyring the start, stop, number of points and the mode " + "First we need to prepare the sweep by specifying the start, stop, number of points and the mode " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "keith.smua.fastsweep.prepareSweep(1, 2, 500, mode=\"IV\")" + "keith.smua.fastsweep_start(1)\n", + "keith.smua.fastsweep_stop(2)\n", + "keith.smua.fastsweep_npts(500)\n", + "keith.smua.fastsweep_mode(\"IV\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "When the sweep parameters are set, we can use a \"do0d\" to preform the sweep " + "Next we want to register our parameter" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting experimental run with id: 154. \n" - ] - }, - { - "data": { - "text/plain": [ - "(results #154@C:\\Users\\Farzad\\experiments.db\n", - " -------------------------------------------\n", - " keithley_smua_Voltage - array\n", - " keithley_smua_iv_sweep - array,\n", - " [],\n", - " [None])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEXCAYAAACgUUN5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABu6klEQVR4nO2dd5xdRfn/P885927f9E0CaQsJkEILhN6b9I6KIk0RUbGCChZEEUXF9hP5AiJgQVSKKIJU6S0FCAmhBRLSSU92k233nvn9MWfOmTNnTrm7t2z2zvv12tfee0+b0+aZpw4xxmAwGAyG6sWqdAMMBoPBUFmMIDAYDIYqxwgCg8FgqHKMIDAYDIYqxwgCg8FgqHKMIDAYDIYqxwgCwzYBEY0nonYisivdlv6Cez12TLFeKxExIsqUo11pIKK7iOi0SrejFBDRBUT0XMp1f0FEny91m5IwgkADES0mog73RVtFRHcQUVMZjruciOqJ6Egiuk9Zdg0RzSOiHBFdrSw7nIgct73i73zN/nciok4i+ksBbXrK3Ube9wO9PslewhhbwhhrYozly31stxOdFLM89Yufdp9pcK/H+33ZRyUgot0B7AHgX5VuSz/gegDfJqKaSjbCCIJoTmaMNQHYE8B0AFeW8mBENA7AOsZYB4C9AbyirLIQwDcBPBixixVuxyD+/qhZ53cAZvWieZcq+z65F/voNf1pJNsfGADX43MA7mQmmxWMsZUA3gJwSiXbYQRBAoyxVQAeARcIYvS9TF7H1SCOdj9fTUT/IKI/EVEbEb1BRDNSHGoGgDnS54AgYIz9kTH2XwBtvTkPIjobwEYAT/Rm+4h9fouIXhYdExF93j3fOskccTERrSCilUR0ubStRURXENF7RLTOvWbD3GVi288Q0RIA/1PNG66m8iMiekFoKUQ0nIjuJKLNRDSLiFql400moseIaD0RvU1EH5OW3UFEvyOiB9179jIRTXSXPeOuNtc9zseVazAFwE0ADnCXb5Tad5G0nqc1RO2TiD5LRAvdNv6biLaXtmdE9EUiehfAu9Jvk9zPJxLRq+65L1W1xpT3czAR/cG9V8vd62sTUQ0RvUZEX3LXs4noeSK6yv1+NRHdQ0R/d6/fK0S0R8yhjgfwtHptiOh6ItpARIuI6Hhp+fbu9VjvXp/PxpzDCUS0wG3HcvHMEdFQIvoPEa1xj/EfIhorbVfo88SI6MtE9D4RrSWinxORtj+Ne/ZcngJwYsz1Kj2MMfOn/AFYDOBo9/NYAPMA/Mb9fjiAZTHrXw2gE8AJAGwAPwHwUsyxvg/eQXcC2Op+zgPY5H62lfX/AuBq5bfDAXQD+BDAIgC/AtAoLR8E4B33XK4G8JcCrsVTAC6KWGYBeMbd504ANgCY7i5rBcAA3AWgEcBuANZI1+krAF5y21QL4GYAdynb/sndtl76LSO1ayGAiQAGA1jgnuPRADLutre76zYCWArgQnfZdABrAUx1l98BYB2Afd3ldwL4m3SeDMCkmGt0AYDn4q6buo66TwBHum3ay70evwXwjLL+YwCGAahX9+E+A7u592R391k4TbmemYR7/U/3PjQCGAlgJoDPuct2de/vFADfce+dLT3zPQDOApAFcDn4c5jVHKPRbUuLcm16AHwW/J35PIAVAMhd/gyAGwHUgQ/I1gA4MuIcVgI4xP08FMBe7ufhAM4E0ACgGcDdAO5X7leq50m69k+692O8u+5F6r1GwrPnrnMGgFcq2udV8uD99Q+8Y28HH30z8FH0EHfZ4UgWBI9Ly6YC6Eg4XgbAmwBGATgQwIMx6+oEwWj3OBaAHdwX52Zp+W8AfEtqX6GCQAgo8XeNtLwVwHq3/VcqvzMAk6XffgbgD+7nNwEcJS3bDrwzyEjb7qjZnywIviMt/wWA/0rfTwbwmvv54wCeVc7rZgDfdz/fAeBWadkJAN6SvpdDEPwBwM+k703u9WiV1j9SOUZkuwD8GsCvdNcuYv1RALrgChn3t08AeFL6fhmAt8EFwk7S71dDGuyAP4deh6wcZ4zbljrl2iyUvje464wGMA58YNQsLf8JgDsizmMJuOlpUMJzvSeADcr9SvU8Sdf+OOn7FwA8od7rpGfP/X4MgPfTvpOl+DOmoWhOY4w1g3f8kwGMKGDbVdLnrQDqSGPXJaI9XVPCBgCTwF+yJwEcTkQbieiMNAdjjK1ijC1gjDmMsUXgvoQzxTHARzW/KqD9Kl9mjA2R/r4nHXux2+ZWcB+EylLp8wcAhLljAoB/uue5EVww5ME7JN22Oj6UPndovgsH/wQA+4ljucc7B7yjEaj3rOTBAQrbg18fAABjrB1cSxkjrRN5PYhoPyJ60jV9bAJwCQp7ZieAj+ZXStfoZnDNQPBHd72HGGPvKtt7bWOMOQCWwb/XMhvd/83K7971Z4xtdT82uftYzxiTTaIfIHhdZM4EF+QfENHTRHQAABBRAxHdTEQfENFm8MHSEApGoaV9ngRRz7ZMmmevGf51qQhGECTAGHsafMR4vfvTFvARCwBuLwXQ0st9v8YYGwLgWgBXuZ8XANjD7XDvi9s+btfw7+3h4J30EiJaBa62n0lEqjO6VxDRiQAOANeafq5ZZZz0eTy4yg/wl+h4RcDUMcaWK+dRDJYCeFo5VhNjrFhhe7p2Bp4TBF98HSvAOw0AABE1gpsz0l6PvwL4N4BxjLHB4H4LSjimzFJwjWCEdI0GMcamSevcCOA/AI4looOV7b377NrKx8K/1/4JMLYFwHsAdk7ZrhUAhhGRLDjGI3hd5P3PYoydCi7A7gfwD3fRZQB2AbAfY2wQgENFc1O2Q0fUsy2T5tmbAmBuH9rRZ4wgSMevARzjOsDeAR/hn0hEWQDfBbfp9oW9AbxCPIRse8bYQnUFIsoSUR34PcsQd8ja7rIjiGgCccYBuA5+aN4t4HbPPd2/m8Ajj451txVO2NZCG01EIwDcCuAiAOcDOJmITlBW+547GpsGbif9u/v7TQCuJaIJ7r5aiOjUQtuQkv8A2JmIznWvY5aI9iHu6E3DhwDi4vU/BDCWgiGArwE4wz33SQA+k7DPuwBc6GqJtQB+DOBlV+NKQzP4yLmTiPYF8MmU2wHwolceBfALIhpE3Jk/kYgOAwAiOhf8Ob0AwJcB/JGCIdV7E9EZrub7VXCh8lLE4R4CcFjKdi0F8AKAn7jP/O7g1zIUAk3cqX0OEQ1mjPUA2AzAcRc3g4/qNxIPSvh+muMn8A3XCT0O3Of1d806aZ69wwD8twjt6TVGEKSAMbYG3Fl0FWNsE7g98FbwUckWcDW4L4hw0d0AzI9Y5/fgD/InwJ11HQDOdZdNB39Ztrj/54G/rGCMbXVNR6sYj4BqB9DpnhPARzUfIGKE5XIDBfMIRHTTLQD+xRh7iDG2DvwFvZWIhkvbPg3uhHsCwPWMsUfd338DPoJ9lIjawDuN/WLa0Gtcs8JHAJwNPmpbBeCnSC/Arwbv+DZqIj4A4H8A3gCwiojWur/9Cr4D/4/gDujIfTLGHgfwPQD3gtvXJ7rtTcsXAPzQvZZXwR8JF8J5AGrAtdINAO4BsB0RjQcfDJ3HGGtnjP0VwGwEzY3/AreHbwB/Ls9wO2MdtwA4h4jSjsY/Aa7VrgB3aH/fvV46zgWw2DX/XAJuhoHb/npwR+1LAB5Oeew4/gUe6fca+ODqD+oKSc8eEW0H7t+7vwjt6TXCK2+oUojouwDWMMZuLvJ+W+FHjuSKuW9D/4J4qOokxtinCtjmrwD+wRi7v1TtKiVExMAd5iHtvcD9/ALAe4yxG4vTst6xrSemGPoIY+xHlW6DofpgjBVkuhqoMMYuq3QbACMIDIaqgojaIxYdzxh7tqyNMfQbjGnIYDAYqhzjLDYYDIYqZ5szDY0YMYK1trZWuhkGg8GwTTFnzpy1jDFtztM2JwhaW1sxe/bsSjfDYDAYtimI6IOoZcY0ZDAYDFWOEQQGg8FQ5RhBYDAYDFWOEQQGg8FQ5RhBYDAYDFWOEQQGg8FQ5RhBYDAYDFVO1QmCjVu7MeeD9ZVuhsFgMPQbqk4Q3PnyEnzilpfhOKbGksFgMABVKAjau3LozjvoyjnJKxsMBkMVUHWCIJfnAqCjJ1/hlhgMBkP/oOoEQU+em4SMIDAYDAbONld0rresbuvEGys2Y3Mnn0a1o9sIAoPBYACqSCOYtWgDLrx9Fhav3QIA6DQagcFgMACoIkHQVMeVn41bXY3ACAKDwWAAUE2CoJYLgg1buwEY05DBYDAIqkYQNNcJQWA0AoPBYJCpGkEgNAKB8REYDAYDp3oEQZ0RBAaDwaCjagRBY01QEBgfgcFgMHCqRhDYFqGxxva+d/SYEhMGg8EAVJEgAILmIeMsNhgMBk51CQLJYWx8BAaDwcCpLkFQl/U+d3Tn4TjM+AoMBkPVU12CoFb2EeTx00fewpSrHjbCwGAwVDVVJQjqs0HT0D2zlwHgcxQYDAZDtVJdgkCKGpJ9BESVaI3BYDD0D6pLEGT90+3oyUNMVsnMrJUGg6GKKZkgIKJxRPQkES0gojeI6CuadQ4nok1E9Jr7d1Wp2gMADVJSWUd3HsyVAI6RBAaDoYop5cQ0OQCXMcZeIaJmAHOI6DHG2AJlvWcZYyeVsB0edVl9QlnOTGRvMBiqmJJpBIyxlYyxV9zPbQDeBDCmVMdLQ31W7yPI540gMBgM1UtZfARE1ApgOoCXNYsPIKK5RPRfIppWynbU10g+gm7fR5BzTLkJg8FQvZR8zmIiagJwL4CvMsY2K4tfATCBMdZORCcAuB/ATpp9XAzgYgAYP358r9tSnw3mEQjyxjRkMBiqmJJqBESUBRcCdzLG7lOXM8Y2M8ba3c8PAcgS0QjNercwxmYwxma0tLT0uj11UYLAOIsNBkMVU8qoIQLwBwBvMsZ+GbHOaHc9ENG+bnvWlapNtZIg6M45cFxNIGd8BAaDoYoppWnoIADnAphHRK+5v30bwHgAYIzdBOAsAJ8nohyADgBnM1a64XnWCmaOdea4VmBMQwaDoZopmSBgjD0HIDZnlzF2A4AbStUGlYwdVIB6XE3AhI8aDIZqpqoyizO2Xi4ZjcBgMFQzVSUIspb+dI0gMBgM1Ux1CQKjERgMBkOIqhIEe08Yik/uNx4/Om3XwO8mocxgMFQzVSUIMraFH5++Gya2NAV+NxqBwWCoZqpKEAhqMsHTNlFDBoOhmqlOQaCEkTpGEBgMhiqmKgVBNhN0GhuNwGAwVDPVKQgUjcD4CAwGQzVTlYJANQ0ZjcBgMFQzVSkIwhqBCR81GAzVS5UKgqCPIG/kgMFgqGKqUxBk4jWCzp48Hpi7AgDwwntrsXT91rK1zWAwGMpNyWco648k+Qh++J8F+OvLSzB6cB0++Xs+u+bi604sW/sMBoOhnFSnRpAQNSQ0gC1dubK1yWAwGCpFVQoC2yLIc9SoGoGYGse2YqdTMBgMhgFBVQoCIKgVqBqB+G6REQQGg2HgU7WCQPYTzFq8HvIMmWIyeyMIDAZDNVC9gkCKHHrq7TW475Xl3nchFBhMopnBYBj4VK0gUKetXLmpw/ssLEW5vBEEBoNh4FO1gsBWzD4NNX4krcPEpPYm08xgMAx8qlYQkCIIGmtt77MoS91jNAKDwVAFVK0gUOexb6z1NQLhLDamIYPBUA1UrSBQrT6yqUgsM6Yhg8FQDVStIFi3pSvwXU4lED4CYxoyGAzVQNUKgs6e4Gg/L+cROMI0ZDQCg8Ew8KlaQaAiz1ssNIJuIwgMBkMVUHFBQETjiOhJIlpARG8Q0Vcq0Y58QBDw/905IwgMBsPAp+KCAEAOwGWMsakA9gfwRSKaWu5GOCxZI5i1eD1ar3gQc5duLGfTDAaDoaRUfD4CxthKACvdz21E9CaAMQAWlPK4z37zCLR35bBiYwc+88fZAUEgtANVI3h4/ioAwMxF67HHuCGlbJ7BYDCUjYoLAhkiagUwHcDLpT7WuGENAIChDTUAgtNVOhGCQMxP0CAlnxkMBsO2Tn8wDQEAiKgJwL0AvsoY26wsu5iIZhPR7DVr1hT1uCKxTI4aykUJgu48AKCxpl/JT4PBYOgT/UIQEFEWXAjcyRi7T13OGLuFMTaDMTajpaWlqMcWpablMtTCN6D6CDyNoMZoBAaDYeBQ8aEt8aI/fwDwJmPsl+U+vsgozjsMq9s6ceT1T6Pd7fBljeAzd8zyBIGZucxgMAwk+oNGcBCAcwEcSUSvuX8nlOvgluULglmLNnhCAAgKgifeWo2trmlIndHMYDAYtmUqrhEwxp4DULEhthjdMwbUZYNysSvCNGTkgMFgGEj0B42goggrT56xgDYAhJ3F7Z4gMJLAYDAMHIwgkHwEbZ2+IMjahB5FIzCmIYPBMBCpekEgTEOOIgi2G1yvCR+N1gieens1zr7lRZx+4/P43ZMLAQB/n7UE1z/ydqmabjD0a558azUuv3tupZthSIERBK5G4DCgrbMHAPDdE6egJmOFBIHo/3WC4ILbZ+Gl99fj1SUbceuz7wMAvnXvPNzgCgWDodq48I5ZuGfOsko3w5CCqhcEJPkINnf2YGhDFhcdsiMyFkVWH00qStpgEs4MBsM2hBEERLDINw0112UBAFk7rBEIHI2PoDbjX8pGU4LCYDBsQyQOXYloJHis//YAOgDMBzCbMTZgajTbFsFhXBAMqueXJGMTtnRHaAQa01BTbQZduW6+rTohssFgMPRjInssIjqCiB4B8CCA4wFsB2AqgO8CmEdEPyCiQeVpZmkhItz41Ht4belGNNe6GoEVoxEwhq5cHj/6zwJsdv0KTXWZwHKZzh6+rhyeettzizBv2aZin4rB0O9gJty63xOnEZwA4LOMsSXqAiLKADgJwDHgNYK2acSDahFw7LRRAIBshtAVYxr6x6yluPW5RbAswrdPmBIoRKc+93+buQS3PrcI2YyFbx03GQDww//wKtuLrzux2KdjMPQrGPN9cYb+SaQgYIx9I2a74Yyx+4vfnMogTP4XHbIjLjhoBwBAjW2hsyevXT/vMK8SqchDaKqN1giiqpkaDNWAwxisyhUPMKQgtTGbiIYQ0WeI6AkAr5awTWVHJIhlpGJytRkbXT1RpiG/3ESjW4lUdhCrgoDIL2NhMFQbJv+y/xPrLCaiegCnAvgk+IQxzQBOA/BMyVtWAbK2LxdrMlZk+KjDmJdl3OBqAo210aYhkrbjy82bYageTEmW/k+cs/ivAN4B9wP8FkArgA2MsacGUsSQTMb2NYKaTLSylHcYtrpZxk+9vRrLNmxFbSZOIwhvb+gd3TkHf35xsbmG2xBGDoRhjOEvL33g9SOVJs40NBXABgBvgs8VkAcwoG9pVgr7rI0TBJJG8Oy7a3Ha714Aky6NepGEHBCagC781JCOW555D9/71xv4x+yllW6KISVsYHcbveLd1e347v3z8fTbxZ1xsbdE9naMsT0BfAzcHPQ4ET0HoJmIRpWpbWUnSiM4ffqYwHqMAR3dviN5bXsXGAPGD2vAGdPHhDQCMeeB+NUZkPpUedi4lYfrbu7oqXBLDGkxylsY4X/s6ScXJ9ZZzBh7izH2fcbYZABfAfAnALOI6IWytK7MZBQfgffZDl4mHjUUVOkcxmARdwyrHb3qI8gZSdBrVKFq6P8YH0EY4X/sL/7C1EVxGGNzAMwhossBHFK6JlWOrBw1JHX+tdmwINjaHQwtdRgPJbUo+uZ6ReuMHOg1Jghx22NgehT7hihx31+EZJoSE7cjOACzARwBYHypGlUpMoHO33f+qv4CxnSCgIGIC4O1W7rxt5lSHh4FR7HGR9B3+noJV7d1YvXmLuw6ZnBxGlRkcnkHL7y3Dofu3FLppvSZ/tLZqTgOwzPvrsFhO7d4Id6l5sPNnVjb3uUJgqQCluUiTR7Bf8DLTDwI4FHwekN/LWWjKkXARxBhJgJ4R96hCALGGNcILB7ZcsV987xlvrOY/zemoT7gXsy+OiBveup9fPZPs4vQoNLwq8ffwXm3zcTMResr3ZQ+018FwZ9eXIwLbp+FB+etLNsxD/npkzjx/z237WkEjDG1hMTfiGhWidpTUeSoIbnzl0NDAS7F1dnLHIdrA7qRhbjVwmRk5EDvIRQnOa+tswcdEZnj/YE3V7YBGBhO8X7iDw2xeN1WAMDqzV1lO6bwDXTn+ldOUcFlMoloMoB3S9CWimMHMoujQ0kdxsKCwDUN6RTMnOcY4t+Naaj3FEuD78k7/Tq+XWic9TXbfknz/tLZqYhcFPm9Lxe+RlD2Q2tJ4yNogz+otQA0AOgQvzPGBkQFUoDPUyyoiRMEDkNPPngHfWdx+KESN12YM/L5fnL3t0HUnIze0p13+o1arkNoK3H5LNsK/fUqiwGZVUFB0F8SI9OYhprL0ZD+QGT4qGoaYkwzjSWDZfEKpipCaBiNoO8USyPozvVvjUAUPOwn/USf6K8CVwzI7AqURu3pZ+GjcSUmWuM2JM7YoreogqhF5wSqsziXZ6E6RI7rLNb5CJ55Z427Dv/eX0YBaZi/fBNWbOyodDNC9PX96c4zr4Na296FOR9sKEKriofQCHIVCCt5a9VmLF2/tWj7K9fj/sLCtQWVbBADskwFNIJuVwh15Rw89fbqsh9fJU7v/DkR3UtE5xHRNCIaSUTjiehIIroGwPMAppSpnWVBLTonqM8GNQI1mQzgDztFmIZediM/PNPQNiQITvrtczjwuv9VuhkenrO4j/vpzuU9YXL+bTNx5v+90K/ui9AIchVo03G/fhaH/OzJou1PN7VrsVm+sQOfvPVlfOPu11NvI9pVEdOQa1H42SNv44LbZ1U8OixuPoKPEtFUAOcA+DT4DGVbwWsPPQTgWsZYZ1laWSaiwkfF9JWCrV3haBORWZzmmepPHc62hpCzfdYIcr6P4P01WwDw3ILtBtf3bcdFQjiLB8KzUg7rR4c7OHtr1ebU2wiNwK6AG6bHix7i/zdVODos1kfAGFsA4DtlakvFiQofVUtM6DQCJpzFcZJAZBb3E7vgtojnLO6jTtCTZ14HNXpwHRat3YIVGzv6jSDodGvRVEIjKDbled4LDyv2o4bKLwnUqEN5EFoJSnYFiOg2IlpNRPMjlh9ORJuI6DX376pStSUt8s2QozVUu/+WLp1pSNQait6/eKkHwstdMYo0yY+sEYwaVAsAWLah//hCur2okvL6CEoxi145BIEYfxVyJE8QVMRZHGypOtgsN6U8+h0AjktY51nG2J7u3w9L2JZURAkCdZCvlpcARB4BeTZsHW+u3Iz5yzeF1P2VmzqwfGMHVreVxtL23pr2XpkY5IiGDzeXzgr44eZObO5Mpxrrru7S9VsjpxWNojvvIOcwvLemHaMH1QEAVmws/jk67jF6i9phFIut3Tks1wQBtKW8D4VQjnGPGKxFCZ117V1Yv6U78FtcHsGWrlxJgyRUjUDnW1y4uq1kx1cpmSBgjD0DYJvKj48yDckagUVAu1YjQKKP4N3V7Tjpt89hXXswk/GAn/wPB133P+x77RN9aL2eNW1d+MivnsEjb6wqeFu5E9rvx8Vvm7zvI37+VEHb+CW9GQ752ZO49K+vFLS9GPke9YunvQzTUgi73z25EEf94mm8vap3L3WpfATn3zYTB2mCANo6SzFRSuklgRAAUYJg7x89jr2ueSzwW5wg+NjNL5Y0SEIVBOp9fnj+Khz9y2fw3zKVv0gUBO4cxYm/9ZIDiGguEf2XiKbFtOFiIppNRLPXrCndRA6yRiDnFMjPSW3G1moEXq2hFGrm5pK8bHrWtHUh77DQaCgNXbnylWBYl7J93uVlQTPbE28VFoInh/++t5qP2EtxvrPdsNQVm3o3uiyVGXHWYn24bCkEQTk0AtGRFuQjcFfWvbFvrEjvdO4NqqbXo5gAX1+2EQD6pE0WQqSzmIjqwLOIRxDRUPjXaxCAMVHbFcArACYwxtqJ6AQA9wPYSbciY+wWALcAwIwZM0r2WGUkjUCOLZY1gpqMFaMRUKqooXJ2sELVV0cgadAlzZWrSmMUavioE/MyxyFfjzb3for6L8Wkr3sst49APC/FLLtQDh9BrwSB2KYUDUqgS3m3copgEIPNumx5SozEaQSfAzAHwGT3v/j7F4Ab+npgxthmxli7+/khAFkiGtHX/fYFWSOQX4SgRmBpHWperaEUHaWICCkHQvvojSBQH1b1eyVQw0d7O2LW3cPeXKO09LZbLZWPIArxvDQWscZROWSZLwjSXy+xTSWi+NTnT00cFD6vctWaipuq8jeMsR0AXM4Y25ExtoP7twdjrM+CgIhGk9trEtG+blvW9XW/fUHWAmR/gaVoBDriag2pxDk21fLWfcXXCAp/2NWHNcqh25N3iqLldHTnE5OP1PDR3tZtKkQQ6O5JT95JFWET1zHlUly3nryT2hEel1XbnXO056deb3GPm2ozYJpy672hLx1tR3c+8hrK90B06oWUbylUeBTrOQeATmU/6pSVIrNcTWYtFYk+AsbYb4noQCL6pJtlfB4RnZe0HRHdBeBFALsQ0TIi+gwRXUJEl7irnAVgPhHNBfD/AJzNKlx4Qx7N27ZsGoI3QUhUETBWQEJZ3Mh6ylUPF5Qmn4Sw+fYmLFBtZ5T9+CO/egZTr3qk8MYpTLnqYfz0kbcK2kbM7VDIg+M4TKtJ6DrKV5dswJSrHsYTb34Y+P3A6/6Had9/OPUxdZri6Te+gF2+G7+PHzywAJO/93BiZ/Xh5k5MveoR3P78Iu3ynb/7Xxzzy6dDv6sdpwiNrqux8YfnFmHKVQ9jdR+d6L19qzd19GDKVQ/j/z2xULt8n2sfx/QfPgrAP49CFMQ05iRZUJ7wm2cT71dauhSrQI/yrhV7QJhEGmfxnwFcD+BgAPu4fzOStmOMfYIxth1jLMsYG8sY+wNj7CbG2E3u8hsYY9NcDWN/xli/mgc54CMA4aZP7YUHv3xwpKomag2lSVfvShjhrdxUvOiVvvgI1NFPlCBYtHZL0aJb7p2zLHa5OIxXwK8Xx1XrRPm/h/clahA9vzCorK5p6+qz2Wbe8k2p1006zw1bubP9zy99ELmOiI6K229OKsT2wOs8YmVZH8Moe6sRrHLfg/+8vkK7fOPWHmxRMrB74yyOu7TygOHd1cVz3KrvljpZlV9rqjxj4zRzFs8AMLXSo/VyIwsCywIaajKYtv3gSNNPLu/mEfRRIwCAlRs7MbGlqaD2RtHWBx+BqkUkxZh355xI01lakhJr1Je3N5VcowSBOioD5BDDgg9TVPKMxb6sok7WqgIHEWonXQp7eW/3KTL4G1LYyXvjI3A8Z3H0NqXyH6h9gDqoEOZANZqoVKR5vOcDGF3qhvQ3gs5i/WeZ7pzDM4tTuAWT7IzFTGTZ3Acfgfqwbu6IN1kVIw6/NsEm6s3yJsJH84VHDek6fEAvLIXASeP7KSVJGoHo1HShzYXsV/6qTrHaW3qrLIqaXg01yeNVpxeO30I1AkExxsThqKH+rxGMALCAiGYC8DKhGGOnlKxV/QA1iUwQFVbXlXNSh48mRQ3pMj57i4gC6U3ET6EawbINHRg3rCFxv44THWGVNBGL5xRU/jP3c5qwx2jTkD4aDOh7hcq+ipFEQdDL/kIdcBbSkToOL+WdSVSX+qYRNNYmawQ56TlIS86bJyR6K10wwtbuPBpr03Sd0ajmYVXgCB9BKSPZZNJoBFcDOA3AjwH8QvqrGgJOZPez2od15Rx3YprCNALdQ7hiYwfunbMMrVc8iCvvm4dpV4UdVL9/5n20XvFgYpRNlGko7zC0XvEgbn32/dA2L72/Dq1XPIh3lRR31Ufw80fewsRvP4RBdRmv3Uls7uzBtO8/gsOvf0q7PMq0dP5tM3HSb58NzemQk2zDE7/9EOYu3ehtM+eDDWi94kEvKefyu+di32sfj3Sca8OCRanihNv691lL0HrFg6EInzT96vtr2tF6xYOYvdgtV67ZqCvn4JhfPo0nIxLnZEGhu6dR5BnDLc+85z1LaUtGd3Tnsf9PnsCk7/wXv378ndh1eyOk5i3bhM/9eQ6AdBqBN7pXDsYYf85lzrttJk7+7XOe0FMv9yk3POd9/rCtE61XPBjIzJ+5aD1ar3gQ81P4eGb86HF88565od/VZy1sGipv0cE0UUNPA1gMIOt+ngWeDDZgeOryw/GPzx0QuVzuA0Q/r05m0Z3LJ/oIfnAKT56WIwZ0HcWGrT347f/4tNB3zVziOcRkrn3oTQDJD0qUs1g8iL94NPwS3+M6bJ95Z612X4LfPfke8g7DKLdWTxpNZl17Nzp68vhA47gEojWCp99Zg/nLN3svr6oRCJZu8PcrnIyi87xnzjKsbuuKHGXpfvdKFScI+Jue5p3vsg3684rb/LmF/Dr/6zXeXt0t3dzRg3dXt+OtiFIV8kj+PbesdhpyjoOfPfy2+5n5zvhAm8MNWrJ+K1a3cQPBwgQnam/mI3jiLT9KK41G4ERoBLqM9WfeWYN5Us0vVQt6fZnfwc9zP//pxcXeb+L9eHRBMJJMx9r2LvxjdjgAIsk05Js++4lGQESfBXAPgJvdn8aAZwEPGFpHNGLfHYZFLpdH+cL0oJogfNNQ9Bt/0KThAIIxxDpVvK2zJzRiiBrFJqnyURpBnBNK7DKcR6D3EYhrkUYjkDNldR1EkrNZbJNnekEgfxVORtVuHmUm0/lRPB9BgkowoqkGAPDh5mAdqULKZYt1dfdUmK2ingP5OhTS8cqPAQPzritjLNacJd/rpGewN4NaUQgQAOqzyRqBrBnKxD2TaSKNxLsqVx0Qfre+mPtUzVHNIxD7LldCYRrT0BcBHARgMwAwxt4FMLKUjepv6ARBVqlh3p13EvMIxMMkawS6qJe2zlzIXh1ln0/SCDa7E16o5RNEhxLXUXXlVUGgb4NwbKXRCOQHO+ewkBkkmzJqSNhuQ4JA+i5MCqogiOpM4xKukkx+I5p4KetiOPp1HVOPe/+iAg3kzrg3DlOACwXfGR+/nbjXg+uziZnDvXGuDqrPep/T1OqPchbHCoKEQnWAb6LJSm0Q71RfAgiSNAK/ZH0/0QgAdDHGPP2KiDKoTHmOiiHfb+EvsJWHM83ENOKBlh8C3TPY1hXWCKJi+JMyayM1ghQqp+rQimqDcGylEQRyx513WGQcexRe/gDTvyjySy2yMjuUBL2oUZY+asg1DSVoBEMbuUZQDEe/rmMSGlwazbCQEbhw3It96Kp46p7R5Rs7kLEIowfVJYbw9kYjUJ+TJKI0grg5JsS7E7d3MXLPWJZXdkPMJtaXQLJQiQnlHD0fWD+KGnqaiL4NoJ6IjgHwBQAPlLZZ/Qv5hov+XzfhdVKtITHaldXCwzXll/Uagd+Z/eox365/w5PvYnVbF35z9vTQfnryjjdaDwmCFAXW4rSSq//9hvdZCII0o2H5gf/ZI29h49aglpEUWuvZdSN8BPJ3kfz3xxc/wNsf+rb1JGfxF+6cg73GD8Uuo5tx41PvAQDmL9+E43/zLD42YyxeeC9cCUV0QMs3dODjN7+Ihavb8emDd4g9F4H6xOj6VdE2MYh4dckGfPuf83Hv5w9AQ00G8q2SO/G8w3Dq73zn58duehHn7D/e+37dw295gjHPmLefvOMXGBR729KVw6m/ex6XHjEJ//fUexgzpB4ZmwJa2F9fXoLH3/wQrcMbte1JS6GCIKoMddwcEyvcnIs4jUUMhh6WnMWeIAD3AZx+4/O4/YJ9MGlkc+R+PnrTC/jiEZO87+q7pb6f4j0R9+aeOcvw0LyVuO2CfSKP0RfSCIJvAbgIwDzwQnQPAbi1JK3pp+hMQxnN9HYWxWcRCOEhawSrNLH3bZ250AMtd8K/eeJd7/Pvn13Ef9MIgnZJeIScxTEagVfHx1Hb4O/vjhcWe59FmF9njwPHYbFakawC3/784tDypDBXz4mmRA15bY94p196358aozuvFzbipXto3io8NG8VJgz3Q2H/O593BD94YIF2WyHA1m3pxsvuROQ/f+RtHDhxuNvu6HNS267VCPJCEOS9fb+5cjNmL96AQ3duCfoIpO23dOcwf7lfUnnm4vWYudi/Fg++7te7Z5JpSHcd5y/fhIWr2/HVv78GADhht9F4edH6gEbw7X/OC23XG0GQK1AQRFUS7ehJLtcS1zzd8yibGh9940MsXd+BW59dhOvO3D1yP7MWb8AX74yOsVFH/uI9ERrv5XfP9X5PDtctnFhBQEQ2gDcYY5MB/L7oR99G0CWU6UwF3EcQZxpyfQQpR70yvZnDQO641fIJaUxDcYJARl6tx3FQa0VHeST5NJJqInlRQxHhgnKnFHWsqHLToXlkC8gdEB1GVJ2oQjpD3ZrqZOciUksk8bEI01Ah1ou8ZBqS773YtfrMn7HXWMxavCFRyPXGuCHf1zTZ475pSPUZpThWzO51CXriXssDnjRmIl30n0A1caoagWDV5k6MHZqcq1MosaKFMZYH8DYRjY9bb6AjP/+io89qHFhJCWVim0LKUIv99WYKQS+6gcLZtKJjidNh1PcvzXSSSaO3pOWJGoEj/us1goBZpIDEMbEvuQOSHddJQkF00GqxMNGcgkof6KKGPGcxP85Id55lEcIZdPoGHcCFHFdcGkeKGvLmfFB6u6zNn/ekKKXeOItzjv58dOSl+6aumkYAx62jm3tEppCosDjUDt/3Ebj3u1kEI5Rmytg0pqGhAN5wM4u9AOWBnlkcQJNZrNMIKCF81IsaKqCUbV2Wz4iWpBHoJo0RHfeQ+myvnMU6jSBpcpqkEX/ScZM0At9JrDdfyZ1GVFs6Y0ZmclitLAia6zLYsDVaEPoagX7fsaetXE+mWdc3DfH/g92oGqERRJmGCqnFJDKFxT48J3LEaDtjWbAtSlH+InUTPESYcU3GSvVMRUUApTLJxSyLm7GNSB4s9S13XDaZMsZCps9Rg+qwuq2rZPMopzE2fQ/ASQB+iCrNLA6YhmJ9BPEqYm80AjFDUVtnD2YvXo9fPvq2dj15lNvZk8c375mLy//B7YrDm2qxuq0L37h7rme6SDMbl9qJ5B2GuzXJMTJJUQ7JGoHfkd49eyn++WrweF5HFakRSG2JOFZcmW95ZCaHLUZpKr97ciGeeWcNut12y4JAntxl9gfr8YuIe6eqXrpRphAEG7Z24/K752KDmyjlm4b8dVVncVoc5nf2QcEC/Prxd/Dsu8EEw4zNBz5Jo+6c4+Crf3sVV973OhhjWLi6DVf/+w3vHv5j9lL867XlyjZ8Wa1tJWoEv3niXTzrJj8yxu3pQoNW2yYHWgjeXrUZP3jgDa3m0t4VLfwJ5N2pvpaikvMI5GvfrWgExSw/I5PGR3Cz6yOoWmRBkBWCwCb8+TP74q6ZS/DQvFXeelEawU2f2htEFDuCOmvvsdhz3BB89/753m9i3Y7uPM666cXINnZ2O6jN8I7nn68uD2Qz7jK6GQtXt+PuOcuw+7ghOHf/Cak0AvnFmLrdICxYuRmPvfkhPrbPuNC6WZvQk2eJcc9Jozs5x+Ib97wOADh9+ljvt3BCWbh0hvp57wlDvXLSALA1pgy4bEKTc0U6Irb5+SO8c58+fgjftyRkJo3yo0hudjOPL/vILqF9qFdEd4nE/Xp1yUa8umSj9/uWrmAZZv4Z0uf0giDPmLYQW54x/Prxd0PrZ20LFlHiPV+5qRP3u1nT3zh2Mi7+8xy8v2YLzj+wFTuMaMSdLy9BY42NU/f0Z8AV7U6jEfyfG9kluGfOMrQOb8ClR+4UEgRyoIXgLy8tAQBcdMiOGDOkPrAszjREhL5X5HORnzv5fIWmILTTIQ1ZlALjI0hBYKrKLL9kGYtwyE4t+MpROwfW0ygKaK7N4LhdeQFXnW8BAH5yxm64/qN7YJfRwRA01SQQhdxRrZRGDZ87dEcMqvMfHnEusQll7k/y+7frmEHYdcygyNGZKB+d1PEkaQxqEpuK2L1fYkJd7u9fXLvPHzYxsE7cpB+yZiVrBIwBwxpr8LWjd9Zt5gkwWSMghK+v7vqo5RH0mcX66yY6YW8idgoK8MJNQ/5n4T+KuudZO51pSL4myzd0eIMl0ck5Dgs9F7Ig6E2pcdt9EeOapr6LuvMUglYHv7+cvk7xHOj8A4LA13ynbjcI5+w3oW8HisD4CFIQmLze7fC8DOPATGYRGoH0U9ay0IlwZyceJHX73ggCOSTVsgg18lzM7v4L9RHYFsG2okdntVkbW7rziR190uixO+fE+iHU0hJxCWV5h88ap04ArrPj19gWupXpJ9Us5xrb0r7wzXUZT4DI9ykqDNRWoqrUSxqXRxDeX9BUlrWsYHJZQaYhP9M7jXkpY/MEyqScpy3SqHr5xg7vuoprlnNYyIHvmYYyyaYhbdvcGxVntspYFnqkUGLds53kI/A+99FHIL+PcpJoj/Scp8mw7i1pBMH3Snb0bQQKaAT8JRahoHJnEWUWkn+PuplRYaniRU9yosqjXHmGM5so0Eax/7g8AoH8AhIRbIruFESxuCQ1Po2pojvvm7lUVBt2XK2hnMOQsazQyE8nCDI2oTsf7MjV7WqzljZHYrvBdVrTUd5hoU69J++EBJPaWels1UmF8sR5Z2wKmnUK9BEE5v51TzVqRJ61LNiUHBUU0Ag2dngDEy+RzXGgPt6FmIZ0iPcsrm1Zm9AhuQBUMyMQ7yOwiIplGQoMoOSABaE15R1WUDhzoaSqPqr7K1mL+iFyRy46vIynEciCQC8M0tw/sV3UukmRRpfdPRcvvMcdZvIEMbZFyGbCgiBNMSu5g7KJkLEs5BxH+3KJYnG/euydyE7r9ucX4doH30w8bpz2owqAqNR8gL9EtkWhQnZqyQnAv59y1rcaEFCbsbT3d/Tg+tActGpbBPrCdtHCTBBVhdKbvN3dR8YKOm8L6UTzsmkohTARzuJk05B/vVds7PAGUXInF0qoEhqObWFLVw4/fGABrrxvXmKlU69tQiOIGe+oGp/uuUsK7GCSSe6Zd9bgOcmhXkjYrKzZytdz5aZO3Prs++jJO9oAlWKRpvpoGxFtdv86iShPRJuTthtIyJ2zOpWiPMK3LN80pJqMBFEhiOIeR2kVSaahN1duxm3PLQaAQNkG26JAaWdfEMRlFnPk95ubhgiOo+/MxDH+PXeFV6ZX5QcPLNCWBVaJmkFMblNU9VGmdIIZOywI9BpBuPxHVtmuJmNpp6wcJJmGgm0Ne2DiZkHzcg40fpukQnmO1HH2tgAdk2sNSdc16lnJWK5pKEEQyHb25Rs6vHejWxIE6vXLO1yIZyzCnA824LbnF+GumUtw95ylqc7F9xHEaQTJgqAQzrttJj71h5e974UoMmoxRsGitVvwowffxDsftqeadKm3pNEImhljgxhjgwDUAzgTwI0la1E/JKARZINOUTmyhMgXGhOGN2Lmt4/iv2v2+fEZwcibuIxlINwRHDN1VGgdXb0V2yKv+Jp8nFQ+Amk/FhEyNo8Q0W0rm3LiJnhJQ9hmHhzly/sL1xqSP3N1WhXeOjOOGEHKy7LKvajN2FpBzRhCGkGNbWk7SN21iTNvedtFFsoL3nNe+yd633HkmZyY5SeU6dqcscg1FyabR0QJkrFD67Fik+8jkB2hYWcxf3YtiwIddNqEqjQ+AvVdSzK/qhBJ4aOa5QXN9qZ5xmV6cqX1ERSkazDO/QCOLU1z+j+iUxE3LpsJlp8Qo3/5lukcn+OGBcPUfNNQlEYQ7LwaNRN690gjLHm/9Zp10zz0cudtu7Ov5R2mFQTyqFsny9L4JLzjavIXBD1S56EuU7ftyTPYlpVKIxCdk+xrUV+8KNOQwxi6cvmg5pixYsNAZcJlEQr3EYjrkLGCUTYF+QgcBExDYkudBiiujWUlRyaJuYcnjWzC8g0dXiftRTxpnqm84yBjUWBCoHHD6rE8YuIfFdsTBNHrqJaWQjUCxnwBpnvH0wqCjKJV6cx5uRL7CBKdxUR0hvTVAjADQGnynPspQY2Ad6ryi+evF+wExf3UR5oE44F9jUDfBrXjbtDMmerZi5UOXHZOimVpfAQ5RaBkLEKehdV4IDizmM6hWshLpr5Acju6lY4vtsSE4yBrU8gEoBMEouPojIsayuijhnryDhzGs31FZcqsrTeZdCsaDW9zeJ+6Y+gQ99wbmNgUDB8tMGoocO1Z9LGFJmwRJWp7QiOY1NKEp95e40UZyc+ruoucwzxzpGDy6EHejGFJ2Ck0AjXSp1CNwJEygHWkVQhqM0HtUXfPOnrynrmrFKTZ88nS37EA2gCcWrIW9UMCeQQZxTRkBzUCWWgIW69ukK92lqLPidIIXpGSiACgIRutEcjPkUVB09Da9i488eaHfh6B5mHVObks96VcuLodv31iYWh5QBC45/DBui2Y5Va6TFNWQ5y6+iI89fYa77N/jkIjCL68Hd15PDB3hTdaS+0sFlnfskYQMg1ZWtOdECzNdb5wrhEvt3IpRflv/ag9bNrztkuomyQWZ+ygJlJQHoEiCMTzqzUN2b4pM1EjcK/PxJFNAIA1bn2ku2cv4+UhXI3ghYVrvRIKeY0g2GVUMz5s68S9c5YllyLxTFzR66i3spDSL/wY8Xkx8rWsy0Z3tWpklLjX6rStUTlIxSBRI2CMXViyo28jyJ2z6FT8BB4+Us45PPZdCG0iYGgDn6zk0iN38rbfe8JQ1Gft0By43oQ3KdW/Bq1pKGwuUX0EP3Kjds47YAKA9Oqr7foIOnsc/PmlD0LLZR+BOIXf/m8hXl60Ds9+80htVI1K1uKx/GqTLvnLHO9zTjENqSOyW59bBIDPGCbU6VTOYo2PQL0ytRlbawIQ2k5TbVAQ6DoJVaPh56DmQoQ2S6yY6vkIFDNDQT4ChwX8C2JTnQYonOt2ihITW7pyIOI+AgDYtJUHDDzx1mrc9twi10fg4JO3vozm2gzm/eBY796J96GxxsbowXVgjEfIvbcmPnrIn4Yyum3qYCzNM1qTsQJaWNycwvKlr8/akRFINREaQWNtBl05P7iios5iIvojEQ2Rvg8lottK1qJ+SCCPICNMQ/5vnr2UgupmXdbG4utOxLn7T/B+u/fzB+IvF+0XGo0k+QhU6mv8TueMvcbg2GmjfHux4izWCY1Ob8Ka8HSROpJKbNdmwxrBxq3dnn04jY9APOhxnZc3Mha27Ih1N3X0cGexbYWdxVrTkOsjkASB2sHVRGgEok2NsiBwncVqBJDOj6MKDHE/5ENF+wiCWkTWtvpgGtInkukEmnCkE1FiUbmt3XnUZ23vPqhRdI7DvPNoc5PPHEUjaK7LBkbEcq6MjjTTUKrPMx+E8PXP2U9fTEF+lxyHBRK+Qm2Qrn29RoMX1GZsrY9ALSdR0TwCALszxjaKL4yxDQCml6xF/RD5wfVNQ/6Nt6VOXKyalGmovp+eaSjlzW6s9R+sjMXt4Dr7s0WEOq0g8NufaoJsV/OJokaTWNfWmfNGy2lGW2kiPbqVEXC0jZa5sdfhqCFdrSHRychCQt11bYSPQIwQ5U6iJmPHmniCpgDVzyHaZIW2UxHTfXo+KyWhrNDMYnl10SnqJvLxNAJLMsNEHGtLdw71WVs7oUpdlptFepSOVCQDineruS4TNLsmDF78NkWvEzIN9eS1115G7tDzkkagE7hyG3XvoED1EQjBO8y1KAhKMSGNIM2eLSIaKr4Q0TCky0hOBRHdRkSriWh+8tqVp0bxEQD+SFYeNScN7IWdVOCZhlJqBA2SRmC7nV2URqAbjcjmEbWT0b1iBMQ6qwIagfuxrTPndZKpNAI7WRCo5xg14mXMtzNbVlCI6bbxncWSIFDWiwofFecWEAQRzmKtRuAE/TVMGt17x4ixiQs7O8DNa0kRKFHIZagBXyDFRQ3JPgK1MxcwxqcN1dm467K2NgNb9REMqs8GoriSTiuQIR1ByFmcd7zzV82JgnpVI3CvjXyN/DId0nYxGgH3EUjZxO5nMQ+2oNIawS8AvEhE1xDRNQBeAPCzIrbhDgDHFXF/JUVoBPJNtiU1Oa1pZ9XmYDlZzzSUUujLnY5F5NkuHeWlskkvCOQp/GYuXp9q5Bj3IMo+grdWtqGzJ4+2rh7+cjnMm/s1zf7jmiKcreK9melOC6nCIBLKwqVAgPBo0PMRdMebhnT3V4zgZOGs2n0FMxdt4NtIL/5cJRJGbCWboeIEaY/kV+EagWTeKcBZLM9QBvjnrxNCImqIyI9SitMs67O2NjO2PmuHzCoPz1+JLV05xTSUCQxEdNdWvqdpfAR8jnH/+4vvrdMGgcgETEPMv49vrfJzbHMOw+rNnVi63g91VcuKyMjPyuq2Tixey7cbqpiGSukjSOMs/hMRzQZwpPvTGYwx/cStvYAx9gwRtRZrf8Xk9Olj8M9Xg3XSfR+BPOr2Q+nS3qt9dxiGu2b6WZJRReeiGOXOUAW4GZ7Ey0CrozLL0ucRyBrBhbfPwrdPmIyLD50YWk/dVxTyCOrmZ97Hik2dXsGu7ryTKnxUnHsaHwFjDI8t+NCbH1iFuS+p6OBrMlbA/i8m/BHYWkEQPsc4H0HQNGS59f2D69709Hs4bOcWtI7wpxucu3RjYB05FFQ9ho6evF8+OmNbwbkJCtAIGAues68RxEQNSSUm5IzwoQ3ZQBa9rBHIQs2i8HW+5C+vAOB5B+KZa6rNBAYiOpt8Y23Ge+YczahcB8EXvE++vQb3vcLf9xpb33GrpiExMJHnhe7KOdj3x08EtstYflCJimwa2vdaf7uhimkoylxVDFLtmTG2gDF2g/tXNCGQFiK6mIhmE9HsNWvWJG9QJK7/6B5484dBZUVvGuL/LdInlug4bc8xmP8DPy/PTmEa+t5JU/H61R/By98+CuOHNXq/W66PoCfnhEZlah6BQHWYvrmyLbHNqkZw50X7Yd/WYQDCoW6zF6/3XsqunJMqRjtN7LfvIwDej4kcYfDDR4HwSySP3gE/HyTgLHYYRjbXotl1Amct0pr8tD6CiMxigIfwxoYdilBQaQQcN9ruzsmmoT7WGpLW90f6vEFXHD8Zt543g7dNqsLr56bw9b574hR8+qAdAvturst428jPQlwtH9F5AvzayoMknVyUo7bEeSdFNKkDL1G5V04UlZGDNByNbwPQa1BqqReZ2oytvU+qaaiiUUP9AcbYLYyxGYyxGS0tLWU7rq0ZTat5BEDQWZz2XhFR4MElzzQUvYPhjTUYVJfFqEF1gU7ZJkI2Q+jOO6E6PWoegUAdoaeJLlEfxMH1Wc83oFYL3dqd9/bZlcun0gg8QRCzqhwuGSdcHNdHIEah6kuoRlJ5eQRK1FB9je3PSmfrNQIhnOpV05Cm1pA4dlwHJbbKpNYI/GiXjB2M6y/cWSyZlbwOnv+fMKwBQxu5uaLG9p95sYm4DoPqs6E6Tc21We+Zle9b1IQ/gFvfyn0vuGlJFgTh61GvSZxMOn1VEAxrEOen7xrl/B2HhUtjAPp8BGG+1RFlRgw5i6tdEPQnapU8AsB3chKlj/pR8U1D0evID5ItdRKys1jtMGyLtPZOVSNIsiUThR/EjO1H5KgdbZs00X13ztFGnqikiRrK5f0XfEVMCKEI7RNmO/UlVAWB6HDkEarDgpmzWVvvAxJtkst+ZGOmWKzL6keAAnH6aZ3F3XknkFAmX76+JJQ5ikZgWeRplxnPHOofQwiMGtsKabbNdZnQPARAvCCQ8wjqauzAM6+7frKQjppnOYRyO8Vuo0y08nOTd/QmKt29IgoPlgRq1JAgFD7aX2oNGfyO3umjRqAiHuI49S9QRZSCgiDrZpSqqrYt1T+SUV/AfCDqIb6Ngq4ex9MI1I5Wfq67ck6q8FEvjyBOEEgveNz8rR09eaxt65LKhQfb3qSU6GDgHdgyqZZNnvEJ3OVkrdRRQ0IjiDgXfbgh/y8fTxCnEaxp6wqVoV7X3hUIK02D4wS1MW+k73ZsGSkCLRA15B5jbTuPhMtqNCc56idQZjnmHlqSKa4hG/QR6C6rfMw0eQSkeV/FexH1HgaihhjTmuzkaVEFvdIIQqahCvsISgkR3QXgRQC7ENEyIvpMpdsUh3jZD5o0wvtN2D75s+NHEBUCScIkinHDfAej/KAKQQD4dV0EURqKKgjSZBirL8eQhqw3yomyfwJcYKQxDYlRZpoEtzxjWLUpuhO58r55WL6xw3vRQxqBIgimjxuC7ryDxeskQZBnvNCe5IjVXU7xEsumodoMH5nrzkRXbVOcEwApAijeRyCu+dm3vATH4bOx2URY29aFvX/0OK5/9O3Cq48maATCtyKeN0vySXznn/MAAIPqM6FnpbkuE6jUKxBzGevIWOQJofqaoJahG4kHBIEIH0147NQQUmEaFLvafexgHCy966r5SZdZ/PV/zNW2LdpHwHMp1Ode9RGo1XCLScUFAWPsE4yx7RhjWcbYWMbYHyrdpjgaajJ46vLD8bOzdpd+4w8Hn4+A/1boLRPb6UYin9p/PB7/+qHYWZoMXR4dWeSbf7YqgkC8PM9fcWRgG1V9DdaY0SO2P2rySDz+9UMxYXijbxqKCY9Tp4CMws8sTlwVjsOwpSuPY6aOwrPfPAJPXHYYxkuCUrDenf9AtfnKtt7Hv34ovnjEpNC2OcdxSyjw71mbYjU21VkMRE8yo527WBnFJkUNyaPTPPNzJra4Zr9H3lhVkCBgiiBQTT5yKLJ4FuTrwxiPZjtw4oiQwGyuC+YBpHF82hZ5x67P2tqOXqYmY+HFK48MLI8NH4X/3m03uA6AbzK1LMKz3zwCf7t4f/z+vBnYa/wQAGr4aHzRORmLgoJdvrdiMNXeFXx367M2nrr8cL9vMKah/kXriMZAJE6jO0oqJI9AxU9KC2+fsSxMGtmsXZ8v99VOdbJtsd6YIfUYojifZOQHWqcdEMhTTbO23x7fWRynEeRTFfTKpEgoEzDGR28jm2sxblgDJrY0aUfrH272zRUyDVJm9qSRzVrNqTvvmoZE1q6lzyPw9qn4CAB9bfmcw7TmL38uALjHSxAE0jPY3pkLmzpYYTXx8w4C8w8Lc6EwfWUsQl1NMC/DIr/T7c472H/H4bCtsDmSRw35v40eVJfYnoxleZpkXdYObK8VBLaF7QbXc5t7CtMQ4GvircN5FF6HpxEQxg1rQENNBvU1tjfIqM2qpqEUoxb4NckE8vMo3p2NyqRVGYvQOqLR08KMs7ifI2rMWJQ+s1glbqpK3ehJftEsy3faqhqBpQiMKOQXK8rJ6ZfB8H8Tx42yfwK+RiBfE9318aOGkjsvhzF09OSDk+5ozm91W6e2fY01ycnxPTmHO4uliJy4YAC5LeJ4WhOQw7RRL/6qvilKoDOtyRrBxo4e2JqBSEGZxYpPQ2wrm4ZqXPOYPx+Bf8+6ehyvU1PbMUgxDaV5P2yLpIgsJXxUc1qik7Yt8oRYYh4BiW25X8PzEUQUhZQHPLopNiPPhYLPjk4QbNganL1PDtEFwlOnFhMjCIqAKD8s1xoqFK9GkWYHSWp0wEegagSKUzmKNNMbCo1Atqt6GkFMsovwEcjmGZ1QEm3liVjxL1heCAIlw1pFjmSRkTWCKHrcOY/l+jNxt0KeFlP8140Yo3wEahJUkmlIvkQbt3Z7piFvOfoWPqoKAjHSl7OE/XvG56kQ563eikF12YDpNI3mbFuEbleTVDOTdYJU3GNb8uvEO4uleUCICzlhGlKbJ74GBQEXwGmwLEC27MiCoMYTBMF9qQEkpYwaKlrNoGpGFIBLqybqiOukk96ZjOVPUB/WCPzPauRM1vZtsEIj+OEDC/DIGx9GHoc3yP9N2Dfj2t+VcwVBxlf1ZfuvQI4aSuq/RHSUbKLTJeONaOLmsJCzOJtCI8g7gY5fnTFLxbYs1LqlPsTx3l+7JbTel+96FSfsNjr0+4Ovr8SDrz+I335iuns8v826xCu5U9rU0ROYKhXgwrTQiWnkR1j4V0T2rFz3RzzzlnTPunOOl5Gr8xEAfJTbnXNiBarAlp3Fio9AJ0jl0O7bn1+MEU21iZPDiNtpW4TarBUdNeR+lTvwR99Y5VVLTYIo6F+qkd7FGs80FNQIxPmkiSjsK0YjKALCNNTelfMevN6ahnQkFaKziLwHq70AjUCOaxYdxm3PL9Ieg0iqqST9Lh7iuNFKdz6PTteM88Rlh+Hxrx+qVXNlH4Hcge05bgg+f7i+/IVsjlEv0+cO3REPfOngQDsFjSk0gq6cE9DQsrYV+H7gxOE4eoo/d3RGigzRJSTJ80w/NG9V5HHnLd/kHi/+vu+3wzBc6jq5N27t4RqBXKEThWYW6zUxTyNw933zuXvjC4fz44rjOQ4CAlDnIwD8yJc0+TYZabBQVxP0EYiR/hXHT8Y+rUMB+PdYdOa3Pvt+SCNoqs3gxnP2ctvot1/kxHjOYtU0hHC7dUJgYksjdhjRGPpdNdvJZj/xrIiIpUuPmITfnzfDG+SIxDJd1FWxMIKgCDS59uYtKUcHOuLei8JMQ7nQMoHa+dYo9s4kdA7tKJsw/43/7+pxuCCosTGxpQmTRjZrz0mYntQqmFmb8BGpE5UTbWTTkLrPg3cage0G17v7UAVBOo0gcP2UqKHDdm4JFf8TwlXnMzlgx+GJxwSADe5IXCcsZeGwfmsPTpu+PQDXNKTxERQ6gbrDWEgAdUumIQDYfewQjHajbMRlzTkOuvO+j0C9u0IQ+KHWaU1DvkYgbyME3IimWuy3A7+uasACUbgC7F4Thnptl9tpWxZqs5YfPtrL0ffRU0ZpS7pYFHw+5WsstHlxrsfvNjowaBjp1hUzGkE/R3QqW7ryoYlI0hKXd5D00qTNI1AfbnnUmsbn5VdZ9X+LMw0Na+QPcHfeQUdPHnWSBqLzEcjVR+UOTFWrxw31w0TVjlhGnhc6KbNYR86NzRfYVjAqR00gzNjkTWepu2e64n86RL0bnZYldzIfbu7EIPccN3fmXBu8pBGwdKG4AsdNQFMFUI8iCGTE8YTpqiZiYCDuhegA0/RpGclZXJOxtKXEbct/rsWxxaNjUTjxzKKgluyXf+fvQ4eSR+Cv535INDXp5+2wlGdYHpiI9shmU5lRboRVmlLuvcUIgiLQ5I522jol01CBmQRx5p9CBMHWGNOQqvbLcwgUUoZaZxrSdRLCPt/V46CjxwlMzqHXCFx7sxP0ERCC12DcsHrvc11M1FBgDuGEonM6ujWmIfkYsmlBtF9UKNWdX1xNepnlGzq84+n2IUIZV2/uDAg7S/URQB+dFIWolqoKIC+PIFYQ8OeuNsJZ7JkQrfQagSVpBDVKtrIQBJbU8YbbF55GUz4ugSQfgYXajB0dNeT+Txro2VbEdVKEdKBcjLu+HKYrIyoNr94cnMOkmBhBUARamviNqq8pLDxOJtZHkHCXbCLUuNUS29WEMtnBpnT2sio9b/kmtF7xYOQxCLJG4O9TdG66Tmu4EAQ54SOIjxoaUs87NdXJSRTsnMZKGkEgfFTZ5aAYjSDNROA9eSfQIaglJiwlJFD4CKKcynE16WWWuYJAd42aajNodW3QdVkbdVl/pKyGKC5d34HrH30n1TEB4Jr/LMD7a7eE7qUoZKh7RsUzccjPngQQbyoE/PuYJvPeJvLKLNQpzmJxjWRtUb1eRGHTmFy2QXauZ4SzuNvRtk98VTUM9TTk5M7g76ppSHoXRHnuiOsschwKqRtVKEYQFIHDd2nBD06ZhiuOn9LrfcS9F1H2Si9czvJt08K+7G0r7TgclZCuY/LbGNYIjpjcgqtPnoqdRjZ5JYoFQxtqYFt8wvvOnnwwwkd5Wb505CRc6JYuVmv0EIIda7Nk3w/4CCIclIB/ra48fjKuPX3XQLkOwX1fODDwvTvnKFFXwTIH6ghc1JNRO2RBGnMUII0MNcL1+6dMwzeP3QW/+vgeuPX8GSDyHdTqqFPmp2fuhse+dig+se9477dDd27Bl4/ayfsuRsNqhxo1UhXHlIkKHxXIiWhJNNZmcOv5M/Dzs3ZHS3NtZMixOJbaFkIwj+DQnVtw9SnTAmN6f0Io7izujIgaEho+A3D7hft4x8xaFh772qH+eqTXBi3Ff5O1Cf+77DD83zl7eb93R5iGzthrLK46aSo+f1j8fCF9wQiCIkBEOP/AVjTVZnrpIYh3BEW93HVZXxCITlYU/tLtd217UBDEJYHpcHy7l0dDTQYXHLQDiAhHSw4ugNuF6zL85eroDiZ/qXboiw7e0WuPKCEtkCOWgOALH9QIgtepTpPgNaKpFufsN0F7TfcaPzTwvcetNeS12Q7miaiZ5NxHwKtk6rS4tD4CgRhZ7j52sPfbYTu3YNcxg3H69LGeZiQ78XWPkW0RPr7PeOw0qjkQtnribqMxaWRTaH31GY73EQS/R0UNCaLNOGGaajMYNagOH50xLvb4InlMFRS8RLZ/Nhe676iM2IJrBHakj0DmiF1GYtft+T3J2ISdRjVj2vaDvO10Tn4uIPzvWdvCji1NOH637bz1owSBbRE+ffAOBT8/hWAEQYko0DLUq/BRYeeWZyFb09YVrFIac4fjykLEkdb/MaiOp+d39OTRmVM0AnXEZfkvn6P6CBRBIF+OoI8gui1ZSXvi55BMTz7oI8hYQTu1RUGhJAqLRVUpTesjkI8ntz0KOc5ca76R/RiKo1T3bHV2qwUJ+X+dlqNuL/IIoq6v0HLSmIaa6oKddlQHK0wm4WxghJ4j3faA69+RJhNKihry5qhQO+0IjcC2gu2XfVaqj6CU0UFRGEHQT4i791EPpTA12ESok7ITZZNInIApWBAUmCPRXJdBbcZGZ4+Djm4n0GnHvUBqhivB7+DUmariooZkaiTzSdK6gpzDlGzQYEer1vaxKd5ZXOj1FhpBkj/DnypV/6zI/Wegam2EBhE1R4BOaKjHS/IRFBI1pI7edYLeIj/QQS3TbCnho6JNQksg+M+y8BGo6wpUH4G4JVlPsIk2RvkIoktMqBP2JOUNlQIjCIqMuIWFzi8aNwKJ6gfqpNoqstoov0D6OkX8fyGmIVuaFD3tgKWplmsEnT15dCl1gXTqrzxncTB81B8tjR/WEHhR4rQMGZFwJ7aNetcaFfVbTQKSb6tq9824mcV2xEi70Gci4wmC+O1kc4vuEsgjUbUCqO65i0pC0450VY0g4wuluLamEcTNKTQC2/LnAVajnVRnsZoHU5PxiwiqZaKTzkst+yC0ZDWSTGARBQcVuqihCNNQOTCCoMjsNmYwLjlsIn7jlglIi+7hqVVGsSqeRmBRIEa/KUIjuP2CffCzM/3y2WmcxWfuNRYXHNiKCw/cwbMdpzUNNddlUe/aXTt68p5PAwhrBDVSaCYL+QgIOwxvxMWH7ojfnzcj0InLwkyo+TW2hf+nXH8/zJV/j7qm933hIBw1eWRon4CYs1gxDclmF5vwsRnj8MUjJ2n3r07fmETaImNBH4GuE5LXDXZAuvXP2GsMBtWFw2v1YZHB7zpn8T2XHOB9lufu+PvF+4f2N338EEwYzn0fqkYQ5YSVQ0lliIJRPmLxbmMG43OH7Yhfnz09UGJicH0wFFfmso/sggsObMXpe41x9yVMQ8ELIDuv1XYGNYKgQAaALmMaGjhYFuGK4ydjzJD65JXl7TT3Xi5mp0NoAcIkIF7CKI3giMkj8bF9xnnfVVPFZw/ZQduGq0+Zhvoau+DyGc11GdRlLbR35pBzWKxGIBck41FD/jJyl3/7hCkYN6wh2PkGPvP/J+2+HU7ZY/vA/tVEp6hT2GV0M350+q5SO/1lmVDUkKoREA6cNALn7DdBrxGkeMFlwZYmxJW30RcEiVnoSuSKTtnIWhauPX232G0F6rPpP1P892OmjsKM1mGBYwK8I91vx+HYSXFWX33yNK9jVwWBLmqIyB80hMJHlTwCOULoyuOnYMyQer/EhEVe4pZYR2ZwfRZXnzLNT6Akoa0pz3HEy2FR8PrpCjB64aNGEFQvupsvXoSol1toBHIaPt/OH9nEdQyyTRQAWpprQ+vI24tkmvSCIIu6rO2V15XNV1o1392xWmtIPV5whBvsmAF9Rq7qLI4zTYxoqvVtvkpUUNBHEA4f1bVLbUMcI6V7IEbPSeHjsmlId1qdUglrteSIzmnb4zjatuomRlHPUzWhqEmM8lzHuu1ti7wMW9VZrHVWS6YhdbmlmIbic3UsL3EraV253RnFR0Ck15gtKzqz2FIEQSnnHYjCCIJ+gu7BEy9ClPNIdPxb3SgPYXpJ6ywWER4C3cQ18sPreBpBWtNQxhUEvLxubYI9X+xXrTWknoMaqaP+rou/FyMw31kc3e6sbWG4Wx4jEPttWQFTiC6hTNdGb/sUpiFZGIv9JWez+ueknVNZEgQBH4Gt92Xk8sxLUAwcJyEiCQg7i1V3gxhBR1XUtC1Cl+uslhMCowjMF6FqBESJUUNiW9sCRjX7GkGSzJadzGr705mGYjQC4yyuXrSmIXdkH/VciDlyt/b4NduBZGexQNUIZBupIHBsKdoiDc11GdRnbS+RLZBHEJiqLzhaD9UaCrVJ1gIQ+qwzwXg+As9ZHH8WYnQY6Oi1GgH5ny19uwRpTD0iSx2QBEGCRuAJgghnsUxIsOkEQYRGoHNZqNfRm7MiUSPwTTLB7SWNIEVhQCLfuR1OAkue18IXBBZGSqahpOdDdRYL0pqGspKgNeGjBo84jSDqoRxUz5eL6RBFBI2sUseFoqn1d3Rx7sEy1uni2gXCWSxeVNlZLD/sY4Zyf4rnI1DyCNToJvk9IQq/UHEagTx6jkPYi+X1Mop6LydwqddZV81VLSOsK1UtawR2gYJAV31UJaMKNs2t7MmHC8/xbfVROzKitpG4B+q9UEtMqElSct2sNBVi5Qit0PWk5Kq6ohSTbSFgGkoK4bQ9QWaJQwGIfq6IgtdKfhZCCWUV0AjMxDT9BN0LLEopdEbEdX/pyJ3QnXO8sgFiJDVcqqeie9EbazJo78oFNILvnjgFB04cjk/uNx5/fXmJ97v88J659xgsXN2Orx6zE5L4ylE7YWhDNtD5y3VeRIc0pCGLOy7Y122r0Ah8H8G4YfW45jTfeQtEvyjCNqsTaNPHD8WFB7ViujsJedKIb5DGUU+kZhb7y8MdojoSDodq1matUEXJkc1hh2WSaSgYPho+r6tPnup9Vksh6x6tXN7RmoZ0nZzc937xiImY2MKdvwdPGoHPHbojPqMEIKglJn798em444XFeGDuCizf2AGbCHdfcgCefHt1qvBmyyJc/pFdUJOxcNr0MYFljCVPVSnuU9a2AhpIkkAV9ybkLI4wDfE5v/mCEU01OGmP7aRt+H8xnatxFlcxcVFD6qxjgqbaDL5/8jRPE1jnlpcYO9SPWNKpmaK+uTyCuvCgHZCxLVx98rTAunKHWZuxcdXJU1PZbr92zM4gokDFUTmSSrTrm8dOxng3XNC3K/s+gu+eOBUjmoJO7KiXVAhMNf4c4CPP7588zc/GTnjXRHSIeqxQ1JDQQpQdCi3omKmjMHl0s1aL0oXvyhqBnwAV31a/UwpPpfnj03fDBQf5nbFsylAzpeW2i/bK90wnPMVvI5pq8Y1jJwcyda88YUpAsPFjCo2M/x89uA5XHD85UMV2ynaDvIlvohDtsggY3JDF906aGhIcsm8kipyrEqiTDiUNysVl87Qk8s8rKrxaXOvPHrIjJo8e5P3uaQRKkcNyYgRBPyHONLS1W68RqGzu5AJje+nl1e13tGv2kMNHPfu6Hd3x9QY5v0GeEESNHpGP5TBfZde1P6pJ7e6kPIM0vo7wPuLPKyoxKlR91P2qjuLEVIpZm+ce6PwDddkE05AQBLEt9TtXdeIc8ZtMoJqqrfcp9OR9H0HSxDZif9sNrotdzz+m/rqqTuTk/QQFio4uRRDoTkUIbNWslBiGG+kj0K8va49qFVE5oawS2gBgBEG/QfcACBtpR0pBINCNvGVEiOIWab9eZdGQ86+gQ4cQNmBRbkJtl+p8BYKZxbrjR738YlIenUYQ3kf88qhSCapDOCovQYw0bYuP0nVmDp2PYFjArOfuNaWPQBcOGhLsSuSK1lmc9zWCpKkuhbYqx+DHkY3owMXAILUg0Dw/Kl255PdGFKzLZtQOPcE0RL4WBvj3P26AIW63OveHl1CWy1ckdBQwPoJ+TWNNYRqBQO5MdCN68dKua0+e6KKvIxRhr5f9FoA0yY2sEbi/vfDeWtz50gfuco2tOkI4bekSpqG+awTCf6IeS3VU6+ZoACTbs2u318bla65tsHYS/580KveL04V9BKqDN1BuwiLtdehxmCekkpytqzbx2dRSawQRE9NkIwRvFL6voRCNQDMfs2QakkmcAyTCJGjzRIIQBP9dVCcak8NHjWmoSrn9wn1wspIFKzhtzzE4aNLwyInbVf7vnL3wmYN3CIZXajqbiw7ZEYft3IKzpdr0MnLN+kJjmn98+m6B9u49YSh2GzMY5x/YGlhPpxGIz88vXIcVbgeTJptVIOZrLoZGIOdY/ObsPXHeARMC7Rb7EE1R93fM1FE4YMfh+NoxO8Oi6Il7jp3ml+4+d/8JSuVY3zR07em74gsRz4GcP6EeJqQRyHPl2pbWmp3LO94IOZd3cNOn9sYn99M/K6fuOQaH7tyCS4+Mt+mr7VEFbDaiY41CmGR0jvSfn8XLqKTxEcjOYplE06Gtj6CzrOjwanGfVNOQOJfOCpqGjEZQYY7YZSSO2GWkdtnghizuvChcjyWK43fbDsfvtl3iei3Ntfjjp/fF5s4e7fKfnLEb3lixCa8v21TwCEXtMHYdMxgPfOng0HoZTYegewf0PoJ4QaCrk5NmvzJCI+jJM5y65xicuueY0HZyiQm1Tc11Wdzl1tKJ8hHUZGzcfO4Mb2a4a07bFUvXbw21kTGGc/abENlW0XmqtZD4snAtHG9ZRF6DbBpyGHDcrqNx3K6jtesObazBnz69b2TbQm2NmKHMG+GnNg3590flozPGYcn6rfjt/xYm7kdsLzr2jEVu1dn4dgg/lH8+/Pc05eRV05A49+6cE5h0qZyUVCMgouOI6G0iWkhEV2iWX0BEa4joNffvolK2xxAkTSdfqhGK3kcQDr3TmYGi2i18HulMQ/HLRceQU/R41afhJajF7EuOjQ8eQycc9BpBHLLjMmQaivERRBW163EcL849V8Ccx2mIMg1lCnQWC8Gq3h9/eWFdm1i/oUYfLaYSVQcscjspwkz1u+jKTZSbkokfIrIB/A7AMQCWAZhFRP9mjC1QVv07Y+zSUrXDEE2al65Uz2VUh6CacZOqaepIE96aVEHV0wiUl1Y+tiUJrjhTQpSzWNdZBToFd5dpaw3pTUOqj0A2DcVoBBlhzy7uPLlR8xF4CX8pNdCMJ6j07dNd27gzEe1qqs140XdxiMGGCFkWrebPhP4c5Pk2ZAKT1AxAH8G+ABYyxt5njHUD+BuAU0t4PEOBpHnmSpXunqb4W9Txk+y3urBMlbR5BD2KnVmdKc2raBmzP4pwFut/C/tMkrpiSzINhZ3FpF0X4IJDdylzUvhosQVBJqLDL1QjEOv3RGoEhT23wlktIvW29sQLA6ERqJP4WBStHfrOYlUj8LeoRHkJoLSCYAyApdL3Ze5vKmcS0etEdA8RjdMsBxFdTESziWj2mjVrStHWAcc3j9slkFimI270cchOI1CftbVz2hYDP/wvfj2930C/7pXHT8aE4Q2piuIlCSAxgldHnME6R1IeQcz+9mkdin13GAYAOFtTBvzAicM9B70sHHYe1QyLgK8cFe+IlTWCkI8gxkQS5Zj91vGTkbF4fX41q7uv+NFieh9BUkd4+C4tOGvvsV5Awu5jh2jXkxO2jp7CfXBTpN9UxKhcJLeJ+aCjEFqnGtodZdohAMdO436WM/caG1gmF6qrlCCotLP4AQB3Mca6iOhzAP4I4Eh1JcbYLQBuAYAZM2YUd4gyQPnC4ZMSszPjHrpvHDsZ3zh2crGbFTp2UqcdNduTjs8dNhGfOyxdhFWSrBCddNSIU7RDnIdawE9Gvo7Xnbk7uvMO7ntluWde+Otn/YAAWRAMqs/i/Z+cGN9Q+NdSl1kcNzLWCYIrjp/sOcbnfv8jiccuFLXERNLvKndc6DumF18XfW0O3mkEdhjRiEVrt+CwnVtw6/n7xO5XCP6jpozCOz86Pr4R8AMSPNOQnFmsOQciYPzwBm2bhcbYnXMGpEawHIA8wh/r/ubBGFvHGBPB7LcC2LuE7TEopC0nXQrSawQaQVCEpzZtZnG8IPD3U8h8xOKcdGGuanhqGuRJUkIml5iLpet0Sp3QFJURnHWzoov5TIp7kmafhTqXhRBXc3x6e/lqU2pEpaKUgmAWgJ2IaAciqgFwNoB/yysQkRzreAqAN0vYHkM/wo5wFofXK9xHUAxEJ5LThCfK7bA8QZA87adA2JWTSmGknRJUXI40mcXB7cJ1cUrdEYloJFU+qbO/FYOo7HBtuwr0KUT6CCz9XUu6l9mM3ndSLkpmGmKM5YjoUgCPALAB3MYYe4OIfghgNmPs3wC+TESnAMgBWA/gglK1x9C/SOsc1L0X5XhZPGdxjLPUIj8DtRCNoKM7ujieDKXcpQhC0dUOivMR6CiXRqAKLD5ndXGP5U0rmWK/unIfcTTU8n3rooZ6g59oN8AEAQAwxh4C8JDy21XS5ysBXFnKNmyLHLpzC555Z2A7xX0fgX65l9ijeTGKOYPT+QfoE7U8H0FMdipJoYJxPgIVUZ8nKfEt7XkKUZW1KZQ3kNSxj1ECCuxi98YKUVFDE4Y3oHV4Y1GPJe5JKUxDQ+p5yZTzDmh1j8F/twg4afftcf9rKwranzi+qTVk8CgkU3NbJalo2OD6LNZt6e5VHkFa4pyNSeGJoh2ifYWMKDtSJr6lPU9PI7AsryS5ICp7WDCssQaLrzsRH7v5RcxctD5x/b6SjfANXXjQDrhQKpddDAoyDRWg0QHch6R7fiwiHD11FJ647DAc9Yun0++vwMzqYmNqDRkqQlIegZg2U5dMVQ4fQZrqm7zoHP9ciI9ga1rTUEofgSimlrUpNClPnLNYpqZMI1J/svfymffSnFKhPoIovImKlPNLOl0vfLZC8RtGEBgqQlLUkBjZ6gqHlWPQlPVq2cRrBEJQFWYaSjc5e9q+UoiqjG2Fpn5M28EVmtDVW9LMI1AshEaQJilOnUa0UITQ7m0+gMjkTiu4i40RBIaK4E9yrn9hRMfanQ+X4LYS/AvFwK++GecsJk9QFWQach2MSXPypvYRuNIoY4U1grRahW+jLm2X4EUNlUGY+89Qcr2kYptkVEGQtHe/6F5Rm5EaIwgMFSFJIzh6Ci/P3NIUrnMvtillXyJG68dMHRVaJipEWkReJ1OIRvARd5+JpqGUJ+hIUUOqRpC2XUKQJc190FcyZYyOEaahrp7iFs5LgyrkU5uGjLPYUE2IBz7qwf/C4RNx1t5jtTNflcOs0FibwazvHI2hDWHzTWNtBm1dORD5nUxdAT6Ca07bFZcfu0vIsatSaNSQRUGNYNZ3jk48hiBNAl0xyNql1+YEwjSURiPoM+75CDk6uD6Lpy4/HL9+/J1UEUSes3ig5REYDHFExZMLiChy+kO/0FtpXxp5/mCZRjeGnMifDrEQjSBrWxjRpN+3TPqoIX8UL3f8Ue3XITS0UgsCb0rKMvoIKqERAEDriMbA/OFxCAFZqfBRYxoyVAQ7wTQUhz8ZTDFblJ4m12zUlXO86RDlGc2KRdrIGlkjKDQeXpD1Rs9lMg2VQxC4QrEzxdzFpSbpXlbaNGQEgaEipJl8PApvDoCSegmiET6C9s6cJwgK0QiKjdAI+tK3CtNEXAJdMUhbXK4YlFMjEKejmzozDYXO2VxsjCAwVISmWj6qFmaWQqi0RrDX+CEAeK2g8cN4ueIdRxQ3K7YQhGWoL4Jx51HNAIDth6SbhL63RJWhLgU7tvB7MmF4fEnpYhB1OmnFgig6V+qEviiMj8BQEQ6cOBz3XHIAJo1sDvz+zDeOSBxdixC7SgmCrxy9Mw7bpQV7jhuCPcYOxuTRzZjROqwyjYEf6ZP2ejz3rSNCI89P7DsOO49qwt4Thha7eQGyZXSKHjl5FO655ADsNT76nGZ+5yhs7Sqd6ShtEFY5r4sOIwgMFcGySNt5jk8xevM0ggqZhmyLsPcE3nYi/XmUE9HZpDW36CZdKdd5+D6Ckh8KABLPaWRzHdAcu0phRHT8ieGjmfIk9EVhTEOGbY5Km4b6GyKPoJLzS6TFm6u6Qh1eqRCDkt662o2z2GAokHIklG1buKahCrciDdkyRg31B9I6j2siqrKWCyMIDNscvkYwMDuTpIxjldGDuYM3aaKb/kBNxgJR8Yq89RdEvoCaUdzi5osMb6yJ3V6EuhZaBbVYGB9BlXP/Fw8K1afp7wx009AjXz0UC1e3p17/uydOxT6tw7DfDtwe/ujXDkV7V65UzesTDTUZ3PypvSvuVyk215w2zQsgkLngwFYMa6zBae480FGcvc841GYsHLfr6BK2MhpiJa4tUmxmzJjBZs+eXelmGCrI0vVbccjPnsSgugxev/rYSjfHYNgmIKI5jLEZumXGNGTY5rDKGItuMFQDRhAYtjk8Z7GRAwZDUTCCwLDNYXt5BAaDoRgYQWDY5qABHjVkMJQbIwgM2yxGDBgMxcEIAsM2h19t04gCg6EYGEFg2OYQAc9GDhgMxcEIAsM2h1922WAwFAOTWWzY5hg1qBYXHNiKj+8zrtJNMRgGBEYQGLY5iAhXnzKt0s0wGAYM/cI0RETHEdHbRLSQiK6odHsMBoOhmqi4ICAiG8DvABwPYCqATxDR1Mq2ymAwGKqHigsCAPsCWMgYe58x1g3gbwBOrXCbDAaDoWroD4JgDICl0vdl7m8eRHQxEc0motlr1qwpa+MMBoNhoNMfBEEijLFbGGMzGGMzWlpaKt0cg8FgGFD0B0GwHIAcBzjW/c1gMBgMZaA/CIJZAHYioh2IqAbA2QD+XeE2GQwGQ9VQ8TwCxliOiC4F8AgAG8BtjLE3Ktwsg8FgqBq2uakqiWgNgA96ufkIAGuL2JxtAXPO1YE55+qgL+c8gTGmdbJuc4KgLxDR7Kg5Owcq5pyrA3PO1UGpzrk/+AgMBoPBUEGMIDAYDIYqp9oEwS2VbkAFMOdcHZhzrg5Kcs5V5SMwGAwGQ5hq0wgMBoPBoGAEgcFgMFQ5VSEIiOg2IlpNRPMr3ZZSkHR+RHQOEb1ORPOI6AUi2qPcbSw2ae8pEe1DRDkiOqtcbSsVac6ZiA4noteI6A0ierqc7SsFKZ7twUT0ABHNdc/5wnK3sdQQ0TgiepKIFrjn+JViH6MqBAGAOwAcV+lGlJA7EH9+iwAcxhjbDcA1GBhOtjuQcE/duS5+CuDRcjSoDNyBmHMmoiEAbgRwCmNsGoCPlqdZJeUOxN/nLwJYwBjbA8DhAH7hlqoZSOQAXMYYmwpgfwBfLPacLVUhCBhjzwBYX+l2lIqk82OMvcAY2+B+fQm8sN82Tcp7+iUA9wJYXfoWlZ4U5/xJAPcxxpa462/z553inBmAZiIiAE3uurlytK1cMMZWMsZecT+3AXgTSqn+vlIVgsAQ4DMA/lvpRpQaIhoD4HQA/1fptpSRnQEMJaKniGgOEZ1X6QaVgRsATAGwAsA8AF9hjDmVbVLpIKJWANMBvFzM/Va86JyhfBDREeCC4OBKt6UM/BrAtxhjDh8sVgUZAHsDOApAPYAXieglxtg7lW1WSTkWwGsAjgQwEcBjRPQsY2xzRVtVAoioCVzD/Wqxz88IgiqBiHYHcCuA4xlj6yrdnjIwA8DfXCEwAsAJRJRjjN1f0VaVlmUA1jHGtgDYQkTPANgDwEAWBBcCuI7xhKiFRLQIwGQAMyvbrOJCRFlwIXAnY+y+Yu/fmIaqACIaD+A+AOcO8NGhB2NsB8ZYK2OsFcA9AL4wwIUAAPwLwMFElCGiBgD7gduTBzJLwDUgENEoALsAeL+iLSoyrv/jDwDeZIz9shTHqAqNgIjuAo8oGEFEywB8nzH2h8q2qnjozg9AFgAYYzcBuArAcAA3uiPk3LZetTHFOQ84ks6ZMfYmET0M4HUADoBbGWPbdMh0ivt8DYA7iGgeAAI3Bw600tQHATgXwDwies397duMsYeKdQBTYsJgMBiqHGMaMhgMhirHCAKDwWCocowgMBgMhirHCAKDwWCocowgMBgMhirHCAKDwWCocowgMBQFImotpMw3EV0iauEQ0QVEtL20bDERjdBscwER3VCcFlceInqfiHZRfvs1EX0rZpt2938rEX2y1G10j/VVIjqPiM534/rlZSOIaA0R1RLR34hop3K0yVBcjCAwVAQ3AepP7tcLAGwfs/pA5W8AzhZfiMgCcJb7exKt4NVGSwoRZQB8GsBfAfwTwDFu1rLgLAAPMMa6wAv8fbPUbTIUHyMIDEWHiHYkolfdSWEmEtHDbjXMZ4losrvO1UR0uTthzAwAd7oTqtS7u/kSEb3iTqYzWXOMFiK6l4hmuX8HEZFFRO8SUYu7jkVEC8V3zT4+SkTz3UlNnnF/u4CI7ieix1zN5FIi+rp7Pi8R0TB3vaeIaIb7eQQRLXY/t7rn+Yr7d2DMpboLwMel74cC+IAx9oF7zPnu31c1214H4BD3mn0t6rjuNbiRiN5yz+kh95qDiPYmoqfde/MIEW2nOc6RAF5hjOXcQmdPAzhZWn62ex4A8CyAo13hYdiWYIyZP/PX5z/wEep88FovrwLYw/39CQA7uZ/3A/A/9/PVAC53Pz8FYIa0r8UAvuR+/gJ4qQSAaw43uJ//CuBg9/N48DosAC9B8FX380cA3BvT5nkAxrifh0jHWAigGUALgE0ALnGX/Urat9dm8KJ2i93PDQDq3M87AZidcN3mS9fqJgCXglcQnQegEbzG/hsAprvrtLv/DwfwH2k/2uOCj9gfAh/0jQawwf0tC+AFAC3ueh8HcJumfT8Q90La3z/dz9uDl3+2peWPAdi70s+j+Svsz0huQzFpAS98dgZjbAHxsrkHArib/FLQtSn3JSoszgFwhmb50QCmSvsd5B7vNrcNvwY3adwec4znwevU/EM6HgA8yfgEIG1EtAnAA+7v8wDsntDuLIAbiGhPAHnwOQLiuAvA2UT0BoDTwAXZ2eCd7RYAIKL7ABwCLmALPe7BAO5mvEb/KiJ60v19FwC7gpdtBgAbwErNfrdDsHDdg+A1qwYB+Bi4oM1Ly1eDC4g5Cedt6EcYQWAoJpvAq0EeDGAB+Ch0I2Nsz17sq8v9n4f+ObUA7M8Y61R+byeiD4noSAD7Ajgn6gCMsUuIaD8AJwKYQ0R7K8cGePG2LumzaEsOvmm1Tlr/awA+BC//bAFQ26fyN/CpNJ8G8Dpj7EPq3fwJhR6XALzBGDsgYb0OSOfHGOtwC9udDi6wvq6sX+duY9iGMD4CQzHpBu8gziOiTzJuU15ERB8FeDldItpDs10buCmmEB4Fn4oS7r73lJbdCuAv4CPhPCIgoomMsZcZY1cBWANgXAHHXwxuwgG4uUQwGMBKdwR+LvhIOxLG2HsA1oLb/GVb+2lE1EBEjeDX9FllU/WaRR33eQBnur6CUeAmJQB4G0ALER0A8Hr3RDRN08Q3AUxSfrsLXACMAvCismxncHOXYRvCCAJDUXHNGScB+BoRnQI+Iv8MEc0Ft3WfqtnsDgA3Kc7iJL4MYAYRvU5ECwBcIi37N7htPc4sBAA/d53R88Ht5XNTHhsArgfweSJ6FdxHILgRwPnu+U4GsCXFvu5y170PABifn/YO8MlVXgb3kahmodcB5F1H99dijnsv+IQ1C8CF4ysANjHGusEF2E/dbV4DN+Op/BfciS3zGLj55++MMa98sStoOhhjq1Kcs6EfYcpQGwYcbjTPrxhjh1S6Lf0BImpijLUT0XBw4XJQIZ01Ef0TwDcZY+8mrPc1AJvZAJrro1owPgLDgIKIrgDwecT4BqqQ/xDREAA1AK7pxYj9CnCncawgALARwJ8Lbp2h4hiNwDDgIaLvAPio8vPdjLFry3T83RDuILsYY/uV4/gGQxJGEBgMBkOVY5zFBoPBUOUYQWAwGAxVjhEEBoPBUOUYQWAwGAxVzv8HqupcFwlkOgEAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "do0d(keith.smua.fastsweep, do_plot=True)" + "fastsweep_meas = qc.Measurement()\n", + "fastsweep_meas.register_parameter(keith.smua.fastsweep)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We can likewise do a VI two- or four-probe measurement " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting experimental run with id: 155. \n" - ] - }, - { - "data": { - "text/plain": [ - "(results #155@C:\\Users\\Farzad\\experiments.db\n", - " -------------------------------------------\n", - " keithley_smua_Current - array\n", - " keithley_smua_vi_sweep - array,\n", - " [],\n", - " [None])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "keith.smua.fastsweep.prepareSweep(0.001, 0.1, 500, mode=\"VI\")\n", - "do0d(keith.smua.fastsweep, do_plot=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting experimental run with id: 156. \n" - ] - }, - { - "data": { - "text/plain": [ - "(results #156@C:\\Users\\Farzad\\experiments.db\n", - " -------------------------------------------\n", - " keithley_smua_Current - array\n", - " keithley_smua_vi_sweep_four_probe - array,\n", - " [],\n", - " [None])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEXCAYAAABlI9noAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAC0PklEQVR4nO19d7xlV1X/d517X5mWmUkyqQQSIAFCMAkkiFKlSRUUEVGRCIgIClh/wA8FFRQRafITpAQSRFApAtJrqAlMQiCkkQ7pmZlMZubNK7fs3x/77HPWXnutfe689+6bdtbn8z73vnvKLmefVb6rbHLOoaWWWmqppZaWg4q93YGWWmqppZYOHGqFSksttdRSS8tGrVBpqaWWWmpp2agVKi211FJLLS0btUKlpZZaaqmlZaNWqLTUUksttbRs1AqVlg5KIqJdRHTPvd2PfYWI6FIietSI5zoiuvd4ezQ6EdE/ENHL93Y/xkFE9CgiunHEc/+YiP5x3H1qolaojJmI6Hoimi2Z2K1E9AEiWrsC7d5ERKuI6NFE9HFx7O+I6BIi6hPRa8WxRxHRsOxv+HuuOOc3iehyIpohomuI6OEj9ukDRLQg7v3DJQ92EeScW+ucu3al2y3Xw2Mzx0dmIqPecxRyzt3fOff1pdxjbxARbQLwuwD+bW/3ZR+g9wD4bSI6Ym92ohUqK0NPdc6tBXAagNMBvHKcjRHRcQC2OudmATwIwEXilKsB/CWAzxi3uLlkuuHvHHbvxwH4RwC/B2AdgEcA2BPm/EZx71P34NolExF1V7K9fZ0OgPk4C8Bny7V+UJNzbg7A5+CF7F6jVqisIDnnbgXwBXjhomqlXOskotcS0X8R0blEtLOEKM4YoakzAFzIvkdCxTl3jnPucwB2LmIYfwPgb51z5zvnhs65m5xzNy3iPhER0bOI6DoiOqT8/4mlZbep/N8R0UuJ6Foi2kJE/0REBbv+eaX1dCcRfYGI7sGOOSJ6CRFdBeAq9tu9y+8fIKJ/JaLPldbTt4noKCJ6a3m/K4jodHa/Y4joY0R0R9nnl7Jj5jMjog8CuDuAT5ft/KWYgzXwTOEYZskdU/bvdey8at1Y9ySiXynb3k5EXyei+7Hrryei/0NEPwIwQ0Rdse4eTETfLa+9hYjeQUSTe/g8p4joTUT0UyK6jYjeRUSrymOfJaJ/Zud+hIjOLr+fVc7/O4jornLuH5Np6okAzpNzQ0R/RkS3l/3/PXZ8ffls7iCiG4jo1XwdiTE8mIg2E9GOcgxvZsf+u1yfdxHRN4jo/uzYnq6n64nolUR0WXn8/UQ0bfTJXHslfR3AkzPzNX5yzrV/Y/wDcD2Ax5bf7wbgEgBvK/9/FIAbM+e/FsAcgCcB6AD4BwDnZ9p6DYDt5TW7y+8DAHeV3zvi/H8H8Frx26MALAC4DcB1AN4CYE15rFMeewW8tXMjgHcAWDXiXHwAwOsyxz9UnnMYgJsBPIUdcwC+BuBQeCb6EwAvKI89rezP/QB0AbwawHfEtV8qr13Ffrs369cWeKtuGsBXy7H/bjnm1wH4WnluAS+w/xrAJIB7wltqvzzKM+PP15gDbU1E8ybPkfcEcBKAGQCPAzABb5VeDWCSnX8xgOPYfFT3KOfhIeVcHg/gcgAvF/N574Zn/RYAnyrnfB2ATwP4h/LYUQBuB/BoAL9dzt+68thZAPoA/qTs+7Pg1++hRjt3ADhTzE0fwN+W1z8J/l3YWB4/F8Anyz4dD7+Onm/c+7sAnlN+XwvgIezY88p7TAF4K4CLxfMaaT2xuf9x+TwOBfDt8Lz5s0bD2ivPeSCAbSvN56J525uNHwx/5YLZBW8VOABfAbBBLhhxPhcqX2bHTgYw29Bet2QCRwL4RQCfyZyrCZWjynYKACcA+AaAfyuPHVOOYTOAowEcXr4Arx9xLj4Az3C3s79z2PENAH4KL3j/TVzrADyB/f9iAF8pv3+OM4ay77sB3INd+2jlflyovIcd+2MAl7P/HwBge/n95wH8VNzrlQDeP8ozw8oIlb8C8F9iPm4C8Ch2/vOsdaf06eUAPqHNnXE+wQu1e7HffgHAdez/ZwD4GTzzfRj7/Sx4hYLYb99DydyVtnoA7ivmZhZAl/12O7yQDErRyezYHwD4unHvb8Bb5oc3rOsN5Zys39P1xOb+Rez/JwG4Rj7rprVX/n8igMEo7+O4/lr4a2Xo6c65dfAL5L7wzHhUupV93w1gmhQcnIhOI6LtAO4EcG8AV8Jr9o8qYYxfG6Ux59ytzrnLnIe2roPXcp9RHg649b84525xzm0B8Gb4l2BUepNzbgP7q4IAnHPbAfw3gFMA/LNy7c/Y9xvghRwA3APA28pxbgewDZ6xHWtcq9Ft7Pus8n8IrrgHPDy1nbX3KnghHmikZzZGOgZ+fgAAzrkh/PhHmg8iOomI/reEd3YA+Hvs2ZrdBGA1gAvZHH2+/D3Qp+GZ/JXOuW+J629yJYcsiT9rSXfCWwyctjrn+uz/3fDP73B46+UGduwGxPPC6fnwVt8VRPR9InoKABBRh4jeQD5IZQe8UADiORp1PQWy1janUdbeOnjLbq9RK1RWkJxz58FrMW8qf5qBf/kA+MWK+MXbk3tf7JzbAOD1AP66/H4ZgFNL5v3x3PW5W6NcJ865O+EhLyeOLwsR0WnwsMKHAbxdOeU49v3u8Bot4F/IPxDCapVz7jtj6OfP4DVu3tY659yogrWpH9rxaJ3AW5O5a26GZ0AAACIi+Lm7KXMNp3cCuALAic65Q+AZF+W7HdEWeMZ5fzZH650PVgn0eniL+mgiera4/tiyz4H4s5b0I3jGP2q/emBzU95b9Qk6565yzj0bwBHwwSkfLf1evwUPuT4WwHp4GA3YszmSZK1tTqOsvfsB2CsRlYFaobLy9FYAjyOiU+Hx3GkiejIRTcD7AqaWeP8HAbiodKwe45y7Wp5ARBOlI7AA0CWi6VKggYh+iYjuQZ6OA/AGeAw60PsB/DERHUFEG+Gx7/9l93Y0Yr6D6NM0PBz3KvjIsmOJ6MXitL8goo1lv14G4D/L398F4JXBWVo6Y5+5p30Ykb4HYCd5R/eqUms9hYjOHPH62+Cx8Nzxw4hoPfvtYgBPIqJDiegoeDgqd8//AvBkInpMua7+DMA8gO9gNFoHYAeAXUR0XwB/OOJ1ACrL6D0A3kJleCsRHUtEv1x+fwT8M/5dAM8F8C9ExK2FIwC8tFynz4RnlJ81mvssgEeO2K8B/Ny8nojWkQ/m+FP4dZcQEf0OEW0qx7O9/HkIPz/zALbCC/u/H6X9BnoJEd2NiA4F8H9Rr21Oo6y9R8LDwXuNWqGywuScuwPeWfjXzrm74H0D74XXlmbgLYGlUAghfgC880+j98Brks+GX8CzAJ5THjsdnvnMlJ+XAOARJn8H4PvwAvFyAD+A1zpDKPPO8hqL/pLiPJUt5e//AOBnzrl3OufmAfwOgNcR0Yns2k/COyovhg+Hfh8AOOc+Aa9JfqSEI34MHxW07FQypqfAR/BdB6/9vhdeYx2F/gHAq0v44s+V+18Bb6ldW55zDIAPwmuf1wP4IlKGE93TOXcl/Pz9S9m/p8KHtS+M2Mc/h9fGd8KvFY3BNdH/gQ8OOL98Jl8GcB/y0X3nAvgj5yMHvwn/HN/PrJML4H0DW+DX1q8757Ya7ZwLL3BXjdivP4Zf29cC+BaA/wBwtnHuEwBcSkS7ALwNwG86H7p8LjxEdRM8GnD+iG3n6D/gn+21AK6Bd+ZH1LT2SsXsSQDOkdeuJFEMXbbU0uKJiH4HHvJY9jwcInLwcExiebV04BARnQUf1fewPbjm7wHc7px767j6NU4iouvhx/zlJd7njwEc55z7y8aTx0j7e+JTS/sQOedUGKGllsZJzrlX7e0+7AvknPuXvd0HoIW/WmqppUUS+eTKXcrfb+/tvrW096iFv1pqqaWWWlo2ai2VllpqqaWWlo0Oap/K4Ycf7o4//vi93Y2WWmqppf2KLrzwwi3OOTWn7qAWKscffzw2b968t7vRUksttbRfERHdYB1r4a+WWmqppZaWjVqh0lJLLbXU0rJRK1RaaqmlllpaNmqFSksttdRSS8tGrVBpqaWWWmpp2agVKi211FJLLS0btUKlpZZaaqmlZaNWqLS04jQYOnz9ytv3djdaaqmlMVArVFpacfq3b1yDs97/fXzl8tuaT26ppZb2K2qFSksrTj/b5re6v3XH3F7uSUsttbTc1AqVllacOuWqGw4P/ArZf/U/P8Zf/Y+1Aef+Rf/zg5vwlH/55t7uRkv7OB3Utb9a2jvUKXeN7R8EQuWD5/sSSX/39FP2ck+WTi//z4sBeJ9Yp6D8yS0dtNRaKgcZXX37LtyWgZ0GQ4fvXmNtB748VJQMabCfCJVLbrwLO+Z6e7sb+wwt9Id7uwst7cPUCpWDjB775vPw83//FfP4u79xLZ79nvPxjZ/cMbY+dPcjoTIcOjz1Hd/CWWd/b293pZH6g+FYIcVgncz3B2NrAxj/OFoaL7VCpaWIbtg6AwC48c7ZsbVRWSr7wa6jCwOvlV/00+17tyMj0NP+37fxzvOuGdv9g1CZ643XUrn3//0cXnBuuyXF/kqtUGkpoonSi94fjo9xBEtlf9BGe4OVgXpecM5mfP7Hty7pHjds3Y0b79y9TD2K6U1fuLKCvcZtqQDAV69o85j2V2qFSksRdTue4Y8TN9+fHPUr4T/oDYb48uW34UX/fuGS7jPXG4wNUnzH166uvs+3PpWx049u3I7PXXLL3u7GoqgVKi1FNFlaKr3B+Bh+sR9ZKgsrYKnsXli65t8fDNEfuhUR1PNjhL/cfgCJrgT9yju+jT/80EWN5117xy5s2TW/Aj0anVqh0lJEE5VQGT/8tV/4VFZAK59dBqEyV/ZzJYIfxgl/tVbQ6OScw6P/+Tz8+ju/s7e7ElErVA4wumt3D49/y3n4yW07F3V95VMZo1AJlkoLf3navdBf8j3mep7Rr4xQGd+cjNMKWml62Ud+gHO/e/3Y7n/DVu8/u37rePxoi6VWqCwjffvqLXu9ntV5V92Bn9y2C2//ylWLun6iW/pUxgh/BZ9KC3954vDXzkXmw+SESm8wxFu+9BPMzNvC64Jrt+LTP7x5j9oaB80t0Qq68IZtI49j3PTJi2/GX3/y0rHd/6Kf3gkAOHr99NjaWAy1GfXLSL/93gsAANe/4cl7rQ8BkyZaXMbzRDF++KtT5amMrYllo5WxVGpGun13D+umJ/b4HiHMVxMqn7r4ZrztK1dhx1wPr3nq/dXrn/Xu8wEATz31mMa29mVL5Rnv/C6A0caxWNqyax675vo4/vA1Y2tjFLr05h0AgLttXLVX+yGptVQOUFpsEY0JFv01LiilFio2AxkO3T5hyaw0/LVYSDBnqQTf1Y7ZZpht++6FxnPG6VNZqqUSaCkO/zCH1vr/xX/4Kh71pq8v+v7LRVffvgvAvlfhYK8IFSI6joi+RkSXEdGlRPSy8vdDiehLRHRV+bnRuP655TlXEdFz2e+vJ6KfEdGulRrLvkqLNFTQLX0qHzz/BtzrVZ8di2DpjOCoP/P1X8bD3/i1ZW97T2kl4C/uqF+sLyswek0oTY4QfBHOCYwq29YY/R7LBa0tNqLu6tt34V6v+iz+5tOX4v6v+Ty2KpFVo6yJlchvCs9qdoxw5GJob1kqfQB/5pw7GcBDALyEiE4G8AoAX3HOnQjgK+X/ERHRoQBeA+DnATwYwGuY8Pl0+dtBS8MlRlQFSyXQOBZsECrfvGoLXnDOZtUi2TqzgJu2jy+rf1RaCebAGaBlqXz/+m14wTmbTSEf4C/t+Y8S0XfPTR7KecG5dhuBxgl/LVe2/raZZotLo0tvvgsA8P5vX4+53hBbdtn3eePnr8CHv/dT9dhyCUfrWexe6FfvRytUADjnbnHOXVR+3wngcgDHAngagHPK084B8HTl8l8G8CXn3Dbn3J0AvgTgCeW9znfO7Z8ZQ8tEIb9ksfAXiSvnjQV75a078bELb1xSGzds3Y0vX37bWF6K2YUB3nXeNUu2tEaBFs75zvXZIp1NtLvHLRW9vy88dzO+fPltJrMMTEy7PigKn/vxrbhuy4x6/bEbPC6/fXevEQLTGOZg6PCvX786GwwwCi0VWgtj3dogVD57yS348U13KdfHLDEniP/169fglR+/RD22XMLRan/nXD3Pswst/BURER0P4HQAFwA4kgmFWwEcqVxyLICfsf9vLH8btb0XEtFmItp8xx3jK5q4tyi88E2O+p9t08MQpaY7ZzDVX37rN/Bn//1D8/7bdy+M3MY4rIG3feUqvOFzV+DjFy1O8AVq0spv2zGH13zqUjz/nO9nz7th64xZ6Xg28qno7QVhYTHdylGvWCqT3fo1/5V/+ZZ6Pb+qSchrc/K1K27HGz9/JX7rPefje9dty16foyZmfOnNd2X9JRtWTwIAvnVV/t1+8YcuwlOUueiKkv6LXZujWCrDoassI4us9sMUrJ7sjDUabzG0V4UKEa0F8DEAL3fO7eDHnF85yw7oO+fe7Zw7wzl3xqZNm5b79nudRl1glr9CTrh2P/5SWy/4P3/xJ3jO+y4YqY1xOBpDv3fMLU1zbupbeOmv35LPFXjkP30dv/r/vq0eGwX+6pXCZmbeEiq2o36Sad87DUuCP8emNaQJtjVTPpD0hzfehd/4t+/ilrts6DInFHJtf++6bXjy27+F933rOvOcjat95NybvviTRW1XkFoqSwucyNE7vnY1nvz2b6kWUyDLcg2K2erJDmZ7A3NOnXMrXqVgrwkVIpqAFygfcs59vPz5NiI6ujx+NACtqtxNAI5j/9+t/O2AoXO/ez2Of8VnsGsRUMJSTeHEUlFeDl7B2GKC23Yv4KfbduualmhjHM7woJ0v1QpqYipBsx7lWV1zhw49xY56vb3w+4yRKDmXcdSPEl7OL2taQ5qjfnoiZiV3zaYM/az3fw/Hv+IzOOGVnzUhNr7epK/tpu1ecF+SYcIbS0sFAH7utV/Ed67ZYp6rUbezZ5bKoWsm1d9Hgb+CRZeD6nqG5RpmZvVkF4OhM9fpCa/8LF71CR2iGxftregvAvA+AJc7597MDn0KQIjmei6ATyqXfwHA44loY+mgf3z52z5DT3vHt/CZHy3etfMvX/XF+7ZlnIQWBeYyCjPVrZD4fw3q4Li+BQ/N9wYYOuDWu1Jfg+R747BUArb+hs9dkdUEm2ihAeNfDughtlQM+KuctN2KpfKBb1+Hf/2aL3mvBT2MoqlyZaIpw18L+5UtaKVnvn5lDUl9//o71Xvz9SSVjW6ZQ3XVbbvwwnM3q3MfLKZA510Zw2C9wRAv+qBduDO0YfVB0lRXZ6Gj+AnDOTI4hpNpqQxrS6WpvQ9/72fmsXHQ3rJUHgrgOQAeTUQXl39PAvAGAI8joqsAPLb8H0R0BhG9FwCcc9sA/B2A75d/f1v+BiJ6IxHdCGA1Ed1IRK9d6YEBHgL44mWLL2O+o9TydvcWY6n4xTWKpnSnoi2OAn9xrdxiqqF9LYJLMrlxWCocxnjxCIX5LOJ908J9l0OocOe2tDTm+wOczeAezVJ57acvq+ZZs1T2NFahiSHuUiBF+Uyb1l/IBpfE51MqLOGZXnbLDnzxsttU3420tNdNx0Lm8lt24POX2u9mYqksUuEZZV2EdzWnVH31itvVuQrDDELUCp7YG7RXMuqdc9+CHaD0GOX8zQBewP4/G8DZynl/CeAvl6mbS6KdS8Dyw8ukvbzN1w6izxxtm1nA0evjbFzJHDSog4/NslTCIr9ZESorY6nUQmUpEUULQnPusvs655ZkBQXiQlpqpu/95nX4py9cWf3fFF2lWiojuCaHzmHNZAczC4NGhqjBNdIYakpitPJh+Hryz62uLiA1+knFSnDOnxfgIFmdYHqik+2X8NM3JqNaRuAoQiWckzv31f/zYwBplY7wTCtLRbEM+bqf7w8w1c2Pfblor0d/Hai02BpOnBbnU2leqIHunEn7mDAH5T6csVkhx4Gp3KTsILkSjnoOSyzl/pFQEff5xA9uwms/fVn1/2LDaXfN97G21DhllQEJY840JPVp8NkoCutwCKwu+9BkqWgWbmjj1U++HwBgrqGf1vrkCouc707RLFSGzmH9qlqQrBVw2GQnz/LkXDXByJaVvSfw12ISNUM/c/AXtxZ/uoJFJ1uhMibKlcR45ccvMQtPck1TCpWfbduN533g+/ifH9yEP/7wD1SsPCykURLUtqnMQcIv6X14v2yfiv/9ZiUKaE/grye+7Zv4ggFXfPqHN+OvSk1OErdUlpIzwAtryrFeJbTtxSbczcz3K0YoHa6SKe5uEFwa5DGKT8XBWypAs6NeU0bqaKQSjlmkL+p6lkcj57tJIABeKTqECRUpeGTMgrTs5FQ1KSSWUjVK1YEgCJoEkDbuMN9ryvnWBBO3VEaplLBc1AqVMZFmqQyHDmd/6zp8+Hs/xfPP0ffg5pi51Hy/edUWfPWK2/Hy/7wYn/7hzSpDDy/zKJbKNqUExSiWyihCpbJUtqeO+j15cS+/ZQfO+4mec/CqT1yCD55/Ay64dmtybBT467vXbMV3r0mvtfomn4dk+JoGPwrtnO9jQxkKKy0N2UaTpaLlqYwSUTp0tUBoctRrwtNJzblBMFmC/totNfNrslQ0J7aDwyEM8pJKkpS50kclBXBT9J+mEDnn8K7zrqn+t3wbAVVo2k/nyPVTShv+87C1PvpM26iLz/FfffJSteTMOKgVKmMizafy1Stux9/+72XK2TXxhSDvwc16f266GPfEUa/1MbyE9z1qndnGHjnqlT3TJcbfpA1avqUzjz8UAPC1K1Ohw/F3C/559nvOx7Pfc35Wi1sY1OOTOS+S4S/WUtk1x4SKtFSm99BSMRht9L8qeFwlEJoUktneIGGE4Z6rMvfgYceWY/n6Lbtx4hFrATSvCy1wYjiUz14Klfh/mfezp/BXb+ASoXH7znlcyywubRzDoasUsqb57igh4WG+jzt0NQAdZub33bJrHh+6QC8ps9zUCpUx0c75frLYRqnLxReChL/SHJJ0sY66UIE87HTO83wJNS2jfmYUS6Vy1M8lTCyxVBpeXMu3FO57x85UA5NabY4e++bzTIgot9fJYiwVjRHOzPerTHDpGJYhrlaeSiDNUpFuFu2ZOeehok5BI/kD5Fglxq/BX2unaqVIO37z9lksDIa4T6nQyH4mvjjNSoCL8nLkKfI575qPn6kUwKOE5kuhId97Tahw6Fmbby5HVOuz/Dx0zSSmJwo1ylLyACunZrmpFSpjJMkMgxaXI74QJNwihYq2GMM5IwkVTYMqrw9RMho2zC0HE1PuDzE9UWC2N8D23fGLu6fRX5alEoTq7TubIbYm0pL1AOCW7XNYVwoP6SdbLZ7nNsXXIEnCV8Ohw8zCABtWBfhLdjz+vymqUINa5LrRhPTQOXQKwqqJzkgJtNIqC8w4rBvNUb92qp4vrY2flVbtvQ1LRY5Dg7+GLo7gktfIdSGtT3l8lIx6q5+hnpom/G7fUStC/+9r1+Bzl8R5bbxcjPYOhjYKIhy7YZVqqQSh/I/PeACAMZQnMagVKmMkqdmuEuGMWvgntz7kyz+KvyMstt0LdumGQJbGCvhFPdEhVaPcOd+vIAbtHsOhw0J/iKMO8TvSbZ9dmjZoWSrBV6JZKpKZfOIHaQ2wU++2vvr+zHd9V/Ul3LR9Fvc92mvO8nnyFjoF4c4R4C/ZRrA8avhLMqj6+32OXNdYuFILgZW/aFFq4bJVZdkPiwKvk47hcH1BHubSLFwezqspI4ExnlBufiV9YXI5a5FuzjkQCO9+zoN8vxK0ID5/h1ybewh/5fqZEyp3CP/GJy+Od6vklrb+jvnPgoBjN67OWiqHrZkqr1kZsdIKlTGS1Cq7IopDi76ajeAvsVgFe1AtlXKx9Rlma5EOH3gqiDDd1YvVzcz3K1NaOx7a3bTOL+aEGe+ppWIIldpSUQIOxP9fvjyt+ONQC/qrbt+VJNMNhw633DWL+x19CAAktaS44Nq4ekJ9npIkhh/GtmGVn09pafC5ut/R61SNlNMo0V/afDr4Z+4tFdsaqiyRnmSkvg2q7pGui7BmHnfykaqyEhhjECpyXaSwqR6UUBTAqcdtAJAKEalsSAt1McVO5XsW7jFV+pC09X27UA6OElsCc9hTCzQJvICIsHH1hFrnLLwfwaJe6rYYo1IrVMZIUiuVD1VzEGfhr6F9rtZGU55LDv4i8i+F5reZ7Q0qJqhGoJX9qoVKPsKmSfiZQqV82bbNLCgMqG7jnoevMcfKX2ZeNwrwwqo3cDjxyHUoSBtH/X3D6smRdk2UzDZAe+tX6yHF/Hked+hq3LpjLsvodKES/68VpXTOoSAvZHOWii1U/GdBhOkJXRlxDjjz+I14wLHr0Ru4xCq76c5ZHLFuqsoSl0pPCn/pz5RAlU9C+iOahMoofhtJqVDxn2GuVKEiFCEpVDiEN98fmn5Jgg851jL/gzBaXeVAtUJlvyfJIOTC+L5SZiK8jKsmOomGkuSQNER4SV9Ekh+Sgb+IgKlu2gffD2B1iY/nwpo3rfVCpQliaHTUG34EPn5p/vM21k53jQgc4Ih1dbimZEC3ltrkMeunsXaqm4yDP491092RqijwaDKg9rGEMFiZ/Mh7dOyGVWY9tWoMI5Rp0eEv7+CenuxgNrOupsu8Dyl4KmUEtmAKTvQQBSYhstt2zuPo9dNV4qpc33JkekixX7shYqopSET6++T5WhuyPL71noZxqI76mYUqLwio57VqI6rcoPES/1kQYaJbqFZbmL81raVy4FAa/VV/JwI233Bnck14GTesnkisBLkmLEd9WPRNPhlN461gDBCmuoXqqHTOVbCRJnTCYrYslTAPm1/9WN+Pfn6xLwyGajtzvQHOPN5v+rn5egFdsVtOG8LRIS7jITHnoAlPdgscsmoiKzTWTU+MVGZ/QYw1rJHAaC1F5OMv/kUcu9Fj9FrpG3k/ToGZvP5XTwFgwF+lg3vVRJHNhrcCODiTm5roqBZucKJb1s5gOMREp6gSFucbLBVNGfFtEIpSqDRFYCaWygjviIwsTKLUZLCLsvYGQ4cJJkikLyxtwxDiVFoqWl268ppVlVBJThkLtUJljCQfNGda9zh0tZogGV7W9asmkpdulLL0Q1cX0UuESvl5/GGrcb+jD8laKgX5BEKtSu/QuWx0WGWplEJF4r0BDz509SQ6BSXau0aatTLfH+KUY9djw+qJxB/C/U+T3cIYq0OnAF78qHsBSF/sIWOUXmjolsqbf+NUb6kYEWScJCMMDKhTEDoFmT6VjasnWbiubUnkHPXHbfQ5DVpAwtB5fH71ZDcLf002WSrBUW/swxN8dUAKBQ6HtYUMpM781IowHPUEFIUuVPgt1k11U0tF2EPnfveGZLM5aamk0V/+87DSh3Tnbr0CQUGE/37RL1T/c5K5KZbfpiAqa53ZMHRIam3hr/2QQrTHvzz7dAB5S2Xd9IT6kGNLRTrqPT3g2PXRuXEbripTIWGO8FL+2gPvhumJwtT0AM9gJg1LZTgM2iDwoQtuSDT8oKWGqBPLFxG0rFFqc2l+gLneAKsmOjj+sDUVVCXHAZRCxcDfCyI88qRN5bh0rZaCBm9o5w+6x0YcMt0d0VLRGVBBXqjI/TM4rBS07yYYIy094v+vlQ2d4eegq0CWlTFkz3TKEOLBipie1DX4AMFVsFEigOP7qQLU1XOpXcPn7ohDpnDXrMi3UZbi6z4TJyw3Wyrh/t5PYkUnFlS/y3J5NrZRflKp/OlCRTjqW6Gy/1FRAL92+rG45yYfvZJAGUwLWjfdVZOawsu6YdWkqZ28+TdOLc/VLQ3LUuFhn5OdQg8pRs3EJjpkOrgL8hEqW3YtRKU1AODCEtY7ZsMq74tIor8CsybTipAkk/76gyH6Q28xdQtKGS373xJcQ8GAUkul1gY1K6JipCAcMj0xUhFRK6eBCJgoKMmI57BSJVQamIMcR7hHWBeaTyUw42kjcitQ5Q9J1h7XnAt1c6lhaUUE/0EipFGvTcAWwIEsRYFQO7pTR339fdO6qUZHPYCo7AuQRnFKiyo802Cp60LFr/8apovHkgiVTLSdFyouWRfz/QG6BVXz2cJf+yENhwCorjuVM73XTHVVJ2B40TSfCs8l8Ocalkr5EqTwVzMz5xrnREfX8AMDevuzTwOQ+gk+euGNeODdN+DkYw5RHdiBeQC2FREo+EzkXAYIaHrCZ4HLuUwsFUM4EtUvsGRAkqGnx2uBsG66i/m+7vvhJKE+KbgswRb1s4E7WKVJukWBqW5hOuqLAlg1WTTkqXgmlcJfqPrZVZ4H4OeTSsEF6GHJBEJR5khZSlWgXBuWVRee2Qef/2CsXzXRGFIMAIetjWtvJTXIjGc21S2wcfUE7tilJed6xax+pvFxCbFZVnJBbJdTIZjmekNMT3TMSLhxUStUlplizdd+KSY6qeYLeEhrsltg1WTH1E7CQrGESmWpZEJgLYgCTAPy8JdhqRQ2HDPXG+BuJX6vafAB5gCCFZHOw4bVE3jkSZvwB4/w/o5EqJRjn57oGL4I//+X//SRmOoaVpmwVKSVUDN8v3mTVdHWCxUvyC1nfuARMighiuLpFMma4TBHYA5NGqdlqRREWDPVNTPqCXaOCacpxWcSY/z6uqnClo1y7c55ax/QrcsE/jIhTZhWHYcbu53CnCtOh4nyJpLhy7Hy+d60bkq1VAZDV0HIQMrwiwT+spJNqUpElsjI7oU+Vk92SiHbwl/7JQXTe6J8Myzt+bH3OxKdolCFylxvgOlugaluJ0kQ44vVSkwcDuvd4D7wnevVhVQES8VIfqysCBM28kLB0pyDBQAEp2360oVXxvR3DB1OOHwNOh3dighCYqqsV2U52Q9fO5m1VCJt0YBKguabMCAG+QRBbgmVUKLcimgK/ZBrhsMcoZ9NPhVLOBIBa6Y6OvxVHl9VOuqtagzOeb+LnadiY/wBbrRCbYNgA4ApJaQ+3TLBslTA5kr2oYZ3O6QpCv7/p512TPUbL4QJpJaKlVtUEHD4Wl2ohLkIz1XCXwGy+qunnAzAdtR7mLq0VMQ5M/ODihd0NIh4TNQKlWWkSvPt5C2Vl/zSvTxEYAiVVZMdTE8USQVUvlitchrOOXTKhXrLXXNRtVQZhpgTGABMSyWMszCZsas0RaJ0MXvBxS0VPdw3QClA3lLpapZK+ZmH+hqE4zBm+FYZ9YKoghwtv0qV0Gf4CTg2Ho2DMesQEST7EfIQHlEGHFgwHpEXbrqjvs6oB/IJqVpyY90nQrejr+1K6cr4TIIyoloq7PtUt9CjvyAsANO6JPUdDP/9YRkRqN1DWipWaZ2CCBvXTCYRZv6cWvHqEKWFL+GVz9OOWw/ADgYI6wZQNnSb71dOelLg23FRK1SWkQIsNGE4fqXWqVkq8/0hprodNcadM6Dprp7tHjSgd5QRaHyhVQsRtjbpmYv/PpERPBGTU17c6oVRmXFtqtjhvqWANvINAlOb6nZUq4/7Oya7RWIh+H7HiXJWTkOnoPLFty2AtQbkGCgki1qO+iC4pMbKgwHI6OeG1ZN4xgPvhsedfCSAVJnhFtWaqa4RUuyqKDfA3o3wofc+TLU+A1WWivFMORNMorvAlA1lXfB1NNVNoSt/ToAKfVZ9mvxYz3dR2JBm6Ee4J6fgqH/UfbwQT1IH2LrIQa9BmSkK3fdTsPBquyxO7VOR8zmz0K8tFcUqGxe1QmUZyT8z5lPJaJ1eS0oX22Dokxe1CBm5kEyGX+hO3fCtgr8MR32AIDTNOZxTlJqebCOMM7yUGjPGKPBXqdVaVkQFf00UuqXCmMNUt4MFpdRFOG7DePE5ttZba6/WnuahTL6Vu+QxfkLPhNhgwl8hNyP0QS4r7kS3EuUqS8Xwd6xfNYHHn3wkXvyoe6thx0nehGGpFGRnmodxADozDrf8yAsfkoHYaktbC66onmlQFIygBgLw7Vc8Ovot0ESnwKl3W483PfNUAHbCaoD6cuHsgA+g0NYWkR2UE73LlaUS32P3wqCyYgtqo7/2UypDbQ1ztIlJ+XNcWXcrXUycUU52C7OECpUMCoAKn+WEki+l4b9nGT7ZCWZBIAClFqaY9uGFmuiQmlHvnbY2ww8Ce6Io0OmkApozByvvIfGpNERemdYQbCgw0HS3g4LyeSpdJaS4apJqC1ITGtxyTCwVsW40X0QV7juhJyY653DMhlUoipAxnyYuAkHAGtCUqx35gF56JGephPnetG7KFCoQCo3lUwmWigY7+XFQtR2BJsSPPGS6ggpz7/lkp1ArMnOoryBFMYP3LwX4Kt1MrB5HFv4qlZnC4DfjoFaoLCOFhWJp8JxJWT6VoMEE5yDX1vhCCtq3pDpUsQwW4JYKa86ChDh0NWnkqVTQ1Ag+lU6haINDLrg6OjTlRLivlUNS6NaQpslpcErOUuEaZ6GMo27DhgIDTXT14Ag+jm6RRn+B94H0+Q5+hFGEYxaaAtV7zCuO+PDMVEd9+VlFsRmCqygYXKMlP5bfNUuFw7fdjh62zO9BpEV/hbkgdAzYKVxb55BAnFPPJZCzPr1y2GSpWFZwUQCrJ/QtnuPQf38fub5n5mtLpVOQGXyx3NQKlWWkUIaiWznqG5hUJlt9WsFSIw2owaxWBRuHhEp/iYY5B/grG1IcvXT6CxHa0hh+BX8ZfpvA5Jqd6LrDVVplgOUYzgnHegwaxBb6wO9hwV/PecjxRphsDH9ZUWwcCpTPLCgzTcKRQJjs6iU9eJViQAn3RQ2L6tAUF1yUgTTtENjwPADDUkkSLBULF7VFl4UsoVtU3KoLazgNNHHZUF7u+7TXt2P9LFTFjMDgSGP7ZiKqaogllspCv1ISNChwXNQKlWUk74+o90KwQoobLZVCTxDji3v0LPHU0om1LA2C8N/zjno7xDX4lgDfl5QJ1lqaz5fRK9pyaMpitk01s3KOTJmAZmfUN1lDzN+hPNOXPvreeMIpRxmWSriHF1xpzoNiqaiac8biYv20ElrDugkWssbE8sy6ZnJW9JfDaM8D0C3YemOq0m+TWZuADn9xwVRk4DFCPtclBAPknlkY69ClEWIhTwUAOkUaBs7nqlsQdhsh3ASoPhXnHHYvDCpfnlfusCLUCpVlJOfqEFWiPLZt5alIZ6YWZZN3tDsTggvfCPaLzbXFiTI5TH+peGRWOg8RA0qsIcTRXxkmZwmuAWP4XSWRVFZbBtLil1UbGeYBlHkqSqQQj8yyrJ3yBn6sipBugjS5IhI0Zy2zv+DPXIEbwzgs+KtaN0Y1CO4DMJ8pasE1UNZN5VMpLEd93cZUN/VFxPCxAhUCVVWLcF6i8DDB1ClyIccsKlCz5sU7Eh1H3UZVcdmwkgGoAQOOHV81mSakSqsNiOdzvj/EYOiqqMNOkVq446JWqCwj8ZdiokgXW5ShbUR/BUY3pYUUc6x2xCzx2KdSXl+QCQlJRz1ga5QVk1NeqqCFWRpSk6NeCsc9rcvFmZwtQOsaZmobw/h5mWVaWHWBgTbfXIBm8lSmJhQ/AurjoQ3N8uPBAknUIeq58JaKZUWQOd8B8gF0S4UL2MoKVoIngoNcq6zL25hQrJ16Lsp1Y+wfz/tplayhsh+2n6ze6CuxdlwN33YVvyN/zy1/XqR4qdUaat/Qmsk0DFxabUAMf4UE1zUc/mod9fsfcWbqs6Mt3JnKBa87EotCzzpOfCoNxR6B2Kzm+HyIX08rGcf+DkCPbsnDX9xS0cfIBZdVXyyq4ZTxqXQo44ugjKN+6EorJL4n76cfA6nRMxyC0OaCM9pqrKZPpdz3Jak+UDNBK5/GldcHBmIVEq33yLExfqvA4ZBZlzoUGAtgQIN/Yw0/l/yo+zti7dwMKS6/a4yUv0Na7gZ/flZ5E/6eTyqldaSiAOiIQFgz2voNzxTwVYZl3pAGZfM2wvmrq5Di1qeyXxJf0BquzOEvE6pwdk6CdD5rlor0d0SWCqrVjkPLrXO3zcSlv10p1ABWqE5hDhHcojB8YsJVNe3L75OdFPLhjNa0Ijhz0OL8GZOzIIhgWVYCOOOozzNSHQrkAgHQE065xeUtFbs0T1GtieiUar5DVdwtu+KyINyisvbeCAy9DkUXJ7haOGYtFaIKQtPytLgyofkiwrrRgy9CG/b6D5Y64C2R1MoI1rrh1wzzXdRj1ZSmSvgplvYolkqUT6NFSLLjOvxVz8WU4qifZRUnwjhWSKa0QmU5ybl6MWqVWiPHr5JHAngGwYWOBl+FPScsX4SVp1JHfwEbyyJ528S+6iHYAMiU0wgavqU5M+ZRKNoghzmykBBsKyK0WRRBgNvaYi1U0heTR/nsaZ4KFzpaP4dsvquxZpzP2agqdh+rgoFVap0LpnyxR7sYagicAJoc9T4UHdD3Q6nhrXQu+HEtZJiPY910V61eEMKW/XkZPxmDC+NnVs+3H4+uFPFxSJiPW1Q5n0o1n9o7wt5DzVLhPkMttDmMI/CRgtpNuvZLijUYzafiPwl2NnouIY+bxE2hinr0V93+oWFXOmmpCIYP6FVYs/kdiGFAzQKQ8Bf3E4xiqfAXt1NQmmDJnoW1FUECFTa0kc87UvKC2FYDgL6HTVzSI5//YZboL49vWDWBbkGJUJHFB3sDp4YlxxaX/cw07T2ywoOlYvhUwlzI6tTc0u9kfJIEqDtxhn4Gduyjv2wLVnPE8/kO95AaPu+nVnVCKgqAotC42EeloRq1pdJNor8qhaVAHVLM5rNORrWtoXFRK1SWkRyDCLqKTyXCx01YJ1gqKYQQheIqVVz9OQJeU5kcTPiLM4/gANQYYYS/Z3wqhfZisxd/Uon1r18YMiOewv+dgtSgB65N5kKGC6qLD+YhNjviyTt9037y40C+nlXwo+WETuVfUh31/h5aVVzOKHOQJmDPFc9fyu370uRTiSxUtfaX/z6hWJ/hblRaKnpF6HrtaVYGt2C1ihB8vsN4dEs8WCppaLNUFIDU2vchxf57R4ks5ErR6okOZhf0bSy4o35BsVQqRYDa5Mf9kjhEoIe5+s+iyFgqZfKjBo8FgQHkqwzHlkrK5Arym0p1CsKdu6VPBagZfsZRXzBHveqID2Z3akXwF1+LzOJMsw44sPI7guacwhiVNqkELYR7+MKDpL7YUUkPZRwcgtDCkiuhwubTLukBPfqLCy6ljXBOYJCb1k3hjl2GpUJQGZC/SbAyjDaASFHIRX/lw9VRz0XGz9AptF0w6+exbnoCu+b7zRaVaX3qfkupCBSqVcYQCSW0WQbUAHmfiqqwIHbUW2VaCPZ7GvoQPlv4az8kGb0iM36HyoJWIYJCD6UdMqBVS6pyzlValAbpDBkTLArCxtUT2DYjIYSU4WvOZWJj0GPs/XctFyBUBwZsRyYg4BgJQYjoL9kPh2ZLJQrrpHwEmR5SHPppwZVC681AaB3yVRQGQ5c8UyDOhUkc9YzJHbZ2Elt3aYqCSHo1rM+6fpgyVuZEN30qhZ38G2n43TTrnq8bzVfB820OMbbM5rBSQfpc+WMNfkuWvJsTsBNKLTUeDJATsDkfVQgTB7yj3oJFo6rPRkkn35c2+XGfpktuvAsPeM0XcN5P7oh+5wvav3j57GnAwvm5v4KHEyFh+AsRA6rvn7NUgmDauHoy8alwhm/vexFgo4zmnNXCOAySwgN6QIMdNaVbdbUAVoMWEFt+apTPsO5HEAgcQtCgFE3rraxXNZKovseUUu+N3yPcR4VjWAmVXFa+rSggVhQURpt31JfjQD3fWj8KtrYsX53ZBuq5sPav4c9Ujapi/g5t/dbMuh6rKsQZfJvbTyWfp1KOVbEiEgGbhdJTpYr3wY8DaOGvfZiIgJ3zfT3OvvzeKdLkLBlNBKTa3MDZWpQsbwLEWeIari1hI3/cH5tWit1xhm8LPls7D/0I86BpenyetMStmtHCzNoP5wSfStIPoQkCecexvs+9q47VG2TxJpjwUxzc3DIEPJOzAw5q/D0uIhrmghD2CNFrUfnvXdXBXd4Dek5DfQ/Lwg3X2wKYh1dPVo56XWEC7KCFal2U748qxGHvtMn7pfkRtHcwFqCoxuE/dUs8+NC6RS5MHKqiEMZS76di1MfLCFjN4hoMlLXHIcv9XagQ0XFE9DUiuoyILiWil5W/H0pEXyKiq8rPjcb1zy3PuYqInst+fxARXUJEVxPR26mceSJ6LRHdREQXl39PGtfYaoGgwBSVA89O3iIYIb9Io7dMn4rqi/CfRcF3n9SYXHkeGVE+5XdSGGm4TxyNpB8HMnkqYhyxds6sEM1iA4dC9KAHrk1qjmMOFYZ+5qyIjhJ2HB/XIbjQR0APHeUwXl2ah213wARXdQ+ln1kNX9GcrWKOmtUn8210R33dhmWp8LWl56nwcRTRfaN+FN6nAgA7ZgV8yy0VzQIoP4lqP1Ss4ct3RBNM9RkTXSX6i0ECo+SpaBZs7LfJ5bxZ/tN6XYXPA8Gn0gfwZ865kwE8BMBLiOhkAK8A8BXn3IkAvlL+HxERHQrgNQB+HsCDAbyGCZ93Avh9ACeWf09gl77FOXda+ffZMY2r0q41aCn34nHzfeToL8P5rC3W2MFta2F5JyQLQ6Twm86MLYbv2LVWnkroQ65yQNxGdIvIirDGWgdNpNq3/rzsJMyOFnbMXvyqn1xwibDOXEJfSH4EbEslnKfNRcyA7Ggkq1x7YGKaT4Wv29AH59LAiNBGWLu55EarDlo1DkUwceGYs1Ti9R0djpittqlZaqlozJjBeIVWUDLcI18hO7KSVQjZf9eCfrjVpu0km8JfB0Dyo3PuFufcReX3nQAuB3AsgKcBOKc87RwAT1cu/2UAX3LObXPO3QngSwCeQERHAzjEOXe+86vjXOP6sVItENiCLz/rpCgFThmmC1qN/ir0hDyOs+oaft0HPaM+7mNgDpyceCkBqS2Ge+jQlLQAfEixbCMdx4Ji9UV+BNHRAWMOVk4OZ+ZNc9FRHJmR30YJGY7gzjAXkaUitN7CjjCjgsNfzCnLnoe/R4qNS4tLq3gLBKeuP08r5si1Xr2SQzyfVvj0ZDe1DOs2aks+rf2ltGFY2ussRz248Ev9fZzZapuaVeNmDF+DXrm/I621Vq+b6j1V9lzh76EaQVnBjR7S1HK5LCWW+wPD54FgqVRERMcDOB3ABQCOdM7dUh66FcCRyiXHAvgZ+//G8rdjy+/y90B/REQ/IqKzM7DaC4loMxFtvuOOO7RTGkmDU6TZ3JSB3YTzaxE0vISKpuHH9Zcy0V+ZhebEcX4d/94hfb+J1ALQIb7a0ak56st7AEwLs52hVuRVYkUozIPDSrk2tOoB3P+kZWdzAQxYRSnrNqqN2XpCOLLzpeYsneh6eSCWCJotrkkGVBidquZ3xBaAHTUY+jmpwEbcka+VeuGKgOUbktCrltPj78GfGRIK/SDShDjzOyplb6Lkx3J9axWXs+sCiKxPfw3vQ9lGUQvhwTB9h1C9yweATyUQEa0F8DEAL3fO7eDHSmtjuUb6TgD3AnAagFsA/LN2knPu3c65M5xzZ2zatGlRDWmbcMmHrIZEMq20Kfqr0tDFQqkd9UoV44gJwuxjIFLx+fqFqX0qilld6NnXiTVkvDCcCQK6f4rXX0q0RaaJaUEPjjHjMNc91ZHZbKl4SCcVGvx5VPfIaPi5kGLLUc8FF5CWSdec6OqmaQx2ArSQYlQJlEAKafo+xlaEti4IHLpKlSr+fuQLStpWBFE+oq8ufU+Kv68+plufyrpQfCrhiUzm3nPyodN+HMo92LrIWXXZvZHK/6WlIn0qHv46AIQKEU3AC5QPOec+Xv58Wwljofy8Xbn0JgDHsf/vVv52U/ld/g7n3G3OuYFzbgjgPfC+mLGQ5e+Izxmtqq222IqC1NwI7lPRBBtfzLqGLxaaCn/FTkreb9mGHkyQWgDWfiyA7p+SfgTdiigtJuZTiS2m2qrL+VRi+MvCxnU4kYct1/1k1yOMgx9XmCBiR71UFGL4K35miaVilDfhFgKQbujk+1kLDWtdAU2JtTz6y47umlTzVGILwGqD+220gpD1+tatjHAP1fpk76i/h+6XIdZPWVCSK5i5EkDRO2JYVEB+b6Q4hSGj3Km+ofHQOKO/CMD7AFzunHszO/QpAM8tvz8XwCeVy78A4PFEtLGEsR4P4AslbLaDiB5S3v93w/VBUJX0qwB+vKwDYlRDBLY21ynsqBALsgFirDXRPhD7KoCY4TtmdmvXD9lLCXh83qoj5e8T95u3V5Ae4jqKpsfhGNU/JbSwrmJFhHnjznw5VmmpaIwyhiD0NiKoJJrw+nrAz6cOBerPg9+PmKXCN2bj/pLQFz0CDVUbekRfbSEAtgO8uof6zOPzLEe9FS7P16/dT0+5xMQ4jNYWXGr0Fxtrt4ows5kxUeqXcUzQd9XS9/W6qa3kPEyXMHzVUskJ+iK7vgtlfY+LumO890MBPAfAJUR0cfnbqwC8AcB/EdHzAdwA4DcAgIjOAPAi59wLnHPbiOjvAHy/vO5vnXPbyu8vBvABAKsAfK78A4A3EtFp8OviegB/MK6B1ZCN/RAnlKQovmCtFy/BWqVPpTLt/WfOSugKx3CthdWCSdWQJPNQLJXYF6Frk+EezsXanQZNWdg5EGAj3YroGNqg3FTKH1fCrzNtaHkqcr6JmSrpXMTCUS0Fw4I36uivQXQPJrcSP4EsWqnWQWP+pZHqRIl1J/NtdCsiFfI57dzaL6UeR/Cp6L42LWTej1U+U0uxQwV/qb5RNhdpTk5s7eerV5Pqu+RQoJlRz95jQEQWivdM8orU2k+ttnHR2ISKc+5biH2MnB6jnL8ZwAvY/2cDONs47xTl9+csurN7SDr85T85M7VMWm6+N2V5xxEd8WIG4oVSvTCFfr3MedAis7iGFMaiWSLNWm1sUQ2dX9ihHxw+AEaxIuKODhqZQww7WW1EL6XBHCxG6RJLJQ9BaOMIp3eIVCHOGVjoi2U5ArZPJdxCC0Wv+4nqHlqkHF/bAJJM9MSSUcbK50IPo80Jrvr+uR1B636kTnj+TLV+akpRLrnXyrjn9+gaqEU2lwtMGVGSSTWfSdZSORDgrwOZss5lpiVp/opwjlU3azDkuHKRaMbcnPW/gR33n1xrHQih5I+HfqSmvYQP+Ni0NiyttmZQ9bj4PHCNFWgQ0FmNk9QcEg4bBW2xr+SQZBPlOO6t+o9iaCqZb8FccuPwGH/dbnV8GIcUS81YE456jbPYamsKGc7BeFpIMU/mU6HC6pxyHEqUWqyd61W6w1hta6ieDAt6BeIAD9265NY8xD3qMerwWMwLfJ6JFlKMug0h/Hgbeng1yn5CbUPjR61Q2YdJx+jjcwpSXiqG0dcLxa6PpPlEZGKidE7zYxJndbXOWZ6nJz9KK0PbzTCCvzQGBZvBcNhI809pjmPN9xT6qOdNxLCR3N8mYcZqgpkCoQnoKWL4htVWaZyG4CICQhkW3jffRmypSM1Y+js6RQHnpL9Dsxxt7TxZNwLGK6pnpisKWkmbcE4VoKHu1smUjcpS0dfFhBFyz+cihxYEaArQ821q5c0QjqjHqllkoQ0ARskm28metKH4ZRotFelfpQMg+fFApgCHRNi1WEiahqPBKalPRS62OLw0vPjZcF9+vYLDcmtHM925JdPUhkzoq8SWYDBWEmcTzBE+rUz0TqFn9nPhWM1FJlnVaiPR8OU42PkyiU22EQSCtPxkYAR/+TlzAVLNWMKRFpworc9YUZD9zOP3HWPtSYVnlKKUEr5NElaFr42vXSLdT5arMMytYCtM3B+vmbHmU4nCxE3B5f+f6KQCNHrPNOvSDySai1yARrOVnKIi46JWqCySLAyzZvpaYiGzVMw4e2f7RBSNUzKgcH/ret+3+uVPQi7Zd8vKkG1Emp4SgQakNbFSh6xm7XjqdlLmwCOzrGRUaUU0+W2ycA1pwq9+VtVcRNpibKpYIdipL6LuAxfA4R6akOfHZRv8HlrCajoXRXY3RMtRLy0ZDTaVuS5yfdbKhlGmSCgKup+hngvNWgr90EvSxPegjHUZ7pNTHkM/8pvIpdaQBlnqfq5wjrTEw3HWzxb+2rdpoqB8xBJZhehQ5aAAeUejpn1wJ2T4jR8P9wcUnFWWDVFfmNEEl1WLKtGQAqM0GFAtXJUQ13J1anudcNhIz6jXLBV7rpoS0PRdAlNLRdMGcwKWa/ikPFMnGKlvg3dStFExyhgqSUPRNSFe9zNfiUF5pkjXjVViBbBzhxKhM5DWZz10K2Q+PKtCUewiH9Yolkqh+0b5e2j5VMJ8SV4R+hEJceU9DEPVtsNO85OsSgv1OKTgGheNJFTKfJH7E9E9iagVRNCd6EAMEaRaEveXLCL6yyFhDjq+bls6QM2sm3a10/02so08HFM7huN+1qXD/XEt2z33QgwaNDl5vswbkuPQLJXBMBbwyVzIbHcBBUpGajmGuVYcfqvbiBmpZGJaCGzSBjgTVJ4HQvv1PXIWruqoH8bJfLINGZmo5W9wmM6CfGJLpVAt3EC6z7BeW2qwTHIPa2sHe20m74gRlJANEkH6DunVBZhSlIFeLYVnHGSGFBPRegAvAfBsAJMA7gAwDeBIIjofwL865762Ir3cB6lbkJpAVj9k3cGXapQNGoxwRHJ4LZzPrwVs7SVxopOihSHVOFXmwBiIDpXEn1Z+h6axapCO5nvqiJcu2U+FqT8TwmrTYLzZnvIsivqlBZQEy4zmXK+J8rihwTf6VKTg2kNoKorMUp6HBllqkUSVhavCjcziGqkmXN66rEq9GBZuOCdXTkZ31NfnaBZVKsTzdbmIaj+Z9HNWPhVjj5sa5jYEl1Bo9IoQ9Tm59a1FmI2LcnkqH4WvAvxw59x2foCIHgTgOUR0T+fc+8bYv32WZLSQfPHCYuPErRBNKACldrxHPpWUGdfMQUZ/hc6F81Ln3bBRcIk2OoZ2LmAjyQjlCxPXT2q2VHiorVU8M0pMtKCSiJGmGqdUAhJH/R4w/NrZz8ahPNPEqpNMLuMbskKfK+ai+jtia8cq+SGFo7TassfFfOvlebRnGgdXSEizqZxM+g7W82VVQpZwo+YPIbEunOPvSzxWrxTlojwLJfQ5tXBVnwl4G8pxpkysFPxlChXn3OMyxy4EcOFYerSfkExoSs1N3VKBeLllOc0IV1a06xyM0cgc5GJX4YEUYpN5E7wN6e8YRTvnbei71ol+Fjp80GHCF0i3IuDMOM3ZkXNlJaghasOCrsJYs5Co0s/BcBQhHjM57ZlDzGfqAM8ILnbv8JldN0bEHon7aL42Cf8mRUCFAI5g0aGY78QSD+3XU2JHf42W0NopCPP9+JkDfKz+c+AcCsTCtFpbndRS4flo0lJJQ+qbK46nyEmqbOz1PBXyOza+mojutSI92c9IY/hADAslmgHXGA1LRQoOazdD3d+Ravi5fANSTGIt/DTnt5EhldpxQLMiUPURiGEOjRnLF2Iw5G2E6/g4Yq3W9C+V50x2tb3G83kq0hryCWb19fLxq5FwrI1wrzjAI2akCawqGGm1Y6IBG2nrJoFNO4YFEMahWm0cKrTbSEu9DKMxV5CRAYtKn4pWGDOyPpN3MI7cSvuJ5Jk2rX95jyT5UbFUpIU6ClQoIWA5Vj26se7nCsmUrKP+2QDWAPgiEX2PiP6EiI5ZmW7t+9QpSDBC/xlhrQ3OOX5dIA5/aZYGv384X/bBznOJ+2iZxDnBVztcy3kgHf5KnbZxO3wcST8lo6RUqGhWm/RFcABe1pqSgkvbNIozsdG0WjnOlMnJewxd/Xs936wPQ+G3SayheA4sS6WGXXUhzydDCnG5biwnerK29+AeGpwDiIQ/LdlU20OkJMunkj6P+rhsQ74jdiRc3AY/pu1xE8PMovI00ut9P2OrjffDqp6RQ07GRaZQcc790Dn3SufcvQC8FMDdAZxPft/531+R3u3DNKE40YEYZpDPcBSfihOL3npxwwuRMFLEJq+22VLWV8Ew5drxqLVh9THWSG1mLKyIxr1OFKFSBA0/vs43IvB36QNDPBdeqMhnkQqunOZsMfwcFKgLR97POMJMRuzZEWYiqkpovYrsE05fjYGNaH1qFq6RvxTmPLVU9HXD+H3KrKUVYVji9fvhP6WlLYW47ieL79EUMJMLV6fqNxddL59pbqfZjhEJx9feXoe/ODm/fe+fwJea3wDgHePs1P5AMqGpUvbK/wtqcIKrUEe86LVggCocWLMiqtpeTQy/Pk+usxgbr9ut7xG30WS66zXK4iieiY4sCxLazwuVwLyqUFxxPGJADU7diU6R7iLIIDYrpDjSagt9Lpoc9Tl/x1Aw0mS+2e+8nzJAQ0aY5YIvJOwaKBFcoh8y30Yr32PBW4kAViAfmWxqRTdyhq9ZKjxh0PdB5PSwGffJj/z6VHlMx4roHC0PJWdpy3eoaWtlbS6093CvWyqBiOhMInozEd0A4LUA/g3AQQ+DTXTyGL0Vv56Ej4r7xjh+Wq+KhwP73+Jr+b0ths+jv7S9IrIwhmIN5Zy6uu9HCcXVoCl+XPGpSCbmRBvSGsolh00o28IOXOqoTx3LbBxkWFysD0CamFjxSXOuYmsoEkoycELpJ1dmdCYoGJSI6LOEY1JdIChM5At46hFm8h6lT0WU8J9QM+rlM7XqudXrN1sktLIc+fEU0pTryrcRz0niX2L36HZI3R3SQi3kXKhBC1IId4SSK6BXb7WtjFDJ5an8PYBnAdgG4CMAHuqcu9E6/2AjG7JB+dlUV0tfjPzF0UI76xc3btdfH9+bSEAQo4TqMlPF0pz5Mbn5j+ZzAfJhm6aADvco0uoEzrkKerB8Kpzhp4ly8bUTnULPei4oOk86ZBPBlWFAVoXgRNHgz0yMg0gvgCi3ErB9cUobiOfCM2u++6QQXMralb6fNPQ5/O4/ZWkdW3DpyZHhHlHGfdV2edzyZVTFTkPf434mFQw0CyAJmInbkKHPapKz8KWFM1JLRUmUdnVFCa0Nub7VoIUxUS5PZQ7AE5xzV61IT/Yzkju+yRdTamqAYQXE6yQ6NkpGvb6fSn0f3oMUolPgLzDBNSJerGeR10IHSBPMOHNo8qlo/eQhmSSuq9oQDF/LSOZwTLq9beostXaXDG0s9FNtMdXOde27eqaIxyEFl9ZGbVHpe2/wMHJACgQpNPSta6VwjM/RfD+IjvO5kLW9tBBZIC0omT7TdN2Em0x2OtFc+bmIrWwgX3k6gTST+daUptSiSsLVh2klhcpSEXxAq9isrb2m/VRWyFDJwl9fzQkUIjqEiJLNsg4Wks43LSpEs1RyUIfGsCXeK3FYDf7isJBuujNLRoEHJMQmLQB+D5+nYkeYqdFf4qWT+6rXkUBhrPlyNlo/texrrTQ4VQzIw19SSIf5DvvHy82tRrJUqnFYVlt8PPE/sYFYBSXz+HvaB02ZsYoTaqG6WhuRUKG8FS37WR+P+yItQz4XE3K7AnGPyW6RCJUo2EV5HsxQr/qrWerVM6sCH8R7nPSzGf4Kt9D8JUk/kbeGUt9n+q6Pi3KWyjOI6I0APg+f6BjKtNwbwC8BuAeAPxt7D/dR6nYKzCzwbV/9J3+IGiOU5TI4VbsZFpalkkIlTQ7XmJcLLYsMv08mGCDxmRSx43k0BuTQ5S+EwIOB+B56aGgdtGBBgbxMS5NTd6Lj9yEZDF2lGXIGNNkNW/0Ka4drtZT3RdSl1hGdk4sI5Mf9OTHcaM13mggatyG1cz4XqfWJiKycnegcagg1ryyRYXRcwkqcUn9HvkrCVNdbn8Ohi/JJshaXi4MBOolwTNemnAu1n0qZoUq5q4J2yuvLc2Q/98S/pPo+9zb85Zz7EyI6FMAzADwTwNEAZgFcDuDfyu2CD1rSrAiAaYRMg+GFAlNLI8+EZOx5jY1rGme8kAi60OFalur32YNggE5Boihg2kYyTnY8jDPHHPTwbB79Vd9XG4fvZ5ENrw5wTG/g0O2we1SWiv9xvlcrEtLiki9u4osw/ATSTyYtQ85f5V7jaaSRLsTB1k3qRI/nIi3V3qwoyFprBcm5iMcoy7RIRqq9H6mvosBsT/H9lP8HRWBhMMR04Z8fFxqWxSUtlWxdOuM95P1MoxvFe1qtXyeOh2dqZNSLd0gLA5fvkKx6PQ7K7lHvnNsG4D3lX0uMJPwVvmk+k7A3+54zbMEIkRYGzDGHJKmq+qdmxvlieXG/tDbSl04u5vi60I8E/uKCSWD82gZDkU+FCW0+jiL30gmGH5jcwmCIVWAMiGm94Ti/B2/DzwUbZ/kphQqfTz4OzU8mBXDqOI4ZqR2ZRdE9NNiV93Mx+TYyE11be2k4b8lIRR4LKetG9SOojvr0mU1PdKp78CATPn5/j9Q3FC295B0r+5a1ImR0Y3wPGaBhWYYyJye1huw2uMIyZpnS7qeyWDJLWVSaVvy7/55qJ5LB+GsNS4Vdr0WPpRFoqYXA++a1F9sszwUDcI0yeueqxew/dQYUNWkmJvI2dJhOfymrNviLLcI6JQMKWm0s3BT4qyejkTjzSHMe/DhizTjZhreI51sKYBJMLpfEWWm1xla/4dycT6Vr+oZsDV8KcQn/WlBgT8JfYn070c+4TIv0k1UdBcAslb58ZnYbQyeFeL7mlhXRx+8hoxul8hjmtbqHMVeDZJuAeC70KgnxvVYiV6UVKoskqV1LZqqVw+AvhQ51lPcITKaQobb5Mi9NuHTC5EiJCFFeOn2P+rqNXD6CthGSQ8occvupSF+F75NTXsq4n3tmqdTwV9UGYw7dwsNG3KcitT6Z5JYGHFB1X96PWsjHfQttRBqpsD5NX0XGiiBCY+6RtJC1NvIRT7o1VPltROizFI6a0sWTf8M9tCzxShHo6MEV0tpPIeh4HLldMLXgC6dZKuraE7wgOV5ebxTwjNaFmTcXf45fpLRCZdFkZ2jH2pyEAHi4b/iNH/fHUN4jhbcqKySzZwVnttrxmsmlwQRc4xw1GECP4w9jSBkpJMMXG55p/dR8Pwl8gPgeXKYm5TaE4KqFSmxphP4TEaa6HQF/IbEi4n7Ga6IKABAZ2hLGk4pCDCvJzbFQXouoDStPBchEkJXtrJrsxL4K0YbpqGdtUAKxiX4GS6U8kFjZSsWJVDvXkx/DetAslaYISsgCnsKaTyyqQn9msUIj4V3/ydcWUEOA4VZUXd8sxNOctnh9a9F046JRMupXE9FfEdF7yv9PJKKnjL1n+zh1O3pdLc4IAdvRqFsaiI6lQkHJN9C0wcrSSeGD6P4GvMVrf5G0RIbxi9tYxdWAvyKGX+gbnnGLTY3+qjlQdd/qHgIbB0lmHveT+1T4Ofwek90idtQLBpTkdyTaYtA4bcFEhOihSYEgoUA7FyYj/CT8JSyR1ZNd7J4fJMfDRNflZqKbxNo5USI8+RzIEikSgtMgTa7whH7kfD+Tmh9syNd/3LdwXM63Xv7EtnbSgIKmHJIwvtJqE++xZX0imgsvYOv6YXX/+ecKyJSRLJX3A5gH8Avl/zcBeN3YerSf0GS3wHw/DSlOhYauXWiLsfKpMF8BXwOav0Nn6P5TCiUbD47vkcPfh8pLlUvA1DBnyfBlvkH60mkVn+t7V/dqYA7R9UI4apaK1DinuoUIKY7b2LB6Elt2zbMwWf97Ve5dmwuXasaJc1oKhIxVp2m1UvgRpYzU/+5PWjPpLbKg4ct1FeZKhlcnPhXNShZ+gr4oKFkrZbrSlcKm2h4i/pw6Yi+/J1GugKfc6CsJjDDe86ifHcuiCspjfR3/rJ+pvvW4FFzxPYRFpfCbcdEoQuVezrk3AugBgHNuN2JF86CkNVNdzMzbpSxsKMM+noYaSgaShp/qQqPWxGLWElO4V6rtUXSODhuF41bVXGFRRfWqJBxTqPupgN1Dwl+xT4X3PYw1dnAT0hcfqOeqqjVlbJELAFMThQKl1McfdI+N2L0wwGW37KiOA4q/Q7QRR2bJF1/ZmEr1VeS0WtmGtVun/3/NlA8KnS3zsKRAWDPpmfWu+X50j3QfEnvdyAoFVrSSvIeE8XIBILWlMojO2ZMCnkRI/IFxP1MhrvnztMgs6XcMc1RZhkIBlfXx5FwAfH+auJ861DceGkWoLBDRKpTzSX7Trvmx9mo/oHVTXSwMhpW1IhdbpRkkDur6Hgm0pLxYiaUi2mmCt7TjqeCzXwhZwywJJjAtmfgzdXYyS6XQ932pIbZUwxq6tC5X4n9i5xfJXEhLxX9ZGOj4O+Adv4mlwtp48AmHAgA2X39ndZwP1c69qO/hrUs+TgX+UjYCC5ahubWyYEAacwn9WzPlhcbMghcaSXJkp8CqiQ5mmFBRYTqF4VvCT7ahVZ52QjimOyrGAnZSsai4YLIc9UkBzxGsfb62OMTm++nnO8yHlk/m7x0NI5oLCaElcyEsVGmJa0J6XJTNUynpNfBZ9ccR0YcAPBTAWePs1P5AQZubmR9gqtupH5ZYbJZPBEgZ3UAstoQRInVO57KWJTRlZV9LwRMzBwPeYotVatZ6G7bgSvd9ie8hnb6hH7mcBp+MxywVksy8HF8RM6BeAukwS6XbiSFPxAzosDWTAFAx28rfEeCvyonOx5H6VOKAA7lm9Ochw31lZCKJe+Qis1ZPhrXdr/oY+hZozVRXWCqCGRdSOMaqxEQV+iygwoa1x4V4UxFF1VGPeF3x64DUGrJ3No0/rT1yQj8BL0An2bwkvk3EVltuB0rZhqxkbPpUxP4y46BGoeKc+xIRXQTgIfBr4mXOuS1j79k+Tmun6hfv0DWTphM8WghCg0le7kq7KO8BzYlom7Opo19CQij7VrcP0YaDgDFMTa3uh8v1QWH4UnDJjOMk2kiBv4ZDNO6nwkvBEFFyHGC4tRJSLJ/X1ERhar18zJbGqTnqNZ+KnE/OSL1wrP+3n2k81vge+cis2lIJ8FcsuABg3XQXu+btoAWivE9FhsnKcHc/ljR6MQnVzezmqdVr03w/TcmmunAs17+iPGo+FYDvHaNbEeEW0mrz7WmoRjxXYOfsTZ9Ko1AhogeWX28pP+9OROsB3OCc6xuXHfC0btpP3c65UisVTKqOXhGaVvTiNe9/7cSCHs2nUt9Hhtn6PsaCKalbJMptZPtoCEbeB34dkAqupszo1M8Q55CQMtdcIw3nyOP+d39OgL+443cgnpeEvySTk89EYueao15aQwVpkGnMPKQlE37nnzKpNdJqEwgtZujBUtldWVzx+ACvVO2a67FxCIZPeihuBTeKasrC0K/aS4SjsAByuRlq9JfoZyq4Gp6HEMAapCmVjTp82ldr0BQzfm/daouVIinEa35T9yFqQ1l746JR4K9/BfBAAD+Cf+anALgUwHoi+kPn3BfH2L99lir4ayF+8ZJQWqFdREwI8ctfF5Ssj6d4b3mM0nBfyWBkGK3UgDSTWDpcU9govUds6dTXhTHw68I4YsGVWhnRPUjfbClogJrgkgzIa6RpG7noL94GAExNdHDXbC+6h/Q/8WdiJQ1yqI+XaQn3yMExlo9LCtiUGQtGqUGB5TlrAvwlLRV2jzVTnSRQRTLBXEa9TKCUAQehvVgZERCbkakeVt2UVQUha4kovjj2f2JxaRCaMg6gfs+SPBXRf80yJCHckuhGITR8H8CuT/s5LhrFUX8zgNOdc2c45x4E4HQA1wJ4HIA3jrNz+zIF+GtXaamke1Ioi01Z0BozjRzt7HhSl8hgMFKwyeM5k9gBaR8zbZDQerUxhPvyc3IQm3ypOkVaULJxPxUnfBVKzg/vZ9Bq5e56sU+lUEp+xHPMn0ky3wZUwgUskfSppJCpE+Pk41Dne5gyGC3qMJwS4K/dQWFSrIi1UxPYmTjqWT8Laxte/78s01KNQyobiRVRH5fW0CiWirREpNIkBUIS/ZgoZv4z51OR75mmmIW2+ThyvELyAik0pAUcvkkLdhw0ilA5yTl3afjHOXcZgPs6564dX7f2faqEigERVBrjsGHBilBEgAuFFEfN+mQkVgvJaGNNrtpAK8OMrTa4YJLMvG7BhqYieScsqtqJrrcRzkmiv9hx55zQOFNGy6+18lQi+EvJTRJyO+qrnO86QifuZy54I/WHpFZI+D20H7eNJLxaRtOFb3X0l762eT/XTsXRX02+CqlsFAVF2rf0VYTvqa/CngspYLUyLVr+UmLBCgHsHPdV1G2Hcfj75t7TeH1K+KtK3pVQoBAKiTIi3lN/rTOOr5ylMgr8dSkRvRN+S2HAbzF8GRFNocxdORhp7XT84iUvjQHJSKds1tGuMJDRoJC6D5piIjWkXEixZUVwGEMVbILh56wIaVFJ5iChlHC/vH9J0c4VqCRcO0pG/VS3iKAUCeNV7ZTN1Mw4Hs9gmMP4FagwETrKOBBbKgkzZn1MwmRF+OnqMg8lZNVLKxzw63+XtFR4GzJqqvy0oCf9uPDFqQLYfqZ69FfeZyIrA9RKUeyXk+957j2Vloq2vjmpjnpKeQknWf/O6oNDfN04aBRL5SwAVwN4efl3bflbD8Avjadb+z6tmYrDLqWGHpiN9KnI8FG+OAbi5ZYvjQaF6Axfv3+Tg7DqIxunmafC4S9VW4w/JXOQVkTWb6PAX0On7KcS8YYU5sjBeJZPhb/YsvZXUgoGsYaeOEurFzseR6ooiLnIKCJphFnoe3zOKLBpaKdy1C/EOVi8nzKkWINjNIjNWr929FfcT8q1wa4DbEd9vg25NqWVgYg6ynueQmyxoNcQhfh4uI71oxAVxYVCI4WGpoxo/R8HjRJSPAvgn8s/SbuWvUcNRETHATgXwJHwz/rdzrm3kd9Q7D8BHA/gegC/4Zy7c1z9CM7MOvrL/57X0FPHrl7ipGSWyGtA9u56NcOPeIsUfOWX7F7jjEnGbeSPV1n9SBezY9eHczShUsF0pO2nkrYR1yhrwKSruS5bUpixxKWnRO0vCceEdqRGGk6pmEsWKpHCMZ6r0C9+Pb+3Nt9peLXlJ/DnyIKRGjS1drKLhb4v5TLZLdIqCZSOk7cR+iz9T9FYFWVDHPb9dy4WxsFSMZIfpQWQtwzrtjs+tCYah2oZJqkDsfKW+D4LRMdVRz0UXqCEFFfzOUzHGX4fN41SUPJEIvooEV1GRNeGv7H3zKY+gD9zzp0MnzvzEiI6GcArAHzFOXcigK+U/4+NOgVFZSLqF8+TFtqpReFoTD9xujImldU4lY2Ock5d1XE8ZIMIbSj+Dm7taJZKzUjD75l5EIUv67b5OOMTnHOVlqhaQ6yPoT+5iCf1eQ3je2h1oFJLhUE6SRt13+J71P+r0V+CeUiLjN+7mm/u7IeybjKRWeF+1VwomvNEN829SOeKz6VL7hFbdVofhDRl4+THJTPm70+nSDP7ozaKVLGTlmP4PVzPx1GXIbLvYTnqwzlyP5VKpUqUIjkO3k9E/TD9OitgqYxaUPKd8Mz8l+CthH8fZ6dy5Jy7xTl3Ufl9J/z2xscCeBqAc8rTzgHw9HH3JTLfy9+yyYnD9KVogr8AruHIBW/BW3X/NByWjPtX942YWB5is6NjasEm2xCIjgKxxfcIjNSJuUq1Rd6GgDEKxSGLVAmQ/ZDO51ytqTBek3mYbRjMHKnfRgve4Pe2fHmRFWH4wSQTk2tb0+AH7BwpHHMbr8k25PMIbSSWimFF8DHLZybvkfNrykcq168UflpR1iYneZLkLJQNDQr06yruZ94akpUB6t/HTaMIlVXOua8AIOfcDc651wJ48ni7NRoR0fHwIc4XADjSORcSNG+Fh8e0a15IRJuJaPMdd9yx1PaZ+Z4ydP47gCQKx2SmRbzY+EuT07KqBV/BZ3oOSXV9YAwiAi2nOWsQm4yf58drTDrup7QipIXAx68x/AFjxpoTUs6VtFRSJSAeX/gu51veQ7NUhIKfjcyS1pAGBTaV6+BtaDBHoy8iCCYxjuCKsIQOPyYtKnszMWExCWbdnFFf37N+P+LPOL9D8R8JwZQk/zYwa99G3IfkHRJh4kBsRfB7a4hE6BsfRzKfGaERIEE5jn1FqMwTUQHgKiL6IyL6VQBrx9yvRiKitQA+BuDlzrkd/JjzT0edPefcu8ucmzM2bdq0pD5oEIFcKNZ2wP4cXeu04BLNiagyGN4/3mEhdPStUKWDUGf40opI+pARCE35OlIz7ihaVn/gKkesZQFIGCNqQ1hc2j36Q1eVE9HGKscR7pc4n7ORWVooLmsD8fOQwlGuO+lYLjuitFGfEdZoh53En7sldADUG0s5YVEVepkWGTxhWXX18fp/aanUOTnxfGdDm4cOHbkuhCUu55v3rxZ+/lOrbZdan7FgCsEgoRachG814SjHkUSpKRCaFEr83uOkUYTKywCsBvBSAA8C8DsAfnecnWoiIpqAFygfcs59vPz5NiI6ujx+NIDbx92PnPlu7vyYQB318SQqJNEGUwiCM5hQPj5EMplhtJD3Z31UEiy1Uutc+9Ydx/FnquHXbSb3EPi7xox7g2GV91Gdm7EiUgEea86aFdEfuMrZG87JabXhfhYD0nw/kgFpmrVkpJwvNEUSVfcQfeTKTmByE9FYU/grBz1pjHQUiE0qznIunJwL5dyEGWcsv4XBUIwTiKtOGJZKMo5YiCdRnryfQikK0WiVUiSCK+qN1+p7aBasZrW56Hj6vPaV5MfjnXO7nHM3Oud+zzn3DAB3H3fHLCL/NN8H4HLn3JvZoU8BeG75/bkAPjnuvozilJUvd/bFs7DW6qWRZnXMgEKF3clKqEC1ACSTy1oqhjUU78rIGhnBpyIhHSn8QumNUMa9snbYy98bDCtnMRA0eNHPjAVgQ2y24NLKoAtDJXom0uLSrLb+0FUaK5Bahk1WhtRqtflOFAXxzIKA6Xbk2qzHye8d7sGPSQ1YBgOE0jR8PrkyIYWjNlYrhySxDDPPvZ8IFeWZKsxawkbhFP2ZDqPyPnJthbyZqarMUBherIzkLFgr+osnP+rwF8ZOowiVV47420rRQwE8B8Cjieji8u9JAN4A4HFEdBWAx5b/j5Vy5rvl+M0x7IFxD66JJdFjggkCwES3ZDDQ91OpYCWFkTqljQh2GsbMgSjV0ngbWrivE4JLCr+QHBiYnAZ/9RIrIo6O0eABLSiiywQw739oIxJclGZX87ny/eDHUyYnxzEYutji0rLIo/sbJVaYVZdYZUl4tW7hSstvIKSjtCIA6ahnAlgIriZrSFq4+lwYCX3CUrH8NoBfvxOG8Az30pgxh/n475ViFll+4pkKXhCESg3fhnvU4wwzwO+R9rP+X/KbxDcKee/xkZmnQkRPBPAkAMcS0dvZoUPgI8H2CjnnvgUkCmKgx6xkX3JO2fApi+rlkh9D3ampyiz2FDtD4/alZg3UL66ZQ1K1n1oAWhsSEgJqBmRVo00gH3ZPh/TFdeLF521YVgRnDn4u63uk/qe4DyO3UcT99Of4PAz54oZzhgkDiq/n1B+4ar92rZ9aEqcGN6ZBCWDnpE7b2D9VCvFCCGkpHFm/gkJSrX/FouJrX7OGIqtOwErVXMR6ggpNhf71hTLi7xfP10JfWBHSZyjWjbRU5PrW/JKDocOqiU40Dj7GVKiUc5mxVLziJZQNBd6q+ilyZTQIeVyUS368GcCFAH6l/Ay0E8CfjLNT+wvlnLKWA08uWP6Mq8XW6ZT3D4sN1WdOC1sQDF8y2uqrYPjS35FYUwJ2AhBVCNYiiSQjlTXOYo1UWEPlOKoqrgb8xZmDxN8d4pcS4niwhjpsrnj/fT8kjOE/h84nwkltMZwjGVCYcE2rlZZKAjcKKyMZpwr5yJwGl8J4bC77CsPnlkZoT7MS+FhzgkuzhmKrrmyjbkLxL6WBEfzagdaGiJDULZWY0WoWAH8H+e+VTyWC+oboTNWsVVoRqU+lvHcy37biBaRRmkBs7Ughz+89TjKFinPuhwB+SET/7g7ifVNyxJMfK2ZaJeTFCwnwzFIuaL7gTbOYvbhSe5Ga9WSniJyIMSTkor7p0V/50veBAU2wyBXdIRsz68R0r/9NckjqNvw8dMQ8OOc8NNWJfSpNiabhWiIyLZUYTozbSMuLp8mPkhHyObB8Kp2MZp1adfE4JJML35M2iswzrZQR4cBm0JbWBh9L8kxHtIZq4RavzdBP6T/SoKnQwfBMOxkh3VN9KvVx5+Q4Q9tCUQjPVAnI6SXveXyPhcT3Kay+4Kivb6laqLGyIftpwHh7U6gQ0SUoH5fEjQHAOfdz4+vW/kGcgQwEw5YPGSgdePKliiwNXwIkMYuZJpZog+wGC/0YEoKwVKQ2qDG5gXQciz7K8FPuZ+BadD0PsaYX5iQH6UgrQjLzwDwmpYBmbeQw5w6l49DmojccJkpAuHc4N7FUlFDc3JoYDGUUmxLiyu7PI4U6xIV4dFLWbyOjv3TYKI1s5FSNpbzPQAgu6VOpBJdgttKnIgVXrJznS8rXloouHEM/+PGUWYvgCwEbyWca+jBI5ju2ovk9pPJoOurFZnmxpS1h03ghJmH7K5j8mIO/njL21vdz4ua7zaRiLT+nlSaWSvk7b6ObeXFlRFThgdiKJG4dFp3EvmP4wAgGEJFZgYmnfpu47TAPEQODbqnI7YLDi6s5fYkkxAbI2klADV2lEWb18TAPzknHcj1HYUypo94OM9cErLQiEj9CRnPugAtxxOcIhh4xoKKGSsNxoH6m4R7SN8SHKq1cqYzI5yGtT38OizAbpsJRC1ePtXdd2egIIS3fkcmuEFwjzHeYTyeeqRbs0hsOk/ymcG8AmJfwV/VMw2doI16/eUUhvjZV3NJ+joty8NcNrENHAjiz/Pd7zrmx54DsD8QZiMRztTDY/sBFjl9CzEBC4buprmR05fVDJ/wImvNahtkyRlv1u+4/kDJ8qQFJTa+g2nrgi7lAaqloZrf2QnCYTrYhncK9ftB6ZfRXTYnjWMAUmsXlx1G2MUi1d8lIJeQT+iEx/lRo5K2IbMSTGIeEGwEkUVN9YQ0lzzRYhnys0Tmuuo7fw7dfj4OvG1kKpi+sTz8WZtWFvrOxSoEgrSEZBFJDbPZ8+zBx25IZioeawHzi99qXEa/fiQzDr0OKO9E95FwgmgupjAwTmE/2s8iMY5w0SkHJ3wDwPQDPBPAbAC4gol8fd8f2B+IMRGpJehZ4Gr+es1RqBqJbKlLLWuinYbZapJAMJkjgr5ymJ2PwxT2s6K/EYsvAgFJ4ynv0hgGTtjU5DZri97DyJsJcB6EyKTRrPlaHFHbggl4XKpLZxnORhI6KNiSEJiB+No76/yZIs6fMRVyCKG5b60dfg9giZq5ZQ5pVF49V+smkFSL7AAhLRQrYgTYXseKVg9iSHV6Vd0h7z/k5FiIhAyOkpZFTRjSfimZxrUTy4yibdP1fAGcG64SINgH4MoCPjrNj+wNpDCRoQWoWuBJ5olkqlQOv/H3o/GLQNLXEUd+NmbHU3vmNJfw1ShuDJAY/9FEwudAG0pfOt1H/r/lUJIPi/bTgrwjGUCoDcBoMhyBmDYVzKsFlCB2gZixaNBJ/poGpyvnKCnGkjDTSWKu8n/p630aDkG6wlgAB9WV8Q/x7OKc/SDXn2EpPLb+on1UbiI5LWFT6Q7S5kJAlv0dvOEwUhdhR7+CrUpXHlfInvG0Jidb9tN+R1KcSzq3fQ992TXIc/aHD9IT9PBILd1+yVAAUAu7aOuJ1BzzxRS+1JAv2yUXhmFEhcEnUVWgjhb9idVJTTCz4S0ZEyTGGczSGH84xqxSzF0ZCJTJMtjcQgk1APhr8JTW5pugYOY5wTmV5itBpQIe/pLDiQlizVPhYVSEutwGwNE7EbUQ7UCqKgLQMZQgsv3d1TmJF1FTtuVIKDk1waVGDVg5J5ajPKTSJwhOvi9F8KtJSiQWscxBVK+rf47mgqL9yrFJ4+nuUQmUwqLbO4G1YEFv4nvOpyH7KklBy/Y+TRrFUPk9EXwDw4fL/ZwH47Pi6tP9QxEAEnqtpMCmeGy/4+b7XomSVYuc4g7K1rDRcMlwfb2IUhJU03WWWuRxjro2BZA5SqFQvJaJ50vppOSFD/xYqS0Uwh3oqyva0Nup7cebj+1oz/IUR4K8kUgjxyy/zbap+JtatzTxkG1LjlAEH/JxAaSkYCWl6C5r7ZTpsbUntPIwj9C+MJY3+4oLLsqhswaX5hjSfivUO+rEy7X3oksisJC/IWeVPUI0T4CH1qVDR3nN+j4X+MIGp+XEtaMG3UX9Pk2bF2jQ2CtsnhIpz7i+I6NcAPKz86d3OuU+Mt1v7B6k+lcxik3kqEjMOu+jx+wN+sfVGcEIuJLkb9ULrMPOZ2PW8j5qlQtSMSfN7hE/bGkodtrKfqU8lbqM/1Bl+NlQX8h4xcwl9dkIgSK2W38O52EFe9yM+z/KpyDUjrwdSjF9qnAOljRRO1CLMpNYbzwW/h5btrvkzZGTXgMNfJdyYQKshwkzcN/SB88Dh0Fo39nxGkOYwhp2qPnBLBc0WLsB8pxU0W18zSGDucA//Kd/zcKa02qQyIVGPvE9Fh79WQKY0CxUi+lMA/8mqAbdUku5TkUKlPn+gMEv+jBcGg2TB+3u4xqJ/gC8oKavqAoEpUKJxylDdgaFZp/i8IviqTN7QSHw8sYYMSwWg1KciLKoAfyXVZsVcS0YL1MxLs1Rihq/XqvL9qJmtuEUsmBQrgpS56HBGipjJDZ1R7r2c76CdS8EVQ5apjyq1oNO5SARsBnpKLRUZdeUiJ324R2KpkDxuj8PyqVgVCrRx6DW1lHGW/8t3RIOVpBWR5KkI36fMRwvnyUjPOEpTD1u2HPUrCX+N4htZB+CLRPRN8vupqJtfHYwUvXjSp1LObPRiJS936lOZVC0NZ/g7FGiqqy0k/ykx/jpUN2akUnDJxZzT3sObUcFfiI+rWc9CaPSlT0W0saA4faVfJhUqMTOWDCr0udYmY5gD4DkJqD4lRKGFFFtJbHoGuAg4cJLRlr8Hn0p5rhVcMRw6bwFmIDZpfYZzQv81a0hCkqrgEpajLsTDQOvfAklGujifShrxlzrymaXi8rW/5FxUEDIX0knSbHyPefmeR0qVXRmAiwMtEpTPRZL8KHjBOKlRqDjn/sY5d38ALwFwNIDziOjLY+/ZfkA8wkVG4VQRS8yScU5orUJLSsxipomN4lORe0XIQnVSM5a5NHYIbN1GX0R/WSXQLZ+KZg0FsqAUmWCmhvtCMCCn+2X4XKQ+lRRikxFmQM1AtDItnKFrfoScdeuvj0vrOAcV468FV2qpACksm9bDqs+WYc3hHEsZCcd9P/T59O9GbKkkgov7OwRsWs+F7KetfVt+G+knywW7eA2/blPmkMj3PFE0lPdcBpos9IdVLlroA8CtaB3qTkPRbcHlIAV0/LzGSXsSxXU7/Da9WwEcMZ7u7F8UM6H4pZCagZZMJ7WkebHYuFk8kk+lL4UKqusBLeGv/L3CnDV4IO+o15zXQG2hJC+lS9tIw32NfIRgZQSNs6szj3APGS7M+ymFo7yHLJwZ36MWoNJS0Uv3xMeTKgwyt0hUjc75VCwLFlKRyJYuEVGDiNeWpWyEOQj9yBXG7A/jdVOfEysjcrfDkaK/quOp34aQKgpJrpgorinnCrCtofQdUqzo8pOHFGvKYy7AA2I+m6K/hk6WtKm0qrHTKMmPLyairwP4CoDDAPx+W/fLUwx1ePOfF3ME0hdzInHKxkJB86k42D4ViY3nokoGQ7/QZPRX1ceBxoCUxayY9vmchtiXkbbhP7klkitBYZZpEQwo58gcDOOSOaEdmafCM6NltNxQ9cvwZx6vibqNeC4i4SbGIQVXgr9bkA+D+YBUO+fQlIwOC+fkfD/8uQftPM6oT/0MaQi3Vvo+OmEkRpoLE9ei8XLrZmjAStIyrCuBkx7goSlFzGJS3/OcZSgUyF6D38avG/sdGieNElJ8HPw+8BePuS/7HXHzPTVH44fcVxl2jJ+ni61ejGokUSHzVFw2qsRystfaphGqG/mFGkIZA3MQfoR8hBmie2jhqfzeC6rVVkMlwY+gmf9c40wjnigVXDmNUrmHHGuhMLkAb6mlS5hACG2peSoSf6d4LnK5Mpp2rkXC1f6S8Mz0567loCS5MCrDVyKeKD6eKyGkQVMapNkEf8nimp2MP0QPE6/vUUcN2kqT9J3CiGJLk2LrK6wEYe5T0SyVlfCpjBJSvDd3edynKXp5pa9BQDY9hWFLS8Vy4A2dy5Qnr/sjkx8lPDB0Og5bOWQNBiQT5XJ1jTRLhbh2bryU/lrGrDNlLsJccAHK+6BmspefOQbEhXwu4olX5k19KjXDllqvn4vUAkgc3Kg5vgX5cGuJCAnUF56YBY/FG68pQQtMYamsIWVtDYZOXzfSbyNKl1T9rM5x0X3T42klBg2a0oV86IPyDhW1VVq1EZtLfg6kT8XI++mr/pB4fUuYukYkELWVOupt61K+h1IZkQrROKnNjF8CcQZhOREHQsPJCYX5/hBTbMc4rl2PEpmV+jv8J9eycs5WO0+l7qOMFErN7tJSqS+JIrOsMuv+Wv+/BXPkyrQUBaq3cpBhgjWzTRkpH6vWhpYsKmEj6WfTNWdhZWR8ETLgQLM+O0Kw8eM63KhlmdsMX7eG/KdzzmCkiGt/qRCbHeAhj2uVGLRw9URRYGhCbwRHvVYZwLcv5kJal/Id0sJ9KwUz3aY6jBHIJIqKXJgcTGclP65E7a9WqCyB+H4WMgdF+iu0F8+XfK8fchpSjOoeTTH44Xo1+isstMRSiY9rDEjmG0iHaxJBpmhZhNhC4NfJcQL+5dfgr7rMhT6XCSPNaGq2pRL64D81jTJ/D4rmM2cNaXW7Et+QkTkdzrAYqdy4SmaZy3DfPDSlWyL+mG7hdiSzHgyTPBVtz5bIfwRKhE5OwFr5NnlfnNxpc7R3hD8zv5OmaEOpUVavG93aT97DZG+kWPh1lDb2l9pfLRkktblsdIyWoV1ACIWBGWrYU2AjyYAsnwoXbLnyJ1btrz0JZRwYsJFj16fHQz/r/mgwnrQirOKZubyKGCqxGZDmX6qSRYf1OdJKKAqhaIzgOM7VquoLyKdiUMPR2rDgxtz+NqEf0k9gPXfLwnWuGW6sfXHxfcNYpYWbq1Jsld7haAKQz1NJ9voR69uyLnnqAGBYKowXcLhSFl01IUs2rrQQaXwP51Krj49jnNQKlSVQ7BDNRyxZ4YxJ1rGBk45SjTb1qfhPzqz1MNt6DEDTdqwxbi2d6GYCWs5vo9xD08Ikk7M0To2RypIedka9/x6Ke2pWWWCWQ5fm20gnea4Ns7oAtyKcYakwBiSDAQhp8EWuEkNfzXZn68a56jfZj4FzhoUrFQGnhC3z8Ophcg9p9fH78v7wuUjDlpkl02+eC+knGymHpOCh6Nr6Dv2srQg9HNh+DzmqYRUilW1EVl9rqewflMPP5eY9WoiqvgmRlmxnMQdECy0tDZ4yUi1xUb4QSZ4K66TMadD8IQXJcEZKQor1OP6yDSGgZea/lvPDfRVWyXk+VrmtbDXWDDbO98hRw4Gh+Nky/g5tcyw1hFsZx9BgUOEe0jLMbWcgCzWG87my0SlkaHT9THLWZ5Rxr+aphPOQ3EN9Hg3QVA6ODHlYUvGK4EaD4ectlXicvo1clKWVxFkfT8ZaaBCcbQ059htvo/Wp7OPEnWfy5bcqAOdiz9PaRkFLyvlUci8dyutRnaNGfyWmu7SG2Es3lJFZZRuMoY/CrNXQ0BBqawQUDMQ9Itwa6UtXaHM5KgMy8HcghnzSkGGmLQ6VXBgloMDKnA4aqWZdWs80TEaaZR7PRZzfZOWp6AoT78dwaEBswvrsqXkqzVZy6KWVj8PbULcz4H1QrM9EsTPyP2Qul3zXc/OdQMQGVJ4mrMaWSvIOZaK/BkPLp9IKlX2aOH7e5GtQmRQgtFJRsbb8dC6Dv8sSK2I/Fd6HJP9DHNe0MP/C1LdM65elwjPBtTGalmX7VJC0IfsZ53/kBCzXnG0mZ+1U6PthWypRCOvQCnG15xusxEr4zCZxDgyGn8x3DE25aN2lsBERVXXF9NDouh8WxBb1U/HbyLnSxjqSpVKNw6ovFlsRMgIzzYVBdNyPI+5n6gezLdwm349lqaT+U1TXy7nQ2lCDTFgE2bioFSpLoDRPJdVwEie4DAlm7reBcPxyZms5GXMRT9WaMxh+Cl0pUVXMtAfSzOjEd6QxuYIX3gwbQmUY5VD3I+S1b0T5IUCKz8djbYrcUvaoZ/fQggHCfPBxSCNC96noTC7nnM5ZhrwPOsQGYalozFgk9goYj1viVvRXOA6EXBjNbxOvX2ldyrkqVGZsr73Y2a+/gxL+yvmwNHi3w5S7anO3hntY7zkfq2W1ada+zJdqSsYeJ7VCZQmUy1NJHNhqccE09lxzvnnNOF/i3Nqf21/P7q8IncCENWtIhobKnIZUQ0oZFLfI9OgY/1lj34Y1NKzbIEICC0lLRY2aykElimasWp9DZxbGlIwwgQLR1MaeOac9PBY1oYZXS1+aLNMinej8uaswngIF5nOLdEd9tp9UD9SKMPNzkbeGmqzkGC0YpRSMUn1AWLi5xMQkwgzxcSvUPLe5W3qPoRpSP36R0gqVJVGsaQ1VrbbeblV3tCf+ClUoOH3PdJZvMLReSiBitjnBpzH8TpGWsVCz9sOLazqOhUWVM90Hef+UJhD4cS0aKSnTYsBG1TgyNZwGBiP197BL9/h7NEUSacxF0zjrsWo+rJyywfMq7Hsw7VuxVDijzEV/RQw/04alnVdQoKqdo2zDf8oSQoCAqBuqRmtRVTJqUOZ6+TZS4Zhz1MtcmNqn6EkWpw33qJ+prmD6e9f3UJN/W0tl3yaJCVtWBmA58LQS5Lp2YTrRBbyWw2qHUkOSEIWh1abJeLYW1pQrkNOyOCPM5QqMknQIiOTHqo0wXzoc0+RfCv2sEwJtn4mF8cvMacshqyWKavMt5as+3zHDj7Ld1aTBPCPlayfn76gsFVFTS7Zhb2hmWyqpgI2TCsM5CUScVKVAfFxZ31UyqVHdesjGKe+hWTuqFcEV1CKOtuNzoftU4jaaCmOOk1qhsgSS+LkWBlub/82VdeXLy8177aXizEFjckn5hyb4S8kV4HuVA2EDolQL4zkkiylN4vuJup8Z+EsvBpnCA2ob5f92DkksuKxKr7alYisa1XG5B48MjYZ9HEJztoQjEigwZaRcuGWjv1Srzn865yo/gpVxH+6hMfwcQydKfVxx0iDiuVDXXsPeMvwdVvxkchwDRTjyYJZ+JsAjTgTVkpTrfmrjcKINrZ/2O4RyHK2lsk/TKD6V8LJYmbb8EVsLwTmoLy6HplQ/AurrgVRojeIALyjvqJfWkJU5neLaom5X1I9holk3t5Hmwuxx+GmDQODBFwEeSxIPhYY/it/Gsl5H86lYCZjheAqxdcXalAU8Q5vVPRRLha/vXLRd9ExlnooCTVn5NHmfShirXl8sl1TY5NdJBJe6bsDC8u1IOKufSaScag3lYWrNgs2V3x8ntUJlCRQv2DT6izPkpg2w6j0pdJNVtVSIbflq7IUC2Al/Vi5NUoG1/L1KsMzUONN8KmqMfQa3TpI0E4GgFYNMI56aSsHkIp6seljhHlqCpT8n1ihVjRN1H/xc6BF9Vln7eBxKYAS7h57hTdH9m+bTEuJAc/QXF1zSUc9Dca2s/dEEbN2GDkciGm9SMHUYH8/5O7S5iGt/5QRsfQ89MbHuxyhRbLmacHIu5FyNk1qhsgRqShDj8JQVasgd3P64riVpPhVuqeSyyCP8vSEiKty3aoOUukYZrFaHfJDAGJbvqLrHHsT5h3O4RSbbSGGjVDv3jNQeBw9s0LfxTTXKplBdQPh+NB9AJBDiMQ5c2gdSmLEMvojmQqkuICMLNSYX7pGtzJt5P6RFlfgRNO08o31LZQTQfRFSMPFkVe24HEc+9ygtx5SsX6f7O7jgUqtGi3148tFf1lYcrVDZp0l7KZLjzNcApPh54pQ1zHsVGy9ip7C8PlmsztikS0J00qkrILasE70B19bKcUjMWUIMSZKmlp0tjoe+122gbCP0o6EQo3Hc90N/Hsk9FNiIC65KMCXlZuo+yjZSq84K4RbPLGtFpImg3MrWkh/5M6shNg5phrXl/+8ZeSpNQocrGvy+4XrAjm4ELJ+KXj8vXwomoygUVK3rnKXinFMjzALxuZB5J5HCYyRC+3uEc4Zi/cfHx0mtUFkCRZCLwkxVhtxQMM8qNNdXyr13C6rua9VOAsRiVZk1oj5KwRX6qJX11jXSnBM9Fx1Th3Xqwg/lPfStgAOp5fcTKFCDjaR2no4jtK/uI440TFaHx2yG35h7JK06w4kuLUMV9hzW90j6WVCWyXHotKmKcWgjm6diBHjsiaWibjZGsUBI+qmEcKsJlgwik23w7SEs32nop96H+KFqCiqxdWPm9IAXlBRrUzyPcVIrVJZAUihIbS+Cv9TNqTToScdJLYiBa5v8Gn//mJHKxZrCY/nNltTy/aINzTmtaZxWmZZ6H5O0n7z2V24r4Cz+zvJlss5QhdFy/1E4L5un0mC1WXALd/T7NuxIInu+bastfO8Ph6qfrLoH66dW0gYogxYyEBuHTlV/B8+rGAHGywVfNIWaW3XQRrJUEPqhh4k3wdyhn9Z+Q/E4dAtYKhvq7qjc+sxY6uOksQkVIjqbiG4noh+z304lou8S0SVE9GkiOsS49mVE9GMiupSIXt50PREdT0SzRHRx+feucY2LU6cgsaDTCBqeUQykWn7y0rC1xLU9C5pKoat0sTpjsRJRo1O3Q5q1ldFIDfx9FIbv8fkUk06CARr9NlobqVWmZYnn/Aga/KXtQV8JDQX+KpT5lgmvKYxXX8+tOqufRMiGLfMCndq6kf3Ukx/rZzIKbNQTSbOhjbxw1LLIldIkbC5SiytWmohSCC31qcRh/6F/gGUZ8h1DFaWo8oONGu6u1KVD+g41+WVykZ7jpHFaKh8A8ATx23sBvMI59wAAnwDwF/IiIjoFwO8DeDCAUwE8hYjuPcL11zjnTiv/XrSsIzFIWhqJZssZslKuPdKMw2JTtwOur+dNdIvUiZ7bQleWbgh9zC7WCirRGb5WP2w0bZEvvXrBa4y21qx1LczfIb/zozT/ByqjjBmQ5mcAGphxIddEWqalFlz6tsipcLQj+mR2NhAizKQFHCsK/lrdAg7tVD4VVTjWzz3Xz8HQH3dOPvPUnzFK5JZe7LF+x7TCmLl3VAbbAKmQB5pKwSh+SXUfnnxJm7x/iQeyKBAyE1zaWA8In4pz7hsAtomfTwLwjfL7lwA8Q7n0fgAucM7tds71AZwH4Nf24PoVI5nIpjnwmkJpc4xQJj9OdEQyHrOE9Ov9Z7RYR6gUq4aGOqfCBxp2PoqlUijMwTHhyZlDaC+0r0d/5UuTcGbsBWS8S6a/x2jl3vn2zvmghHQDLQ5NaVsWR9crEJv6TFXhWM6FAseE5gbOqX4yIKzdcA89jDb0Q0/Mrfup7X/j28jDjbF2nibmytp2C4M8jGcnvIbjSrBLebvIglX8S5X1mQlnHzqXLeEfQenqurKVv/DNlW04p1tcLsqMGw+ttE/lUgBPK78/E8Bxyjk/BvBwIjqMiFYDeBI7L3f9CUT0AyI6j4gebnWAiF5IRJuJaPMdd9yxlLGI8NBUe44tlZSBcK00FybonOEspVSo5HBUq4Q5L9Qowzr5vhhaVQCJ5aoJf0gZvlXFVdOcA6MI7VsJaHyc8h78pespFoLvRz48NcLGlXGEe8S5SwoTKxWRendJMq63I/qy4dVsl0ANjgnMZjCwhWPUD8VSiSEdu5py5HPJCOBmnwqSe9TMuH4HJxtKweT2+slFJvJ1ofVTvufWPXJ5Wrl8m1GVJi7kY6sutnDHSSstVJ4H4MVEdCGAdQAW5AnOucsB/COALwL4PICLAQwarr8FwN2dc6cD+FMA/2H5a5xz73bOneGcO2PTpk1LGkys5VjRX/57v8Rz5YtX4e/D+hp+f8BrF73BEJNG1jPXnGPNOGZATVqWhReH/o3sq8ho51oOCde+Nc05MMQ60i3fRjZpEDWjlfMpI7M0OMa3r8Mx4Zx8Pg33qQwT6zO2Xv1vuTppKhzDlJUFRRGILZVU6IwyDq5M5MKWvfWZQkL+HrFPJSvYckUUy7H2+in81fSOxn40bRtfVP0L50jB1Ing3Xztr3wQSd3PXFLtQIGQm+HIsg8rgH91x94CI+fcFQAeDwBEdBKAJxvnvQ/A+8rz/h7AjbnrnXPzAObL7xcS0TXwUNnmMQ6nEa/1QsUvsp65D3i9WMM19fGaofcHDhPdVKgApTaoQCWapZIz/xdUweU/LQaUJONZjJSFr6b9rBm+FmEWGEXYuc/eCjjui/piDx3bAVBj+KjGoVlD4f6aUzeMZciYlBTifC56ig+gCTuXNZ5kdjYQC6YgpCcV63Iw1P1k4RweoJGOs54LvRZV2b/IMrQFl+3vQHUcyFsqPeUdIUiBYFsyOQi6isjTIrMKD73xcUhFwfezITQ6mm/5TONxABnBpfKCWACPk1bUUiGiI8rPAsCrAahRWuy8u8P7U/4jdz0RbSKiTvn9ngBOBHDtOMcCSOw6xc99SLH/riepsT0rRtDgrRBXXord8iMA5YJXGGkdoTZM/AwqA8qEuFpVXOtQ3jQCh49TY3LhfqHUja1xxhCEld9RWUPKWHNl63kUmlVQUvqP1Agz5lNRHcvST5bxYallcZhgWuj7dRPlJzFI0863ycOmnEkFGG9qoqMcd0ZwRurPGM0XpysjzjksDNIqxTIsOZesWr1DSk2tQHqiqBCORoDHkEGBXBFILZV8sMt8Od/8XeXvurbXj/TFjZPGGVL8YQDfBXAfIrqRiJ4P4NlE9BMAVwC4GcD7y3OPIaLPsss/RkSXAfg0gJc457aXv6vXA3gEgB8R0cUAPgrgRc45GSSw7MSZkM6Qa+1D3wcco2li0BkQT2IbZSFpWm2nYGPo59pgkVlGYldoqymrOdXea2a90C+tIaHJdQuqoAXtxeZ90HMBaianQUKyn1aFhNBO5e9InOQid6nBMtTgGn59Mg6hOWvKTBzimrbBC0qGdZfbpEvz53GhMd/36PSUwuSiqMGM0Bi1TprlAB9U48igAVowQARB5zT8vEJTv+dDBZHg6yZ9h2TAQVOwSyXE2Xxzq03PiaMoCXmcNDb4yzn3bOPQ25Rzb4Z3yIf/VUe7c+5txvUfA/CxxfV08cRNZ8vnwZMTNSYmtetCYYSutFS0Fz/cWy3bzTQ5QNdqEybX1bVzyzktNWc7jLZ+IaYU4evHCROO6XZ49YA9r1JcfWWadepTyScuhn85M9YVBZsZRz6Vvu5YTsLEIyilHEYDTMchoaz1qUSHAXH0l26p1McWBkMUpIeBD50OaYZ+5K0IpU6aqjSxgARlrBzSTAXwiG1kM+qF38ZIFI2d6EwgVBFmNWqh8ory+7wiVJqy9uVcjJNW2lF/QFGI+hgMHYYu1ZI6RRExiJzzTcvQ5uGMKv7OLRVtIUlLRdVqayamac5VFI9jDCiz0Zf64jLH8Vx/EMEkYR7CPSzH8USnqISBHf2VYw5aG3kGlDrAayGff3HtZ841495gmDDBqYkC8/060122wYM3gBCZZVs784rzmvvicjAerwaRy1OZ7w8x1e3EfoRIAFt+m2YYjz8P3880RypAX9o40rwhm9FqQrwpqTCMgyc5a9UewvocRVGwqxTHlkoMf/lPK8Q7tLNfw18HA4WXVwu1BbyTO15sea0W0DHjwAgT7Z35VLJZtmyx5mpRec05jWwBvOAKPg0ZAuvbyDBS5jua7w0xrThT/TidmqcS/g/MqWkr4KHCgGrcmodG55+HFf0VaYMKlBdprZqGzx3LYpyrJjoYlFCjFhrNgzfqNqJbRMyjN1AsQ+6LMyOziGnOus8FZTvzvUFiDXUYw6+rSeQFcN5PZgey8HdQzz1Cpo3Ub5MrmNpYpVhBFOpz8hGUTSWEwvpeUMZKytrUIMuVsFRWNPrrQKOwIBcMJiUz6nOl1nMJTcFRn0Al5bn94VBdSLUGlNdqeTRSwhxYFE9TXaMwjlw28Hx/mFgqvEaZtU+J96nUmrMGsSUO10hzrl+6BcNRLxmQBflwDd+CbJxzpQZvW0OaZThdzs1cf2CMA+U4OAPSYFX/XYNNw7iGQ4c+9MREvuOnZqkQUTVWdZyKwpP1tTWUP5nteb/Nqsl67cTKiGV9ylwyfa5i61O3hoBmZ79m4YZ+WCHFHMar58IWXE3wrQXN7vc+lYOBAu5ch6hquHSpMWpwClGknQA6ZOOg+2TUchuZjXs0rbYJ/lLzETKasxa2CcYc5nqDjE+FZ1+nlkrQeK0ENGmpyJLyQCmgAyadZUB6hYRwD82K8PegChICgOlJIUAh/XDx9UHgzvUGWQbEn2mqkcZOXWvd9Id1fnVTcU05F3KsUxO2VWdZ8ny+tWfqr/fHZxf8PVYpEWY5tGDUfBvvz9PgL1THgTKaLrOdcE8R8kAtQPUN5GJEQbf2a6Ez3x+gU5BZPUATjnIuxkmtUFkCBaerhdHLnRlz+HquzIpzDr1+KpQ4/JVlpEO+j0NG8PX18uSAHRpaYefsxc05Q3OWytDxygPxPSY61JhRn7NUCsaNLadunHhoR39FDMhgxnNBs1bGGvlUpKVS9mm+N2TWayaEezhM4S8GlahRicxSqX15GQ3epRF7oS8D58rgC+knQ9VGrr5Ytf6dw2Sh+NrK47t7fUx2CzO60UILZK6LGe7r9I3XZHTjbG+A1VJRIJZjooT+h3Z4deucAO0Ph4qzv4YCFxSYuuqHAYWHPqwE/NX6VJZAqU8l1WB49Je6SdEwZoRWWfmeYqlUEMPAZaESh3ox5YIFFgZDTArmEDt1U6gkfOflYnJtzPdtSyXKUxFz1WU+FdNXgfo+vO9ACiUCmmWZd5ZW8JfhcAVqZrx7wQuV6SQogUVmKSHc04qlEtdJq5nccOihJym4uAWcddQ7HoprKRN6RJMfax1SLJ8pjxrsKbBpmIumIorh+NzCQBHQ/jNnqYQ+AMa6Kfg4/W85n8ruhT5WT8a6eFT7S/F9+rFQlNyrCa5Amv+VKwoL/VRR8OfE1lDO7zhOaoXKEkj6VFJ/RFz6Xr64U90O+kPvq9AytDmz1bRa7u9oys2wF5pIfjT8NpFFxvq4esK/YIGJNmUDz/VS/J3DfFb0V7eg6piaxKmWjNcFtKXVyqJ9i6v9RdF8qAyfCXFpLdVCZcj8S6llOHQOs70BnAPWTMVMTuapaOVowhit5EdeEFKbi3CNC/BXJmxZc4D7sXB/hrYxVa0M7V5ILQTu4LZ9KrW1o+ep1OPUy7TUluFw6DDX04V4balblgpFyY9WtYd6rOkzDfJgQbE+/TmxbyhnzY+TWqGyBAoYpbWgfUY9s1TE8bXTfuHMzBtOWZYUZe2cB5QvrhodU35xtc9D09RGwd8HQ6ghxWumOuUY+lVftL03aktlmGjv2out+VRC+7rGyTHpdJuAyKeilC6R/bScpUBcbsPagXL3gp8Pbaw5n8p06ZuIHPXKM3UOmCnbWC2ECqI20jwVnvxoafg8yVLLt/F98YxyvqfBX/Ha5e3Kc5yzkziDxbW7N4ic9LING/6Kw5ZzPhU9pNh/OvhnAkDtR5THYlp1eiCK9H3OzPexdiq1cHkEpRTiVT9cJoikqCG0cVIrVJZAQSPMOgkrrDVd0GHh7Fro552ypTWUhhT7/61opMhXEbSwDMPPWUNW/Hu3U2CqW1RCRSuvz5mcDn/V2qC2nwoQfCoct7b9Ib1huk0AhwJzjuO8pVLOxVCHG4HasqssFYUBhddam+9VHP5SixPWzH73vG9jjcZsGVSiwbJhjJYVwZmtVjPO98Uzyfl+GlLMa8Ll5juc05TTk4O/ePCFHiyDarwJrFq2uTAYqu8gD1QJzzS1mGJFQWbUh/vwdyhOco7nwfttYkWBW9HzpqUiHfXpM219Kvs4hQU338/4VBhmLI8H2GLXXJNQsTL2/edgqG9vW2tZVhVjCX/pe4yENmpLRVhcU13sKoWKlX0d1rKu1dbjtKy+bqeomJMe/VW3sXOuh3XTE/FxXp0glILJhPtae88AwRehw4nhmVWWSjKfsRVh+VRmFwZV3TgLxgtzLuEvgmByVkSfc1XukSVAe4MhdvcGieAK97HgL3W/FQNaDfBtLqNeg7/4+1GXm7HnW4NmN6yeBABs373QkKfinwmQQpoc5s6FFAcIDbAKY9brZq18piR8KqajXod/Qx9a+Gsfp/DMQu0jvUyL/65p12Hh7JrvZ6sUB8w4h/E3lbGYWbC12gr+0iyVEZjD6qkOZub7VYy8nuFdWyrTE6mVEfqpBQMAXmDXOz/qWm14X3bM9nHItMCkyybzPhVuqSjRX5pT13gmM/MZSyWyIqRQCfDXUBVcXKvdXT1Tib8ji7/XlgrU3CN+zl2zPTgHrC+ZrzzHO+rtiL6mrH2ghp6yPpXeQAl6qBWFXPQXh0VlG4et9ePasmuhLtSo7GzqkLE+C+7DyodfV5ZKZEXX46isIQF/+T1y/HdNiPtzynB3xRcX2gn9fPc3rsEnL74pucdyUCtUlkCByVSWiqKtRaXvxYIPQmVmvq9aGlwoaCU9eOSVvqNcvVh3zvUAINHgo2Q8pRYVh0o0Rz3gmdrMwqC6j1ruPcAYiqUS+zv0NrpFg0+FabU5S4XDlc0+FVvjDMJPs/yAWuPUIJvIpyJqrYW5mesNVGbMLZXap5JRFLQqCcxCsPD3sHbunPHrZv2qeD7DWIfOqfXc6orOtuCS4eqqT4VFfyWWSvk5dJlcMW6pKM9009opAMDWXfO4a9aP9RA21tqKdlUCZg7+0vLJgBq+suFGL7iC9SktFX88PNNB8g4Btc/EeqZrJju4fssMAODc796Ar1+5tE0KLWqFyhIoMMP5nlWmJTaLk4fMhEouYikwW63MBeC1H93R78k5D7EBwDpFg89CJSz6y4J81k51/RgMK0NaKlaiXMSAtNpfA1e9NLnksB1zfRyyKn0pAf9iLhgMiMNGWhuhr4Ohw865fjKXfCx2SHHehxXOn+8NslvPDp2r/FiSAYEQVUmwa38Ns5noALBtt98Hb4MiVILmmwsT5xFmdo5Ic5203b00lFfzxTUlP8o+cEvlrtkeVk92ku2dfR8dUxRESDHFkYdWnkoYJ2Dtglk/U22skfJnOurrQBXZxrMffHd899qtuPr2nbhzZgEbFetzOagVKkug2qfiGUhienOzWIv+KpnBzvnRfCpmWfpSAyKKNWcOn+20hAp7IdQyLczZb4X7rimFihVhFq4P1s60YanEGfUK/DUY1taQovVu3TWP+f4AO2Z7OERaKsLq8/fMMyDZBlA/0+27F7Bhtc5oARsqafaplPBXb5jPPXKoHPVWqG1ow3qmfgdLWxEAgDtnSqGijLUgjBD95Ux/hzwn2UK3/PzyZbdhdiGNGowizIyNwNLaX3Ebh67xjDVYKtIi4/6+WfOZxhua6T4VisJ9tWi6H/x0ewWbrpHwF1s3uZBiHo0q38MHHLseAHDT9jnMLAwqgbrc1AqVJVDtU9HhlA7VmklfsTQ4/KWFGnLncuPOjwYmDXitdUcFf+kaUND2LI01JD92ijiqKoyD+4X0Tbpq4Zsv6WHAX52itMh0JgjyfqM//PeLsGOul4wzrmirC8c4+TGfGb19tocNq9KXMlwSNM6cpZKt/dUbYGa+j6luYSoKAf6SPhVucWl+myoyi1sRhv9oWylUNPgraOjziubMLdxcMh4AuKE/z/JPveDczZhd6CfCk1fhzlmfAEwLd6rbwSHTXWydWcAOVaj48//hc1fgth3zAFIhHvJ1AN136u8jIyjjcwZDh+9csxWf+/EtADRHPfOpGCHFoTy+Ff0V/F63bJ8FgNZS2Rcpjf6STL8QUSHCF8GFihKdxeEBbVe7WuN0Rg2owIDALJVUE+OOzlxJD8u0Xz3Zwcz8oNLk0tL2ZeHBXroPBB+nQy24JL4+UfgyLdYLE37/6hW3Y+dcP7FUZJ0oGXIM1FqtL1+iW1wd8gED23f3DO1dwF/G9rbBKpM+rIlOgW5BmOsPsHVmAYeXmL+8/zev2mI6ddMqCUYouuNCWn8md5bw13rDKusP/dqxo79sRaFgQqE/SItWhr4BZZ6Ksq4C5eAvoA4G0J7pYWunsKW0VCwLFwA+euHPAGgJraIauZqnUq8tIM1vCnTlrTsBpPAXF45NyY9WYETo982lUDl0TfpMl4NaobIECkxpvnTgpYXm4mx1+ZAnuwUmOwV2zQ9UrDXc/4Pn3wBA99kAtqUS6L3fvDYLf0VOeMtRb2h6QAl/LfRxxy6vyW0SZjUxjRbQEwKBOhxSa6Nb1v4K4cDynGAZAJ6hH7JKOupDG04t8Q/UL6VVKRnw0Mdsb4C7ZntVOKq8R+jPZKfIFv1zTi8rMj3RwezCENtmFip4Rt7/f390Cy67eQcmOpRCT0UtuLTgi8Db+0M7Lyj8v6V8pqqjvqj9ian16T/jUHTdGgpVKeTau23HXPXdOT2SLlyf284gnGNZn2umOphd8M80XTf1+WaeSpGvxODP8X2YMyJFA82V70jqqK+FoxlSDLL3VkINrd603c/roWtihWW5qBUqS6BG+KuI81Q0DWbtdBe75ntZS+Xq23cBSLVJyfC16BkAuOC6bdgx10OnoFTLKl+InjGGuKRH6hcCakf9ll1eq021a/8yhCKLZpkWA4IDQka9q2A8+fIHoRlIE54AcNOds2okXTgnKk+uPK/Vk13snu97n4rCaEPfd8z1EkYL1Myl3po5PWf1ZAe7F/qqUGE8DnfsnE+eZziJh6/a1a3tkh6rSk351rvmsGqio0cbEVURUalgY9BtQ4TZ7oUB5nrDREjfctdc9L9cm6qfzIThbEtl1YRXFHT4q/6uld/35/Ctl/V3JCgTIZpOs3IBH+UGKCHFAurL+VSsEkJBmbvlrtZS2WepCf7iGfU9A2tdM9WJyrRolkog04oY5H0qgGdA66a7yT1DVIq1xwgPDQ2Z6ukYuhg64MY7dwNIhQpAuPTmHbhhmz9uOXWds/efnyiTH6uwz+m8UNGSxwDgn7/0E9y0fU4VXMG/VM2F+ry8/8hbKulLGRjOnbt7iUXm++HbCAJW5uyEvu+a72PrrgUcllgq9dzMK7to+nO8hfHub1wLQK9JB3gmO7OgW1RBWG2bWUh9GSVNdooqVD1X+yu3/0doA0gxfm6paOOIIU0dYuPM2LK0pyc62L0wMKIG6/PnDAHK957RojTDfYbO4c7dC1g31VXXH8BKwRhQ3865frXTpqSwtoKAlUpRLVT8vLY+lX2QakuljP7SCko2mMVrJj0DCQs2DmeMz7Xw4jojWT8O1EIlHYMXfJajk8MY8z3d7A7lZm7YWgqVdamlAgDPPft7AFJGyiEKbTtWoNyka1hbKlKj3DUfCxUt6irQzdtnVQ0/RNjctdvOzVgz2cGtO+YwdPrxcN/tuxfMBDXHYBBN8IRoOh3+qgdy12zPcNj6z3/6wpVqGxx22mWERq9mwlFrI/RzaykQcj6VmXnvZLcs6a0zHmKTY33SA46O/k+rPfjPS27arm6xy9twzkN1GjP3PsE+ds2nvji+bhb6Hj7LFWWdU5I0w32Gzj8zzT8VaMdsD0R6yDEAnP53Xyrb0K3gXKRnuCZAmmuV574c1AqVJVB40DVDTi2JQVWvSi+JvXaqi11zfdy8fRab1k1Fi1463tPSJQzGGCjbyrLLt87MJ1FCoY+80rKpcZYx9LIkCFAHHFy3ZQbTE0WSte/E+UnyI0tMnF3oJ+GUfqwl/FUlqMX9CBqz2QabjFnF6QvUEEWwhrSXf/VUF7eWmp6E4IDawbrdYMYhEm6uF/xLuvW6ZdcCZnsDHLpW96kAvp9WvgIn2UZgWP1Mvk1tcS2o1lDoZ7Aykoz6ssktu+Yxs6Cvm9CPoDlLofKyx5yIXzn1mOr/BP4q181nL7kVX7vydkx2CpXhAz4ZdbY3wEYJJ8IrAiEgIS0FU9/PhJ3CfA6GfisCo6RNsFRyFsJdsz1MdgoliKT+3h86VXDx9dspCOvEnIdQ/iB0LL/OUqkVKkugBP6SpS6otlT8fii6T2VmoY8b75zF3Tauio7Js7UtXwG/yDRGKRmQxhyICBf9dDu+dsXtAFKttsqFKaESjTkERvrTrbtx+Nqp5IUIQjeQ9DXwPJUZpew3AEx2CAsM/mqyVKwIM8BbEXJHRqCOzNpeWiray79mslNp55pgCgzFCxUdmto2s4BPXHQjACQ5O4BXNAKUeKjoA3ccby8ZUNqGDnvI4z6Js6dqrGFsO+f6tqUy2a3mKg2n923869evwQXXbVNrhwUfynV3+CxvifETUQQxprXa6u9X3rpT92FRCDjwz0zCiYD3HwXhqDHrQDMLaeFM3saM4cgHyq0b+kPcaUQNBhq61NribQTKVSnePruAQzSou6DqOU11U8G1XNQKlSVQWNRzvQG6ShhsyKgPkT66T8XDXzdtn8WxG2KhIhdSgklzGEO1IhhUsruXbJ/Lz3jdZy4HYAuVYKkk2duo/Re33DWbwAdADQ8Gkoy0dup6jVJjQMEq+Nk272SUQiVg6lUbUnNmc3Hn7l4S6hv64VwdRqu9/Ksnu1W4rsaAAjNeGKRb7AK15vv2r15t3mP1ZBd3lsxalrUndkvnUgtBo8QHwBSFnXN9rJvSxllfk4O/qnOM3CMAuPaOGVUZCULk2rJ0iCbE+fxYQSSAtz4tHxZQQz5J4AP8Mws+ET3woSZtLsJ8BsVmlaIUrV81ge2zvTJpNu/LsGBTTupYgTIxV49MBOrnlBOeS6VWqCyBKkulpzuXQ2RVlaSmwDprJ7vYWcJfd9u4OjomFQlpVvN9MTShwmXcjrm+qgEFp17VRiZreWZ+oI4h/LZjTklQwwiWSvn5rvOuwa75Qbo/CICj13uBe8WtO1FQmvAnKWepAOlcArVPZfusHaHDx68xoCZmLJ+p5VOpvmey5QGoikLA96t+ymQ9Bmk2wV9AKpTqftpjlfqTJlQC47vmjl0g0n1UXPinUYOizwajBWqhomWRR89MUQQ46Tsu+s/vXrPV7MdhayexbWYB23f3sDFjqQD6fI9iqVQ+QSWKLVDom6UoLAe1QmUJFBbYjrmeupC6paUScii0F2vtdBd37JxHb+Bw1CGxg1u+NGk12hr+mpnvJxiqNG+1FyIECASyILShIbiAONJKY9bzUqgYfptrt8zg8pt3qJbKUeunAQBX3rYDh6yaSKzCp512TPR/wqwlMzdeXOeA7aE0iZIxz6E5zR+yuoEZk+iIHv3FBJdRRDHQKIqCtMrC3L31y1fhlrtmk4RYIF4HFqONLBUjoi+QZuEGy+TGO2exdqqr+hw5TGlty1Cdq8Jf/jPAX1puBp/jJg1egxuDkP7z//4hAB3+2rh6Elt2zWPHXE8NRY/aWKQyEkrB5IRKuK5JeC6FWqGyBAov1ZZdC6bjd+jqYo45JzeQQh3yxZRWQuTvMBg+J+2FkAx/1WQ+/FRjDrxdbbFLS0Xbt706dzBUfSrHbPBC5WfbdIjtrc86Dc95yD2q/y3BFUh3pvr2P3PJLVgz2VFf7jUNDGhVhgkCCsNvsFSsIoqBNI2zab457TCjv2yBUfUzOkf3qdT3S++xftWE3+hr6NR1BcTCX5tPTuo7WC6uN5WRcBr8xeenCf6aHMGK0NbWYWsmsX2330agKepK3yulWYB2CsLM/MAMd+fXWc90OagVKkugwGC27ppXHb+BIe+YC9VkNaeszaSkViqFBvd37JofJMdDVdVAo1gqlsaZjf6a5ExQESqDvKUiB6pBbJvWTlXCR9PCiCgr3Jqc10Bd9+uKW3eamPTqBgEaafjKfIes7Nw91k7Z8yk1Vu2ZSkWhSfvWhEqnoOreo1gqyR45op+a0OgUVCkIlkKU86lIsgJRAO9zmehQss8OEM9x01ypDnJhNa9W7sGjzrSxPuSeh1bfVUsl6Ufaxi/e63B86+otuGHr7mZLpYW/9k1aXVkqemZzYPqh0qvmB+ALzPJnVO0phewAVBCbFFpJQTlVqEhLRb/HX370R+gNdI2yyc8w35NCpWmcSvhpp8AR67y1IsOJA3HGluDvmXMD/ezO2eq79VLGloqST9MpWIRNOhdSiOshxbZQSYI3RhIq+ddcEypAM/7O52KyY4fiArbQCP4FW6jUbTdZKrqiUPuX1q+aVCOe+JptmqtRGL62frmFpL1DH3nhL+BB99gIQJ9vaeFqgv7ppx9T+dMsiC1Yfq1Q2UcpMPGh0xd0iAZ52Ud+AMDwqSxB2wsQw0J/iNleaqnc96hD8Lqnn1L9PwoD0rZK5aSGS5b71Psx7LmlksB8RgZ3eDGbnJBAPhpJnhvoJ2UxPwDYaJSwaLJUgFoway/+rBQqiuDJwV+JpaJo73K+my0VY6xhHKaj3o7+yp3LKViE1jPnz6kZ/kqP38pKvaw3lJE98ano1mc+8RaIhYoVZBLme5T3VHsmPHpO26kTqJ9TC3/to8RfeI1J3feodQDq+PVcOC6gFVrMa/DB7A7hwNr9uQNbXayJ5pyHWyzmENpWHfWsDS30OtH0jDbCi6n5VIC478lLM4Kj84zjN1bfNSc9EAs0C3+vmXEz3Kj1g+emSCHeLQgPP/Hw6n+NmS80hHADwO8//ITqu5a7ATDhaIYU56G+6FxDaDRbKqPDX9pcjmJ98ufY6FNR+iBLBGmK16EN8BdQ9197T1M/WXoOT9ZtGmuTRbYUaoXKEmjNZF5rfdppx+JMxqiaHPXay89JLrZ1U90II9aEynSDpjfHGJCWkSwdrpZDNUAo2kvJNeehk/n1o1sqwflo48X1+KzM6kBaP1/z1Pvjsfc7Imor6QNr27RUKtgoPS59KhozPnzdpHmciPDB5/887n3EWgAp7AQ0h3ADwCueeL/q+2FJrTZP1TgMBsQtnCbN13JOB1+D9cynMpCmJO39eei9DmN9MCBNLhwbmK12fIeo5tAsVPSxhndosdbnWsaPLPgr5Hu1lso+SqszoZ+BDmMhjE2Wioy8aqKiIPzN0+5f/a8JrQkmKLScBp40aEWUcLKshJDwpTFr3sYwlSlRQh9gWypBiGvlUXgfNEqiZ5TnNdktcO8jvHVpCS4OMWgVb30/RrdUpNUG1Puma/0OtGdQSf65WpZKEKwWAzqy9HFZ/eB0jEjsDRTm09Le+XqzijAG0t7BZ515HP7il+8DwG+ap9GmtfU4FhNSvGOuGf7i66ZprKMgCk0BA1Z9sSBs2pDifZQmOkW1ADQ8F6g1tILsirSBtJf30r/55WwfeDa0ZUVUQqXhhVFj3wXTO2q9pdWWPhVDuOZIvusWkwtVV61xHrnO3h9C8m4tox5AVT/NYi65YoCBAnMYxaei0SjVY9dXGmczVNJUjsPaVjb4OywL4QiWV2UJ2EDHbbSEih+H9Ux51FST4LIqGBxRrgtrHvg4mkOK0zb6worQBM/0RKeyxqyxBmVpOfxklqWi1T5bbmqFyhIpLBRrMQaTds1UWosn/B6oKWchd3/AhmwChNWESaubY4nfjjxkOjkHqLWzppdSIw5//cEj7omH3PMw9bwwDqdAaICtDQNp0qEGw/nfQ5/0+2ghqZLCc9Dme3ahWaho1kvSj1W2VisZUBNZTC4nuIA9K/Vx7IbV6u9BcGkRU0DsX2oUKoZFtY4pdhrxcWjW0GufejJOOHyN2cbf/MopVeQWYAuvUBzUtlT879rzSyMo83NhWirl76Osw8VSK1SWSGGBWBp6yHK3Ij5y0V+jEMe1LQ13VQYq4aSx2dWTXbz/985U24vaWIIDMLS7bqqLVz7pfqbWW+fl6PexBB6QBhwEmEtSEDYWYxilCF94cTUGtVwvc8DPR7FUmsgaUxAqErIblb76Z4+svlvwcA1/5SPpAF3p4XTrXbPq7/X4mp+dRmc99AQ88ZSjAOjP9Kj103jTM08FADzjgXcz7xMEpJbHAtQWrgzzB4D5PbRUmuDbUSzmxVKz2jUGIqKzATwFwO3OuVPK304F8C4AawFcD+C3nXM7lGtfBuD34VfIe5xzb92T65ebwsO1LZXRncvWQjlClMSP718/Qsu0XZWJKuE0Iyr9Bvql+xyRvQ6o/Rmy7tQotGaygz945D3xq6cfmz3vsfc7Eh/4zvVR8AOn3PimJzo4+6wzcNpxG7F2qmuee/px/t4/d7f1I/Y+pWBFyMrJAPD23zod7/zaNXjdr55SVfjV6ITD1yRRRZwCrKrNdxAq99q0Bj8tN0ZbDIU1GypD7yndc9NaPODY9biuLBipUVP0F6cmgd609LQq4aPSphJCm+3pz+SEw9fgv/7gF/DAu28w73HomkmsUfaVCRTyr2QBViC1VJr8S5bVFmCxcVoqe0WoAPgAgHcAOJf99l4Af+6cO4+IngfgLwD8Fb+IiE6BFygPBrAA4PNE9L/OuatHuX4cFB5uE/xlmaP8RbEWyvmvfIzZPhcqFjRTOXWV+z/voSfg7G9fBwB4+EmbzHaaKPhUtMV61CHTuHXHHF7wsBOMQo6EV7JoJIseduLhuOr1T2x8oSx69H2PbDznCacchW+/4tFJxeg9oRCOvL2sdszpl+5zxEhC+st/+sjs8fDcNcF1xCHT2DqzgI+/+KEmtAUA3/o/v5RUd+Y0ilB51ZPuiytu2Wke/+RLHmpCjaGvwOJ3Ifzzx5+E0+++EbfvnMOjTtLn9VH32YRnPuhu+NPHn2Te5zfPPA7f+Mkd5vEQIZebiwefcKh5DPAWTc6nERRQGWgBAJNdzyde+pgTEx8Op0fdZxO+fqU9jtCGjEJcTtorQsU59w0iOl78fBKAb5TfvwTgC0iFwv0AXOCc2w0ARHQegF8D8MYRr192Om7jKlx+yw4T4wxMtKkyaY5yGDtnGk2RQpoj86+fejL++qknV+X7LXrFE++LIw+xHeEPusdG/NfmG5NKywDwmZc+DLftmMfJxxxiXj8qNQmUs886A3voUkioSaD8/a8+IMlw5hTCfdNtlUenJsd3eO6aNXPO752J719/p2kdB9KeFafHnXwk3vblq3DWL55gnvPCR9wre4+iIBQZ2OneR6zFf7zg5xsZskV/9OgTG8+Z6nbwTyU8ZdEbnvFz2eNLtdoA4E8eexJ+9xeON4+H91RGegHA3z3tFJx05Dq89NEnZvnB+557JvpDe20GfnTAwV8GXQrgaQD+B8AzARynnPNjAK8nosMAzAJ4EoDNe3A9iOiFAF4IAHe/+92X3On7HrUOX7zsNty6Y149HsINx7UftFbZVVJwguYc9U0Y7YsemWcev3HGcTj1uA2471Gp4Dhs7ZSZC7HcNIo1slT6rZ/Pr5vH3u8IvP/3zsTD73149rylUNDwNWXmiEOm8eSfOzr5fU/p8LVTOP9VtpW8XPSLY5yn5aLlECpHHDJdPTeNwjuo+VQOWzuFlz/WtrQCdQpCp7Df5RMOX4NfPf1YPP9htqKwVNqXhMrzALydiP4KwKfg4a2InHOXE9E/AvgigBkAFwMYjHp9eY93A3g3AJxxxhl77gAQ9Jj7HYm3f/VqnFhqp5LOKKNCnt7gLxgnaclYy01EpAqUg5GIaCSIayn0lAccjdt3zOHZD166YrSv02de+jDcvH2u+cQx0klHrsXG1RP408c1M/bFUgg0ecz9xrd2OgXhLc86bWz3B/YhoeKcuwLA4wGAiE4C8GTjvPcBeF953t8DuHFPrl9uOvW4Dfjeqx5TOfIk3e/oQ3D9G1akKyaFZMJxmrwtrSwVBeEFD7/n3u7GitD9j1mP+x+z+MCJ5aDVk1384K8fP9Y2Dl0zic2vfuzYUI2Von1GqBDREc6524moAPBq+Eiu3Hl3h/enPGRPrh8H5UzaUeiljzkRt+9YvCZ23l88ygzZBOpcmnFGfLTUUktLp6X44fYV2lshxR8G8CgAhxPRjQBeA2AtEb2kPOXjAN5fnnsMgPc6555UHvtY6VPpAXiJc257+fuztev3B1qqSX2Pw9Zkj//5L98HC/0hnnrqMdnzWmqppZaWSmRlJx8MdMYZZ7jNmzc3n9hSSy211FJFRHShc+4M7VibUd9SSy211NKyUStUWmqppZZaWjZqhUpLLbXUUkvLRq1QaamlllpqadmoFSottdRSSy0tG7VCpaWWWmqppWWjVqi01FJLLbW0bNQKlZZaaqmllpaNDurkRyK6A8ANe3DJ4QC2jKk7+zIdjOM+GMcMHJzjPhjHDCxt3PdwzqkbMB3UQmVPiYg2W1mkBzIdjOM+GMcMHJzjPhjHDIxv3C381VJLLbXU0rJRK1RaaqmlllpaNmqFyp7Ru/d2B/YSHYzjPhjHDByc4z4YxwyMadytT6WlllpqqaVlo9ZSaamlllpqadmoFSottdRSSy0tG7VCZUQioicQ0ZVEdDURvWJv92ccRETHEdHXiOgyIrqUiF5W/n4oEX2JiK4qPzfu7b6Og4ioQ0Q/IKL/Lf8/gYguKJ/5fxLR/r15uCAi2kBEHyWiK4jociL6hYPhWRPRn5Tr+8dE9GEimj4QnzURnU1EtxPRj9lv6vMlT28vx/8jInrgYttthcoIREQdAP8PwBMBnAy/dfHJe7dXY6E+gD9zzp0M4CEAXlKO8xUAvuKcOxHAV8r/D0R6GYDL2f//COAtzrl7A7gTwPP3Sq/GR28D8Hnn3H0BnAo/9gP6WRPRsQBeCuAM59wpADoAfhMH5rP+AIAniN+s5/tEACeWfy8E8M7FNtoKldHowQCuds5d65xbAPARAE/by31adnLO3eKcu6j8vhOeyRwLP9ZzytPOAfD0vdLBMRIR3Q3AkwG8t/yfADwawEfLUw6ocRPRegCPAPA+AHDOLTjntuMgeNYAugBWEVEXwGoAt+AAfNbOuW8A2CZ+tp7v0wCc6zydD2ADER29mHZboTIaHQvgZ+z/G8vfDlgiouMBnA7gAgBHOuduKQ/dCuDIvdWvMdJbAfwlgGH5/2EAtjvn+uX/B9ozPwHAHQDeX0J+7yWiNTjAn7Vz7iYAbwLwU3hhcheAC3FgP2tO1vNdNh7XCpWWEiKitQA+BuDlzrkd/JjzMegHVBw6ET0FwO3OuQv3dl9WkLoAHgjgnc650wHMQEBdB+iz3givlZ8A4BgAa5BCRAcFjev5tkJlNLoJwHHs/7uVvx1wREQT8ALlQ865j5c/3xZM4fLz9r3VvzHRQwH8ChFdDw9tPhre37ChhEiAA++Z3wjgRufcBeX/H4UXMgf6s34sgOucc3c453oAPg7//A/kZ83Jer7LxuNaoTIafR/AiWWEyCS8Y+9Te7lPy06lH+F9AC53zr2ZHfoUgOeW358L4JMr3bdxknPulc65uznnjod/tl91zv02gK8B+PXytANq3M65WwH8jIjuU/70GACX4QB/1vCw10OIaHW53sO4D9hnLch6vp8C8LtlFNhDANzFYLI9ojajfkQioifB4+4dAGc7516/d3u0/EREDwPwTQCXoPYtvArer/JfAO4Ov1XAbzjnpAPwgCAiehSAP3fOPYWI7glvuRwK4AcAfsc5N78Xu7esRESnwQcmTAK4FsDvwSuaB/SzJqK/AfAs+GjHHwB4Abz/4IB61kT0YQCPgi9xfxuA1wD4HyjPtxSw74CHAncD+D3n3OZFtdsKlZZaaqmllpaLWvirpZZaaqmlZaNWqLTUUksttbRs1AqVllpqqaWWlo1aodJSSy211NKyUStUWmqppZZaWjZqhUpLLbXUUkvLRq1QaWmvEhEdz0tzj3D+i4jod8vvZxHRMezY9UR0uHLNWUT0juXp8b5BRHQSEX22LGF+ERH9FxGtaJ0uInp6rlo3Eb08PKtF3NcR0X3Zb5uI6POL7WtLK0etUGlpvyLn3Lucc+eW/54FX7/poCIimgbwGfi6XSc65x4I4F8BbNqDe3Ry/49IT4ffCkK7fxfA8wD8xyLu+2wA3yo/AQDOuTsA3EJED13E/VpaQWqFSkv7DBHRPcuKuWcS0b2I6PNEdCERfTNorUT0WiL6cyL6dQBnAPgQEV1MRKvK2/xxqblfwjVd1sYmIvoYEX2//HsoERWlxr+pPKcoNytSmTQRPZP8Bk8/JKJvlL+dRUT/U258dD0R/RER/Wk5nvOJ6NDyvK8T0Rnl98PLemPBYvtm2feLiOgXM1P1WwC+65z7dPjBOfd159yPpVVGRP9bVgkAEe0ion8moh8C+AXl/98hou+V8/lvQdCU572+HO/5RHRk2b9fAfBP5fn3En18NICLQuXfctxvIaLN5DcEO5OIPl7O++tYf9cCeBj8fia/Ke75PwB+OzMvLe0D1AqVlvYJIl+D6mMAznLOfR/AuwH8sXPuQQD+HF4Tr8g591EAmwH8tnPuNOfcbHloS6m5v7O8TtLb4DdjOhPAMwC81zk3BPDvqBnWYwH8sNSONfprAL/snDsVnrEGOgXArwE4E8DrAewuKwB/F0ATDHQ7gMeVfX8WgLdnzj0Fvlz7ntIaABc45051zn2L/w9ga9nuQ51zpwEYoJ6PNQDOL8/7BoDfd859B75e1F+U83+NaOuhSh8XnHNnAHgXfM2pl5RjOYuIDivPeRr8xmE/AbCViB7Ert8M4OGLGHdLK0jd5lNaamnstAmeyfyac+6yUlv9RQD/7UsSAQCmRrxXqKx8ITyDl/RYACez+x5Stnd22Ye3wsM278+08W0AHyCi/2LtAcDXys3NdhLRXQCCJXEJgJ9r6PcEgHeU9bgGAE5qOH8xNIAX3Nr/jwHwIADfL+dmFeoKtgsA/rf8fiGAx43Q1tGId9EE6iKslwC4NBQsJKJr4SvkboWHvN5WnveR8v8gnG7HQQh37m/UCpWW9gW6C7567MPgK8YW8JsmnbaIe4UigAPo67sA8BDn3Jz4fRcR3UZEj4bf6dOEWZxzLyKin4ffKfJCpk3zAoRD9v+Q9aWPGiGYZuf/CXzRv1PL47J/nC4F8EjjGL+/bGPOOTcw/icA5zjnXqncs+fqIoHWvEqaFW0D8XzIueqWEOGjATyAiBx88VZHRH9Rtj9d3relfZha+KulfYEWAPwqfOnt3yo3BruOiJ4J+JL8RHSqct1OAOv2sK0vAvjj8E9pGQR6LzwM9t+C+UZERPdyzl3gnPtr+N0Tj7POVeh6eIsAqEutA8B6ALeUUNxz4BmqRf8B4BeJ6MmsT48golPK+59W+oWOgxeQo9BXAPw6ER1R3u9QIrpHwzW5+b8cwL1HbDvQrwP4oHPuHs65451zxwG4DjXkdRKAkSMFW9o71AqVlvYJcs7NAHgKgD8hol+BtxSeXzqRL4XH2iV9AMC7hKO+iV4K4Awi+hERXQbgRezYpwCsRR76Arxz+hLyodDfAfDDEdsG/Fa2f0hEP4AvSR7oXwE8txzvfeF3YlSp9B89BT4o4apyHC+GF3DfhmfEl8H7ZS4apVPOucsAvBrAF4noRwC+BA9h5egjAP6iDEaQjvrPAXjEKG0zejaAT4jfPoY6CuyX4KPeWtqHqS1931JLJZVRWW9xzrXO4GUgIvoEgL90zl21TPf7BoCnOefuXI77tTQeai2VlloCQESvgNeKNZ9CS4ujV6DZ2hmJyvDuN7cCZd+n1lJpqSWDiOj/Anim+Pm/V2rXTyJ6AIAPip/nnXM/vxLtt9TSYqgVKi211FJLLS0btfBXSy211FJLy0atUGmppZZaamnZqBUqLbXUUkstLRu1QqWlllpqqaVlo/8P0EkHX/JlxvQAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "keith.smua.fastsweep.prepareSweep(0.001, 0.1, 500, mode=\"VIfourprobe\")\n", - "do0d(keith.smua.fastsweep, do_plot=True)" + "And finally we can perform the measurement" ] }, { @@ -369,7 +248,18 @@ "metadata": {}, "outputs": [], "source": [ - "do0d(keith.smua.fastsweep, do_plot=True)" + "initialise_database()\n", + "new_experiment(name=\"fastweep_exp\", sample_name=\"no sample\")\n", + "\n", + "with fastsweep_meas.run() as datasaver:\n", + " somenumbers = keith.smua.fastsweep.get()\n", + " datasaver.add_result(\n", + " (keith.smua.fastsweep, somenumbers),\n", + " (keith.smua.fastweep_setpoints, keith.smua.fastweep_setpoints.get()),\n", + " )\n", + "\n", + "data = datasaver.dataset\n", + "plot_dataset(data)" ] }, { From edb0b969f2185007f371cb4e7099997a13aa39e3 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Thu, 12 Feb 2026 13:21:10 -0800 Subject: [PATCH 10/22] Add parameter for fastsweep inter delay --- .../Keithley/_Keithley_2600.py | 34 ++++++++++++++++--- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index d8e15591d4e8..24548f1d2fc7 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -36,6 +36,9 @@ class LuaSweepParameter(ParameterWithSetpoints[npt.NDArray, "Keithley2600Channel """ Parameter class to hold the data from a deployed Lua script sweep. + + For more information on writing Lua scripts for the Keithley2600, please see + https://www.tek.com/en/documents/application-note/how-to-write-scripts-for-test-script-processing-(tsp) """ def _set_mode(self, mode: Literal["IV", "VI", "VIfourprobe"]) -> None: @@ -110,13 +113,23 @@ def _fast_sweep(self) -> npt.NDArray: f"for index = 1, {steps} do", " target = startX + (index-1)*dX", f" {channel}.source.level{source} = target", - f" {channel}.measure.{meas}({channel}.nvbuffer1)", - "end", - "format.data = format.REAL32", - "format.byteorder = format.LITTLEENDIAN", - f"printbuffer(1, {steps}, {channel}.nvbuffer1.readings)", ] + # Only add delay code to lua script if greater than 0 + inter_delay = self.instrument.fastsweep_inter_delay.get_latest() + if inter_delay > 0: + script.append(f" delay({inter_delay})") + + script.extend( + [ + f" {channel}.measure.{meas}({channel}.nvbuffer1)", + "end", + "format.data = format.REAL32", + "format.byteorder = format.LITTLEENDIAN", + f"printbuffer(1, {steps}, {channel}.nvbuffer1.readings)", + ] + ) + return self.instrument._execute_lua(script, steps) def get_raw(self) -> npt.NDArray: @@ -629,6 +642,17 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Stopping value of fastsweep. Can be current or voltage.""" + self.fastsweep_inter_delay: Parameter[float, Self] = self.add_parameter( + name="fastsweep_inter_delay", + label="Fastsweep Inter Delay", + initial_value=0, + vals=vals.Numbers(min_value=0), + unit="s", + get_cmd=None, + set_cmd=None, + ) + """Time in seconds to wait between setting a target value and taking a measurement.""" + self.fastsweep_setpoints: FastSweepSetpoints = self.add_parameter( name="fastsweep_setpoints", label="Fastsweep setpoints", From d81e4be640a9ad5ac794bda5bfc15382eec6ede0 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Thu, 12 Feb 2026 13:22:00 -0800 Subject: [PATCH 11/22] Update FastSweepSetpoints docstring --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 24548f1d2fc7..26c2f2d7d4a7 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -140,8 +140,7 @@ def get_raw(self) -> npt.NDArray: class FastSweepSetpoints(Parameter[npt.NDArray, "Keithley2600Channel"]): """ - A simple :class:`.Parameter` that holds all the setpoints (relative to the - measurement start) at which the points of the time trace were acquired. + A simple :class:`Parameter` that holds all the setpoints for a fastsweep """ def get_raw(self) -> npt.NDArray: From 974843b63016c92962547f02396fec2639793120 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Thu, 12 Feb 2026 15:11:05 -0800 Subject: [PATCH 12/22] Fix typo in Keithley 2600 example notebook --- .../driver_examples/Qcodes example with Keithley 2600.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index 89af5ec33e84..a00da88b7c1c 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -255,7 +255,7 @@ " somenumbers = keith.smua.fastsweep.get()\n", " datasaver.add_result(\n", " (keith.smua.fastsweep, somenumbers),\n", - " (keith.smua.fastweep_setpoints, keith.smua.fastweep_setpoints.get()),\n", + " (keith.smua.fastsweep_setpoints, keith.smua.fastsweep_setpoints.get()),\n", " )\n", "\n", "data = datasaver.dataset\n", From 8e0e833929b9dcf8d42034b9b0d58eff4c28c6cc Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Wed, 18 Feb 2026 10:28:15 -0800 Subject: [PATCH 13/22] Rename inter delay to settle delay for clarity --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 26c2f2d7d4a7..d7c8610206fe 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -116,9 +116,9 @@ def _fast_sweep(self) -> npt.NDArray: ] # Only add delay code to lua script if greater than 0 - inter_delay = self.instrument.fastsweep_inter_delay.get_latest() - if inter_delay > 0: - script.append(f" delay({inter_delay})") + settle_delay = self.instrument.fastsweep_settle_delay.get_latest() + if settle_delay > 0: + script.append(f" delay({settle_delay})") script.extend( [ @@ -641,7 +641,7 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Stopping value of fastsweep. Can be current or voltage.""" - self.fastsweep_inter_delay: Parameter[float, Self] = self.add_parameter( + self.fastsweep_settle_delay: Parameter[float, Self] = self.add_parameter( name="fastsweep_inter_delay", label="Fastsweep Inter Delay", initial_value=0, From c59ce2957c20cf954a06ddce15c6d64650fbc21e Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Thu, 19 Feb 2026 22:21:07 -0800 Subject: [PATCH 14/22] Major refactor to add 2D fast sweeps --- .../Qcodes example with Keithley 2600.ipynb | 84 +-- .../Keithley/_Keithley_2600.py | 550 ++++++++++++++---- tests/drivers/test_keithley_26xx.py | 120 +++- 3 files changed, 563 insertions(+), 191 deletions(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index a00da88b7c1c..61cf93ef2a17 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -10,12 +10,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import qcodes as qc\n", - "from qcodes.dataset import initialise_database, new_experiment, plot_dataset\n", + "from qcodes.dataset import (\n", + " LinSweep,\n", + " do0d,\n", + " initialise_database,\n", + " new_experiment,\n", + " plot_dataset,\n", + ")\n", "from qcodes.instrument_drivers.Keithley import Keithley2614B" ] }, @@ -195,34 +201,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's make a fast IV curve by sweeping the voltage from 1 V to 2 V in 500 steps\n", - "(when making this notebook, nothing was connected to the instrument, so we just measure noise)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we need to prepare the sweep by specifying the start, stop, number of points and the mode " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "keith.smua.fastsweep_start(1)\n", - "keith.smua.fastsweep_stop(2)\n", - "keith.smua.fastsweep_npts(500)\n", - "keith.smua.fastsweep_mode(\"IV\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we want to register our parameter" + "### 1D Fast Sweep\n", + "\n", + "Let's make a fast IV curve by sweeping the voltage from 1 V to 2 V in 500 steps.\n", + "Create a `LinSweep` object and pass it to `setup_fastsweep`, then call `do0d` on `fastsweep`." ] }, { @@ -231,35 +213,24 @@ "metadata": {}, "outputs": [], "source": [ - "fastsweep_meas = qc.Measurement()\n", - "fastsweep_meas.register_parameter(keith.smua.fastsweep)" + "# Configure a 1D fastsweep using LinSweep\n", + "fast_sweep_1d = LinSweep(keith.smua.volt, 1, 2, 500)\n", + "keith.smua.setup_fastsweep(fast_sweep_1d, mode=\"IV\")\n", + "\n", + "# Perform the measurement\n", + "ds, _, _ = do0d(keith.smua.fastsweep)\n", + "plot_dataset(ds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "And finally we can perform the measurement" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "initialise_database()\n", - "new_experiment(name=\"fastweep_exp\", sample_name=\"no sample\")\n", + "### 2D Fast Sweep\n", "\n", - "with fastsweep_meas.run() as datasaver:\n", - " somenumbers = keith.smua.fastsweep.get()\n", - " datasaver.add_result(\n", - " (keith.smua.fastsweep, somenumbers),\n", - " (keith.smua.fastsweep_setpoints, keith.smua.fastsweep_setpoints.get()),\n", - " )\n", + "For 2D sweeps, provide both inner and outer `LinSweep` objects. The inner sweep runs to completion for each step of the outer sweep. The measurement is performed on the **inner** channel (the one from the first LinSweep).\n", "\n", - "data = datasaver.dataset\n", - "plot_dataset(data)" + "Here we sweep `smua.volt` (inner/fast axis) while stepping `smub.volt` (outer/slow axis):" ] }, { @@ -268,8 +239,15 @@ "metadata": {}, "outputs": [], "source": [ - "# Finally, tear down the instrument\n", - "keith.close()" + "# Configure a 2D fastsweep: inner on smua, outer on smub\n", + "inner_sweep = LinSweep(keith.smua.volt, -1, 1, 100) # inner (fast axis)\n", + "outer_sweep = LinSweep(keith.smub.volt, 0, 0.5, 20) # outer (slow axis)\n", + "\n", + "keith.smua.setup_fastsweep(inner_sweep, outer_sweep, mode=\"IV\")\n", + "\n", + "# Perform the measurement - call fastsweep on the inner channel (smua)\n", + "ds, _, _ = do0d(keith.smua.fastsweep)\n", + "plot_dataset(ds)" ] }, { diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index d7c8610206fe..6fdb056ff033 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -3,8 +3,9 @@ import logging import struct import warnings +from dataclasses import dataclass from enum import StrEnum -from typing import TYPE_CHECKING, Any, Literal, Self +from typing import TYPE_CHECKING, Any, Literal, Protocol import numpy as np import numpy.typing as npt @@ -18,6 +19,7 @@ ) from qcodes.parameters import ( Parameter, + ParameterBase, ParameterWithSetpoints, ParamRawDataType, create_on_off_val_mapping, @@ -32,93 +34,217 @@ log = logging.getLogger(__name__) +class _SweepLike(Protocol): + """Protocol for LinSweep-like objects.""" + + @property + def param(self) -> ParameterBase: ... + @property + def num_points(self) -> int: ... + + def get_setpoints(self) -> npt.NDArray: ... + + +@dataclass +class _FastSweepConfig: + """Internal configuration for fastsweep.""" + + inner_start: float + inner_stop: float + inner_npts: int + inner_delay: float = 0.0 + inner_param_name: str = "Voltage" + inner_param_unit: str = "V" + inner_param_full_name: str | None = None # Original parameter's full_name + inner_channel: str = "smua" # Lua channel name for inner sweep + outer_start: float | None = None + outer_stop: float | None = None + outer_npts: int | None = None + outer_delay: float = 0.0 + outer_param_name: str = "Voltage" + outer_param_unit: str = "V" + outer_param_full_name: str | None = None # Original parameter's full_name + outer_channel: str = "smub" # Lua channel name for outer sweep + mode: Literal["IV", "VI", "VIfourprobe"] = "IV" + + @property + def is_2d(self) -> bool: + return self.outer_npts is not None + + @property + def total_points(self) -> int: + if self.is_2d: + assert self.outer_npts is not None + return self.inner_npts * self.outer_npts + return self.inner_npts + + def get_inner_setpoints(self) -> npt.NDArray: + return np.linspace(self.inner_start, self.inner_stop, self.inner_npts) + + def get_outer_setpoints(self) -> npt.NDArray: + if not self.is_2d: + raise RuntimeError("No outer setpoints for 1D sweep") + assert self.outer_start is not None + assert self.outer_stop is not None + assert self.outer_npts is not None + return np.linspace(self.outer_start, self.outer_stop, self.outer_npts) + + +class _FastSweepInnerSetpoints(Parameter[npt.NDArray, "Keithley2600Channel"]): + """Parameter that returns the inner axis setpoints for a fastsweep.""" + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + self._source_full_name: str | None = None + + @property + def register_name(self) -> str: + """Return source parameter's full_name for dataset registration.""" + if self._source_full_name is not None: + return self._source_full_name + return self.full_name + + def get_raw(self) -> npt.NDArray: + if self.instrument is None: + raise RuntimeError("No instrument attached to Parameter.") + config = self.instrument._fastsweep_config + if config is None: + raise RuntimeError("Fastsweep not configured. Call setup_fastsweep first.") + return config.get_inner_setpoints() + + +class _FastSweepOuterSetpoints(Parameter[npt.NDArray, "Keithley2600Channel"]): + """Parameter that returns the outer axis setpoints for a 2D fastsweep.""" + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + self._source_full_name: str | None = None + + @property + def register_name(self) -> str: + """Return source parameter's full_name for dataset registration.""" + if self._source_full_name is not None: + return self._source_full_name + return self.full_name + + def get_raw(self) -> npt.NDArray: + if self.instrument is None: + raise RuntimeError("No instrument attached to Parameter.") + config = self.instrument._fastsweep_config + if config is None: + raise RuntimeError("Fastsweep not configured. Call setup_fastsweep first.") + return config.get_outer_setpoints() + + class LuaSweepParameter(ParameterWithSetpoints[npt.NDArray, "Keithley2600Channel"]): """ - Parameter class to hold the data from a - deployed Lua script sweep. + Parameter class to perform fast sweeps using Lua scripts on the Keithley 2600. + + Supports both 1D and 2D sweeps. Configure using the channel's + ``setup_fastsweep`` method with LinSweep objects. + + For 1D sweeps, returns a 1D array. For 2D sweeps, returns a 2D array + with shape (outer_npts, inner_npts). For more information on writing Lua scripts for the Keithley2600, please see https://www.tek.com/en/documents/application-note/how-to-write-scripts-for-test-script-processing-(tsp) """ - def _set_mode(self, mode: Literal["IV", "VI", "VIfourprobe"]) -> None: + def _update_metadata(self, config: _FastSweepConfig) -> None: + """Update parameter metadata based on sweep configuration.""" + mode = config.mode + match mode: case "IV": self.unit = "A" - self.setpoint_names = ("Voltage",) - self.setpoint_units = ("V",) - self.label = "current" - self._short_name = "iv_sweep" - case "VI": + self.label = "Current" + case "VI" | "VIfourprobe": self.unit = "V" - self.setpoint_names = ("Current",) - self.setpoint_units = ("A",) - self.label = "voltage" - self._short_name = "vi_sweep" - case "VIfourprobe": - self.unit = "V" - self.setpoint_names = ("Current",) - self.setpoint_units = ("A",) - self.label = "voltage" - self._short_name = "vi_sweep_four_probe" + self.label = "Voltage" + + # Build labels that include original parameter info for traceability + inner_full_label = config.inner_param_name + if config.inner_param_full_name: + inner_full_label = ( + f"{config.inner_param_name} ({config.inner_param_full_name})" + ) + + if self.instrument is not None: + # Set source name so dataset uses original parameter's name + self.instrument.fastsweep_inner_setpoints._source_full_name = ( + config.inner_param_full_name + ) + self.instrument.fastsweep_inner_setpoints.unit = config.inner_param_unit + self.instrument.fastsweep_inner_setpoints.label = inner_full_label + self.instrument.fastsweep_inner_setpoints.vals = vals.Arrays( + shape=(config.inner_npts,) + ) - def _fast_sweep(self) -> npt.NDArray: + if config.is_2d: + assert config.outer_npts is not None + outer_full_label = config.outer_param_name + if config.outer_param_full_name: + outer_full_label = ( + f"{config.outer_param_name} ({config.outer_param_full_name})" + ) + + # Set source name so dataset uses original parameter's name + self.instrument.fastsweep_outer_setpoints._source_full_name = ( + config.outer_param_full_name + ) + self.instrument.fastsweep_outer_setpoints.unit = config.outer_param_unit + self.instrument.fastsweep_outer_setpoints.label = outer_full_label + self.instrument.fastsweep_outer_setpoints.vals = vals.Arrays( + shape=(config.outer_npts,) + ) + self.setpoints = ( + self.instrument.fastsweep_outer_setpoints, + self.instrument.fastsweep_inner_setpoints, + ) + self.setpoint_names = (outer_full_label, inner_full_label) + self.setpoint_units = (config.outer_param_unit, config.inner_param_unit) + self.vals = vals.Arrays(shape=(config.outer_npts, config.inner_npts)) + else: + self.setpoints = (self.instrument.fastsweep_inner_setpoints,) + self.setpoint_names = (inner_full_label,) + self.setpoint_units = (config.inner_param_unit,) + self.vals = vals.Arrays(shape=(config.inner_npts,)) + + def _build_1d_script(self, config: _FastSweepConfig) -> list[str]: + """Build Lua script for 1D sweep.""" if self.instrument is None: raise RuntimeError("No instrument attached to Parameter.") - channel = self.instrument.channel - - # an extra visa query, a necessary precaution - # to avoid timing out when waiting for long - # measurements + channel = config.inner_channel nplc = self.instrument.nplc() - mode = self.instrument.fastsweep_mode() - start = self.instrument.fastsweep_start() - stop = self.instrument.fastsweep_stop() - steps = self.instrument.fastsweep_npts() + dX = (config.inner_stop - config.inner_start) / (config.inner_npts - 1) - dV = (stop - start) / (steps - 1) - - match mode: + match config.mode: case "IV": - meas = "i" - source = "v" - func = "1" - sense_mode = "0" + meas, source, func, sense_mode = "i", "v", "1", "0" case "VI": - meas = "v" - source = "i" - func = "0" - sense_mode = "0" + meas, source, func, sense_mode = "v", "i", "0", "0" case "VIfourprobe": - meas = "v" - source = "i" - func = "0" - sense_mode = "1" - case _: - raise ValueError(f"Invalid fastsweep mode {mode}") + meas, source, func, sense_mode = "v", "i", "0", "1" script = [ f"{channel}.measure.nplc = {nplc:.12f}", - f"{channel}.source.output = 1", - f"startX = {start:.12f}", - f"dX = {dV:.12f}", f"{channel}.sense = {sense_mode}", - f"{channel}.source.output = 1", f"{channel}.source.func = {func}", + f"{channel}.source.output = 1", f"{channel}.measure.count = 1", + f"startX = {config.inner_start:.12f}", + f"dX = {dX:.12f}", f"{channel}.nvbuffer1.clear()", f"{channel}.nvbuffer1.appendmode = 1", - f"for index = 1, {steps} do", + f"for index = 1, {config.inner_npts} do", " target = startX + (index-1)*dX", f" {channel}.source.level{source} = target", ] - # Only add delay code to lua script if greater than 0 - settle_delay = self.instrument.fastsweep_settle_delay.get_latest() - if settle_delay > 0: - script.append(f" delay({settle_delay})") + if config.inner_delay > 0: + script.append(f" delay({config.inner_delay})") script.extend( [ @@ -126,31 +252,104 @@ def _fast_sweep(self) -> npt.NDArray: "end", "format.data = format.REAL32", "format.byteorder = format.LITTLEENDIAN", - f"printbuffer(1, {steps}, {channel}.nvbuffer1.readings)", + f"printbuffer(1, {config.inner_npts}, {channel}.nvbuffer1.readings)", ] ) + return script - return self.instrument._execute_lua(script, steps) + def _build_2d_script(self, config: _FastSweepConfig) -> list[str]: + """Build Lua script for 2D sweep.""" + if self.instrument is None: + raise RuntimeError("No instrument attached to Parameter.") - def get_raw(self) -> npt.NDArray: - data = self._fast_sweep() + inner_channel = config.inner_channel + outer_channel = config.outer_channel + nplc = self.instrument.nplc() - return data + assert config.outer_start is not None + assert config.outer_stop is not None + assert config.outer_npts is not None + dX_inner = (config.inner_stop - config.inner_start) / (config.inner_npts - 1) + dX_outer = (config.outer_stop - config.outer_start) / (config.outer_npts - 1) -class FastSweepSetpoints(Parameter[npt.NDArray, "Keithley2600Channel"]): - """ - A simple :class:`Parameter` that holds all the setpoints for a fastsweep - """ + match config.mode: + case "IV": + meas, source, func, sense_mode = "i", "v", "1", "0" + outer_source, outer_func = "v", "1" + case "VI": + meas, source, func, sense_mode = "v", "i", "0", "0" + outer_source, outer_func = "i", "0" + case "VIfourprobe": + meas, source, func, sense_mode = "v", "i", "0", "1" + outer_source, outer_func = "i", "0" + + script = [ + # Set up inner channel (fast sweep) + f"{inner_channel}.measure.nplc = {nplc:.12f}", + f"{inner_channel}.sense = {sense_mode}", + f"{inner_channel}.source.func = {func}", + f"{inner_channel}.source.output = 1", + f"{inner_channel}.measure.count = 1", + # Set up outer channel + f"{outer_channel}.source.func = {outer_func}", + f"{outer_channel}.source.output = 1", + # Initialize variables + f"startX_inner = {config.inner_start:.12f}", + f"dX_inner = {dX_inner:.12f}", + f"startX_outer = {config.outer_start:.12f}", + f"dX_outer = {dX_outer:.12f}", + # Clear buffer + f"{inner_channel}.nvbuffer1.clear()", + f"{inner_channel}.nvbuffer1.appendmode = 1", + # Outer loop (slow axis on other channel) + f"for outer_idx = 1, {config.outer_npts} do", + " outer_target = startX_outer + (outer_idx-1)*dX_outer", + f" {outer_channel}.source.level{outer_source} = outer_target", + ] + + if config.outer_delay > 0: + script.append(f" delay({config.outer_delay})") + + script.extend( + [ + f" for inner_idx = 1, {config.inner_npts} do", + " inner_target = startX_inner + (inner_idx-1)*dX_inner", + f" {inner_channel}.source.level{source} = inner_target", + ] + ) + + if config.inner_delay > 0: + script.append(f" delay({config.inner_delay})") + + script.extend( + [ + f" {inner_channel}.measure.{meas}({inner_channel}.nvbuffer1)", + " end", + "end", + "format.data = format.REAL32", + "format.byteorder = format.LITTLEENDIAN", + f"printbuffer(1, {config.total_points}, {inner_channel}.nvbuffer1.readings)", + ] + ) + return script def get_raw(self) -> npt.NDArray: if self.instrument is None: raise RuntimeError("No instrument attached to Parameter.") - npts = self.instrument.fastsweep_npts() - start = self.instrument.fastsweep_start() - stop = self.instrument.fastsweep_stop() - return np.linspace(start, stop, npts) + config = self.instrument._fastsweep_config + if config is None: + raise RuntimeError("Fastsweep not configured. Call setup_fastsweep first.") + + if config.is_2d: + script = self._build_2d_script(config) + data = self.instrument._execute_lua(script, config.total_points) + assert config.outer_npts is not None + return data.reshape(config.outer_npts, config.inner_npts) + else: + script = self._build_1d_script(config) + return self.instrument._execute_lua(script, config.total_points) class TimeTrace(ParameterWithSetpoints): @@ -622,64 +821,54 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: ) """Current limit e.g. the maximum current allowed in voltage mode. If exceeded the voltage will be clipped.""" - self.fastsweep_npts: Parameter[int, Self] = self.add_parameter( - "fastsweep_npts", - initial_value=20, - label="Number of fastweep points", - get_cmd=None, - set_cmd=None, - ) - """Parameter fastweep_npts""" - - self.fastsweep_start: Parameter[float, Self] = self.add_parameter( - "fastsweep_start", label="fastsweep start", get_cmd=None, set_cmd=None - ) - """Starting value of fastsweep. Can be current or voltage.""" + # Internal fastsweep configuration - set via setup_fastsweep() + self._fastsweep_config: _FastSweepConfig | None = None - self.fastsweep_stop: Parameter[float, Self] = self.add_parameter( - "fastsweep_stop", label="fastsweep stop", get_cmd=None, set_cmd=None - ) - """Stopping value of fastsweep. Can be current or voltage.""" - - self.fastsweep_settle_delay: Parameter[float, Self] = self.add_parameter( - name="fastsweep_inter_delay", - label="Fastsweep Inter Delay", - initial_value=0, - vals=vals.Numbers(min_value=0), - unit="s", - get_cmd=None, - set_cmd=None, + # Setpoint parameters for fastsweep + self.fastsweep_inner_setpoints: _FastSweepInnerSetpoints = self.add_parameter( + name="fastsweep_inner_setpoints", + label="Sweep setpoints", + snapshot_value=False, + vals=vals.Arrays(shape=(1,)), # Placeholder, updated by setup_fastsweep + parameter_class=_FastSweepInnerSetpoints, ) - """Time in seconds to wait between setting a target value and taking a measurement.""" + """Holds inner axis setpoints for fastsweep.""" - self.fastsweep_setpoints: FastSweepSetpoints = self.add_parameter( - name="fastsweep_setpoints", - label="Fastsweep setpoints", + self.fastsweep_outer_setpoints: _FastSweepOuterSetpoints = self.add_parameter( + name="fastsweep_outer_setpoints", + label="Outer sweep setpoints", snapshot_value=False, - vals=vals.Arrays(shape=(self.fastsweep_npts,)), - parameter_class=FastSweepSetpoints, + vals=vals.Arrays(shape=(1,)), # Placeholder, updated by setup_fastsweep + parameter_class=_FastSweepOuterSetpoints, ) - """Holds array of setpoints for doing a fastsweep. Can - be of units V or I depending on `Keithley2600Channel.fastsweep_mode`""" + """Holds outer axis setpoints for 2D fastsweep.""" self.fastsweep: LuaSweepParameter = self.add_parameter( "fastsweep", - vals=vals.Arrays(shape=(self.fastsweep_npts,)), - setpoints=(self.fastsweep_setpoints,), + vals=vals.Arrays(shape=(1,)), # Placeholder, updated by setup_fastsweep + setpoints=(self.fastsweep_inner_setpoints,), # Updated by setup_fastsweep parameter_class=LuaSweepParameter, + docstring="Performs a fast sweep using on-instrument Lua scripts. " + "Configure using setup_fastsweep() with LinSweep object(s). " + "For 1D sweeps, returns a 1D array. " + "For 2D sweeps, returns a 2D array with shape (outer_npts, inner_npts).", ) - """Performs buffered readout of desired sweep mode.""" - - self.fastsweep_mode: Parameter[Literal["IV", "VI", "VIfourprobe"], Self] = ( - self.add_parameter( - "fastsweep_mode", - initial_value="IV", - get_cmd=None, - set_cmd=self.fastsweep._set_mode, - vals=vals.Enum("IV", "VI", "VIfourprobe"), - ) - ) - """Parameter fastsweep_mode""" + """ + Performs a fast sweep. Configure with setup_fastsweep() before use. + Call fastsweep on the **inner** channel (the one from the first LinSweep). + + Example 1D: + >>> from qcodes.dataset import LinSweep + >>> keith.smua.setup_fastsweep(LinSweep(keith.smua.volt, 0, 1, 100)) + >>> ds, _, _ = do0d(keith.smua.fastsweep) + + Example 2D (inner=smub, outer=smua): + >>> keith.smua.setup_fastsweep( + ... LinSweep(keith.smub.volt, 0, 1, 100), # inner + ... LinSweep(keith.smua.volt, 0, 0.5, 20), # outer + ... ) + >>> ds, _, _ = do0d(keith.smub.fastsweep) # call on inner channel + """ self.timetrace_npts: Parameter = self.add_parameter( "timetrace_npts", @@ -745,6 +934,135 @@ def reset(self) -> None: log.debug(f"Reset channel {self.channel}. Updating settings...") self.snapshot(update=True) + def setup_fastsweep( + self, + inner: _SweepLike, + outer: _SweepLike | None = None, + mode: Literal["IV", "VI", "VIfourprobe"] = "IV", + inner_delay: float = 0.0, + outer_delay: float = 0.0, + ) -> None: + """ + Configure a 1D or 2D fastsweep using LinSweep objects. + + Both 1D and 2D sweeps execute entirely on the instrument via Lua scripts, + minimizing communication overhead. + + For 1D sweeps, provide only the inner sweep. + For 2D sweeps, provide both inner and outer sweeps. The inner sweep + runs to completion for each step of the outer sweep. + + The channels are determined by the LinSweep parameters you provide. + After calling setup_fastsweep, call `fastsweep` on the **inner** channel + (the channel from the first LinSweep) to execute the measurement. + + Args: + inner: LinSweep object for the inner sweep axis. The channel is + determined from the parameter (e.g., keith.smua.volt → smua). + Measurement is performed on this channel. + outer: Optional LinSweep object for the outer sweep axis. + If provided, performs a 2D sweep. The channel is determined + from the parameter. + mode: Sweep mode - 'IV' (sweep voltage, measure current), + 'VI' (sweep current, measure voltage), or + 'VIfourprobe' (four-probe VI measurement). + inner_delay: Time in seconds to wait after setting each inner point + before measuring. + outer_delay: Time in seconds to wait after setting each outer point + before starting the inner sweep. + + Example 1D: + + >>> from qcodes.dataset import LinSweep + >>> keith.smua.setup_fastsweep(LinSweep(keith.smua.volt, 0, 1, 100)) + >>> ds, _, _ = do0d(keith.smua.fastsweep) + + Example 2D (inner=smua, outer=smub): + + >>> keith.smua.setup_fastsweep( + ... LinSweep(keith.smua.volt, 0, 1, 100), # inner + ... LinSweep(keith.smub.volt, 0, 0.5, 20), # outer + ... ) + >>> ds, _, _ = do0d(keith.smua.fastsweep) # call on inner channel + + Example 2D (inner=smub, outer=smua): + + >>> keith.smua.setup_fastsweep( + ... LinSweep(keith.smub.volt, 0, 1, 100), # inner + ... LinSweep(keith.smua.volt, 0, 0.5, 20), # outer + ... ) + >>> ds, _, _ = do0d(keith.smub.fastsweep) # call on inner channel + + """ + + # Helper to extract channel name from parameter + def get_channel(param: ParameterBase) -> str: + """Extract Lua channel name (smua/smub) from parameter.""" + # Check if parameter's instrument has a channel attribute + inst = getattr(param, "instrument", None) + if inst is not None and hasattr(inst, "channel"): + return inst.channel + # Fallback: try to detect from full_name + full_name = getattr(param, "full_name", "") + if "smub" in full_name.lower(): + return "smub" + return "smua" # Default + + # Get setpoints from inner sweep to derive start/stop + inner_setpoints = inner.get_setpoints() + inner_start = float(inner_setpoints[0]) + inner_stop = float(inner_setpoints[-1]) + inner_param = inner.param + inner_name = getattr(inner_param, "label", None) or inner_param.name + inner_unit = getattr(inner_param, "unit", "") or "" + inner_full_name = getattr(inner_param, "full_name", inner_param.name) + inner_channel = get_channel(inner_param) + + # Build the configuration + config = _FastSweepConfig( + inner_start=inner_start, + inner_stop=inner_stop, + inner_npts=inner.num_points, + inner_delay=inner_delay, + inner_param_name=inner_name, + inner_param_unit=inner_unit, + inner_param_full_name=inner_full_name, + inner_channel=inner_channel, + mode=mode, + ) + + # Add outer sweep configuration if provided + if outer is not None: + outer_setpoints = outer.get_setpoints() + outer_start = float(outer_setpoints[0]) + outer_stop = float(outer_setpoints[-1]) + outer_param = outer.param + outer_name = getattr(outer_param, "label", None) or outer_param.name + outer_unit = getattr(outer_param, "unit", "") or "" + outer_full_name = getattr(outer_param, "full_name", outer_param.name) + outer_channel = get_channel(outer_param) + + config.outer_start = outer_start + config.outer_stop = outer_stop + config.outer_npts = outer.num_points + config.outer_delay = outer_delay + config.outer_param_name = outer_name + config.outer_param_unit = outer_unit + config.outer_param_full_name = outer_full_name + config.outer_channel = outer_channel + + # Get the inner channel object where fastsweep should be called from + # (measurement happens on the inner channel) + inner_channel_obj: Keithley2600Channel = getattr( + self.root_instrument, inner_channel + ) + + # Store configuration on the inner channel - users call fastsweep there + inner_channel_obj._fastsweep_config = config + + # Update fastsweep parameter metadata on the inner channel + inner_channel_obj.fastsweep._update_metadata(config) + def _execute_lua(self, _script: list[str], steps: int) -> npt.NDArray: """ This is the function that sends the Lua script to be executed and diff --git a/tests/drivers/test_keithley_26xx.py b/tests/drivers/test_keithley_26xx.py index 18bd8bbd4ca0..7a695b5851e8 100644 --- a/tests/drivers/test_keithley_26xx.py +++ b/tests/drivers/test_keithley_26xx.py @@ -5,6 +5,7 @@ import numpy as np import pytest +from qcodes.dataset import LinSweep from qcodes.instrument_drivers.Keithley import ( Keithley2600Channel, Keithley2600MeasurementStatus, @@ -190,31 +191,24 @@ def test_fast_sweep_parameters(smus) -> None: npts = 50 # Test IV mode - smu.fastsweep_mode("IV") + sweep = LinSweep(smu.volt, start_val, stop_val, npts) + smu.setup_fastsweep(sweep, mode="IV") assert smu.fastsweep.unit == "A" - assert smu.fastsweep.label == "current" + assert smu.fastsweep.label == "Current" # Test VI mode - smu.fastsweep_mode("VI") + sweep = LinSweep(smu.curr, start_val, stop_val, npts) + smu.setup_fastsweep(sweep, mode="VI") assert smu.fastsweep.unit == "V" - assert smu.fastsweep.label == "voltage" + assert smu.fastsweep.label == "Voltage" # Test VIfourprobe mode - smu.fastsweep_mode("VIfourprobe") + smu.setup_fastsweep(sweep, mode="VIfourprobe") assert smu.fastsweep.unit == "V" - assert smu.fastsweep.label == "voltage" + assert smu.fastsweep.label == "Voltage" - smu.fastsweep_start(start_val) - assert smu.fastsweep_start() == start_val - - smu.fastsweep_stop(stop_val) - assert smu.fastsweep_stop() == stop_val - - smu.fastsweep_npts(npts) - assert smu.fastsweep_npts() == npts - - # Test the setpoints (fastsweep_setpoints) - setpoints = smu.fastsweep_setpoints() + # Test the inner setpoints + setpoints = smu.fastsweep_inner_setpoints() expected_setpoints = np.linspace(start_val, stop_val, npts) np.testing.assert_array_almost_equal(setpoints, expected_setpoints) @@ -222,11 +216,9 @@ def test_fast_sweep_parameters(smus) -> None: def test_fastsweep(driver) -> None: smu = driver.smua - # Configure the fastsweep - smu.fastsweep_mode("IV") - smu.fastsweep_start(0.0) - smu.fastsweep_stop(1.0) - smu.fastsweep_npts(10) + # Configure the fastsweep using LinSweep + sweep = LinSweep(smu.volt, 0.0, 1.0, 10) + smu.setup_fastsweep(sweep, mode="IV") # Mock _execute_lua to return fake measurement data fake_data = np.linspace(0, 0.001, 10) # Fake current readings @@ -236,3 +228,87 @@ def test_fastsweep(driver) -> None: assert len(result) == 10 np.testing.assert_array_equal(result, fake_data) + + +def test_fastsweep_2d_parameters(driver) -> None: + """Test 2D fastsweep configuration with inner and outer sweeps.""" + smua = driver.smua + smub = driver.smub + + inner_start, inner_stop, inner_npts = 0.0, 1.0, 50 + outer_start, outer_stop, outer_npts = -0.5, 0.5, 20 + + inner_sweep = LinSweep(smua.volt, inner_start, inner_stop, inner_npts) + outer_sweep = LinSweep(smub.volt, outer_start, outer_stop, outer_npts) + + # Setup 2D fastsweep - config is stored on inner channel (smua) + smua.setup_fastsweep(inner_sweep, outer_sweep, mode="IV") + + # Check inner setpoints + inner_setpoints = smua.fastsweep_inner_setpoints() + expected_inner = np.linspace(inner_start, inner_stop, inner_npts) + np.testing.assert_array_almost_equal(inner_setpoints, expected_inner) + + # Check outer setpoints + outer_setpoints = smua.fastsweep_outer_setpoints() + expected_outer = np.linspace(outer_start, outer_stop, outer_npts) + np.testing.assert_array_almost_equal(outer_setpoints, expected_outer) + + # Check measurement parameter metadata + assert smua.fastsweep.unit == "A" + assert smua.fastsweep.label == "Current" + + # Check setpoints are properly configured for 2D + assert len(smua.fastsweep.setpoints) == 2 + assert smua.fastsweep.setpoints[0] == smua.fastsweep_outer_setpoints + assert smua.fastsweep.setpoints[1] == smua.fastsweep_inner_setpoints + + +def test_fastsweep_2d_execution(driver) -> None: + """Test 2D fastsweep returns correctly shaped data.""" + smua = driver.smua + smub = driver.smub + + inner_npts = 10 + outer_npts = 5 + + inner_sweep = LinSweep(smua.volt, 0.0, 1.0, inner_npts) + outer_sweep = LinSweep(smub.volt, -0.5, 0.5, outer_npts) + + smua.setup_fastsweep(inner_sweep, outer_sweep, mode="IV") + + # Mock _execute_lua to return fake 2D measurement data (flattened) + total_points = inner_npts * outer_npts + fake_data = np.linspace(0, 0.001, total_points) + + with patch.object(smua, "_execute_lua", return_value=fake_data): + result = smua.fastsweep() + + # Check result is reshaped to 2D + assert result.shape == (outer_npts, inner_npts) + np.testing.assert_array_equal(result.flatten(), fake_data) + + +def test_fastsweep_channel_detection(driver) -> None: + """Test that channels are correctly detected from LinSweep parameters.""" + smua = driver.smua + smub = driver.smub + + # Setup with inner=smub, outer=smua (reversed) + inner_sweep = LinSweep(smub.volt, 0.0, 1.0, 10) + outer_sweep = LinSweep(smua.volt, -0.5, 0.5, 5) + + # Can call setup_fastsweep from any channel + smua.setup_fastsweep(inner_sweep, outer_sweep, mode="IV") + + # Config should be stored on inner channel (smub) + assert smub._fastsweep_config is not None + assert smub._fastsweep_config.inner_channel == "smub" + assert smub._fastsweep_config.outer_channel == "smua" + + # Call fastsweep on inner channel (smub) + fake_data = np.linspace(0, 0.001, 50) + with patch.object(smub, "_execute_lua", return_value=fake_data): + result = smub.fastsweep() + + assert result.shape == (5, 10) From 59977c306f30c151c95d8634cb5e957f11d90882 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 20 Feb 2026 10:51:41 -0800 Subject: [PATCH 15/22] Rename _SweepLike class and add delay property --- .../Keithley/_Keithley_2600.py | 33 +++++++++---------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 6fdb056ff033..abc452cdaffb 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -34,11 +34,15 @@ log = logging.getLogger(__name__) -class _SweepLike(Protocol): +class _LinSweepLike(Protocol): """Protocol for LinSweep-like objects.""" @property def param(self) -> ParameterBase: ... + + @property + def delay(self) -> float: ... + @property def num_points(self) -> int: ... @@ -849,7 +853,7 @@ def __init__(self, parent: Instrument, name: str, channel: str) -> None: setpoints=(self.fastsweep_inner_setpoints,), # Updated by setup_fastsweep parameter_class=LuaSweepParameter, docstring="Performs a fast sweep using on-instrument Lua scripts. " - "Configure using setup_fastsweep() with LinSweep object(s). " + "Configure using setup_fastsweep() with LinSweep-like object(s). " "For 1D sweeps, returns a 1D array. " "For 2D sweeps, returns a 2D array with shape (outer_npts, inner_npts).", ) @@ -936,11 +940,9 @@ def reset(self) -> None: def setup_fastsweep( self, - inner: _SweepLike, - outer: _SweepLike | None = None, + inner: _LinSweepLike, + outer: _LinSweepLike | None = None, mode: Literal["IV", "VI", "VIfourprobe"] = "IV", - inner_delay: float = 0.0, - outer_delay: float = 0.0, ) -> None: """ Configure a 1D or 2D fastsweep using LinSweep objects. @@ -957,19 +959,16 @@ def setup_fastsweep( (the channel from the first LinSweep) to execute the measurement. Args: - inner: LinSweep object for the inner sweep axis. The channel is + inner: LinSweep-like object for the inner sweep axis. The channel is determined from the parameter (e.g., keith.smua.volt → smua). - Measurement is performed on this channel. - outer: Optional LinSweep object for the outer sweep axis. - If provided, performs a 2D sweep. The channel is determined - from the parameter. + Measurement is performed on this channel. The delay is + extracted from the LinSweep object. + outer: Optional LinSweepLike object for the outer sweep axis. + If provided, performs a 2D sweep. The channel and delay are + determined from the LinSweep object. mode: Sweep mode - 'IV' (sweep voltage, measure current), 'VI' (sweep current, measure voltage), or 'VIfourprobe' (four-probe VI measurement). - inner_delay: Time in seconds to wait after setting each inner point - before measuring. - outer_delay: Time in seconds to wait after setting each outer point - before starting the inner sweep. Example 1D: @@ -1023,7 +1022,7 @@ def get_channel(param: ParameterBase) -> str: inner_start=inner_start, inner_stop=inner_stop, inner_npts=inner.num_points, - inner_delay=inner_delay, + inner_delay=inner.delay, inner_param_name=inner_name, inner_param_unit=inner_unit, inner_param_full_name=inner_full_name, @@ -1045,7 +1044,7 @@ def get_channel(param: ParameterBase) -> str: config.outer_start = outer_start config.outer_stop = outer_stop config.outer_npts = outer.num_points - config.outer_delay = outer_delay + config.outer_delay = outer.delay config.outer_param_name = outer_name config.outer_param_unit = outer_unit config.outer_param_full_name = outer_full_name From aba56c2d5d85ecdcf01e10cb2322eecad29bc369 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 20 Feb 2026 11:20:23 -0800 Subject: [PATCH 16/22] Add better documentation for _LinSweepLike object. --- .../Qcodes example with Keithley 2600.ipynb | 4 +- .../Keithley/_Keithley_2600.py | 43 +++++++++++++------ 2 files changed, 33 insertions(+), 14 deletions(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index 61cf93ef2a17..ff288477e8e4 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -204,7 +204,9 @@ "### 1D Fast Sweep\n", "\n", "Let's make a fast IV curve by sweeping the voltage from 1 V to 2 V in 500 steps.\n", - "Create a `LinSweep` object and pass it to `setup_fastsweep`, then call `do0d` on `fastsweep`." + "Create a `LinSweep` object and pass it to `setup_fastsweep`, then call `do0d` on `fastsweep`. \n", + "\n", + "*NOTE:* `LinSweep` isn't specifically required here. We just need a `_LinSweepLike` object to pass, which requires `param`, `delay`, and `num_points` attributes and a `get_setpoints()` method." ] }, { diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index abc452cdaffb..796e5d9eb045 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -35,7 +35,20 @@ class _LinSweepLike(Protocol): - """Protocol for LinSweep-like objects.""" + """ + Protocol for sweep objects that can be used with ``setup_fastsweep``. + + Any object implementing this protocol can be used to configure fast sweeps. + The canonical example is :class:`qcodes.dataset.LinSweep`. + + Required attributes: + param: The parameter being swept (e.g., ``keith.smua.volt``). + delay: Time in seconds to wait after setting each point before measuring. + num_points: Number of sweep points. + + Required methods: + get_setpoints: Returns the array of setpoint values for the sweep. + """ @property def param(self) -> ParameterBase: ... @@ -145,7 +158,8 @@ class LuaSweepParameter(ParameterWithSetpoints[npt.NDArray, "Keithley2600Channel Parameter class to perform fast sweeps using Lua scripts on the Keithley 2600. Supports both 1D and 2D sweeps. Configure using the channel's - ``setup_fastsweep`` method with LinSweep objects. + ``setup_fastsweep`` method with sweep objects that implement the + ``_LinSweepLike`` protocol (e.g., :class:`qcodes.dataset.LinSweep`). For 1D sweeps, returns a 1D array. For 2D sweeps, returns a 2D array with shape (outer_npts, inner_npts). @@ -945,7 +959,10 @@ def setup_fastsweep( mode: Literal["IV", "VI", "VIfourprobe"] = "IV", ) -> None: """ - Configure a 1D or 2D fastsweep using LinSweep objects. + Configure a 1D or 2D fastsweep using sweep objects. + + Accepts any object implementing the ``_LinSweepLike`` protocol. + The canonical example is :class:`qcodes.dataset.LinSweep`. Both 1D and 2D sweeps execute entirely on the instrument via Lua scripts, minimizing communication overhead. @@ -954,18 +971,18 @@ def setup_fastsweep( For 2D sweeps, provide both inner and outer sweeps. The inner sweep runs to completion for each step of the outer sweep. - The channels are determined by the LinSweep parameters you provide. - After calling setup_fastsweep, call `fastsweep` on the **inner** channel - (the channel from the first LinSweep) to execute the measurement. + The channels are determined by the sweep parameters you provide. + After calling setup_fastsweep, call ``fastsweep`` on the **inner** channel + (the channel from the first sweep object) to execute the measurement. Args: - inner: LinSweep-like object for the inner sweep axis. The channel is - determined from the parameter (e.g., keith.smua.volt → smua). - Measurement is performed on this channel. The delay is - extracted from the LinSweep object. - outer: Optional LinSweepLike object for the outer sweep axis. - If provided, performs a 2D sweep. The channel and delay are - determined from the LinSweep object. + inner: Sweep object for the inner (fast) axis. Must have ``param``, + ``delay``, ``num_points`` attributes and a ``get_setpoints()`` + method. See :class:`qcodes.dataset.LinSweep` for an example. + The channel is determined from ``param.instrument.channel``. + Measurement is performed on this channel. + outer: Optional sweep object for the outer (slow) axis. + If provided, performs a 2D sweep. mode: Sweep mode - 'IV' (sweep voltage, measure current), 'VI' (sweep current, measure voltage), or 'VIfourprobe' (four-probe VI measurement). From 53a793df047dca07c1e943dce814039dbad66f48 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 20 Feb 2026 14:16:07 -0800 Subject: [PATCH 17/22] Simplify get_channel helper function --- .../Keithley/_Keithley_2600.py | 44 ++++++++----------- 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 796e5d9eb045..b448df6c7612 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -5,7 +5,7 @@ import warnings from dataclasses import dataclass from enum import StrEnum -from typing import TYPE_CHECKING, Any, Literal, Protocol +from typing import TYPE_CHECKING, Any, Literal, Protocol, cast import numpy as np import numpy.typing as npt @@ -36,7 +36,7 @@ class _LinSweepLike(Protocol): """ - Protocol for sweep objects that can be used with ``setup_fastsweep``. + Protocol for linear sweep objects that can be used with ``setup_fastsweep``. Any object implementing this protocol can be used to configure fast sweeps. The canonical example is :class:`qcodes.dataset.LinSweep`. @@ -1014,24 +1014,21 @@ def setup_fastsweep( # Helper to extract channel name from parameter def get_channel(param: ParameterBase) -> str: """Extract Lua channel name (smua/smub) from parameter.""" - # Check if parameter's instrument has a channel attribute - inst = getattr(param, "instrument", None) - if inst is not None and hasattr(inst, "channel"): - return inst.channel - # Fallback: try to detect from full_name - full_name = getattr(param, "full_name", "") - if "smub" in full_name.lower(): - return "smub" - return "smua" # Default + inst = param.instrument + + if not isinstance(inst, Keithley2600Channel): + raise ValueError( + f"Parameter '{param.name}' must belong to a Keithley2600Channel. " + f"Got instrument of type {type(inst).__name__}." + ) + + return inst.channel # Get setpoints from inner sweep to derive start/stop inner_setpoints = inner.get_setpoints() inner_start = float(inner_setpoints[0]) inner_stop = float(inner_setpoints[-1]) - inner_param = inner.param - inner_name = getattr(inner_param, "label", None) or inner_param.name - inner_unit = getattr(inner_param, "unit", "") or "" - inner_full_name = getattr(inner_param, "full_name", inner_param.name) + inner_param = cast("Parameter", inner.param) inner_channel = get_channel(inner_param) # Build the configuration @@ -1040,9 +1037,9 @@ def get_channel(param: ParameterBase) -> str: inner_stop=inner_stop, inner_npts=inner.num_points, inner_delay=inner.delay, - inner_param_name=inner_name, - inner_param_unit=inner_unit, - inner_param_full_name=inner_full_name, + inner_param_name=inner_param.label, + inner_param_unit=inner_param.unit, + inner_param_full_name=inner_param.full_name, inner_channel=inner_channel, mode=mode, ) @@ -1052,19 +1049,16 @@ def get_channel(param: ParameterBase) -> str: outer_setpoints = outer.get_setpoints() outer_start = float(outer_setpoints[0]) outer_stop = float(outer_setpoints[-1]) - outer_param = outer.param - outer_name = getattr(outer_param, "label", None) or outer_param.name - outer_unit = getattr(outer_param, "unit", "") or "" - outer_full_name = getattr(outer_param, "full_name", outer_param.name) + outer_param = cast("Parameter", outer.param) outer_channel = get_channel(outer_param) config.outer_start = outer_start config.outer_stop = outer_stop config.outer_npts = outer.num_points config.outer_delay = outer.delay - config.outer_param_name = outer_name - config.outer_param_unit = outer_unit - config.outer_param_full_name = outer_full_name + config.outer_param_name = outer_param.label + config.outer_param_unit = outer_param.unit + config.outer_param_full_name = outer_param.full_name config.outer_channel = outer_channel # Get the inner channel object where fastsweep should be called from From c7adf9f2c7e8a180e1efc9085df8a977f8e277f5 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 20 Feb 2026 14:18:26 -0800 Subject: [PATCH 18/22] Fix issue causing mypy failure --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index b448df6c7612..6b3ac3bf2775 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -224,8 +224,8 @@ def _update_metadata(self, config: _FastSweepConfig) -> None: self.vals = vals.Arrays(shape=(config.outer_npts, config.inner_npts)) else: self.setpoints = (self.instrument.fastsweep_inner_setpoints,) - self.setpoint_names = (inner_full_label,) - self.setpoint_units = (config.inner_param_unit,) + self.setpoint_names = (inner_full_label,) # type: ignore[assignment] + self.setpoint_units = (config.inner_param_unit,) # type: ignore[assignment] self.vals = vals.Arrays(shape=(config.inner_npts,)) def _build_1d_script(self, config: _FastSweepConfig) -> list[str]: From 83f8f712bf0c37c8a0409ca0c002729c4fdd352d Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Fri, 20 Feb 2026 14:25:38 -0800 Subject: [PATCH 19/22] Raise TypeError if parameter doesn't belong to Keithley2600Channel --- src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index 6b3ac3bf2775..c9654f9b9598 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -1017,7 +1017,7 @@ def get_channel(param: ParameterBase) -> str: inst = param.instrument if not isinstance(inst, Keithley2600Channel): - raise ValueError( + raise TypeError( f"Parameter '{param.name}' must belong to a Keithley2600Channel. " f"Got instrument of type {type(inst).__name__}." ) From f934866e3bddb37f324bfc95376cde4491e7027a Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Mon, 23 Feb 2026 18:03:28 -0800 Subject: [PATCH 20/22] Allow users to select which channel is measured during fastsweep. --- .../Keithley/_Keithley_2600.py | 69 ++++++++++++------- 1 file changed, 46 insertions(+), 23 deletions(-) diff --git a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py index c9654f9b9598..93d073c1d3e2 100644 --- a/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py +++ b/src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py @@ -83,6 +83,7 @@ class _FastSweepConfig: outer_param_full_name: str | None = None # Original parameter's full_name outer_channel: str = "smub" # Lua channel name for outer sweep mode: Literal["IV", "VI", "VIfourprobe"] = "IV" + measurement_channel: str = "smua" @property def is_2d(self) -> bool: @@ -233,7 +234,8 @@ def _build_1d_script(self, config: _FastSweepConfig) -> list[str]: if self.instrument is None: raise RuntimeError("No instrument attached to Parameter.") - channel = config.inner_channel + sweep_channel = config.inner_channel + meas_channel = config.measurement_channel nplc = self.instrument.nplc() dX = (config.inner_stop - config.inner_start) / (config.inner_npts - 1) @@ -247,18 +249,23 @@ def _build_1d_script(self, config: _FastSweepConfig) -> list[str]: meas, source, func, sense_mode = "v", "i", "0", "1" script = [ - f"{channel}.measure.nplc = {nplc:.12f}", - f"{channel}.sense = {sense_mode}", - f"{channel}.source.func = {func}", - f"{channel}.source.output = 1", - f"{channel}.measure.count = 1", + # Configure measurement channel + f"{meas_channel}.measure.nplc = {nplc:.12f}", + f"{meas_channel}.sense = {sense_mode}", + f"{meas_channel}.measure.count = 1", + # Configure sweep/source channel + f"{sweep_channel}.source.func = {func}", + f"{sweep_channel}.source.output = 1", + # Initialize sweep variables f"startX = {config.inner_start:.12f}", f"dX = {dX:.12f}", - f"{channel}.nvbuffer1.clear()", - f"{channel}.nvbuffer1.appendmode = 1", + # Clear measurement buffer + f"{meas_channel}.nvbuffer1.clear()", + f"{meas_channel}.nvbuffer1.appendmode = 1", + # Sweep loop f"for index = 1, {config.inner_npts} do", " target = startX + (index-1)*dX", - f" {channel}.source.level{source} = target", + f" {sweep_channel}.source.level{source} = target", ] if config.inner_delay > 0: @@ -266,11 +273,11 @@ def _build_1d_script(self, config: _FastSweepConfig) -> list[str]: script.extend( [ - f" {channel}.measure.{meas}({channel}.nvbuffer1)", + f" {meas_channel}.measure.{meas}({meas_channel}.nvbuffer1)", "end", "format.data = format.REAL32", "format.byteorder = format.LITTLEENDIAN", - f"printbuffer(1, {config.inner_npts}, {channel}.nvbuffer1.readings)", + f"printbuffer(1, {config.inner_npts}, {meas_channel}.nvbuffer1.readings)", ] ) return script @@ -282,6 +289,7 @@ def _build_2d_script(self, config: _FastSweepConfig) -> list[str]: inner_channel = config.inner_channel outer_channel = config.outer_channel + meas_channel = config.measurement_channel nplc = self.instrument.nplc() assert config.outer_start is not None @@ -303,24 +311,25 @@ def _build_2d_script(self, config: _FastSweepConfig) -> list[str]: outer_source, outer_func = "i", "0" script = [ + # Configure measurement channel + f"{meas_channel}.measure.nplc = {nplc:.12f}", + f"{meas_channel}.sense = {sense_mode}", + f"{meas_channel}.measure.count = 1", # Set up inner channel (fast sweep) - f"{inner_channel}.measure.nplc = {nplc:.12f}", - f"{inner_channel}.sense = {sense_mode}", f"{inner_channel}.source.func = {func}", f"{inner_channel}.source.output = 1", - f"{inner_channel}.measure.count = 1", - # Set up outer channel + # Set up outer channel (slow sweep) f"{outer_channel}.source.func = {outer_func}", f"{outer_channel}.source.output = 1", - # Initialize variables + # Initialize sweep variables f"startX_inner = {config.inner_start:.12f}", f"dX_inner = {dX_inner:.12f}", f"startX_outer = {config.outer_start:.12f}", f"dX_outer = {dX_outer:.12f}", - # Clear buffer - f"{inner_channel}.nvbuffer1.clear()", - f"{inner_channel}.nvbuffer1.appendmode = 1", - # Outer loop (slow axis on other channel) + # Clear measurement buffer + f"{meas_channel}.nvbuffer1.clear()", + f"{meas_channel}.nvbuffer1.appendmode = 1", + # Outer loop (slow axis) f"for outer_idx = 1, {config.outer_npts} do", " outer_target = startX_outer + (outer_idx-1)*dX_outer", f" {outer_channel}.source.level{outer_source} = outer_target", @@ -342,12 +351,12 @@ def _build_2d_script(self, config: _FastSweepConfig) -> list[str]: script.extend( [ - f" {inner_channel}.measure.{meas}({inner_channel}.nvbuffer1)", + f" {meas_channel}.measure.{meas}({meas_channel}.nvbuffer1)", " end", "end", "format.data = format.REAL32", "format.byteorder = format.LITTLEENDIAN", - f"printbuffer(1, {config.total_points}, {inner_channel}.nvbuffer1.readings)", + f"printbuffer(1, {config.total_points}, {meas_channel}.nvbuffer1.readings)", ] ) return script @@ -957,6 +966,7 @@ def setup_fastsweep( inner: _LinSweepLike, outer: _LinSweepLike | None = None, mode: Literal["IV", "VI", "VIfourprobe"] = "IV", + measure_inner_channel: bool = False, ) -> None: """ Configure a 1D or 2D fastsweep using sweep objects. @@ -980,12 +990,16 @@ def setup_fastsweep( ``delay``, ``num_points`` attributes and a ``get_setpoints()`` method. See :class:`qcodes.dataset.LinSweep` for an example. The channel is determined from ``param.instrument.channel``. - Measurement is performed on this channel. outer: Optional sweep object for the outer (slow) axis. If provided, performs a 2D sweep. mode: Sweep mode - 'IV' (sweep voltage, measure current), 'VI' (sweep current, measure voltage), or 'VIfourprobe' (four-probe VI measurement). + measure_inner_channel: If True, measure on the inner sweep channel. + If False (default), measure on the opposite sweep channel as inner. + This allows measuring a response on a different channel than + the one being swept. For example, sweep voltage on smua while + measuring current on smub. Example 1D: @@ -1031,6 +1045,14 @@ def get_channel(param: ParameterBase) -> str: inner_param = cast("Parameter", inner.param) inner_channel = get_channel(inner_param) + channel_to_measure = inner_channel + + if not measure_inner_channel: + channels = ["smua", "smub"] + channel_to_measure = next( + channel for channel in channels if channel != inner_channel + ) + # Build the configuration config = _FastSweepConfig( inner_start=inner_start, @@ -1042,6 +1064,7 @@ def get_channel(param: ParameterBase) -> str: inner_param_full_name=inner_param.full_name, inner_channel=inner_channel, mode=mode, + measurement_channel=channel_to_measure, ) # Add outer sweep configuration if provided From 1a5d37aed6e73df349227f6940098de782eb6f06 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Tue, 24 Feb 2026 16:17:40 -0800 Subject: [PATCH 21/22] Update K2600 example nb with notes on measure_inner_channel arg --- .../driver_examples/Qcodes example with Keithley 2600.ipynb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index ff288477e8e4..c35bc6aaa0ea 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -206,7 +206,9 @@ "Let's make a fast IV curve by sweeping the voltage from 1 V to 2 V in 500 steps.\n", "Create a `LinSweep` object and pass it to `setup_fastsweep`, then call `do0d` on `fastsweep`. \n", "\n", - "*NOTE:* `LinSweep` isn't specifically required here. We just need a `_LinSweepLike` object to pass, which requires `param`, `delay`, and `num_points` attributes and a `get_setpoints()` method." + "*NOTE on LinSweep:* `LinSweep` isn't specifically required here. We just need a `_LinSweepLike` object to pass, which requires `param`, `delay`, and `num_points` attributes and a `get_setpoints()` method.\n", + "\n", + "*NOTE on fastsweep:* Users may decide which channel the current/voltage is measured from during a fastsweep. It is usually expected to measure the channel that is being swept, but in cases where your measurement requires you to collect data from some other source (e.g., if you are changing A and want to measure effects on B), you can set `measure_inner_channel` to false in `setup_fastsweep`" ] }, { @@ -217,7 +219,7 @@ "source": [ "# Configure a 1D fastsweep using LinSweep\n", "fast_sweep_1d = LinSweep(keith.smua.volt, 1, 2, 500)\n", - "keith.smua.setup_fastsweep(fast_sweep_1d, mode=\"IV\")\n", + "keith.smua.setup_fastsweep(fast_sweep_1d, mode=\"IV\", measure_inner_channel=True)\n", "\n", "# Perform the measurement\n", "ds, _, _ = do0d(keith.smua.fastsweep)\n", From dba4da46ae53cfaadccaff29303069277f25c697 Mon Sep 17 00:00:00 2001 From: Thomas Lemon Date: Tue, 24 Feb 2026 16:19:05 -0800 Subject: [PATCH 22/22] Fix grammar in K2600 nb example --- .../driver_examples/Qcodes example with Keithley 2600.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb index c35bc6aaa0ea..04cf435978c3 100644 --- a/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb +++ b/docs/examples/driver_examples/Qcodes example with Keithley 2600.ipynb @@ -208,7 +208,7 @@ "\n", "*NOTE on LinSweep:* `LinSweep` isn't specifically required here. We just need a `_LinSweepLike` object to pass, which requires `param`, `delay`, and `num_points` attributes and a `get_setpoints()` method.\n", "\n", - "*NOTE on fastsweep:* Users may decide which channel the current/voltage is measured from during a fastsweep. It is usually expected to measure the channel that is being swept, but in cases where your measurement requires you to collect data from some other source (e.g., if you are changing A and want to measure effects on B), you can set `measure_inner_channel` to false in `setup_fastsweep`" + "*NOTE on fastsweep:* Users may decide which channel the current/voltage is measured from during a fastsweep. It is usually expected to measure the channel that is being swept (which is the default behavior), but in cases where your measurement requires you to collect data from some other terminal (e.g., if you are sweeping voltage on terminal A and want to measure current on terminal B), you can set `measure_inner_channel=False` in `setup_fastsweep`." ] }, {