From 8c9ee6584eac171be07bfd7c7cca33b8dad1375c Mon Sep 17 00:00:00 2001 From: germano Date: Wed, 7 Dec 2022 17:58:15 +0100 Subject: [PATCH 1/8] enable autotest override --- config/machine_settings/hostnames.ini | 3 ++- init.sh | 1 + src/ui/test_leak/test_leak.py | 2 +- src/ui/test_resistance/test_resistance.py | 2 +- 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/config/machine_settings/hostnames.ini b/config/machine_settings/hostnames.ini index c5a2c96..4963953 100644 --- a/config/machine_settings/hostnames.ini +++ b/config/machine_settings/hostnames.ini @@ -6,4 +6,5 @@ ST-TEN-1: st-ten-1 ST-TEN-2: st-ten-2 stten3: st-ten-3 this: this -LAPTOP-ST64MEV3: laptop \ No newline at end of file +LAPTOP-ST64MEV3: laptop +germano-neo: st-ten-2 \ No newline at end of file diff --git a/init.sh b/init.sh index 1378d63..fc9221d 100755 --- a/init.sh +++ b/init.sh @@ -4,6 +4,7 @@ here="$(realpath "$(dirname "$0")")" cd "$here" echo "---------- initialize venv ----------" +sudo apt-get install python3-venv lsof "./venv/bin/python" | awk 'NR > 1 {print $2}' | xargs kill || : lsof "./venv/Scripts/activate" | awk 'NR > 1 {print $2}' | xargs kill || : python="python" diff --git a/src/ui/test_leak/test_leak.py b/src/ui/test_leak/test_leak.py index c783554..1ec9244 100644 --- a/src/ui/test_leak/test_leak.py +++ b/src/ui/test_leak/test_leak.py @@ -5,7 +5,7 @@ from ui.test_test import Test_Test class Test_Leak(Test_Test): - def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=False): + def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=True): super().__init__(components=components, recipe=recipe, step=step, pieces=pieces, run_once=run_once, reset_on_start=reset_on_start, enable_override=enable_override) self.start_b.clicked.connect(lambda checked, self=weakref.ref(self): self().components["tecna_t3"].start_test()) self.stop_b.clicked.connect(lambda checked, self=weakref.ref(self): self().components["tecna_t3"].stop_test()) diff --git a/src/ui/test_resistance/test_resistance.py b/src/ui/test_resistance/test_resistance.py index 13a58e0..34c2d1f 100644 --- a/src/ui/test_resistance/test_resistance.py +++ b/src/ui/test_resistance/test_resistance.py @@ -5,7 +5,7 @@ from ui.test_test import Test_Test class Test_Resistance(Test_Test): - def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=False): + def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=True): super().__init__(components=components, recipe=recipe, step=step, pieces=pieces, run_once=run_once, reset_on_start=reset_on_start, enable_override=enable_override) self.ok_counter_limit = 3 From 46deb81013b706ba04320ae2c2b2342ab9e31cc5 Mon Sep 17 00:00:00 2001 From: germano Date: Fri, 16 Dec 2022 11:57:33 +0100 Subject: [PATCH 2/8] 4-wire resistance measurement feature TBT --- config/machine_settings/defaults.ini | 1 + config/machine_settings/st-ten-2.ini | 1 + src/components/multicomp_730424.py | 8 ++++++-- 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/config/machine_settings/defaults.ini b/config/machine_settings/defaults.ini index 5373d60..e2baedd 100644 --- a/config/machine_settings/defaults.ini +++ b/config/machine_settings/defaults.ini @@ -70,6 +70,7 @@ status_pin: 0 ; port: ? baudrate: 115200 cable_resistance: 0.75 +4wire: disabled [neo_pixels] ; port: ? diff --git a/config/machine_settings/st-ten-2.ini b/config/machine_settings/st-ten-2.ini index df7db02..8639302 100644 --- a/config/machine_settings/st-ten-2.ini +++ b/config/machine_settings/st-ten-2.ini @@ -13,6 +13,7 @@ port: COM6 [multicomp] port: COM10 +4wire: enabled [recipe] recipe_name_field: cod finito cliente diff --git a/src/components/multicomp_730424.py b/src/components/multicomp_730424.py index f49538c..291dabd 100644 --- a/src/components/multicomp_730424.py +++ b/src/components/multicomp_730424.py @@ -40,7 +40,10 @@ class Multicomp730424(Component): self.write("FUNC1 \"RES\"") self.write("RATE F") self.write("AUTO 0") - self.write("CONF:RES 500") + if self.config[self.name]["4wire"] is "enabled": + self.write("CONF:FRES 500") + else: + self.write("CONF:RES 500") def set_resistance_scale(self, resistance=None): if resistance is None: @@ -79,6 +82,7 @@ class Multicomp730424(Component): self.write(command) info[value_name] = self.read() if isinstance(info["measure"], float) and info["measure"] < 1e9: - info["measure"] -= self.cable_resistance + if self.config[self.name]["4wire"] is not "enabled": + info["measure"] -= self.cable_resistance self.log.debug(str(info)) super()._get([info]) From bbad2f28d02b1d2da65da75b323c063f06fd56f3 Mon Sep 17 00:00:00 2001 From: germano Date: Sat, 31 Dec 2022 14:00:23 +0100 Subject: [PATCH 3/8] usb-5860 test ok --- src/components/usb_5860.py | 154 +++++++++++++++++++++++++++++++++++++ src/test/test_usb5860.py | 18 +++++ 2 files changed, 172 insertions(+) create mode 100644 src/components/usb_5860.py create mode 100644 src/test/test_usb5860.py diff --git a/src/components/usb_5860.py b/src/components/usb_5860.py new file mode 100644 index 0000000..04c0c3b --- /dev/null +++ b/src/components/usb_5860.py @@ -0,0 +1,154 @@ +import ctypes +import sys +import time +from enum import Enum + +from PyQt5.QtCore import QMutex, Qt, QTimer, pyqtSlot + +from .component import Component + +if "--sim-io" not in sys.argv: + libbiodaq = ctypes.CDLL("/opt/advantech/libs/libbiodaq.so") +else: + import lib.dummies.libbiodaq as libbiodaq + + +class USB_5860(Component): + class DioPortDir(Enum): + Input = 0x00 + LoutHin = 0x0F + LinHout = 0xF0 + Output = 0xFF + + class DeviceInformation(ctypes.Structure): + _fields_ = [ + ('DeviceNumber', ctypes.c_uint32), + ('DeviceMode', ctypes.c_uint32), + ('ModuleIndex', ctypes.c_uint32), + ('Description', ctypes.c_wchar_p) + ] + + def __init__(self, bench, name, config): + super().__init__(bench, name, config) + self.mutex = QMutex() + # DEVICE INFORMATION + self.info = self.DeviceInformation() + self.info.Description = "USB-5860,BID#0" + #self.info.DeviceNumber = -1 + self.info.DeviceMode = 1 + self.info.ModuleIndex = 0 + # DIGITAL INPUTS CLASS + self.di_create = libbiodaq.AdxInstantDiCtrlCreate + self.di_create.restype = ctypes.c_void_p + self.di_setSelectedDevice = libbiodaq.InstantDiCtrl_setSelectedDevice + self.di_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.di_setSelectedDevice.restype = ctypes.c_uint32 + # DIGITAL INPUTS READ FUNCTION + self.di_read = libbiodaq.InstantDiCtrl_ReadAny + self.di_read.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p] + self.di_read.restype = ctypes.c_int32 + # DIGITAL OUTPUTS CLASS + self.do_create = libbiodaq.AdxInstantDoCtrlCreate + self.do_create.restype = ctypes.c_void_p + # SET SELECTED DEVICE + self.do_setSelectedDevice = libbiodaq.InstantDoCtrl_setSelectedDevice + self.do_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.do_setSelectedDevice.restype = ctypes.c_uint32 + # get ports + self.get_ports = libbiodaq.InstantDoCtrl_getPortDirection + self.get_ports.argtypes = [ctypes.c_void_p] + self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) + # # Array_getItem + # self.array_getItem = libbiodaq.TArray_getItem + # self.array_getItem.argtypes = [ctypes.c_void_p, ctypes.c_int32] + # self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) + # PortDirection_setDirection + self.port_direction_set_direction = libbiodaq.PortDirection_setDirection + self.port_direction_set_direction.argtypes = [ctypes.c_void_p, ctypes.c_uint8] + self.port_direction_set_direction.restype = ctypes.c_int32 + # DIGITAL OUTPUTS WRITE FUNCTION + self.do_write_bit = libbiodaq.InstantDoCtrl_WriteBit + self.do_write_bit.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char] + self.do_write_bit.restype = ctypes.c_int32 + self.buffer = ctypes.create_string_buffer(5) + # INIT OBJECTS + self.di_ctrl = self.di_create() + self.do_ctrl = self.do_create() + self.di_init_status = self.di_setSelectedDevice(self.di_ctrl, ctypes.byref(self.info)) + self.do_init_status = self.do_setSelectedDevice(self.do_ctrl, ctypes.byref(self.info)) + if "--sim-io" not in sys.argv: + self.dio_ports = self.get_ports(self.do_ctrl) + # SET ALL RELAYS OFF + for bit in range(0, 8): + self.set_bit(0, bit, False) + self.state_delay = 1 + self.last_get = None + self.state_count = None + self.last_out = None + + @pyqtSlot() + def start(self): + # ACQUISITION TIMER + self.timer = QTimer() + self.timer.setTimerType(Qt.PreciseTimer) + self.timer.setInterval(int(1000 / 20)) + self.timer.timeout.connect(self._get) + self.timer.start() + super().start() + + # Read data for buffer + @pyqtSlot() + def _get(self): + get = self.get() + # print(self.last_get) + if self.state_count is None or self.last_get is None: + self.last_out = get + self.state_count = [[1 for bit in byte] for byte in get] + else: + for byte_n, byte in enumerate(get): + for bit_n, bit in enumerate(byte): + if bit == self.last_get[byte_n][bit_n]: + self.state_count[byte_n][bit_n] += 1 + else: + self.state_count[byte_n][bit_n] = 1 + if self.state_count[byte_n][bit_n] > self.state_delay: + self.last_out[byte_n][bit_n] = bit + self.last_get = get + self.update.emit([time.time(), self.last_out]) + + masks = [1 << n for n in range(8)] + + def get_all(self): + return self.get() + + # Read all data bytes + def get(self): + self.mutex.lock() + self.di_read(self.di_ctrl, 0, 2, self.buffer) + read = [] + for byte in range(len(self.buffer)): + byte = ~int.from_bytes(self.buffer[byte], "little") + read.append([bool(byte & m) for m in self.masks]) + self.mutex.unlock() + return read + + # Read data bit + def get_bit(self, byte, bit): + return self.get()[byte][bit] + + # Send data byte + def set(self, start_byte, val): + for byte, v in enumerate(val, start=start_byte): + for bit, bv in enumerate([bool(v & m) for m in self.masks]): + self.set_bit(byte, bit, bv) + + # Write single bit + def set_bit(self, byte, bit, val): + self.mutex.lock() + # print("set", byte, bit, not val, flush=True) + self.do_write_bit(self.do_ctrl, byte, bit, int(val)) + self.mutex.unlock() + + # val from buffer channel + def vfbc(self, buffer, channel): + return buffer[channel[0]][channel[1]] diff --git a/src/test/test_usb5860.py b/src/test/test_usb5860.py new file mode 100644 index 0000000..4674628 --- /dev/null +++ b/src/test/test_usb5860.py @@ -0,0 +1,18 @@ +import time + +from src.components.usb_5860 import USB_5860 + +digital_io = USB_5860(None, None, None) +digital_io.start() + +out_val = 0 +while True: + res = digital_io.set_bit(0, 0, out_val) + input_data = digital_io.get() + print("in:{} out:{}".format(bytes(input_data[0]), out_val)) + + time.sleep(1) + if out_val == 0: + out_val = 1 + else: + out_val = 0 From ae8561c05a6c93e44a0e6ba4aa39b9fd12c52800 Mon Sep 17 00:00:00 2001 From: germano Date: Tue, 3 Jan 2023 10:22:54 +0100 Subject: [PATCH 4/8] usb5860 windows ok --- src/components/Automation/BDaq/AiChannel.py | 9 + src/components/Automation/BDaq/AiCtrlBase.py | 34 + src/components/Automation/BDaq/AiFeatures.py | 215 ++ .../Automation/BDaq/AnalogInputChannel.py | 208 ++ .../Automation/BDaq/AnalogOutputChannel.py | 82 + src/components/Automation/BDaq/AoChannel.py | 10 + src/components/Automation/BDaq/AoCtrlBase.py | 58 + src/components/Automation/BDaq/AoFeatures.py | 112 + src/components/Automation/BDaq/BDaqApi.py | 2749 +++++++++++++++++ .../Automation/BDaq/BufferedAoCtrl.py | 84 + src/components/Automation/BDaq/CjcSetting.py | 48 + .../Automation/BDaq/CntrCtrlBase.py | 95 + .../Automation/BDaq/CntrFeatures.py | 231 ++ src/components/Automation/BDaq/Conversion.py | 83 + .../Automation/BDaq/ConvertClock.py | 36 + .../BDaq/CounterCapabilityIndexer.py | 11 + .../BDaq/CounterClockSourceIndexer.py | 11 + .../BDaq/CounterGateSourceIndexer.py | 11 + .../Automation/BDaq/CounterIndexer.py | 19 + src/components/Automation/BDaq/DaqCtrlBase.py | 86 + src/components/Automation/BDaq/DeviceCtrl.py | 203 ++ .../Automation/BDaq/DiCosintPort.py | 27 + src/components/Automation/BDaq/DiPmintPort.py | 38 + .../Automation/BDaq/DiintChannel.py | 53 + src/components/Automation/BDaq/DioCtrlBase.py | 35 + src/components/Automation/BDaq/DioFeatures.py | 90 + src/components/Automation/BDaq/DioPort.py | 75 + src/components/Automation/BDaq/EcChannel.py | 77 + .../Automation/BDaq/EventCounterCtrl.py | 33 + src/components/Automation/BDaq/FmChannel.py | 53 + .../Automation/BDaq/FreqMeterCtrl.py | 34 + .../Automation/BDaq/InstantAiCtrl.py | 105 + .../Automation/BDaq/InstantAoCtrl.py | 21 + .../Automation/BDaq/InstantDiCtrl.py | 87 + .../Automation/BDaq/InstantDoCtrl.py | 38 + .../Automation/BDaq/NoiseFilterChannel.py | 27 + .../Automation/BDaq/NosFltChannel.py | 9 + src/components/Automation/BDaq/OneShotCtrl.py | 24 + src/components/Automation/BDaq/OsChannel.py | 103 + src/components/Automation/BDaq/PiChannel.py | 27 + src/components/Automation/BDaq/PoChannel.py | 93 + src/components/Automation/BDaq/PwMeterCtrl.py | 32 + .../Automation/BDaq/PwModulatorCtrl.py | 22 + src/components/Automation/BDaq/Record.py | 46 + src/components/Automation/BDaq/ScanChannel.py | 58 + .../Automation/BDaq/TimerPulseCtrl.py | 24 + src/components/Automation/BDaq/TmrChannel.py | 79 + src/components/Automation/BDaq/Trigger.py | 112 + src/components/Automation/BDaq/UdChannel.py | 132 + .../Automation/BDaq/UdCounterCtrl.py | 37 + src/components/Automation/BDaq/Utils.py | 203 ++ .../Automation/BDaq/WaveformAiCtrl.py | 95 + src/components/Automation/BDaq/__init__.py | 2427 +++++++++++++++ src/components/Automation/__init__.py | 0 src/components/usb_5860.py | 117 +- 55 files changed, 8781 insertions(+), 47 deletions(-) create mode 100644 src/components/Automation/BDaq/AiChannel.py create mode 100644 src/components/Automation/BDaq/AiCtrlBase.py create mode 100644 src/components/Automation/BDaq/AiFeatures.py create mode 100644 src/components/Automation/BDaq/AnalogInputChannel.py create mode 100644 src/components/Automation/BDaq/AnalogOutputChannel.py create mode 100644 src/components/Automation/BDaq/AoChannel.py create mode 100644 src/components/Automation/BDaq/AoCtrlBase.py create mode 100644 src/components/Automation/BDaq/AoFeatures.py create mode 100644 src/components/Automation/BDaq/BDaqApi.py create mode 100644 src/components/Automation/BDaq/BufferedAoCtrl.py create mode 100644 src/components/Automation/BDaq/CjcSetting.py create mode 100644 src/components/Automation/BDaq/CntrCtrlBase.py create mode 100644 src/components/Automation/BDaq/CntrFeatures.py create mode 100644 src/components/Automation/BDaq/Conversion.py create mode 100644 src/components/Automation/BDaq/ConvertClock.py create mode 100644 src/components/Automation/BDaq/CounterCapabilityIndexer.py create mode 100644 src/components/Automation/BDaq/CounterClockSourceIndexer.py create mode 100644 src/components/Automation/BDaq/CounterGateSourceIndexer.py create mode 100644 src/components/Automation/BDaq/CounterIndexer.py create mode 100644 src/components/Automation/BDaq/DaqCtrlBase.py create mode 100644 src/components/Automation/BDaq/DeviceCtrl.py create mode 100644 src/components/Automation/BDaq/DiCosintPort.py create mode 100644 src/components/Automation/BDaq/DiPmintPort.py create mode 100644 src/components/Automation/BDaq/DiintChannel.py create mode 100644 src/components/Automation/BDaq/DioCtrlBase.py create mode 100644 src/components/Automation/BDaq/DioFeatures.py create mode 100644 src/components/Automation/BDaq/DioPort.py create mode 100644 src/components/Automation/BDaq/EcChannel.py create mode 100644 src/components/Automation/BDaq/EventCounterCtrl.py create mode 100644 src/components/Automation/BDaq/FmChannel.py create mode 100644 src/components/Automation/BDaq/FreqMeterCtrl.py create mode 100644 src/components/Automation/BDaq/InstantAiCtrl.py create mode 100644 src/components/Automation/BDaq/InstantAoCtrl.py create mode 100644 src/components/Automation/BDaq/InstantDiCtrl.py create mode 100644 src/components/Automation/BDaq/InstantDoCtrl.py create mode 100644 src/components/Automation/BDaq/NoiseFilterChannel.py create mode 100644 src/components/Automation/BDaq/NosFltChannel.py create mode 100644 src/components/Automation/BDaq/OneShotCtrl.py create mode 100644 src/components/Automation/BDaq/OsChannel.py create mode 100644 src/components/Automation/BDaq/PiChannel.py create mode 100644 src/components/Automation/BDaq/PoChannel.py create mode 100644 src/components/Automation/BDaq/PwMeterCtrl.py create mode 100644 src/components/Automation/BDaq/PwModulatorCtrl.py create mode 100644 src/components/Automation/BDaq/Record.py create mode 100644 src/components/Automation/BDaq/ScanChannel.py create mode 100644 src/components/Automation/BDaq/TimerPulseCtrl.py create mode 100644 src/components/Automation/BDaq/TmrChannel.py create mode 100644 src/components/Automation/BDaq/Trigger.py create mode 100644 src/components/Automation/BDaq/UdChannel.py create mode 100644 src/components/Automation/BDaq/UdCounterCtrl.py create mode 100644 src/components/Automation/BDaq/Utils.py create mode 100644 src/components/Automation/BDaq/WaveformAiCtrl.py create mode 100644 src/components/Automation/BDaq/__init__.py create mode 100644 src/components/Automation/__init__.py diff --git a/src/components/Automation/BDaq/AiChannel.py b/src/components/Automation/BDaq/AiChannel.py new file mode 100644 index 0000000..b3ba0f5 --- /dev/null +++ b/src/components/Automation/BDaq/AiChannel.py @@ -0,0 +1,9 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.AnalogInputChannel import AnalogInputChannel + + +class AiChannel(AnalogInputChannel): + def __init__(self, nativeChannelObj): + super(AiChannel, self).__init__(nativeChannelObj) diff --git a/src/components/Automation/BDaq/AiCtrlBase.py b/src/components/Automation/BDaq/AiCtrlBase.py new file mode 100644 index 0000000..8a41415 --- /dev/null +++ b/src/components/Automation/BDaq/AiCtrlBase.py @@ -0,0 +1,34 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.BDaqApi import TAiCtrlBase, TArray +from Automation.BDaq.AiFeatures import AiFeatures +from Automation.BDaq.AiChannel import AiChannel + + +class AiCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(AiCtrlBase, self).__init__(scenario, devInfo) + self._ai_features = None + self._ai_channels = [] + + @property + def features(self): + if self._ai_features is None: + self._ai_features = AiFeatures(TAiCtrlBase.getFeatures(self._obj)) + return self._ai_features + + @property + def channels(self): + if not self._ai_channels: + count = self.features.channelCountMax + nativeArray = TAiCtrlBase.getChannels(self._obj) + for i in range(count): + aiChannObj = AiChannel(TArray.getItem(nativeArray, i)) + self._ai_channels.append(aiChannObj) + return self._ai_channels + + @property + def channelCount(self): + return TAiCtrlBase.getChannelCount(self._obj) diff --git a/src/components/Automation/BDaq/AiFeatures.py b/src/components/Automation/BDaq/AiFeatures.py new file mode 100644 index 0000000..11cbb57 --- /dev/null +++ b/src/components/Automation/BDaq/AiFeatures.py @@ -0,0 +1,215 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAiFeatures, TArray +from Automation.BDaq import Utils +from Automation.BDaq import MathInterval + + +class AiFeatures(object): + def __init__(self, nativeFeature): + self._ai_feature = nativeFeature + + # ADC features + @property + def resolution(self): + return TAiFeatures.getResolution(self._ai_feature) + + @property + def dataSize(self): + return TAiFeatures.getDataSize(self._ai_feature) + + @property + def dataMask(self): + return TAiFeatures.getDataMask(self._ai_feature) + + @property + def timestampResolution(self): + return TAiFeatures.getTimestampResolution(self._ai_feature) + + # channel features + @property + def channelCountMax(self): + return TAiFeatures.getChannelCountMax(self._ai_feature) + + @property + def channelType(self): + value = TAiFeatures.getChannelType(self._ai_feature) + return Utils.toAiChannelType(value) + + @property + def overallValueRange(self): + ret = TAiFeatures.getOverallValueRange(self._ai_feature) + return True if ret else False + + @property + def valueRanges(self): + nativeArr = TAiFeatures.getValueRanges(self._ai_feature) + return TArray.ToValueRange(nativeArr, True) + + @property + def burnoutReturnTypes(self): + nativeArr = TAiFeatures.getBurnoutReturnTypes(self._ai_feature) + return TArray.ToBurnoutRetType(nativeArr, True) + + @property + def connectionTypes(self): + nativeArr = TAiFeatures.getConnectionTypes(self._ai_feature) + return TArray.ToAiSignalType(nativeArr, True) + + @property + def overallConnection(self): + value = TAiFeatures.getOverallConnection(self._ai_feature) + return True if value else False + + @property + def couplingTypes(self): + nativeArr = TAiFeatures.getCouplingTypes(self._ai_feature) + return TArray.ToCouplingType(nativeArr, True) + + @property + def iepeTypes(self): + nativeArr = TAiFeatures.getIepeTypes(self._ai_feature) + return TArray.ToIepeType(nativeArr, True) + + @property + def impedanceTypes(self): + nativeArr = TAiFeatures.getImpedanceTypes(self._ai_feature) + return TArray.ToImpedanceType(nativeArr, True) + + @property + def filterTypes(self): + nativeArr = TAiFeatures.getFilterTypes(self._ai_feature) + return TArray.ToFilterType(nativeArr, True) + + @property + def filterCutoffFreqRange(self): + x = MathInterval() + TAiFeatures.getFilterCutoffFreqRange(self._ai_feature, ctypes.pointer(x)) + return x + + @property + def filterCutoffFreq1Range(self): + x = MathInterval() + TAiFeatures.getFilterCutoffFreq1Range(self._ai_feature, ctypes.pointer(x)) + return x + + # cjc featues + @property + def thermoSupported(self): + value = TAiFeatures.getThermoSupported(self._ai_feature) + return True if value else False + + @property + def cjcChannels(self): + nativeArr = TAiFeatures.getCjcChannels(self._ai_feature) + return TArray.ToInt32(nativeArr, True) + + # buffered ai -> basic features + @property + def bufferedAiSupported(self): + value = TAiFeatures.getBufferedAiSupported(self._ai_feature) + return True if value else False + + @property + def samplingMethod(self): + ret = TAiFeatures.getSamplingMethod(self._ai_feature) + return Utils.toSamplingMethod(ret) + + @property + def channelStartBase(self): + return TAiFeatures.getChannelStartBase(self._ai_feature) + + @property + def channelCountBase(self): + return TAiFeatures.getChannelCountBase(self._ai_feature) + + # buffered ai -> conversion clock features + @property + def convertClockSources(self): + nativeArr = TAiFeatures.getConvertClockSources(self._ai_feature) + return TArray.ToSignalDrop(nativeArr, True) + + @property + def convertClockRange(self): + x = MathInterval() + TAiFeatures.getConvertClockRange(self._ai_feature, ctypes.pointer(x)) + return x + + # buffered ai -> burst scan + @property + def burnstScanSupported(self): + value = TAiFeatures.getBurstScanSupported(self._ai_feature) + return True if value else False + + @property + def scanClockSources(self): + nativeArr = TAiFeatures.getScanClockSources(self._ai_feature) + return TArray.ToSignalDrop(nativeArr, True) + + @property + def scanClockRange(self): + x = MathInterval() + TAiFeatures.getScanClockRange(self._ai_feature, ctypes.pointer(x)) + return x + + @property + def scanCountMax(self): + return TAiFeatures.getScanCountMax(self._ai_feature) + + # buffered ai->trigger features + @property + def triggerCount(self): + return TAiFeatures.getTriggerCount(self._ai_feature) + + @property + def retriggerable(self): + value = TAiFeatures.getRetriggerable(self._ai_feature) + return True if value else False + + @property + def triggerFilterTypes(self): + nativeArr = TAiFeatures.getTriggerFilterTypes(self._ai_feature, 0) + return TArray.ToFilterType(nativeArr, True) + + @property + def triggerFilterCutoffFreq(self): + x = MathInterval() + TAiFeatures.getTriggerFilterCutoffFreqRange(self._ai_feature, 0, ctypes.byref(x)) + return x + + # trigger 0 + @property + def triggerSupported(self): + return self.triggerCount != 0 + + # trigger 1 + @property + def trigger1Supported(self): + return self.triggerCount > 1 + + # buffered ai->trigger0/1/../x features + def getTriggerActions(self, trigger = 0): + nativeArray = TAiFeatures.getTriggerActions(self._ai_feature, trigger) + return TArray.ToTriggerAction(nativeArray, True) + + def getTriggerDelayRange(self, trigger = 0): + x = MathInterval() + TAiFeatures.getTriggerDelayRange(self._ai_feature, trigger, ctypes.byref(x)) + return x + + def getTriggerSources(self, trigger = 0): + nativeArray = TAiFeatures.getTriggerSources(self._ai_feature, trigger) + return TArray.ToSignalDrop(nativeArray, True) + + def getTriggerSourceVrg(self, trigger = 0): + native = TAiFeatures.getTriggerSourceVrg(self._ai_feature, trigger) + return Utils.toValueRange(native) + + def getTriggerHysteresisIndexMax(self, trigger = 0): + return TAiFeatures.getTriggerHysteresisIndexMax(self._ai_feature, trigger) + + def getTriggerHysteresisIndexStep(self, trigger = 0): + return TAiFeatures.getTriggerHysteresisIndexStep(self._ai_feature, trigger) diff --git a/src/components/Automation/BDaq/AnalogInputChannel.py b/src/components/Automation/BDaq/AnalogInputChannel.py new file mode 100644 index 0000000..060ae93 --- /dev/null +++ b/src/components/Automation/BDaq/AnalogInputChannel.py @@ -0,0 +1,208 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAiChannel, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import * + + +class AnalogInputChannel(object): + def __init__(self, ai_channel_obj): + self._ai_channel_obj = ai_channel_obj + + @property + def channel(self): + return TAiChannel.getChannel(self._ai_channel_obj) + + @property + def logicalNumber(self): + return TAiChannel.getLogicalNumber(self._ai_channel_obj) + + @property + def valueRange(self): + value = TAiChannel.getValueRange(self._ai_channel_obj) + return Utils.toValueRange(value) + + @valueRange.setter + def valueRange(self, value): + if not isinstance(value, ValueRange): + raise TypeError('a ValueRange is required') + ret = ErrorCode.lookup(TAiChannel.setValueRange(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set valueRange is failed, the error code is 0x%X' % (ret.value)) + + @property + def signalType(self): + value = TAiChannel.getSignalType(self._ai_channel_obj) + return Utils.toAiSignalType(value) + + @signalType.setter + def signalType(self, value): + if not isinstance(value, AiSignalType): + raise TypeError('a AiSignalType is required') + ret = ErrorCode.lookup(TAiChannel.setSignalType(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set signalType is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnoutRetType(self): + value = TAiChannel.getBurnoutRetType(self._ai_channel_obj) + return Utils.toBurnoutRetType(value) + + @burnoutRetType.setter + def burnoutRetType(self, value): + if not isinstance(value, BurnoutRetType): + raise TypeError('a BurnoutRetType is required') + ret = ErrorCode.lookup(TAiChannel.setBurnoutRetType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set burnoutRetType is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnoutRetValue(self): + value = TAiChannel.getBurnoutRetValue(self._ai_channel_obj) + return value + + @burnoutRetValue.setter + def burnoutRetValue(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setBurnoutRetValue(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set burnoutRetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnShortRetValue(self): + return TAiChannel.getBurnShortRetValue(self._ai_channel_obj) + + @burnShortRetValue.setter + def burnShortRetValue(self, value): + if not isinstance(value, (float, int)): + raise TypeError("a float is required") + ret = ErrorCode.lookup(TAiChannel.setBurnShortRetValue(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set burnShortRetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterType(self): + value = TAiChannel.getFilterType(self._ai_channel_obj) + return Utils.toFilterType(value) + + @filterType.setter + def filterType(self, value): + if not isinstance(value, FilterType): + raise TypeError('a FilterType is requires') + ret = ErrorCode.lookup(TAiChannel.setFilterType(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterType is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq(self): + value = TAiChannel.getFilterCutoffFreq(self._ai_channel_obj) + return value + + @filterCutoffFreq.setter + def filterCutoffFreq(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setFilterCutoffFreq(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq1(self): + value = TAiChannel.getFilterCutoffFreq1(self._ai_channel_obj) + return value + + @filterCutoffFreq1.setter + def filterCutoffFreq1(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setFilterCutoffFreq1(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq1 is failed, the error code is 0x%X' % (ret.value)) + + @property + def couplingType(self): + value = TAiChannel.getCouplingType(self._ai_channel_obj) + return Utils.toCouplingType(value) + + @couplingType.setter + def couplingType(self, value): + if not isinstance(value, CouplingType): + raise TypeError('a CouplingType is required') + ret = ErrorCode.lookup(TAiChannel.setCouplingType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set couplingType is failed, the error code is 0x%X' % (ret.value)) + + @property + def iepeType(self): + value = TAiChannel.getIepeType(self._ai_channel_obj) + return Utils.toIepeType(value) + + @iepeType.setter + def iepeType(self, value): + if not isinstance(value, IepeType): + raise TypeError('a IepeType is required') + ret = ErrorCode.lookup(TAiChannel.setIepeType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set iepeType is failed, the error code is 0x%X' % (ret.value)) + + @property + def impedanceType(self): + value = TAiChannel.getImpedanceType(self._ai_channel_obj) + return Utils.toImpedanceType(value) + + @impedanceType.setter + def impedanceType(self, value): + if not isinstance(value, ImpedanceType): + raise TypeError('a ImpedanceType is required') + ret = ErrorCode.lookup(TAiChannel.setImpedanceType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set impedanceType is failed, the error code is 0x%X' % (ret.value)) + + @property + def sensorDescription(self): + desc = ctypes.create_unicode_buffer(1024) + pSize = (ctypes.c_int * 1)(1024) + err = TAiChannel.getSensorDescription(self._ai_channel_obj, pSize, desc) + if err == int(ErrorCode.ErrorBufferTooSmall.value): + desc = ctypes.create_unicode_buffer(pSize[0]) + err = TAiChannel.getSensorDescription(self._ai_channel_obj, pSize, desc) + + return ErrorCode.lookup(err), desc.value.encode() + + @sensorDescription.setter + def sensorDescription(self, value): + ret = ErrorCode.lookup(TAiChannel.setSensorDescription(self._ai_channel_obj, len(value), value)) + if BioFailed(ret): + raise ValueError('set sensorDescription is failed, the error code is 0x%X' % (ret.value)) + + @property + def scaleTable(self): + pSize = (c_int32 * 1)(32) + buffer = (MapFuncPiece * 32)() + ret = ErrorCode.lookup(TAiChannel.getScaleTable(self._ai_channel_obj, pSize, buffer)) + if ret == ErrorCode.ErrorBufferTooSmall: + buffer = (MapFuncPiece * pSize[0])() + ret = ErrorCode.lookup(TAiChannel.getScaleTable(self._ai_channel_obj, pSize, buffer)) + + if BioFailed(ret): + raise ValueError('get scaletable is failed, the error code is 0x%X' % (ret.value)) + return None + else: + data = [] + for i in range(pSize[0]): + data.append(buffer[i]) + return data + + @scaleTable.setter + def scaleTable(self, table): + size = len(table) + dataArra = (MapFuncPiece * size)() + for i in range(size): + dataArra[i] = table[i] + ret = ErrorCode.lookup(TAiChannel.setScaleTable(self._ai_channel_obj, size, dataArra)) + if BioFailed(ret): + raise ValueError('set scaleTable is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AnalogOutputChannel.py b/src/components/Automation/BDaq/AnalogOutputChannel.py new file mode 100644 index 0000000..37d3c47 --- /dev/null +++ b/src/components/Automation/BDaq/AnalogOutputChannel.py @@ -0,0 +1,82 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAoChannel, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import * + + +class AnalogOutputChannel(object): + def __init__(self, ao_channel_obj): + self._ao_channel_obj = ao_channel_obj + + @property + def channel(self): + return TAoChannel.getChannel(self._ao_channel_obj) + + @property + def valueRange(self): + return Utils.toValueRange(TAoChannel.getValueRange(self._ao_channel_obj)) + + @valueRange.setter + def valueRange(self, value): + if not isinstance(value, ValueRange): + raise TypeError('a ValueRange is required') + ret = ErrorCode.lookup(TAoChannel.setValueRange(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set valueRange is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefBipolar(self): + return TAoChannel.getExtRefBipolar(self._ao_channel_obj) + + @extRefBipolar.setter + def extRefBipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoChannel.setExtRefBipolar(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set extRefBipolar is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefUnipolar(self): + return TAoChannel.getExtRefUnipolar(self._ao_channel_obj) + + @extRefUnipolar.setter + def extRefUnipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoChannel.setExtRefUnipolar(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set extRefUnipolar is failed, the error code is 0x%X' % (ret.value)) + + + @property + def scaleTable(self): + pSize = (ctypes.c_int * 1)(32) + buffer = (MapFuncPiece * 32)() + ret = ErrorCode.lookup(TAoChannel.getScaleTable(self._ao_channel_obj, pSize, buffer)) + if ret == ErrorCode.ErrorBufferTooSmall: + buffer = (MapFuncPiece * pSize[0])() + ret = ErrorCode.lookup(TAoChannel.getScaleTable(self._ao_channel_obj, pSize, buffer)) + + if BioFailed(ret): + raise ValueError('get scaletable is failed, the error code is 0x%X' % (ret.value)) + return None + else: + data = [] + for i in range(pSize[0]): + data.append(buffer[i]) + return data + + @scaleTable.setter + def scaleTable(self, table): + size = len(table) + dataArra = (MapFuncPiece * size)() + for i in range(size): + dataArra[i] = table[i] + ret = ErrorCode.lookup(TAoChannel.setScaleTable(self._ao_channel_obj, size, dataArra)) + if BioFailed(ret): + raise ValueError('set scaletable is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AoChannel.py b/src/components/Automation/BDaq/AoChannel.py new file mode 100644 index 0000000..64dfaf2 --- /dev/null +++ b/src/components/Automation/BDaq/AoChannel.py @@ -0,0 +1,10 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.AnalogOutputChannel import AnalogOutputChannel + + +class AoChannel(AnalogOutputChannel): + def __init__(self, nativeChannelObj): + super(AoChannel, self).__init__(nativeChannelObj) diff --git a/src/components/Automation/BDaq/AoCtrlBase.py b/src/components/Automation/BDaq/AoCtrlBase.py new file mode 100644 index 0000000..c8ee19e --- /dev/null +++ b/src/components/Automation/BDaq/AoCtrlBase.py @@ -0,0 +1,58 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.BDaqApi import TAoCtrlBase, TArray, BioFailed +from Automation.BDaq.AoFeatures import AoFeatures +from Automation.BDaq.AoChannel import AoChannel +from Automation.BDaq import ErrorCode + + +class AoCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(AoCtrlBase, self).__init__(scenario, devInfo) + self._ao_features = None + self._ao_channels = [] + + @property + def features(self): + if self._ao_features is None: + self._ao_features = AoFeatures(TAoCtrlBase.getFeatures(self._obj)) + return self._ao_features + + @property + def channels(self): + if not self._ao_channels: + count = self.features.channelCountMax + nativeChannArr = TAoCtrlBase.getChannels(self._obj) + for i in range(count): + self._ao_channels.append(AoChannel(TArray.getItem(nativeChannArr, i))) + return self._ao_channels + + @property + def channelCount(self): + return self.features.channelCountMax + + @property + def extRefValueForUnipolar(self): + return TAoCtrlBase.getExtRefValueForUnipolar(self._obj) + + @extRefValueForUnipolar.setter + def extRefValueForUnipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoCtrlBase.setExtRefValueForUnipolar(self._obj, value)) + if BioFailed(ret): + raise ValueError('set extRefValueForUnipolar is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefValueForBipolar(self): + return TAoCtrlBase.getExtRefValueForBipolar(self._obj) + + @extRefValueForBipolar.setter + def extRefValueForBipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoCtrlBase.setExtRefValueForBipolar(self._obj, value)) + if BioFailed(ret): + raise ValueError('set extRefValueForBipolar is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AoFeatures.py b/src/components/Automation/BDaq/AoFeatures.py new file mode 100644 index 0000000..6669918 --- /dev/null +++ b/src/components/Automation/BDaq/AoFeatures.py @@ -0,0 +1,112 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAoFeatures +from Automation.BDaq.BDaqApi import TArray +from Automation.BDaq import MathInterval +from Automation.BDaq import Utils + + +class AoFeatures(object): + def __init__(self, nativeFeatures): + self._ao_feature = nativeFeatures + + # DAC features + @property + def resolution(self): + return TAoFeatures.getResolution(self._ao_feature) + + @property + def dataSize(self): + return TAoFeatures.getDataSize(self._ao_feature) + + @property + def dataMask(self): + return TAoFeatures.getDataMask(self._ao_feature) + + # channel features + @property + def channelCountMax(self): + return TAoFeatures.getChannelCountMax(self._ao_feature) + + @property + def valueRanges(self): + nativeArray = TAoFeatures.getValueRanges(self._ao_feature) + return TArray.ToValueRange(nativeArray, True) + + @property + def externalRefAntiPolar(self): + ret = TAoFeatures.getExternalRefAntiPolar(self._ao_feature) + return True if ret else False + + @property + def externalRefRange(self): + x = MathInterval() + TAoFeatures.getExternalRefRange(self._ao_feature, ctypes.pointer(x)) + return x + + # buffered ao->basic features + @property + def bufferedAoSupported(self): + ret = TAoFeatures.getBufferedAoSupported(self._ao_feature) + return True if ret else False + + @property + def samplingMethod(self): + ret = TAoFeatures.getSamplingMethod(self._ao_feature) + return Utils.toSamplingMethod(ret) + + @property + def channelStartBase(self): + return TAoFeatures.getChannelStartBase(self._ao_feature) + + @property + def channelCountBase(self): + return TAoFeatures.getChannelCountBase(self._ao_feature) + + # buffered ao->conversion clock features + @property + def convertClockSources(self): + nativeArray = TAoFeatures.getConvertClockSources(self._ao_feature) + return TArray.ToSignalDrop(nativeArray, True) + + @property + def convertClockRange(self): + x = MathInterval() + TAoFeatures.getConvertClockRange(self._ao_feature, ctypes.pointer(x)) + return x + + # buffered ao->trigger features + @property + def triggerCount(self): + return TAoFeatures.getTriggerCount(self._ao_feature) + + @property + def retriggerable(self): + value = TAoFeatures.getRetriggerable(self._ao_feature) + return True if value else False + + # trigger 0 + @property + def triggerSupported(self): + return self.triggerCount != 0 + + # trigger 1 + @property + def trigger1Supported(self): + return self.triggerCount > 1 + + def getTriggerActions(self, trigger = 0): + nativeArray = TAoFeatures.getTriggerActions(self._ao_feature, trigger) + return TArray.ToTriggerAction(nativeArray, True) + + def getTriggerDelayRange(self, trigger = 0): + x = MathInterval() + TAoFeatures.getTriggerDelayRange(self._ao_feature, trigger, ctypes.byref(x)) + return x + + def getTriggerSources(self, trigger = 0): + nativeArray = TAoFeatures.getTriggerSources(self._ao_feature, trigger) + return TArray.ToSignalDrop(nativeArray, True) \ No newline at end of file diff --git a/src/components/Automation/BDaq/BDaqApi.py b/src/components/Automation/BDaq/BDaqApi.py new file mode 100644 index 0000000..8a07693 --- /dev/null +++ b/src/components/Automation/BDaq/BDaqApi.py @@ -0,0 +1,2749 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import platform +from ctypes import * +from Automation.BDaq import * +from Automation.BDaq import Utils + +if platform.architecture()[0] == '32bit': + c_uint64 = c_uint32 + + +if platform.system().lower() == 'windows': + dll = windll.LoadLibrary(r"biodaq") +else: + dll = cdll.LoadLibrary(r"libbiodaq.so") + + +def AdxEnumToString(enumName, enumValue, enumStrLen): + pStr = create_unicode_buffer(enumStrLen, "\0") + dll.AdxEnumToString.argtypes = [c_wchar_p, c_uint32, c_uint32, c_wchar_p] + dll.AdxEnumToString.restype = c_int32 + dll.AdxEnumToString(enumName, enumValue, enumStrLen, pStr) + enumStrBuffer = pStr.value + pStr = None + return enumStrBuffer + + +def AdxGetValueRangeInformation(valueRangeArg, sizeofDesc, pDescription, pMathIntervalRange, pValueUnit): + dll.AdxGetValueRangeInformation.argtypes = [c_uint32, c_uint32, c_wchar_p, POINTER(MathInterval), POINTER(pValueUnit)] + dll.AdxGetValueRangeInformation.restype = c_uint32 + + ret = dll.AdxGetValueRangeInformation(valueRangeArg, sizeofDesc, pDescription, pMathIntervalRange, pValueUnit) + return ret + + +def BioFailed(ret): + if isinstance(ret, ErrorCode): + ret = ret.value + if c_ulong(ret).value >= c_ulong(0xC0000000).value: + return True + return False + + +class TArray(object): + + @staticmethod + def ToInt32(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + int_obj = cast(item, POINTER(c_int32)).contents + arr.append(int_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def ToInt64(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + int64_obj = cast(item, POINTER(c_int64)).contents + arr.append(int64_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def ToByte(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + byte_obj = cast(item, POINTER(c_byte)).contents + arr.append(byte_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def dispose(TArrayObj): + dll.TArray_Dispose.argtypes = [c_uint64] + dll.TArray_Dispose(TArrayObj) + + @staticmethod + def getLength(TArrayObj): + dll.TArray_getLength.argtypes = [c_uint64] + dll.TArray_getLength.restype = c_int32 + return dll.TArray_getLength(TArrayObj) + + @staticmethod + def getItem(TArrayObj, index): + dll.TArray_getItem.argtypes = [c_uint64, c_int32] + dll.TArray_getItem.restype = c_uint64 + return dll.TArray_getItem(TArrayObj, index) + + @staticmethod + def toDeviceTreeNode(nativeArr, autoFree=True): + count = TArray.getLength(nativeArr) + DeviceTreeNodeList = [] + for i in range(count): + item = TArray.getItem(nativeArr, i) + deviceTreeNodeObjSave = DeviceTreeNode() + deviceTreeNodeObj = cast(item, POINTER(DeviceTreeNode)).contents + + deviceTreeNodeObjSave.DevicIntEnumber = deviceTreeNodeObj.DevicIntEnumber + deviceTreeNodeObjSave.Description = deviceTreeNodeObj.Description + for j in range(8): + deviceTreeNodeObjSave.ModulesIndex[j] = deviceTreeNodeObj.ModulesIndex[j] + + DeviceTreeNodeList.append(deviceTreeNodeObjSave) + del deviceTreeNodeObj + if autoFree: + TArray.dispose(nativeArr) + return DeviceTreeNodeList + + @staticmethod + def ToEnum(nptr, autoFree, enumName, convert): + if nptr == 0: + return None + count = TArray.getLength(nptr) + data_list = [] + for i in range(count): + item = TArray.getItem(nptr, i) + enumValue = cast(item, POINTER(c_int)).contents.value + # cast to enum + enumObj = convert(enumValue) + data_list.append(enumObj) + if autoFree: + TArray.dispose(nptr) + return data_list + + @staticmethod + def ToTerminalBoard(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, TerminalBoard, Utils.toTerminalBoard) + + @staticmethod + def ToEventId(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, EventId, Utils.toEventId) + + @staticmethod + def toAccessMode(nativeArr, autoFree=True): + return TArray.ToEnum(nativeArr, autoFree, AccessMode, Utils.toAccessMode) + + @staticmethod + def ToValueRange(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ValueRange, Utils.toValueRange) + + @staticmethod + def ToAiSignalType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, AiSignalType, Utils.toAiSignalType) + + @staticmethod + def ToBurnoutRetType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, BurnoutRetType, Utils.toBurnoutRetType) + + @staticmethod + def ToFilterType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, FilterType, Utils.toFilterType) + + @staticmethod + def ToSignalDrop(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, SignalDrop, Utils.toSignalDrop) + + @staticmethod + def ToActiveSignal(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ActiveSignal, Utils.toActiveSignal) + + @staticmethod + def ToActiveSignal(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ActiveSignal, Utils.toActiveSignal) + + @staticmethod + def ToTriggerAction(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, TriggerAction, Utils.toTriggerAction) + + @staticmethod + def ToCounterCapability(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CounterCapability, Utils.toCounterCapability) + + @staticmethod + def ToSignalPolarity(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, SignalPolarity, Utils.toSignalPolarity) + + @staticmethod + def ToOutSignalType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, OutSignalType, Utils.toOutSignaleType) + + @staticmethod + def ToFreqMeasureMethod(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, FreqMeasureMethod, Utils.toFreqMeasureMethod) + + @staticmethod + def ToCounterCascadeGroup(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CounterCascadeGroup, Utils.toCounterCascadeGroup) + + @staticmethod + def ToCountingType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CountingType, Utils.toCountingType) + + @staticmethod + def ToCouplingType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CouplingType, Utils.toCouplingType) + + @staticmethod + def ToIepeType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, IepeType, Utils.toIepeType) + + @staticmethod + def ToImpedanceType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ImpedanceType, Utils.toImpedanceType) + + @staticmethod + def ToDoCircuitType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, DoCircuitType, Utils.toDoCircuitType) + + +class TScanChannel(object): + @staticmethod + def getChannelStart(obj): + dll.TScanChannel_getChannelStart.restype = c_int32 + dll.TScanChannel_getChannelStart.argtypes = [c_uint64] + return dll.TScanChannel_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TScanChannel_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TScanChannel_getChannelCount.restype = c_int32 + dll.TScanChannel_getChannelCount.argtypes = [c_uint64] + return dll.TScanChannel_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TScanChannel_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setChannelCount(obj, value) + + @staticmethod + def getIntervalCount(obj): + dll.TScanChannel_getIntervalCount.restype = c_int32 + dll.TScanChannel_getIntervalCount.argtypes = [c_uint64] + return dll.TScanChannel_getIntervalCount(obj) + + @staticmethod + def setIntervalCount(obj, value): + dll.TScanChannel_setIntervalCount.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setIntervalCount(obj, value) + + @staticmethod + def getSamples(obj): + dll.TScanChannel_getSamples.restype = c_int32 + dll.TScanChannel_getSamples.argtypes = [c_uint64] + return dll.TScanChannel_getSamples(obj) + + @staticmethod + def setSamples(obj, value): + dll.TScanChannel_setSamples.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setSamples(obj, value) + + +class TConvertClock(object): + @staticmethod + def getSource(obj): + dll.TConvertClock_getSource.argtypes = [c_uint64] + return dll.TConvertClock_getSource(obj) + + @staticmethod + def setSource(obj, value): + dll.TConvertClock_setSource.argtypes = [c_uint64, c_int32] + return dll.TConvertClock_setSource(obj, value) + + @staticmethod + def getRate(obj): + dll.TConvertClock_getRate.restype = c_double + dll.TConvertClock_getRate.argtypes = [c_uint64] + return dll.TConvertClock_getRate(obj) + + @staticmethod + def setRate(obj, value): + dll.TConvertClock_setRate.argtypes = [c_uint64, c_double] + return dll.TConvertClock_setRate(obj, c_double(value)) + + +class TTrigger(object): + @staticmethod + def getSource(obj): + dll.TTrigger_getSource.argtypes = [c_uint64] + dll.TTrigger_getSource.restype = c_int32 + return dll.TTrigger_getSource(obj) + + @staticmethod + def setSource(obj, value): + dll.TTrigger_setSource.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setSource(obj, value) + + @staticmethod + def getEdge(obj): + dll.TTrigger_getEdge.argtypes = [c_uint64] + dll.TTrigger_getEdge.restype = c_int32 + return dll.TTrigger_getEdge(obj) + + @staticmethod + def setEdge(obj, value): + dll.TTrigger_setEdge.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setEdge(obj, value) + + @staticmethod + def getLevel(obj): + dll.TTrigger_getLevel.argtypes = [c_uint64] + dll.TTrigger_getLevel.restype = c_double + return dll.TTrigger_getLevel(obj) + + @staticmethod + def setLevel(obj, value): + dll.TTrigger_setLevel.argtypes = [c_uint64, c_double] + return dll.TTrigger_setLevel(obj, c_double(value)) + + @staticmethod + def getAction(obj): + dll.TTrigger_getAction.argtypes = [c_uint64] + dll.TTrigger_getAction.restype = c_int32 + return dll.TTrigger_getAction(obj) + + @staticmethod + def setAction(obj, value): + dll.TTrigger_setAction.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setAction(obj, value) + + @staticmethod + def getDelayCount(obj): + dll.TTrigger_getDelayCount.argtypes = [c_uint64] + dll.TTrigger_getDelayCount.restype = c_int32 + return dll.TTrigger_getDelayCount(obj) + + @staticmethod + def setDelayCount(obj, value): + dll.TTrigger_setDelayCount.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setDelayCount(obj, value) + + @staticmethod + def getHysteresisIndex(obj): + dll.TTrigger_getHysteresisIndex.argtypes = [c_uint64] + dll.TTrigger_getHysteresisIndex.restype = c_double + return dll.TTrigger_getHysteresisIndex(obj) + + @staticmethod + def setHysteresisIndex(obj, value): + dll.TTrigger_setHysteresisIndex.argtypes = [c_uint64, c_double] + return dll.TTrigger_setHysteresisIndex(obj, c_double(value)) + + @staticmethod + def getFilterType(obj): + dll.TTrigger_getFilterType.argtypes = [c_uint64] + dll.TTrigger_getFilterType.restype = c_int32 + return dll.TTrigger_getFilterType(obj) + + @staticmethod + def setFilterType(obj, value): + dll.TTrigger_setFilterType.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setFilterType(obj, value) + + @staticmethod + def getFilterCutoffFreq(obj): + dll.TTrigger_getFilterCutoffFreq.argtypes = [c_uint64] + dll.TTrigger_getFilterCutoffFreq.restype = c_double + return dll.TTrigger_getFilterCutoffFreq(obj) + + @staticmethod + def setFilterCutoffFreq(obj, value): + dll.TTrigger_setFilterCutoffFreq.argtypes = [c_uint64, c_double] + return dll.TTrigger_setFilterCutoffFreq(obj, c_double(value)) + + +class TConversion(object): + @staticmethod + def getClockSource(obj): + dll.TConversion_getClockSource.argtypes = [c_uint64] + return dll.TConversion_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TConversion_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TConversion_setClockSource(obj, value) + + @staticmethod + def getClockRate(obj): + dll.TConversion_getClockRate.restype = c_double + dll.TConversion_getClockRate.argtypes = [c_uint64] + return dll.TConversion_getClockRate(obj) + + @staticmethod + def setClockRate(obj, value): + dll.TConversion_setClockRate.argtypes = [c_uint64, c_double] + return dll.TConversion_setClockRate(obj, c_double(value)) + + @staticmethod + def getChannelStart(obj): + dll.TConversion_getChannelStart.restype = c_int32 + dll.TConversion_getChannelStart.argtypes = [c_uint64] + return dll.TConversion_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TConversion_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TConversion_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TConversion_getChannelCount.restype = c_int32 + dll.TConversion_getChannelCount.argtypes = [c_uint64] + return dll.TConversion_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TConversion_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TConversion_setChannelCount(obj, value) + + @staticmethod + def getChannelMap(obj, count, chMap): + dll.TConversion_getChannelMap.argtypes = [c_uint64, c_int32, POINTER(c_byte)] # need attention + return dll.TConversion_getChannelMap(obj, count, chMap) + + @staticmethod + def setChannelMap(obj, count, chMap): + dll.TConversion_setChannelMap.argtypes = [c_uint64, c_int32, POINTER(c_byte)] # need attention + return dll.TConversion_setChannelMap(obj, count, chMap) + + +class TRecord(object): + @staticmethod + def getSectionLength(obj): + dll.TRecord_getSectionLength.restype = c_int32 + dll.TRecord_getSectionLength.argtypes = [c_uint64] + return dll.TRecord_getSectionLength(obj) + + @staticmethod + def setSectionLength(obj, value): + dll.TRecord_setSectionLength.argtypes = [c_uint64, c_int32] + return dll.TRecord_setSectionLength(obj, value) + + @staticmethod + def getSectionCount(obj): + dll.TRecord_getSectionCount.argtypes = [c_uint64] + return dll.TRecord_getSectionCount(obj) + + @staticmethod + def setSectionCount(obj, value): + dll.TRecord_setSectionCount.argtypes = [c_uint64, c_int32] + return dll.TRecord_setSectionCount(obj, value) + + @staticmethod + def getCycles(obj): + dll.TRecord_getCycles.restype = c_int32 + dll.TRecord_getCycles.argtypes = [c_uint64] + return dll.TRecord_getCycles(obj) + + @staticmethod + def setCycles(obj, value): + dll.TRecord_setCycles.argtypes = [c_uint64, c_int32] + return dll.TRecord_setCycles(obj, value) + + +class TNosFltChannel(object): + @staticmethod + def getChannel(obj): + dll.TNosFltChannel_getChannel.argtypes = [c_uint64] + return dll.TNosFltChannel_getChannel(obj) + + @staticmethod + def getEnabled(obj): + dll.TNosFltChannel_getEnabled.restype = c_int8 + dll.TNosFltChannel_getEnabled.argtypes = [c_uint64] + return dll.TNosFltChannel_getEnabled(obj) + + @staticmethod + def setEnabled(obj, value): + dll.TNosFltChannel_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TNosFltChannel_setEnabled(obj, value) + + +class TDeviceCtrl(object): + @staticmethod + def Refresh(dev_obj): + dll.TDeviceCtrl_Refresh.argtypes = [c_void_p] + return dll.TDeviceCtrl_Refresh(dev_obj) + + @staticmethod + def ReadRegister(dev_obj, space, offset, length, data_arr): + dll.TDeviceCtrl_ReadRegister.argtypes = [c_void_p, c_int32, c_int32, c_int32, c_void_p] # need attention + return dll.TDeviceCtrl_ReadRegister(dev_obj, space, offset, length, data_arr) + + @staticmethod + def WriteRegister(dev_obj, space, offset, length, data_arr): + dll.TDeviceCtrl_WriteRegister.argtypes = [c_void_p, c_int32, c_int32, c_int32, c_void_p] # need attention] + return dll.TDeviceCtrl_WriteRegister(dev_obj, space, offset, length, data_arr) + + @staticmethod + def ReadPrivateRegion(dev_obj, signature, length, data_arr): + dll.TDeviceCtrl_ReadPrivateRegion.argtypes = [c_void_p, c_int32, c_int32, POINTER(c_uint8)] # need attention] + return dll.TDeviceCtrl_ReadPrivateRegion(dev_obj, signature, length, data_arr) + + @staticmethod + def WritePrivateRegion(dev_obj, signature, length, data_arr): + dll.TDeviceCtrl_WritePrivateRegion.argtypes = [c_void_p, c_int32, c_int32, POINTER(c_uint8)] # need attention]] + return dll.TDeviceCtrl_WritePrivateRegion(dev_obj, signature, length, data_arr) + + @staticmethod + def SynchronizeTimebase(dev_obj): + dll.TDeviceCtrl_SynchronizeTimebase.argtypes = [c_void_p] + return dll.TDeviceCtrl_SynchronizeTimebase(dev_obj) + + @staticmethod + def CalculateAbsoluteTime(dev_obj, relativeTime): + dll.TDeviceCtrl_CalculateAbsoluteTime.restype = c_double + dll.TDeviceCtrl_CalculateAbsoluteTime.argtypes = [c_void_p, c_double] + return dll.TDeviceCtrl_CalculateAbsoluteTime(dev_obj, c_double(relativeTime)) + + @staticmethod + def getDeviceNumber(dev_obj): + dll.TDeviceCtrl_getDeviceNumber.restype = c_int32 + dll.TDeviceCtrl_getDeviceNumber.argtypes = [c_void_p] + return dll.TDeviceCtrl_getDeviceNumber(dev_obj) + + @staticmethod + def getDescription(dev_obj, length, descr): + dll.TDeviceCtrl_getDescription.argtypes = [c_void_p, c_int32, c_wchar_p] # need attention + return dll.TDeviceCtrl_getDescription(dev_obj, length, descr) + + @staticmethod + def setDescription(dev_obj, length, descr): + dll.TDeviceCtrl_setDescription.argtypes = [c_void_p, c_int32, c_wchar_p] # need attention] + return dll.TDeviceCtrl_setDescription(dev_obj, length, descr) + + @staticmethod + def getAccessMode(dev_obj): + dll.TDeviceCtrl_getAccessMode.argtypes = [c_void_p] + return dll.TDeviceCtrl_getAccessMode(dev_obj) + + @staticmethod + def getProductId(dev_obj): + dll.TDeviceCtrl_getProductId.argtypes = [c_void_p] + return dll.TDeviceCtrl_getProductId(dev_obj) + + @staticmethod + def getBoardId(dev_obj): + dll.TDeviceCtrl_getBoardId.restype = c_int32 + dll.TDeviceCtrl_getBoardId.argtypes = [c_void_p] + return dll.TDeviceCtrl_getBoardId(dev_obj) + + @staticmethod + def setBoardId(dev_obj, value): + dll.TDeviceCtrl_setBoardId.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setBoardId(dev_obj, value) + + @staticmethod + def getBoardVersion(dev_obj, length, version): + dll.TDeviceCtrl_getBoardVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getBoardVersion(dev_obj, length, version) + + @staticmethod + def getDriverVersion(dev_obj, length, version): + dll.TDeviceCtrl_getDriverVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getDriverVersion(dev_obj, length, version) + + @staticmethod + def getDllVersion(dev_obj, length, version): + dll.TDeviceCtrl_getDllVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getDllVersion(dev_obj, length, version) + + @staticmethod + def getLocation(dev_obj, length, location): + dll.TDeviceCtrl_getLocation.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getLocation(dev_obj, length, location) + + @staticmethod + def getPrivateRegionLength(dev_obj): + dll.TDeviceCtrl_getPrivateRegionLength.restype = c_int32 + dll.TDeviceCtrl_getPrivateRegionLength.argtypes = [c_void_p] + return dll.TDeviceCtrl_getPrivateRegionLength(dev_obj) + + @staticmethod + def getHotResetPreventable(dev_obj): + dll.TDeviceCtrl_getHotResetPreventable.restype = c_int32 + dll.TDeviceCtrl_getHotResetPreventable.argtypes = [c_void_p] + return dll.TDeviceCtrl_getHotResetPreventable(dev_obj) + + @staticmethod + def getBaseAddresses(dev_obj): + dll.TDeviceCtrl_getBaseAddresses.argtypes = [c_void_p] + dll.TDeviceCtrl_getBaseAddresses.restype = c_uint64 + return dll.TDeviceCtrl_getBaseAddresses(dev_obj) + + @staticmethod + def getInterrupts(dev_obj): + dll.TDeviceCtrl_getInterrupts.argtypes = [c_void_p] + dll.TDeviceCtrl_getInterrupts.restype = c_uint64 + return dll.TDeviceCtrl_getInterrupts(dev_obj) + + @staticmethod + def getSupportedTerminalBoard(dev_obj): + dll.TDeviceCtrl_getSupportedTerminalBoard.argtypes = [c_void_p] + dll.TDeviceCtrl_getSupportedTerminalBoard.restype = c_uint64 + return dll.TDeviceCtrl_getSupportedTerminalBoard(dev_obj) + + @staticmethod + def getSupportedEvents(dev_obj): + dll.TDeviceCtrl_getSupportedEvents.argtypes = [c_void_p] + dll.TDeviceCtrl_getSupportedEvents.restype = c_uint64 + return dll.TDeviceCtrl_getSupportedEvents(dev_obj) + + @staticmethod + def getSupportedScenarios(dev_obj): + dll.TDeviceCtrl_getSupportedScenarios.restype = c_int32 + dll.TDeviceCtrl_getSupportedScenarios.argtypes = [c_void_p] + return dll.TDeviceCtrl_getSupportedScenarios(dev_obj) + + @staticmethod + def getTerminalBoard(dev_obj): + dll.TDeviceCtrl_getTerminalBoard.argtypes = [c_void_p] + return dll.TDeviceCtrl_getTerminalBoard(dev_obj) + + @staticmethod + def setTerminalBoard(dev_obj, value): + dll.TDeviceCtrl_setTerminalBoard.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setTerminalBoard(dev_obj, value) + + @staticmethod + def setLocateEnabled(dev_obj, value): + dll.TDeviceCtrl_setLocateEnabled.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setLocateEnabled(dev_obj, value) + + @staticmethod + def getInstalledDevices(): + dll.TDeviceCtrl_getInstalledDevices.restype = c_uint64 + return dll.TDeviceCtrl_getInstalledDevices() + + @staticmethod + def getHwSpecific(dev_obj, name, pSize, dataArr): + dll.TDeviceCtrl_getHwSpecific.argtypes = [c_void_p, c_wchar_p, POINTER(c_int32), c_void_p] + return dll.TDeviceCtrl_getHwSpecific(dev_obj, name, pSize, dataArr) + + @staticmethod + def setHwSpecific(dev_obj, name, size, dataArr): + dll.TDeviceCtrl_setHwSpecific.argtypes = [c_void_p, c_wchar_p, c_int32, c_void_p] + return dll.TDeviceCtrl_setHwSpecific(dev_obj, name, size, dataArr) + + +class TDaqCtrlBase(object): + @staticmethod + def addEventHandler(obj, eventId, eventProc, userParam): + dll.TDaqCtrlBase_addEventHandler.argtypes = [c_uint64] + dll.TDaqCtrlBase_addEventHandler(obj, eventId, eventProc, userParam) # after add types + + @staticmethod + def removeEventHandler(obj, eventId, eventProc, userParam): + dll.TDaqCtrlBase_removeEventHandler.argtypes = [c_uint64] + dll.TDaqCtrlBase_removeEventHandler(obj, eventId, eventProc, userParam) # after add types + + @staticmethod + def cleanup(obj): + dll.TDaqCtrlBase_Cleanup.argtypes = [c_uint64] + dll.TDaqCtrlBase_Cleanup(obj) + + @staticmethod + def dispose(obj): + dll.TDaqCtrlBase_Dispose.argtypes = [c_uint64] + dll.TDaqCtrlBase_Dispose(obj) + + @staticmethod + def getSelectedDevice(obj, devInfo): + dll.TDaqCtrlBase_getSelectedDevice.argtypes = [c_uint64, POINTER(DeviceInformation)] + return dll.TDaqCtrlBase_getSelectedDevice(obj, byref(devInfo)) + + @staticmethod + def setSelectedDevice(obj, devInfo): + dll.TDaqCtrlBase_setSelectedDevice.argtypes = [c_uint64, POINTER(DeviceInformation)] + return dll.TDaqCtrlBase_setSelectedDevice(obj, byref(devInfo)) + + @staticmethod + def getState(obj): + dll.TDaqCtrlBase_getState.argtypes = [c_uint64] + return dll.TDaqCtrlBase_getState(obj) + + @staticmethod + def getDevice(obj): + dll.TDaqCtrlBase_getDevice.argtypes = [c_uint64] + dll.TDaqCtrlBase_getDevice.restype = c_void_p + return dll.TDaqCtrlBase_getDevice(obj) + + @staticmethod + def getSupportedDevices(obj): + dll.TDaqCtrlBase_getSupportedDevices.argtypes = [c_uint64] + dll.TDaqCtrlBase_getSupportedDevices.restype = c_uint64 + return dll.TDaqCtrlBase_getSupportedDevices(obj) + + @staticmethod + def getSupportedModes(obj): + dll.TDaqCtrlBase_getSupportedModes.argtypes = [c_uint64] + dll.TDaqCtrlBase_getSupportedModes.restype = c_uint64 + return dll.TDaqCtrlBase_getSupportedModes(obj) + + @staticmethod + def Create(scenario): + dll.TDaqCtrlBase_Create.argtypes = [c_int32] + dll.TDaqCtrlBase_Create.restype = c_uint64 + return dll.TDaqCtrlBase_Create(scenario) + + @staticmethod + def getModule(obj): + dll.TDaqCtrlBase_getModule.argtypes = [c_uint64] + dll.TDaqCtrlBase_getModule.restype = c_void_p + return dll.TDaqCtrlBase_getModule(obj) + + @staticmethod + def LoadProfile(obj, profile): + dll.TDaqCtrlBase_LoadProfile.argtypes = [c_uint64, c_wchar_p] + return dll.TDaqCtrlBase_LoadProfile(obj, profile) + + +class TAoCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TAoCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TAoCtrlBase_getFeatures.restype = c_uint64 + return dll.TAoCtrlBase_getFeatures(obj) + + @staticmethod + def getChannels(obj): + dll.TAoCtrlBase_getChannels.argtypes = [c_uint64] + dll.TAoCtrlBase_getChannels.restype = c_uint64 + return dll.TAoCtrlBase_getChannels(obj) + + @staticmethod + def getChannelCount(obj): + dll.TAoCtrlBase_getChannelCount.restype = c_int32 + dll.TAoCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TAoCtrlBase_getChannelCount(obj) + + @staticmethod + def getExtRefValueForUnipolar(obj): + dll.TAoCtrlBase_getExtRefValueForUnipolar.restype = c_double + dll.TAoCtrlBase_getExtRefValueForUnipolar.argtypes = [c_uint64] + return dll.TAoCtrlBase_getExtRefValueForUnipolar(obj) + + @staticmethod + def setExtRefValueForUnipolar(obj, value): + dll.TAoCtrlBase_setExtRefValueForUnipolar.argtypes = [c_uint64, c_double] + return dll.TAoCtrlBase_setExtRefValueForUnipolar(obj, c_double(value)) + + @staticmethod + def getExtRefValueForBipolar(obj): + dll.TAoCtrlBase_getExtRefValueForBipolar.restype = c_double + dll.TAoCtrlBase_getExtRefValueForBipolar.argtypes = [c_uint64] + return dll.TAoCtrlBase_getExtRefValueForBipolar(obj) + + @staticmethod + def setExtRefValueForBipolar(obj, value): + dll.TAoCtrlBase_setExtRefValueForBipolar.argtypes = [c_uint64, c_double] + return dll.TAoCtrlBase_setExtRefValueForBipolar(obj, c_double(value)) + + +class TInstantAoCtrl(object): + @staticmethod + def writeAny(obj, chStart, chCount, dataRaw, dataScaled): + dll.TInstantAoCtrl_WriteAny.argtypes = [c_uint64, c_int32, c_int32, c_void_p, POINTER(c_double)] + return dll.TInstantAoCtrl_WriteAny(obj, chStart, chCount, dataRaw, dataScaled) + + +class TAoFeatures(object): + # DAC features + @staticmethod + def getResolution(aoFeatureObj): + dll.TAoFeatures_getResolution.restype = c_int32 + dll.TAoFeatures_getResolution.argtypes = [c_uint64] + return dll.TAoFeatures_getResolution(aoFeatureObj) + + @staticmethod + def getDataSize(aoFeatureObj): + dll.TAoFeatures_getDataSize.restype = c_int32 + dll.TAoFeatures_getDataSize.argtypes = [c_uint64] + return dll.TAoFeatures_getDataSize(aoFeatureObj) + + @staticmethod + def getDataMask(aoFeatureObj): + dll.TAoFeatures_getDataMask.restype = c_int32 + dll.TAoFeatures_getDataMask.argtypes = [c_uint64] + return dll.TAoFeatures_getDataMask(aoFeatureObj) + + # channel features + @staticmethod + def getChannelCountMax(aoFeatureObj): + dll.TAoFeatures_getChannelCountMax.restype = c_int32 + dll.TAoFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelCountMax(aoFeatureObj) + + @staticmethod + def getValueRanges(aoFeatureObj): + dll.TAoFeatures_getValueRanges.argtypes = [c_uint64] + dll.TAoFeatures_getValueRanges.restype = c_uint64 + return dll.TAoFeatures_getValueRanges(aoFeatureObj) + + @staticmethod + def getExternalRefAntiPolar(aoFeatureObj): + dll.TAoFeatures_getExternalRefAntiPolar.restype = c_int8 + dll.TAoFeatures_getExternalRefAntiPolar.argtypes = [c_uint64] + return dll.TAoFeatures_getExternalRefAntiPolar(aoFeatureObj) + + @staticmethod + def getExternalRefRange(aoFeatureObj, mathIntervalObj): + dll.TAoFeatures_getExternalRefRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAoFeatures_getExternalRefRange(aoFeatureObj, mathIntervalObj) + + # buffered ao->basic features + @staticmethod + def getBufferedAoSupported(aoFeatureObj): + dll.TAoFeatures_getBufferedAoSupported.restype = c_int8 + dll.TAoFeatures_getBufferedAoSupported.argtypes = [c_uint64] + return dll.TAoFeatures_getBufferedAoSupported(aoFeatureObj) + + @staticmethod + def getSamplingMethod(aoFeatureObj): + dll.TAoFeatures_getSamplingMethod.argtypes = [c_uint64] + return dll.TAoFeatures_getSamplingMethod(aoFeatureObj) + + @staticmethod + def getChannelStartBase(aoFeatureObj): + dll.TAoFeatures_getChannelStartBase.restype = c_int32 + dll.TAoFeatures_getChannelStartBase.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelStartBase(aoFeatureObj) + + @staticmethod + def getChannelCountBase(aoFeatureObj): + dll.TAoFeatures_getChannelCountBase.restype = c_int32 + dll.TAoFeatures_getChannelCountBase.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelCountBase(aoFeatureObj) + + # buffered ao->conversion clock features + @staticmethod + def getConvertClockSources(aoFeatureObj): + dll.TAoFeatures_getConvertClockSources.argtypes = [c_uint64] + dll.TAoFeatures_getConvertClockSources.restype = c_uint64 + return dll.TAoFeatures_getConvertClockSources(aoFeatureObj) + + @staticmethod + def getConvertClockRange(aoFeatureObj, mathInterval): + dll.TAoFeatures_getConvertClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAoFeatures_getConvertClockRange(aoFeatureObj, mathInterval) + + # buffered ao->trigger features + @staticmethod + def getTriggerCount(aoFeatureObj): + dll.TAoFeatures_getTriggerCount.restype = c_int32 + dll.TAoFeatures_getTriggerCount.argtypes = [c_uint64] + return dll.TAoFeatures_getTriggerCount(aoFeatureObj) + + @staticmethod + def getRetriggerable(aoFeatureObj): + dll.TAoFeatures_getRetriggerable.restype = c_int8 + dll.TAoFeatures_getRetriggerable.argtypes = [c_uint64] + return dll.TAoFeatures_getRetriggerable(aoFeatureObj) + + # buffered ao->trigger0/1/.../x features + @staticmethod + def getTriggerSources(aoFeatureObj, trigger): + dll.TAoFeatures_getTriggerSources.argtypes = [c_uint64, c_int32] + dll.TAoFeatures_getTriggerSources.restype = c_uint64 + return dll.TAoFeatures_getTriggerSources(aoFeatureObj, trigger) + + @staticmethod + def getTriggerActions(aoFeatureObj, trigger): + dll.TAoFeatures_getTriggerActions.argtypes = [c_uint64, c_int32] + dll.TAoFeatures_getTriggerActions.restype = c_uint64 + return dll.TAoFeatures_getTriggerActions(aoFeatureObj, trigger) + + @staticmethod + def getTriggerDelayRange(aoFeatureObj, trigger, mathIntervalX): + dll.TAoFeatures_getTriggerDelayRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAoFeatures_getTriggerDelayRange(aoFeatureObj, trigger, mathIntervalX) + + +class TAoChannel(object): + @staticmethod + def getChannel(aoChannelObj): + dll.TAoChannel_getChannel.restype = c_int32 + dll.TAoChannel_getChannel.argtypes = [c_uint64] + return dll.TAoChannel_getChannel(aoChannelObj) + + @staticmethod + def getValueRange(aoChannelObj): + dll.TAoChannel_getValueRange.argtypes = [c_uint64] + return dll.TAoChannel_getValueRange(aoChannelObj) + + @staticmethod + def setValueRange(aoChannelObj, valueRange): + dll.TAoChannel_setValueRange.argtypes = [c_uint64, c_int32] + return dll.TAoChannel_setValueRange(aoChannelObj, valueRange) + + @staticmethod + def getExtRefBipolar(aoChannelObj): + dll.TAoChannel_getExtRefBipolar.restype = c_double + dll.TAoChannel_getExtRefBipolar.argtypes = [c_uint64] + return dll.TAoChannel_getExtRefBipolar(aoChannelObj) + + @staticmethod + def setExtRefBipolar(aoChannelObj, value): + dll.TAoChannel_setExtRefBipolar.argtypes = [c_uint64, c_double] + return dll.TAoChannel_setExtRefBipolar(aoChannelObj, c_double(value)) + + @staticmethod + def getExtRefUnipolar(aoChannelObj): + dll.TAoChannel_getExtRefUnipolar.restype = c_double + dll.TAoChannel_getExtRefUnipolar.argtypes = [c_uint64] + return dll.TAoChannel_getExtRefUnipolar(aoChannelObj) + + @staticmethod + def setExtRefUnipolar(aoChannelObj, value): + dll.TAoChannel_setExtRefUnipolar.argtypes = [c_uint64, c_double] + return dll.TAoChannel_setExtRefUnipolar(aoChannelObj, c_double(value)) + + # new: scale table + @staticmethod + def getScaleTable(aoChannelObj, pSize, mapFuncPieceTable): + dll.TAoChannel_getScaleTable.argtypes = [c_uint64, POINTER(c_int32), POINTER(MapFuncPiece)] + return dll.TAoChannel_getScaleTable(aoChannelObj, pSize, mapFuncPieceTable) + + @staticmethod + def setScaleTable(aoChannelObj, size, mapFuncPieceTable): + dll.TAoChannel_setScaleTable.argtypes = [c_uint64, c_int32, POINTER(MapFuncPiece)] + return dll.TAoChannel_setScaleTable(aoChannelObj, size, mapFuncPieceTable) + + +class TAiCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TAiCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TAiCtrlBase_getFeatures.restype = c_uint64 + return dll.TAiCtrlBase_getFeatures(obj) + + @staticmethod + def getChannels(obj): + dll.TAiCtrlBase_getChannels.restype = c_uint64 + dll.TAiCtrlBase_getChannels.argtypes = [c_uint64] + return dll.TAiCtrlBase_getChannels(obj) + + @staticmethod + def getChannelCount(obj): + dll.TAiCtrlBase_getChannelCount.restype = c_int32 + dll.TAiCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TAiCtrlBase_getChannelCount(obj) + + +class TWaveformAiCtrl(object): + @staticmethod + def Prepare(obj): + dll.TWaveformAiCtrl_Prepare.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Prepare(obj) + + @staticmethod + def Start(obj): + dll.TWaveformAiCtrl_Start.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Start(obj) + + @staticmethod + def Stop(obj): + dll.TWaveformAiCtrl_Stop.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Stop(obj) + + @staticmethod + def GetData(obj, dt, count, buffer, timeout, returned, startTime, markCount, makrBuf): + dll.TWaveformAiCtrl_GetData.argtypes = [c_uint64, c_int32, c_int32, c_void_p, c_int32, POINTER(c_int32), POINTER(c_double), POINTER(c_int32), POINTER(DataMark)] + return dll.TWaveformAiCtrl_GetData(obj, dt, count, buffer, timeout, returned, startTime, markCount, makrBuf) + + @staticmethod + def getConversion(obj): + dll.TWaveformAiCtrl_getConversion.argtypes = [c_uint64] + dll.TWaveformAiCtrl_getConversion.restype = c_uint64 + return dll.TWaveformAiCtrl_getConversion(obj) + + @staticmethod + def getRecord(obj): + dll.TWaveformAiCtrl_getRecord.argtypes = [c_uint64] + dll.TWaveformAiCtrl_getRecord.restype = c_uint64 + return dll.TWaveformAiCtrl_getRecord(obj) + + @staticmethod + def getTrigger(obj, trigIdx): + dll.TWaveformAiCtrl_getTrigger.argtypes = [c_uint64, c_int32] + dll.TWaveformAiCtrl_getTrigger.restype = c_uint64 + return dll.TWaveformAiCtrl_getTrigger(obj, trigIdx) + + +class TBufferedAoCtrl(object): + @staticmethod + def getScanChannel(obj): + dll.TBufferedAoCtrl_getScanChannel.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getScanChannel.restype = c_uint64 + return dll.TBufferedAoCtrl_getScanChannel(obj) + + @staticmethod + def getConvertClock(obj): + dll.TBufferedAoCtrl_getConvertClock.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getConvertClock.restype = c_uint64 + return dll.TBufferedAoCtrl_getConvertClock(obj) + + @staticmethod + def getTrigger(obj, trigIdx): + dll.TBufferedAoCtrl_getTrigger.argtypes = [c_uint64, c_int32] + dll.TBufferedAoCtrl_getTrigger.restype = c_uint64 + return dll.TBufferedAoCtrl_getTrigger(obj, trigIdx) + + @staticmethod + def getStreaming(obj): + dll.TBufferedAoCtrl_getStreaming.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getStreaming.restype = c_int8 + return dll.TBufferedAoCtrl_getStreaming(obj) + + @staticmethod + def setStreaming(obj, value): + dll.TBufferedAoCtrl_setStreaming.argtypes = [c_uint64, c_int8] + return dll.TBufferedAoCtrl_setStreaming(obj, value) + + @staticmethod + def Prepare(obj): + dll.TBufferedAoCtrl_Prepare.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_Prepare(obj) + + @staticmethod + def RunOnce(obj): + dll.TBufferedAoCtrl_RunOnce.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_RunOnce(obj) + + @staticmethod + def Start(obj): + dll.TBufferedAoCtrl_Start.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_Start(obj) + + @staticmethod + def Stop(obj, value): + dll.TBufferedAoCtrl_Stop.argtypes = [c_uint64, c_int32] + return dll.TBufferedAoCtrl_Stop(obj, value) + + @staticmethod + def SetData(obj, dt, count, buffer): + dll.TBufferedAoCtrl_SetData.argtypes = [c_uint64, c_int32, c_int32, c_void_p] + return dll.TBufferedAoCtrl_SetData(obj, dt, count, buffer) + + +class TInstantAiCtrl(object): + @staticmethod + def getCjc(obj): + dll.TInstantAiCtrl_getCjc.argtypes = [c_uint64] + dll.TInstantAiCtrl_getCjc.restype = c_uint64 + return dll.TInstantAiCtrl_getCjc(obj) + + @staticmethod + def getAutoConvertClockRate(obj): + dll.TInstantAiCtrl_getAutoConvertClockRate.restype = c_double + dll.TInstantAiCtrl_getAutoConvertClockRate.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertClockRate(obj) + + @staticmethod + def setAutoConvertClockRate(obj, value): + dll.TInstantAiCtrl_setAutoConvertClockRate.argtypes = [c_uint64, c_double] + return dll.TInstantAiCtrl_setAutoConvertClockRate(obj, c_double(value)) + + @staticmethod + def getAutoConvertChannelStart(obj): + dll.TInstantAiCtrl_getAutoConvertChannelStart.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertChannelStart(obj) + + @staticmethod + def setAutoConvertChannelStart(obj, intValue): + dll.TInstantAiCtrl_setAutoConvertChannelStart.argtypes = [c_uint64, c_int32] + return dll.TInstantAiCtrl_setAutoConvertChannelStart(obj, intValue) + + @staticmethod + def getAutoConvertChannelCount(obj): + dll.TInstantAiCtrl_getAutoConvertChannelCount.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertChannelCount(obj) + + @staticmethod + def setAutoConvertChannelCount(obj, intValue): + dll.TInstantAiCtrl_setAutoConvertChannelCount.argtypes = [c_uint64, c_int32] + return dll.TInstantAiCtrl_setAutoConvertChannelCount(obj, intValue) + + @staticmethod + def readAny(obj, chStart, chCount, dataRaw, dataScaled): + dll.TInstantAiCtrl_ReadAny.restype = c_uint32 + dll.TInstantAiCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, c_void_p, POINTER(c_double)] + return dll.TInstantAiCtrl_ReadAny(obj, chStart, chCount, dataRaw, dataScaled) + + +class TCjcSetting(object): + @staticmethod + def getChannel(cjcSetObj): + dll.TCjcSetting_getChannel.restype = c_int32 + dll.TCjcSetting_getChannel.argtypes = [c_uint64] + return dll.TCjcSetting_getChannel(cjcSetObj) + + @staticmethod + def setChannel(cjcSetObj, intCh): + dll.TCjcSetting_setChannel.argtypes = [c_uint64, c_int32] + return dll.TCjcSetting_setChannel(cjcSetObj, intCh) + + @staticmethod + def getValue(cjcSetObj): + dll.TCjcSetting_getValue.restype = c_double + dll.TCjcSetting_getValue.argtypes = [c_uint64] + return dll.TCjcSetting_getValue(cjcSetObj) + + @staticmethod + def setValue(cjcSetObj, value): + dll.TCjcSetting_setValue.argtypes = [c_uint64, c_double] + return dll.TCjcSetting_setValue(cjcSetObj, c_double(value)) + + @staticmethod + def getUpdateFreq(cjcSetObj): + dll.TCjcSetting_getUpdateFreq.restype = c_double + dll.TCjcSetting_getUpdateFreq.argtypes = [c_uint64] + return dll.TCjcSetting_getUpdateFreq(cjcSetObj) + + @staticmethod + def setUpdateFreq(cjcSetObj, value): + dll.TCjcSetting_setUpdateFreq.argtypes = [c_uint64, c_double] + return dll.TCjcSetting_setUpdateFreq(cjcSetObj, c_double(value)) + + +class TAiFeatures(object): + # ADC features + @staticmethod + def getResolution(aiFeatureObj): + dll.TAiFeatures_getResolution.restype = c_int32 + dll.TAiFeatures_getResolution.argtypes = [c_uint64] + return dll.TAiFeatures_getResolution(aiFeatureObj) + + @staticmethod + def getDataSize(aiFeatureObj): + dll.TAiFeatures_getDataSize.restype = c_int32 + dll.TAiFeatures_getDataSize.argtypes = [c_uint64] + return dll.TAiFeatures_getDataSize(aiFeatureObj) + + @staticmethod + def getDataMask(aiFeatureObj): + dll.TAiFeatures_getDataMask.restype = c_int32 + dll.TAiFeatures_getDataMask.argtypes = [c_uint64] + return dll.TAiFeatures_getDataMask(aiFeatureObj) + + # new: timestamp resolution + @staticmethod + def getTimestampResolution(aiFeatureObj): + dll.TAiFeatures_getTimestampResolution.restype = c_double + dll.TAiFeatures_getTimestampResolution.argtypes = [c_uint64] + return dll.TAiFeatures_getTimestampResolution(aiFeatureObj) + + # channel features + @staticmethod + def getChannelCountMax(aiFeatureObj): + dll.TAiFeatures_getChannelCountMax.restype = c_int32 + dll.TAiFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelCountMax(aiFeatureObj) + + @staticmethod + def getChannelType(aiFeatureObj): + dll.TAiFeatures_getChannelType.restype = c_int + dll.TAiFeatures_getChannelType.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelType(aiFeatureObj) + + @staticmethod + def getOverallValueRange(aiFeatureObj): + dll.TAiFeatures_getOverallValueRange.restype = c_int8 + dll.TAiFeatures_getOverallValueRange.argtypes = [c_uint64] + return dll.TAiFeatures_getOverallValueRange(aiFeatureObj) + + @staticmethod + def getValueRanges(aiFeatureObj): + dll.TAiFeatures_getValueRanges.argtypes = [c_uint64] + dll.TAiFeatures_getValueRanges.restype = c_uint64 + return dll.TAiFeatures_getValueRanges(aiFeatureObj) + + @staticmethod + def getBurnoutReturnTypes(aiFeatureObj): + dll.TAiFeatures_getBurnoutReturnTypes.argtypes = [c_uint64] + dll.TAiFeatures_getBurnoutReturnTypes.restype = c_uint64 + return dll.TAiFeatures_getBurnoutReturnTypes(aiFeatureObj) + + @staticmethod + def getConnectionTypes(aiFeatureObj): + dll.TAiFeatures_getConnectionTypes.argtypes = [c_uint64] + dll.TAiFeatures_getConnectionTypes.restype = c_uint64 + return dll.TAiFeatures_getConnectionTypes(aiFeatureObj) + + @staticmethod + def getOverallConnection(aiFeatureObj): + dll.TAiFeatures_getOverallConnection.restype = c_int8 + dll.TAiFeatures_getOverallConnection.argtypes = [c_uint64] + return dll.TAiFeatures_getOverallConnection(aiFeatureObj) + + # filter + @staticmethod + def getFilterTypes(aiFeatureObj): + dll.TAiFeatures_getFilterTypes.argtypes = [c_uint64] + dll.TAiFeatures_getFilterTypes.restype = c_uint64 + return dll.TAiFeatures_getFilterTypes(aiFeatureObj) + + @staticmethod + def getFilterCutoffFreqRange(aiFeaturesObj, mathIntervalVal): + dll.TAiFeatures_getFilterCutoffFreqRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getFilterCutoffFreqRange(aiFeaturesObj, mathIntervalVal) + + @staticmethod + def getFilterCutoffFreq1Range(aiFeaturesObj, mathIntervalVal): + dll.TAiFeatures_getFilterCutoffFreq1Range.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getFilterCutoffFreq1Range(aiFeaturesObj, mathIntervalVal) + + # CJC features + @staticmethod + def getThermoSupported(aiFeaturesObj): + dll.TAiFeatures_getThermoSupported.restype = c_int8 + dll.TAiFeatures_getThermoSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getThermoSupported(aiFeaturesObj) + + @staticmethod + def getCjcChannels(aiFeaturesObj): + dll.TAiFeatures_getCjcChannels.argtypes = [c_uint64] + dll.TAiFeatures_getCjcChannels.restype = c_uint64 + return dll.TAiFeatures_getCjcChannels(aiFeaturesObj) + + # buffered ai -> basic features + @staticmethod + def getBufferedAiSupported(aiFeaturesObj): + dll.TAiFeatures_getBufferedAiSupported.restype = c_int8 + dll.TAiFeatures_getBufferedAiSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getBufferedAiSupported(aiFeaturesObj) + + @staticmethod + def getSamplingMethod(aiFeaturesObj): + dll.TAiFeatures_getSamplingMethod.restype = c_int + dll.TAiFeatures_getSamplingMethod.argtypes = [c_uint64] + return dll.TAiFeatures_getSamplingMethod(aiFeaturesObj) + + @staticmethod + def getChannelStartBase(aiFeaturesObj): + dll.TAiFeatures_getChannelStartBase.restype = c_int32 + dll.TAiFeatures_getChannelStartBase.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelStartBase(aiFeaturesObj) + + @staticmethod + def getChannelCountBase(aiFeaturesObj): + dll.TAiFeatures_getChannelCountBase.restype = c_int32 + dll.TAiFeatures_getChannelCountBase.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelCountBase(aiFeaturesObj) + + # buffered ai->conversion clock features + @staticmethod + def getConvertClockSources(aiFeaturesObj): + dll.TAiFeatures_getConvertClockSources.argtypes = [c_uint64] + dll.TAiFeatures_getConvertClockSources.restype = c_uint64 + return dll.TAiFeatures_getConvertClockSources(aiFeaturesObj) + + @staticmethod + def getConvertClockRange(aiFeaturesObj, mathIntervalValue): + dll.TAiFeatures_getConvertClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getConvertClockRange(aiFeaturesObj, mathIntervalValue) + + # buffered ai->burst scan + @staticmethod + def getBurstScanSupported(aiFeaturesObj): + dll.TAiFeatures_getBurstScanSupported.restype = c_int8 + dll.TAiFeatures_getBurstScanSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getBurstScanSupported(aiFeaturesObj) + + @staticmethod + def getScanClockSources(aiFeaturesObj): + dll.TAiFeatures_getScanClockSources.argtypes = [c_uint64] + dll.TAiFeatures_getScanClockSources.restype = c_uint64 + return dll.TAiFeatures_getScanClockSources(aiFeaturesObj) + + @staticmethod + def getScanClockRange(aiFeaturesObj, mathIntervalValue): + dll.TAiFeatures_getScanClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getScanClockRange(aiFeaturesObj, mathIntervalValue) + + @staticmethod + def getScanCountMax(aiFeaturesObj): + dll.TAiFeatures_getScanCountMax.restype = c_int32 + dll.TAiFeatures_getScanCountMax.argtypes = [c_uint64] + return dll.TAiFeatures_getScanCountMax(aiFeaturesObj) + + # buffered ai->trigger features + @staticmethod + def getRetriggerable(aiFeaturesObj): + dll.TAiFeatures_getRetriggerable.restype = c_int8 + dll.TAiFeatures_getRetriggerable.argtypes = [c_uint64] + return dll.TAiFeatures_getRetriggerable(aiFeaturesObj) + + @staticmethod + def getTriggerCount(aiFeaturesObj): + dll.TAiFeatures_getTriggerCount.restype = c_int32 + dll.TAiFeatures_getTriggerCount.argtypes = [c_uint64] + return dll.TAiFeatures_getTriggerCount(aiFeaturesObj) + + @staticmethod + def getTriggerFilterTypes(aiFeaturesObj, reserved): + dll.TAiFeatures_getTriggerFilterTypes.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerFilterTypes.restype = c_uint64 + return dll.TAiFeatures_getTriggerFilterTypes(aiFeaturesObj, reserved) + + @staticmethod + def getTriggerFilterCutoffFreqRange(aiFeaturesObj, reserved, mathIntervalValue): + dll.TAiFeatures_getTriggerFilterCutoffFreqRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAiFeatures_getTriggerFilterCutoffFreqRange(aiFeaturesObj, reserved, mathIntervalValue) + + # buffered ai->trigger0/1/.../x features + @staticmethod + def getTriggerActions(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerActions.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerActions.restype = c_uint64 + return dll.TAiFeatures_getTriggerActions(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerDelayRange(aiFeaturesObj, trigger, mathIntervalX): + dll.TAiFeatures_getTriggerDelayRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAiFeatures_getTriggerDelayRange(aiFeaturesObj, trigger, mathIntervalX) + + @staticmethod + def getTriggerSources(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerSources.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerSources.restype = c_uint64 + return dll.TAiFeatures_getTriggerSources(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerSourceVrg(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerSourceVrg.argtypes = [c_uint64, c_int32] + return dll.TAiFeatures_getTriggerSourceVrg(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerHysteresisIndexMax(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerHysteresisIndexMax.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerHysteresisIndexMax.restype = c_double + return dll.TAiFeatures_getTriggerHysteresisIndexMax(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerHysteresisIndexStep(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerHysteresisIndexStep.argtypes = [c_uint64, c_int32] + return dll.TAiFeatures_getTriggerHysteresisIndexStep(aiFeaturesObj, trigger) + + # new coupling & IEPE & Impedance + @staticmethod + def getCouplingTypes(aiFeaturesObj): + dll.TAiFeatures_getCouplingTypes.argtypes = [c_uint64] + dll.TAiFeatures_getCouplingTypes.restype = c_uint64 + return dll.TAiFeatures_getCouplingTypes(aiFeaturesObj) + + @staticmethod + def getIepeTypes(aiFeaturesObj): + dll.TAiFeatures_getIepeTypes.argtypes = [c_uint64] + dll.TAiFeatures_getIepeTypes.restype = c_uint64 + return dll.TAiFeatures_getIepeTypes(aiFeaturesObj) + + @staticmethod + def getImpedanceTypes(aiFeaturesObj): + dll.TAiFeatures_getImpedanceTypes.argtypes = [c_uint64] + dll.TAiFeatures_getImpedanceTypes.restype = c_uint64 + return dll.TAiFeatures_getImpedanceTypes(aiFeaturesObj) + + # new: sensor features + @staticmethod + def getMeasureTypes(aiFeaturesObj): + dll.TAiFeatures_getMeasureTypes.argtypes = [c_uint64] + dll.TAiFeatures_getMeasureTypes.restype = c_uint64 + return dll.TAiFeatures_getMeasureTypes(aiFeaturesObj) + + @staticmethod + def getBridgeResistances(aiFeaturesObj): + dll.TAiFeatures_getBridgeResistances.argtypes = [c_uint64] + dll.TAiFeatures_getBridgeResistances.restype = c_uint64 + return dll.TAiFeatures_getBridgeResistances(aiFeaturesObj) + + @staticmethod + def getExcitingVoltageRange(aiFeaturesObj): + dll.TAiFeatures_getExcitingVoltageRange.argtypes = [c_uint64] + return dll.TAiFeatures_getExcitingVoltageRange(aiFeaturesObj) + + +class TAiChannel(object): + @staticmethod + def getChannel(aiChannObj): + dll.TAiChannel_getChannel.restype = c_int32 + dll.TAiChannel_getChannel.argtypes = [c_uint64] + return dll.TAiChannel_getChannel(aiChannObj) + + @staticmethod + def getLogicalNumber(aiChannObj): + dll.TAiChannel_getLogicalNumber.restype = c_int32 + dll.TAiChannel_getLogicalNumber.argtypes = [c_uint64] + return dll.TAiChannel_getLogicalNumber(aiChannObj) + + @staticmethod + def getValueRange(aiChannObj): + dll.TAiChannel_getValueRange.restype = c_int + dll.TAiChannel_getValueRange.argtypes = [c_uint64] + return dll.TAiChannel_getValueRange(aiChannObj) + + @staticmethod + def setValueRange(aiChannObj, valueRangeValue): + dll.TAiChannel_setValueRange.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setValueRange(aiChannObj, valueRangeValue) + + @staticmethod + def getSignalType(aiChannObj): + dll.TAiChannel_getSignalType.restype = c_int + dll.TAiChannel_getSignalType.argtypes = [c_uint64] + return dll.TAiChannel_getSignalType(aiChannObj) + + @staticmethod + def setSignalType(aiChannObj, aiSignalTypeValue): + dll.TAiChannel_setSignalType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setSignalType(aiChannObj, aiSignalTypeValue) + + @staticmethod + def getBurnoutRetType(aiChannObj): + dll.TAiChannel_getBurnoutRetType.restype = c_int + dll.TAiChannel_getBurnoutRetType.argtypes = [c_uint64] + return dll.TAiChannel_getBurnoutRetType(aiChannObj) + + @staticmethod + def setBurnoutRetType(aiChannObj, burnoutRetTypeValue): + dll.TAiChannel_setBurnoutRetType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setBurnoutRetType(aiChannObj, burnoutRetTypeValue) + + @staticmethod + def getBurnoutRetValue(aiChannObj): + dll.TAiChannel_getBurnoutRetValue.restype = c_double + dll.TAiChannel_getBurnoutRetValue.argtypes = [c_uint64] + return dll.TAiChannel_getBurnoutRetValue(aiChannObj) + + @staticmethod + def setBurnoutRetValue(aiChannObj, value): + dll.TAiChannel_setBurnoutRetValue.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setBurnoutRetValue(aiChannObj, c_double(value)) + + @staticmethod + def getBurnShortRetValue(aiChannObj): + dll.TAiChannel_getBurnShortRetValue.restype = c_double + dll.TAiChannel_getBurnShortRetValue.argtypes = [c_uint64] + return dll.TAiChannel_getBurnShortRetValue(aiChannObj) + + @staticmethod + def setBurnShortRetValue(aiChannObj, value): + dll.TAiChannel_setBurnShortRetValue.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setBurnShortRetValue(aiChannObj, c_double(value)) + + @staticmethod + def getFilterType(aiChannObj): + dll.TAiChannel_getFilterType.restype = c_int + dll.TAiChannel_getFilterType.argtypes = [c_uint64] + return dll.TAiChannel_getFilterType(aiChannObj) + + @staticmethod + def setFilterType(aiChannObj, filterTypeValue): + dll.TAiChannel_setFilterType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setFilterType(aiChannObj, filterTypeValue) + + @staticmethod + def getFilterCutoffFreq(aiChannObj): + dll.TAiChannel_getFilterCutoffFreq.restype = c_double + dll.TAiChannel_getFilterCutoffFreq.argtypes = [c_uint64] + return dll.TAiChannel_getFilterCutoffFreq(aiChannObj) + + @staticmethod + def setFilterCutoffFreq(aiChannObj, value): + dll.TAiChannel_setFilterCutoffFreq.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setFilterCutoffFreq(aiChannObj, c_double(value)) + + @staticmethod + def getFilterCutoffFreq1(aiChannObj): + dll.TAiChannel_getFilterCutoffFreq1.restype = c_double + dll.TAiChannel_getFilterCutoffFreq1.argtypes = [c_uint64] + return dll.TAiChannel_getFilterCutoffFreq1(aiChannObj) + + @staticmethod + def setFilterCutoffFreq1(aiChannObj, value): + dll.TAiChannel_setFilterCutoffFreq1.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setFilterCutoffFreq1(aiChannObj, c_double(value)) + + # new: Coupling & IEPE & Impedance + @staticmethod + def getCouplingType(aiChannObj): + dll.TAiChannel_getCouplingType.restype = c_int + dll.TAiChannel_getCouplingType.argtypes = [c_uint64] + return dll.TAiChannel_getCouplingType(aiChannObj) + + @staticmethod + def setCouplingType(aiChannObj, couplingTypeValue): + dll.TAiChannel_setCouplingType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setCouplingType(aiChannObj, couplingTypeValue) + + @staticmethod + def getIepeType(aiChannObj): + dll.TAiChannel_getIepeType.restype = c_int + dll.TAiChannel_getIepeType.argtypes = [c_uint64] + return dll.TAiChannel_getIepeType(aiChannObj) + + @staticmethod + def setIepeType(aiChannObj, iepeTypeValue): + dll.TAiChannel_setIepeType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setIepeType(aiChannObj, iepeTypeValue) + + @staticmethod + def getImpedanceType(aiChannObj): + dll.TAiChannel_getImpedanceType.restype = c_int + dll.TAiChannel_getImpedanceType.argtypes = [c_uint64] + return dll.TAiChannel_getImpedanceType(aiChannObj) + + @staticmethod + def setImpedanceType(aiChannObj, impedanceTypeValue): + dll.TAiChannel_setImpedanceType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setImpedanceType(aiChannObj, impedanceTypeValue) + + # new: Sensor Scaling + @staticmethod + def getSensorDescription(aiChannObj, pSize, wDescArr): + dll.TAiChannel_getSensorDescription.argtypes = [c_uint64, POINTER(c_int32), c_wchar_p] + return dll.TAiChannel_getSensorDescription(aiChannObj, pSize, wDescArr) + + @staticmethod + def setSensorDescription(aiChannObj, size, wDescArr): + dll.TAiChannel_setSensorDescription.argtypes = [c_uint64, c_int32, c_wchar_p] + return dll.TAiChannel_setSensorDescription(aiChannObj, size, wDescArr) + + # new: scale table + @staticmethod + def getScaleTable(aiChannObj, pSize, mapFuncPieceTable): + dll.TAiChannel_getScaleTable.argtypes = [c_uint64, POINTER(c_int32), POINTER(MapFuncPiece)] + return dll.TAiChannel_getScaleTable(aiChannObj, pSize, mapFuncPieceTable) + + @staticmethod + def setScaleTable(aiChannObj, size, mapFuncPieceTable): + dll.TAiChannel_setScaleTable.argtypes = [c_uint64, c_int32, POINTER(MapFuncPiece)] + return dll.TAiChannel_setScaleTable(aiChannObj, size, mapFuncPieceTable) + + +################################################## +# DIO部分 +################################################## +class TDioCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TDioCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TDioCtrlBase_getFeatures.restype = c_uint64 + return dll.TDioCtrlBase_getFeatures(obj) + + @staticmethod + def getPortCount(obj): + dll.TDioCtrlBase_getPortCount.restype = c_int32 + dll.TDioCtrlBase_getPortCount.argtypes = [c_uint64] + return dll.TDioCtrlBase_getPortCount(obj) + + @staticmethod + def getPorts(obj): + dll.TDioCtrlBase_getPorts.argtypes = [c_uint64] + dll.TDioCtrlBase_getPorts.restype = c_uint64 + return dll.TDioCtrlBase_getPorts(obj) + + +class TInstantDoCtrl(object): + @staticmethod + def writeAny(obj, startPort, portCount, dataArray): + dll.TInstantDoCtrl_WriteAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_WriteAny(obj, startPort, portCount, dataArray) + + @staticmethod + def readAny(obj, startPort, portCount, dataArray): + dll.TInstantDoCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_ReadAny(obj, startPort, portCount, dataArray) + + @staticmethod + def writeBit(obj, port, bit, data): + dll.TInstantDoCtrl_WriteBit.argtypes = [c_uint64, c_int32, c_int32, c_uint8] + return dll.TInstantDoCtrl_WriteBit(obj, port, bit, data) + + @staticmethod + def readBit(obj, port, bit, data): + dll.TInstantDoCtrl_ReadBit.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_ReadBit(obj, port, bit, byref(data)) + + +class TInstantDiCtrl(object): + @staticmethod + def readAny(obj, portStart, portCount, dataArray): + dll.TInstantDiCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDiCtrl_ReadAny(obj, portStart, portCount, dataArray) + + @staticmethod + def readBit(obj, port, bit, data): + dll.TInstantDiCtrl_ReadBit.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDiCtrl_ReadBit(obj, port, bit, data) + + @staticmethod + def snapStart(obj): + dll.TInstantDiCtrl_SnapStart.argtypes = [c_uint64] + return dll.TInstantDiCtrl_SnapStart(obj) + + @staticmethod + def snapStop(obj): + dll.TInstantDiCtrl_SnapStop.argtypes = [c_uint64] + return dll.TInstantDiCtrl_SnapStop(obj) + + @staticmethod + def getNoiseFilterBlockTime(obj): + dll.TInstantDiCtrl_getNoiseFilterBlockTime.restype = c_double + dll.TInstantDiCtrl_getNoiseFilterBlockTime.argtypes = [c_uint64] + return dll.TInstantDiCtrl_getNoiseFilterBlockTime(obj) + + @staticmethod + def setNoiseFilterBlockTime(obj, value): + dll.TInstantDiCtrl_setNoiseFilterBlockTime.argtypes = [c_uint64, c_double] + return dll.TInstantDiCtrl_setNoiseFilterBlockTime(obj, c_double(value)) + + @staticmethod + def getNoiseFilter(obj): + dll.TInstantDiCtrl_getNoiseFilter.argtypes = [c_uint64] + dll.TInstantDiCtrl_getNoiseFilter.restype = c_uint64 + return dll.TInstantDiCtrl_getNoiseFilter(obj) + + @staticmethod + def getDiintChannels(obj): + dll.TInstantDiCtrl_getDiintChannels.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiintChannels.restype = c_uint64 + return dll.TInstantDiCtrl_getDiintChannels(obj) + + @staticmethod + def getDiCosintPorts(obj): + dll.TInstantDiCtrl_getDiCosintPorts.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiCosintPorts.restype = c_uint64 + return dll.TInstantDiCtrl_getDiCosintPorts(obj) + + @staticmethod + def getDiPmintPorts(obj): + dll.TInstantDiCtrl_getDiPmintPorts.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiPmintPorts.restype = c_uint64 + return dll.TInstantDiCtrl_getDiPmintPorts(obj) + + +class TDioPort(object): + @staticmethod + def getPort(obj): + dll.TDioPort_getPort.restype = c_int32 + dll.TDioPort_getPort.argtypes = [c_uint64] + return dll.TDioPort_getPort(obj) + + @staticmethod + def getDirection(obj): + dll.TDioPort_getDirection.argtypes = [c_uint64] + return dll.TDioPort_getDirection(obj) + + @staticmethod + def setDirection(obj, value): + dll.TDioPort_setDirection.argtypes = [c_uint64, c_int32] + return dll.TDioPort_setDirection(obj, value) + + @staticmethod + def getDiInversePort(obj): + dll.TDioPort_getDiInversePort.restype = c_uint8 + dll.TDioPort_getDiInversePort.argtypes = [c_uint64] + return dll.TDioPort_getDiInversePort(obj) + + @staticmethod + def setDiInversePort(obj, value): + dll.TDioPort_setDiInversePort.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDiInversePort(obj, value) + + @staticmethod + def getDiOpenState(obj): + dll.TDioPort_getDiOpenState.restype = c_uint8 + dll.TDioPort_getDiOpenState.argtypes = [c_uint64] + return dll.TDioPort_getDiOpenState(obj) + + @staticmethod + def setDiOpenState(obj, value): + dll.TDioPort_setDiOpenState.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDiOpenState(obj, value) + + @staticmethod + def getDoPresetValue(obj): + dll.TDioPort_getDoPresetValue.restype = c_uint8 + dll.TDioPort_getDoPresetValue.argtypes = [c_uint64] + return dll.TDioPort_getDoPresetValue(obj) + + @staticmethod + def setDoPresetValue(obj, value): + dll.TDioPort_setDoPresetValue.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDoPresetValue(obj, value) + + @staticmethod + def getDoCircuitType(obj): + dll.TDioPort_getDoCircuitType.argtypes = [c_uint64] + return dll.TDioPort_getDoCircuitType(obj) + + @staticmethod + def setDoCircuitType(obj, value): + dll.TDioPort_setDoCircuitType.argtypes = [c_uint64, c_int32] + return dll.TDioPort_setDoCircuitType(obj, value) + + +class TDiintChannel(object): + @staticmethod + def getChannel(diIntChanObj): + dll.TDiintChannel_getChannel.restype = c_int32 + dll.TDiintChannel_getChannel.argtypes = [c_uint64] + return dll.TDiintChannel_getChannel(diIntChanObj) + + @staticmethod + def getEnabled(diIntChanObj): + dll.TDiintChannel_getEnabled.restype = c_int8 + dll.TDiintChannel_getEnabled.argtypes = [c_uint64] + return dll.TDiintChannel_getEnabled(diIntChanObj) + + @staticmethod + def setEnabled(diIntChanObj, value): + dll.TDiintChannel_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TDiintChannel_setEnabled(diIntChanObj, value) + + @staticmethod + def getGated(diIntChanObj): + dll.TDiintChannel_getGated.restype = c_int8 + dll.TDiintChannel_getGated.argtypes = [c_uint64] + return dll.TDiintChannel_getGated(diIntChanObj) + + @staticmethod + def setGated(diIntChanObj, value): + dll.TDiintChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TDiintChannel_setGated(diIntChanObj, value) + + @staticmethod + def getTrigEdge(diIntChanObj): + dll.TDiintChannel_getTrigEdge.argtypes = [c_uint64] + return dll.TDiintChannel_getTrigEdge(diIntChanObj) + + @staticmethod + def setTrigEdge(diIntChanObj, value): + dll.TDiintChannel_setTrigEdge.argtypes = [c_uint64, c_int32] + return dll.TDiintChannel_setTrigEdge(diIntChanObj, value) + + +class TDiCosintPort(object): + @staticmethod + def getPort(obj): + dll.TDiCosintPort_getPort.restype = c_int32 + dll.TDiCosintPort_getPort.argtypes = [c_uint64] + return dll.TDiCosintPort_getPort(obj) + + @staticmethod + def getMask(obj): + dll.TDiCosintPort_getMask.restype = c_byte + dll.TDiCosintPort_getMask.argtypes = [c_uint64] + return dll.TDiCosintPort_getMask(obj) + + @staticmethod + def setMask(obj, value): + dll.TDiCosintPort_setMask.argtypes = [c_uint64, c_uint8] + return dll.TDiCosintPort_setMask(obj, value) + + +class TDiPmintPort(object): + @staticmethod + def getPort(obj): + dll.TDiPmintPort_getPort.restype = c_int32 + dll.TDiPmintPort_getPort.argtypes = [c_uint64] + return dll.TDiPmintPort_getPort(obj) + + @staticmethod + def getMask(obj): + dll.TDiPmintPort_getMask.restype = c_uint8 + dll.TDiPmintPort_getMask.argtypes = [c_uint64] + return dll.TDiPmintPort_getMask(obj) + + @staticmethod + def setMask(obj, value): + dll.TDiPmintPort_setMask.argtypes = [c_uint64, c_uint8] + return dll.TDiPmintPort_setMask(obj, value) + + @staticmethod + def getPattern(obj): + dll.TDiPmintPort_getPattern.restype = c_uint8 + dll.TDiPmintPort_getPattern.argtypes = [c_uint64] + return dll.TDiPmintPort_getPattern(obj) + + @staticmethod + def setPattern(obj, value): + dll.TDiPmintPort_setPattern.argtypes = [c_uint64, c_uint8] + return dll.TDiPmintPort_setPattern(obj, value) + + +class TDioFeatures(object): + @staticmethod + def getPortProgrammable(obj): + dll.TDioFeatures_getPortProgrammable.restype = c_int8 + dll.TDioFeatures_getPortProgrammable.argtypes = [c_uint64] + return dll.TDioFeatures_getPortProgrammable(obj) + + @staticmethod + def getChannelCountMax(obj): + dll.TDioFeatures_getChannelCountMax.restype = c_int32 + dll.TDioFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TDioFeatures_getChannelCountMax(obj) + + @staticmethod + def getPortCount(obj): + dll.TDioFeatures_getPortCount.restype = c_int32 + dll.TDioFeatures_getPortCount.argtypes = [c_uint64] + return dll.TDioFeatures_getPortCount(obj) + + @staticmethod + def getPortsType(obj): + dll.TDioFeatures_getPortsType.argtypes = [c_uint64] + dll.TDioFeatures_getPortsType.restype = c_uint64 + return dll.TDioFeatures_getPortsType(obj) + + @staticmethod + def getDiSupported(obj): + dll.TDioFeatures_getDiSupported.restype = c_int8 + dll.TDioFeatures_getDiSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDiSupported(obj) + + @staticmethod + def getDoSupported(obj): + dll.TDioFeatures_getDoSupported.restype = c_int8 + dll.TDioFeatures_getDoSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDoSupported(obj) + + @staticmethod + def getDiDataMask(obj): + dll.TDioFeatures_getDiDataMask.argtypes = [c_uint64] + dll.TDioFeatures_getDiDataMask.restype = c_uint64 + return dll.TDioFeatures_getDiDataMask(obj) + + @staticmethod + def getDiNoiseFilterSupported(obj): + dll.TDioFeatures_getDiNoiseFilterSupported.restype = c_int8 + dll.TDioFeatures_getDiNoiseFilterSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDiNoiseFilterSupported(obj) + + @staticmethod + def getDiNoiseFilterOfChannels(obj): + dll.TDioFeatures_getDiNoiseFilterOfChannels.argtypes = [c_uint64] + dll.TDioFeatures_getDiNoiseFilterOfChannels.restype = c_uint64 + return dll.TDioFeatures_getDiNoiseFilterOfChannels(obj) + + @staticmethod + def getDiNoiseFilterBlockTimeRange(obj, mathIntervalValue): + dll.TDioFeatures_getDiNoiseFilterBlockTimeRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TDioFeatures_getDiNoiseFilterBlockTimeRange(obj, mathIntervalValue) + + @staticmethod + def getDoDataMask(obj): + dll.TDioFeatures_getDoDataMask.argtypes = [c_uint64] + return dll.TDioFeatures_getDoDataMask(obj) + + @staticmethod + def getDoFreezeSignalSources(obj): + dll.TDioFeatures_getDoFreezeSignalSources.argtypes = [c_uint64] + return dll.TDioFeatures_getDoFreezeSignalSources(obj) + + @staticmethod + def getDoReflectWdtFeedIntervalRange(obj, mathInterValValue): + dll.TDioFeatures_getDoReflectWdtFeedIntervalRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TDioFeatures_getDoReflectWdtFeedIntervalRange(obj, mathInterValValue) + + @staticmethod + def getDoPresetValueDepository(obj): + dll.TDioFeatures_getDoPresetValueDepository.argtypes = [c_uint64] + return dll.TDioFeatures_getDoPresetValueDepository(obj) + + @staticmethod + def getDoCircuitSelectableTypes(obj): + dll.TDioFeatures_getDoCircuitSelectableTypes.argtypes = [c_uint64] + return dll.TDioFeatures_getDoCircuitSelectableTypes(obj) + + +class TCounterIndexer(object): + @staticmethod + def getLength(obj): + dll.TCounterIndexer_getLength.restype = c_int32 + dll.TCounterIndexer_getLength.argtypes = [c_uint64] + return dll.TCounterIndexer_getLength(obj) + + @staticmethod + def getItem(obj, index): + dll.TCounterIndexer_getItem.argtypes = [c_uint64, c_int32] + dll.TCounterIndexer_getItem.restype = c_uint64 + return dll.TCounterIndexer_getItem(obj, index) + + @staticmethod + def dispose(obj): + dll.TCounterIndexer_Dispose.argtypes = [c_uint64] + dll.TCounterIndexer_Dispose(obj) + + +class TCntrFeatures(object): + @staticmethod + def getChannelCountMax(obj): + dll.TCntrFeatures_getChannelCountMax.restype = c_int32 + dll.TCntrFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TCntrFeatures_getChannelCountMax(obj) + + @staticmethod + def getResolution(obj): + dll.TCntrFeatures_getResolution.restype = c_int32 + dll.TCntrFeatures_getResolution.argtypes = [c_uint64] + return dll.TCntrFeatures_getResolution(obj) + + @staticmethod + def getDataSize(obj): + dll.TCntrFeatures_getDataSize.restype = c_int32 + dll.TCntrFeatures_getDataSize.argtypes = [c_uint64] + return dll.TCntrFeatures_getDataSize(obj) + + @staticmethod + def getCapabilities(obj): + dll.TCntrFeatures_getCapabilities.argtypes = [c_uint64] + dll.TCntrFeatures_getCapabilities.restype = c_uint64 + return dll.TCntrFeatures_getCapabilities(obj) + + # noise filter features + @staticmethod + def getNoiseFilterSupported(obj): + dll.TCntrFeatures_getNoiseFilterSupported.restype = c_int8 + dll.TCntrFeatures_getNoiseFilterSupported.argtypes = [c_uint64] + return dll.TCntrFeatures_getNoiseFilterSupported(obj) + + @staticmethod + def getNoiseFilterOfChannels(obj): + dll.TCntrFeatures_getNoiseFilterOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getNoiseFilterOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getNoiseFilterOfChannels(obj) + + @staticmethod + def getNoiseFilterBlockTimeRange(obj, x): + dll.TCntrFeatures_getNoiseFilterBlockTimeRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getNoiseFilterBlockTimeRange(obj, byref(x)) + + # event counting features + @staticmethod + def getEcClockSources(obj): + dll.TCntrFeatures_getEcClockSources.argtypes = [c_uint64] + dll.TCntrFeatures_getEcClockSources.restype = c_uint64 + return dll.TCntrFeatures_getEcClockSources(obj) + + @staticmethod + def getEcClockPolarities(obj): + dll.TCntrFeatures_getEcClockPolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getEcClockPolarities.restype = c_uint64 + return dll.TCntrFeatures_getEcClockPolarities(obj) + + @staticmethod + def getEcGatePolarities(obj): + dll.TCntrFeatures_getEcGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getEcGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getEcGatePolarities(obj) + + @staticmethod + def getEcGateControlOfChannels(obj): + dll.TCntrFeatures_getEcGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getEcGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getEcGateControlOfChannels(obj) + + # frequency measurement features + @staticmethod + def getFmMethods(obj): + dll.TCntrFeatures_getFmMethods.argtypes = [c_uint64] + dll.TCntrFeatures_getFmMethods.restype = c_uint64 + return dll.TCntrFeatures_getFmMethods(obj) + + # one-shot features + @staticmethod + def getOsClockSources(obj): + dll.TCntrFeatures_getOsClockSources.argtypes = [c_uint64] + dll.TCntrFeatures_getOsClockSources.restype = c_uint64 + return dll.TCntrFeatures_getOsClockSources(obj) + + @staticmethod + def getOsClockPolarities(obj): + dll.TCntrFeatures_getOsClockPolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getOsClockPolarities.restype = c_uint64 + return dll.TCntrFeatures_getOsClockPolarities(obj) + + @staticmethod + def getOsGateSources(obj): + dll.TCntrFeatures_getOsGateSources.argtypes = [c_uint64] + dll.TCntrFeatures_getOsGateSources.restype = c_uint64 + return dll.TCntrFeatures_getOsGateSources(obj) + + @staticmethod + def getOsGatePolarities(obj): + dll.TCntrFeatures_getOsGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getOsGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getOsGatePolarities(obj) + + @staticmethod + def getOsOutSignals(obj): + dll.TCntrFeatures_getOsOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getOsOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getOsOutSignals(obj) + + @staticmethod + def getOsDelayCountRange(obj, x): + dll.TCntrFeatures_getOsDelayCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getOsDelayCountRange(obj, byref(x)) + + # Timer/pulse features + @staticmethod + def getTmrGateControlOfChannels(obj): + dll.TCntrFeatures_getTmrGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getTmrGateControlOfChannels(obj) + + @staticmethod + def getTmrGatePolarities(obj): + dll.TCntrFeatures_getTmrGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getTmrGatePolarities(obj) + + @staticmethod + def getTmrOutSignals(obj): + dll.TCntrFeatures_getTmrOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getTmrOutSignals(obj) + + @staticmethod + def getTmrFrequencyRange(obj, x): + dll.TCntrFeatures_getTmrFrequencyRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getTmrFrequencyRange(obj, byref(x)) + + # pulse width measurement features + @staticmethod + def getPiCascadeGroup(obj): + dll.TCntrFeatures_getPiCascadeGroup.argtypes = [c_uint64] + dll.TCntrFeatures_getPiCascadeGroup.restype = c_uint64 + return dll.TCntrFeatures_getPiCascadeGroup(obj) + + # pulse width modulation features + @staticmethod + def getPoGateControlOfChannels(obj): + dll.TCntrFeatures_getPoGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getPoGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getPoGateControlOfChannels(obj) + + @staticmethod + def getPoGatePolarities(obj): + dll.TCntrFeatures_getPoGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getPoGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getPoGatePolarities(obj) + + @staticmethod + def getPoOutSignals(obj): + dll.TCntrFeatures_getPoOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getPoOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getPoOutSignals(obj) + + @staticmethod + def getPoHiPeriodRange(obj, x): + dll.TCntrFeatures_getPoHiPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoHiPeriodRange(obj, byref(x)) + + @staticmethod + def getPoLoPeriodRange(obj, x): + dll.TCntrFeatures_getPoLoPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoLoPeriodRange(obj, byref(x)) + + @staticmethod + def getPoOutCountRange(obj, x): + dll.TCntrFeatures_getPoOutCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoOutCountRange(obj, byref(x)) + + # Up-down counter features + @staticmethod + def getUdCountingTypes(obj): + dll.TCntrFeatures_getUdCountingTypes.argtypes = [c_uint64] + dll.TCntrFeatures_getUdCountingTypes.restype = c_uint64 + return dll.TCntrFeatures_getUdCountingTypes(obj) + + @staticmethod + def getUdInitialValues(obj): + dll.TCntrFeatures_getUdInitialValues.argtypes = [c_uint64] + dll.TCntrFeatures_getUdInitialValues.restype = c_uint64 + return dll.TCntrFeatures_getUdInitialValues(obj) + + @staticmethod + def getUdSnapEventSources(obj): + dll.TCntrFeatures_getUdSnapEventSources.argtypes = [c_uint64] + dll.TCntrFeatures_getUdSnapEventSources.restype = c_uint64 + return dll.TCntrFeatures_getUdSnapEventSources(obj) + + # new: measurement timeout range + @staticmethod + def getMeasurementTimeoutRange(obj, x): + dll.TCntrFeatures_getMeasurementTimeoutRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getMeasurementTimeoutRange(obj, byref(x)) + + @staticmethod + def getUdValueResetTimes(obj, x): + dll.TCntrFeatures_getUdValueResetTimes.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getUdValueResetTimes(obj, byref(x)) + + # Counter continue comparing: outputting pulse settings + @staticmethod + def getCcpGateControlOfChannels(obj): + dll.TCntrFeatures_getCcpGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getCcpGateControlOfChannels(obj) + + @staticmethod + def getCcpGatePolarities(obj): + dll.TCntrFeatures_getCcpGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getCcpGatePolarities(obj) + + @staticmethod + def getCcpOutSignals(obj): + dll.TCntrFeatures_getCcpOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getCcpOutSignals(obj) + + @staticmethod + def getCcpHiPeriodRange(obj, x): + dll.TCntrFeatures_getCcpHiPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpHiPeriodRange(obj, byref(x)) + + @staticmethod + def getCcpLoPeriodRange(obj, x): + dll.TCntrFeatures_getCcpLoPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpLoPeriodRange(obj, byref(x)) + + @staticmethod + def getCcpOutCountRange(obj, x): + dll.TCntrFeatures_getCcpOutCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpOutCountRange(obj, byref(x)) + + +class TCntrCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TCntrCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TCntrCtrlBase_getFeatures.restype = c_uint64 + return dll.TCntrCtrlBase_getFeatures(obj) + + @staticmethod + def getChannelStart(obj): + dll.TCntrCtrlBase_getChannelStart.restype = c_int32 + dll.TCntrCtrlBase_getChannelStart.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TCntrCtrlBase_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TCntrCtrlBase_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TCntrCtrlBase_getChannelCount.restype = c_int32 + dll.TCntrCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TCntrCtrlBase_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TCntrCtrlBase_setChannelCount(obj, value) + + @staticmethod + def getEnabled(obj): + dll.TCntrCtrlBase_getEnabled.restype = c_int8 + dll.TCntrCtrlBase_getEnabled.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getEnabled(obj) + + @staticmethod + def setEnabled(obj, value): + dll.TCntrCtrlBase_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TCntrCtrlBase_setEnabled(obj, value) + + @staticmethod + def getRunning(obj): + dll.TCntrCtrlBase_getRunning.restype = c_int8 + dll.TCntrCtrlBase_getRunning.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getRunning(obj) + + @staticmethod + def getNoiseFilterBlockTime(obj): + dll.TCntrCtrlBase_getNoiseFilterBlockTime.restype = c_double + dll.TCntrCtrlBase_getNoiseFilterBlockTime.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getNoiseFilterBlockTime(obj) + + @staticmethod + def setNoiseFilterBlockTime(obj, value): + dll.TCntrCtrlBase_setNoiseFilterBlockTime.argtypes = [c_uint64, c_double] + return dll.TCntrCtrlBase_setNoiseFilterBlockTime(obj, c_double(value)) + + @staticmethod + def getNoiseFilter(obj): + dll.TCntrCtrlBase_getNoiseFilter.argtypes = [c_uint64] + dll.TCntrCtrlBase_getNoiseFilter.restype = c_uint64 + return dll.TCntrCtrlBase_getNoiseFilter(obj) + + @staticmethod + def getMeasurementTimeout(obj): + dll.TCntrCtrlBase_getMeasurementTimeout.restype = c_double + dll.TCntrCtrlBase_getMeasurementTimeout.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getMeasurementTimeout(obj) + + @staticmethod + def setMeasurementTimeout(obj, value): + dll.TCntrCtrlBase_setMeasurementTimeout.argtypes = [c_uint64, c_double] + return dll.TCntrCtrlBase_setMeasurementTimeout(obj, c_double(value)) + + +class TEcChannel(object): + @staticmethod + def getChannel(obj): + dll.TEcChannel_getChannel.restype = c_int32 + dll.TEcChannel_getChannel.argtypes = [c_uint64] + return dll.TEcChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TEcChannel_getNoiseFiltered.restype = c_int8 + dll.TEcChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TEcChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TEcChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TEcChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getClockSource(obj): + dll.TEcChannel_getClockSource.argtypes = [c_uint64] + return dll.TEcChannel_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TEcChannel_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setClockSource(obj, value) + + @staticmethod + def getClockPolarity(obj): + dll.TEcChannel_getClockPolarity.argtypes = [c_uint64] + return dll.TEcChannel_getClockPolarity(obj) + + @staticmethod + def setClockPolarity(obj, value): + dll.TEcChannel_setClockPolarity.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setClockPolarity(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TEcChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TEcChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TEcChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setGatePolarity(obj, value) + + @staticmethod + def getGated(obj): + dll.TEcChannel_getGated.restype = c_int8 + dll.TEcChannel_getGated.argtypes = [c_uint64] + return dll.TEcChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TEcChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TEcChannel_setGated(obj, value) + + +class TEventCounterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TEventCounterCtrl_getChannels.argtypes = [c_uint64] + dll.TEventCounterCtrl_getChannels.restype = c_uint64 + return dll.TEventCounterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TEventCounterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_int32)] + return dll.TEventCounterCtrl_Read(obj, count, buffer) + + +class TFmChannel(object): + @staticmethod + def getChannel(obj): + dll.TFmChannel_getChannel.restype = c_int32 + dll.TFmChannel_getChannel.argtypes = [c_uint64] + return dll.TFmChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TFmChannel_getNoiseFiltered.restype = c_int8 + dll.TFmChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TFmChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TFmChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TFmChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getFmMethod(obj): + dll.TFmChannel_getFmMethod.argtypes = [c_uint64] + return dll.TFmChannel_getFmMethod(obj) + + @staticmethod + def setFmMethod(obj, value): + dll.TFmChannel_setFmMethod.argtypes = [c_uint64, c_int32] + return dll.TFmChannel_setFmMethod(obj, value) + + @staticmethod + def getCollectionPeriod(obj): + dll.TFmChannel_getCollectionPeriod.restype = c_double + dll.TFmChannel_getCollectionPeriod.argtypes = [c_uint64] + return dll.TFmChannel_getCollectionPeriod(obj) + + @staticmethod + def setCollectionPeriod(obj, value): + dll.TFmChannel_setCollectionPeriod.argtypes = [c_uint64, c_double] + return dll.TFmChannel_setCollectionPeriod(obj, c_double(value)) + + +class TFreqMeterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TFreqMeterCtrl_getChannels.argtypes = [c_uint64] + dll.TFreqMeterCtrl_getChannels.restype = c_uint64 + return dll.TFreqMeterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, data): + dll.TFreqMeterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_double)] + return dll.TFreqMeterCtrl_Read(obj, count, data) + + +class TPiChannel(object): + @staticmethod + def getChannel(obj): + dll.TPiChannel_getChannel.restype = c_int32 + dll.TPiChannel_getChannel.argtypes = [c_uint64] + return dll.TPiChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TPiChannel_getNoiseFiltered.restype = c_int8 + dll.TPiChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TPiChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TPiChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TPiChannel_setNoiseFiltered(obj, value) + + +class TPwMeterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TPwMeterCtrl_getChannels.argtypes = [c_uint64] + dll.TPwMeterCtrl_getChannels.restype = c_uint64 + return dll.TPwMeterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TPwMeterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(PulseWidth)] + return dll.TPwMeterCtrl_Read(obj, count, buffer) + + +class TPoChannel(object): + @staticmethod + def getChannel(obj): + dll.TPoChannel_getChannel.restype = c_int32 + dll.TPoChannel_getChannel.argtypes = [c_uint64] + return dll.TPoChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TPoChannel_getNoiseFiltered.restype = c_int8 + dll.TPoChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TPoChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TPoChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TPoChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getPulseWidth(obj, pulseWidth): + dll.TPoChannel_getPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TPoChannel_getPulseWidth(obj, byref(pulseWidth)) + + @staticmethod + def setPulseWidth(obj, pulseWidthValue): + dll.TPoChannel_setPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TPoChannel_setPulseWidth(obj, byref(pulseWidthValue)) + + @staticmethod + def getGatePolarity(obj): + dll.TPoChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TPoChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, signPolarValue): + dll.TPoChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setGatePolarity(obj, signPolarValue) + + @staticmethod + def getGated(obj): + dll.TPoChannel_getGated.restupe = c_int8 + dll.TPoChannel_getGated.argtypes = [c_uint64] + return dll.TPoChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TPoChannel_setGated.argtypes = [c_uint64] + return dll.TPoChannel_setGated(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TPoChannel_getOutSignal.argtypes = [c_uint64] + return dll.TPoChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, outSignTypeValue): + dll.TPoChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setOutSignal(obj, outSignTypeValue) + + @staticmethod + def getOutCount(obj): + dll.TPoChannel_getOutCount.restype = c_int32 + dll.TPoChannel_getOutCount.argtypes = [c_uint64] + return dll.TPoChannel_getOutCount(obj) + + @staticmethod + def setOutCount(obj, value): + dll.TPoChannel_setOutCount.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setOutCount(obj, value) + + +class TPwModulatorCtrl(object): + @staticmethod + def getChannels(obj): + dll.TPwModulatorCtrl_getChannels.argtypes = [c_uint64] + dll.TPwModulatorCtrl_getChannels.restype = c_uint64 + return dll.TPwModulatorCtrl_getChannels(obj) + +class TOsChannel(object): + @staticmethod + def getChannel(obj): + dll.TOsChannel_getChannel.restype = c_int32 + dll.TOsChannel_getChannel.argtypes = [c_uint64] + return dll.TOsChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TOsChannel_getNoiseFiltered.restype = c_int8 + dll.TOsChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TOsChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TOsChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TOsChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getDelayCount(obj): + dll.TOsChannel_getDelayCount.restype = c_int32 + dll.TOsChannel_getDelayCount.argtypes = [c_uint64] + return dll.TOsChannel_getDelayCount(obj) + + @staticmethod + def setDelayCount(obj, value): + dll.TOsChannel_setDelayCount.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setDelayCount(obj, value) + + @staticmethod + def getClockSource(obj): + dll.TOsChannel_getClockSource.argtypes = [c_uint64] + return dll.TOsChannel_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TOsChannel_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setClockSource(obj, value) + + @staticmethod + def getClockPolarity(obj): + dll.TOsChannel_getClockPolarity.argtypes = [c_uint64] + return dll.TOsChannel_getClockPolarity(obj) + + @staticmethod + def setClockPolarity(obj, value): + dll.TOsChannel_setClockPolarity.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setClockPolarity(obj, value) + + @staticmethod + def getGateSource(obj): + dll.TOsChannel_getGateSource.argtypes = [c_uint64] + return dll.TOsChannel_getGateSource(obj) + + @staticmethod + def setGateSource(obj, value): + dll.TOsChannel_setGateSource.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setGateSource(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TOsChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TOsChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TOsChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setGatePolarity(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TOsChannel_getOutSignal.argtypes = [c_uint64] + return dll.TOsChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TOsChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setOutSignal(obj, value) + + +class TOneShotCtrl(object): + @staticmethod + def getChannels(obj): + dll.TOneShotCtrl_getChannels.argtypes = [c_uint64] + dll.TOneShotCtrl_getChannels.restype = c_uint64 + return dll.TOneShotCtrl_getChannels(obj) + + +class TTmrChannel(object): + @staticmethod + def getChannel(obj): + dll.TTmrChannel_getChannel.restype = c_int32 + dll.TTmrChannel_getChannel.argtypes = [c_uint64] + return dll.TTmrChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TTmrChannel_getNoiseFiltered.restype = c_int8 + dll.TTmrChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TTmrChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TTmrChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TTmrChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getFrequency(obj): + dll.TTmrChannel_getFrequency.restype = c_double + dll.TTmrChannel_getFrequency.argtypes = [c_uint64] + return dll.TTmrChannel_getFrequency(obj) + + @staticmethod + def setFrequency(obj, value): + dll.TTmrChannel_setFrequency.argtypes = [c_uint64, c_double] + return dll.TTmrChannel_setFrequency(obj, c_double(value)) + + @staticmethod + def getGatePolarity(obj): + dll.TTmrChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TTmrChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TTmrChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TTmrChannel_setGatePolarity(obj, value) + + @staticmethod + def getGated(obj): + dll.TTmrChannel_getGated.restype = c_int8 + dll.TTmrChannel_getGated.argtypes = [c_uint64] + return dll.TTmrChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TTmrChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TTmrChannel_setGated(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TTmrChannel_getOutSignal.argtypes = [c_uint64] + return dll.TTmrChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TTmrChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TTmrChannel_setOutSignal(obj, value) + + +class TTimerPulseCtrl(object): + @staticmethod + def getChannels(obj): + dll.TTimerPulseCtrl_getChannels.argtypes = [c_uint64] + dll.TTimerPulseCtrl_getChannels.restype = c_uint64 + return dll.TTimerPulseCtrl_getChannels(obj) + + +class TUdChannel(object): + @staticmethod + def getChannel(obj): + dll.TUdChannel_getChannel.restype = c_int32 + dll.TUdChannel_getChannel.argtypes = [c_uint64] + return dll.TUdChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TUdChannel_getNoiseFiltered.restype = c_int8 + dll.TUdChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TUdChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TUdChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TUdChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getCountingType(obj): + dll.TUdChannel_getCountingType.argtypes = [c_uint64] + return dll.TUdChannel_getCountingType(obj) + + @staticmethod + def setCountingType(obj, value): + dll.TUdChannel_setCountingType.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setCountingType(obj, value) + + @staticmethod + def getInitialValue(obj): + dll.TUdChannel_getInitialValue.restype = c_int32 + dll.TUdChannel_getInitialValue.argtypes = [c_uint64] + return dll.TUdChannel_getInitialValue(obj) + + @staticmethod + def setInitialValue(obj, value): + dll.TUdChannel_setInitialValue.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setInitialValue(obj, value) + + @staticmethod + def getResetTimesByIndex(obj): + dll.TUdChannel_getResetTimesByIndex.restype = c_int32 + dll.TUdChannel_getResetTimesByIndex.argtypes = [c_uint64] + return dll.TUdChannel_getResetTimesByIndex(obj) + + @staticmethod + def setResetTimesByIndex(obj, value): + dll.TUdChannel_setResetTimesByIndex.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setResetTimesByIndex(obj, value) + + @staticmethod + def getPulseWidth(obj, width): + dll.TUdChannel_getPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TUdChannel_getPulseWidth(obj, byref(width)) + + @staticmethod + def setPulseWidth(obj, width): + dll.TUdChannel_setPulseWidth.restype = c_uint32 + dll.TUdChannel_setPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TUdChannel_setPulseWidth(obj, byref(width)) + + @staticmethod + def getGated(obj): + dll.TUdChannel_getGated.restype = c_int8 + dll.TUdChannel_getGated.argtypes = [c_uint64] + return dll.TUdChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TUdChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TUdChannel_setGated(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TUdChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TUdChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TUdChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setGatePolarity(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TUdChannel_getOutSignal.argtypes = [c_uint64] + return dll.TUdChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TUdChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setOutSignal(obj, value) + + @staticmethod + def getOutCount(obj): + dll.TUdChannel_getOutCount.restype = c_int32 + dll.TUdChannel_getOutCount.argtypes = [c_uint64] + return dll.TUdChannel_getOutCount(obj) + + @staticmethod + def setOutCount(obj, value): + dll.TUdChannel_setOutCount.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setOutCount(obj, value) + + +class TUdCounterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TUdCounterCtrl_getChannels.argtypes = [c_uint64] + dll.TUdCounterCtrl_getChannels.restype = c_uint64 + return dll.TUdCounterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TUdCounterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_int32)] + return dll.TUdCounterCtrl_Read(obj, count, buffer) + + @staticmethod + def ValueReset(obj): + dll.TUdCounterCtrl_ValueReset.argtypes = [c_uint64] + return dll.TUdCounterCtrl_ValueReset(obj) + + + + + + diff --git a/src/components/Automation/BDaq/BufferedAoCtrl.py b/src/components/Automation/BDaq/BufferedAoCtrl.py new file mode 100644 index 0000000..b623ae1 --- /dev/null +++ b/src/components/Automation/BDaq/BufferedAoCtrl.py @@ -0,0 +1,84 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq.AoCtrlBase import AoCtrlBase +from Automation.BDaq import Scenario, ErrorCode, MAX_TRIG_COUNT +from Automation.BDaq.ScanChannel import ScanChannel +from Automation.BDaq.ConvertClock import ConvertClock +from Automation.BDaq.BDaqApi import TBufferedAoCtrl, BioFailed +from Automation.BDaq.Trigger import Trigger + + +class BufferedAoCtrl(AoCtrlBase): + def __init__(self, devInfo = None): + super(BufferedAoCtrl, self).__init__(Scenario.SceBufferedAo, devInfo) + self._scanChannObj = None + self._cnvtClockObj = None + self._triggers = [] + + # property + @property + def scanChannel(self): + if self._scanChannObj is None: + self._scanChannObj = ScanChannel(TBufferedAoCtrl.getScanChannel(self._obj)) + return self._scanChannObj + + @property + def convertClock(self): + if self._cnvtClockObj is None: + self._cnvtClockObj = ConvertClock(TBufferedAoCtrl.getConvertClock(self._obj)) + return self._cnvtClockObj + + @property + def streaming(self): + if self.features.bufferedAoSupported: + return TBufferedAoCtrl.getStreaming(self._obj) + + @streaming.setter + def streaming(self, value): + if self.features.bufferedAoSupported: + ret = ErrorCode.lookup(TBufferedAoCtrl.setStreaming(self._obj, value)) + if BioFailed(ret): + raise ValueError('set streaming is failed, the error code is 0x%X' % (ret.value)) + + @property + def trigger(self): + if not self._triggers: + self._triggers = [None] * MAX_TRIG_COUNT + + for i in range(self.features.triggerCount): + self._triggers[i] = Trigger(TBufferedAoCtrl.getTrigger(self._obj, i)) + return self._triggers + + # method + def prepare(self): + return ErrorCode.lookup(TBufferedAoCtrl.Prepare(self._obj)) + + def runOnce(self): + return ErrorCode.lookup(TBufferedAoCtrl.RunOnce(self._obj)) + + def start(self): + return ErrorCode.lookup(TBufferedAoCtrl.Start(self._obj)) + + def stop(self, value): + return ErrorCode.lookup(TBufferedAoCtrl.Stop(self._obj, value)) + + def setDataF64(self, count, scaledData): + doubleArray = (c_double * count)() + for i in range(count): + doubleArray[i] = scaledData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 8, count, doubleArray)) + + def setDataI32(self, count, rawData): + intArray = (c_int32 * count)() + for i in range(count): + intArray[i] = rawData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 4, count, intArray)) + + def setDatai16(self, count, rawData): + shortArray = (c_int16 * count)() + for i in range(count): + shortArray[i] = rawData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 2, count, shortArray)) diff --git a/src/components/Automation/BDaq/CjcSetting.py b/src/components/Automation/BDaq/CjcSetting.py new file mode 100644 index 0000000..fc1404b --- /dev/null +++ b/src/components/Automation/BDaq/CjcSetting.py @@ -0,0 +1,48 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TCjcSetting, BioFailed +from Automation.BDaq import ErrorCode + + +class CjcSetting(object): + def __init__(self, nativeCjcSetting): + self._cjcObj = nativeCjcSetting + + @property + def channel(self): + return TCjcSetting.getChannel(self._cjcObj) + + @channel.setter + def channel(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCjcSetting.setChannel(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set channel is failed, the error code is 0x%X' % (ret.value)) + + @property + def value(self): + return TCjcSetting.getValue(self._cjcObj) + + @value.setter + def value(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCjcSetting.setValue(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set value is failed, the error code is 0x%X' % (ret.value)) + + @property + def updateFrequency(self): + return TCjcSetting.getUpdateFreq(self._cjcObj) + + @updateFrequency.setter + def updateFrequency(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCjcSetting.setUpdateFreq(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set updateFrequency is failed, the error code is 0x%X' % (ret.value)) + diff --git a/src/components/Automation/BDaq/CntrCtrlBase.py b/src/components/Automation/BDaq/CntrCtrlBase.py new file mode 100644 index 0000000..5758ff6 --- /dev/null +++ b/src/components/Automation/BDaq/CntrCtrlBase.py @@ -0,0 +1,95 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.CntrFeatures import CntrFeatures +from Automation.BDaq.BDaqApi import TCntrCtrlBase, BioFailed +from Automation.BDaq.NosFltChannel import NosFltChannel +from Automation.BDaq import ErrorCode + + +class CntrCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(CntrCtrlBase, self).__init__(scenario, devInfo) + self._cntr_features = None + + @property + def features(self): + if self._cntr_features is None: + self._cntr_features = CntrFeatures(TCntrCtrlBase.getFeatures(self._obj)) + return self._cntr_features + + @property + def channelStart(self): + return TCntrCtrlBase.getChannelStart(self._obj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setChannelStart(self._obj, value)) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TCntrCtrlBase.getChannelCount(self._obj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setChannelCount(self._obj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def enabled(self): + value = TCntrCtrlBase.getEnabled(self._obj) + return value != 0 + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + # value = 1 if value else 0 + ret = ErrorCode.lookup(TCntrCtrlBase.setEnabled(self._obj, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) + + @property + def running(self): + value = TCntrCtrlBase.getRunning(self._obj) + return True if value else False + + @property + def noiseFilterBlockTime(self): + return TCntrCtrlBase.getNoiseFilterBlockTime(self._obj) + + @noiseFilterBlockTime.setter + def noiseFilterBlockTime(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setNoiseFilterBlockTime(self._obj, value)) + if BioFailed(ret): + raise ValueError('set noiseFilterBlockTime is failed, the error code is 0x%X' % (ret.value)) + + @property + def noiseFilter(self): + if not self.features.noiseFilterSupported: + return None + nativeObj = TCntrCtrlBase.getNoiseFilter(self._obj) + return NosFltChannel(nativeObj) + + @property + def measurementTimeout(self): + return TCntrCtrlBase.getMeasurementTimeout(self._obj) + + @measurementTimeout.setter + def measurementTimeout(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setMeasurementTimeout(self._obj, value)) + if BioFailed(ret): + raise ValueError('set measurementTimeout is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/CntrFeatures.py b/src/components/Automation/BDaq/CntrFeatures.py new file mode 100644 index 0000000..71def47 --- /dev/null +++ b/src/components/Automation/BDaq/CntrFeatures.py @@ -0,0 +1,231 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TCntrFeatures, TArray +from Automation.BDaq.CounterCapabilityIndexer import CounterCapabilityIndexer +from Automation.BDaq.CounterClockSourceIndexer import CounterClockSourceIndexer +from Automation.BDaq.CounterGateSourceIndexer import CounterGateSourceIndexer +from Automation.BDaq import MathInterval + + +class CntrFeatures(object): + def __init__(self, native_cntr_features): + self._native_cntr_features = native_cntr_features + + # Channel features + @property + def channelCountMax(self): + return TCntrFeatures.getChannelCountMax(self._native_cntr_features) + + @property + def resolution(self): + return TCntrFeatures.getResolution(self._native_cntr_features) + + @property + def dataSize(self): + return TCntrFeatures.getDataSize(self._native_cntr_features) + + @property + def capabilities(self): + return CounterCapabilityIndexer(TCntrFeatures.getCapabilities(self._native_cntr_features)) + + # noise filter features + @property + def noiseFilterSupported(self): + value = TCntrFeatures.getNoiseFilterSupported(self._native_cntr_features) + return True if value else False + + @property + def noiseFilterOfChannels(self): + nativeArray = TCntrFeatures.getNoiseFilterOfChannels(self._native_cntr_features) + return TArray.ToByte(nativeArray, True) + + @property + def noiseFilterBlockTimeRange(self): + x = MathInterval() + TCntrFeatures.getNoiseFilterBlockTimeRange(self._native_cntr_features, x) + return x + + # event counting features + @property + def ecClockSources(self): + clockObj = TCntrFeatures.getEcClockSources(self._native_cntr_features) + return CounterClockSourceIndexer(clockObj) + + @property + def ecClockPolarities(self): + nativeArray = TCntrFeatures.getEcClockPolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ecGatePolarities(self): + nativeArray = TCntrFeatures.getEcGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ecGateControlOfChannels(self): + nativeArray = TCntrFeatures.getEcGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + # frequency measurement features + @property + def fmMethods(self): + nativeArray = TCntrFeatures.getFmMethods(self._native_cntr_features) + return TArray.ToFreqMeasureMethod(nativeArray, True) + + # one-shot features + @property + def osClockSources(self): + clockObj = TCntrFeatures.getOsClockSources(self._native_cntr_features) + return CounterClockSourceIndexer(clockObj) + + @property + def osClockPolarities(self): + nativeArray = TCntrFeatures.getOsClockPolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def osGateSources(self): + clockObj = TCntrFeatures.getOsGateSources(self._native_cntr_features) + return CounterGateSourceIndexer(clockObj) + + @property + def osGatePolarities(self): + nativeArray = TCntrFeatures.getOsGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def osOutSignals(self): + nativeArray = TCntrFeatures.getOsOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def osDelayCountRange(self): + x = MathInterval() + TCntrFeatures.getOsDelayCountRange(self._native_cntr_features, x) + return x + + # Timer/pulse features + @property + def tmrGateControlOfChannels(self): + nativeArray = TCntrFeatures.getTmrGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def tmrGatePolarities(self): + nativeArray = TCntrFeatures.getTmrGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def tmrOutSignals(self): + nativeArray = TCntrFeatures.getTmrOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def tmrFrequencyRange(self): + x = MathInterval() + TCntrFeatures.getTmrFrequencyRange(self._native_cntr_features, x) + return x + + # pulse width measurement features + @property + def piCascadeGroup(self): + nativeArray = TCntrFeatures.getPiCascadeGroup(self._native_cntr_features) + return TArray.ToCounterCascadeGroup(nativeArray, True) + + # pulse width modulation features + @property + def poGateControlOfChannels(self): + nativeArray = TCntrFeatures.getPoGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def poGatePolarities(self): + nativeArray = TCntrFeatures.getPoGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def poOutSignals(self): + nativeArray = TCntrFeatures.getPoOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def poHiPeriodRange(self): + x = MathInterval() + TCntrFeatures.getPoHiPeriodRange(self._native_cntr_features, x) + return x + + @property + def poLoPeriodRange(self): + x = MathInterval() + TCntrFeatures.getPoLoPeriodRange(self._native_cntr_features, x) + return x + + @property + def poOutCountRange(self): + x = MathInterval() + TCntrFeatures.getPoOutCountRange(self._native_cntr_features, x) + return x + + # Up-down counter features + @property + def udCountingTypes(self): + nativeArray = TCntrFeatures.getUdCountingTypes(self._native_cntr_features) + return TArray.ToCountingType(nativeArray, True) + + @property + def udInitialValues(self): + nativeArray = TCntrFeatures.getUdInitialValues(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def udSnapEventSources(self): + nativeArray = TCntrFeatures.getUdSnapEventSources(self._native_cntr_features) + return TArray.ToEventId(nativeArray, True) + + # new: measurement timeout range + @property + def measurementTimeoutRange(self): + x = MathInterval() + TCntrFeatures.getMeasurementTimeoutRange(self._native_cntr_features, x) + return x + + @property + def udValueResetTimes(self): + x = MathInterval() + TCntrFeatures.getUdValueResetTimes(self._native_cntr_features, x) + return x + + # Counter continue comparing: outputting pulse settings + @property + def ccpGateControlOfChannels(self): + nativeArray = TCntrFeatures.getCcpGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def ccpGatePolarities(self): + nativeArray = TCntrFeatures.getCcpGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ccpOutSignals(self): + nativeArray = TCntrFeatures.getCcpOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def ccpHiPeriodRange(self): + x = MathInterval() + TCntrFeatures.getCcpHiPeriodRange(self._native_cntr_features, x) + return x + + @property + def ccpLoPeriodRange(self): + x = MathInterval() + TCntrFeatures.getCcpLoPeriodRange(self._native_cntr_features, x) + return x + + @property + def ccpOutCountRange(self): + x = MathInterval() + TCntrFeatures.getCcpOutCountRange(self._native_cntr_features, x) + return x diff --git a/src/components/Automation/BDaq/Conversion.py b/src/components/Automation/BDaq/Conversion.py new file mode 100644 index 0000000..72f463e --- /dev/null +++ b/src/components/Automation/BDaq/Conversion.py @@ -0,0 +1,83 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_byte +from Automation.BDaq.BDaqApi import TConversion, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, SignalDrop + + +class Conversion(object): + def __init__(self, nativeConvObj, chanCount): + self._nativeConvObj = nativeConvObj + self._chanCount = chanCount + + @property + def clockSource(self): + ret = TConversion.getClockSource(self._nativeConvObj) + return Utils.toSignalDrop(ret) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TConversion.setClockSource(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockRate(self): + return TConversion.getClockRate(self._nativeConvObj) + + @clockRate.setter + def clockRate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TConversion.setClockRate(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set clockRate is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelStart(self): + return TConversion.getChannelStart(self._nativeConvObj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TConversion.setChannelStart(self._nativeConvObj, int(value))) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TConversion.getChannelCount(self._nativeConvObj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TConversion.setChannelCount(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelMap(self): + data = [] + dataArr = (c_byte * self._chanCount)() + TConversion.getChannelMap(self._nativeConvObj, self._chanCount, dataArr) + for i in range(self._chanCount): + data.append(dataArr[i]) + return data + + @channelMap.setter + def channelMap(self, value): + if not isinstance(value, list): + raise TypeError('a list is required') + dataLen = len(value) + dataArr = (c_byte * dataLen)() + for i, data in enumerate(value): + dataArr[i] = data + ret = ErrorCode.lookup(TConversion.setChannelMap(self._nativeConvObj, dataLen, dataArr)) + if BioFailed(ret): + raise ValueError('set channelMap is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/ConvertClock.py b/src/components/Automation/BDaq/ConvertClock.py new file mode 100644 index 0000000..17abba6 --- /dev/null +++ b/src/components/Automation/BDaq/ConvertClock.py @@ -0,0 +1,36 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TConvertClock, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, SignalDrop + + +class ConvertClock(object): + def __init__(self, nativeCnrtClkObj): + self._nativeCnrtClkObj = nativeCnrtClkObj + + @property + def source(self): + ret = TConvertClock.getSource(self._nativeCnrtClkObj) + return Utils.toSignalDrop(ret) + + @source.setter + def source(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TConvertClock.setSource(self._nativeCnrtClkObj, value)) + if BioFailed(ret): + raise ValueError('set source is failed, the error code is 0x%X' % (ret.value)) + + @property + def rate(self): + return TConvertClock.getRate(self._nativeCnrtClkObj) + + @rate.setter + def rate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TConvertClock.setRate(self._nativeCnrtClkObj, value)) + if BioFailed(ret): + raise ValueError('set rate is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/CounterCapabilityIndexer.py b/src/components/Automation/BDaq/CounterCapabilityIndexer.py new file mode 100644 index 0000000..8cd3852 --- /dev/null +++ b/src/components/Automation/BDaq/CounterCapabilityIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import CounterCapability +from Automation.BDaq import Utils + + +class CounterCapabilityIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterCapabilityIndexer, self).__init__(nativeIndexer, CounterCapability, Utils.toCounterCapability) diff --git a/src/components/Automation/BDaq/CounterClockSourceIndexer.py b/src/components/Automation/BDaq/CounterClockSourceIndexer.py new file mode 100644 index 0000000..2863285 --- /dev/null +++ b/src/components/Automation/BDaq/CounterClockSourceIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import SignalDrop +from Automation.BDaq import Utils + + +class CounterClockSourceIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterClockSourceIndexer, self).__init__(nativeIndexer, SignalDrop, Utils.toSignalDrop) diff --git a/src/components/Automation/BDaq/CounterGateSourceIndexer.py b/src/components/Automation/BDaq/CounterGateSourceIndexer.py new file mode 100644 index 0000000..eb6e44d --- /dev/null +++ b/src/components/Automation/BDaq/CounterGateSourceIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import SignalDrop +from Automation.BDaq import Utils + + +class CounterGateSourceIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterGateSourceIndexer, self).__init__(nativeIndexer, SignalDrop, Utils.toSignalDrop) diff --git a/src/components/Automation/BDaq/CounterIndexer.py b/src/components/Automation/BDaq/CounterIndexer.py new file mode 100644 index 0000000..382c84a --- /dev/null +++ b/src/components/Automation/BDaq/CounterIndexer.py @@ -0,0 +1,19 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TCounterIndexer, TArray + + +class CounterIndexer(object): + def __init__(self, nativeIndex, clazz, convert): + self._nativeIndex = nativeIndex + self._clazz = clazz + self._convert = convert + + @property + def length(self): + return TCounterIndexer.getLength(self._nativeIndex) + + def getItem(self, channel): + nativeArray = TCounterIndexer.getItem(self._nativeIndex, channel) + return TArray.ToEnum(nativeArray, True, self._clazz, self._convert) diff --git a/src/components/Automation/BDaq/DaqCtrlBase.py b/src/components/Automation/BDaq/DaqCtrlBase.py new file mode 100644 index 0000000..6b42915 --- /dev/null +++ b/src/components/Automation/BDaq/DaqCtrlBase.py @@ -0,0 +1,86 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import ErrorCode +from Automation.BDaq.BDaqApi import TDaqCtrlBase, TArray, BioFailed +from Automation.BDaq import DeviceInformation, ControlState +from Automation.BDaq.DeviceCtrl import DeviceCtrl +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode + + +class DaqCtrlBase(object): + def __init__(self, scenario, devInfo): + self._deviceCtrl = None + self._obj = self.create(scenario) + + if devInfo is not None: + self.selectedDevice = devInfo + + @property + def initialized(self): + return self.state != ControlState.Uninited + + def cleanup(self): + TDaqCtrlBase.cleanup(self._obj) + + def dispose(self): + TDaqCtrlBase.dispose(self._obj) + + @property + def selectedDevice(self): + devInfo = DeviceInformation() + TDaqCtrlBase.getSelectedDevice(self._obj, devInfo) + return devInfo + + @selectedDevice.setter + def selectedDevice(self, devInfo): + if not isinstance(devInfo, (DeviceInformation, int, str)): + raise TypeError('The parameter value is not supported.') + + if isinstance(devInfo, str): + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, DeviceInformation(Description=devInfo))) + elif isinstance(devInfo, int): + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, DeviceInformation(Description=u'', DeviceNumber=devInfo))) + else: + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, devInfo)) + + if BioFailed(ret): + raise ValueError('The device is not opened, and the error code is 0x%X' % (ret.value)) + + @property + def state(self): + ret = TDaqCtrlBase.getState(self._obj) + return Utils.toControlState(ret) + + @property + def device(self): + if self._deviceCtrl is None: + self._deviceCtrl = DeviceCtrl(TDaqCtrlBase.getDevice(self._obj)) + return self._deviceCtrl + + @property + def supportedDevices(self): + nativeArray = TDaqCtrlBase.getSupportedDevices(self._obj) + deviceTreeNodeArr = TArray.toDeviceTreeNode(nativeArray) + return deviceTreeNodeArr + + @property + def supportedModes(self): + nativeArray = TDaqCtrlBase.getSupportedModes(self._obj) + accessModeList = TArray.toAccessMode(nativeArray) + return accessModeList + + @property + def module(self): + return TDaqCtrlBase.getModule(self._obj) + + def create(self, scenario): + return TDaqCtrlBase.Create(scenario.value) + + def __set_loadProfile(self, profile): + ret = ErrorCode.lookup(TDaqCtrlBase.LoadProfile(self._obj, profile)) + if BioFailed(ret): + raise ValueError('set loadProfile is failed, the error code is 0x%X' % (ret.value)) + + loadProfile = property(None, __set_loadProfile) diff --git a/src/components/Automation/BDaq/DeviceCtrl.py b/src/components/Automation/BDaq/DeviceCtrl.py new file mode 100644 index 0000000..75700d1 --- /dev/null +++ b/src/components/Automation/BDaq/DeviceCtrl.py @@ -0,0 +1,203 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int32, c_byte, c_uint8 +from ctypes import create_unicode_buffer +from ctypes import pointer + +from Automation.BDaq.BDaqApi import TArray, TerminalBoard +from Automation.BDaq.BDaqApi import TDeviceCtrl, BioFailed +from Automation.BDaq import ErrorCode +from Automation.BDaq import Utils + + +class DeviceCtrl(object): + def __init__(self, nativeDev): + self._nativeDev = nativeDev + + # method + def refresh(self): + return ErrorCode.lookup(TDeviceCtrl.Refresh(self._nativeDev)) + + def readRegister(self, space, offset, length): + dataArr = (c_byte * length)() + data = [] + ret = TDeviceCtrl.ReadRegister(self._nativeDev, space, offset, length, dataArr) + if not BioFailed(ret): + for i in range(length): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def writeRegister(self, space, offset, length, data): + if not isinstance(data, list): + raise TypeError('a list is required') + if length != len(data): + raise ValueError('Length mismatch: length:%d, len(data):%d' % (length, len(data))) + dataArr = (c_byte * length)() + for i in range(length): + dataArr[i] = data[i] + ret = TDeviceCtrl.WriteRegister(self._nativeDev, space, offset, length, dataArr) + return ErrorCode.lookup(ret) + + def readPrivateRegion(self, signature, length): + dataArr = (c_uint8 * length)() + data = [] + + ret = TDeviceCtrl.ReadPrivateRegion(self._nativeDev, signature, length, dataArr) + if not BioFailed(ret): + for i in range(length): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def writePrivateRegion(self, signature, length, data): + if not isinstance(data, list): + raise TypeError('a list is required') + + if length != len(data): + raise ValueError('Length mismatch: length:%d, len(data):%d' % (length, len(data))) + + dataArr = (c_uint8 * length)() + for i in range(length): + dataArr[i] = data[i] + + ret = TDeviceCtrl.WritePrivateRegion(self._nativeDev, signature, length, dataArr) + return ErrorCode.lookup(ret) + + def synchronizeTimeBase(self): + return ErrorCode.lookup(TDeviceCtrl.SynchronizeTimebase(self._nativeDev)) + + def calculateAbsoluteTime(self, relativeTime): + if not isinstance(relativeTime, float): + raise TypeError('a float is required') + return TDeviceCtrl.CalculateAbsoluteTime(self._nativeDev, relativeTime) + + # properties + @property + def deviceNumber(self): + return TDeviceCtrl.getDeviceNumber(self._nativeDev) + + @property + def description(self): + descr = create_unicode_buffer(256) + TDeviceCtrl.getDescription(self._nativeDev, 256, descr) + + return descr.value.encode() + + @description.setter + def description(self, desc): + ret = ErrorCode.lookup(TDeviceCtrl.setDescription(self._nativeDev, len(desc), desc)) + if BioFailed(ret): + raise ValueError('set description is failed, the error code is 0x%X' % (ret.value)) + + @property + def accessMode(self): + return Utils.toAccessMode(TDeviceCtrl.getAccessMode(self._nativeDev)) + + @property + def productId(self): + return Utils.toProductId(TDeviceCtrl.getProductId(self._nativeDev)) + + @property + def boardId(self): + return TDeviceCtrl.getBoardId(self._nativeDev) + + @boardId.setter + def boardId(self, value): + ret = ErrorCode.lookup(TDeviceCtrl.setBoardId(self._nativeDev, value)) + if BioFailed(ret): + raise ValueError('set boardId is failed, the error code is 0x%X' % (ret.value)) + + @property + def boardVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getBoardVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def driverVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getDriverVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def dllVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getDllVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def location(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getLocation(self._nativeDev, 256, version) + return version.value.encode() + + @property + def privateRegionLength(self): + return TDeviceCtrl.getPrivateRegionLength(self._nativeDev) + + @property + def hotResetPreventable(self): + return TDeviceCtrl.getHotResetPreventable(self._nativeDev) + + @property + def baseAddresses(self): + nativeArray = TDeviceCtrl.getBaseAddresses(self._nativeDev) + return TArray.ToInt64(nativeArray, True) + + @property + def interrupts(self): + nativeArray = TDeviceCtrl.getInterrupts(self._nativeDev) + return TArray.ToInt32(nativeArray, True) + + @property + def supportedTerminalBoard(self): + nativeArray = TDeviceCtrl.getSupportedTerminalBoard(self._nativeDev) + return TArray.ToTerminalBoard(nativeArray, True) + + @property + def supportedEvents(self): + nativeArray = TDeviceCtrl.getSupportedEvents(self._nativeDev) + return TArray.ToEventId(nativeArray, True) + + @property + def supportedScenarios(self): + return TDeviceCtrl.getSupportedScenarios(self._nativeDev) + + @property + def terminalBoard(self): + return Utils.toTerminalBoard(TDeviceCtrl.getTerminalBoard(self._nativeDev)) + + @terminalBoard.setter + def terminalBoard(self, value): + if not isinstance(value, TerminalBoard): + raise TypeError("a TerminalBoard is required") + ret = ErrorCode.lookup(TDeviceCtrl.setTerminalBoard(self._nativeDev, value)) + if BioFailed(ret): + raise ValueError('set terminalBoard is failed, the error code is 0x%X' % (ret.value)) + + def setLocateEnabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + return ErrorCode.lookup(TDeviceCtrl.setLocateEnabled(self._nativeDev, value)) + + @property + def installedDevices(self): + nativeArray = TDeviceCtrl.getInstalledDevices() + arr = TArray.toDeviceTreeNode(nativeArray, True) + return arr + + def getHwSpecific(self, name): + dataArr = (c_int32 * 1)() + size = c_int32(4) + pSize = pointer(size) + data = None + ret = ErrorCode.lookup(TDeviceCtrl.getHwSpecific(self._nativeDev, name, pSize, dataArr)) + if ret == ErrorCode.Success: + data = dataArr[0] + return ret, data + + def setHwSpecific(self, name, data): + dataArr = (c_int32 * 1)() + dataArr[0] = data + ret = TDeviceCtrl.setHwSpecific(self._nativeDev, name, 4, dataArr) + return ErrorCode.lookup(ret) diff --git a/src/components/Automation/BDaq/DiCosintPort.py b/src/components/Automation/BDaq/DiCosintPort.py new file mode 100644 index 0000000..30e4f24 --- /dev/null +++ b/src/components/Automation/BDaq/DiCosintPort.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TDiCosintPort, BioFailed +from Automation.BDaq import ErrorCode + + +class DiCosintPort(object): + def __init__(self, nativeDiCosintPortObj): + self._nativeDiCosintPortObj = nativeDiCosintPortObj + + @property + def port(self): + return TDiCosintPort.getPort(self._nativeDiCosintPortObj) + + # The channels in the port that enabled change of state interrupt + @property + def mask(self): + return TDiCosintPort.getMask(self._nativeDiCosintPortObj) + + @mask.setter + def mask(self, value): + ret = ErrorCode.lookup(TDiCosintPort.setMask(self._nativeDiCosintPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set mask is failed, the error code is 0x%X' % (ret.value)) + diff --git a/src/components/Automation/BDaq/DiPmintPort.py b/src/components/Automation/BDaq/DiPmintPort.py new file mode 100644 index 0000000..e8733fd --- /dev/null +++ b/src/components/Automation/BDaq/DiPmintPort.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDiPmintPort +from Automation.BDaq import ErrorCode + + +class DiPmintPort(object): + def __init__(self, nativeDiPmPortObj): + self._nativeDiPmPortObj = nativeDiPmPortObj + + @property + def port(self): + return TDiPmintPort.getPort(self._nativeDiPmPortObj) + + @property + def mask(self): + return TDiPmintPort.getMask(self._nativeDiPmPortObj) + + @mask.setter + def mask(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDiPmintPort.setMask(self._nativeDiPmPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set mask is failed, the error code is 0x%X' % (ret.value)) + + @property + def pattern(self): + return TDiPmintPort.getPattern(self._nativeDiPmPortObj) + + @pattern.setter + def pattern(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDiPmintPort.setPattern(self._nativeDiPmPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set pattern is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/DiintChannel.py b/src/components/Automation/BDaq/DiintChannel.py new file mode 100644 index 0000000..7388023 --- /dev/null +++ b/src/components/Automation/BDaq/DiintChannel.py @@ -0,0 +1,53 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDiintChannel, BioFailed +from Automation.BDaq import ErrorCode, ActiveSignal +from Automation.BDaq import Utils + + +class DiintChannel(object): + def __init__(self, diIntChan): + self._diIntChan = diIntChan + + @property + def channel(self): + return TDiintChannel.getChannel(self._diIntChan) + + @property + def enabled(self): + value = TDiintChannel.getEnabled(self._diIntChan) + return True if value else False + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TDiintChannel.setEnabled(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TDiintChannel.getGated(self._diIntChan) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TDiintChannel.setGated(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def trigEdge(self): + return Utils.toActiveSignal(TDiintChannel.getTrigEdge(self._diIntChan)) + + @trigEdge.setter + def trigEdge(self, value): + if not isinstance(value, ActiveSignal): + raise TypeError('a ActiveSignal is required') + ret = ErrorCode.lookup(TDiintChannel.setTrigEdge(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set trigEdge is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/DioCtrlBase.py b/src/components/Automation/BDaq/DioCtrlBase.py new file mode 100644 index 0000000..de79cff --- /dev/null +++ b/src/components/Automation/BDaq/DioCtrlBase.py @@ -0,0 +1,35 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDioCtrlBase, TArray +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.DioFeatures import DioFeatures +from Automation.BDaq.DioPort import DioPort + + +class DioCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(DioCtrlBase, self).__init__(scenario, devInfo) + self._dio_features = None + self._dio_ports = list() + + @property + def features(self): + if self._dio_features is None: + self._dio_features = DioFeatures(TDioCtrlBase.getFeatures(self._obj)) + return self._dio_features + + @property + def portCount(self): + return self.features.portCount + + @property + def ports(self): + if not self._dio_ports: + nativeArray = TDioCtrlBase.getPorts(self._obj) + count = self.portCount + for i in range(count): + dioPortObj = DioPort(TArray.getItem(nativeArray, i)) + self._dio_ports.append(dioPortObj) + + return self._dio_ports diff --git a/src/components/Automation/BDaq/DioFeatures.py b/src/components/Automation/BDaq/DioFeatures.py new file mode 100644 index 0000000..2504e57 --- /dev/null +++ b/src/components/Automation/BDaq/DioFeatures.py @@ -0,0 +1,90 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TArray +from Automation.BDaq.BDaqApi import TDioFeatures +from Automation.BDaq import MathInterval +from Automation.BDaq import Utils + + +class DioFeatures(object): + def __init__(self, nativeFeatures): + self._dio_features = nativeFeatures + + # common + @property + def portProgrammable(self): + ret = TDioFeatures.getPortProgrammable(self._dio_features) + return True if ret else False + + @property + def channelCountMax(self): + return TDioFeatures.getChannelCountMax(self._dio_features) + + @property + def portCount(self): + return TDioFeatures.getPortCount(self._dio_features) + + @property + def portsType(self): + nativeArr = TDioFeatures.getPortsType(self._dio_features) + return TArray.ToByte(nativeArr, True) + + @property + def diSupported(self): + ret = TDioFeatures.getDiSupported(self._dio_features) + return True if ret else False + + @property + def doSupported(self): + ret = TDioFeatures.getDoSupported(self._dio_features) + return True if ret else False + + @property + def diDataMask(self): + nativeArray = TDioFeatures.getDiDataMask(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def diNoiseFilterSupported(self): + ret = TDioFeatures.getDiNoiseFilterSupported(self._dio_features) + return True if ret else False + + @property + def diNoiseFilterOfChannels(self): + nativeArray = TDioFeatures.getDiNoiseFilterOfChannels(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def diNoiseFilterBlockTimeRange(self): + x = MathInterval() + TDioFeatures.getDiNoiseFilterBlockTimeRange(self._dio_features, ctypes.pointer(x)) + return x + + @property + def doDataMask(self): + nativeArray = TDioFeatures.getDoDataMask(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def doFreezeSignalSources(self): + nativeArray = TDioFeatures.getDoFreezeSignalSources(self._dio_features) + return TArray.ToSignalDrop(nativeArray, True) + + @property + def reflectWdtFeedIntervalRange(self): + x = MathInterval() + TDioFeatures.getDoReflectWdtFeedIntervalRange(self._dio_features, ctypes.pointer(x)) + return x + + @property + def doPresetValueDepository(self): + ret = TDioFeatures.getDoPresetValueDepository(self._dio_features) + return Utils.toDepository(ret) + + @property + def doCircuitSelectableTypes(self): + nativeArray = TDioFeatures.getDoCircuitSelectableTypes(self._dio_features) + return TArray.ToDoCircuitType(nativeArray, True) diff --git a/src/components/Automation/BDaq/DioPort.py b/src/components/Automation/BDaq/DioPort.py new file mode 100644 index 0000000..163b50d --- /dev/null +++ b/src/components/Automation/BDaq/DioPort.py @@ -0,0 +1,75 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDioPort, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, DioPortDir, DoCircuitType + + +class DioPort(object): + def __init__(self, nativePort): + self._nativePort = nativePort + + @property + def port(self): + return TDioPort.getPort(self._nativePort) + + @property + def direction(self): + return Utils.toDioPortDir(TDioPort.getDirection(self._nativePort)) + + @direction.setter + def direction(self, value): + if not isinstance(value, DioPortDir): + raise TypeError('a DioPortDir is required') + ret = ErrorCode.lookup(TDioPort.setDirection(self._nativePort, value)) + if BioFailed(ret): + raise ValueError('set direction is failed, the error code is 0x%X' % (ret.value)) + + @property + def diInversePort(self): + return TDioPort.getDiInversePort(self._nativePort) + + @diInversePort.setter + def diInversePort(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDiInversePort(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set diInversePort is failed, the error code is 0x%X' % (ret.value)) + + @property + def diOpenState(self): + return TDioPort.getDiOpenState(self._nativePort) + + @diOpenState.setter + def diOpenState(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDiOpenState(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set diOpenState is failed, the error code is 0x%X' % (ret.value)) + + @property + def doPresetValue(self): + return TDioPort.getDoPresetValue(self._nativePort) + + @doPresetValue.setter + def doPresetValue(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDoPresetValue(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set doPresetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def doCircuitType(self): + return Utils.toDoCircuitType(TDioPort.getDoCircuitType(self._nativePort)) + + @doCircuitType.setter + def doCircuitType(self, value): + if not isinstance(value, DoCircuitType): + raise TypeError('a DoCircuitType is required') + ret = ErrorCode.lookup(TDioPort.setDoCircuitType(self._nativePort, value)) + if BioFailed(ret): + raise ValueError('set doCircuitType is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/EcChannel.py b/src/components/Automation/BDaq/EcChannel.py new file mode 100644 index 0000000..993d5ee --- /dev/null +++ b/src/components/Automation/BDaq/EcChannel.py @@ -0,0 +1,77 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TEcChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, SignalDrop +from Automation.BDaq import Utils + + +class EcChannel(object): + def __init__(self, nativeEcChanObj): + self._nativeEcChanObj = nativeEcChanObj + + @property + def channel(self): + return TEcChannel.getChannel(self._nativeEcChanObj) + + @property + def noiseFiltered(self): + value = TEcChannel.getNoiseFiltered(self._nativeEcChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TEcChannel.setNoiseFiltered(self._nativeEcChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockSource(self): + return Utils.toSignalDrop(TEcChannel.getClockSource(self._nativeEcChanObj)) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TEcChannel.setClockSource(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockPolarity(self): + return Utils.toSignalPolarity(TEcChannel.getClockPolarity(self._nativeEcChanObj)) + + @clockPolarity.setter + def clockPolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError("a SignalPolarity is required") + ret = ErrorCode.lookup(TEcChannel.setClockPolarity(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockPolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + return Utils.toSignalPolarity(TEcChannel.getGatePolarity(self._nativeEcChanObj)) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError("a SignalePolarity is required") + ret = ErrorCode.lookup(TEcChannel.setGatePolarity(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TEcChannel.getGated(self._nativeEcChanObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TEcChannel.setGated(self._nativeEcChanObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/EventCounterCtrl.py b/src/components/Automation/BDaq/EventCounterCtrl.py new file mode 100644 index 0000000..edb7d77 --- /dev/null +++ b/src/components/Automation/BDaq/EventCounterCtrl.py @@ -0,0 +1,33 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.EcChannel import EcChannel +from Automation.BDaq.BDaqApi import TArray, TEventCounterCtrl + + +class EventCounterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(EventCounterCtrl, self).__init__(Scenario.SceEventCounter, devInfo) + self._ec_channels = [] + + @property + def channels(self): + if not self._ec_channels: + count = self.features.channelCountMax + nativeArr = TEventCounterCtrl.getChannels(self._obj) + for i in range(count): + ecChannObj = EcChannel(TArray.getItem(nativeArr, i)) + self._ec_channels.append(ecChannObj) + return self._ec_channels + + def read(self, count = 1): + dataArr = (c_int * count)() + data = [] + ret = ErrorCode.lookup(TEventCounterCtrl.Read(self._obj, count, dataArr)) + for i in range(count): + data.append(dataArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/FmChannel.py b/src/components/Automation/BDaq/FmChannel.py new file mode 100644 index 0000000..bdd8402 --- /dev/null +++ b/src/components/Automation/BDaq/FmChannel.py @@ -0,0 +1,53 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TFmChannel, BioFailed +from Automation.BDaq import ErrorCode, FreqMeasureMethod +from Automation.BDaq import Utils + + +class FmChannel(object): + def __init__(self, nativeFmChanObj): + self._nativeFmChanObj = nativeFmChanObj + + @property + def channel(self): + return TFmChannel.getChannel(self._nativeFmChanObj) + + @property + def noiseFiltered(self): + value = TFmChannel.getNoiseFiltered(self._nativeFmChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TFmChannel.setNoiseFiltered(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def fmMethod(self): + value = TFmChannel.getFmMethod(self._nativeFmChanObj) + return Utils.toFreqMeasureMethod(value) + + @fmMethod.setter + def fmMethod(self, value): + if not isinstance(value, FreqMeasureMethod): + raise TypeError("a FreqMeasureMethod is required") + ret = ErrorCode.lookup(TFmChannel.setFmMethod(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set fmMethod is failed, the error code is 0x%X' % (ret.value)) + + @property + def collectionPeriod(self): + return TFmChannel.getCollectionPeriod(self._nativeFmChanObj) + + @collectionPeriod.setter + def collectionPeriod(self, value): + if not isinstance(value, (float, int)): + raise TypeError("a float is required") + ret = ErrorCode.lookup(TFmChannel.setCollectionPeriod(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set collectionPeriod is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/FreqMeterCtrl.py b/src/components/Automation/BDaq/FreqMeterCtrl.py new file mode 100644 index 0000000..a5c605c --- /dev/null +++ b/src/components/Automation/BDaq/FreqMeterCtrl.py @@ -0,0 +1,34 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_double + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.FmChannel import FmChannel +from Automation.BDaq.BDaqApi import TArray, TFreqMeterCtrl + + +class FreqMeterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(FreqMeterCtrl, self).__init__(Scenario.SceFreqMeter, devInfo) + self._fm_channls = [] + + @property + def channels(self): + if not self._fm_channls: + count = self.features.channelCountMax + nativeArr = TFreqMeterCtrl.getChannels(self._obj) + for i in range(count): + fmChannObj = FmChannel(TArray.getItem(nativeArr, i)) + self._fm_channls.append(fmChannObj) + return self._fm_channls + + def read(self, count = 1): + dataArr = (c_double * count)() + data = [] + ret = ErrorCode.lookup(TFreqMeterCtrl.Read(self._obj, count, dataArr)) + + for i in range(count): + data.append(dataArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/InstantAiCtrl.py b/src/components/Automation/BDaq/InstantAiCtrl.py new file mode 100644 index 0000000..3eb9123 --- /dev/null +++ b/src/components/Automation/BDaq/InstantAiCtrl.py @@ -0,0 +1,105 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantAiCtrl, BioFailed +from Automation.BDaq.AiCtrlBase import AiCtrlBase +from Automation.BDaq.CjcSetting import CjcSetting + + +class InstantAiCtrl(AiCtrlBase): + def __init__(self, devInfo = None): + super(InstantAiCtrl, self).__init__(Scenario.SceInstantAi, devInfo) + self._cjc = None + + @property + def cjc(self): + if self._cjc is None: + self._cjc = CjcSetting(TInstantAiCtrl.getCjc(self._obj)) + return self._cjc + + @property + def autoConvertClockRate(self): + return TInstantAiCtrl.getAutoConvertClockRate(self._obj) + + @autoConvertClockRate.setter + def autoConvertClockRate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertClockRate(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertClockRate is failed, the error code is 0x%X' % (ret.value)) + + @property + def autoConvertChannelStart(self): + return TInstantAiCtrl.getAutoConvertChannelStart(self._obj) + + @autoConvertChannelStart.setter + def autoConvertChannelStart(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertChannelStart(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertChannelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def autoConvertChannelCount(self): + return TInstantAiCtrl.getAutoConvertChannelCount(self._obj) + + @autoConvertChannelCount.setter + def autoConvertChannelCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertChannelCount(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertChannelCount is failed, the error code is 0x%X' % (ret.value)) + + def readDataF64(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + scaledArray = (c_double * chCount)() + dataScaled = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, None, scaledArray)) + if BioFailed(ret): + return ret, dataScaled + + for i in range(chCount): + dataScaled.append(scaledArray[i]) + return ret, dataScaled + + def readDataI32(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + rawArray = (c_int32 * chCount)() + dataRaw = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, rawArray, None)) + if BioFailed(ret): + return ret, dataRaw + + for i in range(chCount): + dataRaw.append(rawArray[i]) + return ret, dataRaw + + def readDataI16(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + rawArray = (c_int16 * chCount)() + dataRaw = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, rawArray, None)) + if BioFailed(ret): + return ret, dataRaw + + for i in range(chCount): + dataRaw.append(rawArray[i]) + return ret, dataRaw diff --git a/src/components/Automation/BDaq/InstantAoCtrl.py b/src/components/Automation/BDaq/InstantAoCtrl.py new file mode 100644 index 0000000..3714a74 --- /dev/null +++ b/src/components/Automation/BDaq/InstantAoCtrl.py @@ -0,0 +1,21 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantAoCtrl +from Automation.BDaq.AoCtrlBase import AoCtrlBase + + +class InstantAoCtrl(AoCtrlBase): + def __init__(self, devInfo = None): + super(InstantAoCtrl, self).__init__(Scenario.SceInstantAo, devInfo) + + def writeAny(self, chStart, chCount, dataRaw, dataScaled): + doubleArray = (c_double * chCount)() + for i in range(chCount): + doubleArray[i] = dataScaled[i] + + return ErrorCode.lookup(TInstantAoCtrl.writeAny(self._obj, chStart, chCount, dataRaw, doubleArray)) + diff --git a/src/components/Automation/BDaq/InstantDiCtrl.py b/src/components/Automation/BDaq/InstantDiCtrl.py new file mode 100644 index 0000000..66f5589 --- /dev/null +++ b/src/components/Automation/BDaq/InstantDiCtrl.py @@ -0,0 +1,87 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.DioCtrlBase import DioCtrlBase +from Automation.BDaq.BDaqApi import TInstantDiCtrl, TArray, BioFailed +from Automation.BDaq.DiintChannel import DiintChannel +from Automation.BDaq.NosFltChannel import NosFltChannel +from Automation.BDaq.DiPmintPort import DiPmintPort +from Automation.BDaq.DiCosintPort import DiCosintPort + + +class InstantDiCtrl(DioCtrlBase): + def __init__(self, devInfo = None): + super(InstantDiCtrl, self).__init__(Scenario.SceInstantDi, devInfo) + self._nosFltChans = [] + self._intChans = [] + self._cosPorts = [] + self._pmPorts = [] + + @property + def noiseFilterBlockTime(self): + return TInstantDiCtrl.getNoiseFilterBlockTime(self._obj) + + @noiseFilterBlockTime.setter + def noiseFilterBlockTime(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TInstantDiCtrl.setNoiseFilterBlockTime(self._obj, value)) + if BioFailed(ret): + raise ValueError('set noiseFilterBlockTime is failed, the error code is 0x%X' % (ret.value)) + + @property + def noiseFilter(self): + if not self._nosFltChans: + nativeArr = TInstantDiCtrl.getNoiseFilter(self._obj) + count = TArray.getLength(nativeArr) + for i in range(count): + nosFltChannObj = NosFltChannel(TArray.getItem(nativeArr, i)) + self._nosFltChans.append(nosFltChannObj) + return self._nosFltChans + + @property + def diIntChannels(self): + if not self._intChans: + nativeArray = TInstantDiCtrl.getDiintChannels(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + diintChannObj = DiintChannel(TArray.getItem(nativeArray, i)) + self._intChans.append(diintChannObj) + return self._intChans + + @property + def diCosintPorts(self): + if not self._cosPorts: + nativeArray = TInstantDiCtrl.getDiCosintPorts(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + cosPortsObj = DiCosintPort(TArray.getItem(nativeArray, i)) + self._cosPorts.append(cosPortsObj) + return self._cosPorts + + @property + def diPmintPorts(self): + if not self._pmPorts: + nativeArray = TInstantDiCtrl.getDiPmintPorts(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + pmPortsObj = DiPmintPort(TArray.getItem(nativeArray, i)) + self._pmPorts.append(pmPortsObj) + return self._pmPorts + + def readAny(self, portStart, portCount): + dataArray = (c_uint8 * portCount)() + data = [] + ret = TInstantDiCtrl.readAny(self._obj, portStart, portCount, dataArray) + for i in range(portCount): + data.append(dataArray[i]) + return ErrorCode.lookup(ret), data + + def readBit(self, port, bit): + dataArray = (c_uint8 * 1)() + ret = TInstantDiCtrl.readBit(self._obj, port, bit, dataArray) + data = dataArray[0] + return ErrorCode.lookup(ret), data diff --git a/src/components/Automation/BDaq/InstantDoCtrl.py b/src/components/Automation/BDaq/InstantDoCtrl.py new file mode 100644 index 0000000..e4e92d5 --- /dev/null +++ b/src/components/Automation/BDaq/InstantDoCtrl.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantDoCtrl +from Automation.BDaq.DioCtrlBase import DioCtrlBase + + +class InstantDoCtrl(DioCtrlBase): + def __init__(self, devInfo = None): + super(InstantDoCtrl, self).__init__(Scenario.SceInstantDo, devInfo) + + def writeAny(self, portStart, portCount, data): + dataArray = (c_uint8 * portCount)() + for i in range(portCount): + dataArray[i] = data[i] + ret = TInstantDoCtrl.writeAny(self._obj, portStart, portCount, dataArray) + return ErrorCode.lookup(ret) + + def writeBit(self, port, bit, data): + ret = TInstantDoCtrl.writeBit(self._obj, port, bit, data) + return ErrorCode.lookup(ret) + + def readAny(self, portStart, portCount): + dataArray = (c_uint8 * portCount)() + data = [] + ret = TInstantDoCtrl.readAny(self._obj, portStart, portCount, dataArray) + for i in range(portCount): + data.append(dataArray[i]) + return ErrorCode.lookup(ret), data + + def readBit(self, port, bit): + dataArray = (c_uint8 * 1)() + ret = TInstantDoCtrl.readBit(self._obj, port, bit, dataArray) + data = dataArray[0] + return ErrorCode.lookup(ret), data diff --git a/src/components/Automation/BDaq/NoiseFilterChannel.py b/src/components/Automation/BDaq/NoiseFilterChannel.py new file mode 100644 index 0000000..0de98c2 --- /dev/null +++ b/src/components/Automation/BDaq/NoiseFilterChannel.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TNosFltChannel, BioFailed +from Automation.BDaq import ErrorCode + + +class NoiseFilterChannel(object): + def __init__(self, native_nos_flt_chann_obj): + self._native_nos_flt_chann_obj = native_nos_flt_chann_obj + + @property + def channel(self): + return TNosFltChannel.getChannel(self._native_nos_flt_chann_obj) + + @property + def enabled(self): + ret = TNosFltChannel.getEnabled(self._native_nos_flt_chann_obj) + return True if ret else False + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TNosFltChannel.setEnabled(self._native_nos_flt_chann_obj, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/NosFltChannel.py b/src/components/Automation/BDaq/NosFltChannel.py new file mode 100644 index 0000000..98a698d --- /dev/null +++ b/src/components/Automation/BDaq/NosFltChannel.py @@ -0,0 +1,9 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.NoiseFilterChannel import NoiseFilterChannel + + +class NosFltChannel(NoiseFilterChannel): + def __init__(self, nativeNoiseFilterChannObj): + super(NosFltChannel, self).__init__(nativeNoiseFilterChannObj) diff --git a/src/components/Automation/BDaq/OneShotCtrl.py b/src/components/Automation/BDaq/OneShotCtrl.py new file mode 100644 index 0000000..50742d5 --- /dev/null +++ b/src/components/Automation/BDaq/OneShotCtrl.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import Scenario +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq.OsChannel import OsChannel +from Automation.BDaq.BDaqApi import TArray, TOneShotCtrl + + +class OneShotCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(OneShotCtrl, self).__init__(Scenario.SceOneShot, devInfo) + self._os_channels = [] + + @property + def channels(self): + if not self._os_channels: + count = self.features.channelCountMax + nativeArr = TOneShotCtrl.getChannels(self._obj) + + for i in range(count): + poChannObj = OsChannel(TArray.getItem(nativeArr, i)) + self._os_channels.append(poChannObj) + return self._os_channels diff --git a/src/components/Automation/BDaq/OsChannel.py b/src/components/Automation/BDaq/OsChannel.py new file mode 100644 index 0000000..21397a8 --- /dev/null +++ b/src/components/Automation/BDaq/OsChannel.py @@ -0,0 +1,103 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TOsChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq import Utils, SignalDrop + + +class OsChannel(object): + def __init__(self, nativeOsObj): + self._nativeOsObj = nativeOsObj + + @property + def channel(self): + return TOsChannel.getChannel(self._nativeOsObj) + + @property + def noiseFiltered(self): + value = TOsChannel.getNoiseFiltered(self._nativeOsObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TOsChannel.setNoiseFiltered(self._nativeOsObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def delayCount(self): + return TOsChannel.getDelayCount(self._nativeOsObj) + + @delayCount.setter + def delayCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TOsChannel.setDelayCount(self._nativeOsObj, value)) + if BioFailed(ret): + raise ValueError('set delayCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockSource(self): + return Utils.toSignalDrop(TOsChannel.getClockSource(self._nativeOsObj)) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TOsChannel.setClockSource(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockPolarity(self): + value = TOsChannel.getClockPolarity(self._nativeOsObj) + return Utils.toSignalPolarity(value) + + @clockPolarity.setter + def clockPolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TOsChannel.setClockPolarity(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockPolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gateSource(self): + return Utils.toSignalDrop(TOsChannel.getGateSource(self._nativeOsObj)) + + @gateSource.setter + def gateSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TOsChannel.setGateSource(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set gateSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TOsChannel.getGatePolarity(self._nativeOsObj) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TOsChannel.setGatePolarity(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TOsChannel.getOutSignal(self._nativeOsObj) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError("a OutSignalType is required") + ret = ErrorCode.lookup(TOsChannel.setOutSignal(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PiChannel.py b/src/components/Automation/BDaq/PiChannel.py new file mode 100644 index 0000000..bb2c749 --- /dev/null +++ b/src/components/Automation/BDaq/PiChannel.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TPiChannel, BioFailed +from Automation.BDaq import ErrorCode + + +class PiChannel(object): + def __init__(self, nativePiChanObj): + self._nativePiChanObj = nativePiChanObj + + @property + def channel(self): + return TPiChannel.getChannel(self._nativePiChanObj) + + @property + def noiseFiltered(self): + value = TPiChannel.getNoiseFiltered(self._nativePiChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TPiChannel.setNoiseFiltered(self._nativePiChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PoChannel.py b/src/components/Automation/BDaq/PoChannel.py new file mode 100644 index 0000000..2af8102 --- /dev/null +++ b/src/components/Automation/BDaq/PoChannel.py @@ -0,0 +1,93 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq import PulseWidth, ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq.BDaqApi import TPoChannel, BioFailed +from Automation.BDaq import Utils + + +class PoChannel(object): + def __init__(self, nativePoChannObj): + self._nativePoChannObj = nativePoChannObj + + @property + def channel(self): + return TPoChannel.getChannel(self._nativePoChannObj) + + @property + def noiseFiltered(self): + value = TPoChannel.getNoiseFiltered(self._nativePoChannObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + + ret = ErrorCode.lookup(TPoChannel.setNoiseFiltered(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def pulseWidth(self): + value = PulseWidth() + TPoChannel.getPulseWidth(self._nativePoChannObj, value) + return value + + @pulseWidth.setter + def pulseWidth(self, value): + if not isinstance(value, PulseWidth): + raise TypeError("a PulseWidth is required") + ret = ErrorCode.lookup(TPoChannel.setPulseWidth(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set pulseWidth is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + return Utils.toSignalPolarity(TPoChannel.getGatePolarity(self._nativePoChannObj)) + + @gatePolarity.setter + def gatePolarity(self, varValue): + if not isinstance(varValue, SignalPolarity): + raise TypeError("a SignalPolarity is required") + ret = ErrorCode.lookup(TPoChannel.setGatePolarity(self._nativePoChannObj, varValue.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TPoChannel.getGated(self._nativePoChannObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TPoChannel.setGated(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + return Utils.toOutSignaleType(TPoChannel.getOutSignal(self._nativePoChannObj)) + + @outSignal.setter + def outSignal(self, varValue): + if not isinstance(varValue, OutSignalType): + raise TypeError('a OutSignalType is required') + ret = ErrorCode.lookup(TPoChannel.setOutSignal(self._nativePoChannObj, varValue.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) + + @property + def outCount(self): + return TPoChannel.getOutCount(self._nativePoChannObj) + + @outCount.setter + def outCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TPoChannel.setOutCount(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set outCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PwMeterCtrl.py b/src/components/Automation/BDaq/PwMeterCtrl.py new file mode 100644 index 0000000..69f5442 --- /dev/null +++ b/src/components/Automation/BDaq/PwMeterCtrl.py @@ -0,0 +1,32 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, PulseWidth, ErrorCode +from Automation.BDaq.BDaqApi import TArray, TPwMeterCtrl +from Automation.BDaq.PiChannel import PiChannel + + +class PwMeterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(PwMeterCtrl, self).__init__(Scenario.ScePwMeter, devInfo) + self._pi_channesl = [] + + @property + def channels(self): + if not self._pi_channesl: + count = self.features.channelCountMax + nativeArr = TPwMeterCtrl.getChannels(self._obj) + for i in range(count): + piChanObj = PiChannel(TArray.getItem(nativeArr, i)) + self._pi_channesl.append(piChanObj) + return self._pi_channesl + + def read(self, count = 1): + pulseWidthArr = (PulseWidth * count)() + ret = ErrorCode.lookup(TPwMeterCtrl.Read(self._obj, count, pulseWidthArr)) + data = [] + if ret == ErrorCode.Success: + for i in range(count): + data.append(pulseWidthArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/PwModulatorCtrl.py b/src/components/Automation/BDaq/PwModulatorCtrl.py new file mode 100644 index 0000000..ddbc0ed --- /dev/null +++ b/src/components/Automation/BDaq/PwModulatorCtrl.py @@ -0,0 +1,22 @@ + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario +from Automation.BDaq.PoChannel import PoChannel +from Automation.BDaq.BDaqApi import TArray, TPwModulatorCtrl + + +class PwModulatorCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(PwModulatorCtrl, self).__init__(Scenario.ScePwModulator, devInfo) + self._po_channels = [] + + @property + def channels(self): + if not self._po_channels: + count = self.features.channelCountMax + nativeArr = TPwModulatorCtrl.getChannels(self._obj) + + for i in range(count): + poChannObj = PoChannel(TArray.getItem(nativeArr, i)) + self._po_channels.append(poChannObj) + return self._po_channels diff --git a/src/components/Automation/BDaq/Record.py b/src/components/Automation/BDaq/Record.py new file mode 100644 index 0000000..4a8156a --- /dev/null +++ b/src/components/Automation/BDaq/Record.py @@ -0,0 +1,46 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TRecord, BioFailed +from Automation.BDaq import ErrorCode + + +class Record(object): + def __init__(self, nativeRecordObj): + self._nativeRecordObj = nativeRecordObj + + @property + def sectionLength(self): + return TRecord.getSectionLength(self._nativeRecordObj) + + @sectionLength.setter + def sectionLength(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setSectionLength(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set sectionLength is failed, the error code is 0x%X' % (ret.value)) + + @property + def sectionCount(self): + return TRecord.getSectionCount(self._nativeRecordObj) + + @sectionCount.setter + def sectionCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setSectionCount(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set sectionCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def cycles(self): + return TRecord.getCycles(self._nativeRecordObj) + + @cycles.setter + def cycles(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setCycles(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set cycles is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/ScanChannel.py b/src/components/Automation/BDaq/ScanChannel.py new file mode 100644 index 0000000..6a8cc28 --- /dev/null +++ b/src/components/Automation/BDaq/ScanChannel.py @@ -0,0 +1,58 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import ErrorCode +from Automation.BDaq.BDaqApi import TScanChannel, BioFailed + + +class ScanChannel(object): + def __init__(self, nativeScanChanObj): + self._nativeScanChanObj = nativeScanChanObj + + @property + def channelStart(self): + return TScanChannel.getChannelStart(self._nativeScanChanObj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setChannelStart(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TScanChannel.getChannelCount(self._nativeScanChanObj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setChannelCount(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def samples(self): + return TScanChannel.getSamples(self._nativeScanChanObj) + + @samples.setter + def samples(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setSamples(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set samples is failed, the error code is 0x%X' % (ret.value)) + + @property + def intervalCount(self): + return TScanChannel.getIntervalCount(self._nativeScanChanObj) + + @intervalCount.setter + def intervalCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setIntervalCount(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set intervalCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/TimerPulseCtrl.py b/src/components/Automation/BDaq/TimerPulseCtrl.py new file mode 100644 index 0000000..de94f6a --- /dev/null +++ b/src/components/Automation/BDaq/TimerPulseCtrl.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import Scenario +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq.TmrChannel import TmrChannel +from Automation.BDaq.BDaqApi import TArray, TTimerPulseCtrl + + +class TimerPulseCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(TimerPulseCtrl, self).__init__(Scenario.SceTimerPulse, devInfo) + self._tmr_channels = [] + + @property + def channels(self): + if not self._tmr_channels: + count = self.features.channelCountMax + nativeArr = TTimerPulseCtrl.getChannels(self._obj) + + for i in range(count): + tmrChannObj = TmrChannel(TArray.getItem(nativeArr, i)) + self._tmr_channels.append(tmrChannObj) + return self._tmr_channels diff --git a/src/components/Automation/BDaq/TmrChannel.py b/src/components/Automation/BDaq/TmrChannel.py new file mode 100644 index 0000000..3f9d232 --- /dev/null +++ b/src/components/Automation/BDaq/TmrChannel.py @@ -0,0 +1,79 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TTmrChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq import Utils + + +class TmrChannel(object): + def __init__(self, nativeTmrObj): + self._nativeTmrObj = nativeTmrObj + + @property + def channel(self): + return TTmrChannel.getChannel(self._nativeTmrObj) + + @property + def noiseFiltered(self): + value = TTmrChannel.getNoiseFiltered(self._nativeTmrObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TTmrChannel.setNoiseFiltered(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def frequency(self): + return TTmrChannel.getFrequency(self._nativeTmrObj) + + @frequency.setter + def frequency(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTmrChannel.setFrequency(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set frequency is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TTmrChannel.getGatePolarity(self._nativeTmrObj) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TTmrChannel.setGatePolarity(self._nativeTmrObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TTmrChannel.getGated(self._nativeTmrObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TTmrChannel.setGated(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TTmrChannel.getOutSignal(self._nativeTmrObj) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError("a OutSignalType is required") + ret = ErrorCode.lookup(TTmrChannel.setOutSignal(self._nativeTmrObj, value.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/Trigger.py b/src/components/Automation/BDaq/Trigger.py new file mode 100644 index 0000000..a01514e --- /dev/null +++ b/src/components/Automation/BDaq/Trigger.py @@ -0,0 +1,112 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TTrigger, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import SignalDrop, ErrorCode, ActiveSignal, TriggerAction, FilterType + + +class Trigger(object): + def __init__(self, nativeTrigObj): + self._nativeTrigObj = nativeTrigObj + + @property + def source(self): + value = TTrigger.getSource(self._nativeTrigObj) + return Utils.toSignalDrop(value) + + @source.setter + def source(self, value): + if not isinstance(value, SignalDrop): + raise TypeError("a SignalDrop is required") + ret = ErrorCode.lookup(TTrigger.setSource(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set source is failed, the error code is 0x%X' % (ret.value)) + + @property + def edge(self): + value = TTrigger.getEdge(self._nativeTrigObj) + return Utils.toActiveSignal(value) + + @edge.setter + def edge(self, value): + if not isinstance(value, ActiveSignal): + raise TypeError('a ActiveSignal is required') + ret = ErrorCode.lookup(TTrigger.setEdge(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set edge is failed, the error code is 0x%X' % (ret.value)) + + @property + def level(self): + value = TTrigger.getLevel(self._nativeTrigObj) + return value + + @level.setter + def level(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setLevel(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set level is failed, the error code is 0x%X' % (ret.value)) + + @property + def action(self): + value = TTrigger.getAction(self._nativeTrigObj) + return Utils.toTriggerAction(value) + + @action.setter + def action(self, value): + if not isinstance(value, TriggerAction): + raise TypeError('a TriggerAction is required') + ret = ErrorCode.lookup(TTrigger.setAction(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set action is failed, the error code is 0x%X' % (ret.value)) + + @property + def delayCount(self): + return TTrigger.getDelayCount(self._nativeTrigObj) + + @delayCount.setter + def delayCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is requires') + ret = ErrorCode.lookup(TTrigger.setDelayCount(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set delayCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def hysteresisIndex(self): + return TTrigger.getHysteresisIndex(self._nativeTrigObj) + + @hysteresisIndex.setter + def hysteresisIndex(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setHysteresisIndex(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set hysteresisIndex is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterType(self): + value = TTrigger.getFilterType(self._nativeTrigObj) + return Utils.toFilterType(value) + + @filterType.setter + def filterType(self, value): + if not isinstance(value, FilterType): + raise TypeError('a FilterType is required') + ret = ErrorCode.lookup(TTrigger.setFilterType(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set filterType is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq(self): + return TTrigger.getFilterCutoffFreq(self._nativeTrigObj) + + @filterCutoffFreq.setter + def filterCutoffFreq(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setFilterCutoffFreq(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq is failed, the error code is 0x%X' % (ret.value)) \ No newline at end of file diff --git a/src/components/Automation/BDaq/UdChannel.py b/src/components/Automation/BDaq/UdChannel.py new file mode 100644 index 0000000..c579516 --- /dev/null +++ b/src/components/Automation/BDaq/UdChannel.py @@ -0,0 +1,132 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TUdChannel, BioFailed +from Automation.BDaq import ErrorCode, PulseWidth, CountingType, SignalPolarity, OutSignalType +from Automation.BDaq import Utils + + +class UdChannel(object): + def __init__(self, nativeUdChann): + self._nativeUdChann = nativeUdChann + + @property + def channel(self): + return TUdChannel.getChannel(self._nativeUdChann) + + @property + def noiseFiltered(self): + ret = TUdChannel.getNoiseFiltered(self._nativeUdChann) + return True if ret else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TUdChannel.setNoiseFiltered(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def countingType(self): + value = TUdChannel.getCountingType(self._nativeUdChann) + return Utils.toCountingType(value) + + @countingType.setter + def countingType(self, value): + if not isinstance(value, CountingType): + raise TypeError('a CountingType is required') + ret = ErrorCode.lookup(TUdChannel.setCountingType(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set countingType is failed, the error code is 0x%X' % (ret.value)) + + @property + def initialValue(self): + return TUdChannel.getInitialValue(self._nativeUdChann) + + @initialValue.setter + def initialValue(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setInitialValue(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set initialValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def resetTimesByIndex(self): + return TUdChannel.getResetTimesByIndex(self._nativeUdChann) + + @resetTimesByIndex.setter + def resetTimesByIndex(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setResetTimesByIndex(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set resetTimesByIndex is failed, the error code is 0x%X' % (ret.value)) + + @property + def pulseWidth(self): + x = PulseWidth() + TUdChannel.getPulseWidth(self._nativeUdChann, x) + return x + + @pulseWidth.setter + def pulseWidth(self, value): + if not isinstance(value, PulseWidth): + raise TypeError('a PulseWidth is required') + ret = ErrorCode.lookup(TUdChannel.setPulseWidth(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set pulseWidth is failed, the error code is 0x%X' % (ret.value)) + + + @property + def gated(self): + value = TUdChannel.getGated(self._nativeUdChann) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TUdChannel.setGated(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TUdChannel.getGatePolarity(self._nativeUdChann) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TUdChannel.setGatePolarity(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TUdChannel.getOutSignal(self._nativeUdChann) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError('a OutSignalType is required') + ret = ErrorCode.lookup(TUdChannel.setOutSignal(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) + + @property + def outCount(self): + return TUdChannel.getOutCount(self._nativeUdChann) + + @outCount.setter + def outCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setOutCount(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set outCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/UdCounterCtrl.py b/src/components/Automation/BDaq/UdCounterCtrl.py new file mode 100644 index 0000000..579867f --- /dev/null +++ b/src/components/Automation/BDaq/UdCounterCtrl.py @@ -0,0 +1,37 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.UdChannel import UdChannel +from Automation.BDaq.BDaqApi import TArray, TUdCounterCtrl + + +class UdCounterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(UdCounterCtrl, self).__init__(Scenario.SceUdCounter, devInfo) + self._ud_channels = [] + + @property + def channels(self): + if not self._ud_channels: + count = self.features.channelCountMax + nativeArr = TUdCounterCtrl.getChannels(self._obj) + + for i in range(count): + udChannObj = UdChannel(TArray.getItem(nativeArr, i)) + self._ud_channels.append(udChannObj) + return self._ud_channels + + def read(self, count = 1): + dataArr = (c_int * count)() + data = [] + ret = TUdCounterCtrl.Read(self._obj, count, dataArr) + for i in range(count): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def valueReset(self): + return ErrorCode.lookup(TUdCounterCtrl.ValueReset(self._obj)) diff --git a/src/components/Automation/BDaq/Utils.py b/src/components/Automation/BDaq/Utils.py new file mode 100644 index 0000000..e3135c5 --- /dev/null +++ b/src/components/Automation/BDaq/Utils.py @@ -0,0 +1,203 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import * + + +def CreateArray(DataType, DataNum): + dataArray = (DataType * DataNum)() + return dataArray + +def toAccessMode(value): + value = int(value) + for x in AccessMode: + if x.value == value: + return x + return AccessMode.ModeRead + +def toControlState(value): + value = int(value) + for x in ControlState: + if x.value == value: + return x + return ControlState.Uninited + +def toProductId(value): + value = int(value) + for x in ProductId: + if x.value == value: + return x + return ProductId.BD_UNKNOWN + +def toTerminalBoard(value): + value = int(value) + for x in TerminalBoard: + if x.value == value: + return x + + return TerminalBoard.WiringBoard + +def toDepository(value): + value = int(value) + for x in Depository: + if x.value == value: + return x + return Depository.DepositoryNone + +def toAiChannelType(value): + value = int(value) + for x in AiChannelType: + if x.value == value: + return x + return AiChannelType.AllSingleEnded + +def toAiSignalType(value): + value = int(value) + for x in AiSignalType: + if x.value == value: + return x + return AiSignalType.PseudoDifferential + +def toValueRange(value): + value = int(value) + for x in ValueRange: + if x.value == value: + return x + return ValueRange.V_OMIT + +def toSamplingMethod(value): + value = int(value) + return SamplingMethod.EqualTimeSwitch if value == SamplingMethod.EqualTimeSwitch.value else SamplingMethod.Simultaneous + +def toFilterType(value): + value = int(value) + for x in FilterType: + if x.value == value: + return x + return FilterType.FilterNone + +def toBurnoutRetType(value): + value = int(value) + for x in BurnoutRetType: + if x.value == value: + return x + return BurnoutRetType.Current + +def toSignalDrop(value): + value = int(value) + + for x in SignalDrop: + if x.value == value: + return x + return SignalDrop.SignalNone + +def toSignalPolarity(value): + value = int(value) + + for x in SignalPolarity: + if x.value == value: + return x + return SignalPolarity.Negative + +def toTriggerAction(value): + value = int(value) + + for x in TriggerAction: + if x.value == value: + return x + return TriggerAction.ActionNone + +def toActiveSignal(value): + value = int(value) + + for x in ActiveSignal: + if x.value == value: + return x + return ActiveSignal.ActiveNone + +def toDioPortDir(value): + value = int(value) + for x in DioPortDir: + if x.value == value: + return x + return DioPortDir.Input + +def toDoCircuitType(value): + value = int(value) + + for x in DoCircuitType: + if x.value == value: + return x + return DoCircuitType.TTL + +def toEventId(value): + value = int(value) + + for x in EventId: + if x.value == value: + return x + return EventId.EvtPropertyChanged + +def toCounterCapability(value): + value = int(value) + + for x in CounterCapability: + if x.value == value: + return x + return CounterCapability.Primary + +def toCounterCascadeGroup(value): + value = int(value) + + for x in CounterCascadeGroup: + if x.value == value: + return x + return CounterCascadeGroup.GroupNone + +def toFreqMeasureMethod(value): + value = int(value) + + for x in FreqMeasureMethod: + if x.value == value: + return x + return FreqMeasureMethod.AutoAdaptive + +def toCountingType(value): + value = int(value) + for x in CountingType: + if x.value == value: + return x + return CountingType.CountingNone + +def toOutSignaleType(value): + value = int(value) + + for x in OutSignalType: + if x.value == value: + return x + return OutSignalType.SignalOutNone + +def toCouplingType(value): + value = int(value) + + for x in CouplingType: + if x.value == value: + return x + + return CouplingType.ACCoupling + +def toIepeType(value): + value = int(value) + + for x in IepeType: + if x.value == value: + return x + return IepeType.IEPENone + +def toImpedanceType(value): + value = int(value) + + for x in ImpedanceType: + if x.value == value: + return x + return ImpedanceType.Ipd1Momh diff --git a/src/components/Automation/BDaq/WaveformAiCtrl.py b/src/components/Automation/BDaq/WaveformAiCtrl.py new file mode 100644 index 0000000..cb974af --- /dev/null +++ b/src/components/Automation/BDaq/WaveformAiCtrl.py @@ -0,0 +1,95 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int32, c_int16, c_double, byref, c_int + +from Automation.BDaq.AiCtrlBase import AiCtrlBase +from Automation.BDaq import Scenario, DataMark, ErrorCode, MAX_TRIG_COUNT +from Automation.BDaq.Conversion import Conversion +from Automation.BDaq.Record import Record +from Automation.BDaq.BDaqApi import TWaveformAiCtrl +from Automation.BDaq.Trigger import Trigger + + +class WaveformAiCtrl(AiCtrlBase): + def __init__(self, devInfo = None): + super(WaveformAiCtrl, self).__init__(Scenario.SceWaveformAi, devInfo) + self._conversion = None + self._record = None + self._triggers = [] + + @property + def conversion(self): + if self._conversion is None: + nativeConver = TWaveformAiCtrl.getConversion(self._obj) + self._conversion = Conversion(nativeConver, self.features.channelCountMax) + return self._conversion + + @property + def record(self): + if self._record is None: + nativeRecord = TWaveformAiCtrl.getRecord(self._obj) + self._record = Record(nativeRecord) + return self._record + + @property + def trigger(self): + if not self._triggers: + self._triggers = [None] * MAX_TRIG_COUNT + + for i in range(self.features.triggerCount): + self._triggers[i] = Trigger(TWaveformAiCtrl.getTrigger(self._obj, i)) + return self._triggers + + def prepare(self): + ret = TWaveformAiCtrl.Prepare(self._obj) + return ErrorCode.lookup(ret) + + def start(self): + ret = TWaveformAiCtrl.Start(self._obj) + return ErrorCode.lookup(ret) + + def stop(self): + return ErrorCode.lookup(TWaveformAiCtrl.Stop(self._obj)) + + def getDataI16(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_int16 * count)() + return self.__getData(2, count, dataArr, timeout, startTime, markCount) + + def getDataI32(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_int32 * count)() + return self.__getData(4, count, dataArr, timeout, startTime, markCount) + + def getDataF64(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_double * count)() + return self.__getData(8, count, dataArr, timeout, startTime, markCount) + + def __getData(self, dt, count, dataArr, timeout, startTime, markCount): + returned = (c_int * 1)() + dataBuf = [] + startTimeClock = startTime + if startTime is not None: + startTimeClock = (c_double * 1)() + + markBufTmp = None + markCountTmp = None + if markCount is not None and isinstance(markCount, int): + markBufTmp = (DataMark * markCount)() + markCountTmp = (c_int32 * 1)() + + ret = TWaveformAiCtrl.GetData(self._obj, dt, count, dataArr, timeout, returned, startTimeClock, markCountTmp, + markBufTmp) + + for i in range(returned[0]): + dataBuf.append(dataArr[i]) + + startTimeClock = None if startTimeClock is None else startTimeClock[0] + markCountTmp = None if markCount is None else markCountTmp[0] + if markCount is None: + markBuf = None + else: + markBuf = [] + for i in range(markCountTmp): + markBuf.append(markBufTmp[i]) + return ErrorCode.lookup(ret), returned[0], dataBuf, startTimeClock, markCountTmp, markBuf + diff --git a/src/components/Automation/BDaq/__init__.py b/src/components/Automation/BDaq/__init__.py new file mode 100644 index 0000000..b0703fd --- /dev/null +++ b/src/components/Automation/BDaq/__init__.py @@ -0,0 +1,2427 @@ +import sys +if sys.version_info[:3] < (3,4): + sys.path.append('../3rd_party') +from enum import Enum, IntEnum +from ctypes import Structure, c_int32, c_double, c_int64, c_wchar +from ctypes import c_uint8 + + +DAQ_NAVI_VER = 0x400 + +MAX_DEVICE_DESC_LEN = 64 +MAX_VRG_DESC_LEN = 256 +MAX_SIG_DROP_DESC_LEN = 256 + +MAX_AI_CH_COUNT = 128 +MAX_AO_CH_COUNT = 128 +MAX_DIO_PORT_COUNT = 32 +MAX_CNTR_CH_COUNT = 8 +MAX_TRIG_COUNT = 4 +MAX_DIO_TRIG_COUNT = 2 + + +class TerminalBoard(IntEnum): + WiringBoard = 0 + PCLD8710 = 1 + PCLD789 = 2 + PCLD8115 = 3 + + +class ModuleType(IntEnum): + DaqGroup = 1 + DaqDevice = 2 + DaqAi = 3 + DaqAo = 4 + DaqDio = 5 + DaqCounter = 6 + DaqCali = 7 + DaqAny = -1 + + +class AccessMode(IntEnum): + ModeRead = 0 + ModeWrite = 1 + ModeWriteWithReset = 2 + ModeWriteShared = 3 + + +class Depository(IntEnum): + DepositoryNone = 0 + DepositoryOnSystem = 1 + DepositoryOnDevice = 2 + + +class MathIntervalType(IntEnum): + # Right boundary definition, define the maximum value state, use the bit 0,1 + RightOpenSet = 0x0, # No maximum value limitation. + RightClosedBoundary = 0x1, # The maximum value is included. + RightOpenBoundary = 0x2, # The maximum value is not included. + + # Left boundary definition, define the minimum value state, used the bit 2, 3 + LeftOpenSet = 0x0, # No minimum value limitation. + LeftClosedBoundary = 0x4, # The minimum value is included. + LeftOpenBoundary = 0x8, # The minimum value is not included + + # The signality expression + Boundless = 0x0, # Boundless set. (LeftOpenSet | RightOpenSet) + + # The combination notation + LOSROS = 0x0, # (LeftOpenSet | RightOpenSet), algebra notation: (un-limit, max) + LOSRCB = 0x1, # (LeftOpenSet | RightClosedBoundary), algebra notation: (un-limit, max ] + LOSROB = 0x2, # (LeftOpenSet | RightOpenBoundary), algebra notation: (un-limit, max) + + LCBROS = 0x4, # (LeftClosedBoundary | RightOpenSet), algebra notation: [min, un-limit) + LCBRCB = 0x5, # (LeftClosedBoundary | RightClosedBoundary), algebra notation: [ min, right ] + LCBROB = 0x6, # (LeftClosedBoundary | RightOpenBoundary), algebra notation: [ min, right) + + LOBROS = 0x8, # (LeftOpenBoundary | RightOpenSet), algebra notation: (min, un-limit) + LOBRCB = 0x9, # (LeftOpenBoundary | RightClosedBoundary), algebra notation: (min, right ] + LOBROB = 0xA, # (LeftOpenBoundary | RightOpenBoundary), algebra notation: (min, right) + + +class AiChannelType(IntEnum): + AllSingleEnded = 0 + AllDifferential = 1 + AllSeDiffAdj = 2 + MixedSeDiffAdj = 3 + + +class AiSignalType(IntEnum): + SingleEnded = 0 + Differential = 1 + PseudoDifferential = 2 + + +class CouplingType(IntEnum): + DCCoupling = 0 + ACCoupling = 1 + + +class ImpedanceType(IntEnum): + Ipd1Momh = 0 + Ipd50omh = 1 + + +class IepeType(IntEnum): + IEPENone = 0 + IEPE4mA = 1 + IEPE10mA = 2 + IEPE2mA = 3 + + +class FilterType(IntEnum): + FilterNone = 0 + LowPass = 1 + HighPass = 2 + BandPass = 3 + BandStop = 4 + + +class DioPortType(IntEnum): + PortDi = 0 # the port number references to a DI port + PortDo = 1 # the port number references to a DO port + PortDio = 2 # the port number references to a DI port and a DO port + Port8255A = 3 # the port number references to a PPI port A mode DIO port. + Port8255C = 4 # the port number references to a PPI port C mode DIO port. + PortIndvdlDio = 5 # the port number references to a port whose each channel can be configured as in or out. + + +class DioPortDir(IntEnum): + Input = 0x00 + LoutHin = 0x0F + LinHout = 0xF0 + Output = 0xFF + + +class DoCircuitType(IntEnum): + TTL = 0 + Sink = 1 + Source = 2 + Relay = 3 + + +class SamplingMethod(IntEnum): + EqualTimeSwitch = 0 + Simultaneous = 1 + + +class TemperatureDegree(IntEnum): + Celsius = 0 + Fahrenheit = 1 + Rankine = 2 + Kelvin = 3 + + +class BurnoutRetType(IntEnum): + Current = 0 + ParticularValue = 1 + UpLimit = 2 + LowLimit = 3 + LastCorrectValue = 4 + + +class ValueUnit(IntEnum): + Kilovolt = 0 # KV + Volt = 1 # V + Millivolt = 2 # mV + Microvolt = 3 # uV + Kiloampere = 4 # KA + Ampere = 5 # A + Milliampere = 6 # mA + Microampere = 7 # uA + CelsiusUnit = 8 # Celsius + + +class ValueRange(IntEnum): + V_OMIT = -1 # Unknown when get, ignored when set + V_Neg15To15 = 0 # +/- 15 V + V_Neg10To10 = 1 # +/- 10 V + V_Neg5To5 = 2 # +/- 5 V + V_Neg2pt5To2pt5 = 3 # +/- 2.5 V + V_Neg1pt25To1pt25 = 4 # +/- 1.25 V + V_Neg1To1 = 5 # +/- 1 V + + V_0To15 = 6 # 0~15 V + V_0To10 = 7 # 0~10 V + V_0To5 = 8 # 0~5 V + V_0To2pt5 = 9 # 0~2.5 V + V_0To1pt25 = 10 # 0~1.25 V + V_0To1 = 11 # 0~1 V + + mV_Neg625To625 = 12 # +/- 625mV + mV_Neg500To500 = 13 # +/- 500 mV + mV_Neg312pt5To312pt5 = 14 # +/- 312.5 mV + mV_Neg200To200 = 15 # +/- 200 mV + mV_Neg150To150 = 16 # +/- 150 mV + mV_Neg100To100 = 17 # +/- 100 mV + mV_Neg50To50 = 18 # +/- 50 mV + mV_Neg30To30 = 19 # +/- 30 mV + mV_Neg20To20 = 20 # +/- 20 mV + mV_Neg15To15 = 21 # +/- 15 mV + mV_Neg10To10 = 22 # +/- 10 mV + mV_Neg5To5 = 23 # +/- 5 mV + + mV_0To625 = 24 # 0 ~ 625 mV + mV_0To500 = 25 # 0 ~ 500 mV + mV_0To150 = 26 # 0 ~ 150 mV + mV_0To100 = 27 # 0 ~ 100 mV + mV_0To50 = 28 # 0 ~ 50 mV + mV_0To20 = 29 # 0 ~ 20 mV + mV_0To15 = 30 # 0 ~ 15 mV + mV_0To10 = 31 # 0 ~ 10 mV + + mA_Neg20To20 = 32 # +/- 20mA + mA_0To20 = 33 # 0 ~ 20 mA + mA_4To20 = 34 # 4 ~ 20 mA + mA_0To24 = 35 # 0 ~ 24 mA + + # For USB4702_4704 + V_Neg2To2 = 36 # +/- 2 V + V_Neg4To4 = 37 # +/- 4 V + V_Neg20To20 = 38 # +/- 20 V + + Jtype_0To760C = 0x8000 # T/C J type 0~760 'C + Ktype_0To1370C = 0x8001 # T/C K type 0~1370 'C + Ttype_Neg100To400C = 0x8002 # T/C T type -100~400 'C + Etype_0To1000C = 0x8003 # T/C E type 0~1000 'C + Rtype_500To1750C = 0x8004 # T/C R type 500~1750 'C + Stype_500To1750C = 0x8005 # T/C S type 500~1750 'C + Btype_500To1800C = 0x8006 # T/C B type 500~1800 'C + + Pt392_Neg50To150 = 0x8007 # Pt392 -50~150 'C + Pt385_Neg200To200 = 0x8008 # Pt385 -200~200 'C + Pt385_0To400 = 0x8009 # Pt385 0~400 'C + Pt385_Neg50To150 = 0x800a # Pt385 -50~150 'C + Pt385_Neg100To100 = 0x800b # Pt385 -100~100 'C + Pt385_0To100 = 0x800c # Pt385 0~100 'C + Pt385_0To200 = 0x800d # Pt385 0~200 'C + Pt385_0To600 = 0x800e # Pt385 0~600 'C + Pt392_Neg100To100 = 0x800f # Pt392 -100~100 'C + Pt392_0To100 = 0x8010 # Pt392 0~100 'C + Pt392_0To200 = 0x8011 # Pt392 0~200 'C + Pt392_0To600 = 0x8012 # Pt392 0~600 'C + Pt392_0To400 = 0x8013 # Pt392 0~400 'C + Pt392_Neg200To200 = 0x8014 # Pt392 -200~200 'C + Pt1000_Neg40To160 = 0x8015 # Pt1000 -40~160 'C + + Balcon500_Neg30To120 = 0x8016 # Balcon500 -30~120 'C + + Ni518_Neg80To100 = 0x8017 # Ni518 -80~100 'C + Ni518_0To100 = 0x8018 # Ni518 0~100 'C + Ni508_0To100 = 0x8019 # Ni508 0~100 'C + Ni508_Neg50To200 = 0x801a # Ni508 -50~200 'C + + Thermistor_3K_0To100 = 0x801b # Thermistor 3K 0~100 'C + Thermistor_10K_0To100 = 0x801c # Thermistor 10K 0~100 'C + + Jtype_Neg210To1200C = 0x801d # T/C J type -210~1200 'C + Ktype_Neg270To1372C = 0x801e # T/C K type -270~1372 'C + Ttype_Neg270To400C = 0x801f # T/C T type -270~400 'C + Etype_Neg270To1000C = 0x8020 # T/C E type -270~1000 'C + Rtype_Neg50To1768C = 0x8021 # T/C R type -50~1768 'C + Stype_Neg50To1768C = 0x8022 # T/C S type -50~1768 'C + Btype_40To1820C = 0x8023 # T/C B type 40~1820 'C + + Jtype_Neg210To870C = 0x8024 # T/C J type -210~870 'C + Rtype_0To1768C = 0x8025 # T/C R type 0~1768 'C + Stype_0To1768C = 0x8026 # T/C S type 0~1768 'C + Ttype_Neg20To135C = 0x8027 # T/C T type -20~135 'C + + V_0To30 = 0x8028 # 0 ~ 30 V + A_0To3 = 0x8029 # 0 ~ 3 A + + Pt100_Neg50To150 = 0x802a # Pt100 -50~150 'C + Pt100_Neg200To200 = 0x802b # Pt100 -200~200 'C + Pt100_0To100 = 0x802c # Pt100 0~100 'C + Pt100_0To200 = 0x802d # Pt100 0~200 'C + Pt100_0To400 = 0x802e # Pt100 0~400 'C + Btype_300To1820C = 0x802f # T/C B type 300~1820 'C + + V_Neg12pt5To12pt5 = 0x8030 # +/- 12.5 V + + # 0xC000 ~ 0xF000 : user customized value range type + UserCustomizedVrgStart = 0xC000 + UserCustomizedVrgEnd = 0xF000 + + # AO external reference type + V_ExternalRefBipolar = 0xF001 # External reference voltage unipolar + V_ExternalRefUnipolar = 0xF002 # External reference voltage bipolar + + +class SignalPolarity(IntEnum): + Negative = 0 + Positive = 1 + + +class CountingType(IntEnum): + CountingNone = 0 + DownCount = 1 # counter value decreases on each clock + UpCount = 2 # counter value increases on each clock + PulseDirection = 3 # counting direction is determined by two signals, one is clock, the other is direction signal + TwoPulse = 4 # counting direction is determined by two signals, one is up-counting signal, the other is down-counting signal + AbPhaseX1 = 5 # AB phase, 1x rate up/down counting + AbPhaseX2 = 6 # AB phase, 2x rate up/down counting + AbPhaseX4 = 7 # AB phase, 4x rate up/down counting + + +class OutSignalType(IntEnum): + SignalOutNone = 0 # no output or output is 'disabled' + ChipDefined = 1 # hardware chip defined + NegChipDefined = 2 # hardware chip defined, negative logical + PositivePulse = 3 # a low-to-high pulse + NegativePulse = 4 # a high-to-low pulse + ToggledFromLow = 5 # the level toggled from low to high + ToggledFromHigh = 6 # the level toggled from high to low + + +class CounterCapability(IntEnum): + Primary = 1 + InstantEventCount = 2 + OneShot = 3 + TimerPulse = 4 + InstantFreqMeter = 5 + InstantPwmIn = 6 + InstantPwmOut = 7 + UpDownCount = 8 + BufferedEventCount = 9 + BufferedPwmIn = 10 + BufferedPwmOut = 11 + BufferedUpDownCount = 12 + InstantEdgeSeparation = 13 + + +class CounterOperationMode(IntEnum): + C8254_M0 = 0 # 8254 mode 0, interrupt on terminal count + C8254_M1 = 1 # 8254 mode 1, hardware retriggerable one-shot + C8254_M2 = 2 # 8254 mode 2, rate generator + C8254_M3 = 3 # 8254 mode 3, square save mode + C8254_M4 = 4 # 8254 mode 4, software triggered strobe + C8254_M5 = 5 # 8254 mode 5, hardware triggered strobe + + C1780_MA = 6 # Mode A level & pulse out, Software-Triggered without Hardware Gating + C1780_MB = 7 # Mode B level & pulse out, Software-Triggered with Level Gating, = 8254_M0 + C1780_MC = 8 # Mode C level & pulse out, Hardware-triggered strobe level + C1780_MD = 9 # Mode D level & Pulse out, Rate generate with no hardware gating + C1780_ME = 10 # Mode E level & pulse out, Rate generator with level Gating + C1780_MF = 11 # Mode F level & pulse out, Non-retriggerable One-shot (Pulse type = 8254_M1) + C1780_MG = 12 # Mode G level & pulse out, Software-triggered delayed pulse one-shot + C1780_MH = 13 # Mode H level & pulse out, Software-triggered delayed pulse one-shot with hardware gating + C1780_MI = 14 # Mode I level & pulse out, Hardware-triggered delay pulse strobe + C1780_MJ = 15 # Mode J level & pulse out, Variable Duty Cycle Rate Generator with No Hardware Gating + C1780_MK = 16 # Mode K level & pulse out, Variable Duty Cycle Rate Generator with Level Gating + C1780_ML = 17 # Mode L level & pulse out, Hardware-Triggered Delayed Pulse One-Shot + C1780_MO = 18 # Mode O level & pulse out, Hardware-Triggered Strobe with Edge Disarm + C1780_MR = 19 # Mode R level & pulse out, Non-Retriggerbale One-Shot with Edge Disarm + C1780_MU = 20 # Mode U level & pulse out, Hardware-Triggered Delayed Pulse Strobe with Edge Disarm + C1780_MX = 21 # Mode X level & pulse out, Hardware-Triggered Delayed Pulse One-Shot with Edge Disarm + + +class CounterValueRegister(IntEnum): + CntLoad = 0 + CntPreset = 0 + CntHold = 1 + CntOverCompare = 2 + CntUnderCompare = 3 + + +class CounterCascadeGroup(IntEnum): + GroupNone = 0 # no cascade + Cnt0Cnt1 = 1 # Counter 0 as first, counter 1 as second. + Cnt2Cnt3 = 2 # Counter 2 as first, counter 3 as second + Cnt4Cnt5 = 3 # Counter 4 as first, counter 5 as second + Cnt6Cnt7 = 4 # Counter 6 as first, counter 7 as second + + +class FreqMeasureMethod(IntEnum): + AutoAdaptive = 0 # Intelligently select the measurement method according to the input signal. + CountingPulseBySysTime = 1 # Using system timing clock to calculate the frequency + CountingPulseByDevTime = 2 # Using the device timing clock to calculate the frequency + PeriodInverse = 3 # Calculate the frequency from the period of the signal + + +class ActiveSignal(IntEnum): + ActiveNone = 0 + RisingEdge = 1 + FallingEdge = 2 + BothEdge = 3 + HighLevel = 4 + LowLevel = 5 + + +class TriggerAction(IntEnum): + ActionNone = 0 # No action to take even if the trigger condition is satisfied + DelayToStart = 1 # Begin to start after the specified time is elapsed if the trigger condition is satisfied + DelayToStop = 2 # Stop execution after the specified time is elapsed if the trigger condition is satisfied + Mark = 3 # Generate a mark data + + +class SignalPosition(IntEnum): + InternalSig = 0 + OnConnector = 1 + OnAmsi = 2 + + +class SignalDrop(IntEnum): + SignalNone = 0 # No connection + + # Internal signal connector + SigInternalClock = 1 # Device built-in clock, If the device has several built-in clock, this represent the highest freq one. + SigInternal1KHz = 2 # Device built-in clock, 1KHz + SigInternal10KHz = 3 # Device built-in clock, 10KHz + SigInternal100KHz = 4 # Device built-in clock, 100KHz + SigInternal1MHz = 5 # Device built-in clock, 1MHz + SigInternal10MHz = 6 # Device built-in clock, 10MHz + SigInternal20MHz = 7 # Device built-in clock, 20MHz + SigInternal30MHz = 8 # Device built-in clock, 30MHz + SigInternal40MHz = 9 # Device built-in clock, 40MHz + SigInternal50MHz = 10 # Device built-in clock, 50MHz + SigInternal60MHz = 11 # Device built-in clock, 60MHz + + SigDiPatternMatch = 12 # When DI pattern match occurred + SigDiStatusChange = 13 # When DI status change occurred + + # Function pin on connector + SigExtAnaClock = 14 # Analog clock pin of connector + SigExtAnaScanClock = 15 # scan clock pin of connector + SigExtAnaTrigger = 16 # external analog trigger pin of connector + SigExtAnaTrigger0 = 16, # external analog trigger pin of connector 0 + SigExtDigClock = 17 # digital clock pin of connector + SigExtDigTrigger0 = 18 # external digital trigger 0 pin(or DI start trigger pin) of connector + SigExtDigTrigger1 = 19 # external digital trigger 1 pin(or DI stop trigger pin) of connector + SigExtDigTrigger2 = 20 # external digital trigger 2 pin(or DO start trigger pin) of connector + SigExtDigTrigger3 = 21 # external digital trigger 3 pin(or DO stop trigger pin) of connector + SigCHFrzDo = 22 # Channel freeze DO ports pin + + # Signal source or target on the connector + # AI channel pins + SigAi0 = 23 + SigAi1 = 24 + SigAi2 = 25 + SigAi3 = 26 + SigAi4 = 27 + SigAi5 = 28 + SigAi6 = 29 + SigAi7 = 30 + SigAi8 = 31 + SigAi9 = 32 + SigAi10 = 33 + SigAi11 = 34 + SigAi12 = 35 + SigAi13 = 36 + SigAi14 = 37 + SigAi15 = 38 + SigAi16 = 39 + SigAi17 = 40 + SigAi18 = 41 + SigAi19 = 42 + SigAi20 = 43 + SigAi21 = 44 + SigAi22 = 45 + SigAi23 = 46 + SigAi24 = 47 + SigAi25 = 48 + SigAi26 = 49 + SigAi27 = 50 + SigAi28 = 51 + SigAi29 = 52 + SigAi30 = 53 + SigAi31 = 54 + SigAi32 = 55 + SigAi33 = 56 + SigAi34 = 57 + SigAi35 = 58 + SigAi36 = 59 + SigAi37 = 60 + SigAi38 = 61 + SigAi39 = 62 + SigAi40 = 63 + SigAi41 = 64 + SigAi42 = 65 + SigAi43 = 66 + SigAi44 = 67 + SigAi45 = 68 + SigAi46 = 69 + SigAi47 = 70, + SigAi48 = 71 + SigAi49 = 72 + SigAi50 = 73 + SigAi51 = 74 + SigAi52 = 75 + SigAi53 = 76 + SigAi54 = 77 + SigAi55 = 78 + SigAi56 = 79 + SigAi57 = 80 + SigAi58 = 81 + SigAi59 = 82 + SigAi60 = 83 + SigAi61 = 84 + SigAi62 = 85 + SigAi63 = 86 + + # AO channel pins + SigAo0 = 87 + SigAo1 = 88 + SigAo2 = 89 + SigAo3 = 90 + SigAo4 = 91 + SigAo5 = 92 + SigAo6 = 93 + SigAo7 = 94 + SigAo8 = 95 + SigAo9 = 96 + SigAo10 = 97 + SigAo11 = 98 + SigAo12 = 99 + SigAo13 = 100 + SigAo14 = 101 + SigAo15 = 102 + SigAo16 = 103 + SigAo17 = 104 + SigAo18 = 105 + SigAo19 = 106 + SigAo20 = 107 + SigAo21 = 108 + SigAo22 = 109 + SigAo23 = 110 + SigAo24 = 111 + SigAo25 = 112 + SigAo26 = 113 + SigAo27 = 114 + SigAo28 = 115 + SigAo29 = 116 + SigAo30 = 117 + SigAo31 = 118 + + # DI pins + SigDi0 = 119 + SigDi1 = 120 + SigDi2 = 121 + SigDi3 = 122 + SigDi4 = 123 + SigDi5 = 124 + SigDi6 = 125 + SigDi7 = 126 + SigDi8 = 127 + SigDi9 = 128 + SigDi10 = 129 + SigDi11 = 130 + SigDi12 = 131 + SigDi13 = 132 + SigDi14 = 133 + SigDi15 = 134 + SigDi16 = 135 + SigDi17 = 136 + SigDi18 = 137 + SigDi19 = 138 + SigDi20 = 139 + SigDi21 = 140 + SigDi22 = 141 + SigDi23 = 142 + SigDi24 = 143 + SigDi25 = 144 + SigDi26 = 145 + SigDi27 = 146 + SigDi28 = 147 + SigDi29 = 148 + SigDi30 = 149 + SigDi31 = 150 + SigDi32 = 151 + SigDi33 = 152 + SigDi34 = 153 + SigDi35 = 154 + SigDi36 = 155 + SigDi37 = 156 + SigDi38 = 157 + SigDi39 = 158 + SigDi40 = 159 + SigDi41 = 160 + SigDi42 = 161 + SigDi43 = 162 + SigDi44 = 163 + SigDi45 = 164 + SigDi46 = 165 + SigDi47 = 166 + SigDi48 = 167 + SigDi49 = 168 + SigDi50 = 169 + SigDi51 = 170 + SigDi52 = 171 + SigDi53 = 172 + SigDi54 = 173 + SigDi55 = 174 + SigDi56 = 175 + SigDi57 = 176 + SigDi58 = 177 + SigDi59 = 178 + SigDi60 = 179 + SigDi61 = 180 + SigDi62 = 181 + SigDi63 = 182 + SigDi64 = 183 + SigDi65 = 184 + SigDi66 = 185 + SigDi67 = 186 + SigDi68 = 187 + SigDi69 = 188 + SigDi70 = 189 + SigDi71 = 190 + SigDi72 = 191 + SigDi73 = 192 + SigDi74 = 193 + SigDi75 = 194 + SigDi76 = 195 + SigDi77 = 196 + SigDi78 = 197 + SigDi79 = 198 + SigDi80 = 199 + SigDi81 = 200 + SigDi82 = 201 + SigDi83 = 202 + SigDi84 = 203 + SigDi85 = 204 + SigDi86 = 205 + SigDi87 = 206 + SigDi88 = 207 + SigDi89 = 208 + SigDi90 = 209 + SigDi91 = 210 + SigDi92 = 211 + SigDi93 = 212 + SigDi94 = 213 + SigDi95 = 214 + SigDi96 = 215 + SigDi97 = 216 + SigDi98 = 217 + SigDi99 = 218 + SigDi100 = 219 + SigDi101 = 220 + SigDi102 = 221 + SigDi103 = 222 + SigDi104 = 223 + SigDi105 = 224 + SigDi106 = 225 + SigDi107 = 226 + SigDi108 = 227 + SigDi109 = 228 + SigDi110 = 229 + SigDi111 = 230 + SigDi112 = 231 + SigDi113 = 232 + SigDi114 = 233 + SigDi115 = 234 + SigDi116 = 235 + SigDi117 = 236 + SigDi118 = 237 + SigDi119 = 238 + SigDi120 = 239 + SigDi121 = 240 + SigDi122 = 241 + SigDi123 = 242 + SigDi124 = 243 + SigDi125 = 244 + SigDi126 = 245 + SigDi127 = 246 + SigDi128 = 247 + SigDi129 = 248 + SigDi130 = 249 + SigDi131 = 250 + SigDi132 = 251 + SigDi133 = 252 + SigDi134 = 253 + SigDi135 = 254 + SigDi136 = 255 + SigDi137 = 256 + SigDi138 = 257 + SigDi139 = 258 + SigDi140 = 259 + SigDi141 = 260 + SigDi142 = 261 + SigDi143 = 262 + SigDi144 = 263 + SigDi145 = 264 + SigDi146 = 265 + SigDi147 = 266 + SigDi148 = 267 + SigDi149 = 268 + SigDi150 = 269 + SigDi151 = 270 + SigDi152 = 271 + SigDi153 = 272 + SigDi154 = 273 + SigDi155 = 274 + SigDi156 = 275 + SigDi157 = 276 + SigDi158 = 277 + SigDi159 = 278 + SigDi160 = 279 + SigDi161 = 280 + SigDi162 = 281 + SigDi163 = 282 + SigDi164 = 283 + SigDi165 = 284 + SigDi166 = 285 + SigDi167 = 286 + SigDi168 = 287 + SigDi169 = 288 + SigDi170 = 289 + SigDi171 = 290 + SigDi172 = 291 + SigDi173 = 292 + SigDi174 = 293 + SigDi175 = 294 + SigDi176 = 295 + SigDi177 = 296 + SigDi178 = 297 + SigDi179 = 298 + SigDi180 = 299 + SigDi181 = 300 + SigDi182 = 301 + SigDi183 = 302 + SigDi184 = 303 + SigDi185 = 304 + SigDi186 = 305 + SigDi187 = 306 + SigDi188 = 307 + SigDi189 = 308 + SigDi190 = 309 + SigDi191 = 310 + SigDi192 = 311 + SigDi193 = 312 + SigDi194 = 313 + SigDi195 = 314 + SigDi196 = 315 + SigDi197 = 316 + SigDi198 = 317 + SigDi199 = 318 + SigDi200 = 319 + SigDi201 = 320 + SigDi202 = 321 + SigDi203 = 322 + SigDi204 = 323 + SigDi205 = 324 + SigDi206 = 325 + SigDi207 = 326 + SigDi208 = 327 + SigDi209 = 328 + SigDi210 = 329 + SigDi211 = 330 + SigDi212 = 331 + SigDi213 = 332 + SigDi214 = 333 + SigDi215 = 334 + SigDi216 = 335 + SigDi217 = 336 + SigDi218 = 337 + SigDi219 = 338 + SigDi220 = 339 + SigDi221 = 340 + SigDi222 = 341 + SigDi223 = 342 + SigDi224 = 343 + SigDi225 = 344 + SigDi226 = 345 + SigDi227 = 346 + SigDi228 = 347 + SigDi229 = 348 + SigDi230 = 349 + SigDi231 = 350 + SigDi232 = 351 + SigDi233 = 352 + SigDi234 = 353 + SigDi235 = 354 + SigDi236 = 355 + SigDi237 = 356 + SigDi238 = 357 + SigDi239 = 358 + SigDi240 = 359 + SigDi241 = 360 + SigDi242 = 361 + SigDi243 = 362 + SigDi244 = 363 + SigDi245 = 364 + SigDi246 = 365 + SigDi247 = 366 + SigDi248 = 367 + SigDi249 = 368 + SigDi250 = 369 + SigDi251 = 370 + SigDi252 = 371 + SigDi253 = 372 + SigDi254 = 373 + SigDi255 = 374 + + # DIO pins + SigDio0 = 375 + SigDio1 = 376 + SigDio2 = 377 + SigDio3 = 378 + SigDio4 = 379 + SigDio5 = 380 + SigDio6 = 381 + SigDio7 = 382 + SigDio8 = 383 + SigDio9 = 384 + SigDio10 = 385 + SigDio11 = 386 + SigDio12 = 387 + SigDio13 = 388 + SigDio14 = 389 + SigDio15 = 390 + SigDio16 = 391 + SigDio17 = 392 + SigDio18 = 393 + SigDio19 = 394 + SigDio20 = 395 + SigDio21 = 396 + SigDio22 = 397 + SigDio23 = 398 + SigDio24 = 399 + SigDio25 = 400 + SigDio26 = 401 + SigDio27 = 402 + SigDio28 = 403 + SigDio29 = 404 + SigDio30 = 405 + SigDio31 = 406 + SigDio32 = 407 + SigDio33 = 408 + SigDio34 = 409 + SigDio35 = 410 + SigDio36 = 411 + SigDio37 = 412 + SigDio38 = 413 + SigDio39 = 414 + SigDio40 = 415 + SigDio41 = 416 + SigDio42 = 417 + SigDio43 = 418 + SigDio44 = 419 + SigDio45 = 420 + SigDio46 = 421 + SigDio47 = 422 + SigDio48 = 423 + SigDio49 = 424 + SigDio50 = 425 + SigDio51 = 426 + SigDio52 = 427 + SigDio53 = 428 + SigDio54 = 429 + SigDio55 = 430 + SigDio56 = 431 + SigDio57 = 432 + SigDio58 = 433 + SigDio59 = 434 + SigDio60 = 435 + SigDio61 = 436 + SigDio62 = 437 + SigDio63 = 438 + SigDio64 = 439 + SigDio65 = 440 + SigDio66 = 441 + SigDio67 = 442 + SigDio68 = 443 + SigDio69 = 444 + SigDio70 = 445 + SigDio71 = 446 + SigDio72 = 447 + SigDio73 = 448 + SigDio74 = 449 + SigDio75 = 450 + SigDio76 = 451 + SigDio77 = 452 + SigDio78 = 453 + SigDio79 = 454 + SigDio80 = 455 + SigDio81 = 456 + SigDio82 = 457 + SigDio83 = 458 + SigDio84 = 459 + SigDio85 = 460 + SigDio86 = 461 + SigDio87 = 462 + SigDio88 = 463 + SigDio89 = 464 + SigDio90 = 465 + SigDio91 = 466 + SigDio92 = 467 + SigDio93 = 468 + SigDio94 = 469 + SigDio95 = 470 + SigDio96 = 471 + SigDio97 = 472 + SigDio98 = 473 + SigDio99 = 474 + SigDio100 = 475 + SigDio101 = 476 + SigDio102 = 477 + SigDio103 = 478 + SigDio104 = 479 + SigDio105 = 480 + SigDio106 = 481 + SigDio107 = 482 + SigDio108 = 483 + SigDio109 = 484 + SigDio110 = 485 + SigDio111 = 486 + SigDio112 = 487 + SigDio113 = 488 + SigDio114 = 489 + SigDio115 = 490 + SigDio116 = 491 + SigDio117 = 492 + SigDio118 = 493 + SigDio119 = 494 + SigDio120 = 495 + SigDio121 = 496 + SigDio122 = 497 + SigDio123 = 498 + SigDio124 = 499 + SigDio125 = 500 + SigDio126 = 501 + SigDio127 = 502 + SigDio128 = 503 + SigDio129 = 504 + SigDio130 = 505 + SigDio131 = 506 + SigDio132 = 507 + SigDio133 = 508 + SigDio134 = 509 + SigDio135 = 510 + SigDio136 = 511 + SigDio137 = 512 + SigDio138 = 513 + SigDio139 = 514 + SigDio140 = 515 + SigDio141 = 516 + SigDio142 = 517 + SigDio143 = 518 + SigDio144 = 519 + SigDio145 = 520 + SigDio146 = 521 + SigDio147 = 522 + SigDio148 = 523 + SigDio149 = 524 + SigDio150 = 525 + SigDio151 = 526 + SigDio152 = 527 + SigDio153 = 528 + SigDio154 = 529 + SigDio155 = 530 + SigDio156 = 531 + SigDio157 = 532 + SigDio158 = 533 + SigDio159 = 534 + SigDio160 = 535 + SigDio161 = 536 + SigDio162 = 537 + SigDio163 = 538 + SigDio164 = 539 + SigDio165 = 540 + SigDio166 = 541 + SigDio167 = 542 + SigDio168 = 543 + SigDio169 = 544 + SigDio170 = 545 + SigDio171 = 546 + SigDio172 = 547 + SigDio173 = 548 + SigDio174 = 549 + SigDio175 = 550 + SigDio176 = 551 + SigDio177 = 552 + SigDio178 = 553 + SigDio179 = 554 + SigDio180 = 555 + SigDio181 = 556 + SigDio182 = 557 + SigDio183 = 558 + SigDio184 = 559 + SigDio185 = 560 + SigDio186 = 561 + SigDio187 = 562 + SigDio188 = 563 + SigDio189 = 564 + SigDio190 = 565 + SigDio191 = 566 + SigDio192 = 567 + SigDio193 = 568 + SigDio194 = 569 + SigDio195 = 570 + SigDio196 = 571 + SigDio197 = 572 + SigDio198 = 573 + SigDio199 = 574 + SigDio200 = 575 + SigDio201 = 576 + SigDio202 = 577 + SigDio203 = 578 + SigDio204 = 579 + SigDio205 = 580 + SigDio206 = 581 + SigDio207 = 582 + SigDio208 = 583 + SigDio209 = 584 + SigDio210 = 585 + SigDio211 = 586 + SigDio212 = 587 + SigDio213 = 588 + SigDio214 = 589 + SigDio215 = 590 + SigDio216 = 591 + SigDio217 = 592 + SigDio218 = 593 + SigDio219 = 594 + SigDio220 = 595 + SigDio221 = 596 + SigDio222 = 597 + SigDio223 = 598 + SigDio224 = 599 + SigDio225 = 600 + SigDio226 = 601 + SigDio227 = 602 + SigDio228 = 603 + SigDio229 = 604 + SigDio230 = 605 + SigDio231 = 606 + SigDio232 = 607 + SigDio233 = 608 + SigDio234 = 609 + SigDio235 = 610 + SigDio236 = 611 + SigDio237 = 612 + SigDio238 = 613 + SigDio239 = 614 + SigDio240 = 615 + SigDio241 = 616 + SigDio242 = 617 + SigDio243 = 618 + SigDio244 = 619 + SigDio245 = 620 + SigDio246 = 621 + SigDio247 = 622 + SigDio248 = 623 + SigDio249 = 624 + SigDio250 = 625 + SigDio251 = 626 + SigDio252 = 627 + SigDio253 = 628 + SigDio254 = 629 + SigDio255 = 630 + + # Counter clock pins + SigCntClk0 = 631 + SigCntClk1 = 632 + SigCntClk2 = 633 + SigCntClk3 = 634 + SigCntClk4 = 635 + SigCntClk5 = 636 + SigCntClk6 = 637 + SigCntClk7 = 638 + + # counter gate pins + SigCntGate0 = 639 + SigCntGate1 = 640 + SigCntGate2 = 641 + SigCntGate3 = 642 + SigCntGate4 = 643 + SigCntGate5 = 644 + SigCntGate6 = 645 + SigCntGate7 = 646 + + # counter out pins + SigCntOut0 = 647 + SigCntOut1 = 648 + SigCntOut2 = 649 + SigCntOut3 = 650 + SigCntOut4 = 651 + SigCntOut5 = 652 + SigCntOut6 = 653 + SigCntOut7 = 654 + + # counter frequency out pins + SigCntFout0 = 655 + SigCntFout1 = 656 + SigCntFout2 = 657 + SigCntFout3 = 658 + SigCntFout4 = 659 + SigCntFout5 = 660 + SigCntFout6 = 661 + SigCntFout7 = 662 + + # AMSI pins + SigAmsiPin0 = 663 + SigAmsiPin1 = 664 + SigAmsiPin2 = 665 + SigAmsiPin3 = 666 + SigAmsiPin4 = 667 + SigAmsiPin5 = 668 + SigAmsiPin6 = 669 + SigAmsiPin7 = 670 + SigAmsiPin8 = 671 + SigAmsiPin9 = 672 + SigAmsiPin10 = 673 + SigAmsiPin11 = 674 + SigAmsiPin12 = 675 + SigAmsiPin13 = 676 + SigAmsiPin14 = 677 + SigAmsiPin15 = 678 + SigAmsiPin16 = 679 + SigAmsiPin17 = 680 + SigAmsiPin18 = 681 + SigAmsiPin19 = 682 + + # new clocks + SigInternal2Hz = 683 # Device built-in clock, 2Hz + SigInternal20Hz = 684 # Device built-in clock, 20Hz + SigInternal200Hz = 685 # Device built-in clock, 200KHz + SigInternal2KHz = 686 # Device built-in clock, 2KHz + SigInternal20KHz = 687 # Device built-in clock, 20KHz + SigInternal200KHz = 688 # Device built-in clock, 200KHz + SigInternal2MHz = 689 # Device built-in clock, 2MHz + + # New Function pin on connector + SigExtAnaTrigger1 = 690 # external analog trigger pin of connector 1 + + # Reference clock + SigExtDigRefClock = 691 # digital clock pin of connector + SigInternal100MHz = 692 + SigAiConvClock = 693 + + # digital trigger from master after ADC latency + SigExtDigTrgAdcLatency = 694 + SigExtDigTrg0AdcLatency = SigExtDigTrgAdcLatency, + SigExtDigTrg1AdcLatency = 695 + + # digital trigger from master/MSDI pin after ADC latency + SigMDSITrg0 = 696 + SigMDSITrg1 = 697 + + SigMDSITrg0AdcLatency = 698 + SigMDSITrg1AdcLatency = 699 + + # reference clock source from master/MDSI pin + SigMDSIRefClock = 700 + SigMDSIClock = 701 + + # clock source & trigger for Master/Slave module + # internal clock x, as a master module + SigIntClock0 = 702 + SigIntClock1 = 703 + SigIntClock2 = 704 + SigIntClock3 = 705 + + # clock from internal clock x, as a slave module + SigIntClk0Slv = 706 + SigIntClk1Slv = 707 + SigIntClk2Slv = 708 + SigIntClk3Slv = 709 + + # Trigger x from trigger pin, as a slave module + SigExtDigTrg0Slv = 710 + SigExtDigTrg1Slv = 711 + SigExtDigTrg2Slv = 712 + SigExtDigTrg3Slv = 713 + + +class EventId(IntEnum): + EvtDeviceRemoved = 0 # The device was removed from system + EvtDeviceReconnected = 1 # The device is reconnected + EvtPropertyChanged = 2 # Some properties of the device were changed + # ----------------------------------------------------------------- + # AI events + # ----------------------------------------------------------------- + EvtBufferedAiDataReady = 3 + EvtBufferedAiOverrun = 4 + EvtBufferedAiCacheOverflow = 5 + EvtBufferedAiStopped = 6 + + # ----------------------------------------------------------------- + # AO event IDs + # ----------------------------------------------------------------- + EvtBufferedAoDataTransmitted = 7 + EvtBufferedAoUnderrun = 8 + EvtBufferedAoCacheEmptied = 9 + EvtBufferedAoTransStopped = 10 + EvtBufferedAoStopped = 11 + + # ----------------------------------------------------------------- + # DIO event IDs + # ----------------------------------------------------------------- + EvtDiInterrupt = 12 + EvtDiintChannel000 = EvtDiInterrupt + EvtDiintChannel001 = 13 + EvtDiintChannel002 = 14 + EvtDiintChannel003 = 15 + EvtDiintChannel004 = 16 + EvtDiintChannel005 = 17 + EvtDiintChannel006 = 18 + EvtDiintChannel007 = 19 + EvtDiintChannel008 = 20 + EvtDiintChannel009 = 21 + EvtDiintChannel010 = 22 + EvtDiintChannel011 = 23 + EvtDiintChannel012 = 24 + EvtDiintChannel013 = 25 + EvtDiintChannel014 = 26 + EvtDiintChannel015 = 27 + EvtDiintChannel016 = 28 + EvtDiintChannel017 = 29 + EvtDiintChannel018 = 30 + EvtDiintChannel019 = 31 + EvtDiintChannel020 = 32 + EvtDiintChannel021 = 33 + EvtDiintChannel022 = 34 + EvtDiintChannel023 = 35 + EvtDiintChannel024 = 36 + EvtDiintChannel025 = 37 + EvtDiintChannel026 = 38 + EvtDiintChannel027 = 39 + EvtDiintChannel028 = 40 + EvtDiintChannel029 = 41 + EvtDiintChannel030 = 42 + EvtDiintChannel031 = 43 + EvtDiintChannel032 = 44 + EvtDiintChannel033 = 45 + EvtDiintChannel034 = 46 + EvtDiintChannel035 = 47 + EvtDiintChannel036 = 48 + EvtDiintChannel037 = 49 + EvtDiintChannel038 = 50 + EvtDiintChannel039 = 51 + EvtDiintChannel040 = 52 + EvtDiintChannel041 = 53 + EvtDiintChannel042 = 54 + EvtDiintChannel043 = 55 + EvtDiintChannel044 = 56 + EvtDiintChannel045 = 57 + EvtDiintChannel046 = 58 + EvtDiintChannel047 = 59 + EvtDiintChannel048 = 60 + EvtDiintChannel049 = 61 + EvtDiintChannel050 = 62 + EvtDiintChannel051 = 63 + EvtDiintChannel052 = 64 + EvtDiintChannel053 = 65 + EvtDiintChannel054 = 66 + EvtDiintChannel055 = 67 + EvtDiintChannel056 = 68 + EvtDiintChannel057 = 69 + EvtDiintChannel058 = 70 + EvtDiintChannel059 = 71 + EvtDiintChannel060 = 72 + EvtDiintChannel061 = 73 + EvtDiintChannel062 = 74 + EvtDiintChannel063 = 75 + EvtDiintChannel064 = 76 + EvtDiintChannel065 = 77 + EvtDiintChannel066 = 78 + EvtDiintChannel067 = 79 + EvtDiintChannel068 = 80 + EvtDiintChannel069 = 81 + EvtDiintChannel070 = 82 + EvtDiintChannel071 = 83 + EvtDiintChannel072 = 84 + EvtDiintChannel073 = 85 + EvtDiintChannel074 = 86 + EvtDiintChannel075 = 87 + EvtDiintChannel076 = 88 + EvtDiintChannel077 = 89 + EvtDiintChannel078 = 90 + EvtDiintChannel079 = 91 + EvtDiintChannel080 = 92 + EvtDiintChannel081 = 93 + EvtDiintChannel082 = 94 + EvtDiintChannel083 = 95 + EvtDiintChannel084 = 96 + EvtDiintChannel085 = 97 + EvtDiintChannel086 = 98 + EvtDiintChannel087 = 99 + EvtDiintChannel088 = 100 + EvtDiintChannel089 = 101 + EvtDiintChannel090 = 102 + EvtDiintChannel091 = 103 + EvtDiintChannel092 = 104 + EvtDiintChannel093 = 105 + EvtDiintChannel094 = 106 + EvtDiintChannel095 = 107 + EvtDiintChannel096 = 108 + EvtDiintChannel097 = 109 + EvtDiintChannel098 = 110 + EvtDiintChannel099 = 111 + EvtDiintChannel100 = 112 + EvtDiintChannel101 = 113 + EvtDiintChannel102 = 114 + EvtDiintChannel103 = 115 + EvtDiintChannel104 = 116 + EvtDiintChannel105 = 117 + EvtDiintChannel106 = 118 + EvtDiintChannel107 = 119 + EvtDiintChannel108 = 120 + EvtDiintChannel109 = 121 + EvtDiintChannel110 = 122 + EvtDiintChannel111 = 123 + EvtDiintChannel112 = 124 + EvtDiintChannel113 = 125 + EvtDiintChannel114 = 126 + EvtDiintChannel115 = 127 + EvtDiintChannel116 = 128 + EvtDiintChannel117 = 129 + EvtDiintChannel118 = 130 + EvtDiintChannel119 = 131 + EvtDiintChannel120 = 132 + EvtDiintChannel121 = 133 + EvtDiintChannel122 = 134 + EvtDiintChannel123 = 135 + EvtDiintChannel124 = 136 + EvtDiintChannel125 = 137 + EvtDiintChannel126 = 138 + EvtDiintChannel127 = 139 + EvtDiintChannel128 = 140 + EvtDiintChannel129 = 141 + EvtDiintChannel130 = 142 + EvtDiintChannel131 = 143 + EvtDiintChannel132 = 144 + EvtDiintChannel133 = 145 + EvtDiintChannel134 = 146 + EvtDiintChannel135 = 147 + EvtDiintChannel136 = 148 + EvtDiintChannel137 = 149 + EvtDiintChannel138 = 150 + EvtDiintChannel139 = 151 + EvtDiintChannel140 = 152 + EvtDiintChannel141 = 153 + EvtDiintChannel142 = 154 + EvtDiintChannel143 = 155 + EvtDiintChannel144 = 156 + EvtDiintChannel145 = 157 + EvtDiintChannel146 = 158 + EvtDiintChannel147 = 159 + EvtDiintChannel148 = 160 + EvtDiintChannel149 = 161 + EvtDiintChannel150 = 162 + EvtDiintChannel151 = 163 + EvtDiintChannel152 = 164 + EvtDiintChannel153 = 165 + EvtDiintChannel154 = 166 + EvtDiintChannel155 = 167 + EvtDiintChannel156 = 168 + EvtDiintChannel157 = 169 + EvtDiintChannel158 = 170 + EvtDiintChannel159 = 171 + EvtDiintChannel160 = 172 + EvtDiintChannel161 = 173 + EvtDiintChannel162 = 174 + EvtDiintChannel163 = 175 + EvtDiintChannel164 = 176 + EvtDiintChannel165 = 177 + EvtDiintChannel166 = 178 + EvtDiintChannel167 = 179 + EvtDiintChannel168 = 180 + EvtDiintChannel169 = 181 + EvtDiintChannel170 = 182 + EvtDiintChannel171 = 183 + EvtDiintChannel172 = 184 + EvtDiintChannel173 = 185 + EvtDiintChannel174 = 186 + EvtDiintChannel175 = 187 + EvtDiintChannel176 = 188 + EvtDiintChannel177 = 189 + EvtDiintChannel178 = 190 + EvtDiintChannel179 = 191 + EvtDiintChannel180 = 192 + EvtDiintChannel181 = 193 + EvtDiintChannel182 = 194 + EvtDiintChannel183 = 195 + EvtDiintChannel184 = 196 + EvtDiintChannel185 = 197 + EvtDiintChannel186 = 198 + EvtDiintChannel187 = 199 + EvtDiintChannel188 = 200 + EvtDiintChannel189 = 201 + EvtDiintChannel190 = 202 + EvtDiintChannel191 = 203 + EvtDiintChannel192 = 204 + EvtDiintChannel193 = 205 + EvtDiintChannel194 = 206 + EvtDiintChannel195 = 207 + EvtDiintChannel196 = 208 + EvtDiintChannel197 = 209 + EvtDiintChannel198 = 210 + EvtDiintChannel199 = 211 + EvtDiintChannel200 = 212 + EvtDiintChannel201 = 213 + EvtDiintChannel202 = 214 + EvtDiintChannel203 = 215 + EvtDiintChannel204 = 216 + EvtDiintChannel205 = 217 + EvtDiintChannel206 = 218 + EvtDiintChannel207 = 219 + EvtDiintChannel208 = 220 + EvtDiintChannel209 = 221 + EvtDiintChannel210 = 222 + EvtDiintChannel211 = 223 + EvtDiintChannel212 = 224 + EvtDiintChannel213 = 225 + EvtDiintChannel214 = 226 + EvtDiintChannel215 = 227 + EvtDiintChannel216 = 228 + EvtDiintChannel217 = 229 + EvtDiintChannel218 = 230 + EvtDiintChannel219 = 231 + EvtDiintChannel220 = 232 + EvtDiintChannel221 = 233 + EvtDiintChannel222 = 234 + EvtDiintChannel223 = 235 + EvtDiintChannel224 = 236 + EvtDiintChannel225 = 237 + EvtDiintChannel226 = 238 + EvtDiintChannel227 = 239 + EvtDiintChannel228 = 240 + EvtDiintChannel229 = 241 + EvtDiintChannel230 = 242 + EvtDiintChannel231 = 243 + EvtDiintChannel232 = 244 + EvtDiintChannel233 = 245 + EvtDiintChannel234 = 246 + EvtDiintChannel235 = 247 + EvtDiintChannel236 = 248 + EvtDiintChannel237 = 249 + EvtDiintChannel238 = 250 + EvtDiintChannel239 = 251 + EvtDiintChannel240 = 252 + EvtDiintChannel241 = 253 + EvtDiintChannel242 = 254 + EvtDiintChannel243 = 255 + EvtDiintChannel244 = 256 + EvtDiintChannel245 = 257 + EvtDiintChannel246 = 258 + EvtDiintChannel247 = 259 + EvtDiintChannel248 = 260 + EvtDiintChannel249 = 261 + EvtDiintChannel250 = 262 + EvtDiintChannel251 = 263 + EvtDiintChannel252 = 264 + EvtDiintChannel253 = 265 + EvtDiintChannel254 = 266 + EvtDiintChannel255 = 267 + + EvtDiStatusChange = 268 + EvtDiCosintPort000 = EvtDiStatusChange + EvtDiCosintPort001 = 269 + EvtDiCosintPort002 = 270 + EvtDiCosintPort003 = 271 + EvtDiCosintPort004 = 272 + EvtDiCosintPort005 = 273 + EvtDiCosintPort006 = 274 + EvtDiCosintPort007 = 275 + EvtDiCosintPort008 = 276 + EvtDiCosintPort009 = 277 + EvtDiCosintPort010 = 278 + EvtDiCosintPort011 = 279 + EvtDiCosintPort012 = 280 + EvtDiCosintPort013 = 281 + EvtDiCosintPort014 = 282 + EvtDiCosintPort015 = 283 + EvtDiCosintPort016 = 284 + EvtDiCosintPort017 = 285 + EvtDiCosintPort018 = 286 + EvtDiCosintPort019 = 287 + EvtDiCosintPort020 = 288 + EvtDiCosintPort021 = 289 + EvtDiCosintPort022 = 290 + EvtDiCosintPort023 = 291 + EvtDiCosintPort024 = 292 + EvtDiCosintPort025 = 293 + EvtDiCosintPort026 = 294 + EvtDiCosintPort027 = 295 + EvtDiCosintPort028 = 296 + EvtDiCosintPort029 = 297 + EvtDiCosintPort030 = 298 + EvtDiCosintPort031 = 299 + + EvtDiPatternMatch = 300 + EvtDiPmintPort000 = EvtDiPatternMatch + EvtDiPmintPort001 = 301 + EvtDiPmintPort002 = 302 + EvtDiPmintPort003 = 303 + EvtDiPmintPort004 = 304 + EvtDiPmintPort005 = 305 + EvtDiPmintPort006 = 306 + EvtDiPmintPort007 = 307 + EvtDiPmintPort008 = 308 + EvtDiPmintPort009 = 309 + EvtDiPmintPort010 = 310 + EvtDiPmintPort011 = 311 + EvtDiPmintPort012 = 312 + EvtDiPmintPort013 = 313 + EvtDiPmintPort014 = 314 + EvtDiPmintPort015 = 315 + EvtDiPmintPort016 = 316 + EvtDiPmintPort017 = 317 + EvtDiPmintPort018 = 318 + EvtDiPmintPort019 = 319 + EvtDiPmintPort020 = 320 + EvtDiPmintPort021 = 321 + EvtDiPmintPort022 = 322 + EvtDiPmintPort023 = 323 + EvtDiPmintPort024 = 324 + EvtDiPmintPort025 = 325 + EvtDiPmintPort026 = 326 + EvtDiPmintPort027 = 327 + EvtDiPmintPort028 = 328 + EvtDiPmintPort029 = 329 + EvtDiPmintPort030 = 330 + EvtDiPmintPort031 = 331 + + EvtBufferedDiDataReady = 332 + EvtBufferedDiOverrun = 333 + EvtBufferedDiCacheOverflow = 334 + EvtBufferedDiStopped = 335 + + EvtBufferedDoDataTransmitted = 336 + EvtBufferedDoUnderrun = 337 + EvtBufferedDoCacheEmptied = 338 + EvtBufferedDoTransStopped = 339 + EvtBufferedDoStopped = 340 + + EvtReflectWdtOccured = 341 + + # ----------------------------------------------------------------- + # Counter/Timer event IDs + # ----------------------------------------------------------------- + EvtCntTerminalCount0 = 342 + EvtCntTerminalCount1 = 343 + EvtCntTerminalCount2 = 344 + EvtCntTerminalCount3 = 345 + EvtCntTerminalCount4 = 346 + EvtCntTerminalCount5 = 347 + EvtCntTerminalCount6 = 348 + EvtCntTerminalCount7 = 349 + + EvtCntOverCompare0 = 350 + EvtCntOverCompare1 = 351 + EvtCntOverCompare2 = 352 + EvtCntOverCompare3 = 353 + EvtCntOverCompare4 = 354 + EvtCntOverCompare5 = 355 + EvtCntOverCompare6 = 356 + EvtCntOverCompare7 = 357 + + EvtCntUnderCompare0 = 358 + EvtCntUnderCompare1 = 359 + EvtCntUnderCompare2 = 360 + EvtCntUnderCompare3 = 361 + EvtCntUnderCompare4 = 362 + EvtCntUnderCompare5 = 363 + EvtCntUnderCompare6 = 364 + EvtCntUnderCompare7 = 365 + + EvtCntEcOverCompare0 = 366 + EvtCntEcOverCompare1 = 367 + EvtCntEcOverCompare2 = 368 + EvtCntEcOverCompare3 = 369 + EvtCntEcOverCompare4 = 370 + EvtCntEcOverCompare5 = 371 + EvtCntEcOverCompare6 = 372 + EvtCntEcOverCompare7 = 373 + + EvtCntEcUnderCompare0 = 374 + EvtCntEcUnderCompare1 = 375 + EvtCntEcUnderCompare2 = 376 + EvtCntEcUnderCompare3 = 377 + EvtCntEcUnderCompare4 = 378 + EvtCntEcUnderCompare5 = 379 + EvtCntEcUnderCompare6 = 380 + EvtCntEcUnderCompare7 = 381 + + EvtCntOneShot0 = 382 + EvtCntOneShot1 = 383 + EvtCntOneShot2 = 384 + EvtCntOneShot3 = 385 + EvtCntOneShot4 = 386 + EvtCntOneShot5 = 387 + EvtCntOneShot6 = 388 + EvtCntOneShot7 = 389 + + EvtCntTimer0 = 390 + EvtCntTimer1 = 391 + EvtCntTimer2 = 392 + EvtCntTimer3 = 393 + EvtCntTimer4 = 394 + EvtCntTimer5 = 395 + EvtCntTimer6 = 396 + EvtCntTimer7 = 397 + + EvtCntPwmInOverflow0 = 398 + EvtCntPwmInOverflow1 = 399 + EvtCntPwmInOverflow2 = 400 + EvtCntPwmInOverflow3 = 401 + EvtCntPwmInOverflow4 = 402 + EvtCntPwmInOverflow5 = 403 + EvtCntPwmInOverflow6 = 404 + EvtCntPwmInOverflow7 = 405 + + EvtUdIndex0 = 406 + EvtUdIndex1 = 407 + EvtUdIndex2 = 408 + EvtUdIndex3 = 409 + EvtUdIndex4 = 410 + EvtUdIndex5 = 411 + EvtUdIndex6 = 412 + EvtUdIndex7 = 413 + + EvtCntPatternMatch0 = 414 + EvtCntPatternMatch1 = 415 + EvtCntPatternMatch2 = 416 + EvtCntPatternMatch3 = 417 + EvtCntPatternMatch4 = 418 + EvtCntPatternMatch5 = 419 + EvtCntPatternMatch6 = 420 + EvtCntPatternMatch7 = 421 + + EvtCntCompareTableEnd0 = 422 + EvtCntCompareTableEnd1 = 423 + EvtCntCompareTableEnd2 = 424 + EvtCntCompareTableEnd3 = 425 + EvtCntCompareTableEnd4 = 426 + EvtCntCompareTableEnd5 = 427 + EvtCntCompareTableEnd6 = 428 + EvtCntCompareTableEnd7 = 429 + + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + # v1.1: new event of AI + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx# + EvtBufferedAiBurnOut = 430 + EvtBufferedAiTimeStampOverrun = 431 + EvtBufferedAiTimeStampCacheOverflow = 432 + EvtBufferedAiMarkOverrun = 433 + EvtBufferedAiConvStopped = 434 # Reserved for later using + + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + # v1.2: new event of Buffered Counter + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + EvtCiDataReady = 435 + EvtCiDataReady0 = EvtCiDataReady + EvtCiDataReady1 = 436 + EvtCiDataReady2 = 437 + EvtCiDataReady3 = 438 + EvtCiDataReady4 = 439 + EvtCiDataReady5 = 440 + EvtCiDataReady6 = 441 + EvtCiDataReady7 = 442 + + EvtCiOverrun = 443 + EvtCiOverrun0 = EvtCiOverrun + EvtCiOverrun1 = 444 + EvtCiOverrun2 = 445 + EvtCiOverrun3 = 446 + EvtCiOverrun4 = 447 + EvtCiOverrun5 = 448 + EvtCiOverrun6 = 449 + EvtCiOverrun7 = 450 + + EvtCiCacheOverflow = 451 + EvtCiCacheOverflow0 = EvtCiCacheOverflow + EvtCiCacheOverflow1 = 452 + EvtCiCacheOverflow2 = 453 + EvtCiCacheOverflow3 = 454 + EvtCiCacheOverflow4 = 455 + EvtCiCacheOverflow5 = 456 + EvtCiCacheOverflow6 = 457 + EvtCiCacheOverflow7 = 458 + + EvtCoDataTransmitted = 459 + EvtCoDataTransmitted0 = EvtCoDataTransmitted + EvtCoDataTransmitted1 = 460 + EvtCoDataTransmitted2 = 461 + EvtCoDataTransmitted3 = 462 + EvtCoDataTransmitted4 = 463 + EvtCoDataTransmitted5 = 464 + EvtCoDataTransmitted6 = 465 + EvtCoDataTransmitted7 = 466 + + EvtCoUnderrun = 467 + EvtCoUnderrun0 = EvtCoUnderrun + EvtCoUnderrun1 = 468 + EvtCoUnderrun2 = 469 + EvtCoUnderrun3 = 470 + EvtCoUnderrun4 = 471 + EvtCoUnderrun5 = 472 + EvtCoUnderrun6 = 473 + EvtCoUnderrun7 = 474 + + EvtCoCacheEmptied = 475 + EvtCoCacheEmptied0 = EvtCoCacheEmptied + EvtCoCacheEmptied1 = 476 + EvtCoCacheEmptied2 = 477 + EvtCoCacheEmptied3 = 478 + EvtCoCacheEmptied4 = 479 + EvtCoCacheEmptied5 = 480 + EvtCoCacheEmptied6 = 481 + EvtCoCacheEmptied7 = 482 + + EvtCoTransStopped = 483 + EvtCoTransStopped0 = EvtCoTransStopped + EvtCoTransStopped1 = 484 + EvtCoTransStopped2 = 485 + EvtCoTransStopped3 = 486 + EvtCoTransStopped4 = 487 + EvtCoTransStopped5 = 488 + EvtCoTransStopped6 = 489 + EvtCoTransStopped7 = 490 + + EvtCntrStopped = 491 + EvtCntrStopped0 = EvtCntrStopped + EvtCntrStopped1 = 492 + EvtCntrStopped2 = 493 + EvtCntrStopped3 = 494 + EvtCntrStopped4 = 495 + EvtCntrStopped5 = 496 + EvtCntrStopped6 = 497 + EvtCntrStopped7 = 498 + + +class ErrorCode(Enum): + # + # The operation is completed successfully. + # + Success = 0 + + # ************************************************************************ + # warning + # ************************************************************************ + # + # The interrupt resource is not available. + # + WarningIntrNotAvailable = 0xA0000000 + + # + # The parameter is out of the range. + # + WarningParamOutOfRange = 0xA0000001 + + # + # The property value is out of range. + # + WarningPropValueOutOfRange = 0xA0000002 + + # + # The property value is not supported. + # + WarningPropValueNotSpted = 0xA0000003 + + # + # The property value conflicts with the current state. + # + WarningPropValueConflict = 0xA0000004 + + # + # The value range of all channels in a group should be same, + # such as 4~20mA of PCI-1724. + # + WarningVrgOfGroupNotSame = 0xA0000005 + + # + # Some properties of a property set are failed to be written into device. + # + # + WarningPropPartialFailed = 0xA0000006 + + # + # The operation had been stopped. + # + # + WarningFuncStopped = 0xA0000007 + + # + # The operation is time-out. + # + # + WarningFuncTimeout = 0xA0000008 + + # + # The cache is over-run. + # + # + WarningCacheOverflow = 0xA0000009 + + # + # The channel is burn-out. + # + # + WarningBurnout = 0xA000000A + + # + # The current data record is end. + # + # + WarningRecordEnd = 0xA000000B + + # + # The specified profile is not valid. + # + # + WarningProfileNotValid = 0xA000000C + + # *********************************************************************** + # error + # *********************************************************************** + # + # The handle is NULL or its type doesn't match the required operation. + # + ErrorHandleNotValid = 0xE0000000 + + # + # The parameter value is out of range. + # + ErrorParamOutOfRange = 0xE0000001 + + # + # The parameter value is not supported. + # + ErrorParamNotSpted = 0xE0000002 + + # + # The parameter value format is not the expected. + # + ErrorParamFmtUnexpted = 0xE0000003 + + # + # Not enough memory is available to complete the operation. + # + ErrorMemoryNotEnough = 0xE0000004 + + # + # The data buffer is null. + # + ErrorBufferIsNull = 0xE0000005 + + # + # The data buffer is too small for the operation. + # + ErrorBufferTooSmall = 0xE0000006 + + # + # The data length exceeded the limitation. + # + ErrorDataLenExceedLimit = 0xE0000007 + + # + # The required function is not supported. + # + ErrorFuncNotSpted = 0xE0000008 + + # + # The required event is not supported. + # + ErrorEventNotSpted = 0xE0000009 + + # + # The required property is not supported. + # + ErrorPropNotSpted = 0xE000000A + + # + # The required property is read-only. + # + ErrorPropReadOnly = 0xE000000B + + # + # The specified property value conflicts with the current state. + # + ErrorPropValueConflict = 0xE000000C + + # + # The specified property value is out of range. + # + ErrorPropValueOutOfRange = 0xE000000D + + # + # The specified property value is not supported. + # + ErrorPropValueNotSpted = 0xE000000E + + # + # The handle hasn't own the privilege of the operation the user wanted. + # + ErrorPrivilegeNotHeld = 0xE000000F + + # + # The required privilege is not available because someone else had own it. + # + ErrorPrivilegeNotAvailable = 0xE0000010 + + # + # The driver of specified device was not found. + # + ErrorDriverNotFound = 0xE0000011 + + # + # The driver version of the specified device mismatched. + # + ErrorDriverVerMismatch = 0xE0000012 + + # + # The loaded driver count exceeded the limitation. + # + ErrorDriverCountExceedLimit = 0xE0000013 + + # + # The device is not opened. + # + ErrorDeviceNotOpened = 0xE0000014 + + # + # The required device does not exist. + # + ErrorDeviceNotExist = 0xE0000015 + + # + # The required device is unrecognized by driver. + # + ErrorDeviceUnrecognized = 0xE0000016 + + # + # The configuration data of the specified device is lost or unavailable. + # + ErrorConfigDataLost = 0xE0000017 + + # + # The function is not initialized and can't be started. + # + ErrorFuncNotInited = 0xE0000018 + + # + # The function is busy. + # + ErrorFuncBusy = 0xE0000019 + + # + # The interrupt resource is not available. + # + ErrorIntrNotAvailable = 0xE000001A + + # + # The DMA channel is not available. + # + ErrorDmaNotAvailable = 0xE000001B + + # + # Time out when reading/writing the device. + # + ErrorDeviceIoTimeOut = 0xE000001C + + # + # The given signature does not match with the device current one. + # + ErrorSignatureNotMatch = 0xE000001D + + # + # The function cannot be executed while the buffered AI is running. + # + ErrorFuncConflictWithBfdAi = 0xE000001E + + # + # The value range is not available in single-ended mode. + # + ErrorVrgNotAvailableInSeMode = 0xE000001F + + # + # The value range is not available in 50omh input impedance mode.. + # + ErrorVrgNotAvailableIn50ohmMode = 0xE0000020 + + # + # The coupling type is not available in 50omh input impedance mode.. + # + ErrorCouplingNotAvailableIn50ohmMode = 0xE0000021 + + # + # The coupling type is not available in IEPE mode. + # + ErrorCouplingNotAvailableInIEPEMode = 0xE0000022 + + # + # The Communication is failed when reading/writing the device. + # + ErrorDeviceCommunicationFailed = 0xE0000023 + + # + # The device's 'fix number' conflicted with other device's + # + ErrorFixNumberConflict = 0xE0000024 + + # + # The Trigger source conflicted with other trigger configuration + # + ErrorTrigSrcConflict = 0xE0000025 + + # + # All properties of a property set are failed to be written into device. + # + ErrorPropAllFailed = 0xE0000026 + + # + # Undefined error + # + ErrorUndefined = 0xE000FFFF + + @staticmethod + def lookup(value): + value = value & 0xFFFFFFFF + for code in ErrorCode: + if value == code.value: + return code + return ErrorCode.ErrorUndefined + + # def toInt(self): + # return self.value + # + # def toString(self): + # return AdxEnumToString("ErrorCode", self.value, 256) + + +class ProductId(IntEnum): + BD_DEMO = 0x00 # demo board + BD_PCL818 = 0x05 # PCL-818 board + BD_PCL818H = 0x11 # PCL-818H + BD_PCL818L = 0x21 # PCL-818L + BD_PCL818HG = 0x22 # PCL-818HG + BD_PCL818HD = 0x2b # PCL-818HD + BD_PCM3718 = 0x37 # PCM-3718 + BD_PCM3724 = 0x38 # PCM-3724 + BD_PCM3730 = 0x5a # PCM-3730 + BD_PCI1750 = 0x5e # PCI-1750 + BD_PCI1751 = 0x5f # PCI-1751 + BD_PCI1710 = 0x60 # PCI-1710 + BD_PCI1712 = 0x61 # PCI-1712 + BD_PCI1710HG = 0x67 # PCI-1710HG + BD_PCI1711 = 0x73 # PCI-1711 + BD_PCI1711L = 0x75 # PCI-1711L + BD_PCI1713 = 0x68 # PCI-1713 + BD_PCI1753 = 0x69 # PCI-1753 + BD_PCI1760 = 0x6a # PCI-1760 + BD_PCI1720 = 0x6b # PCI-1720 + BD_PCM3718H = 0x6d # PCM-3718H + BD_PCM3718HG = 0x6e # PCM-3718HG + BD_PCI1716 = 0x74 # PCI-1716 + BD_PCI1731 = 0x75 # PCI-1731 + BD_PCI1754 = 0x7b # PCI-1754 + BD_PCI1752 = 0x7c # PCI-1752 + BD_PCI1756 = 0x7d # PCI-1756 + BD_PCM3725 = 0x7f # PCM-3725 + BD_PCI1762 = 0x80 # PCI-1762 + BD_PCI1721 = 0x81 # PCI-1721 + BD_PCI1761 = 0x82 # PCI-1761 + BD_PCI1723 = 0x83 # PCI-1723 + BD_PCI1730 = 0x87 # PCI-1730 + BD_PCI1733 = 0x88 # PCI-1733 + BD_PCI1734 = 0x89 # PCI-1734 + BD_PCI1710L = 0x90 # PCI-1710L + BD_PCI1710HGL = 0x91 # PCI-1710HGL + BD_PCM3712 = 0x93 # PCM-3712 + BD_PCM3723 = 0x94 # PCM-3723 + BD_PCI1780 = 0x95 # PCI-1780 + BD_MIC3756 = 0x96 # MIC-3756 + BD_PCI1755 = 0x97 # PCI-1755 + BD_PCI1714 = 0x98 # PCI-1714 + BD_PCI1757 = 0x99 # PCI-1757 + BD_MIC3716 = 0x9A # MIC-3716 + BD_MIC3761 = 0x9B # MIC-3761 + BD_MIC3753 = 0x9C # MIC-3753 + BD_MIC3780 = 0x9D # MIC-3780 + BD_PCI1724 = 0x9E # PCI-1724 + BD_PCI1758UDI = 0xA3 # PCI-1758UDI + BD_PCI1758UDO = 0xA4 # PCI-1758UDO + BD_PCI1747 = 0xA5 # PCI-1747 + BD_PCM3780 = 0xA6 # PCM-3780 + BD_MIC3747 = 0xA7 # MIC-3747 + BD_PCI1758UDIO = 0xA8 # PCI-1758UDIO + BD_PCI1712L = 0xA9 # PCI-1712L + BD_PCI1763UP = 0xAC # PCI-1763UP + BD_PCI1736UP = 0xAD # PCI-1736UP + BD_PCI1714UL = 0xAE # PCI-1714UL + BD_MIC3714 = 0xAF # MIC-3714 + BD_PCM3718HO = 0xB1 # PCM-3718HO + BD_PCI1741U = 0xB3 # PCI-1741U + BD_MIC3723 = 0xB4 # MIC-3723 + BD_PCI1718HDU = 0xB5 # PCI-1718HDU + BD_MIC3758DIO = 0xB6 # MIC-3758DIO + BD_PCI1727U = 0xB7 # PCI-1727U + BD_PCI1718HGU = 0xB8 # PCI-1718HGU + BD_PCI1715U = 0xB9 # PCI-1715U + BD_PCI1716L = 0xBA # PCI-1716L + BD_PCI1735U = 0xBB # PCI-1735U + BD_USB4711 = 0xBC # USB4711 + BD_PCI1737U = 0xBD # PCI-1737U + BD_PCI1739U = 0xBE # PCI-1739U + BD_PCI1742U = 0xC0 # PCI-1742U + BD_USB4718 = 0xC6 # USB-4718 + BD_MIC3755 = 0xC7 # MIC3755 + BD_USB4761 = 0xC8 # USB4761 + BD_PCI1784 = 0XCC # PCI-1784 + BD_USB4716 = 0xCD # USB4716 + BD_PCI1752U = 0xCE # PCI-1752U + BD_PCI1752USO = 0xCF # PCI-1752USO + BD_USB4751 = 0xD0 # USB4751 + BD_USB4751L = 0xD1 # USB4751L + BD_USB4750 = 0xD2 # USB4750 + BD_MIC3713 = 0xD3 # MIC-3713 + BD_USB4711A = 0xD8 # USB4711A + BD_PCM3753P = 0xD9 # PCM3753P + BD_PCM3784 = 0xDA # PCM3784 + BD_PCM3761I = 0xDB # PCM-3761I + BD_MIC3751 = 0xDC # MIC-3751 + BD_PCM3730I = 0xDD # PCM-3730I + BD_PCM3813I = 0xE0 # PCM-3813I + BD_PCIE1744 = 0xE1 # PCIE-1744 + BD_PCI1730U = 0xE2 # PCI-1730U + BD_PCI1760U = 0xE3 # PCI-1760U + BD_MIC3720 = 0xE4 # MIC-3720 + BD_PCM3810I = 0xE9 # PCM-3810I + BD_USB4702 = 0xEA # USB4702 + BD_USB4704 = 0xEB # USB4704 + BD_PCM3810I_HG = 0xEC # PCM-3810I_HG + BD_PCI1713U = 0xED # PCI-1713U + + # !!!BioDAQ only Product ID starts from here!!! + BD_PCI1706U = 0x800 + BD_PCI1706MSU = 0x801 + BD_PCI1706UL = 0x802 + BD_PCIE1752 = 0x803 + BD_PCIE1754 = 0x804 + BD_PCIE1756 = 0x805 + BD_MIC1911 = 0x806 + BD_MIC3750 = 0x807 + BD_MIC3711 = 0x808 + BD_PCIE1730 = 0x809 + BD_PCI1710_ECU = 0x80A + BD_PCI1720_ECU = 0x80B + BD_PCIE1760 = 0x80C + BD_PCIE1751 = 0x80D + BD_ECUP1706 = 0x80E + BD_PCIE1753 = 0x80F + BD_PCIE1810 = 0x810 + BD_ECUP1702L = 0x811 + BD_PCIE1816 = 0x812 + BD_PCM27D24DI = 0x813 + BD_PCIE1816H = 0x814 + BD_PCIE1840 = 0x815 + BD_PCL725 = 0x816 + BD_PCI176E = 0x817 + BD_PCIE1802 = 0x818 + BD_AIISE730 = 0x819 + BD_PCIE1812 = 0x81A + BD_MIC1810 = 0x81B + BD_PCIE1802L = 0x81C + BD_PCIE1813 = 0x81D + BD_PCIE1840L = 0x81E + BD_PCIE1730H = 0x81F + BD_PCIE1756H = 0x820 + BD_PCIERXM01 = 0x821 # PCIe-RXM01 + BD_MIC1816 = 0x822 + BD_USB5830 = 0x823 + BD_USB5850 = 0x824 + BD_USB5860 = 0x825 + BD_VPX1172 = 0x826 + BD_USB5855 = 0x827 + BD_USB5856 = 0x828 + BD_USB5862 = 0x829 + BD_PCIE1840T = 0x82A + BD_AudioCard = 0x82B + BD_AIIS1750 = 0x82C + BD_PCIE1840HL = 0x82D + BD_PCIE1765 = 0x82E + BD_PCIE1761H = 0x82F + BD_PCIE1762H = 0x830 + BD_PCIE1884 = 0x831 + BD_PCIE1758DIO = 0x832 + BD_PCIE1758DI = 0x833 + BD_PCIE1758DO = 0x834 + + # + BD_USB5817 = 0x835 + BD_USB5801 = 0x836 + BD_PCM2731 = 0x837 + BD_MOS1110 = 0x838 + BD_PCIE1750UH = 0x839 + BD_PCIE1750U = 0x83A + BD_USB5820 = 0x83B + + # + BD_THK1710R = 0x83C + BD_PCIE1803 = 0x83D + BD_PCIE1824 = 0x83E + BD_PCIE1805 = 0x83F + + # + BD_MIOE1747 = 0x840 + BD_ECUP1710 = 0x841 + BD_PCIE1824L = 0x842 + + # + BD_PCIE1763AH = 0x843 + BD_PCIE1763DH = 0x844 + + # + BD_MIC1816B = 0x845 + + # + BD_SUSIGPIO = 0x846 + + # + BD_MIC1810B = 0x847 + + # iDAQ series + BD_IDAQ731 = 0x848 + BD_IDAQ763D = 0x849 + BD_IDAQ817 = 0x84A + BD_IDAQ821 = 0x84B + + # + BD_EAPIGPIO = 0x84C + + # iDAQ series + BD_IDAQ841 = 0x84D + BD_IDAQ801 = 0x84E + + # WISE-5000 starts from here + BD_WISE5051 = 0x901 + BD_WISE5056 = 0x902 + BD_WISE5056SO = 0x903 + BD_WISE5015 = 0x904 + BD_WISE5017 = 0x905 + BD_WISE5018 = 0x906 + BD_WISE5024 = 0x907 + BD_WISE5080 = 0x908 + BD_WISE5074 = 0x909 + BD_WISE5001 = 0x90A + BD_WISE5052 = 0x90B + BD_WISE5057 = 0x90C + BD_WISE5057SO = 0x90D + BD_WISE5017C = 0x90E + BD_WISE5017V = 0x90F + BD_WISE5079 = 0x910 + + BD_AMAX5051 = 0x911 + BD_AMAX5056 = 0x912 + BD_AMAX5056SO = 0x913 + BD_AMAX5015 = 0x914 + BD_AMAX5017 = 0x915 + BD_AMAX5018 = 0x916 + BD_AMAX5024 = 0x917 + BD_AMAX5080 = 0x918 + BD_AMAX5074 = 0x919 + BD_AMAX5001 = 0x91A + BD_AMAX5052 = 0x91B + BD_AMAX5057 = 0x91C + BD_AMAX5057SO = 0x91D + BD_AMAX5017C = 0x91E + BD_AMAX5017V = 0x91F + BD_AMAX5079 = 0x920 + + # Unknown productId + BD_UNKNOWN = -1 + + +class ControlState(IntEnum): + Idle = 0 + Ready = 1 + Running = 2 + Stopped = 3 + Uninited = -1 + + +class Scenario(IntEnum): + SceInstantAi = 1 << 0 + SceBufferedAi = 1 << 1 + SceWaveformAi = 1 << 2 + SceInstantAo = 1 << 3 + SceBufferedAo = 1 << 4 + SceInstantDi = 1 << 5 + SceInstantDo = 1 << 6 + SceEventCounter = 1 << 7 + SceFreqMeter = 1 << 8 + SceOneShot = 1 << 9 + SceTimerPulse = 1 << 10 + ScePwMeter = 1 << 11 + ScePwModulator = 1 << 12 + SceUdCounter = 1 << 13 + SceBufferedEventCounter = 1 << 14 + SceBufferedPwMeter = 1 << 15 + SceBufferedPwModulator = 1 << 16 + SceBufferedUdCounter = 1 << 17 + SceEdgeSeparation = 1 << 18 + SceBufferedDi = 1 << 19 + SceBufferedDo = 1 << 20 + SceCalibration = 1 << 21 + + +class MathInterval(Structure): + _fields_ = [ + ('Type', c_int32), + ('Min', c_double), + ('Max', c_double) + ] + + +class MapFuncPiece(Structure): + _fields_ = [ + ("Size", c_int32), # the size of structure + ("Degree", c_int32), # the polynomial degree + ("UpperLimit", c_double), # the upper limit for this scaling polynomial + ("Coef", c_double * 2) # variable length array for the coefficient of polynomial, in increasing degree + ] + + +class DataMark(Structure): + _fields_ = [ + ("DataIndex", c_int64), + ("SrcId", c_int32), + ("_reserved_", c_int32) + ] + + +class DeviceInformation(Structure): + _fields_ = [ + ("DeviceNumber", c_int32), + ("DeviceMode", c_int32), # AccessMode + ("ModuleIndex", c_int32), + ("Description", c_wchar * MAX_DEVICE_DESC_LEN) + ] + + def __init__(self, Description='', DeviceNumber=-1, DeviceMode=AccessMode.ModeWrite, ModuleIndex=0): + self.DeviceNumber = DeviceNumber + self.DeviceMode = DeviceMode + self.ModuleIndex = ModuleIndex + self.Description = Description + + +class DeviceTreeNode(Structure): + _fields_ = [ + ("DevicIntEnumber", c_int32), + ("ModulesIndex", c_int32 * 8), + ("Description", c_wchar * MAX_DEVICE_DESC_LEN) + ] + + +class DeviceEventArgs(Structure): + _fields_ = [ + ("Id", c_int32) # EventId + ] + + +class BfdAiEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32), + ("MarkCount", c_int32) + ] + + +class BfdAoEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class DiSnapEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("SrcNum", c_int32), + ("Length", c_int32), + ("PortData", c_uint8 * MAX_DIO_PORT_COUNT) + ] + + +class BfdDiEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32), + ("MarkCount", c_int32) + ] + + +class BfdDoEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class CntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Channel", c_int32) + ] + + +class UdCntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Length", c_int32), + ("Data", c_int32 * MAX_CNTR_CH_COUNT) + ] + + +class BfdCntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Channel", c_int32), + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class PulseWidth(Structure): + _fields_ = [ + ("HiPeriod", c_double), + ("LoPeriod", c_double) + ] + diff --git a/src/components/Automation/__init__.py b/src/components/Automation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/components/usb_5860.py b/src/components/usb_5860.py index 04c0c3b..df04c83 100644 --- a/src/components/usb_5860.py +++ b/src/components/usb_5860.py @@ -1,5 +1,6 @@ import ctypes import sys +import platform import time from enum import Enum @@ -8,7 +9,16 @@ from PyQt5.QtCore import QMutex, Qt, QTimer, pyqtSlot from .component import Component if "--sim-io" not in sys.argv: - libbiodaq = ctypes.CDLL("/opt/advantech/libs/libbiodaq.so") + win = platform.system() == "Windows" + + if win: + from Automation.BDaq import * + from Automation.BDaq.InstantDoCtrl import InstantDoCtrl + from Automation.BDaq.InstantDiCtrl import InstantDiCtrl + from Automation.BDaq.BDaqApi import AdxEnumToString, BioFailed + pass + else: + libbiodaq = ctypes.CDLL("/opt/advantech/libs/libbiodaq.so") else: import lib.dummies.libbiodaq as libbiodaq @@ -38,46 +48,44 @@ class USB_5860(Component): self.info.DeviceMode = 1 self.info.ModuleIndex = 0 # DIGITAL INPUTS CLASS - self.di_create = libbiodaq.AdxInstantDiCtrlCreate - self.di_create.restype = ctypes.c_void_p - self.di_setSelectedDevice = libbiodaq.InstantDiCtrl_setSelectedDevice - self.di_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] - self.di_setSelectedDevice.restype = ctypes.c_uint32 - # DIGITAL INPUTS READ FUNCTION - self.di_read = libbiodaq.InstantDiCtrl_ReadAny - self.di_read.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p] - self.di_read.restype = ctypes.c_int32 - # DIGITAL OUTPUTS CLASS - self.do_create = libbiodaq.AdxInstantDoCtrlCreate - self.do_create.restype = ctypes.c_void_p - # SET SELECTED DEVICE - self.do_setSelectedDevice = libbiodaq.InstantDoCtrl_setSelectedDevice - self.do_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] - self.do_setSelectedDevice.restype = ctypes.c_uint32 - # get ports - self.get_ports = libbiodaq.InstantDoCtrl_getPortDirection - self.get_ports.argtypes = [ctypes.c_void_p] - self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) - # # Array_getItem - # self.array_getItem = libbiodaq.TArray_getItem - # self.array_getItem.argtypes = [ctypes.c_void_p, ctypes.c_int32] - # self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) - # PortDirection_setDirection - self.port_direction_set_direction = libbiodaq.PortDirection_setDirection - self.port_direction_set_direction.argtypes = [ctypes.c_void_p, ctypes.c_uint8] - self.port_direction_set_direction.restype = ctypes.c_int32 - # DIGITAL OUTPUTS WRITE FUNCTION - self.do_write_bit = libbiodaq.InstantDoCtrl_WriteBit - self.do_write_bit.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char] - self.do_write_bit.restype = ctypes.c_int32 - self.buffer = ctypes.create_string_buffer(5) - # INIT OBJECTS - self.di_ctrl = self.di_create() - self.do_ctrl = self.do_create() - self.di_init_status = self.di_setSelectedDevice(self.di_ctrl, ctypes.byref(self.info)) - self.do_init_status = self.do_setSelectedDevice(self.do_ctrl, ctypes.byref(self.info)) - if "--sim-io" not in sys.argv: - self.dio_ports = self.get_ports(self.do_ctrl) + if win: + self.di_ctrl = InstantDiCtrl(self.info.Description) + self.do_ctrl = InstantDoCtrl(self.info.Description) + self.di_read = self.di_ctrl.readAny + self.do_write_bit = self.do_ctrl.writeBit + self.buffer = ctypes.create_string_buffer(5) + else: + self.di_create = libbiodaq.AdxInstantDiCtrlCreate + self.di_create.restype = ctypes.c_void_p + self.di_setSelectedDevice = libbiodaq.InstantDiCtrl_setSelectedDevice + self.di_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.di_setSelectedDevice.restype = ctypes.c_uint32 + # DIGITAL INPUTS READ FUNCTION + self.di_read = libbiodaq.InstantDiCtrl_ReadAny + self.di_read.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p] + self.di_read.restype = ctypes.c_int32 + # DIGITAL OUTPUTS CLASS + self.do_create = libbiodaq.AdxInstantDoCtrlCreate + self.do_create.restype = ctypes.c_void_p + # SET SELECTED DEVICE + self.do_setSelectedDevice = libbiodaq.InstantDoCtrl_setSelectedDevice + self.do_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.do_setSelectedDevice.restype = ctypes.c_uint32 + # get ports + self.get_ports = libbiodaq.InstantDoCtrl_getPortDirection + self.get_ports.argtypes = [ctypes.c_void_p] + self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) + # DIGITAL OUTPUTS WRITE FUNCTION + self.do_write_bit = libbiodaq.InstantDoCtrl_WriteBit + self.do_write_bit.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char] + self.do_write_bit.restype = ctypes.c_int32 + self.buffer = ctypes.create_string_buffer(5) + # INIT OBJECTS + self.di_ctrl = self.di_create() + self.do_ctrl = self.do_create() + self.di_init_status = self.di_setSelectedDevice(self.di_ctrl, ctypes.byref(self.info)) + self.do_init_status = self.do_setSelectedDevice(self.do_ctrl, ctypes.byref(self.info)) + # SET ALL RELAYS OFF for bit in range(0, 8): self.set_bit(0, bit, False) @@ -121,14 +129,26 @@ class USB_5860(Component): def get_all(self): return self.get() - # Read all data bytes + # Read 1 input byte def get(self): self.mutex.lock() - self.di_read(self.di_ctrl, 0, 2, self.buffer) read = [] - for byte in range(len(self.buffer)): - byte = ~int.from_bytes(self.buffer[byte], "little") - read.append([bool(byte & m) for m in self.masks]) + if win: + ret=self.di_read(0, 1 ) + if ret[0]== ErrorCode.Success: + self.buffer=ret[1] + byte = self.buffer[0] + read.append([bool(byte & m) for m in self.masks]) + + else: + self.buffer = None + else: + self.di_read(self.di_ctrl, 0, 1, self.buffer) + + for byte in range(len(self.buffer)): + byte = ~int.from_bytes(self.buffer[byte], "little") + read.append([bool(byte & m) for m in self.masks]) + self.mutex.unlock() return read @@ -146,7 +166,10 @@ class USB_5860(Component): def set_bit(self, byte, bit, val): self.mutex.lock() # print("set", byte, bit, not val, flush=True) - self.do_write_bit(self.do_ctrl, byte, bit, int(val)) + if win: + self.do_write_bit(byte, bit, int(val)) + else: + self.do_write_bit(self.do_ctrl, byte, bit, int(val)) self.mutex.unlock() # val from buffer channel From 001f71b8dcefac66fa6739cb7c2f703ba717de1a Mon Sep 17 00:00:00 2001 From: germano Date: Tue, 3 Jan 2023 17:57:14 +0100 Subject: [PATCH 5/8] usb-5862 tbt --- config/machine_settings/defaults.ini | 1 + config/machine_settings/st-ten-4.ini | 31 +++ config/machine_settings/st-ten-5.ini | 35 +++ config/machine_settings/st-ten-6.ini | 35 +++ config/machine_settings/this.ini | 33 --- designer.sh | 7 +- src/components/component.py | 3 +- src/components/{usb_5860.py => usb_586x.py} | 46 ++-- src/main.py | 4 +- src/requirements.txt | 1 + src/test/test_usb5860.py | 18 -- src/test/test_usb586x.py | 32 +++ src/ui/leak_step_editor/leak_step_editor.ui | 268 +++++++++++--------- src/ui/test/test.py | 4 +- 14 files changed, 314 insertions(+), 204 deletions(-) create mode 100644 config/machine_settings/st-ten-4.ini create mode 100644 config/machine_settings/st-ten-5.ini create mode 100644 config/machine_settings/st-ten-6.ini delete mode 100644 config/machine_settings/this.ini rename src/components/{usb_5860.py => usb_586x.py} (85%) delete mode 100644 src/test/test_usb5860.py create mode 100644 src/test/test_usb586x.py diff --git a/config/machine_settings/defaults.ini b/config/machine_settings/defaults.ini index e2baedd..8816657 100644 --- a/config/machine_settings/defaults.ini +++ b/config/machine_settings/defaults.ini @@ -13,6 +13,7 @@ galaxy_camera: absent ; uvc_camera: present ; vision_saver: present ; vision: present +digital_io: absent [galaxy_camera] horizontal_resolution: 2448 diff --git a/config/machine_settings/st-ten-4.ini b/config/machine_settings/st-ten-4.ini new file mode 100644 index 0000000..ee2b749 --- /dev/null +++ b/config/machine_settings/st-ten-4.ini @@ -0,0 +1,31 @@ +[machine] +description = ST-TEN-4 - TERMOFORMATURA MAPPANO + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 diff --git a/config/machine_settings/st-ten-5.ini b/config/machine_settings/st-ten-5.ini new file mode 100644 index 0000000..4642967 --- /dev/null +++ b/config/machine_settings/st-ten-5.ini @@ -0,0 +1,35 @@ +[machine] +description = ST-TEN-5 IVECO DAILY ELETTRICO + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present +digital_io: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 + +[digital_io] +id: USB-5862,BID#0 \ No newline at end of file diff --git a/config/machine_settings/st-ten-6.ini b/config/machine_settings/st-ten-6.ini new file mode 100644 index 0000000..779eaa4 --- /dev/null +++ b/config/machine_settings/st-ten-6.ini @@ -0,0 +1,35 @@ +[machine] +description = ST-TEN-6 DOPPIA PROVA PRESSIONE 6/20 BAR + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present +digital_io: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 + +[digital_io] +id: USB-5860,BID#0 \ No newline at end of file diff --git a/config/machine_settings/this.ini b/config/machine_settings/this.ini deleted file mode 100644 index d930d56..0000000 --- a/config/machine_settings/this.ini +++ /dev/null @@ -1,33 +0,0 @@ -[machine] -description = ~~~~~~~~~~ THIS ~~~~~~~~~~ - -[hardware_config] -archive_synchronizer: present -galaxy_camera: present -label_printer: present -multicomp: present -neo_pixels: present -remote_api: present -screwdriver: present -tecna_t3: present -uvc_camera: present -vision_saver: present -vision: present - -[tecna_t3] -model: t3l -port: /dev/ttyUSB0 -saver: present -saver_label_template: 6 -saver_print_on_fail: yes -saver_label_count: 1 - -[multicomp] -port: /dev/ttyACM0 - -[neo_pixels] -port: /dev/ttyACM1 - -[archive_synchronizer] -poll_time: 6 -hold_time: 1 diff --git a/designer.sh b/designer.sh index ffc2be7..4e7c252 100755 --- a/designer.sh +++ b/designer.sh @@ -1,6 +1,7 @@ #!/bin/bash -x cd "$(dirname "$0")" -#source "./venv/bin/activate" || source "./venv/Scripts/activate" || : +source "./venv/bin/activate" || source "./venv/Scripts/activate" || : #python3 -m pip install --upgrade qt5-tools -#"$(python3 -c "import sys; print(sys.path[-1])")/qt5_applications/Qt/bin/designer" $* -$(pwd)/venv/lib/python3.9/site-packages/qt5_applications/Qt/bin/designer $* +"$(python3 -c "import sys; print(sys.path[-1])")/qt5_applications/Qt/bin/designer" $* +#$(pwd)/venv/lib/python3.9/site-packages/qt5_applications/Qt/bin/designer $* +#$(pwd)/venv/lib/python3.8/site-packages/qt5_applications/Qt/bin/designer $* diff --git a/src/components/component.py b/src/components/component.py index 12b2392..55d9e85 100644 --- a/src/components/component.py +++ b/src/components/component.py @@ -140,7 +140,8 @@ class Component(QObject): self._set_requestors.connect(self._do_set_requestors) self._set_period.connect(self._do_set_period) if self.config is not None: - self.config.updated.connect(self.reconfigure) + if self.config.updated is not None: + self.config.updated.connect(self.reconfigure) self._do_reconfigure() self._init_periodic() self._started = True diff --git a/src/components/usb_5860.py b/src/components/usb_586x.py similarity index 85% rename from src/components/usb_5860.py rename to src/components/usb_586x.py index df04c83..bcc0fb8 100644 --- a/src/components/usb_5860.py +++ b/src/components/usb_586x.py @@ -23,13 +23,7 @@ else: import lib.dummies.libbiodaq as libbiodaq -class USB_5860(Component): - class DioPortDir(Enum): - Input = 0x00 - LoutHin = 0x0F - LinHout = 0xF0 - Output = 0xFF - +class USB_586x(Component): class DeviceInformation(ctypes.Structure): _fields_ = [ ('DeviceNumber', ctypes.c_uint32), @@ -38,13 +32,23 @@ class USB_5860(Component): ('Description', ctypes.c_wchar_p) ] - def __init__(self, bench, name, config): - super().__init__(bench, name, config) + def __init__(self, config): + super().__init__(config) self.mutex = QMutex() # DEVICE INFORMATION + self.id=config.id + if "5860" in self.id: + self.type = "5860" + self.in_size = 1 + self.out_size = 1 + if "5862" in self.id: + self.type = "5862" + self.in_size = 2 + self.out_size = 2 self.info = self.DeviceInformation() - self.info.Description = "USB-5860,BID#0" - #self.info.DeviceNumber = -1 + self.info.Description = config.id + + # self.info.DeviceNumber = -1 self.info.DeviceMode = 1 self.info.ModuleIndex = 0 # DIGITAL INPUTS CLASS @@ -87,8 +91,9 @@ class USB_5860(Component): self.do_init_status = self.do_setSelectedDevice(self.do_ctrl, ctypes.byref(self.info)) # SET ALL RELAYS OFF - for bit in range(0, 8): - self.set_bit(0, bit, False) + for bit in range(0, self.out_size*8): + self.set_bit(int(bit/8), bit%8, False) + self.state_delay = 1 self.last_get = None self.state_count = None @@ -134,19 +139,20 @@ class USB_5860(Component): self.mutex.lock() read = [] if win: - ret=self.di_read(0, 1 ) - if ret[0]== ErrorCode.Success: - self.buffer=ret[1] - byte = self.buffer[0] - read.append([bool(byte & m) for m in self.masks]) + ret = self.di_read(0, self.in_size) + if ret[0] == ErrorCode.Success: + self.buffer = ret[1] + for byte_num in range(len(self.buffer)): + byte = self.buffer[byte_num] + read.append([bool(byte & m) for m in self.masks]) else: self.buffer = None else: self.di_read(self.di_ctrl, 0, 1, self.buffer) - for byte in range(len(self.buffer)): - byte = ~int.from_bytes(self.buffer[byte], "little") + for byte_num in range(len(self.buffer)): + byte = int.from_bytes(self.buffer[byte_num], "little") read.append([bool(byte & m) for m in self.masks]) self.mutex.unlock() diff --git a/src/main.py b/src/main.py index 9cb7b16..0afd009 100644 --- a/src/main.py +++ b/src/main.py @@ -79,6 +79,7 @@ try: try: # READ CONFIG self.config = ConfigReader() + self.config["autotest_done"]=False # INIT COMPONENT self.components_specs = { "archive_synchronizer": {"c": ArchiveSynchronizer}, @@ -142,9 +143,6 @@ try: self.main_window.archive_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(Archive(hide_cloud_image="vision_saver" not in self().components))) if "--archive" in sys.argv: self.main_window.archive_a.trigger() - # self.main_window.autotests_archive_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(Autotests_Archive())) - # if "--autotests-archive" in sys.argv: - # self.main_window.autotests_archive_a.trigger() self.main_window.about_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(About())) if "--about" in sys.argv: self.main_window.about_a.trigger() diff --git a/src/requirements.txt b/src/requirements.txt index ac8abdf..f0b698e 100644 --- a/src/requirements.txt +++ b/src/requirements.txt @@ -10,6 +10,7 @@ pillow pycoral pymodbus pyqt5 +pyqt5-tools pyserial pyserial-asyncio requests diff --git a/src/test/test_usb5860.py b/src/test/test_usb5860.py deleted file mode 100644 index 4674628..0000000 --- a/src/test/test_usb5860.py +++ /dev/null @@ -1,18 +0,0 @@ -import time - -from src.components.usb_5860 import USB_5860 - -digital_io = USB_5860(None, None, None) -digital_io.start() - -out_val = 0 -while True: - res = digital_io.set_bit(0, 0, out_val) - input_data = digital_io.get() - print("in:{} out:{}".format(bytes(input_data[0]), out_val)) - - time.sleep(1) - if out_val == 0: - out_val = 1 - else: - out_val = 0 diff --git a/src/test/test_usb586x.py b/src/test/test_usb586x.py new file mode 100644 index 0000000..283c54a --- /dev/null +++ b/src/test/test_usb586x.py @@ -0,0 +1,32 @@ +import sys +import time + +from src.components.usb_586x import USB_586x + +class config: + id = None + updated= None + +if "--5862" in sys.argv: + config.id = "USB-5860,BID#0" + out_size = 16 +else: + config.id = "USB-5860,BID#0" + out_size = 8 + +digital_io = USB_586x(config) +digital_io.start() + +out_num = 0 +while True: + out_bit = out_num % 8 + out_byte = int(out_num/8) + res = digital_io.set_bit(out_byte, out_bit, 1) + time.sleep(0.5) + res2 = digital_io.set_bit(out_byte, out_bit, 0) + input_data = digital_io.get() + print("in:{} out:{}".format(bytes(input_data[0]), out_num)) + time.sleep(0.5) + out_num += 1 + if out_num == out_size: + out_num = 0 \ No newline at end of file diff --git a/src/ui/leak_step_editor/leak_step_editor.ui b/src/ui/leak_step_editor/leak_step_editor.ui index beb78ae..24acc74 100644 --- a/src/ui/leak_step_editor/leak_step_editor.ui +++ b/src/ui/leak_step_editor/leak_step_editor.ui @@ -6,27 +6,45 @@ 0 0 - 955 - 161 + 1221 + 252 Leak Step Editor - - - 0 - - - 0 - - - 0 - - - 0 - - + + + + + + 10 + 50 + false + + + + Elettrovalvole + + + + + + 9999 + + + + + + + Configurazione relè + + + + + + + @@ -39,13 +57,6 @@ Pre-Riempimento - - - - 9999 - - - @@ -81,10 +92,117 @@ + + + + 9999 + + + - + + + + + 10 + 50 + false + + + + Riempimento + + + + + + PR+ Pressione Max + + + + + + + T1: Riempimento + + + + + + + s + + + + + + + 150 + + + + + + + 9999 + + + + + + + PR- Pressione Min + + + + + + + 100 + + + + + + + % + + + + + + + % + + + + + + + T2: Assestamento + + + + + + + 9999 + + + + + + + s + + + + + + + @@ -187,107 +305,7 @@ - - - - - 10 - 50 - false - - - - Riempimento - - - - - - PR+ Pressione Max - - - - - - - T1: Riempimento - - - - - - - s - - - - - - - 150 - - - - - - - 9999 - - - - - - - PR- Pressione Min - - - - - - - 100 - - - - - - - % - - - - - - - % - - - - - - - T2: Assestamento - - - - - - - 9999 - - - - - - - s - - - - - - - + diff --git a/src/ui/test/test.py b/src/ui/test/test.py index 9a7d6b2..6adb08d 100755 --- a/src/ui/test/test.py +++ b/src/ui/test/test.py @@ -96,7 +96,8 @@ class Test(Widget): self.autotest_cycle_steps = None if "--no-autotest" not in sys.argv: self.autotest_period = 12 * 60 * 60 * 1000 - self.request_autotest("init") + if not self.config["autotest_done"]: + self.request_autotest("init") else: self.autotest_period = None # INIT TEST DATA @@ -223,6 +224,7 @@ class Test(Widget): self.autotesting = False self.autotesting_reason = None self.cycle_index = -1 + self.config["autotest_done"] = True if not self.autotesting: if len(self.cycle_steps): # goto next step in cycle_steps From 5591116c4db93e427ccfca4ce9e637e106b9e5fc Mon Sep 17 00:00:00 2001 From: germano Date: Wed, 4 Jan 2023 18:20:58 +0100 Subject: [PATCH 6/8] dev new features partial --- config/machine_settings/defaults.ini | 2 + ...riscaldati - COMPLETA rev19_29-12-2022.csv | 200 ++++++++++++++++++ ...iscaldati - COMPLETA rev19_29-12-2022.xlsx | Bin 0 -> 984066 bytes src/ui/imgs/assembly_1.jpg | Bin 2280197 -> 0 bytes src/ui/imgs/autotest_nok.png | Bin 102573 -> 0 bytes src/ui/imgs/autotest_ok.png | Bin 101725 -> 0 bytes src/ui/leak_step_editor/leak_step_editor.py | 1 + src/ui/leak_step_editor/leak_step_editor.ui | 48 ++++- src/ui/recipe_selection/recipe_selection.py | 17 +- 9 files changed, 257 insertions(+), 11 deletions(-) create mode 100644 src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv create mode 100644 src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx delete mode 100755 src/ui/imgs/assembly_1.jpg delete mode 100755 src/ui/imgs/autotest_nok.png delete mode 100755 src/ui/imgs/autotest_ok.png diff --git a/config/machine_settings/defaults.ini b/config/machine_settings/defaults.ini index 8816657..59501ec 100644 --- a/config/machine_settings/defaults.ini +++ b/config/machine_settings/defaults.ini @@ -106,6 +106,8 @@ r nominale: 1000000000 tolleranza_resistenza_pos: 10 tolleranza_resistenza_neg: 5 prova_tenuta_abilitata: x +config_elettrovalvole: 0 +warning_img: tempo_pre_riempimento: 0 pressione_pre_riempimento: 1000 tempo_riempimento: 10 diff --git a/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv new file mode 100644 index 0000000..a684d47 --- /dev/null +++ b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv @@ -0,0 +1,200 @@ +"N°","AGGIORNATO COD VOLPIANO (UT)","AGGIORNATO COD VOLPIANO (MANU)","AGGIORNATO ST VOLPIANO (GRAZIA)","Cliente","Cod FInito cliente","Cod Finito R5","Cod Semilavorato Costampato","Cod Semilavorato raccordato e cablato","Cod. ContoLavoro OLD","Tubo","Mat","L[mm]","diam[mm]","Racc. 1","Or. 1","Racc. 2","Or. 2","CE su racc.1","Connettore elettrico","W-lock","connettore","tolleranza_resistenza_pos","tolleranza_resistenza_neg","tolleranza_resistenza","tempo_assestamento","codice_a_barre","verifica_codice_a_barre_abilitata","Etichetta","etichetta interoperazionale","Immagine_warning","T alim","Serie","Volumi","Lotti di produzione","Adattatori +RS0633 e/o RS0634","NOTE","R nominale","T tolleranza disegno +/-","MIN: Potenza 30 W/m","MAX: Potenza a 15 W/m","Valore medio misurato Resistenza semilav","Note1","Note2","Aggiornata Tolleranza" +162,"x","x","x","TEREX",36000,"ND","R55510","R55510/1","36000/CL","TGAI15EL","EPDM",600,"4x13","9,49","0°","9,49","90°","CE0101","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55510/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,4 Ω",20%,"6,0","13,7","8,5",,,01/12/2022 +163,"x","x","x","TEREX",36342,"ND","R55482","R55482/1","36342/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","90°","CE0101","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,30,"R55482/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,4 Ω",25%,"1,5","3,1","2,9",,"Fare test con cavi accorciati",01/12/2022 +164,"x",,,"TEREX",36343,"ND","R55483","R55483/1","36343/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0060","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,30,"R55483/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,5 Ω",20%,"1,5","3,1",,,, +121,"x","x","x","Stauffer Diesel",59867,"ND","R55511","R55511/1","59867/CL","TGAI15EL","EPDM",1250,"4x13","6,30","90°","7,89","90°","CE0088","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55511/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"3,3","7,1","4,3",,,14/11/2022 +122,"x","x","x","Stauffer Diesel",59868,"ND","R55593","R55593/1","59868/CL","TGAI15EL","EPDM",2450,"4x13","7,89","90°","7,89","90°","CE0088","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,30,"R55593/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,7 Ω",20%,"1,8","3,8","2,7",,,01/12/2022 +12,"x","x","x","Merlo",117342,"ND","R52370","R52370/1","117342/CL","026/02EL","PA12",3000,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52370/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.000 pz/anno,,,,"3,1 Ω",20%,"1,5","3,1",3,"Modificare valore disegno","Fare test con cavi accorciati",14/11/2022 +13,"x","x","x","Merlo",117343,"ND","R52371","R52371/1","117343/CL","026/02EL","PA12",3500,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52371/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,3 Ω",20%,"1,3","2,7","3,3","Modificare valore disegno","Fare test con cavi accorciati",14/11/2022 +14,"x","x","x","Merlo",117344,"ND","R52372","R52372/1","117344/CL","026/02EL","PA12",1400,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52372/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"5,6 Ω",20%,"3,0","6,4","5,3","Modificare valore disegno",,14/11/2022 +15,"x","x","x","Merlo",117345,"ND","R52619","R52619/1","117345/CL","026/02EL","PA12",2650,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52619/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"2,9 Ω",20%,"1,7","3,5","2,7","Modificare valore disegno",,14/11/2022 +16,"x","x","x","Merlo",117346,"ND","R52620","R52620/1","117346/CL","026/02EL","PA12",1500,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52620/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.300 pz/anno,,,,"5,8 Ω",20%,"2,8","6,0","5,4","Modificare valore disegno",,29/11/2022 +17,"x","x","x","Merlo",117347,"ND","R52368","R52368/1","117347/CL","026/02EL","PA12",1400,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52368/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",4.000 pz/anno,,,,"5,7 Ω",20%,"3,0","6,4","5,2","Modificare valore disegno",,14/11/2022 +18,"x","x","x","Merlo",117536,"ND","R53214","R53214/1","117536/CL","026/02EL","PA12",860,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53214/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",150 pz/anno,,,,"6,9 Ω",20%,"4,5","10,0","6,9","Modificare valore disegno",,29/11/2022 +19,"x","x","x","Merlo",117537,"ND","R53213","R53213/1","117537/CL","026/02EL","PA12",860,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53213/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",150 pz/anno,,,,"6,9 Ω",20%,"4,5","10,0","6,9","Modificare valore disegno",,29/11/2022 +24,"x","x","x","Merlo",124938,"ND","R53919","R53919/1","124938/CL","026/02EL","PA12",1100,"6X13","9,49","0°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R53919/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",800 pz/anno,,,,"10,3 Ω",10%,"5,2","11,2","10,3","Modificare valore disegno",,29/11/2022 +25,"x","x","x","Merlo",124939,"ND","R53920","R53920/1","124939/CL","026/02EL","PA12",1200,"6X13","7,89","0°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R53920/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",800 pz/anno,,,,"8,8 Ω",10%,"4,8","10,3","8,7","Modificare valore disegno",,29/11/2022 +59,"x",,,"Merlo",125637,"ND","R54674","R54674/1","125637/CL","TGAI16EL","EPDM",2600,"3X13","6,30","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,30,"R54674/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",200 pz/anno,,,,"2,9 Ω",20%,"1,7","3,6",,,, +98,"x","x","x","Hattat",1034955,"ND","R55194","R55194/1","---","026/02EL","PA12",1470,"6X13","9,49",90,"7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55194/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"5,5 Ω",10%,"3,9","8,3",,,, +99,"x","x","x","Hattat",1034956,"ND","R55195","R55195/1","---","026/02EL","PA12",1320,"6X13","9,49",90,"9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55195/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"5,0 Ω",20%,"4,3","9,2",,,, +100,"x",,,"Hattat",1034957,"ND","R55196","R55196/1","---","TGAI15EL","EPDM",649,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R55196/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"10,3 Ω",10%,"7,7","17,4",,,, +101,"x","x","x","Hattat",1034982,"ND","R55209","R55209/1","---","TGAI15EL","EPDM",1400,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55209/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.000 pz/anno,,,,"7,4 Ω",20%,"4,1","8,7",,,,07/12/2022 +169,"x","x","x","Hattat",1035154,"ND","R55711","R55711/1","---","TGAI15EL","EPDM",1848,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55711/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"3,5 Ω",20%,"3,2","6,7",,,, +170,"x","x","x","Hattat",1035165,"ND","R55712","R55712/1","---","026/02EL","PA12",498,"6X13","9,49",90,"9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55712/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"9,0 Ω",10%,"9,4","21,9",,,, +171,"x","x","x","Hattat",1035166,"ND","R55713","R55713/1","---","026/02EL","PA12",573,"6X13","9,49",90,"7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55713/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"10,0 Ω",10%,"8,5","19,4",,,, +182,"x","x","x","Andreoli",2032061,"R54487","R55782","R55782/1 ","---","026/02EL","PA12",1624,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55782/1 -{N11}","x","ETA013L.prn","ETACL.prn","Img-02",14 V,"PRT",,,"X","Da completare con adattatori RS0633 (2x), montati","4,5 Ω",20%,"3,3","7,0",,,, +183,"x","x","x","Andreoli",2032062,"R54488","R55783","R55783/1 ","---","026/02EL","PA12",1378,"6x13","7,89","0°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55783/1 -{N11}","x","ETA013L.prn","ETACL.prn","Img-05",14 V,"PRT",,,"X","Da completare con adattatore RS0633 (1x), montato","6,7 Ω",10%,"3,8","8,2",,,, +108,"x",,,"Andreoli",2032075,"R54799","R55768","R55768/1","---","026/02EL","PA12",656,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55768/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02",14 V,"PRT",,,"X","Da completare con adattatori RS0633 (2x), montati","11,1 Ω",10%,"7,1","16,1",,,, +109,"x","x","x","Andreoli",2032076,"R54800","R55176","R55176/1","---","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55176/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",14 V,"PRT",,,"X","Da completare con adattatore RS0633 (1x), montato","5,2 Ω",20%,"3,6","7,6",,"modificare valore res disegno",, +146,"x","x","x","Tiffin",5073279,"ND","R55138","R55138/1","5073279/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",25,25,25,30,"R55138/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,5 Ω",25%,"1,5","3,1",,,,14/11/2022 +147,"x","x","x","Tiffin",5073280,"ND","R55139","R55139/1","5073280/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55139/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"3,4 Ω",20%,"2,2","4,6",,,, +148,"x","x","x","Tiffin",5073281,"ND","R55140","R55140/1","5073281/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R55140/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,1 Ω",20%,"1,8","3,7",,,, +149,"x","x","x","Tiffin",5073282,"ND","R55141","R55141/1","5073282/CL","TGAI15EL","EPDM",1000,"4x13","9,49","90°","9,49","0°","CE0084","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55141/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"7,2 Ω",20%,"4,0","8,7",,,,14/11/2022 +150,"x","x","x","Tiffin",5073283,"ND","R55142","R55142/1","5073283/CL","TGAI15EL","EPDM",3000,"4x13","9,49","0°","7,89","90°","CE0085","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",20,20,20,30,"R55142/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,4 Ω",20%,"1,5","3,1","2,6",,,01/12/2022 +151,"x","x","x","Tiffin",5073284,"ND","R55143","R55143/1","5073284/CL","TGAI15EL","EPDM",2000,"4x13","9,49","0°","7,89","90°","CE0084","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55143/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"3,3 Ω",20%,"2,2","4,6",,,, +157,"x",,,"Capacity truck",10005328,"ND","R55463","R55463/1","10005328/CL","TGAI15EL","EPDM",1650,"4x13","9,49","0°","9,49","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55463/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"2,6","5,5",,,, +158,"x",,,"Capacity truck",10006716,"ND","R55465","R55465/1","10006716/CL","TGAI15EL","EPDM",1650,"4x13","9,49","0°","9,49","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55465/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,5 Ω",20%,"2,6","5,5",,,, +159,"x","x","x","Capacity truck",10006719,"ND","R55467","R55467/1","10006719/CL","TGAI15EL","EPDM",1500,"4x13","9,49","90°","9,49","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55467/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,1 Ω",20%,"2,8","6,0","3,8",,,01/12/2022 +160,"x","x","x","Capacity truck",10006721,"ND","R55468","R55468/1","10006721/CL","TGAI15EL","EPDM",1400,"4x13","9,49","90°","7,89","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55468/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,1 Ω",20%,"3,0","6,4",,,, +1,"x","x",,"Vanhool",11519588,"ND","R52373","R52373/1","11519588/CL","026/02EL","PA12",4600,"6X13","9,49","90°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52373/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,9 Ω",10%,"4,0","8,2",,,, +2,"x","x",,"Vanhool",11519589,"ND","R52374","R52374/1","11519589/CL","026/02EL","PA12",4600,"6X13","9,49","90°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52374/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,9 Ω",10%,"4,0","8,2",,,, +3,"x","x",,"Vanhool",11519590,"ND","R52375","R52375/1","11519590/CL","026/02EL","PA12",2700,"6X13","7,89","90°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52375/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,4 Ω",10%,"6,6","13,7",,,, +184,"x",,,"Vanhool",11650477,"ND","R55393","R55393/1","11650477/CL","TGAI15EL","EPDM",4650,"4x13","7,89","0°","7,89","90°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,40,"R55393/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,5 Ω",10%,"4,0","8,1",,,, +125,"x","x","x","ENC",18020001,"ND","R55484","R55484/1","18020001/CL","TGAI15EL","EPDM",1150,"4x13","9,49","0°","9,49","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",10,10,10,20,"R55484/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,6 Ω",10%,"14,2","30,7","14,6","Modificare valore disegno",,11/11/2022 +126,"x","x","x","ENC",18020002,"ND","R55485","R55485/1","18020002/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R55485/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,7 Ω",20%,"6,0","12,4","9,3","Modificare valore disegno",,11/11/2022 +127,"x","x","x","ENC",18020003,"ND","R55486","R55486/1","18020003/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R55486/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,5 Ω",20%,"6,0","12,4","9,5","Modificare valore disegno",,11/11/2022 +56,"x","x","x","Irum",21003808,"ND","R54783","R54783/1","21.003808/CL","TGAI15EL","EPDM",1500,"4x13","7,89","0°","6,30","90°","CE0077/3","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R54783/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"5,2 Ω",20%,"2,8","6,0",,,,11/11/2022 +57,"x","x","x","Irum",21003809,"ND","R54785","R54785/1","21003809/CL","026/02EL","PA12",1000,"6X13","9,49","90°","9,49","0°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",15,15,15,10,"R54785/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"7,7 Ω",15%,"4,0","8,7","7,3",,,01/12/2022 +58,"x","x","x","Irum",21003810,"ND","R54784","R54784/1","21.003810/CL","026/02EL","PA12",1000,"6X13","7,89","90°","9,49","0°","CE0077/2","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",15,15,15,10,"R54784/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"7,7 Ω",15%,"4,0","8,7","7,1",,,01/12/2022 +139,"x",,,"Prinoth",28026891,"ND","R52972","R52972/1","28026891/CL","TGAI15EL","EPDM",2986,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52972/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,5 Ω",10%,"6,0","12,4",,,, +140,"x",,,"Prinoth",28026892,"ND","R52973","R52973/1","28026892/CL","TGAI15EL","EPDM",3177,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52973/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"10,1 Ω",10%,"5,7","11,7",,,, +141,"x",,,"Prinoth",28026894,"ND","R52975","R52975/1","28026894/CL","TGAI15EL","EPDM",2386,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52975/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,7 Ω",10%,"7,4","15,4",,,, +142,"x","x","x","Prinoth",28026895,"ND","R52976","R52976/1","28026895/CL","TGAI15EL","EPDM",2867,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52976/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,1 Ω",10%,"6,3","12,9",,,, +143,"x",,,"Prinoth",28026896,"ND","R52977","R52977/1","28026896/CL","TGAI15EL","EPDM",2166,"4x13","6,30","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52977/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,0 Ω",10%,"8,1","16,9",,,, +144,"x",,,"Prinoth",28026897,"ND","R52978","R52978/1","28026897/CL","TGAI15EL","EPDM",2216,"4x13","6,30","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52978/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,4 Ω",10%,"7,9","16,6",,,, +145,"x",,,"Prinoth",28026898,"ND","R52979","R52979/1","28026898/CL","TGAI15EL","EPDM",4697,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,40,"R52979/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,3 Ω",10%,"3,9","8,0",,,, +110,"x","x","x","Prinoth",28054860,"ND","R54345","R54345/1","28054860/CL","TGAI15EL","EPDM",1850,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R54345/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",150 pz/anno,,,,"15,7 Ω",10%,"9,4","19,7","14,6",,,01/12/2022 +111,"x","x","x","Prinoth",28054871,"ND","R54346","R54346/1","28054871/CL","TGAI15EL","EPDM",2200,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",15,15,15,30,"R54346/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",150 pz/anno,,,,"14,7 Ω",15%,"8,0","16,7","13,3",,,01/12/2022 +128,"x","x","x","Antonio Carraro",46628004,"ND","R54689","R54689/1","46628004/CL","026/02EL","PA12",800,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54689/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,8 Ω",10%,"4,8","10,7",,,,14/11/2022 +129,"x","x","x","Antonio Carraro",46628005,"ND","R54690","R54690/1","46628005/CL","TGAI15EL","EPDM",800,"4x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",15,15,15,20,"R54690/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,2 Ω",15%,"4,8","10,7",,,,14/11/2022 +130,"x","x","x","Antonio Carraro",46628006,"ND","R54691","R54691/1","46628006/CL","TGAI15EL","EPDM",550,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54691/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,1 Ω",20%,"6,4","14,8",,,,14/11/2022 +186,"x",,,"Antonio Carraro",46628007,"ND","R55258","R55258/1","46628007/CL","026/02EL","PA12",550,"6x13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55258/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,4 Ω",10%,"6,4","14,8",,,, +187,"x",,,"Antonio Carraro",46628008,"ND","R55260","R55260/1","46628008/CL","026/02EL","PA12",600,"6x13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55260/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"10,0 Ω",10%,"6,0","13,7",,,, +188,"x",,,"Antonio Carraro",46628009,"ND","R55262","R55262/1","46628009/CL","026/02EL","PA12",1470,"6x13","7,89","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55262/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,4 Ω",10%,"2,9","6,1",,,, +195,"x",,,"Manitou",52607933,"ND","R53253","R53253/1","52607933/CL","026/02EL","PA12",3300,"6X13","9,49","90°","7,89","90°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53253/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,9 Ω",10%,"1,4","2,8",,,, +196,"x",,,"Manitou",52607935,"ND","R53251","R53251/1","52607935/CL","026/02EL","PA12",3300,"6X13","9,49","90°","9,49","90°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53251/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,9 Ω",10%,"1,4","2,8",,,, +197,"x",,,"Manitou",52607941,"ND","R53252","R53252/1","52607941/CL","026/02EL","PA12",2340,"6X13","7,89","90°","7,89","0°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53252/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,1 Ω",10%,"1,9","3,9",,,, +45,"x",,,"Manitou",53003548,"ND","R54907","R54907/1","53003548/CL","026/02EL","PA12",2270,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54907/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,3 Ω",20%,"1,9","4,1",,,, +4,"x","x",,"Manitou",53020608,"ND","R52399","R52399/1","53020608/CL","026/02EL","PA12",3650,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52399/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"6,3 Ω",10%,"5,0","10,2",6,,, +5,"x","x",,"Manitou",53020610,"ND","R52400","R52400/1","53020610/CL","026/02EL","PA12",2680,"6X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52400/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"8,7 Ω",10%,"6,7","13,8","8,7","Modificare valore disegno",, +6,"x","x",,"Manitou",53020612,"ND","R52401","R52401/1","53020612/CL","026/02EL","PA12",970,"6X13","9,49","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52401/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"13,0 Ω",10%,"12,0 *","35,9","12,6",,, +7,"x","x",,"Manitou",53027246,"ND","R52452","R52452/1","53027246/CL","026/02EL","PA12",1150,"6X13","9,49","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52452/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,9 Ω",10%,"14,2","30,7","14,9","Modificare valore disegno",, +8,"x","x",,"Manitou",53027247,"ND","R52453","R52453/1","53027247/CL","026/02EL","PA12",2750,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52453/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,0 Ω",10%,"6,5","13,5",9,"Modificare valore disegno",, +9,"x","x",,"Manitou",53027248,"ND","R52454","R52454/1","53027248/CL","026/02EL","PA12",1900,"6X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52454/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"11,7 Ω",10%,"9,1","19,2","11,7","Modificare valore disegno",, +10,"x","x",,"Manitou",53027252,"ND","R52510","R52510/1","53027252/CL","026/02EL-S","PA12",750,"6X13","6,30","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52510/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"20,6 Ω",10%,"20,2","45,2",,,, +11,"x","x",,"Manitou",53027253,"ND","R52511","R52511/1","53027253/CL","026/02EL","PA12",1960,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52511/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,2 Ω",10%,"8,9","18,6",,,, +60,"x","x","x","FPT",5802933678,"ND","R54292","R54292/1","5802933678/CL","026/02EL","PA12",2000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54292/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,6 Ω",20%,"2,2","4,6",4,,,01/12/2022 +61,"x","x","x","FPT",5802933689,"ND","R54294","R54294/1","5802933689/CL","026/02EL","PA12",3000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R54294/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,6 Ω",25%,"1,5","3,1","3,1",,"Fare test con cavi accorciati",01/12/2022 +64,"X","x","x","FPT",5802933697,"ND","R54296","R54296/1","5802933697/CL","026/02EL","PA12",2000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54296/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,6 Ω",20%,"2,2","4,6","4,2",,,01/12/2022 +65,"x","x","x","FPT",5802933700,"ND","R54298","R54298/1","5802933700/CL","026/02EL","PA12",3000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R54298/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,6 Ω",25%,"1,5","3,1","3,1",,"Fare test con cavi accorciati",01/12/2022 +48,"x","x","x","FPT",5802933703,"ND","R54300","R54300/1","5802933703/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,20,"R54300/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,4 Ω",25%,"2,2","4,6","3,7",,,01/12/2022 +47,"x","x","x","FPT",5802933707,"ND","R54302","R54302/1","5802933707/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R54302/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,5 Ω",20%,"1,5","3,1",,,, +85,"x","x","x","FPT",5802938582,"ND","R54532","R54532/1","5802938582/CL","026/02EL-S","PA12",500,"6x13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54532/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",10%,"6,9","16,0","7,2",,,01/12/2022 +62,"x","x","x","FPT",5802969802,"ND","R54526","R54526/1","5802969802/CL","026/02EL","PA12",1000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54526/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,8 Ω",10%,"4,0","8,7","7,8",,,01/12/2022 +46,"x","x","x","FPT",5802969810,"ND","R54528","R54528/1","5802969810/CL","TGAI15EL","EPDM",1000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54528/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",20%,"4,0","8,7","6,4",,,13/12/2022 +63,"x","x","x","FPT",5802969811,"ND","R54530","R54530/1","5802969811/CL","026/02EL","PA12",1000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54530/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,8 Ω",10%,"4,0","8,7","7,4",,,01/12/2022 +86,"x","x","x","FPT",5802970303,"ND","R54534","R54534/1","5802970303/CL","026/02EL-S","PA12",500,"6x13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",14,14,14,10,"R54534/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",14%,"6,9","16,0","7,3",,"Aggiornata tolleranza fino a 6,3 come a disegno = potenza 36W/m", +97,"x","x","x","Bimotor"," BR5PLH1000","R54276/C4","R55717","R55717/1","R54276/C4/CL","TGAI15EL","EPDM",1000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55717/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","7,5 Ω",20%,"5,1","11,0",,,,11/11/2022 +113,"x","x","x","Otokar","13H30-32252-P4","R55677","R55603","R55603/1","13H30-32252-AA/CL","026/02EL-S","PA12",800,"6x13","9,49","90°","7,89","90°","CE0110","AMP SUPERSEAL 1.5 SERIES: 282080-1",,"SCR12",12,12,12,10,"R55603/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",250 pz/anno,,,,"21,7 Ω",12%,"19,2","42,7",,,,14/11/2022 +114,"x","x","x","Otokar","13H30-32254-P4","R55678","R55605","R55605/1","13H30-32254-AA/CL","TGAI16EL","EPDM",1800,"3x13","6,30","0°","6,30","0°","CE0110","AMP SUPERSEAL 1.5 SERIES: 282080-1",,"SCR12",20,20,20,20,"R55605/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT","250 pz/anno",,,,"15,4 Ω",20%,"9,6","20,2",,,, +115,"x","x","x","Otokar","13M26-32254-P4","R55679","R55608","R55608/1","13M26-32254-AA/CL","TGAI16EL","EPDM",2300,"3x13","6,30","0°","6,30","0°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R55608/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",250 pz/anno,,,,"11,3 Ω",20%,"7,7","16,0",,,, +116,"x","x","x","Otokar","13M65-32254-P4","R55680","R55609","R55609/1","13M65-32254-AA/CL","026/02EL","PA12",3000,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55609/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",500 pz/anno,,,,"8,4 Ω",20%,"6,0","12,4",,,, +112,"x","x","x","Otokar","13R00-32254-P4","R55676","R55602","R55602/1","13R00-32254-AA/CL","026/02EL","PA12",1200,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55602/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",1.000 pz/anno,,,,"17,6 Ω",10%,"13,7","29,5","17,6","Modificare valore disegno",, +119,"x","x","x","Otokar","13R50-32252-P4","R55683","R55612","R55612/1","13R50-32252-AA/CL","026/02EL-S","PA12",800,"6x13","9,49","90°","9,49","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",12,12,12,10,"R55612/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"21,7 Ω",12%,"19,2","42,7",,,,14/11/2022 +120,"x","x","x","Otokar","13R50-32254-P4","R55684","R55613","R55613/1","13R50-32254-AA/CL","026/02EL","PA12",2200,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55613/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"11,8 Ω",10%,"8,0","16,7",,,, +66,"x","x","x","CRANE CARRIER","145-3810","ND","R54445","R54445/1","145-3810/CL","TGAI15EL","EPDM",3200,"4x13","9,49","0°","7,89","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54445/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,6 Ω",20%,"1,4","2,9","2,5",,,01/12/2022 +67,"x","x","x","CRANE CARRIER","145-3811","ND","R54446","R54446/1","145-3811/CL","TGAI15EL","EPDM",540,"4x13","9,49","0°","9,49","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54446/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,7 Ω",20%,"6,5","15,0","7,2",,,14/11/2022 +68,"x","x","x","CRANE CARRIER","145-3812","ND","R54447","R54447/1","145-3812/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54447/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,5 Ω",20%,"1,5","3,1",,,, +69,"x","x","x","CRANE CARRIER","145-3813","ND","R54448","R54448/1","145-3813/CL","TGAI15EL","EPDM",2500,"4x13","9,49","0°","7,89","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54448/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,1 Ω",20%,"1,8","3,7",2,,,01/12/2022 +70,"x","x","x","CRANE CARRIER","145-3814","ND","R54449","R54449/1","145-3814/CL","TGAI15EL","EPDM",1000,"4x13","9,49","0°","9,49","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54449/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"7,2 Ω",20%,"4,0","8,7","6,2",,,01/12/2022 +71,"x","x","x","CRANE CARRIER","145-3815","ND","R54450","R54450/1","145-3815/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54450/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"3,4 Ω",20%,"2,2","4,6",,,, +72,"x","x","x","CRANE CARRIER","145-3830","ND","R54878","R54878/1","145-3830/CL","TGAI15EL","EPDM",500,"4x13","9,49","90°","9,49","0°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54878/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,2 Ω",20%,"6,9","16,0","6,8",,"Da verificare",01/12/2022 +73,"x",,,"CRANE CARRIER","145-3831","ND","R54879","R54879/1","145-3831/CL","TGAI15EL","EPDM",500,"4x13","9,49","90°","7,89","0°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",10,10,10,20,"R54879/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,2 Ω",10%,"6,9","16,0",,,, +117,"x","x","x","Otokar","16N60-32252-P4","R55681","R55610","R55610/1","16N60-32252-AA/CL","026/02EL","PA12",2000,"6x13","9,49","90°","9,49","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55610/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"14,4 Ω",20%,"8,7","18,3",,,, +118,"x","x","x","Otokar","16N60-32254-P4","R55682","R55611","R55611/1","16N60-32254-AA/CL","026/02EL","PA12",1700,"6x13","7,89","0°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55611/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"15,7 Ω",20%,"10,1","21,3",,,, +26,"x",,,"Venieri","180.3.827","ND","R54095","R54095/1","180.3.827/CL","026/02EL","PA12",860,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",10,10,10,10,"R54095/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"6,9 Ω",10%,"4,5","10,0",,,, +27,"x",,,"Venieri","180.3.828","ND","R53928","R53928/1","180.3.828/CL","026/02EL","PA12",2650,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53928/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,3 Ω",20%,"1,7","3,5",,,, +28,"x",,,"Venieri","180.3.829","ND","R53929","R53929/1","180.3.829/CL","026/02EL","PA12",2650,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53929/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,3 Ω",20%,"1,7","3,5",,,, +38,"x","x","x","Venieri","180.3.830","ND","R55660","R55660/1","180.3.830/CL","026/02EL","PA12",1000,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R55660/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,0 Ω",10%,"4,0","8,7",,,,14/11/2022 +39,"x","x","x","Venieri","180.3.831","ND","R55661","R55661/1","180.3.831/CL","026/02EL","PA12",1000,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R55661/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,0 Ω",10%,"4,0","8,7",,,,14/11/2022 +198,"x",,,"Venieri","180.3.832","ND","R54140","R54140/1","180.3.832/CL","026/02EL","PA12",4000,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R54140/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"3,1 Ω",20%,"1,1","2,3",,,, +105,"x",,,"Venieri","180.3.837","ND","R54788","R54788/1","180.3.837/CL","026/02EL-S","PA12",1000,"6X13","7,89","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R54788/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"26,1 Ω",10%,"16,0","34,9",,,, +106,"x",,,"Venieri","180.3.838","ND","R54789","R54789/1","180.3.838/CL","026/02EL-S","PA12",1000,"6X13","9,49","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R54789/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"26,1 Ω",10%,"16,0","34,9",,,, +107,"x",,,"Venieri","180.3.839","ND","R54790","R54790/1","180.3.839/CL","026/02EL","PA12",4000,"6X13","7,89","90°","7,89","90°","CE0065","HDSCS: 4-1418483-1",,"SCR9",20,20,20,10,"R54790/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"6,9 Ω",20%,"4,6","9,4",,,, +52,"x",,,"Merlo","19PU012_639","ND","R55202","R55202/1","ND","026/02EL","PA12",2450,"6X13","7,89","0°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R55202/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"PRT",,,,,"4,3 Ω",20%,"2,5","5,3",,,, +74,"x","x","x","INDIANA PHOENIX","465-012","ND","R55146","R55146/1","465-012/CL","TGAI15EL","EPDM",1500,"4x13","9,49","90°","9,49","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,20,"R55146/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"5,1 Ω",20%,"2,8","6,0","4,5",,,01/12/2022 +75,"x","x","x","INDIANA PHOENIX","465-013","ND","R55147","R55147/1","465-013/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55147/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"2,1 Ω",20%,"1,8","3,7",2,,,01/12/2022 +76,"x","x","x","INDIANA PHOENIX","465-014","ND","R55151","R55151/1","465-014/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55151/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"2,4 Ω",20%,"1,5","3,1","2,3",,,01/12/2022 +165,"x","x","x","INDIANA PHOENIX","465-018","R55749","R55561","R55561/1","---","TGAI15EL","EPDM",1500,"4x13","6,30","0°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,20,"R55561/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"5,2 Ω",20%,"2,8","6,0","4,4","Modificare valore disegno","Da verificare su pezzi campionatura in consegna il 25/11/22",01/12/2022 +166,"x","x","x","INDIANA PHOENIX","465-019","R55750","R55673","R55673/1","---","TGAI15EL","EPDM",3200,"4x13","9,49","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55673/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"2,6 Ω",20%,"1,4","2,9","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +167,"x","x","x","INDIANA PHOENIX","465-021","R55751","R55666","R55666/1","---","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55666/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"2,5 Ω",20%,"1,5","3,1","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +168,"x","x","x","INDIANA PHOENIX","465-022","R55753","R55752","R55752/1","---","TGAI15EL","EPDM",3400,"4x13","9,49","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55752/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,"Rifilo ridotto a 50mm per parte","2,7 Ω",20%,"1,4","2,7","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +154,"x","x","x","BCS","580B1783","ND","R55626","R55626/1","580B1783/CL","026/02EL","PA12",550,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55626/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,7 Ω",10%,"6,4","14,8",,,, +155,"x","x","x","BCS","580B1784","ND","R55627","R55627/1","580B1784/CL","026/02EL","PA12",500,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55627/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,0 Ω",10%,"6,9","16,0",,,, +192,"x",,,"BCS","580B1809","ND","R55504","R55504/1","580B1809/CL","026/02EL-S","PA12",355,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55504/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"12,0 Ω",10%,"8,6","21,1",,,, +193,"x",,,"BCS","580B1810","ND","R55505","R55505/1","580B1810/CL","026/02EL-S","PA12",385,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55505/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"12,6 Ω",10%,"8,2","19,8",,,, +194,"x",,,"BCS","580B1811","ND","R55506","R55506/1","580B1811/CL","TGAI15EL","EPDM",2017,"4x13","7,89","90°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R55506/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","3,7 Ω",20%,"2,2","4,5",,,, +156,"x","x","x","BCS","580B2270","ND","R55628","R55628/1","580B2270/CL","TGAI15EL","EPDM",1538,"4x13","7,89","90°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55628/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,2 Ω",20%,"2,8","5,9",,,, +189,"x",,,"Argo Tractors","6619812A1","R55754","R55757","R55757/1","---","026/02EL","PA12",1532,"6X13","7,89","90°","7,89","90°","CE0077/3","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",10,10,10,10,"R55757/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"4,6 Ω",10%,"2,8","5,9",,,, +190,"x",,,"Argo Tractors","6619813A1","R55755","R55758","R55758/1","---","026/02EL-S","PA12",370,"6X13","9,49","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55758/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"12,7 Ω",10%,"8,4","20,4",,,, +191,"x",,,"Argo Tractors","6619814A1","R55756","R55759","R55759/1","---","026/02EL-S","PA12",473,"6X13","9,49","90°","9,49","90°","CE0077/2","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",10,10,10,10,"R55759/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"14,5 Ω",10%,"7,1","16,8",,,, +29,"x","x","x","Argo Tractors","6671546A3","ND","R54313","R54313/1","6671546A3/CL","026/02EL","PA12",855,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54313/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"10,3 Ω",10%,"4,5","10,1",,,, +30,"x","x","x","Argo Tractors","6671547A3","ND","R54314","R54314/1","6671547A3/CL","026/02EL","PA12",800,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54314/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"8,1 Ω",10%,"4,8","10,7","8,3",,,14/11/2022 +31,"x","x","x","Argo Tractors","6671549A3","ND","R54315","R54315/1","6671549A3/CL","026/02EL","PA12",1025,"6X13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54315/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"8,0 Ω",10%,"3,9","8,5",,,,14/11/2022 +35,"x","x","x","Argo Tractors","6688903A2","ND","R53645","R53645/1","6688903A2/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53645/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"12,4 Ω",10%,"8,3","20,0","12,1",,,11/11/2022 +37,"x","x","x","Argo Tractors","6688904A2","ND","R53643","R53643/1","6688904A2/CL","026/02EL","PA12",469,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53643/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"8,0 Ω",10%,"7,2","16,9","8,4",,,14/11/2022 +36,"x","x","x","Argo Tractors","6688905A1","ND","R53644","R53644/1","6688905A1/CL","TGAI15EL","EPDM",1858,"4X13","7,89","0°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R53644/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"3,1 Ω",20%,"2,3","4,9","3,4",,,14/01/2022 +40,"x","x","x","Argo Tractors","6691394A3","ND","R54335","R54335/1","6691394A3/CL","026/02EL","PA12",1020,"6X13","7,89","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54335/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"7,8 Ω",10%,"3,9","8,6",,,,29/11/2022 +41,"x","x","x","Argo Tractors","6693686A3","ND","R54336","R54336/1","6693686A1/CL","026/02EL","PA12",2375,"6X13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54336/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,3 Ω",20%,"1,9","3,9","3,7",,,01/12/2022 +42,"x","x","x","Argo Tractors","6693687A3","ND","R54337","R54337/1","6693687A3/CL","026/02EL","PA12",2520,"6X13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",30,30,30,10,"R54337/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,0 Ω",30%,"1,8","3,7","3,6",,"Fare test con cavi accorciati",01/12/2022 +32,"x","x","x","Argo Tractors","6703587A","ND","R54020","R54020/1","6703587A/CL","026/02EL","PA12",515,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54020/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"8,4 Ω",20%,"6,7","15,6",,,,01/12/2022 +33,"x","x","x","Argo Tractors","6703588A","ND","R54021","R54021/1","6703588A/CL","026/02EL","PA12",595,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54021/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"9,4 Ω",20%,"6,0","13,8",,,,01/12/2022 +34,"x","x","x","Argo Tractors","6703589A","ND","R54026","R54026/1","6703589A/CL","TGAI15EL","EPDM",1528,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54026/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"3,9 Ω",20%,"2,8","5,9","4,4",,,14/11/2022 +43,"x","x","x","Argo Tractors","6703994A1","ND","R54732","R54732/1","6703994A1/CL","TGAI15EL","EPDM",1800,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54732/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",400 pz/anno,,,,"4,4 Ω",20%,"2,4","5,1","4,3",,,01/12/2022 +178,"x",,,"Argo Tractors","6721854A1","R55741","R55559","R55559/1","---","026/02EL","PA12",555,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55559/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"9,3 Ω",20%,"6,4","14,7",,,, +185,"x","x","x","Argo Tractors","6721865A1","R55785","R55560","R55560/1","---","026/02EL","PA12",775,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55560/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,6 Ω",20%,"4,9","11,0",,,, +134,"x","x","x","Deutz","ACC95887051","R55207","R55734","R55734/1","R55207/CL","026/02EL-S","PA12",788,"6x13","9,49","0°","7,89","90°","CE0129","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55734/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"20,9 Ω",10%,"19,4","43,2",,,, +135,"x",,,"Deutz","ACC95887053","R55208","R55735","R55735/1","---","026/02EL-S","PA12",786,"6x13","9,49","0°","9,49","90°","CE0129","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55735/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"20,9 Ω",10%,"19,5","43,3",,,, +136,"x","x","x","Deutz","ACC95887080","R55500","R55736","R55736/1","R55500/CL","026/02EL","PA12",950,"6x13","9,49","90°","7,89","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R55736/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,5 Ω",20%,"4,2","9,1",,,, +137,"x","x","x","Deutz","ACC95887081","R55501","R55737","R55737/1","R55501/CL","026/02EL","PA12",965,"6x13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R55737/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,5 Ω",20%,"4,1","9,0",,,, +138,"x","x","x","Deutz","ACC95887082","R55502","R55738","R55738/1","R55502/CL","026/02EL","PA12",2250,"6x13","7,89","90°","7,89","0°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R55738/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,9 Ω",20%,"2,0","4,1",3,,,01/12/2022 +94,"x","x",,"Bimotor","BR5BLH1000","R54259/C4","R55725","R55725/1","R54259/C4/CL","026/02EL","PA12",1000,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55725/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633, montati ","5,9 Ω",20%,"5,1","11,0",,,, +93,"x","x",,"Bimotor","BR5BLH1500","R54257","R55724","R55724/1","R54257/CL","026/02EL","PA12",1500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55724/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","4,2 Ω",20%,"3,6","7,6",,,, +92,"x","x",,"Bimotor","BR5BLH2500","R54259/C2","R55723","R55723/1","R54259/C2/CL","026/02EL","PA12",2500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55723/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","3,0 Ω",20%,"2,3","4,7",,,, +124,"x","x","x","Bimotor","BR5BLH345","R54384","R52727","R52727/1","R54384/CL","026/02EL-S","PA12",345,"6X13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52727/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","11,7 Ω",10%,"11,1","27,3",,,,11/11/2022 +91,"x","x","x","Bimotor","BR5BLH3500","R54259","R55722","R55722/1","R54259/CL","026/02EL","PA12",3500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55722/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","3,7 Ω",20%,"1,6","3,4","3,8",,"Accorciare rifilo",29/11/2022 +96,"x","x","x","Bimotor","BR5PLH1500","R54276/C3","R55716","R55716/1","R54276/C3/CL","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55716/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","5,2 Ω",20%,"3,6","7,6",,"modificare valore res disegno",,11/11/2022 +95,"x","x","x","Bimotor","BR5PLH2500","R54276/C2","R55715","R55715/1","R54276/C2/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,30,"R55715/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","2,8 Ω",25%,"2,3","4,7",,,,11/11/2022 +44,"x","x","x","Bimotor","BR5PLH3000","R54276","R55714","R55714/1","R54276/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R55714/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati","2,5 Ω",20%,"1,9","3,9",,,, +90,"x","x","x","Bimotor","BR5SLH1000","R54258/C4","R55721","R55721/1","R54258/C4/CL","026/02EL","PA12",1000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55721/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","5,9 Ω",20%,"5,1","11,0",,,,14/11/2022 +89,"x","x",,"Bimotor","BR5SLH1500","R54256","R55720","R55720/1","R54256/CL","026/02EL","PA12",1500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55720/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","4,2 Ω",20%,"3,6","7,6",,,, +88,"x","x","x","Bimotor","BR5SLH2500","R54258/C2","R55719","R55719/1","R54258/C2/CL","026/02EL","PA12",2500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R55719/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","3,0 Ω",25%,"2,3","4,7",,,,14/11/2022 +123,"x","x","x","Bimotor","BR5SLH345","R54383","R55726","R55726/1","R54383/CL","026/02EL-S","PA12",345,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55726/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634 (2x), montati","11,7 Ω",10%,"11,1","27,3",,,,11/11/2022 +87,"x","x","x","Bimotor","BR5SLH3500","R54258","R55718","R55718/1","R54258/CL","026/02EL","PA12",3500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R55718/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","3,0 Ω",25%,"1,6","3,4",,,, +53,"x",,,"Sutphen","CHF-6156","ND","R54951","R54951/1","CHF-6156/CL","TGAI15EL","EPDM",1054,"4X13","9,49","0°","9,49","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R54951/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"5,0 Ω",20%,"3,8","8,3",,,, +54,"x",,,"Sutphen","CHF-6157","ND","R54952","R54952/1","CHF-6157/CL","TGAI15EL","EPDM",2680,"4X13","7,89","90°","6,30","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R54952/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"2,2 Ω",20%,"1,7","3,5",,,, +55,"x",,,"Sutphen","CHF-6158","ND","R54953","R54953/1","CHF-6158/CL","TGAI15EL","EPDM",2680,"4X13","7,89","0°","7,89","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R54953/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"2,2 Ω",20%,"1,7","3,5",,,, +179,"x","x","x","Eminox","M0856","R55742","R55733","R55733/1","---","026/02EL","PA12",3000,"6X13","7,89","90°","7,89","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55733/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"10,5 Ω",10%,"6,0","12,4",,,, +180,"x","x","x","Eminox","M0887","R55744","R55743","R55743/1","---","026/02EL-S","PA12",800,"6X13","7,89","0°","9,49","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55743/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"21,2 Ω",10%,"19,2","42,7",,,, +181,"x","x","x","Eminox","M0888","R55746","R55745","R55745/1","---","026/02EL-S","PA12",800,"6X13","9,49","0°","9,49","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55745/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"21,2 Ω",10%,"19,2","42,7",,,, +152,"x","x","x","Kaha","R53293","R53293","R53292","R53292/1","R53293/CL","026/02EL","PA12",5000,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R53292/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"4,3 Ω",20%,"3,7","7,5",,,, +172,"x",,,"New Sorema","R53958","R53958","R53957","R53957/1","---","026/02EL","PA12",4500,"6X13","9,49","0°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53957/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","6,1 Ω",20%,"4,1","8,3",,,, +173,"x",,,"New Sorema","R53960","R53960","R53959","R53959/1","---","026/02EL","PA12",4500,"6X13","9,49","0°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53959/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","6,1 Ω",20%,"4,1","8,3",,,, +174,"x",,,"New Sorema","R53962","R53962","R53961","R53961/1","---","026/02EL","PA12",5500,"6X13","9,49","0°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53961/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","4,6 Ω",20%,"3,4","6,9",,,, +175,"x",,,"New Sorema","R53964","R53964","R53963","R53963/1","---","026/02EL","PA12",5500,"6X13","9,49","0°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53963/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","4,6 Ω",20%,"3,4","6,9",,,, +49,"x","x","x","Avoni","R54815","R54815","R54814","R54814/1","R54815/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54814/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-03",12 V,"SI",,,"X","Da completare con adattatori RS0634 (1x) RS0633 (1x), montati","12,4 Ω",10%,"8,3","20,0","12,4",,,01/12/2022 +50,"x",,,"Avoni","R54817","R54817","R54816","R54816/1","R54817/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54816/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"SI",,,"X","Da completare con adattatori RS0634 (2x), montati","12,4 Ω",10%,"8,3","20,0",,,, +51,"x",,,"Avoni","R54819","R54819","R54818","R54818/1","R54819/CL","TGAI15EL","EPDM",1200,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54818/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",12 V,"SI",,,"X","Da completare con adattatori RS0633 (1x), montati","4,3 Ω",20%,"3,4","7,4",,,, +78,"x",,,"Avoni","R54824","R54824","R54823","R54823/1","---","026/02EL","PA12",500,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54823/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-03",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (1x) RS0633 (1x), montati","9,0 Ω",10%,"6,9","16,0",,,, +79,"x",,,"Avoni","R54826","R54826","R54825","R54825/1","---","026/02EL","PA12",500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54825/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (2x), montati","9,0 Ω",10%,"6,9","16,0",,,, +80,"x",,,"Avoni","R54828","R54828","R54827","R54827/1","---","TGAI15EL","EPDM",500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R54827/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",12 V,"PRT",,,"X","Da completare con adattatori RS0633 (1x), montati","8,5 Ω",10%,"6,9","16,0",,,, +81,"x",,,"Deutz","R54841","R54841","R55770","R55770/1","---","026/02EL","PA12",2025,"6x13","7,89","90°","7,89","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55770/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"10,9 Ω",10%,"8,6","18,1",,,, +82,"x",,,"Deutz","R54842","R54842","R55771","R55771/1","R54842/CL","026/02EL","PA12",1525,"6x13","7,89","90°","7,89","90°","CE0065","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55771/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"14,0 Ω",10%,"11,1","23,6",,,, +176,"x",,,"New Sorema","R54860","R54860","R55764","R55764/1","R54860/CL","026/02EL","PA12","4028,5","6X13","9,49","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",20,20,20,10,"R55764/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"6,9 Ω",20%,"4,5","9,3",,,, +177,"x",,,"New Sorema","R54861","R54861","R55765","R55765/1","R54861/CL","026/02EL","PA12","4028,5","6X13","7,89","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",20,20,20,10,"R55765/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"6,9 Ω",20%,"4,5","9,3",,,, +102,"x","x","x","Himoinsa","R54915","R54915","R55685","R55685/1","R54915/CL","026/02EL","PA12",915,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55685/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (1x), montati ","7,2 Ω",10%,"4,3","9,5",,,, +103,"x","x","x","Himoinsa","R54916","R54916","R55686","R55686/1","R54916/CL","TGAI15EL","EPDM",1965,"4X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55686/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"2,2","4,6","4,5",,,11/11/2022 +83,"x",,,"Deutz","R55144","R55144","R55772","R55772/1","R55144/CL","026/02EL","PA12",2025,"6x13","9,49","90°","7,89","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55772/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"10,9 Ω",10%,"8,6","18,1",,,, +84,"x",,,"Deutz","R55145","R55145","R55773","R55773/1","R55145/CL","026/02EL","PA12",2025,"6x13","9,49","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55773/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"10,9 Ω",10%,"8,6","18,1",,,, +77,"x",,,"Avoni","R55177","R55177","R55176","R55176/1","---","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55176/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"5,2 Ω",20%,"2,8","6,0",,,, +104,"x","x","x","Himoinsa","R55192","R55192","R55687","R55687/1","R55192/CL","026/02EL","PA12",850,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55687/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634, montati","10,2 Ω",10%,"4,6","10,1",,,, +131,"x",,,"Deutz","R55204","R55204","R55774","R55774/1","R55204/CL","026/02EL","PA12",1537,"6x13","7,89","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55774/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"14,3 Ω",10%,"11,1","23,5",,,, +132,"x",,,"Deutz","R55205","R55205","R55775","R55775/1","R55205/CL","026/02EL","PA12",1537,"6x13","9,49","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55775/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"14,3 Ω",10%,"11,1","23,5",,,, +133,"x",,,"Deutz","R55206","R55206","R55776","R55776/1","---","026/02EL","PA12",3058,"6x13","7,89","0°","7,89","0°","CE0065","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55776/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"7,2 Ω",10%,"5,9","12,2",,,, +153,"x",,,"Kaha","R55320","R55320","R55769","R55769/1","R55320/CL","026/02EL","PA12",3000,"6x13","7,89","0°","6,30","90°","CE0077/N","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55769/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,4 Ω",20%,"6,0","12,4",,,, +161,"x","x","x","Euromach","TUB0500400","R54235","R55747","R55747/1","R54235/CL","026/02EL","PA12",2300,"6x13","7,89","0°","7,89","90°","CE0053","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55747/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"8,1 Ω",10%,"7,7","16,0",,,, +20,,,,"Argo Tractors",,,,"R53861",,"TGAI15EL","EPDM",850,"4x13","7,89","90°","6,30","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"6,4 Ω",,"4,6","10,1",,,, +21,,,,"Argo Tractors",,,,"R53847",,"TGAI15EL","EPDM",2050,"4x13","7,89","90°","6,30","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"3,5 Ω",,"2,1","4,5",,,, +22,,,,"Argo Tractors",,,,"R53848",,"026/02EL","PA12",500,"6X13","9,49","90°","9,49","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"9,0 Ω",,"6,9","16,0",,,, +23,,,,"Argo Tractors",,,,"R53849",,"026/02EL","PA12",550,"6X13","9,49","90°","7,89","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"9,7 Ω",,"6,4","14,8",,,, diff --git a/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..090724957530a62aa9a9f995596f18778ff05aaf GIT binary patch literal 984066 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 z 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ä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 z z7TACp&8M$1m*m{~vAE&$%CnsAy$R5kcs`7(o@5~JZO4J0!`I}S^OLXIiu`NrQZe8S4kK5F;WO{$+?7I$TQ#5 z90CnwYWXqG9@|?C(|1*Vhx?`}rIy*IKWCQIklc+si@)ZtGPa&U@oaHV>5zupO;Q=; zZrt2m&|)HIo8$LJuNI`^#!bIBAx#UⓈU7VcwcCt+bVkeAfB`9a4u{b|bvf+(A} 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%0A;JT!M4!Xm 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

FZ4Qn@gYP{ruPnhLX`k0ojXU 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

    ?(hb~m@e?nPSBPF8cdVO*DShb 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%0DPD-L<} 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%0DEIthSa(Kt5_8mp(9@P6NJ38BXP)M? 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

  1. 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ºGemm_ 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

    j&X|nQ~n9};AHVf?JsNMyNx_e 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%0D@dr%yh$k;H*I3pv_ioafD$znEecAuJooD808 zF$+hpCV&cLh|CCAWIogY*!5u8&zAFT>??wg#TL5OyZxCP z$L3oFl6ZpxW6w?Alna?2iRVSxhAWTpO}3M%SzhTHy|j1QE$l6CcMB+GWnqlsoMs81 z<#+!81>pYxf^}*?@J=7v{{ULo{5Ph!{hod!T}^+YOK%wvXxBxzJ-18&mj!wIq;bKo z#t-bJX#;LojPtucdb=YvV&qf5vnY+^oB(SQLoAP$W1gKVCArTfs1!!|QNeII9`$Z1 z-rO$WM{li3BcAR#^OeR8RG!W`MmFT(vuPnM@-XYDYJIRP;Oa^0z2cabXIznuVZ;_s%YA+=9P6D zZ&MR(1-(zbXF6(HGpdzC^f%y_?boSkdNr4WekJL*7f@SHsJGkxVz@k>ee3lv!QL$J z?~L^8eOtoXlo!@AkQa1{8*v%NGwENS=XqSIO6z8NRH_}A-@L`Q=g!lE(xh8vW?)wp z^3$f#*BK3#1RpW^dt$RCA2CvXT>f?WX#)TwOPnn)RmCRl$42CL5t)i@qWwFa% zM;Qba8;_-N*S2i3GMt9=J*%n@W0s-LTv{^Vuo)iJn=OcK#oHCob5ut=cN%hv2nPcXG;hpag6n-C$NoJHxAet=cOkmL7X8-%YN)W1^}w8jI2Vg6m!i> zV@|`OS2$Myk73@n;$l;18}ZINlTj)5H#$2>+B_f~dWzPE3`~Ulz>M=*o5gfCqg(_7 z0Z;2zP{g_4#t%_d256$t=96@bA^=maF;}$Pc&{%Ni5qte6)6cJW5Y`1uY(@P=b^dq3_GW&z5l2Y=S2o8df{aI`Z9!!E;?7&U{cjNK#1 zG~a<9EYYm>ODMGad$^NO`(2)HF@!CWzS!rFrFYZ(J=CQ-taItNDILTcST7+@wLWxD zv1Ue*;eARQAc3wUa138E5KcI*E)NUq*4i$;;pDrXNjFHyS{!XHk}z@3Gfhbu{avSX z0quN23?3Yo?Lw*$ml*_egZ)o>Sv2isZ*_G78Q?L8fDGkZ9Vw$fWb9DV?=_*NNj>h5 z`_MNKt<%_5SoKTbg@&6lG=$)H6{Hd~_6&8Gh^}ql%(}Lf0vr|H+Pv$<-Zj&-`|F*4 z_8GMJ>{D^LApOScjC}=ahwKZMekfbp8HsT5x`v3J>U-BatoXVcI|%&6O_8?dW;jLn zG}Kej)7jZwogBXv^n2YqOt^ueRuL-hQ;{Lh{{UQ7-v#_oveobP{R?ccTw0W73`Q6c zkVQ|k=vTE%L(*C1>KFGmM%uzb5AQ(WmM0&HtS=7us_RnKby+Wx(KPqOkR)+!0yV%?6&Yndjv}h6^H`ibAo?L2kjBf zSoo9068uWmh_}9c9J*D?dcSJD2{ZFc?}(Uw(BgoSMX06M_cZ9Fu(`Mi$CaW%wE8*P;B2dE%>RVb?$%$g;( zveU)Yi%EH@MH(J$qw zH&B~ciLLxWb!`-K5*1JnGuZK(?SHc_VGh&YG}18KN%f_vx|=j@?Jw>SeVp&wJq1vb zEoENv0=vKi(z!GCS0ombB=1(jFQ^_0BPH-G8UJdws=0@l`ckR z&Sv`CS20{Zz@-i{*ygz3H^i$n^229pUw}V(!!PB>dYMIzH`w<701n&vKMlShYB!eu z0O@I^$oNS)RyZ72;%AF*(LNmN##?BNk`}|r$0|W@)Yk=g*y^Pg&&A6dCAj#7qFc=} zUC8?T6;OqCuI40G-~1IbMbE>353RkQkvrUMQR&ZIR|LKzvX?{4e`R}{>z{@?P1dko zoe6;n2j|8{dFjws(tl@??|6(H1K8K*xzwMxlJh+p7qIaefqb(c&)%&Vs3%q|~Q3FaEcZSG8j4qjf82 zWVi2~NK%SAk9v@?j51+>>}kdp*iGDgY_c%iNN$+*tIAeBtH-~3-Vw1SX(VTI+>j3y zab`&rZ5*Fka@Yuogl;4=5Pv#slc-izPnh(q0MEDGy@ZI{PdPPto684jJ4ZE9T7d$y zvXxdRoYmOwe4G-@kJ}ZxR}(fgOBr?B;b@N#lrHa?fZ%;=W=$B}%C=EP9^-a8^{e(~ z7dUN0O}eqvCW3A@z6~tV!s!@5RmXhRGN-8R(1y|h=Oj!^ZaC!Doz1X}G7tj}zM~b1 ze6}&6S6sLRf_dYgtz9xM&Yv*iw^0(2UMAU=+Hz0lR--8)4p-(Jb6L-F<13L%5oa#h z-Vdc{+I@wr?qHe^GG+r~Zs~*16#&~RJWLA_kTcWPn1neB56nMW2Ba%NEQ`Fa$_)&= zwyN;srC`P+w$1*sLC|BZQI9VBA9e>!QUgLpF{17n7^s9vHVR=$_MxKF=)vub86f_h zY4OH@Fk!X*YB>>V2#!ZZO^kRa^QjqDZJ#mVV2an3TS7U8JOH{k&9r{BOAy+25&2Y= z7CtD%aklm;>BTw-nV2{mvEG8v`%~Bew{kHG z-D?%NF;?2<=0uLnE67H0SS~>C$*&Ojv-?W?6!Q^r0dOU-!{v)VxFReg&CUakU! zs!x&%?VQqAKO(+_-agu#7KEu@WBpOCm|~pGx{g z8yr)YQWVrKL6R{$6&!WxP??#DEh9J7(>UicWO$qa?9QXHt0rhw7h;_KC^_XTl_tFM z!ue7D@SO8j(eAILiR2_G8*m3v=~+v2Goyn}kjB1ZfS-3b!4;_**=d%pWsO_=tOp>} z8dFCzsQ9Kc3lv{0mEd|;m}+|5j2Q3S$EInT997ivPlZrbzP)QYJ7$rwwSmtyjY_E( z7+mUfy#h&GJWHPE+v#4P;ctfiBk>HD(P_GN=;a&QS3E*82Q}j3G2Ex4hoaB3{2TC} zL(oj|Tu#@QN(R|o2GYZ*$EA9mmY!`@qQZGU!l*C@y?l-{9VtCecMVHI!mjB^Qdxb+ zdcJKZl`#ZnXa44Kn(->syF0C8)qEZB?)P8WIJTKBINr>5g+7A5o$znM{VPb{E5foa z{O)2-N&43$)NJLu@NcHyh-H}ua8ekQN0E}ZM35+nkFih86n4^s?y>nS5kT7 zgVwIbyvRu8bHN`dIfV9@)BN;%=CtPBpZOxa)*+(XuiE)VZhFpKGYg11S4@F@^CX+0U}tzQr>6rW`Q}7Lpv;@NTw=4&o$e4TgQ_4U&b0oizL%* zwLxq!(2x{O&~w{9{zB^URE(h7$3V|LPuKjm7FUWq;+f_ z#gTH&r0W?_w)HGI9`2)a=3xB62ycYjom8rPMpSpN2sWjO=5pP^&UvZ#e99DkD*4E;q`C|U#&QM@KRT`E zMkip%OZ|TJYMD`waqb-M!WLBa=~WwXKo=zkwFTHziNvh%Jgt$BYD;$g;f_aiU^qDI zK}FdUJ6tyM2VV7E(WQxHm~=c;%Eh}BqunfO%64)`)~+l7qYU*JIjl%4ENN*AMjfRG zJRa3rILR4h-Of7IMF7msxK-FA4e80Kyzvx{b~fYGdi^VSfazjMqfnr)bHyx8Br$@C zBch$9z{U-0(?cmCmoFTEf*3I8r+Tjy$k-x3>W?EMy=K=#L@$>diqR--ry$^QOAIkY z=VE-v0CUAF8^^fW6vsT0@)IO%9OLOt^P!O)lo5`ZAEhFQ6|Jxm9SvmB zF~3r?tZ_VwihBMcs!t?q6SEMA4oN2%q-!0_=@ZXJh%<%tQ^+2)$>fqWDyXm6U|^6t z)`^;P8P@W=tGtH|yEr2RR@IlEEW78GzVARfRdNH3&6{PoRz?yx18Z^jtFN)QwUcB4 z#m&Y6B=8ja8lyKG5!~B-o!k~end2QRDVKYYgl!(avk>!(-?#ho20*Kj9fJb!n6PUr;d+t#Kf1ZaF{B zyKGunZ<)gcCvFsf5$Rn~NYTroqZ94`0PXlygja|_N~EZAN3}~cl&ntC&VFYKMse;c zJ*~Tz`F%Yr0(rEt6a0a2cO1}+R2B_@J5p$t^&VbCw+!vM4sf~6Q4{SvZsxL=azvJ9 zxS!0CzFYx-00Nq<(UY*_JZ?RHl?2I(knWLCZVr8_LmW%{wmB!QQe_~x@&az$RacYF zFe)kMf+#@^mmrnE%{e_yDeigCiGC&cH^DZB=UCL`xYSGI>~Y~(dy;!s=TF4njvgZT zhkvLg#oU(qa1udp6i!0{L|8T!@xTP0}#jyB|Dr6{vS zCXSlhM3}m)!9s(MwcTm@O|&qDf#YcoLkxY|qP?NhTj;V*2b4nX=xd~~(AHnHMz=6d zszv|=l6(GD4?`J9^e+tQQrgKVNBg7ZRq8YAUHBI>M2QjDQ;r8Bj&li2)wfyhVc5WV ztLxv|w3otKjF$6G)-#lh4>$xQMo;&TYNaDNJB^o3v7XX9Ie?1XHY8LZGv~iNdsoE2 z8$K6#8j@=M7`we1tTzT!C3g7?2Vy$(&1)GlEPWU7d-jI0@$Q{_;ZGM^MRntwD=`P2 z%duD@;5Qvl6)vHFcX>OYxXv6Cv}25Psgz9Sx)=0&8@tP!u_MiR9RkLK_*)%-rucip zy1u`u>bh2&u3JZYYa7ihbM0M-I)ZrSv3I?WX>NJey#NhC^1i9QlXh& zZFx~Dg^76wtpv(8B>O{!F_t@X(A6io1QZ7x_MlOAGt7>z+rJJeuOV(1Bi4gd?k3hG z5mpx}xy=JBGk_bOXpZIKaLC(O9MN*3hg{!W+_{o@o>wRMsswYBxKM3kQlR8u=hmT; zAb*JD8kYcUSl{?aIigl@a0Uft<6}N@01Gk6H2tc)lTut=#~e0ulg%)%L7Y%AT1DHi z6Pjs!f$|Lc`p^P=#ZCYsni~u-Dx&NKg_q?6?wXWH205*OyKOoURIoX%ILtsX#~jcE zZ!#1-Z9ht;es7d7Gy$b*sG-b(Mh|+O<3>jz&sqS6KqA;fZsMSJMInNZrYHgl94W{o z`ct8~P;xSTGe8d)3(B_adQ^dd=qLfjFadH|hv89eCnqNvpv}vnDzhm7Ime)@B3Zuf zb5{kanXRVEUSO_HI&`k(jnIn6PSNe;)HSU_RkXB%B_>H7m?!{!NUo}A);GP6^=tnC zf&qTQl77Q~@K3*oJ{|EslP;U_N5uQQMX&kMs?3r~0Z7}p+JQ0;M$b-_`+D)Dh|xL* zjEoR_ipIRJBJ5^px(<=y+aafDwifzzmiCj&iEz7^Ur#@-s#C(<=r8;Hzv!7NTxhC|W$;D;~xBp zK#!fjTFklA&|oj#&ji-47DjT7&R*)-?VZ^}U>?<;_ie&CV!5a@YQn(j^KB=0@~cUE zI4iUl?b5f5t|BixbNPf|j=WT_vfuy#Bl%MHHjWnvd;!RIsqnJuTBOmLE1@xbb9 z7wj@eArqgut2#a(@5GV(ol^Ii7DQUIUcp?zYV@Gc;Defkz9CV zRlAnmAA3OVNZLCuJ!&x+NL7P`wmYdz{eAcy`(%7S_@QlYqUu_mw}$*)VoW8$^2NdE zN2cog4J4P#X=7!UE)MlMQ=0tGFu+cf+-Ls)4tK(O4p%Ngl4@1Ul#*}Pt zb2?jf4zdtWZ05P$N+=q33A`>i&vQtVhQ3+tr3}L=J*$+vm8EGWWgusddfp7>sS_4< zl2BKjqx2P>CA%_|RzHtw={aU+&tO>&0;_b%99A@zEeL*DWo@t|QVt6CjxpUUFbd6ym@eYUK z%SH1wOY4~7jx~(CFlNU9d)L$Oq?5+R53T;(C8Fy-9I(_s;R^WMtLWN|ykX>xbva_)pWz9>&wBlJV3TLY z=2?yEyL3I4*W>>H?K|Ox(}X`1ZZ!*7l|x5zLz(#FpQbCf(SL29+HMJ1_03ztQ$iep z5^0H&y}1UP%9XB;3VFQZ&s6Z|?cMQ0*2h)2*EFvS>$jmnw}Z%ga1U@;ACUpHnGkeJt^<&a+1U0D_13F6>@DyYTPDJ{*EB7Dl>; zVIlU}(!G~J{j?bsO(P7PsdUjY0Is@lzKePi~N zb=bkNh92O9nzdZUSY~K0p#7EaEUaR+wX}{vq#OwV10C>BwPb1k0JFxqpm>&R_^d87br@M$ zxdRD1Pd#G_}0f{m@I(vO8+DYdk|w`&6133S@0<{fL6pTSzjpQ~D44Jnt*U9RoH zj~>|fH2t~C@Z6^z<39s7tp>N@fim0Y%fCM*<(RSxEpX>A4V!v#(6_-46XQ^a=`+HBXKU`3MJR^T@-0mom$te;_Lt30RT$HoY} zH>`Lw#FpAU*Y;!A$5-zSckrMU4nk$e4@dj_CqM~quIL9?S#l?~Me@wlymgdyV_dqdV*yjY*tLUe-x+BYGZ_2dh z=vIb2PjcUFibxtb(Sv6^9MwxjzB-DD5z;3F=8Nx#2(#3SA%aAe@k^cbJufuPO?$&<@ z8tLZ5auYF;*k=WE)318->qzaQ&&U4&2a$F0cfrEy^Ut)OR~tycz}iP9y*vI2i)Rw} zYr=8d-a1UumH{w#Fa!Z!d-#sHM^nW90_fA&d_L2XMs&AOxL0Ali3H~r?sn5%S}>9n zNl@@Xug|lXr&eC4p-GQxhn{z4P?39&jlLk~rtMC5Q>>npl}*l*U-F&osbvg<4&x#3=9Y zQ$;9=*~^xG0i|PTGX1*(`^YRhnzJXAbICb84@xXi20XG4<5TWw2*D?g1prrOWpGd9 zOB#WK2@E~^R7?wK<8Da+cc#b_ZsYu`AS7Ln3FD7nN@$3;@eE@EngS6YmcWC}1o@J# z@$!R=de+d9GT375wY*v4W=9`)2b@<`7O{10b8UAEkus3k>zdt2#G$HRTxxoQ&2lp% z{KbIkNvx+wM=EksvTPQGnBfw%ZVtjKrQsthmdVe0=eI*>>~@+yo8i--O)U4*4RA2q z3opvc^{!^_*&24*0eLRD4O z_x}JYsv?tW$r#DbIqgUZr7p1qkxt|7)|mi%d^uJt(}6(Kv2u12A!KgY`c()db#_?* zDtn*hLAqge<+c@w%Jd)7q)<^o>Fq(2i7bLiAUhuz>FOzvCe$m8vF>OHriNVyDh4yo zD%>9=NwtjvV>)TGq6NtqsU&RZuZB-iSB4ow_2G~~VWIaWyM zE=GxaOiLyyS6Ibot*D*t1GNgZsnNpqt>mnnabtqN098Xu$u>lQPg_W z@xwde<2#q>Q0_^gX=y9Wrdakweo(|$O%R67aOjv*fI!abhC385b^XQFNN#xct}j^e zB=6-wXFgELWi*E!&py;ONoJU$h7k{#A6m$h&6&e15_5`)zJ}>s)U(o^-0wnIcFlSQ zgWz3XTaRX!XCRw)GVz>s=bG|yb@@|l^r%s}^;d$v25Gi&S={)AWP6V^NYSV}NCT#S zrF*5ek!Po($7KXocHsQ6#xMXC@)*2ZZs)Z^g^jd`Nw5WFU~}nOF-8jr{$O*Ade@6q zS7)Ud*;whcPYc~@^E4KS(_Ci`6yT^m>*+57{29_Bl`l2hb-TNTgD7?+99JCVXHs_1 z`U2NSv$luGw6=oXH*l)B+getzx?(9D>4Fq$INrESo-M z-JiyY#g64Qh>h7`RP@CgQ!1`b&~iQNL6Q_j%PSp++mTeAR8PBbY#zRqoRFL7U5F^o zdLLSL#yQ)7wLH39nNOiI#*%Fab13Q!BF4vlPa}hhzCwA~a@r3wmdOLAdR4P&lpuyN zdybVBv7%x{WiH~$CS%4iik+>T0{19{Al*Cy^n7#Zv7 zS?dE_w1))`U^>--UF;`|F$a)>a!zS{sL|09Z{9HAW2vOr7ne`-aFWR=lY{b_ywC`q zFubasc;^+1X6X-_M3W&-6n5?@sN1liOQHAgNa&A{*;WwXs5`;OJu1D#h-31Mim#qC z*w93aXLyZOS(|1sF~O+TDG|KYBXQ10wFY9_A{P0+M$d6b@%fhuB4XV4pa|M2RhT*X zYckDdjLh*U;N`vP*kq<>k=5JfVtK_&G?JhpK+ZaUTCPSHC|gG`$@5suK@33c-mFNX zBn$`5+Z3EYMA&w`vm{Or*ELG*8|{0Lf}rC*pGsFLNVtM#&d~l>Jf7yL%N*$pzDlD= zGleGr)8=NNofIQ&lh7W9oUI$&NDDJfv~{I$9Xu}@I;7)x8RL;v?UrK@5=bO$b{NT| zF?_PTk>$Vhq{9{jyJIv6m95~Fz>pu8=EiZFq&6&)tVj?B{OO9q&d3p854;?E8mtk5 ztd3du$0Ma~GEo|wvc5;sl+O`_L9x(=-I98msO~0;FKn&mH=FW-$GNIzFEQglts3XA zt!z?8nlQIUR4h{;rDsN9GsvOb9if2(ika+gTHBl#U3a+_H|Q_mF4S|0>&Ao8|`2i~LI8pz0`e5V~d(lv@7B>O@c5t0W#|t|u@UniX%MS(^8?m{QoR0hT9AypPZ=krRkvM{kO|%@ zxtWBXrFEChjnYBSDtPHkR*6tXBq5aJ0ClU3u43d0*;yj_mmKu!eW~xXqXb`=1J<^K zu#{Q(*&JDjJcLMi-2U|(@KEwGiwHqzuYFk8-z3c9p?vPDz4X{6_IZ{axZDaI@X zvyxM^DzBHg^&I|npgzv5&ouHx2^lN(tqr5GxYzK*wUP4#u)Z(3{&QA+lRe&#+hz5E=Te%6@Fi(K_$4E z!n1E&jE_@OEezz1*u(-Ai*frv;jlQx21ufHRXg$2{{VKeY|V-GmjD4K^(QE?aal>RxREufjY9@yU@=spw;65Hcj?}xlVZ}rl`2RB zJaI&ptr9x3fY`{u%^+xvK|s>9kHFzE-`1c}6p~9J3^Fs1dIe)5{_pI{rb3E`Cp(5Z zX9WHg^6$mZ+D}Z-p-m6MGFe<}OpGLz32!H;!99%zut&g`+Sa$?OUd;ucIWNavTz*d zrg~zlrG#wAv4EX`shPY}Hth6S%u1JP8Fvz(dVAMV2AV8YE?Ek%@UiyysEe^}GeCau zs;T*y{yD8(KGyAI3K5lw@BGiTK4xaqJts%H@vlYjt);!R(X-l* zFy|nQ;GbHCN!v$f7L{{4`5R|1`@&9h_}1IVk)zx~OgoPlA9v|aF)(iCd{eMuisf5B zR0=9x0{ZB zVn1JMwJQ@T9}E0S@cVo&@wMNHbQ5y-K7X3x*-J+v_4;DIoAB?8w7(JPx=z2Q%(wT> znY*`<2I!>k!0k=S=;xH~j)TJz_)&(@=4i};D_%`-VZghn7pDo!bl1CN=>*ee-5Ly)f`fLD@FwK%9M zc{$BVpxiR&2Q?dv6O%v?s&9}g{Kqw@_R+%{yBBX!j+6mf=H>#CtVqbf5P7Owxg|va z1>1~M;#YSdkIuJ?15P-^c;Je@2yhc6M|xl*E+1}A(bBA{#-Q`_cc2RcVZbA5p7hyS zLHQW%6af&BKHr-nrFD;Q3xWKo13FX;2n6x^)JtyQr~$gr1H88^4?jw~Z5a)QBiq`5 zHRFL9LC-y^DWipQzcBTn#z?IkAdnQAonrFX46z5VwOu{QI&Ct{F^&3+@$dDo-f#Ff zd-f8t{kebOq1tAr<3axb7VF`xaBKJQ1q5DP2{%C#XN(f1kEl{Rm zJU2GFt-A+;>fS<DaeXD^!W(0^FEQt^`gN`1wJ?*m zr{xFy6nFNe@L$CJQ2xxCMDx!Lx<`4cyi#ooa1Rj@4>ZVk|cPM9Ik z^l(N9uk(ce0E3zT0AaNKm%nWN2ll1#PK=iS01W;nMz(sxgv2)bqT>w2ebVc+`>>GL z=alz8#+;Am4_ES{as~@$s-6vU%{xAReup*Gwy-u-X(Eu3APvE+8T7^s+gCltJ!>-w zGd5c(p#-|P9ck+YN9arSfdV%&bl#v0? zJa(;82P>M|R*_|J?AJFRW{YY0fX_;T>ct|Qi&+ftXCos7iUdmqskjlx8EEJ0jPq14 zC3|Vs+TuczF&N3~RHDQXN+Ohla|wL#H;R)n%^_uEVm%IWY5O(=lG~(;Q>%_~RW~$B z*$0lE)h;DP*om*eZMiHvUBRRH?&kjh#l9Gjg=ZNp3XbIW?Oa&gG-|=Yo%FUpVtyTbS@?hPOF@fO z@P@Zrx_FB&6uOg= z3C@0$0H;qR?u#m0o|(ltZQ@jP!QJm!%3TJRV!W{`s6ZI7=j&R_Yqkhk4j->0n#|fU zv2xZF;IJxAYWM>uZsOU-4FwjIg*=QO(xabwJA(1;*ia0L13xSCZ3iO0rTvGzH9v~K zX^kW7OKW?1Yi=&B(pa~BoUzet zrRy4u@heN@E(Ba)Cro4j1$o}7;oUD#l4g5o?Vel)Wn5<+GheU5N9Q%=)e`BNG*&RY zU)oofOb^TENKVo1nz4Ohs=!2$-^aC3zH^)?{Cd}9I~<2O9=EJVXEP-8GnOiiv#9l| zO{wY=XA@k?+emPvkL6mZT!~AuPHj?MF4h}n)902I>Hsa1@9SH(KM^lhfID~Q)0_t+KG=zkHuFWNMh+84#|iC!3u z#>I*&=8&i23~@h~%E*#UHZ(u-d zn&FmRB=kKRdEGYb^g1mg_R0O3^{0_7el7TJ2UCn(Z;N-j?opccy&K}c!#@zg70!+0 z-wEHs{GnUu#{U4IBokb+p)`6i##4GGcGkDnH^^Sf^49S^VvsofDP*&>m;G(55`Vma z)ceug-`yx&cz;B?E@#s$?Bkxa_?w?Ust5}Cc5NaO` z{2{2wlFO$wQZ7Q6-x#hp{u%G#$CaqV_B}%ecQ9wsI4Q2MEzLvt!MT|@D`_} z!=SoJb)`n(<4K*1As&aX>r-C-%$hy4+C|=s@CogP-`*h3I$#ogg=-v2*rh=wW1FA$ zV2ArlQ@M{#uyJ-jeA|HC>}!nw0ETANG>8SQt(2i-n{;9^xGLv32DVs}8kl~?O-JBY zi($Hw;@?la@|{K#%NQ80OI7#>;@R}+uB6g68LuI5=&G2lqltSQvcsHaxA61DHYZP% z=(njG60#DXcaQ%7RdM>ShBY`KxJR*Nkb{E5t#n4eb3dzC;(pI~z8eDjOlaX(F?@iY z_^zJLOW~*Kj=FW?h}1;HCoDO2*BeGsXusr3SsD z-hXCl52#+++B`t-F>)IogpT5&)fXe!^3U!22=xocY0_wn#WF!&L9V~Uy4AJbp(dQD z6qMeqSZx$WUBv00l@70@e`Z2%qljEbHVN}T3{*Ou*M?@ikz=!*2Zw8HoQ#UwnRX@8 zF!ZbM4;|Wdj2exyrx<4>pKyAb_D>J#mfDt>`ifp4XxuA9yXVLEvFTY!-(upep`k9H zr^j+kx3>{)Pn0W;ezi5mk!c-@>JO>FR5l0`F7^C6)FRGP`wnZZUSOKPmuD<_g(Of5 zAHuELY1)WkExg`rkn-cp&IM{;Asafgv*Lru`XIm-JA0kNG8321^epUFB@%-o(zXg)Y z=j}ui;h2&($Fmr(Ho4VJqw-tf1&UpKTksx_r(4|2v0suNLGtV*jGxlGFZe1=<)nTi z_+8=cYV{r@lQ67HfIQeA^jm4LSbjXIyix?@l`@iQk(LSLpTcAPn z@yDfnMm`+VZ0M&gMy1U0I!OD}b?H}4>dPo)BxK^gesOm?$!5TfSOcGGWrT70kC1pC zm5(VhMx3#zKuJ4=MI5d20Df+j4w;)}`Q&B7fPV@iMp6R;GsiV9HWGF(M`#sU_cl*8 z7>RfU;O3>B3&_-5#ux#|N=IOU32d*|tw*#sEN5v}ATabbxulIXuVDVrc1U~e>yK)* z1$|yS0dXvLl026ABphIh$Br;}eBD1YN?QPmLV~-qQe=hOlH)z=03vy1E)i4|9sO$J zvbt?M*BlxEhsyI95Kh6`mT<=f2HbSxn%Xh2rLkN@wstbn?<%Lo}C-C~z*xezKODf8uGRGWr z=~_(BIM|E1`jOI;0!j4i$Pq4BVPBOQ=M_>nVUs3ude$H|NEGG1VUN_)?Y71UbI0?f z1*ea6Z1Ex7qb*d_VT0%Jr6*)kVJLSYcMx;fb*m{Sl@J*@`c@)kNq3phZXZnZR+>Pl zA}@iSl;azSr89YwBw?G1xTQR;jHew9Q-Bobi(&Z*0GtnMnXTEBU>=>TGe|y#8RK+i z1#-ia?^goG@S|<#JmtHYwt0f4lvSlkDkN*H1e{XMz-x#l!&%sm2;Xe&VN^G}~hn_Neob))akHwwV zyQ@j6c#BljZyrbABT9E<`-9fMR>|^phljnajw;m-qS_A%=^kA2&I2bqL}QxeHJ=b# z-o(dDoWllw>kdtO(4=|usCo45HQskQV5g_8O=o0xuH(Pc+O<%z%Q}Y4wr-nzv6b#| z-l<0fs_d*jZn-0+Rg4=o?14mZPSV_RD^fcomN#MxWAMPCD+sk~r1^&<1sjfgR^r&& z*edz5CU*?<#we4qaE-_KgHqAqg4P`>S)B}Frrw}pL6L>_#d)pIiDQk5e6E?s0pyy+ zt8R3AGnk)Lm5hL$r1A)?DH=w@63jE-(xOtZDr{h}d1M45mv5H4T_?hq6Pso79U4gr zC(E3g^RYOdRCeL;*Jsh*4fr6;9{&JcKW4QXc0}KKk6xW?>HQnSHo6t0acS|yv26vm zj&tc>9gW7yO`i4}4PzzvOPFQVoo)2hmnX{~G=Ovmn&YWZQi=6`jp6M#K#5|qwzgQ< z0h1Wqyn5G8+H@$9$q_5T&N>rZQ>t-Qkqx6Hmk%2f3iUXx3H*>ssU^Dp6@zy2`hiXfSKxL90>e<`PL9tj(DlCZGg6BV4k^u5tvj(DYoh7{vC8T706_U$f7OhwT98qK{dI}3N|L=AgP( zXUdEW@U#)k%I>9@Z#@M*C2hk8@}N#&?CH5AJF``ye5)#<9-j2m4sned2@`@Jjy)>; z>l$>x&q}^>;_g&%V$6sLa1T!O*=`|`FjbO3y~k7SOPjdL&jK#VHfJN859d%a?Qy<8 z-RGQksR8Rc#D!41j!)97G>s+~g!eziNYX9rSCZZQnI}@)lyIPRsVwtz5Oj^vh{q!a znV})XC^v^(@y~jm)F5o*asE_>M=%q!FwXDpp48S!5UR3};0Ec`Py#0BVIWbw91&5^ z8?MtD9B1a^r_zBHB#b~)%Xu4;a(gu?jiEv20(Wu_IIZHqsdEj|syrkiC+5iQ?NV)4 zRT$cOaw&mYcXUFF86{0I%LER}H<8ksb}j<%SrjijyZh5z1Lf@~kN1AGHgrIA5v=A! zmf=e;7y_econ6$w$T}XIsS?IU{!@fW0c`$N6w~fLUgErv*c2JbmK4VfNL05cwLr;- zEg3tr-iB0Fv=Vg<0g*v3_eck=SCTkl+2jl!Gm+M!GSu1w9@zZTMyJZ@jP*2@cGJvP za=IpcFiEQkB3p$jh61_6b;o+E84(tZhs@m%y^I|#KKtfBY?de)`tWINC)k6`I z3F9^W6&GXjqcq5<#xjF~yO_Bbvau^Wa;LfN^rmv?Sdz{Bsgh9< zE4XLc&72&Lrl63#8-k-4w|u1aGyxLGSMMFBp}V;gG!=H0iwcr}i{%aY2R(_cSnnPP0^F1f zjP>bP7~It(j*G-Mo+Q+#(0o5>eC)5Z&*dL2f8bT_eg^n$ZKa7N*JhVg)ba|us9>Ye z=cX&Nnz5?T_G@@Z$X8~G6aYO1TrtYHZN;MZ?Ohzmi3r4@EwpXVBNfiiGsk)nL2eFl z{66)IdXi~CuE$Wxk206#lq)o_xN>QZ8I2aY5 zG8#!D-K=|*<(+*9=xS83laj2P`uxWkHC6&wh4#6SE>v^R2C?IgGcN$=*VeLjB33L< z9D6r21;NEskbnt@7a;VgGBPjkgevUF#{(s^&{voEyW(zv;M;g+)$U}6%~HSt%!AV% zzO=53f<6uSf$^)vek`~)7P8#w-XBTbqgbZeWCyt;oO@S?+>vo0F^_EbKT}JY9Z-pK z(!(r@iueHZt?O+vL=8B}+ClrhDM_NuUp8qr?U9vN^{r*Qn&t(zA(#X5jOP`e;C1>g zg?A)z+$0;DJB~(hJ?p*EbV+8NZYEWYbCZ!&qW470W6>?N*cw35Mv;ZarS}0w?M^qo~2jo*w&t=MrF2_b1lOZ z$y6ZZo`Sb!g2jS4nEj)67-NimX@RSu_?!L_o13MzNaS8XcjPs28s~~FZf>WB-9pH6 zNQ@n$+NYFFbUb6l@LTHEj}6>$D*0>*zh0flub2E4uIe8PJaKh(3QIMInhGIsP=YXe z(7PErdf4`B{{R%jAv%`m(RLRfHtYkkUZfnb1Wnn93 zW#~Pt%r$*f%{vr41I9a4nj->B%;YgS>ME_(^lpv|jpPoVm6bp_IbK_dLJiDM1L<29 z8hZJP&%27u4yGt$jgBK#9>b+aF2Ky#(5ou{sQQpqC8lbo6gQ7U=4>T)_7 zvu!$~6Q6FqXe*HwCn>qMwp4#QrN5^Jg2iK;V4upP;h5wa2Vzesu>nEdN~#bJ4+lLc zHok;~v){i;5U@OEftLa8kVQPI=XM5YG2NBhU?daHe=34mv4mzNdk;#=dz%zXFI<21 zsY8R_pa~OU&QDKj?R+oc8&441YZnq~aM?Abxw+W?0P@rhpnKJ%hH@;{_VY1_Zs&vQ zDYIOxu(%O2y!;03@7>m0V$g&T7p0 ziS{!lKs3eNrIf2@y)mcIv=orJ1Y)fi(a~cA=JgahG9A=u0%~LEvFO>Oa{m|yGTt>G{S}=BY;6^g46LG-K8$`!&ov!0m(sYb+d9W|7T5Jvfeo-6jN{sTM!;qE~rjx{5|Sw>Cm&x`Ba@YWf`buU7Dd zyMJ$6&v{^jCS+Wd9^i9XxLCN=>UtiD;w>Y@7Li_QmyujV;5P@6TX@Goipo(sAuEV8 z+;dA@f7^8|V{)f|n;%1(>Wb9ms_h$}%!h)$C;0bK*7dI!d`o>w*T;ID?6-Hu`zawM zj?e+*05M-l!SMf@2UJJocmfh ziNg@R>$~5%Tj8(8EpPT*{i41Z{?NW0`#Nbh^PMxq7X9b5k$^0J-Og+KFz_dfw67Lu zS{I4*3$(q_H7i)}ZKYfg$m2N3K zH#k*rwXkjL2`Mj0D{1KC`1zi&2io8&N6bg-Uy`5jSijhM$M);}h5j&nA{Op^ZKv6` zv*GDcL3F%?7mZgv0b#J7!b4xju-yIGGyJ73TJktGeGkPtZ2EtSbbHBky-EpGtdUO{ z!3?LNJ#pKma&kfY^000Tp7q#`TSKlEII)%p-3dLa3^sD7at@qzrOb?)CGzd=M#l%= z-l|VzvF*yAFBl(6G!ad0mMplyQCad$jGjTyH9!zdr#roQ_N#(qJs+O`07?o`CKF^T zqqknit#ld(hWuCJtH11@4CyzThN8t$Sx}S(x@7dNp-;K0ia&CG0{;NP8T1bl{58}3 zfALe}SN1l!btG~uHl=pkxg12KpS_;dU&r6@Nly-ZHPiL46>1vxrQ8dz*M!#gMY1<1lOBFw(yBLRN_RNTf595YkE2E66pd~);>8)%{m?s+UU1ht zw}mMpj=N7viASMEf1e2?ZN`17NaaidMh#-qS{qZ5XU&O*8H;wU3pRyA#sLaO4L(Dz zokOGWZ;17;1Z#G>mxVQ(&ktP0>gw=0A2>PWXC15ci{L-)&7kc`QYIgAViM-cg zsyNJ7DhCDqE5Xik-)kOtFL{0^TqkqxcrJAPLe>kdJ5saM?50mLDPWK|k$rgSP&BYb z^A!a2ugQo&1(J83zTrloT_~XRi@K$fzU*Z%{!{KcQ;Xl9|Yp4XK;&l5= z(T=2sBq8J4ykcM5L&aVq*OmS(e%iYBqj_&0BC zKj5Oj349l$>7wiQnE1k)noLd2@Yw3eP5=>OkUH1co&o;=g1~qKLb|iid^h`BcyHoH zopQ!mV)15x$pR1u$R|`xXWuxizPOoh10;{o{Wty!3-D)J@T?v(@kW8+`=1Oz5vSEW zA*@AoS0lZtB=O%I*V+F73%o(_Gxm+pVetpR?~1+~@mHG&k!>3ALwOM+g?QTqPqPK3 zPP&oJR+Ed=%GER<7HAUP={_We=S9EdLh_JHFJ>6vj=dZ)MEQo za#&n=w?mo`0==fAEJ==>D13gE>{>UE{B>nxZ2C9E-yPXa(l&d&_&%gC$u+}MErH(* z!fD;Jva|Tr@n=eS{Ev;g#-(t)%N5*c;aK{B20uFV4Hx#D_~vdD-T0@$w>CTvn@+(a z>$|OR)yh-Y^{D4^Tb_@k{?k7e;klMu%O3=5)q{v;ZGT8(MEy1=TEx1 zZ-uvrB$i!z#Tl@kZHunq>(5HzmJUmy=~B(0_c{pw0BGNXKsVdGZKi1qF~!+2lbY^y zkBL7I_1k2-(tKy(yUTXyMdA$p1cO;R5=T@qblKBeYWh{_0?$*^?%4DZOs${D)`1zw zBZ`lC9SO!uLJ2Kxra=_e@Jkrztbl>|8s>Fh0{Bx|MN91#&9Ts`1tP6ik`H4Ra&r6= z_JR^d>o zMo%bVff%kDPuXJ9+fMr(j;CtuuFQr+Il(03^{$BG45xIh~BcS}NkC)-5ofAQF(`vR>h@M$82hM%>W7EBB8i>#8 z=bSHvZ?tV{b(a0u^3ZNONLt&{f48L6;Eu~yiX~>+*l>3YbgFVjQ>2!K&lawuq{C~d z-c7y~ltxdTjAY}ddUx2hiNyZ^YL4dK*;GisHZn2Rgwc;H8Z~1SmeW1tfC2)Y-Dz(; zM*`|A2-Y4sj(KIy{LwVv63J17(u0o9Rde%3Gd|@5tza_1%lXK*cBpiaLA9}g3_$aJT;(v}G3m~32 zF5yy1gtjtObDWCuDp|9xJL-DAgKuh@4wQk`Hd|E;n9kN29!>LW;~) zaU*U8j(Dgp2A`CL3l`)L&a3%_BmgN1>zc|^H72)bcV}e^fcL9XVl`tM9pvZhQE)89 zeIZ3jT)Fi0s4rL&n?VDpqy%E&rSgGL8F=Hlq?LdG0rUIzpbIdt`Blyoj>eqPtGNn2 z#%g5{8nI?T8Hij{5)H>|=K%4O(z9^^l0^)+0Pf2U209T>mMyu+J9~Ro#ED3!Xk0nj z9^y#OYW$;ekCdwe(ySvZkjs_|s)rr@s#rHfc`Pd_D;f@MvNEXwh(4Vuvn+A%7~}H& zD>oBJ%I0PSvj7GF7o_5-+kF9*I z@rU-;_%-mKPMQlFsC;MQsMVS6{J^Oe2Mvt!I#;`wZwi2jgF-WtnX}JZ~NQm{gJ1 zO)iI`0E7c_P<2tyzqN8Yzl!F(NNwUpiC2y2IU>G-nda4z$y{7dCRE5-4)TXXc~^GB**Na4XJrpA+qnM;!idsmB#} z?sZeAV~M`kudk#d%yo}wTzX=&6)7a}MZFJt@Snkbb6cGyx?62CPe{a=nF_o5VAs^18}N>e;hR^rv$D3C zSYynQcQ`%B&3u+W8s(wuQJ{6u+s5F?&d(x{FnuddD0ZO$oOJ`zzIv@oo~1b0($nmo z>f~BLt1aPO%DLo^TJ@g_d@s~Bd+5^jS}20#F+-f5*{&JL)y~NJf5ZO(40Qhh4_mBl z8Jg)pJBi2wyQ^z8w%HVHSJT|r1!{*R>KbWpEAHGj`sck|SX?5+cVzxm$;{4bgyT<0 zgGkv29lM%}3r{uVCl0-Sf}b-nEK6z`{{T9Hx2bsYfGipZAYyWPIO$ekie=i#o#1jkYn8KT#>DFoRcQi(d+|?>8AK9E z85_v^r==o?6^mdkw749OwAetALC4GV>p%{bRxQn)xE(5uua~-KcRTw7=|ey;+_key zlZdg?9V(O_e9bT|o!P-rj0(lYfd2rr%WBT06$X2rwFRZvnI>rvq}jj#^`U4c&2ZqV z?p!|yfl^H{j#MqQvkrh`6@1;nA`7dSen8<-`qfB?mLgP=hxoHpoy91QC-+RQr_CM! z;Xoe0-Kuz_5QS}^@t$d!6)u`Pmm6`AK2wU2FP?x*o!(*CNg!jMDUQT) zOpz%0S&n-8RMK3z2<%MU1;&2pq%>B7c-wJTUzGEM)9XmnD-0}*PEStefGbFnI199o z!@V*%C6yf*mIzB@IK^pA2(KGlFjDAZP;xSJPMz9Kf*>)wJu6TvO)Qf;tYe;-Bkxfv z$Q5$DfyM;|!*Zmn=fSZT$j8f&d2f1jaWaB{o;c1a9T6=&Vk88F$UePl65e)IP=dY4 zpq9E6<%&qZc&n41aoVfKvdCURyE)?{nhYehB#tTWU4C7WE^^0;xh2#_20(x^pS_F| zL9!~1tO?G^J7=b9GOpNi267bRrfWGvQk1MK%JA+5S<|2$IrXXFlXL-f-^38unMknVu zh$Qqj+BLYh*s-Fq=Q!m1Rf`=nbYbORD+iVJtqvJSv2*MYa;(e~JqYVmrHP{?C* z?@q*(76T*v%13dIwN_Z3LI*eWVl=Bq!t)PzDaZ7XSpA2Z4W{IT1q1fAq)fky% zAQqVRB-cprd1zTj1B0Hm(-4zGt>%93aA0<0qbReCbgZjE42sOdxb>>i zGV;pbI*icdDNCTRNS8a5fxskl_l;p{8k}}w;K<1gaiNuq5H_gwtfbz=rF{>L{ww~{ zT6U8q#*^V`3u-1XWpZ)1)CTEa6nLM{{R}O#^8Iehpgnc)66Q*8cLu_2e(S;V6yU*1PsQhI~dMo%Sb1; zyIHN=vH`~?Et9c9D3BY_c^65qwMakE##fmj(RA^D_aXC^rT5(Y8P|a!qP_N0sU*0i&vf}EpQpsl1|>jtDJF}UscxD6o+Y%;bz8rFB#|Zu6j=r z+G$aLXh)ehF;H>AW5@NR<#SZ-d4G$1Q52eV*FpK-6}F7A&3yj=;)IJ*RN$EpObUKu zv0p~iWR4j0i3*vwlf0f!psRYLPo_I7E*VcFuO_6Z#^;-AI?dGgGXlmm$4qzite3eP zR1#Q@wJu20kr|hFEWuVRdS?|%J4s}5!7JR>QkBKaV{X??0}MyaTd8iSq>gb?WH7c% zY&AkwC|P;pfGh667#xa*ciN+ADeHqlyku5|q*Ib`K9x6_w>%&4pkxv|GXc?mohoC1 zMF2^hkVi^j-IK;B8YEr(bN>L>r5PFYpcvo@&j+PT5!<_R=7AE4BVM46aaD}3xa~bU zW`+f4W@1iqDyu$lNhYu^DU9AZ#W-$kVM(IKq^x6s1hc=CzWwW34L@9HE+=0O_?|mR zhem1D~YN6U)RG3bbrBt&^P1syBUJQ?t_#@;!;Hd;Q7b@Mt$9E_hS zC%@9SjXvVCKDpEX0APQMV@6hB2 zmGsD>L*?LY81<{NTMbEcJh12y%1*`rds9ELS{>Zu>MB|+&yvlQkVaSORi?B=3Au26 z`ijNdp^TM;jiDJsjt^W^&dS6jWAvm*){REp$^iApHBxw(5Mu#{rYmUN)7ljTQwId7 z+tmA3owS=j*AfS{4&dfk%DZql{&e+aP|V5);YuyvQhAvoULv^(lDNq}mA!2hhP4ve z>Ne3`LDLR1_}5J~TaEQULH__@pZF->?N$E(1jX_H0EYZc@H^tRx;z1Ys>2?q;VZUl zjXv%+U=PU03UTt}VX$~%(!bLCM)-sA1NQ#-H}Lz!PWS*rXymcruaR`8wVx<;bkcnp}^+^%u>*4Kx;TXhcG4-zPX?M4ik!nySok+e3@ z^myb+P&{s~hoJ|pKCzNIBEpK2f{M5;Oy>F@DE`(z6EzJ6Nuc%r^NSWbTZP`q7As=}N!3XfK^9m{4{=Q40{%7Cta*zBI)c(hRwmqlq z7vQ}TRQM(FE?1uYkuh&$taT)?;dh1)&r)Ceynj3s+Y};Y7*ojSIj+d94bsr(?%_8K z2GP6eRSVogtc#7H)^b)es5&{u*C1hqINokk=H!n`NX$H_)mVaRwQbp>@th zYNy;0p2+FAvTgLoV^E}WGmHc8#ZrAri?P?}nhn+LUUSKE{#X-?e83(E;8)K+ zKK-`8YOjeG6Q_!PAxR#L(=>w3231s#yT%1L`H-;Zm|Of#*EJ0-be(rtztka2gc7zw z?(2`vu_u#Gvx9V2>adTWa2YCVWXe=5OQL*7)AXG~O*+Fvec{6(TZCdrDo!(wmGmFQ zUxS_i*St43i9Q+MSy`y@}!*nD5CxfOV~yBPypLD|=RHv}!{?$io@yS9GXu?x$vgHjziWr_a8oN2nkpnHpH z6Uz`BbUEvq`0Upz)zptutyDc4c_S*!%;-m`#beEKvfwiwE9I(EaW9_cOq*5Mmdc+> zu3+9t4g0g(9M)Ip4P2t|G;UEr#%Yp5%D_4mUNB7~Cj&NkAAUBlOz}u<<%o>NHu~a% zTCoX;Gm(S1)7IFrASgKX6crfU(TXM8^C&Dh;B={$BHKq%^yyhinv%x^izy#;8o1Vq zuI!|;eKAl3LfDqVuRUpHw@AVgHo5DL^wJczDqX|`EY4TnzWe_Gf<$<4`$OZO#*5pO zifC5FOh!Y1vM4=2L0@&iT4JaEAJrZ{XxgOD-mewukK&&pVY{}{S%w^!+KzFIn(=FY z4D0$}He&kTeU4XpK6i6pveT%3YmDER*@sTLw~?g1oQKc7>y6`My>itIj`YUyptU{f<5lc$4;l_^GOh^s5L9S=g>T`|FnBBSk$) zBw&3{V^ujT9XM(n%>E;PX;0e!0ON1%$>WV<#-9*%-CM&S52m?ur+8-0;iHA^a!PsN z96NN*ct5RDu<>n^!-*m2V));kaWl$d)JMMuh9C8HUi4VZ;3u3c!R|e z+rg{qa?K2CRTQxSN1z^_)x*v-cmmyA+*>1{8&`iy^6FN1J!*JZt;#x=h`cc@5TTyR zdzLuZVjI5?TEqKShVI~dSGR>B1hML)C$1|GZp|JVFQMCbbL=`jvmFOe)bxp5ZcnpL z$OC%db^L4DG|!7)7d#EEXx=EW@mGno&3?u;lHT^p_Dd_sNEr;Qgl;_#HPK5F(>O6W zD79-J&@b$3{{ROI>OL0JQ{iXr&EXs0ioXq{NNudVWd*8>%_}MaTciXQwzJLA~;td^&EnIK?Dw!^f+pXqvtW0 zXB#UV^mlrXjI^iJc~oNb1;sztNP(;~Qa{xp!O{Ho@;;(rlCX$13Ww*q1U#wC{k zFV~(r)Ve|KtaUmUiUsD6s84yQT3AgOkM{-nmnR2r(zkT|Ye%^K&CUF~*kv{-V1B1O zR#L+wNa7h4-i4s*Qls3=v(64zcnksdthoFuXJc-zYgA(9?(_p|9;E}{ET_`cIt zgH5yWw}rI}c132K-bkBC>M^wRsFq(NvX*+D=cMVMv^*CR+1lz_9krB_5*}Z+pp9|v zd8r`%r@RXHQ`*gEtSZKKnIeS9jDOi6b6m2)$vuwBdCVHQw;$~%@PEyQ-siMyzGC8GGT+4BUYC`X-AgQ}?8|PCpVWpS$>F z@bgiXXPd&h8%$T_bcin=*y5>Gk~HLr&uYH{ei>^qLk0JTqIhGFNU9D1V0bkZ{{XF$MQZ8f1VVd)eSM~tV zZZ!)#{WIb(i7nna1IT4i#rt~tR*Muv!y@*j`wc~PrM-o}#GPp+B!MHwGNbF(xoa=j zyT@J~)GVdbylH2xTE+sOF?_ah>V5tBs`|*41M=JU;P`#xtpnm++xX`~)ciYdunj9y z5(zDCkT3AJOpXQ*JXhww?F_b--UiYh)#ubDZhrVU|MT+Go^vGE7M{Y2^i z02ytrCbW1FW0Y-i@-fe+<6l1h*B&8{R{f~FC8VnCi_9~ffc&^#fc_lUpX~21ytwJP z^aN?-*hbMa71}sqf;g;YgUy=+{KucdzdXdtq1P5)F&ivMg!Sb5)wa2Y;x$#y{^uPl z&6edBV2a%#VoqlC$68pe4ae^Z+1Lur$U|ea`#kCkV?8TwRxu*&a>G5kQgZ^dbF?y$ zSC6Mk&|9A{700oxnWZw)zyg=&9-g0C5x~lz!VlKDrLogYkv47ll;@|?tPPK~7aMbm z#IjPc?nDHJ9cnw7Q_NJ_+_&1>Bd)*qg9LM-<4;1Gi3n=ou*r&J20RdkTtWStdYbDTB@j zS^%`ssyI~)6jzlA>x zWYqM(2x-sbPZHas2};ut(vZYxL~9E2lv&U1i*f$s^QzEXNyh^Jm=Gw+d&QTA_;|o>ww4XI$r+y9KgHGQm*$j!ksN zHayz32RsXqgbk`|MIwmoI3Qw~%*!#v2yj<&{{R;iEyS@qD=K3GfyG>nZRVa-R7o3m z9XeM-7L1l@oo#J3rJ;?8ZM(7ezxvg{>K-UDZwl;s@;lM7 zykld7yVfqQ7;I-qfhTTzp0$w9?pcc#^vx+q+6cXE2L6Eb{Of+lOqyo^Tg@+EsHBp8 zIIaryZMo4-EwkHv74V0}9wOM+c6RzaJaap8N3U#G)A|R({S(9RszV!HT!zcL9tr;d zWLL>%IgRv-(DpF6SGzr4(kYccd%e!ky!KJjtQd&_Ok{J8mGgCLxgNABcP%Z1u_$m4 zlmRSy?XN}fXT$AJ#gMFIj$yZk;+) zX7f?PsmY{gP?Wob0lslmV^@t`M8uNB`f)*-G_pEC&*wWZIO|Ne4$v8S+&fT5Hl+kV zX_=Rm3)eMd#>vXAaB3wU!;G#+7!2e;%6^pVm-{lPAeCd0?O3&QMC>v~+YxMzM_g4H zCs|#TkC!;CO^B{!lH1ObH7+oC^{m@QceWGAtQhh^>OHEWCd=?Fal&2B=gxWbsO6Q> z;_|V$pPP==sR~`dZJmgGuRVP#vV$|W4sd@e13?)+K&1QqDe=W2iI9!KPc#(O$mEQS zuifLNS&k1b6==erQ9+xHiF}E_*2bt54s+KP2iatvaAi~F_4-g{GW@VA#;QR(Mmg_K zwPM(fLo0O@4mav*Ndm^9$@#yFH0TUs6SMtp?lVoYi;d(2LP=K6Pu7{Zso>=^NYkLR zTLYH|1W_JN zTNufp3YSc$_bR8&>(i|f$igtCLu0SC14VR&ZamYLMI3bRLPK)DXjyT$A0f|Qtp<^i z6Nilh22-C-qOAV$whjw>&{-^OB0KJ4Y2nW+oM+mp#Q|rTg6)NlR3G6K46w1H9fX5S zlz9szih!qoYT7Xn=wXgjGP0F?b{%R5S$<@7W=_pbuqgeU7Amin9N_v@p&KiVo^jT( zH;d4QS7r?yc*Aj@T6#w|!-m+)@79pYhjSnd-#8c?b*Zh~wl}^Malz_ofLb5i13fn38C%q5O@4oAIIfu0kvf#rkRh{nZABj%l3 z0Xm;gN|_?cl_ZgmUX^AtiCN-~8I(nq1a}<`TnvDfEI}Fhedz*?ioRc(kG(+$v8uBy zs__K_%Lk@=P%>+S6Kn_$;nzK>jVm)L#scw!K~X^@cL!-zY@Pre%~X~de4xQw&D;kA zwJu{`R3w(H{#rOx?f&tp{Dp|G3Tca%Tag%?yAVhxr8(k}Vr6Ds!1cuiBvojsdngFQ`WrH>q0YCTED@LkSkwTDbWfUutHN!%qfmH*jsUnZ$E)Le|iUeoR63E_T85UJNkKR7?=%kV- z4hY;1Kw-z@KowOal(GN}ta=Y$YOf@5#>JN5MPAoa5B|q>f49l&6}`xx(%kDl4K;St20r+Hy0_O@BoxpO{Kr8FtR{Xy4288cZIU z?Om0NyzvpVgVwCciFX>3g_)7ZLJw-9(knWQf)|cGeP}Y8B8jIW7qn7I9nB+JtsNFJ19X+a)P2hUJg1!nQ zQH^uOR}kOp5+Gq5Ynae=00Un^T394-TSob12o*yN1i;5m)v?jcYpi}kmM)+J!Nph- z!zw5wocbEBW@hBeF^CYZ32(=>ZEMM)+}T?l7C9|$123KCo!(&XMlp}29L$rDzqLzv z=U81OkROx|GHS)OuF)BPk;of`Ar@vs6rU*)DLuQ^jk}P>Q4uN73P4WJBcWU<=eMO- zXq^EZ5I>b?%(|1xLe_ptDM7Vy#yis=F4fw2}h&DURP-{MY!U@y7ec*E4CbYL^;*lElX%#Qe;l z=avVhLuQoepE+s^bEr<{GS3q+U@@Ji*VeZzbUTufqoZ@v0<%&&EP6JF_B|GLI)$3u zrrd2}R~heBwOfepuH&>ct17No5`8O5+S$Mo2qkEjAHsfPS}J67 zp5Nim1$^f&z{1)Zrj69#bE`qAqu(YIb-ShHVXxKDxL@ncOx>CbH$3-M;n)alq&+ zoTEzG&mmqx*QdQ{q+3ByHuL$=V9P){f^+)xsHC|l2qlO-8U$93RwULt z_;D&m3}tl{<$YO3IWpPC?K3iqbOZ zz^c>y!FKhjB7vlJUEzJrQ<4H%ZQdo`9OQ9~cBjNy{#FNZ{RK4c1LTA$`B<;871HUg z_FPCnJqA51rjj~iribe1{1M0Y3Aq0Nf|`EY`Uk^3UOhp+4ESClt9XiAZI7=sGuv^xb1I#V3_=KJ;zD6v|G=M@3^LV_3*4wdLKtg{{r)+^YqwDAG#p z(G(1le*s!kMpAuG#Gi{F5;aeV-w5PS`#cz;#9w~xj;Oo?N3 z(n;mZG+=zPW4{Bfe^7lHc!D@yBv^Ug)!`^E*H)6h{sPylJ`2Pwh1JUD()brQ-MRX4 z;f;MvNgJ2BiG~3r=RURRKLP$eYCp0M?L+YIUBhvgrv2Z4}k+50u>HRDF z--~#8X1P`;Et5;zLQuO`vyy2$b+gxf*699Q$nz-R^9nerUeJ_e?Y)yt{s;G0;Exw* zelF4UUlw>~{vAU=)NP}^wVpQ&u8sj1KaG1OwCizh$tOHwzr{{lAK&q3!5{EZFW8si z@9p>dEPP1)oqTtvTF-lTV=S5_)RBVLcWR`^B6rHR54gzhU*xUvbKrl(@7aIjXT)FG z$Ky7gE`{Uo3tfGbMJV|%;mIjHP5eQWsn4MuE25g{Z5MOPt}UHzn3gKuohpUQc*!93 z>^jk7Ig}a%T;)#RT9fRM+Z>aRO64!LJwoDl zm8J5d+)9Y}827DWyBo!vz2xq9s<(XS70=H+^UJg5+A)J$K^w+bHEcBb&Rv+cNFuv! z2*j6bZ+{;680}!gjC89uP&|vro*aEH_Tg-tOQ#oNss=XKt$xiqwx!}96;JTuOZ%v- z?(KlxoUB+rl=*^G(UtL6!qWIJ$37v@Uhdmbw1#jJXqzLE(zsQE-GM2?40fb)$~ujE z3@~`xYiBvdL%!i0MH;dC)=RM_s@i>}12_sj&sw!2t)yiw$w144&tI)YjpMPD%2zDo zy=d6$I*x^Z9dbgLp;m9i|3Ba=!`6B>;W*rfybvg zrbby*kDEPymGaU>1FNzYAA3DJ)GX2}24TD&I&`T4>lzdi7R6F3@-|63dSZc*wXt2? z7C7RiiY>iC?V6cvBFkE`V+e3-M#|NQ1&}v2iz!Csuk7}Dh*lsEQQob6n`(uSHa&4r zr`*v&6EyQsk$5j}pt#v#7K)gaYzRWO5 z&n#=vjV09cH!I7gYdW^CXJIo!C4Wa8FN^o)2G2`Z^VE ztbBGRote;RelYOcvTtlf%{o2bX)Z4PTM zx9FE?ZFw<{7ARB@Jr95Wy>)Fai*Mvx>-tuubl3qSSqiXo(DWz0Wa=bj?|lw->%-n1 zwAA8@P@4YAN!%g^C4tGnUS6VPmXkW zEG`mz*0*@alJY^sr@I5jYpcC*`d0X(|4Q53e~e`<9%mcx3 zpBLI^k6OIY7ick$K2=!=>;ODgGs>yR-yg7a1Ta8ZfKWI2S2P`p(7TZ(Z za+d?S9%QNj>C-3Lvvk?@=sZbj2A%OgL-7`>T%0VRgKiWt3j_`iAx(T-M+g=F@%loC8 zGyvd$`2_uI&a0JnJLu;#k5fZQ{kHsdqg>A)j65-;UfPT@ydlwm;~-#Qp0(eToc;pY3sm4e7Mt_pTb5T#@Nf&$RcCN$_{=QQ&VE#d9QDX1AxjGMHpp z6;9S2vycsXHIK%R171qeHSNu#D9JKM!2F4>SA>*K_-62I<$fq>KLUO^_+ID0em}j? z^<6G}ynb|^OThTy<95ay`T83ESpNXvqMrh-ehO+gnl6p5zlyv!VIT=CEW3)g-3^0` zu0TBX6_bNUba8QeGxJ;E-i3Rud_>f4plf%I*H0H;J~>jvaqrThiU23uUcuoPz0%L*O@6;-;kc=5+x=)=N%}vxp{Uj+->0d)5tQzQV33W9S$|=Clxu{isV$6T~^_MF*PUXO;V)F|qZ`Pm@nMnYg)pD_xBg&%* zM+1sgi~+e6DLuziM3Vu-ATVOyy!WXfQc!X4_*P9^1e_A2#D6hQg(D~xo953s{wgCI zYy!y`jX@{n>-46!L#rV;t)mX+GG&P+Sdf1eLAfJv=rf;AD#<61t08sH{{W>$6hc5r zkZ$L#C$VrtqmO3%NO9C;aB82Hk06r-wtChEwkH5($s*eAQJ@aJ16K zSp|%Bx_d&E1zxq@+N=Z}EsdBI#69fP=WwTOAFu)ijgIXkIH_)vluE=8x zkLymcfk>M1M=0Q43ck-+8HL78?b{X1HaO)G~3Y94CXvp<39%Y z3r4-xJa^)KFT-~5@D@h}ox2QYy?$|gZ2tg)pL{>?HM41d3pAL#ORUY9O~u2Iu^;cJ zYWK3-s#Ryp6>xLxeo=f%`1SF#<2B90>pm~lH2pqjERn|S0;&ESdK&YMH^BOJfjXY6 zt1afBz~gfkJv-Ow*h~y)$C3t8uVU=JB8NQ zyQ{G+%Fkl5Y=%`|mO+lyz|U+Iz+7$4YgHTUa?V{!=EX@;T$ewk2@=CD9i(Lh4{CyM z*u2}Ew~z|2Om{V*XQx7?9{y6?gG72w|G+^yo|gk{{T6!seBjkZ%fe8ro5bAO5{0JKXU`= z$4dEp&mNWHk6#Uj=+A40!W($PTSAfW1^}%)NTC=P1c%N61Fd|GYL{obP6;a_>cZ^m zm^dc@`d3k=_&ZtFh>uKxo^8NxWjj`|Vw~)KC*co-OKEDYtre2z0d{Qr-lo0tOVVs~ zyHvNew@4EoHU>9W4OwYplBI5kNo^2hJC}FXuEmJl{JV#zrFrv~r!$qx=1}sL9JoG} zBg)GDRu5c$H6*uSxZlB63c%*Gmf@OaX(VD#9EuF3E0$)pc(DFvRQ3n8K@42(!*%@V zB&m7kL=0>9o6@CLo;6drD*?d80%)NM%+oZ9CKxx&2;kMJ3$ic|w9vsJiyI6UJfG5` zl1-$nhj{wd47663caSVdr~GOdqmn)E5`iEbWOuA3xvX{@b1O>m#5Wv{NEpRH(VJ*k zCoz3$p)Q0>o-Oww00E@vciFZW1QfO zbQJ6&8~EdCV1_fW=R6KLsp4&$hu%0i8S77#jWQc+H!NC1<`(zqTFnwfu&OD+KQTS& z@&TtExF`nESxsvqT^2)+!72UZ>%?T8u%VG~bNxC5Np9h!W&|&M8i_{4*n9)c+?%#2IO*1|wXrc0&bvo%T9a7BiDH1pWJU#n?a)uNsv7=Gh$-bQHj^D2iDTn>kasVB-dt?M|VgWgurDde-1s zi0n942iQ}jZ#kMZjkbZ4f#24%oVo#xEPhSG$X$~oZr}TIuMy{!YyLC?rGz+w;L7si+5ZMF69@J)F zSdq_6)K;+E7iFGL-SqmN{3~ zT&`nOE?XEm9crvWYF{WRVe>E`^VC!X#;(lA=O-kd^nkPbhC~5dbwKE{IoyXINC0G>72Tn_j+ps35SIm*PU3%LW5I@6yaI`yYYM9QSHBQ8hEI?{0~oWOl+Mi(SbtUptwO3GGrW zk+d>emz5=NyMgzOGbtx=UNLMMDHYaa;DRc@n+$IplC*o<G>b&(3OT%kRw z5(2XpcLhkmTyiN~(J^O%e|U`K(i`=h})$)-D!0E}cI)PiyJsM#a(oIg@e zG}0VOrq~z?0>ii?ty61nB@3b5+#L0-;U0j>Ff=bb8)x$5W3=u(WYqD^w%{VLLKvYv zi1n_R$D%Wox*wRP*vJx6s98FkWG-sejJ7tH)@N3EVz6mZT&Lc_JmWR}2^gQ4IHSDr z-LHY6)qc<5L#REf!VAwc1}x{eteqlR;le9O>&EX|vng&{)lf6Wz%*fVoSvlCHI&a4 z&}NP{ML%@%57vX8Oz2{O+`Bjm6Fdx5@I@j%F}PTqZlcQ^MIvdZxsGIT6GKb>4-a!)e0(7a#qIC(K! zO`vJXC}($GtL^LCt$kDAe}{e<@K%`(j+<)@&D$`Zdzm8y$mDa^wQb8|s-2GJNg3IR zP`$VSV--AZ?4e{ojwu@xd2c@q303tSewBDzagZ>(KeQOeA>^0(JfxPwOo`R#2CRvN1P|e3)1qOF)$JB3E6Ny+I zidg$%zF+vC`$A~m3Asxx77=}RsAOpNhi7r_Itqt78q=okd`aTpiQXykQ(a4_>NAwO zVM$Xm&I zCBWLF$?8~ktzcy|dLEIZTs}=FjL20!oH30&w;+%V{Z-nn@P!2xs#?l;=3Ro z%=TFHn_!BoA}b&Rrw0{n^yyV15zK*`l|6-75?0)+cN|wyOt%UpOl@v6nxky1D@dqH zNPrQ>2hbYEaxiY^p!k367kWkIuBULYYAYc7KLqbn*Kx;c=B9g{BKk>Sx>qQFb+GYR zNtrftnx?fNQ1?&)BLaNDc_h~lJ=}^&gF4$#{z+7)f}u!EW>&5Jp|=q>d%s z$mg#DtNpI><~L(9g$vkqpy;NKOHjF%K;_A1>7PoEOz|!4ovYZR;wF9B+6m2PDH@^( z;(LjX5QQhMD`q_^7_eLykRE+2F&a_D7zGF;o;|6I2ToOi#{z>nMUa_-k;fvdPRc&# zB!kw2A?J>Ry*tV+jw>lf#*v93RX|AqR>hQ%+rn;`x0*U}P-=7c7t&8~%n4>E0FhUY znSb^xo8udKF#u&b`?)w7r*on@9JH6Mme_a)6*Y~_i!we~Fe3-jkmSwNB(ls|n;@Fj zx3qG46O?OPChaq%PK&Y|PGyQI^B(|kPhG?BoBu10tSb`|9@JB_h|cK-l6PF6I7=yiH* zQ6|=ufPL%IG>u9YwJ=H*fH?;hpF27uD`;1q+BsRJ-Pb&Kt}^vzGnR<92OL(BmBl8R zrK9+U{{T)Zvj(0Zdz>6sr)m0)hNiC1p|y`i_-A!s~=p zEKhS;IN0WtY%kfFLf`&b$B#I6FGQ*C&X@InB0*uqJ$s}nJlpNzV zr4&l)rz0n=RCF3Gyep7$SPn8hY2sr9P8|&E%VW94b<>waYoFbZ{27zte}hx}82zKP zi&^yBZ;x%_IUf2c9aiF7MuiQ#1?#gWb^ic(HGglq9Hh%htAt3Ll1K8d@&5q+3K{U))AqK|{sKO+bEEt#@NJpW zf8imG%SJUYxnyi{oSnJsb6m8ZFR?k@z5hPI6SfRcZU z(!B~W)f~RbUgzPIlf!8OM;Zh{&;fued*P>!uRa@mLC}0trz{B!*9mWWti*0odj1%% zs^OgF<@t^u9c%k3!gkvHvQF2t-rb*|v6x?NLUdo+O?~Re^j+X@8tJ-*kD+*nMQLA7 zxP&PV-*!Mb1KPcNQ<}%b`VGdPJ-k;7Dv-*v znzKy(+W!E89RAx)Cx`W4*w^CDtFy(rM2#mZ7my$oW{5j2KjLB$KpTw6d{{XjNF1~Ff z->K2g45B&h$XSqv2OaDAeE$H0gn!_SuzuQ~4(@+y-`V>^g5UO>@U5wmTRU_E{t^pC z$!HvPXU5`(*X8sh@wo1NbW=u%^p6Gja`VLZgG|$7^RB}0ASpOe*QI(+ zt>8@t+WSL-3yndww{5b;9(IgpwNsUjh{*CUk9Mh~U)sY4*lksOyeJthj^uaEabEeb3*MDw?IS6P;1o8Jx3Ef;I^g4^3F8jpZBGuCNImE3enKY7&5$o5kG1|GE zPeF@Io>aEGH*oJE8yMo5%Qj=Qp=ZI|Ffq?cdfi0WD8DDTtYx@IV&IWDAduA@iMu2c zDHNTGQXh~hB-UcAitNBS8ShsabY_a7srIqu4=^;T{m^lfUisj!jb0$|7MpKv;p=8( zQmkWXP9Hr@Mk0hN#lm`{c-22beinRt@TbIIvsm3~F=)EL0ZLuA(8nEf*jLc&X2YG) z%%pBsje%Akpx5U({I*nOZicrblG)RoZd!}%QjC^yv~!HtkvLe=GU&t>WG+>{Ubyt2 zTX}9vk~aVaX5EV}G+Uzz7jlj`9Vzj_00(lG$4{+eDO{+=<=CzFee^rMD%4iet7Iur z^y^qkM?_*=Slf-jgZ$|xjTxD8+3o32X~>EnU~S9`0uMRQddjE1a#F#nenURMWx#tcGNWZjB>2J#5w3cKhD2O;5goO zACmn~3pJ1KWZC;c;{7(#(IhkKe`=7se4$Q7c^#kjb*I{HB-3qYo?H#?yo?^z`u!N6 zmt$%x=xD_~hO1^8D5JJjC0SLy4R2`{_UOwLPO60CC#bJL;e*!2?-6Qx=7XbaI=t5! zmxyGwvz4vv?c>Wg%0T>quiy*f<%X-Nd|3F)9-$@OuKxfLUS1`%>(I#|Vt-okagylI zrORV?bIt5+1+|%PGctLMrAJ{}I&@aecMDyRwxPk4V>^>Piutuodg|?MAR^1n%A|T?ba8%Rpcop zl*(1ZC_A{VsmSK5O#S%(0E2ixYHe#u_{HOY*e}Lf;{O1`8?0D1tKpr}lF&|s86r?l zF^``g>>pbGs;=}ajR#b|)6JXRTtOo%?u#I8I6un1n+aCO%H}v7ek{g|b;W*CNZ3B#o4hFY(9nuT@Dsj{(xQg}qA2H0y+nYL@fDR4{1Y zApL6!dpo$qGfAu3JP!W=Dx(d+f3?j_kw*Ns&uaAasy?Qt-{C)Ed)TS!;K!RT>M(cB2x*fNQ<+H;aB9_@aAN zvG6vZqRP&`X|t7-V;qm6$7<3v%DOxIpB8@3&8J7C>Aw!VQQ^%;Xg3nWd`e5(JxD*0 zs#YueH)?W8E~|0lbhwdxv?O_gHXRRMD_aT4Ee}M!9|>&qeK$wb{wr#}D)Qha2+V&p z4e0!j$FE9;4+ux%KMAzjZ;o_$Vz!*K+Rr!dSfB2%elgOjGH4TTLkeGox0C4;UdQ5p z4}GB@%km^~x&6S%;=I>U_+#Q*=@0f*{+VnO{b`aCcY6c4R?4|ffy3(G3%pF)bkB7o z+gp~}(!dA|!_e0|bKw0>D_eUax6?CVDcWBjU;e#6Zf7bUWDu9J33&TayTDMR^9j5olJ`W zi0AiVPD0RBT#=Ke>2qq@-J~(xSy?g26WkCMG46X;7pnMc#9BX!Y_)4!ofA~qa8x{R zfLFc-PHH(3Ue-pgn`D}fymbrtFD+ahtm$ykk~`yR9+khVYID*;&+ALzhZx<*0>3LSEA`U z>J1iu6Y0|JVI*yRB+(3>qj4a6S0zj`mgwuFiL>0=)GlW69jN}&@m=|qSUfE`QXxLL z0B7l0KN^2#RruH7ZxLANz9rH1ty(QN%^PyQbK{`|af8NsSBZp3m3Cz^T+VR zLe=!&9r)tL`r2DvQ%`TQ%jC)TRalOlG1v32%0Jo$Jy%lwwzQilrifUq>~|pN7|%am zYr?Apq|x?t9rZ`))5!zd*`FvJTgJFO{!veY;Hnk!nHIk$#PqS~Lt+MGxRknrz#f&S z1c<;c#tc10d9qra5k)yr`GtyMbH^1y=le6Vpd8T^eFn*`p(iqy$zzZWY)2W$ELi&c z)|{xoTZ!b4V#W?n8Ki+^-^ziGO=Tp2nIzuj03m(qNh2FRUR&OZ33Fa`U?e?_pBt}370)hzUXIa`bQh@sQsnRt75=a#j*l8Ltt-8f7_|9?HHC{CU zjF1Oojs;|C5!0+-nH2N%>s3@VoTmU#Hpp&=nXq>pQu(g}E>*Vl%>qR@_V02Be$_R+ zn`YY}JG1iVwFMJgfL#*|uiM_AXXZqOSq?Mby#P*C-#bPctIqf-8yvCgKogjU$jU}X z7^IR&ywId_I5f^0r;Az(`u9n{u%OyHU~oQ_&&_>3<&6ol&ohc+|LU;&auRd$lY5%ckr!42>^MA zKDEs$bS^RMRi9S0u~H*cXTj=ogIsQ<;_0s(iAz3sfbK$n7t@$5ivzPabF_Vh= zcfr2}G_4sL^IulHy;fF=HDFVpQV&tZe8xX8`zZGC)O5M-P-)h-+oQF#7PjOM-Gjl! zUAK_L;w4ddZ8(g3j0(Bxh0wT>8_ZiZ-}?+>HA4 zpi=W7yBoJ`9s5-iYUGSlqt_n)iQ_^zuErR z8#dQnz57*NL7*X?HevYFjBEufX%UoyaC48XQk~n)WkSp`SBkiUl~i)X zl6c~vxS?Z<7*zz5Qx=I;m@}Ml&0{2MVzfvM!c}q;2XMx7RWDo3#41L@I~*EFi7g9I zLoK`pMI{hmV?3IU+Cw8u-!^m2Ze%>iDyioy>sDirI}Xg_uN`W+fNVZn%F;5n!N3@& zOB$78qvu{Tj-r~EK{DKM?u@F9tba<9SQ$d7Ryp>q6o`!bn#iUIBQ5iT#~p<+ZT!iR zhu%Fs>6#X9Er1FciCoi)#<84ZAKk2Ez^DYQ=WaLkz^k#ALVA@Wnvfj~VtbqfV7%pz zYU(s!4QhJT^g4c<8N9rZ{HdHAR?wj-YzD`Seja$Y!Pm)c;_nV#cz=3>37qZo^WAHR zl3%kB(VgfxI6W(TZdp=<`6?|a zvjV!aGC!6+QaA>ph8?dnvuAMIf-{5aC<1ms5UYcqr7<2(K_9#6k6H>*8z;(h8WZhV z^Gc@TC=6^Jfgpj?9<@!C%Wcgjhsk6JShsQOQ#9!WB1Q|7kVkc?E0Q zIC6nW7|+nqSwi07Bxf#%1BzwMz*t0pvMUT=iVBQKm|KXFP# z(MV&+%_~G@rk7VVK79=uVv<@0*&^!A{n(GszjYlLGP zdW>;MZ1&}l6vsI9ts?phm2PF+$Im_r@iu@#ZovU(1qnslg1Qm?fC06IdB#aRrB+f(PpLCsk63W4%( z;}{jJA405Gi2}LC?3!)P*%mnB4%s9#4%M=ka^p>d+cHJANj_Xv9i+iBxIR`m?0*X0 z5+%i>4mcGhb#imnaaP?5W9CzloQmj-j%u;&eq$$`ig!5c$j4fhqghC1!>_%6Lm!#O zUBeHSgcs!URQ~{4>on<%JAP8k-Ax8;=u$H}I>a0ejzngQrm6DQ1#hjY-@e33~Rk#bPyaSU;hR~Xz% z4W2`<`0IDtY`i`t)-^LHkP_dbx4HJG_)FmKx2gXCXzD)@FRzk!b!hEYVnZixI2G3z z+j5;3W9eNpO}EqGiYTE(jZh%%!1b<@Ew~(_fyX|Sq&TY=Vudilh+sL-^rp(t9lJ-& z4;ifNYNW|xxm*NQ`t#PNTbbl51YsUBdY-xTAFVgonKDMUk#|1UMdKXQaP5wAE)0l+ zKQI}jNt+|VCZv3z?gw%(0Ik)57C<+Ax!{q~kQU^LO}wbctPe)+1!lt+mY!KGhzA+u z)^e9XBAWFRF-F*taL0~1{{Z!?J#|EB--f?If+aoSsQ0v76|2K@|7IT!tA3m8hkPIouQqNaPP{$gE~ExNW&Jv9epb8)RxJ00}Z#A<;@(PU}x6ZIoyh)R)*3ucW*pKT#&gS7uLqY;b4uI zB}?S7rmJx8h~smNkVjti<~O(LF?B7!o-S?A>#F-94#hg=`JwGW_UQ{b*6dp0k}6) zj8YPpL8b{pte^(x)~H-=EPhV?C>Wku2RQ!#>rymMr)V2XeGJ0|EKuL)575RW0LFYA@b3RGh zHv0j^1;b*xNZCDVL-$9m1rAgk5(%kQdhvlll%hXqIRFtuJAwj^pREkFAtX}qg2(2m zW0h9j;BlWr+*TGX7!yY{P73E8b5iOWuBoXP7k4tqjH;}?0Rx~QQa4YjnH{q^Bn)<~ zYg<5sWQx)e>IYG$>8&d$ZNn!#*Q)qaz?WLo(L7QGfmjAO?fomNF|mxKdlskTUk!X5 z(qI-XW2$(jK_n_ff&88^^DnJ@LE;Y)>%J+!eM?`|F0SU>StDo4Mh~E-#A5yw^d(7Q z+Oai)H!Pk>l&(fP^IgWC1aYniC$H4hjk_1(X&=m14tEYct0Lumg1`dGX_L-~JhhZ? zM<1vVqBaRD#ydLA4>Mt~zA{(L$BzYNNc=p9p zYi4IB(7~1&18rsP*BvXCzLB>O2T$S$gF;p@F~&=7C*G!Sm+s`Zr=>dpk+}{xjH%gphhi^ZuNdWvM^lZ*w)Zy%T;6BKW87>ALDoILGj1KpS0iX_u^aq z1H~2+sMKv>W98~LnH%DgK8~yxq3_7%ztyY$35EXv1yKE$zu=``2K+bU4~5=1(X{W1 z(AmU1LE+1(mMhyEoDIR_I4lci5&%Pb=OAx5>2b{~T>V8~7TQ^AU)b8Ct*zJqjl_J} z>0NYE$2tijVCn5#bt#zX(2|PgYoLnr+ebGfZIE;#s`=8{{Ie@bA7&MBmq4)%_M2m@ zTekEJNZ|hfjeP$Au1VuBh1c`y`gWAs=Y~lyG#2ZbWABhV{W{jsT9Gtt>AxO4H+`Vq zc%Jynr)gI4Jo3it``jqWO}%$}SK#OECHqfLre64?+uc$Ts%)ssqa@ZwpAd-DQ#To=Unr&!=h@ZZ;1Nf1<8tjQwnfcrCGvHT={2vYOub`XH6ZldrZf&`^ zgr3YhkEMM1BS9|vc?enKA&L=(i1s8J+nDTvO3xthvDh_-p-Q@B@iqnsBBTX|8HZ*-0*r8Y}s@a?9p_8F;&u zeOElF(zIu3FPgLe0Lhayd{W*o_<7>r3VdVuXL&A}<9!P0FD+z7AkK<%(HwORf-zs( zkL&^aYIsZb&G-%B--wze<*lcTtzs71-kH34mea2d$6RC|!oLstW$<*XU@*DW7~k1R z!fh|JJ!0ESNU0{Zd(AD`_g)9_8}_v_$-NrpkIP2BcTeQc(S0jcONf*g+Humg9F=#K z6(kI$Bt{uo7rK$&zt31chxC*W<179S6aN5$6W{zplUx10e`0SAi+_n0%GX{m@WrZa zO?ovMX;B9rZ~&4A-|9YW?*1RN{Z20sSV=$GKF5Cxm~U-l;#)a~1sP90YpO3pV+!ub z?qa>T=~!2Gjmm=2pQl>NTb%6~o>a@Ytb`xo&0L1*o=+}NOoM^PT9FpM(gdok42ljq zX1yOw@Kn0aohGlK>Nbx^W}Z66W4`HVv%o74mvlrAhFATGXNb z-thLE*AYH^_>i0-?8ovnm66|0k5aX_!!HueEP8m;#Cn&=@3<9Gx#wxGqO^b6OG>@) z`s6=~<{hWMLpz4Ni4-H1fXzlhJlM5=#8T-L{ z8r{`?9p3n8J@Z9jHl)#)Y1i){8U1*ulNYl-CisQn7xCPhp|{p-t=7#NMrj}T{Q&i> zFNA(EPlK9gh$gYLhW`Lry2`~QfD;MEH!f&{(!!J#j$gz+In=yE_Id6jj?Ul$B=XKY z#wRVxQhfcR&}ItPv|R`bI;y@mW(U){$pT^RoW0baQk)$L{98x{@^Ao|z9V<;#|#hXQq zUptt?KEc+m#@lxS8HYid@@gYu)Cl|B0Cs_zv{?)7MBM#9`t^jChOkDZy|X%i;D+z* zS~Dq#0*YNm1_feoPq7q=`;~$n#Be{mP;8P;0yg3L&}dKgM@`Pz-;cYIn&t0JFejoUo!&g_r$5Ok87Zy^(ml#!M zQ;vPe$KzkaXYE(;*H-Ws?IZDD!`J#<_=@LUyqXJ%8*pVZ61euqO7OAA*JTwFc70Ek z@BB10%eIF8IbseA1K1kpBZ36Uko>B|VD`bUo2|L^6sC>sOT$_=yKQT9lT1`E%v1xn z>0UeHUj%)ENsXDF?$`p##9+QFiLQrKWO8;gNfW|0Iw?E?FhyV0<(-to2?zR8QfRlX z#}#vBbtY3XFzP@Y*F)iLDXp*VF76^}AV~pqZZe?srle;$=zAxKwM{=%)^6@B72>hT z@=?bsxamii0eD*2mO!Asf4y7MIp-dSbNeX#MDY*8uiL}+UGeXP+TzDhw(&i+w9-N{ z(?c_eq(TQcDDFQR{{T!68EY1!S2s|kvB>tYNhtpFv}#Z1n))mvK6^FNM+c>Nn@_Nq zO*V;Xc8bK5W*{G~2&k?vt#vD-aL}YMGwV%b8aDd2mM68>HDsM`MnW zt#*s?i^EoMPGR_8s@rOwVzIf7bZjr68Rzq@;fqf~6&AKSgYieAT%FXgKEB_DdXnpx`)7m0J|ok0#+EQ-Fw3|R^f)=L$Vx0t$sFFhuHWf)_UWi= zwrDq;+nJQIA68D)i*@6zOHQ}E*DN&~86|~OyGp76S7DOW6f)<#4wQ_FJFLn(FJDT?Stb>7F;zymJ-I^0UPq zgJaDRoi_HM%J&q zPb{UDDaX^viqZzFQwc^yZfK{SVeK3418D z)g$eQLrWSKMUF-Q?Oub}R*N7ix%FO&vl^IxwvZxWWeBWA{NVi0x82r5bYco_P(;|gZH;y@{`Eo-T`=z`3 z&=x4&Gnr$+9lr{aZL$WBe@Xy`CP?v>JbHJgGb_1pn^(SM{rLv&4X~ z9>#znj_J!V$H|(AZMc~2VvI3OD}f`kL_TI4bBz1bZbhb_YHu}NS4q*K19M4tIE)4S zde>DfJ9`~ww@TQ}#-oB^ey?Uc}WBC zJ?m;D@b`z(HMfoxaDHRm zA;}pBCp_1o6=Q~VnEP8PZV6nKZ+hq;(vkz5{M{*>lAX)V98tpCfLwJoQZ+|XRF+<# z&}S!Ntdaz9jE-BcPAQQok=x}YV~Tg^L}bg0Zv6mly>fb0xS)h7GMoT;q-a5Rs>5QT zVO19*1SQG!^|U|Ks6HF+B+N_&aEu_##mNj$n44-mOVPwa<@W_3wTD-#1=g{ zt$Qsz&O~u0_vy`ZR;goJbneeY@V|jIKM^d;Wp8m22WOhmk_SAI?O#oJPvAACixl^o zzO4qQa@%okv3#96=hnVsACI<(_b|9N&vMc2N`bj^8{ zBymiZC1?vHtbh^n9-@GxmM02}{6n19CU)*wQtnkUyL<80v+iV)IpRo{Dt__wpd_qn zZY=>)+glx~tO{Z~8TVx4K9mwgBx)rAPVdH>DoGwUAC&vhBB(Zwd$s;qe z{KGisrDrMj9f~<7Qc9LkdebkWj#7w|NOSVwW2GUYTQ@Q^m>XDeR4#T$G;qAWTS&!Mj%c?+^|5&sEx`qf zrZ^|9QbBJckkN@S-TPGXB3zlPGeTndhbN{gm5d1!Nh21^91)&|sFKsVuJ}R7J^N;Y z(?o?7w>4@E3l^|t8HRUss|^lfDj10~*ZNheV8{7V!?r|Ru}(}FSx)Z1{c5P_ z?ug{l#pJYwk&8%UAIhr2#wQ1th@1ikO2wkh3Duip7znIF$~;$cc&CjDEmmVk`;2YjzDi({Vn~MG{1xzKfrH@KNUVA+UeH*EwPeo zYkQpTkw8)9?LpkJ{XMJcav4H3qU!9wugu}cDSI}dyE`9(KM{Tqe$~GXb^ic^KN(n9 z{7JNVrttowb_8!SoS4cU<$4wFKTpjM8TcyW!J7WB;S1UA?zIg*^DDVJ@{oE|k*uG171}}1 zwF4Py!PuD?9)4U@H!B+4w3ytZiU4QY)s&6fJ1@OOAv+t8?0Zl(A~25{18?3S^GJ&_Ct0)SFMF$ibBCW*8qCKI6z5NX}XJQj~;3xuTaVcHuefX!C-JNnDZ(QSw z0D%w*C1hWhKAmWiHrk_dvvvAVBD^m7WScTKML6sAt7@_$hE&}k>CIGk8A3Jl?-`^F z8Aq*YtU@!DAgLI~rECPY_N#2FBL!O|mip9kZ!$8K?bPv_%3F;wjphJG;;cSyJJVuq z>mYS?bv?&gl9YzbLt(d-$6R{ToVJ3G%OFL7Op_ z8>pm?Nf=BA65}8@y=$b1sK`-vFys-O&?317w)w+x1LZxj=~1cLM%5(uKi#0#51|2P z^OzL{bNSQTGCA_qjyi+dgFz)%l?g-`QORReP)w}Rf>ip@BGUkS~gRHD?T$ONqn$VfNG6-!Q`1o?-&)`int<; zV0PTBM?HE_OqoD0+6X{KSGeYsTm}xR-fD&`oOC0tQ;C!WSruJ2!Wa|tFzhJ1Vg9oi zz&Hvr2&ptnp%gJ7*uWMfWaqUfksOn`4poAXzMqv>D>q8P5ol&jz%DRU=R2wy84=PKP#Z|R*gN)&Yv{$4MH*o6%NmQlU)RJr17do%An&Pg?~oa{Gii@ zCD_E08`KKawAkc%mjWDfmK+aZigxH{DKvGOeCZ@>gPe3e^&Q+U&Zbud@=pV$NgV9Y z0LJ7#Rd-`J>q&1Mh2(}MW0H8rPCC;_sH>RT&bMWuK|S7~Bf}c5MnNU{>?_Qow()1h z+o&|X38wJ&i!_BE@?3zxbzfe6MRrq1R3X&&{{RU5Eb#Aw{?3|hrL2>rSb0g_cXuF~ z^f>KPC7HJ|=RUPBl0ajWLkm9x=$Qq$eVqS)m0<1y5h_ ztjYAqGb2LAFbO1M?k}k|B&N?D_?P3&6Tr}ov!GN5Vw?aw3Wg`0)R$g;g<)f%4FY#9<)g3% zu<2c1hoxLzNYXSiAR`?);)P7vGtsntE#RGFz{wc^b!zKo@D7jS8KAJ$1WPNSXxZE4 zQ|d>xX&BjynIp+OQQ&V9{2|qJ^P}oE_xeovV6o?F^PC*|;=b9ivEBWWY1TAnI~@Jq{-2e2#;%vP&dDrh-wefb z&gIVpRNUpOGZOOc?d~+xm65lQ{1AR$@vSR~q1|w8B#~|0Zr*F}V~#(&_*VmWs5GqXWJP5;PB}Ch#T?b; z)Ut5yO7_oc~(M+PuaYVotd>r)j6ESRCf6k(}^xKoy&KasvFmwAL9To-;rb zDNqMI)KaWKo!f(T>DGai)DY}?ik>$wg<-(<>p&JU$9(sz5y{3feR@zLX$W{p1ZOpu zJa_>2ptwGTQI#Wu`Blim5XH)c9Fk5piVaKpU8Vl9FO{R{9wF9b$j8~O8P$hO5mrGR-bO2d@&nBT$~QD-kzxxN+87?5m6vi-Ku2-M(xu55 zi39{GY<gqscMqJBelaQJ2Cf7avIK^B4#0ORac$Ba7}F$Z3W75cNV~BaP9dTfIMMwj;5Pr zknccFLt{R){{S#Fn_~p~Rt)^EajD{A-}X88tA398Vwc7Qx-O7^R0Qe`5{1xx^ zIQ_n0Zw&k+_?KutBwD81jVAOMW}6%qK-dq^{oMP~ogHx38Vu4T-#fLl zfDzAL{{YIq82Ewk!$R?LD~%{)1;`9$1LX&4T1$j&(Qt>GS~kf_n}efEvxPlI~? zf#dxqOUtX<8Gu=BqREyVQSf($d~>GVyZNfCc#?djAN}9XzqUSz z+-VvW>*Q6XZ)xwrJ6oA)G`hCqXKi$gdTW2iJZa(CV(`$$(pQx`-~2E9pXPmfd_^9= z3>tm1`PTN~l`uKMIp(zg0A~LH+F!@Nus6orFO6OWvX=Yd?bNFmigc3aW5QboWL|-Q z=QaJ2#{4ZyJIZkxO=o3VE-AHsSG;9wtMbaywbkuwpU!+ana=@^qm7T)l5X8sRr6P0 zGy9JCEAh|3-yD7$=wBDU8*7%jzlC)uBe;aeAS{KH60E<%LCD2@3846eZ$gJ*$7=ro z6|*b_Tpl8(6A>O-kdus;XBTF^O&{L4Y)mS`HEFxXNi_VP$6h?0lcbQxcVjw~o(CCO zQ1t{?@WcNA2L=BC!3H%?4QhTR{l0%;FARO9Bxx@^Z{Zs_Nn3%-JB(+=t>JB3!M-~JOYvfD zr^IP>85vMU2n2m=`!oLlf-HW=pRp~!z)70Z;b(&UUGW7je$#h8w`P}j8yl69KQJAu zla4#%*0~%fYci)LvOTZ<3UB)te#_c#!a#hvYP0MeN0tI-K2g=Yf@apeJ7oA z9iQ(sZNvR>SQ9y7z@tCQkEL}%8C0rbTn9ui)q8PFx11QZ$-|RYa=M1?lfx7;havJX zzgoqbM`>#xTnTd0bEv?7C+C#kPAz1B3l2Zgmw z9$BIXEh0DoW7fZNqYE?fTJY*-eY;DV-gcBg5>tc(atF0RVW#Q#D=Q16je!9{9c!@U zjWe&)G;2{ZZIO4O7{Tvfo8RzKpV+Q%ih9kD$4xID8_}c@$8cd$nWaVNBz@fBtIEYu zZ1?bT<+YFJC*lvodF=J=b4j?K8Dok~$l=2k9k~1}=iO(+;yY6+uw{=d;Zv3!GhaPg ziS)FmZ4Q4$xxTV_hMRDkB~T1<50e@6>t9rOCq(#H@g~yKMAR>AG%p%Jg_F))CBuRD zRk{p}es$(lrgl@Tc|VT7XG^&JPWHYYi20%>o9u=>?Db&7w?D0UA^0WZ4MKAiHi|F2 z!5YNCpD_DZJ9a%7RE@5V`Y(VQ&xWE~&k$KUwgGZS2nSH!mC5*zM$*^Jn#FCRk30lB zw$v$;I;Wkrq9lL?Vh^=J= z(?jO{p0+&K#{U2jehd5|*Q|7(9eh^s{86@8{{Ut&x^=<93;@XeYsGbc+qOL~Qoqwa z1Nb(5N3!eMvS4$93dToc+ZDrz#3Xc6pm_Gb5kSypDSwjv94 zAaE5_XCLERIuC(tR7TQTEX+^K=6uCZ)Yp?zyL%n5ppRzK{3Qy7b%jir=K{S3!^56d z50-fEip$zFWl1BsvGCqdHlZ6a1v7VLV8f&4y%GKf?h_7$`pkflv*b6TH-ZLVQ3y}C%9!;IGfH-b%t z#J8GkmwIi%7zWx_kEgIWKZvcCC89loFq+3#(zQ#yXU~@A?sO5z)Bf{t8R?##Yn1UN z-S(#hmTfKNgdh=^n64|To-pQ~AED*CMy2DQ2KbEwLv!NK3eL)`A;+HH?9+$ZxbZbL(0vb}*e*MQh_*?JfrLZssx-^2YZkip5VCYl*Bi zKN{BEo1XI3R@fbuBOvQxRX-1nj5&R?d@P` z3JDisTm$|cDt(GI=eeaMdVZq>`nUGpj|#>DLv{QV*e|Vws!b1L2c%YbKAW#jM+mHcI1bj@~1B-l-lT@0F0NS<#t6a&eqhh-9}$ zRb}0Q=|DH!if4sq-5UJ4<29m6GN{^j5&6}q8A@FRX_6AYXUIBq=~iS&j3z+Y#}zGV z5q%7`-b=1M6->74xks! zXvHMV?2qz~=Soqy6lRotq_eNgzpYzVortclRdd|nuM_#9ow+yiu};==f-c2-x%-iZ~R%~T}sN$ zz*Mx2$VkR=a620P11iW=W6f1-*vd-B9cAFp4e9b-++NYB~<)#_(oM?6SdQFQ)vl28y6hM&(;~TQ zR!JI04eWXbhv1D@QM0cd)seKQmp-Yun2GSTN zTdpg1+S+-x3wvqr9RC0cDI|{d=QeF7wmq-Gp9`;iNCcBv+(B)$KFL#I`X74wZ^NGq zbYBib5sy!VTx|m&ectuYIhabNk5SX$DFH^8DZ3zJ?wXVLODhH>6Z+Q-BN<`2cS1cn8jw#>CBY}lAu?(JH!C1q zHfcFnL{qaup$To>DZw413cJdf*03idX!%t>Lto`=0#ytnd^B~nHX z3gfM97tjgq5N!k#?@`NYR^&_>!hxN+;;!Ipi*jRU10w^PuV|=uN&&`k%_3yYIXs89 zkyVeIkCbAgx3incS0RN(1O6gJ>}`KfWR)3D&O#>90%KU!HM zl46KT;dvl;sE&p6lDh3x%IyQV;-$9K?pIFKG&Z@oI$gw~Nh02Mvk&w7*Ig>ME0G%7 zrQNmURx-2?Z+ig^6wx_HQagqmip-MxP`V~rrJn0K%g9SRA5u>yxAxA~9j&S$`#O~~ zV-5UR?M#40vPNt>`u_lSx#~SgQq+b>I3F=&2dSw{YEe`+=joALwlph9gl<(0=5(Oj z7~@cQeDG^IpdkI~$f&1)dH1R0UCe+UbMqfs$fU+!!WbgP2mDB1i#j+B6OcBw3^G6vC= zP|d0UJk&;mSjHq#Lb7m^QgQmaVDFisbz(t~*HOEtSG``r(x1Kyxx5RP9h)vgt` z{oWdxoSNu9DV^hGauJ6EkJhWDq~%fP8`KW zBc%q=WK$$;g|ISxy3`&*CIfCA$^QTf3nYc3S%tfP@DNBNtx0os6d2SN1E;kDDA~;U zkr_TxcqH|y+12y6?{?yVu;kq8265Y^BoRoVkh^i7O#mcT@Wdr_&zQ$?$5LtgSxjZY z=dZOi>;>r}k|kG&GmhihlV<3{Fu~3T_);aZ6lVmI26|@|0D^NY%!%LTB=@HkeF*04 zBEyLYb-_QSO*{we&I#L$kZVt7X%zigdV@tFQJn6{!1NvJ6pS>EM(p$=f`&ACMw{%?PRY}5GT%xbJ*)v8I*)1qujM(B z=T=>-+thniTdWsi%v5pPr7#$+82#99$kdXbBn`(2>qycFh%#UlCyw@?pC{oWD@Cu=1j3+;Te!Hy41@us45`e(vD7Rvc`O-|9vOC=clCr(MAhp3}j8u5h1y52fb~?QdKBa9Q5|0{S4fP zsbwe0Id1&)sf62GY>Z3#p46JSo~)&PscG7MyWZd4TH0GECE45zW3U~`uZg}se$)`? zzi068f!0RU<%GvOj$>sxKI^pqsJjmRY5whTO?$pfF05C!C%(DKJ{5OPli4{(!5WjU(2N4 zL%++L%O|h!Ke4KT5uUoAqrbEF$Gb0!`fcBZ_2})b{vcZ0lwU2z%Y^>$Q_%8jXI`?L zw6@n`NfjKYJx4r`&Z)ywDvrmUURcd;;uzt0;XoC49Mj~~poZSw%2;AWQht0ATiEub z;?8bm)S7)+tt{4STebz;_lQ^JP&$4+YnH#%@3k53E}Gx({-@H5$a{jbqT=0KZRA1cQ9y%>`-V)4UD%kWy>fB2a4ae zw2s>-lVdyqqxa+|y%aY-BJL0WkgH028!v zQ<#85lk!jnbyOJu(_K#|khB(}OrbopmKeoVY!z-sC?%p37#Qa!lgivr9CZ5716md& z>{3TsuPVE6N9RBk_P_UAk8YK2-CN}yjRT76YMAyeNXnk|UoqzZ8V4BMZgap5jL^~U zz$$8@u3CX++e@D5wp&JImjtTk8;yMd;Gcr_dWD7Fv*KCpAhnCjB~C*y&PX4Z>snbN zkJLYezqaS>!}~b+YV%LA_+4${U16=FSR#rfW|7x9`G_D6bB}8HpZ1mgw>~F)dGU4D zsiSH3Uk|(&8ils8Fov5OahE)E-l5di>~!$bdb8rqL&e(ElZScYaoiRCYPGM3rE8Y^ zS|df*AY*MD-42Oi>~$|4jpPd=C~d=^YQeeEhs+dVN4Hv=bUEB@p^)~C8xmBu4K_Ff zJ~oriDaJPu)mUgRbn2lG9Y=cYKeM#m15Rtpn}`zVFbNwEnETe;wgb$y?-bo?b14!! zM4u`sZlbtrmh($F``PC`=x)WvB{G2aqzD+`8s{|S=xV`hJSZlMB49%=J;isPF7f{W zihN}TlWnV9Mr^F1SYkz76M@v41C+zkQfXb8S8=YjB9#+%?X91>D;FV|x3FA3`53ly zn#l9!h0gq(9`z?YqtM;c?yasAMyKLKqJ!L_By*um}EprNRSL;aqsP3zwj61 z*TqlSE8`b~{yqE?y^hbsS}n?5NpB_I(-lH)c*j2Qh&jIe`H_y zDBgqN{{V;HBk=@Z2)}6ft&%&h4{LHPFMBGe+-;;MY@<0i;jjrR22FoLcG&WhV=Kf! zD#~&gdV^fmQGIKQO0P6qclgV`}X`kiu`nE~! zn)!UsHIy+Hi}+9O-=pt^7#!DzXImK$daRwFTSr9K&9&#|ejj{N@IS?GgF3tTcjCW> zt}HXfuB&eowWY>5`JbYi=lnnMJ5umf<-E3PucWFBFq3$8&p-xi=rWx4HNDAhei!1m zg?Ox^66sZq`#z0#U#jSPrl0Yu!^XF;Nvz4GTih~;#6`eRPi%Ir4-i`TcIM%HL!;Q~ zHd7d$-SDBrkF<=CbL(GG3aI=Nt{uVIp9}cE!4v7~LRrbEMDjB;HZY*%o)7Y`KKOa@ z1|Nf3{k)bsMaa-)xma#(WOi7h1-XzfZ(n-)&Jp5DnNDYi%&A|Rl;bNWYozs!*2+rp zd+6ThosPpswHeWt(oKEm>bHUXZ9I0c>zY*YKA&_8DNb;w-|??q(yr{hO=&%jpvygs zs>>`*j5s5qul8dBiKU653{43sLTNP9x@qc~X#N<^@HH@4so^T`7ykeZ{%cd|@7QDZ z&G9Gv6aN6>RC+d`*Sf##9*N^kd+zZkur%Wo|^pG(=_q?W40|F1=(XZfxp(`-`*B&xa?IovEB>o zI_7US+TtQXA>s#|kU8s8=&r=hvw9vA`*VN6Vty=s*>PwI`#}6qxAA|1?d9_$@UMog z1*McybPXxVX%8LG89w#+ukjD!OZeYfyO&4PAH#keSIjoPVcgtxY<8(stYb<%x3T7I z({4MIvCkaTCPz|!eZBaoYoV*Xhg+}OCyw3O0x{~{zO=fYnFXx!!yM@+qbbNgN{2LO zV+=)dt&PQ$RnV=K1Y~!tm{_zerI8!TjhVfw>R8IE6_l3gQ6y;?cNrvDOclm6jyhFU zM;u|Z@7l6xZYY<_U!~~WRM_`06F#btm}xOS7Y*^9Z#vPscvO0 zj$>8wRtXoD%A5?>yMMtml`g+(X|#KQ<|otqdiNMdDGUtRd% ziu0#P^dhgZ^%ufF+PlVo24e9RpP}gf7x7frHj8Nu#-o{95CO;xq#PWALEw-wIIl97 z_JsJaZZ0IUlfyPz!dw~m$7s8tB;*D5=D4b1k zNTU%Wdk`~R^Js}@W=_V&MseHlu4z)Xh;A=pj+LREQ&VUov(zQQ+k}OiarGGKUrYQy z_yyvB7U~*Q+G0y)kxVv~eY;0<$2s<@gluC|MXCKq{{X=-z5v|(A=Lay@q1D5{p=R; z#IWg!J0IU%Hbcxa&rH|p=B=n->UZ(pOKWtpv$K*jh9vi|V+yUg^LWWOv7zI?h#v$# z4SXurJ|lct@qhLcS}F3Z7Iay!9~>lTeqzL&V1G*dS@@OvW&BS4qNN%~f-Q%`FNS-_ zM2$$ix>3gGaf8UM>tY&54IDl9Blv&d4JS<7Ev>T)mS5gYBbSmx+>+U^tvog1UDoi) zw7Ufy5nfcP^F2>T+1U2a4rsek6`=}qkHWpDMDXlhNDLoyRFfC2k5AI{RgA~-bRL!H z78){06bRQj??Bo*>pc`?mp})g71CPhh@fqaReJQUgCkboNnD-C+jCmWqyo!`wjW$o zzy`~r{Ma$>KT4}Ej2~b`0zh+DEr)X|`$Nt!pp(}FrE(YEA7HF8l^rsRoZ1<_+&jm}8srW3Z~vFA6w9+t*Nn%(7sWjRJuf}~dy;>~kWpHGGj zM%7KkbBPyHLH?5-J8teP)Wc$I?9Mv$bT+&@<6FzSxt9L`Q4^z38*3RbQ z$j2m$664GzagkF`ZKg-6T&iGvEtzB9DjnqLi#>*I7tcQ{AGgTIJq>+QF`O#Q;(oCCodX7EuP{FAft<2I|N2opu zpbP-Zs?Fz`b8YBN`mRBZ>nc zXFP$H3-c?>oq*b(R_$S~lk9Fby0Eg(Y+~Ho`vDXYpBo02c`Dx(KwOIbr z{y(@E6KyvbRN6?7IOt7$ZfPc|RDMkTI+Zi+NhK}vN?Gto$*QAsFl8Z8O@2vQ+oRK^ zriJB^+ki`B)YCtB`*%3qoL33CZr&3ib&)hkw&h=`?Ny>^-yjpf!Q-t+7i6`KJ`xKCs!eeW%jJ47BoWmMarqb zAmDmbV&i!vAD1}Kr9rc0m6ys4&u5V$7)!!O1wLf+S(F@_HY7 z6jCFdh{!_)R#pSAwMfvcfd>QW-kr%I8(}4R#WGOx{GgCe@~P)SCbwjWtU`_1098s<2Wn0(ZFflX&gO9FaxS7Kz3I3Fn=m11s?*K`aD zsoZ#~o8%0BP{SP!11iW}nN*HD`&D^3bwW?!)SAjs)Gl9{thAUVpI_AMJUeKLBx!FX z2rzv;Yva$0pSL&c{qUk`tRd8H{CBIAW46qJ3O}J>b6$o61yZcJX{)jGbU!e@E&l+) zL%ufrS(sXQ8rlzs{v35^m|MRgdJLYquZgbo?-Ka7;!Cd_c#iK@xh=VzvCrUh`d8|i zR!a;zzVhy6I)=Tx8a|N}(e98)K-tLUz5f6T$-dTQ*isc=sOl@|DbhUpl}>T*W}au? zBRi3gsG!@sGQ6ESeihK7k;giv`)xgDAh0N-+N{fM8ll5}ZZg9qMJ#d_ zAUQau)3J+ZL!|0DUAxZ)q_as8jg=WsA^RVCrn3E`_l)CiK3+Q3Z4#L(`ArKjR3!0L zB$718Tn;fvW_+5=a3q2@0FJ}bxx4QWJ>K9**cS%}(xy(sIiS-h(Y!bC`&icS`bD&ttG6HQ zj(X=6^w)&`2I=rgVW@b5C@!W}4durn7$9`7oyTL6(QbP0=qf3b(K`NJm#U2 zXs!rCrMdO#Lyf>}vn+A4VV4~TwP)JM$e=duy>}5=44J2AoJSHFW$TY`T1lhnAsu+2 z2EfR79i-#)HCkzQPQNQUXY#ER>^@@Hn|}WQEm)udvMQvf?QyUm?#@L=D-hqaqU=cr zBN_Is2;ty>>Z2IsRFc^Rv`Vv)BLJPTS~qJHN;a7raLFWa4K$4Tn2^Ty(m^Vb_p)*- z^~9?nDIian(a=Oeyp;*BD=eW#)KtG0H`VqJvp z9gnRA*mK*wKrtXWJq2mUATTfP*bhnq#Bgp?wO0yy(Iib2>f85>dVSi?V`z7n=Xod? zcB=OB7@N$HHz%fgR%J;t{KLy2)S9l5gSs|NqpwQZ8yY4)S@RRXbGI~+M!+hg z9fWc_)eMDaxKG?Xs(x=ygS9$EXtRa~>D*LKT?D*}=$8`$+lImG-lSONhz1IJ{5I zDV5xV?0eQ=O)LR-Nf8LcoYqtkA$N1T2aM;f1*rEW`3~R*%hMjUOpT7eGYSn$amdKc zzosw`y-_Mzi$;E2{wi9U1N&Xt7#4^$Y zC(e1~Y24r6|>DsDXz7a#dz}o~^`&D(FPjM3nb_kX=BR?Q?{@%@e@Y5+WO6uEVH@pM z5H>6l#h~{+SL?1D8abz-kL2z1TZ18TkBuaN=M|>*^hmu+ufpCHLPz6=j12| z_cfD0gmf#GLwlv!Tw4M^bW`tsH2Kbz=30-!z88wwESE%%3vm0_0DP9B)g@j@<31FkQY7d#H}CU{i(gzH5(*&Bph@=kb^0pNRe=-M*P+cyzr5CNnCa*zM>tI*eD&(k0ErgqD&?7?N4eN&1>{mXKCXYnXv?!;JHC04Kz`)>r0IzHC_ky(awSl6zZ#6T!a)bjt06FAV(T&XA zMs{}Z1Y5NK047XEMknyw) zhn3^l{x$N~kGu?;@SQHBf#U#-Z0ZT%{uJT4mCuf@^i6N!j=w&&Z6(!}%q|uiuowf* zc_W;375e%6H~dogbMe2z1H#(;G5BlZg{bo~@`9Jj7w;(g*Hm`YiAC7u{wPmx;jLcd zOSo9#zFcJ(;O#%fUL$#{S+R5_WbRIXl_^@pdoHIVcd5?_Ht?2`B0lbU=bGm4ZzZ$0 zlJrW_F&hs!?r=Yya?f((9Zn+Z`H)Ea0#IPjv`qikS`36S@kkT)~r^w~mNZ1B?^{6Du?oHdhXfN57RWpsJ=BG%7K}H1g zK;L?-0pqV@n593c)U`fY*v=U0P1n0l=sL2l}S^$&E0|OjTsH^OA zK+6YX1x%f}s_z;HJanLHRuNTIl#)QsE3okAhOc}_cOAWjv73zKcdellXrAY%_zOz# zrI^-rmx^n}&e+`JV`I~;ab76+p?|5{rk`&NdR#puNKXzr1Nl}{k=IHWXP#--kU+sn z`38CJDlI}!JqavA=aXFRozXd~i$a+!8NKmQ{h16+^7D*!>sJTRii2$RIqX<0MBz_4 zuKxf=xQkbjU>iiooE|H#lrC^of!193Qwa)-dFS7fzEow)W49gstDyLG@M~7_hl%t( z6H|jw@ZE*|(p#+e5&1wCI0Wt-3g}QqFR|<29()<$Pubg8J_51T?0i+?nBg=u$O7Nm; zQlu-kIg|pyhHyQ_BKeWiP4LoC`wOh-NdpVFkH);?#9s~X?BX(8T1zkuhRMd!>M5w) zpJ@T~!G>#R zQ>9>e_mi0C}$G5~vyb z*lvFDz!jvSawsr0STIp6+@?Bg=%oHjj zmOP(eYnDpI)7A2$@I&H%$6HT}dj7fMC)8rS)7nN$3=9>7a60KkS^74VT)^5Lf>I6IYks+dNz17sFoy{6Nred^Pa{ z!xp|J(WFl;7F7g8^cDC$`%QnrG5l-bajW>p_ISUaS+dsEeuOz{-H8rL+PPr-gQi~}Z}s9Kn% z1aY}ZA29a@yKOthdWEc37L%8m#DgVH2e~!+wpou=V5E=o!^92%#9(og!_iL$KAnQ>R|*5kSzSI(bC}i|3yFR}f8GRY;DS9hs}X)XQ-<_h zm1NTVPh$FY@s4O_QyU|W8#VS{>=*lTd_(<${vq3VN5wjo?!Egs>USF)I~f~8b|7SD zKPS?^SMh&l$?TP>3P;`gb$+SMYTFUj4--=lAPADM6u5LC+ZT6nLr{n>fN@Aq%& zk^P{2FZiqBPl;X-(fn`Von8%V!c+;sClZ(1$obX!7Z+B&TYYwHO+@VXGX%{OZo(~7Te+ysmUJv*;XIRp;Zxa67 zAMj7F4L$nYNiFY+d=F-vNXI4SwTXX=l1yXjzulrP%;}7e;@-+37c7hbY| zBL2eV3Q27!Bo!d@)Ec`rxJ6z7Z>4D{g-8`-iIi}qh@^R*EDz!SbmDTfMzSl0!xGgj zO7_v_G(KK`I@&YnA(6*yW{%=mL!um&B;fm3(^~I_{sw$U@K1&tz|-Ane-=w5Hx^q? z$yj;=>&025VtAj3JS(gC6I6c=Yq~|=ld2*IWs)7B^Vrus6{L14$rPJ3OR-<=GD7$& z!M{UIxtb!J43pm#gMGoXHfBZg{H8mP98^)wCRiQJdUAVLIgF)nN0;U}Z|hHrX+g}2 zS0|^n1A{ufAH)%9Y$y9VPdb7ZaL5Pg-mBi;-Oi0PE16i9VUG0@T}??LK5C8U1a-|T z3_08h1Cj4h%D`^rY~&5J__m*vatG-|cLL0C^F-4U|zSR(C1f=DuaeQ>7w6sImryL67~e^?71OJ-)q- zV%I{|KINe5xY^H7r7~Fqwg}+T6r*D*^+N9Xeq3>i=jUN0O%YR$y!Nh&Q8Av!5vxZ# zB!&cLRT*RHUqOGtKQ&vMFWOT_mM;&#pE?_PCP_Yc#z#2xue{)%U#&Fzf05 z9Z~sCIX-9D;cg+eycc(oNoo}cQlx-e=qr%EzJun0;X@8EMmtxjOz~ft&Dc$Do?==B zh-U#*V!CZITZ5K@L&3(}cdY70`Wn-zW7M>*PRLwX&wFEIsx7*(5X}f>+(G1n-AK4lt9v$(O&B-zt{#27aa7Rk>YSBG<7{<0faJv19d`+gNr4aCzv3X%` zM(dc*nGsXmwrYlz`x^LK?(oIpZx2Z(nDLdBP=Liq&9SYy+tjy|;TkNgpL_B-*% z?B%ZfOVIR7wAY>97^Z2NUI{aep+^VTr)vDO@#p*zYvMnNMckhSJU=Tm4pHtdWyEd( zJQr^N07~PjglTAcH1j0%XUbZa{1PYjrSP5ZnmkW);N3sZmtll-;hIESr4g$t&^>fYnpO7}u}V z{h098)#r)Q+e*>2J1qxJv`;QLAziVAU*aR_-o6a|y1(G6AF{XX1>rqP9~WvL@Sc2V zF~9a+himgcnU9pP93tnE&C{^2MpV>Qk>N^CO#W>D0O5FiL;bKkX=(A3;+@p-#deEv zWu>d1Cd@I&8#-hHEA$iLwwW5+Kw0(-aq2PaUL|_1%Ex>#{IR+BSAz7>a}~Us6;R`l zF`D{k!&+3Xii@yE*QH?{%<41Obd4cmDt4CSabCfrSQbPCVE+I**yXwC+Gd%IZ5xk& zYVdwZbQzo0+G<3g?8}qRMPH9k-;uPB z#(~&#X{#fsiE(*^P`=ok+XhI<)8EZ1IwsXM*m3ec zfpI^H5p5Bqk_80rMd#^Hj{8!VE=fko51eu-w7MHbNgLAmpH8#1wv_3SLo8!#jH8JT zdew-0dWPm`-$Jmtv6O{hFtBLPJqRMDK8CWDjxWbvD2`cls~tZ=i42o@PaJM}QV-4Z z6X{UhYgQU$gG#p2uM**aW0DTR-_oL{!54O9+jzrR(Jn6UEwqKcwJ2kiW&;HeQa%0a z^Aq;#_?@VDvq7-ZA@J;aU5k+uD!JVvgVbc6Ngt(nSm&wl<&+$xlkSeUz*d@HhQ1Q& zZsqJHg2p!5S8&D;e#CKKgntJ7P}<+^Mez+%{dFMINbs@Y6+y;54n1q)GYKhCsQV^< zr%7pKeuU3wF2#}XGBR*#NRr=Rz(udgDx|hM=^{d~FKh~f?10Ey%q2J=dK%(72F#K! zN}Qb3QY)$-?+&yXN$Nf;=kmO;ig@eXR8hRqPNyM(@99+I)XGw^Zt~`55ypd_hu)oQ zXhP%`-|3o?IrS{bEa41l$8TN*ShtCp7&?-mXE^CWy*5V_L1ZTfZg{J#N~5|SoDX^p z%1CC(tztIxCYAQb+8;Xxx%P`gE$YIZz^Z$!}V<5GD{KDurHxqq$h**%%=harLDw zfQ~yB7{l%Q)y@7~0AP<&Ya?jA2%?+@Qo!xUaaRJHjlwvxeM!Qv)SfF^bX=W^JfFsY z8omttFSWS5@&5phw2OI?Gbh=t?op&TJgmciOLa#BA#%9Sy+6&Yt@7fI+etZ&Rgk%BNvsA1GzNj(&dV2A-N8YykLxTTPU1WDwU+Mh9(528~N3x z@=7dwdRDPrj%i3^PvtrC!DT&0dsR6kd1NV;P!9mpAY%ql+lkx!>MyeS#DroFD<>|1 zSc6Ga0EF+m<~{47)I2}^n`V>V>K0p?C6!}F$-(XQsB#3Xa!ae*TZ0M(SiQSeCHAMg zba3aMhdnDUZlkfwO&q^5-bQ%q)~O_9H<(G!N=@9T#GPSgz#F#b@~um4G2DaYJGL@F z8REI>)kx^43!aVPe}>*5*4+6TMcj6(!!jHILHEp*2{tnpggNWNn4h?1kz zwS6(*{{VsB8nRTryt7NYz;KETGe_Z-7W0W(%01D z?2catWpY%R#OgcQn*gao3W5iysFEZy7FF+>=YC}xB6q=z0fWU*yOp5aIrpw$xdcrt z;r2G;o-!(BcehqnT(tr)Z*^6+W_d|cJAs<39=jFVVm5R+?lD1JrsPtC7DMj!9gQq; z%JE186+_7Osh-1ev1;Dz7?Rka<0ShUuXZ+VP^=X3^sGoEjg}-l?m=01Yv$cYGIa}r zLG4!<_X2mGH&TVjLGRSnJ9v`XM|T_dde)^hE#oArs~P?7arCD7jPWhB`#xWkan`YD zOsficGYL?ZRp5^1t=voJ1tfGeA|hzrXGczie8bwJco@hJEtADuNt5h6!R0KEk|OE! zrL~O<1|$G0P>X#_H+Giukl4!uxD0eO-Nt9#ziL|O3k~JwIpc_P2~`Ao;a(rpk&|u5a#$jjLx$0WxX{&hSuON5aWI{Q@_tB}nZ-X%eXKYFB^<~2o4xno(*#*qx0c$6UB z8RI^cG;;wS4ozV)(F`+`asVN7(yZLdvVyyg@8?+*rcpNhnj)q z2BpLbw>J_-rAp;U-46Tic%T|=TI}dG})v1)a~59zVsTVK`SwqIKq>F zewAhkKJ;#Zdjfmburrd>Swg8ifsQ)$q)AdJivIu)u6otjlC1YAm>DXB_Z(G_$jXu~ z+~bPMXwow1K&!c#&#g%s1i%5rjD(=-D@TQD)OW+A#L$69!XO~cOI zxaS_U0QRq%;%9!WQUyHyRqyOfGHlmNw#<5@Tp&Pa)u>stYLd^X$uR#Dfb z7Z67}qbd1EKKb^bYs`jVjL7Q~p#vCdS#q(kiFw=7lS8?cW{hD1c)Yul%VDxUf{EFb z1V{#R*VeP-VkC|@O2|>jeZBe`&6P2EB&miV5?!0+{{VKWv>sff7cQZ(){&$cG8kjTa>S0kY8UcVSrjP2^q}a2=s@2n zPE;;OQBjzskh?l5h_)9L7h)Z<#f5c^$2)K_f$vqA&moPsGll3V3k#H0W!l@rU~!Do zBT%o&U_t!o7|4}=(fin$hH`0_aYj+20IL)FP$IfU0*%TzKczM})f}`;?7oM!1UQb3 zqw~zfb;#*VyLlp(2e-DkmNqyf5ryJ{(y+g}DqOSeCmar*)W2l@H=6@F{3)eyBcBW9 zL|ZG9gPxSdSO5Z60XlFidjNSmWhF>3<0Fg^X>X*Bu#vi#3J+QUtdRK;@5*Jmj2txMU3H z13eGDe@R6jlfYv|a}i&(!qB-;%5nFBsO})l4YZip5ZOIQ_N^RrHRfX$-bTcpcisL9 zzi({egQ@4ZHJes7jILT`Ws`0d6pW3u*7KxalyvKk)RH1j!#>X@!leAixA$s{%`Lkm zG7{`gI31`nCROXyA6jNN$WW3Mu(&9$iLB<=Q?kNEUzMn13{#vjM z*&q|vqG=D9BMjk{zL=(+gymxY0G%V}Y>JZ%a>F3i)o(OyZ;<03Q|nrD2RA@?Hxj}^ z1~Igb54~5~7D5T*iaCZdeTW<~f|%#f)KW*X++AEqY^<}7HdBS*XOCLNzJQVO-^Cx= zr$+GHcUn(^W46{cWp<6-zk~yVannAP@TZ8pPpkOTP&%iHZspYP7#*R2*$DIknbl4P zG**$gbC8ZbeJfhqNOciQ7&Gt)3VP6Nb{0A<#PL2LamWXbL9VvX!gJe%F~K7-Imll0 z1+H!l2KFUs5qD)8<|Q6f1_yjdS1}bh5^fv zefh6Xu+x>ITgcpi%ZvhX{uQEn95a0mw%bgC;>@%!8qABkb3QZq^{zg4KWw;+%ct#M=iXez(*tzdb&Aszyj6dJ=~Ny4hGe~Pmt+NW}o zJ5#x2F*f6aoMxKq^OB(BuS!560}1cP)~rOo!ISGjv^F$gc8q=J3V8a88UZO{tC5^g zQ4=bH0;n5!sZ!jyc@Y7@#Rf8Zl^)!vVn;PWkQ^v(d(a`B8*bhzWmRnTph7$YBWrW- z+Nwzlte`GWy#r3e*hs8HXCTn5z@EAOR0YXN=YW60r-IgdhC5e^(h=%cBRzM({{RWK z&lCyn+Bj`=>va;mj@<3frF%V<{{V!36-7Hi96FWxMpQA%08Ea!`u43HO(O|6WPIta z__ps~Hz!b8~nx!SqRFk)l#<|U9D;7p& z+JtfG>rhK-!9G?Ue>!p8%2V!AmdzD61M}yc4z*1smfB^K2_%9=JTjaSUDTyxnxxOU z{{UpK+IGj_-LH%-{8!)|FUNYLsgp^b=z?Kx{c2CzWA?A{FUHl-tgU=Cr+6m9)-fc1 zWGb>3$j)6xLC-a(Hm4M+-bwa8E!6c{?=CJbF77TbZk*;xrgG0I^=3V5oso;NJCD|~ zlhEpiV=8Yow*sw!?Nvx@5KqlmlYe+>#!o!fo|kPbw<#QI#aQhp(xQ6}K=iF2!;*&* zOix<$y*omCps?E`g&j(tN`(iLr1w z+B(%Lea=diZK1RMnYoL|j?JI@>YH(*+g!lybpq!&869gxta7Taso`ER_-dMnnKbK6 z&c_Sr%xmS35O{M^(68pTx`IfhLxvdX{&7Lm8C?=-a$Ttk%Fe#0oL6^g5tbZ-xR6e9 zMaDg?iG;CI52h-C%622S)~QOsB#5k|aNONF6-#W^&m5NJh6mlp6g=^xuhKhB zLMZ&*yH$YOf_s{)tN3;(zj+PJcOIpCROo5QjvC_HSlyJN#(UH;y2O4%jB`yuq^vj< za?D0XY0qM^0791C?N=3HnN#V~M(lQNBA|kACkhpfS~?*vr$b?S@v|&W$z4Pm&}h=$ zK^x$P!;FC6O5QTMH)`kIpYTmDh<~*=fd2q(Pl6sA{g8Zf;-3Wg{{Y1L)K*s(x^2sg zTbN6N?Qs_?<&17%L0kez;=kCV!d9B?zlOXuZQ{K`EmOr2>DKY;Hxb9>t;NVdBygP+ z7Tj^#v#4@cf=tl4TarXpcM-#Iau;_){&8Q=hx`@;{t6pm;ZK7a@4*j-`oT{eT~5&J zw>I+tmbUSnvX=CG0bG-%%$!X!s!h((3STX6cnZ>-2-dzY{FA*hqrz+E-pfq=OQVRjF}Bt%hAyqn-p|}*bg$>+2=Y8_*7LJJ;55?sN5ds7v90f%rF$eh$Mu!OIeK^k2kDd@kDa zTj789>(SkOuWRGY6T}iSTU@GY5HVM_oNSgB^eB0*{?EpZ4Vbl*yI^D<)%wO86B$J~ zyQY7Y{7u7^DaqbC#`j%Q^YccZ+BDx1SlmFy(&F5%Ck#eH`Wn;lKZ|cX2d&uX_nMsd zUJq~~j^a`aS^`f5_1oxc_Fo0OK$i|@)UnO}>R#nV-V(L?H}15hrme=;vuEQxTf=no zEDcO0O)j*3n%VvT0EUO%KM(bQWP(Pz7k2LZ;`zgTzSZ=8w7M3(r@^D#S|!WQxRcC0 zbK1YxnswCTrx$e3;ap}8bSqAcMQKH}{ZaJS>^b{zd_et$JZ7F1@m>C<;t$!=P`Obe zNX;v0M4#aucGvb%@O$GogMKM^TS)O=fpzG0trqGOxJE)hcC0c1=dLUK(fU^Sb^V!~ ztm6$EQN>-p%BuLfY0Rx9cXuv+i2keae~Ny)m;F+s{pB4!W7F>2(JtrG78-(FB9?Gg zw<1)6IgrB@)uhT&cqAEFSI~<7Q;Y6?#Rt&-J^ujUyPxoGu8aFXr-{F8-`HZfyo|*? zyvTO2D8L+Ke@f_s=x()EDo+7~F_87?SkwIAg>FYmqn@Ff&R1{;<{q8u^mnY$#}te} z>4VyXGFEMbo!u(UmZ5cPbq=GaT{V`c2@MR%_oHBQkx!b%McD5AS>vA={6>3g-x%u; zs^3EwlCo_I+kMYdTznR@3E_qy?!@2$-l9`9i_pER*)$h#WpaWmn84kF4>if&?}U{Z z+I!Yb+)|fgEv9f7;1ixWq>f*dKRdgMMn#zKgM6T4+Vxr`Vq4~FvdnDZ9?18Q1Qd`&CFI_-@f&L95>CkYAXGuMH#(}xJIc|(C2Vc^cwePUq>1*n(CBoJ9QdC@m8G}V zZl$p*e9K7==w$x@d1}Xpelqw+Nz(NlKgQk@ig|9XcH7=XljQa6I_J`{bdk{vM|1S^ z;m7SS`z&96&e{jV%P$z|+Ag-v#(4h7Qbm+*`@;j9 z%6q1gLv4`qDd4VpjN-EPHacD;`7>PjIcM=ZR1&X_X3*n_yv2DXY|6y+8PBbD_J6Sl zz*}Qwt$5qUad?weh!!x$oHKUG=zl8at48`WN_d-Sk5TZ4gMJnG5v||Bz75c=Z;^|6 zl7T1Cg**dZ%cE$%CGmuaEiPo4$v9_xM-cTsiYt~>tc_K9O#FiX0D`lB!BwokVlNC! z@R#6*v*G^$5qw#?wkdUS8;J$1ql z=4oywoVVGSqq z36ed5t@}umfsdtEGc@H!{8rm|BD5f~1#`|SMq67D%5XA8MKzfLjz0`g1}v7$`O1@y zI#ylHorc zH^h1>x0$&Imyb&MXU6^+hGm?X<7B}EW3_Zrt8I*@PUn(%BjVS^Pub_hT4uB0ZCKxE za9lLgX*2%-shLkv&$fD3?4Q8DjQ#=rsc)B= zRH@nOShLcv^_ZUGDD4?yb&TbeNzZ>@#-xYBx^mo^wJTz9iQIWPE-9h(=&#CG88qRWM(x#D};(rVH zJ{=bBl z`BYatVvketD_v;63j9@cMhS^+-C0Hv2q2pL8~8P#>6#Di3FBMa9Z6C>{{SKs9Pezg z`gX69uTS@Lk92+9G@YZel;A-p&^!2Aq?$|=brVW4a3QiAShQod;Kd& z%Hn=PPdhUz2KV6Ah@}gJ*b8?xMm8HJSLXojJ#pz##UGU>@!y&Vk|r{h{{U8}e?Lm7 zOtO+n`+L(N$?OryaSFG}Hha}VWs-f&8?PRetO`ujw~A?|DY>_B6ak!?=6qSM=w1s; znS58`9X~=y*Lx(gDUtnx=hC&OhjMmC$)6Q`QU3sfj{FMvaJSlbhAlM@9c$?s2#X$L zcRc{F%)g2sw~y@`@kV?7J4d)43h<4`%O$D|F$8r|IT)|C$vArUsaNh4>K`Oer)oOg z^WXTZQkz}8z#Hac+v;llt61rXVvHyt%|&9U|Jif^k`kzW98> zoOJ~Du82VAol?_ieqsTSn}P-_Lru_ZqL?+?$cchU9e#qgNb~AcHSA|w8~ARlvAQ+{ zH}^=Vc#B$|^5$9OG05z4&9nkdYZ&!8oX!^J@XE}sfzMj1$0b;^0(}ixJj|2N0|0`= z8dH;llf0VFa_DS}QN<%*usG@e0N1O?ww9>QWmRF<{i@7rEakO76D6KZY_9pma#wyQ zxV{P*-1FvNnVpJ%hs^3-zB6OZIyUDa!$tXHBX<;8pbJguV*t9v)ckbxE4)`IK&n zNMuuqZ zit$Zx91~nA$tbuVLtN9SWl~4CEtRY`vD({38Y=w1bOHyZY1@6C2n1|Aw(GkcYl?Lb zKCJqTybjPaLIW`E(=|Sv$mr2I1mltES-D*07I3g)G=G$iN3}XORp`CC)^e4NpvmDw z1FgUT@H!EYYNH=D$#o2*)=Z)}A~49reaeFJ;6C_6e((Tu=}2i@;k8L5E~as{bBvz# zX3tNxMS|dmW(4l%iVdx84GU@4?FJ-P^2bwM63jN>sZe+ViwsE>N)m%(`s0&TmQgD# zK52OugPytfrOJ$Ch-ZdKOAuHmLQg?N7S6HA!bXsh&S{cUmfsGne(rix?n#a@zl8@N zikBn>XdU9qNQdU=Y1c89jmm~CjE>ZEEr5y%ks`#Kx8u@WeTJ( zVd`lq6Dcy%%^M@2$#K`%(F`ogP8pXys=1IQa{Md0C)_~6$Gt1ts^U-&9DQk%Vy(Q0 z^D&HXY~za8eXvH%sj>0Tsh~u01eotqOt}?)}pdIDl@3a9G-tl21RVG zB!+hdMhF!;&lXCa-n1Jc2FCVg0ll%(szS`|Au6E(!u!=mRvRQ`QO9y~QtUvA11>Yu z6<*N6kY0sgkz^1#>C-h1&5FAZ9@Pzi`41bFc9k8e%W(3t>{5GXk)&i#D!PClk}9v+ zHjU(!B=w-N(U(F_2^8VFWg$okyqW-zTJ8%VbvZc2Mpet5-!Sye0dnjRBYfE*f$Dow zGYKUlaR;#mfFzYfh!Ju!dm4#=Sjt9Qb}Hi#Bvji8b|=fnQ`VxkPn0xdK6wqEFr5y`@yq; zfyHCnIF?z}nf_l<(t~0)f_UT-C{fpe=}OH6jIlW)Oy?ey7SkCzm1IUz277vX)OtV2RZKm(zm)0q%lO}26r zx0ZVm{HTb{%6TlKJTagyEbu>^eAA9P3a2EIj0}Z!Ip%?m7dwI3gU5C2RMvHtLatYL z_j5oKDk8?x>@V9H%|KzCkXA$y9Fhv)pQ)e-tnJz2VpnP2SB{-(%zk7=pe}rz_US+o zG-Zz5aJ^{~<9Z0f7~3cBdQ(ooR%Fb9LO$Na_NeDEqlile&!=k9OcX&FHb7=&7#oPF zq%kwFPyog=jygl!+Auk#K8MS3wB{xTJA$+z`l{=V@wGsj} zoG@02fgL`z5WGKVctW-?3B^w^6Ulf{fI_Oocke*+PVx~)11vy1RDoO00GPt^4styy ziuiULMtI_bH$K9+Wm16TlgFyl);1^!4ZA()LyD090QF3JaYT0L*~o6W>r6Rriz{sz zAyrQ7{NCf*rIloWs_f^ntu3hebtq4BI)^}~cTKfd?N1a(&14wqo-`Sv&LI2^!wSYG^pe_%!hLW*8`_Y%b6R~rg(%f zmn_k%oy=I|Y)V60&W1o6~UQs{K0Z4QG=(LUQMw1dlLAqGGI*Q9BB9@SWU zrX(B?YQ)`-Q_;L5G_cQc`~wXC05~6~Q(Yycxq>MmYjUxY8=m;hRgoUn#;QWoTNxS< zh`eN<%C&4lTSi2CqHnx$>s8IAk%db7Sho|c!#g^alpN&qn%~p)L=iMo9h*-a@rs^@ z6M7of+Js1t^S70pWYkY6yu0#kK>JLeDs4F3?ND;foaN1{w6jHURW_eq^^rZC@IWR+ z7ZG#EUOnm@`yBF>k2t#1w2PFzd-l3lOziUCfPDzBl|CSNJgirGjkIyeF46`%oKsZ} zno>Mp!rJ`WHT%cs%N%lL8ABd^we4Dj@ZCWS)?_Gk2ViWK_01_yvD@s*RxnR-1jLyb zpe=xU0p79NL?wVEf$QF~GqK9v-UO3kumE$#WXr6SLFP8^n=8kEdcm+c%ZvArv2r(L z^cclwEAA`_C*F|JX428_WmEu#&!u#++Qn>2#Hn7yxhuMI@y`C-f8= zBD2a^E_w8-ayDClK?Z@5d4qAl+s#fGjAno&`A*;#l^bgVfJowkqq!uKyOmWu3cCY7 z} z6DHO9ny#(Rl8*|GPHDLW&snp>DR*U>mo6b4=^Ic^!8a7A-X=yczy zWba~ICnBy}Nb@j^f%VN|bIMjWZEdG_3L^|gdezVD^64OvzJA10Ii)g$)-px`P+3O= zilEwTvTi7a{jpsUeT5D16Q8XhWt_Wt>)3ohg+DC$T#?%f$I43=at#S9-Gut~Orp5=F z*2bx6W@R)ID_|+>TJfud1cC2GiEi5xNeasj8GlZdmUOlGpKr~MxamP~nMzpXwpUVz zAk=Z(KJCP?BfqU&H#(H`J;U~Q{iOabe#yTdeiweyzXoKmo5tQ0o#sn>$oIo}3n^J5 zkOB@FOAM(591wCV{W3q`mf!Gk*X(Qie(7Eu@E4Bt_KH@5Oa;k^>t z;2HHBf&c*&WbGS)X6!xiEBJ=^kN*G#Jos;S1<#5Hg@>+f+j9)T ziB^$RWi{pe%lpyks+wZGE*?KlFJ)E$Ur)AlKa5 zCysRa5*wAcKV);qIUkR`ej8GZp(hDw(f+{Y_}Un%5XE7nrA}!y*3CYreIBo6cBDqZ z8JDlIu6I+@Ek4UUDIL4pxy-21saZ#S=C-3dXwJ)ZKQVu4zxXDX?Ah_|>hr{HqThTx z@td%5spxFB<=k{Gy$ya0e1H9o{{U(4*=TAy*1w=n@h9PmT@<#|^yr#PnBweZLF_u$ z*X0@P=-Lu@iTt_auYpwacuO|QqijOfaZC7%R@zH>{{ZP;t6vWIbK-vsc)_kMqSZgL z8dY#a<79~-?CI2Wt*EsmMr(V6_Lx{~ZNnpr5)=_k9m){Q&T%jqGl&p6%}%Wk$qG?ULE`BZ~h3 zPdfx-S`_peef5@KLKc;5dIo#b~^t6hc4ibP|(a6#94Ax#&QU+ru5xrJD8LQ z-P^5yjQIQ&TrGLw>&3>T8;q0Drk$E;?9B8b+TAXWAcZ`y0_fJ%A+uTbFnXSrX zjjW6^u00rfSMxpp00qMT0D=g33-;{r_OJU!e$85bnegxStkUgXXIpsIIJ`otGv!Z= z0>>CxJ8&C}6^JvsFRA`_UL)|&i~Jko9~XQn_^siMOTfPsv>TVQ)U?akOl}B#%Q~U5(;=jUiBL%DW4 zb|8WVdsX-$^2hH8^{c+NG&LbD63aS}h>MbQgN~Kwo-FZozMmL^*Znr(h{;w1%O3RZ zZ%LlN`v&;At^WXO-5g4js@_>i8#-j1j9_BFeoB;{aHP5O7;Yo)b6*R^Ejr5k*zAn8 zC3JV-WPLkR;Er68wE1JHHS!g1j>x{H^w>iJ2iB;4lWVh)^7>W>LU$39Y2r7>tyPiv zI~0%WKsi{*x^V^+pPSHDJI?X~tZ==ndQ9h@t5cWNRFrZCatN-^_C340(m!c$0+_Dm zhclH0Px`e7oY&p(JgtphjPkPxuVp3Ve@MP3vD7T?Z>5J*mRK7u6t_Tm9DX(7nxxHl zD0{m!mNGGnbj5z>N^4{Cd{sAg*lDqNQ_Ez+M@YK5S!}Fc z)dJuLeZ-%wc5^e#lo8Hd#FiIU_tM86$39*`8;7Uik}G|n1_oe_zk)p~x!Hugjx%4s zzO{(Vt2Ck|EF+BxE%c~t^>)6nOSwGANdq9M1$~WZnU$G-HlAptw?>RQ6dU%C(Ek8q{{Y$TFHegvv|ouD>@RO- zEu_O*L|2y}bnVZn_OB}!XzY79Eq6bL4-wmVo8vFU9ZSc4BD~afHkwy|Hg_yrpS*MH z*YU4c(L67u=$3LM7FI!z48=ZYC%$Xsu{AZZ_LSOCQAg8Xvz_cV`n~p>6w=Q!NEoXe zl+Qmce#?9?ourb+NThW{1Lf|fEFbf|omjFvq{Po;YPmZT(LV6RWDXywq%^nE1(+O9Fviu5fl0NNPUqgW%a zfp-N}P!CR(w`~|f*Pc0`vvLK<3{QMkqy&IQ-a1rFsG|HzLY7_i?RaXnRb6+Db ziu_^lgT(9O4~M=X)%-WBq`r3Bc^Ot#&Tw(q*M1tUq+?b$NAxTEGJev}`(AuAvA+J$ zG5FI=wpcYQNnJ|$gR6$mdhaz42y1fvnprI5ythZon>hex_CNl*`Z_gH^Yy8fF7)j> z)=SpYV!KWFLmZNl;Qa@Fyo$-tW=%TQZ7wUD#7{VpytD0Yr7z)v)aJ3%q>xBjD6+ZrIIqa>iB{fk?ML9vCff2HM$+5Po*N&_*b(3Iap?rHo-+P20)c!?<`1^~#d%e76ap;vdWt$uHdsHG;?Q@WZW zw8r5agdTXVfe3|5IOe>=LoQ3kGrNt!ev~u3`PgzO6Lundc3{JH(lJVcMgk)2S3SGX zV>M0`y@WhT=E} zzj}^ssQZB&ezj3{Gnp;BwZk3C1VChBttulpP#*DClut z4EVFf-x7Wz>X%x_jl5^6-rdT6V-(H{9{I_~;a{O;c{DKky;yCr%|)l_+Fm@h5=;*+ z$8!_vNv6-NAltEU!oGqqw&oL;Lp84Dx+@@N?~c?Zr1OvlcY2s$8veYLm%{nhDOq;gc4$>fa@nM>^lo;p`QaeVU<1~&Ad<(ueI`(&2+7z)RO zgH`3a^D?Eke_Gtm#$=8e%Eq}LN{uaUrocpVlh++;d9SgoX`A+16!IgpuGL;i^s84F z8g7uR(!6s>05~K0)JZ<3(SgJ2UMxm32!_RP;RB^`SK9U5uEHlVr{_}LjpL@KJIyS= zGcjs*StYG=Gkm5i3iP)?I-XezMAlF!aogYw(?7;+R3SEY)DdZvmWExzGpGaKFU3O zJ`p3=;ff1b5-2R-g+c_xYk+a;1v)EvALhqSewFf7>Na}xsH9whS)8#s?ZxZ1ljcepYnHL({w~@Vmr*B)_+XcG+8&1jt9|b6;BcW8lV-qXc`fCb~iaC;<(M z!lg?QIoS34eKI6SAVe!1e|12>6|dzYOPm#ELa?7WDy~;GYI``PLNIrA z&TAu7D;XHng&Mly+FvQD6@HTk;K4cw_XKvhWp8KBmnQ=WOSg`0NzE+46{P7 zliXHYPRSs&LVI@Ng3VD3c35)C?A-8kiqclxirM+`$F%@Tt`SF=xy4m{G@@vT1HZil z=tq4jx-4tR#!V%a!mMo^gsB~C7b7*f6~yT7ah5^B_pI6VSY(x=T!mB6^#Y_C9R>Zp z%z_4RpkuFUSR|RqN4bVG%z+e`=xFmJi*4 zrI-Q6X*TX+2@j4zphX#7n(-B!1srlJTeW{EYyh!1`g_nsib~4_ZRSh^bUCXL!WrY3 zO}Y{?Koklp+LJ6z8#JVOi@P9uQcU~u$i)}0)}m6jhJ|QlEPr@%r?Kr*OO*-6(Vt$m znCw0>a6nwB=bEc>{(O=7P>7jEGJDV#B#oqxE4Y`>EJ%q++DYfwSAzsYd18tRtC_O0CD!mNeUi zlzDN2cW0(4xQ@ezo}>`l?JUD z(#<5YF4)OXI`rnQGYx^kC;SD#8-XN;kDB({AzP+i4& z%x{EJ$&c>zsTIk=1Ggr&hQvvhq;PF_G0L6}YPG3&qE*@qYrrFoqPk+Nh%Wt@$+u|p zAD{qpQX;+@m6oJOaU^#%U&-F|#8KjxY@bkgWKGtfF5x z)bzzySlWCsL-qBb+9Y7CZMCvF;+q69eWk8^mGc`4UmTJCO$8TPH;vSirBfr0{{Tvk zSyn&*1yt})aX`v4ERmtIwzzVt;|$}L9{%{Nl5L6~n|GWt8A#|T5lu@1C5?{5)OyrY z&k}7r4jYc04FF2AGi;ssGDOuvY=@JD#J>ym`_Bt_wQXb7 zp>5?OaKs@QQgD3@Z5mC*%Gx6-Q`X1Dj?u<2tXLD+cJ!#-QYgbN_ms9V*b4rI9NIyk|`qjivk!Pf|RTUS>gLG z4u+;o40*LEkCNC80Z zYv%8W{{XZum!N49T6kLHPSkuy<~loY{y@eCRMrzVrvu>4Z^gbP@jd9h@h+hHmF5Tp z02K$I70)D5-REy#YQkHcaDla9r@TX{EO@}LM$&ZnuBA59LWtM^mj~soVvQV8=vr5X z?5xpQ0GE>8I(t`5rfCZl&vE1#r3ZH2%m-@R<(}tmE$1;?&mFhfvz_S2Bz-#jQwq-; zMs9Jppc&{X98+b#D9eY8uupTqtLqa-5{F&KsOFu_B`Xy^)hTyH13yevh+vtWodI)= z+eh(GX64Z89@ySmBgYh$k-q?7j(-|~tsO34j@gb-V>rVDQrXWoQPpCe&5TlqXt(Vx zjE&Wkf2u%E=TE+#;h8+ra=}yq^{IRns=N|4q|%2%#O`Ct{{Z!?L()g8$^sH0 zI|p*T4RSZPF0!~I3C~{i7|7&rBuS-mq=VAA+xa%1C>*s!k|fXh6o z6Ubj~06563*O`2}T+$kOwc4PrM?4yPZC+TeX%JUwwiF05zr~)_3(ns-BR@ewQSvLZ ze1!53N@ADWfII#)8xB}O&J>3F^rslMrnU%_t;y~}Pn%C7)>*6@IjeO)KRJ_yo{?xi}-sT3?D3<+PazqNQD zi~c5Dc!PC}Gu&J0ig*g!3m<%9shUG`%;mpTK#@p70gMxqRaWiagklY2DIN63d1c9B zdj7R$B-@-5n&ygnQe{2 zt{syY+_~rUt>I5Yl=@3ne*s)Kf&4jZZ62F@e;Ua=tPT*IbCFN+e}a?YUah~|<2dbFC1E#X$8~t^Cz@&P8wlL8rsZQN4IsOorKRYbqaISR zUY$Am3ikg13V148$YXCKVBwDLFwWM)1T|FvO)ketFJov9^I?Dz1!i#b|I; znb2EUqbb}!#;wJryKi7Ou$t2Tvm;4g`@>K-4|XVT_@Vv%2K;NXFdIQrL%Cx~w2kh0@;dK1UvTE^BpV6JsK zezv!G^GI1U`PWdY(kOg!*YK;kry?bU02>(;lc;#vSbV30LVbZm%2d0vluK(VRRfR* zTIzJoM%P-o5NeW$u3zS6Ba`o2r*fH7RPe^9Wh)gaJ-ad3z;z$ivZ0D-ol-=7zNAw! zlzSQ}9E3I(a2004+cFUO+IjY%lCG_%K_*%f<+INnYn2*)-Pzm-J^uiTnbQr&s4x)9 zNIg1nRdpy5>g!Lwv7NMiR^7yq-P)fnXvppzaC2Af4!UV|J8y`;622#VSk?SHs{B^? zwd3E35@`?%Z7=&`{q8=+82%J2P6rjhUQG*5X9~|YbGew3zf9J0nbl4aS|d7Zmv_l# zKJ?|hF@U@}k+%eOu1U!4r@7JiE5}|j_+hErc#q+yh_ycqYY5=F!zuEn8Rv3zuiYQn zSN;m0W2{M`cq8J&UuoKo;LReajwiszLmyvy_zo(`l&^?_*RT1X+22M#9G+E(SsrOW z_G*vaZTu2?b^9-`Z7tOO*6@GFe+GD>8%EJ}$WEOlubUKy=ikP0mHeyMbgvn~savR; z;YM+f_P&+*EOpScL@%yr?DbidC)pYzL-5f3aT~j zp-MfE%)i=e{s}+(KYq|N-+0r&Gt2OA;)_DtE_9qlZ#0DDd69HJgo^wN_~H9K{?OmD zcC~e+d}i=f?yuoB+-@6E$$8kUo;>9+cglc`$jdVHYg%Q?n7H>c9Q3&B4Vue=R@ zG|fs0Z~QYmjgv;i%V^y&+2o~vPWVUS1#TYBXyz+eCuy$mdP#1z>aV9VNBLdiHw06~ zVd~)?kg0x~HLClanffL0)8i5?tTEj(+@0BqP)|&BKc#&WVdD)S#c;eAvBeZ*Y;=A^ zpz+eb*lf2kqm0AD7l)TLCX-EdPgH-LS@u;|FU8csVilzaZ}NVPYP^~6zp~HmQSmeW z3HR|H-^LyjlJmr00&h<3cR}1)VNBr72<%5cm49S^vmfmv@XPj+@D`WxAK^EN^zRVp zcTkC5805^hjC!N5P(kAr{(Ai`yfcOe8Bd6Ck+dtmTAL)QC3w4UdBsV+H;ZlFNAypE zd{(hIS!IunBXHOw2Q_wSBzf9- zU7km5ztWF|Bf&t_8t?d^?IeJ4unZ0#V#HN8w&Pkvl$Fob!TDQ&i&3>D>A=_FLB?@E7d`@Xy3D zE6eBIi%o!ZCxMgr*YuHb6~(>O$uub(g}3~tAZMI@weY-CNB5DJba%lQ6&gj1M4=lT zl0NlZkfNYLfJX-dsjrZ!6Rt9`o-m}4r*3~bu(GM;<2z63Ty2)6%!45+?L8t2*4(DLd)rLDnld110kWMVjM8pYABZf)I1nDSbGbhdHy ztrU@rm5$kN?Nt=1wwauCJ4qjhYOdF|imz^v+XP{T!Va}biYC>c_DouNb`VP`1$F_* zKBl!`xA2^E_!=4M$w0rBhJV7KHv&alKFCI{5 zt{=D3xt)66%U!U2D$h*P=b6`FxOLi4`s5HRNXAA|k~l91cq;qD(9NXkmT}K<4n%h` zObl+hJZ;H2>07&XOMOpGOM3{vv&^M#9p4PAgUXKl;*_-9$wKbP`m5mG?}y`UZ(qN0 zE}N#oCB&JJa0;D6SMl%v00kfT+k5*=e$qZFSnjUxvKUWp9}vyqABbKa zxe|GHS96Faz~nZ5Q~c}pqv0m7X1%qG&W=f0zE@L~tR!<)N9pgwNdr6=3RgQo#yi*7 z{ufQb7z4oPKD0sfJo(3=>zZY<-1%zcqGSV#_1z{Y;#7$a0^^#{%~S4oHrIYg7>%VQ zfHB&;ts!S^vO5I;=WS~PL%X&du1*dsVi)MRs{?8V&cU}F*33w}fO)KCxwKY=-Ze^ zuRYdnR7ArW2h+7s9zU&G7V{2I9V@^*RcM7~&)qz5DrGAH@&5pitr-&W(Vu@f;9yt6 z{{Rvs5ZYYM(Xo_sjxuS}sb*4(K5zIP`&jt9_Eh-O7NezVa_RmP)MSo3xL1@rn*_Jv zU)G<5{BNRsMEH55d`R#%yJdM}a|BzXi#dv7xg+VC_pmjtk0%{L!&8%p_}0%^gT%I) z#g)C}atSig?*)fUsXW!Yop;0%t@M)FSZi99#J*v03|y0wfHR8rmZ2h8mK_j9Fr~zY)c^pao7zt_M;-2W?=~thHZ<8iQEfHe-%Cf%4dL2_a9l zV>npaotr*J__*5T-o4@N1Hv{FL!#WV^Dy}_1;zp69<}+kpxEjf$L&|~8tVS=>QU(+ zTEn}X?&o%Wcs1bW9}7`F&n1VwchK&?Yul8!_+O*x$vwmpJm+%(fwU2y(>3{@@Q=Wd z=zbv8^@|p@iW{O%^dB)E=ju&-j&EpTWc&WQA6G(Jp69AqBqd~wxxwp-Xx}0N?Yq$W zSLM}YdUVj}-^vAohQa)+X4)s7AWI&+dsjK39G1(L80Xa0DB@*c!H-^;>q)aItxYwG z28VG3I2`-dYqXZ0n-Dm2TWMWA9=wTZr+sK%AkS{F~)kcuGOx7EeipLQl-JRt3seqr%53pmsXQ&Zfg>XUxxHlrDjg?gfTYs;m zJ9IOVbzqrEXvtyRRn>_~F=M;fj+IU~AcRE9tPrx2+-<8D3i@@S)HMn1w7W$-%W&Z~ zj^_uQR`lsP65WrNek1JZR(UR6 znnh>fri1xoD?ClGL>G%m%K;@E#nN`K9!p- z#-nhT1L3u%IxANRdY4$0PjWwp7v2C#jBR!?P|nXQfSde309=6D7IM zdQjug!f&C@$*acD7~M}jee0W=?SLUp!CAFqHm*XAEWar%&DyQOWpgW(3xm@wz%+!T zW2v?9{8q}--b)w=2k{S^K9rZLH+X1Uy;<*ADqV}X;J<*74XTj*DLoFjfGR( zb*{@x@T~W2u&ff#J7twnWZ-wNF1{kiO$;^9bnt(`y;o9axWA4|3q|{~FxpQC9c$?i z5Bx9i)`*sm_BigZ6+vkv87kje`OH>3vFuR7+e6kFCY&NjP%4l{5D#wED_i4c(S!YK z#H&}B^r1?_lV#*6kb}4x7;{V z##Rw(8KAo$2LouwJ!oTwkrlTn7&TtdEJqmu3oCNH>a@9Igyp)7QgQ|=`Ov92`3V{K zs`9bk%H0p4s1lMguC7uB+Bal+`c`bR8@I}Z*;3wyw95CFqR|xz18_S|YPO%{+^}gR z247>=vx>Q)df}Scz-+W#GmqA%vz(M9IWdl$^IBL^G;SsmB97Pq0osM!6M@ZTBN7M~ z_koxeN|NA0p_vXEq^PSHqU}7EI47z4R$7<~y~AK`nNgJ0!p_DHlT3Mr3%N^MRr>!$NNQ&AyOOYy+$oYM$%Pf(h%I_rl^sQ7; zn`OIuSMtMP6(^|dXoUH9X$yuMvVNdY;#3j0BE{uoHzS}u>Np@EE9VW2@mQLcE+j@# z12@Z$N_DiU3KUcA#WNWbMHqK3AEC`yi6lv7l|TwjTac2}ourmFJAo=k2iB1yXGS9c z`**44HH=B1d4jSys1xZ-%}-)I48v3V50+k#y8X`GOwdd-u(FwCiQ( zxbsVMmC42{uB0K!8*kLEW>jEzv5bwQj=gIfvPmq8W)dQ{4?lGJ8se!A#YO9=>y|O1 zwYdnx0CV@MV<27OZGKFaX>@QQPZ8kw%fT?f{qrV#kpx|zF&XM=;r-AX zhv(jl8Mzl0RFmap=qjLXvJjw;N()lBJWj~i2D9T=C59N0*WQ@M+&coOqaC_cgaxF861xk?}oqw zjB$z#l1G=v%6j9y4`B=}k`@5&Y;jcPiZVl%%Z@lT%_pI(W7KGi_ap)ly-g!V@WghK zM^AHDn#CE+(f|olj=zObxt@6AGOh$lbJHfPne1#b;xi(`2{IBxA8KT;Bo2)c2X6;H zlsOEkcO-W#q#+z&=A4c8b;=@@$6RCzkP;##IVqlVRqkh>B_kXT1}Ft0DCAZ~hE>b+ z^%RmrBxuhe%w4#kE=2JoMW5F-SIS7?iVPCq^(Uhcaq%(M@nQNgD7+I9^Qt6 zqJ+6YE>I}kTO8Doz_Bq78_;HhVTLwVXp&CngW8%CVvs_Y?MhC-Rd^(9IUAQe;L|Q- zfL%9`Tgk{EG07ZM^MO20Xu^H!+gb_utvaOz@=t021ys&lC8g{t)~7J6+mc>yQVYaxgM*Pkeuk zbAK6pKk*~}6Wi<09$h}EEYcaR^&EV+(c=n19k53p!_vNj%j%r5@2SfP{`-<$R-dov zetbycO{EpKoPJc~Mlvd7x6Q)=jy>!4*vjYTGTgWXi0u*~RT#&;P35+6jGXrVwM1WA z5lFXA{{XvRlyx}kRb-XgJfS>f9^ES$JCn{*l*uY2OvkCn>rnYjiUTn?_NfTA$eJ}^ zy9xI`wX+&R@Uy5=2d8Qa^F>9B$VlCV`hC$*7}-HF;gA!~JJTk^l1G(Wa|K?9-`cJ7 z7Q(UaUYvHVVQh<7sbQeJEP=6!CC?kOJ-uto zq42B^aUJEjjhWOP+w;2~r~GR<9hBK_Eid=29}fPQ&lRU-pppoRHcy!J6`W(K(;4?Y z148iR61bXTRns>95 zhII4hPjn^?fE7pFALCjaHD)>5bv5j6LgcWnt! zp(8*(QI0+9m;T=}YB-WrS)GcE@K}n@Qs`nwtZJ8+n|HVXwP0doYx!TosiEW ztCYqMJu5j+u`W8EX+EOv#ZZyYB=@JqYc%+ko8|Sa%+1?d9k>LBUEM`%vpR6B*w5!d zT-sP^l0%*4_kC)kDPFnt#Q>lt3+HY}Z>=Yr<*3}bZ2Hh>m4?K~&xaoMF3^}Df<}3u zVjq+Y95q)9y^}0ZW`U$xlFn3(rX+bsp{gUH3)4BE(~%b=xM;yG$p@uWn6=ELj0HWt zC?fV`Vf>;~aXi$CIr)bndeCVZTz8yU9l+-`8?!PIw9r!{45Jww=AOd@3QMXF!3!)+a$Oh(i}!1k>n9-=*8!M_UcyhA&A@X2pw(8$PnIL-xj zz9#XWm+-qsOC1Kv!utCjQ@f9ya(d@Ape4}x2gIH=)wQ{2n((SKxg}AuFuLZ{SImKBQs+({*>CI+seJ)yMdyt-3IrIaq zcD@?WUiwyr;b#uGRvx*n=~L=+%2w3(FAe-KTYD>+bvI8XN!q(kPo-$b;cYr8R#9e> zqMQ)JjCxme5;$s9G^W#Z`DeDD?2xRGF4)K)cj;U&jJyM_>(?{*=50d$=E}|mv=O`f zv95Rv{(ULR#wu*`_@I^@$s`U}rz53ude)xI8KaDVryVPjqBoA`D;yG*zz41kUKUq3 z4igQW@#|R0o1TZ^?+y8Al20D}+3D1p_1zD{ziO5!Ba1EsI2Eca zQa8X+`Bg@J#9FqtSft&sX1dFpXzuj!ZcY;!$Gsyw&tcF0Qpd zGe5h)b02e#_4%vfZ-@HlhGw{i{>JxYFR|u$_OGULYN3fu*`B2qa_eb44nAxUdm8L? zjcMa18IJ{kDd#k3z7rQd~oLvA9Bz0`_|&D<$HYvA~YAiDOHdTxJweH?y}N*tLM zc~ecP)NgKz5`DWqn>{xDdGP-L#a$~}u(j1ReP2)2ZMGrb6A~FtG5FW7*!YbuWL0I7 zHo(AcEA#4!?&xGzCUpely$>kfE62=lwRRgyb z_kY9BiJDfmYim4uv=i_)JYZqS;{^Ku0EK_3{{Te46#lV?mk(nltUc;}algGElht`Q z*&pLi(htMQNk=uHz3BV1^yvOuKPz@VxA5uXQOBHR|{s9GQ7f`E}z+YuIcF4-M5{Y{fvIdzqTL3@7k~7)}7t9!3sp@7)VnS4CMH1p4-`@q>u6JVsZKtC!-{s#24S^<7t!-9D+Ne{^8+ zaIa1^X*7Aryw+WzqlMaM;_BH(Df5CSD0N{oG0RI4jkbE`NzA*e8({$ej{??ie zt4m{b8i>&Qwtbl|uL_)lE>j@UKAY8GPLvIB-3*7r7XzNb2qv{IJaxO!HMbHLAuAsM{JU=2iCOl0 zbrp=3wk|TZh4W>F4I3#_)1E~@B5lPAWRGf+`OAv}DN&lbwoCvdudX}Rl-E-xUrA!M zwUf^Q8wBOJuORV{#Cz3CjXOkDwhVzJZRZkwYk0JZg4FT2nahw!13BWipkSEa(uq_$ zX`|A97u@}W;^)E}^Bi{&rnv%@Zu^ca`j)uVtu+ao$hV0jL|Fb_9^iV4`(6$I0DIT5=i_QON@;dy^qXU8WG(Ji(_1se2=bvb0tb)hZ1^Y@j(H$($#*12wb`T8N!= ztwm>XZuU2d!{nGrv=R8!Q`zgfYzpzT60WudGyB&vAuYm_c~S8N-f*SL&DS!{UhbO%FnvDWkfUSXG&qkc4n^=xQFQ z%6HWLfcRahu(XW}D2z4%9r&-bd?R*U5EIY<53MU|aLpd;q%n1f6ScVGwR(P@Nh%k( z%~_e>X^s~kF6!57~F(KBI4@c+%E4HnUzhVR3_nAzQys%DtQl zTONKom%5ria(qYQUl;giU)Ovo;){zk4Rp;N&7KS-DdXsQ=~na~6YJK(X|45DmKjC{ z=+(HdrKKGYn5&^jP_w?(Z&F9q=Ce_en9ttLcm5m~T6UT=iM&QG;|ye0oj6nPR_tV? zS+~~Zj#;96n3;op__!5j3rD(+=5kEXj1pLmGwEElq>j1?-0yrNtoS3rx)+Nz&2g=s z_6tcQNSfb!1qyOizl8L!!7tg4!TfFGe~OuqcE{*z=CP8#i2H1k zGQO<8{{RID`wxfwIpMnvQuTEG5IJc`1UlzEJ&DD99pGQGS!tH-XLi?C#d3|Dlat=Q zM>>_Tj_1_VTAj_#pwgj6Le5Vd^rvm|pbU@4rG8~p^=Z8a+c1*{0P~Duwqc5J3nMsO z=DEutou$D$7_h3bJD~h63p56Y*K%Y0?SAi(LKv^su9O_<(Y+*2xp zi*e2et!`Uo<1%0<6mr;@p^-|_xDArMy{lGfJm7%s+tA{ZiL@U=8RAIPavgq@tr0-3 z0LNVVRwkx=%#R=|%I7>)mfEN{F~_;)qDw6!w=K1cbCHqMRrqeIl_#ZBTrKXYso0G zvU~kr<4@5v@Gofp_CQH^iERIR?_ymJIkmE^E}m<t$h{mj68p-wXloG zdw3^wMjg%tea=~u#uk*-*_@f>5NTR%zC85%TGF-sViOQ?+x9`qyPTXDsR+&Y$32M)`xKz7KLvGQPFi+jt=? z!W)p-=u~l^UTdLKv5S$=c@`GyIPY3;~1V2yQ?q-y-hC68)8Sz@P22_oh6V#5C ze$&Gf-a4$Tv2sRO?EZLn^syx^Og>+ z^73=WE75#A;7vUw6GYhYNx z6n5Y)&=dd#Sh%;rQmc+VYs{%q`y3OQa@?ONsZ+Q(y*?Vdj-f3&}NVfjat}}t+fx{;y^~NAs$=GL6T1tkF4q`hGQ%(n%3%By6uhzO*t_412-nMq~^X z$86LVo@bFKJ6|~D)*Q^*3saxIv7URSFC&l#exHR~vxM7~-;XcX(t~4Ca&DPd%*qbH z)rjqdy1a@(h;^pq$&p?=z4L*BsHeYr*qZVdhiaT)Vx)wNR&Q<)AbstQ{i>zr(IHsX zx^s?{6rP7IsazyEDuiQ#anMpmhUNjVt8qar=ckryH)fG8B!@UEs!8PgSD@P1dW^){OPA+WQq1Hk?mC>z{Y9uqey(BIrR0d9L!Wp zFvRf&Rt#YWIPIFT3~4L3?(oBbOPtjquL)-nvHA1crD%wv@&@vF;~><@u7pgDL}Y@% zZO;Vvt0vYINt!eRaNICz49a%$mk)*ce(9}6o94~TPBTFi3~DGt8`o!9XRV&TI1~s ziR6f|F~{+H)=$Ve5Wlw9BrKZN?#n77Kz7?F=!&A_s=GmDjs1@ea^j>fOau_G+y zK_aaoSjO{}t`a;9llj)0#sWK**fYQs7_x<%kF*uZ+J9QU=<@lIsW|Eh?Myj(kRVW| zCSqk=WPe&~LP#x=Um*P}86#-ySxgMcH{JSms$@K_(nM4RCMTq5D6t-9%m79HR#z;sfZbwRTXhiOjs%%n!DvJT6R&G#nijtGDU8lxS zDchXprV6eXcMN;tgI;7uA~W)=aynCFM?PGD0Vi{wm82bz$470tQ7q)EgVY+eHJhjJ zJhu`501FY;ui61Yi$s!njmC04sJB>|7%&Q~+?rhI3eF=Au`-DjPDdRo^sE{ZyAMC0 zq~whwE`@i6S~LJKU~^1#Pb9}8w>=0vipZ%lQEsl8+IT;is=j@~OvyAclo$)N)W^Ar~ZHe%N5%8Xl%{c%;}*?_>{`%r96FWIi7k7Ob&C7JIKLEk33V>cQPL} z6=EMKrrC&>422vtP%VfEap%m+>B}7GxlE8EHtQWsLzFv@92%B}RcIV4yA8SOG18kfvP6p-BQRsPibTI6K@^cXqpvI1 z2S2Sg<%>*&ppA!MagkNf60nOrVa!qm^Sg1)Kg4jRGnlG54 z5klvCwn@h{`CSX_jgJQzBa=$P_Jp2tBgYKlPbZDrG0kJz5jDm3S)CS5s2OpAf#1C@ zR8p1nE&0u8lNCbw`41g4MW>Y(?V}v}diJX2D3?)#&Jpsea7IQrs?fo*6=Nzn2MvSN z(PE;mGHDRT6@gRK{c5vCY0c zG5l3gjm=!FXxVsAP`bRh^4dtPnlZNn?y$~J@~=zN{3>9zLvrsJ3I=nvocfB{9FwSZ z68)auA0=W1#sFbgZ0(?xC!SnJ$BbjBpyiydWoi*4$0ym!9DUPSHkQ-PxgA{;HU@jr zIpoCDbh%kq?AxAk$Cf{euW5QN!ylg5RvT}$@@QfIb0gt75F1Z31EJhnX zooXd5YeBZffL;cGe3k4sZeHww54( zDuNcI%26!DtrHRnD^|S2la7Wex+J=(5k{q(I2%SuHSZc9!;|4??C(5N4XQM` zkx|F+XM#m;BMagW#jQfhIW!F?QfMubPu-Y)TqmY~3i*Rq)~>Z%xo&5kSs0#$i62@` z*xC>|sW&k>JXAt5bI7a?h{nWtBb@$~D&*w*)(woY13EBR!8zpH$%mJM{D7oA5MziBV`j$6lHwXKY04rVpcfoO4=O} zxwQVmyRecKY1%|&U_AlIKc#u(kgP&M4&#!4I<9VqnJF@qT1KF@YjGmCIc43^xvVWp z?)uM3c&^;XZ71JAPSzr(GpPGMTpVZ8xn(1GyKZ`qhCC~EeImD(>k}~8NaG&$^iPL88)>Hz zH;|^}oIXbf@S#Vkm06^Ba9ISEcA|hg0bP}in#mYqs=YBvUPqfYZozD^;gwGZ^R3w9 zW>7q^iGldm6J!&uwpm;d6dvQHZCT*1*J}EDeJVT4q=d$(jB~-j=CPG~8b;d}ENtH9c%SE3$52IfcQ$dy z6m14qjz_7k3b>MzIQ>d3$Qc-!m!=OmuLSYOfqXsU^t`pytpv*`JNFFp*w#_5?sU?T z@Sntw+22_3)x*o9+s%7wa`FjyAa=m?ubJ;Orm`-sjRfe}!va5@diZ+xJD~J3;-2Qt zPca$4KDEj+m{Dqbq1(OKL$1bDY(yZ9Rhx=RNtTn(An! z*w>B~NXRaF`gE-Ot3_btRA<-Lu$s`?oX%osolAU;>(Z-D;kvaw?ojSUfUl{d=CAuemQ>6*Kk~Tcf?nk{)B}@ntj~G z*J7OfndocxbM|fj0D_);DEQ5NZJ_vxwI2ZZ&E7cJ-_AUl+Z>hrtKfKtAh++REjpw9 z0Qxz7B2<(z4EB2MPNRQxB>w>Pm-2lN*6j=8G!jd1BpRKy^irT`X197)7W{iHwOpMMvBXYEf| z@jt^hlj2vxgEW#$Z?LW2p2X*B58_-`#=Z{m#M(vtx0*DP+szXbccsqT3Xz8A4XANvGFd>D!}PJ#|f=<$uyEz~AhAT;)zT!dG(S{_kE#f91cr^}6#; z-*$W}_{Cx3eL6Wb;*e?yCMSr$&l7v(*WSJX_>%^%@>}ax&vAI0V-EQ8$j4uL{{UzB zBaUe2nOz*q546^+vsyLhXQ!F|GI8ezODD{yg{ijjebd|gne4v|ej$8V{gQqmX#W7T z2f+Ku<ul!$dG^YakB1A&v$zp`)G+xEfuYx`RKFVp;g;5}Y1?PS7gdTf#p zKE`Z(%FEZSe0S?U3X~_7)PE1XA5N>} z_4&TX-r63$9mw*xoyu`t)M@6b&1~f-UPe3D@g!ZeKXi<&e={HOUVr!^#*_PKcn??o zr@v2^TVDl z((Yul)%2U_%3NAps}RaT!Nx)D`ikBMT{of5#3nhDADHi6li@uBLTwjX*0uSih0;Bi z=&myJ9-Mk{N?t;gdZW(oCIV*i@f}cMi2c;90S^@)}Hx zspl26uOwhH4l6lFQhk}HZ7CoZY&UAxw({L1W{`Qlxa87|MJU*?v8y)Xc*yBpXt&Wc z?L9Rg5nRt@Y#S_bjxokQwX%r^&0aF`to|XoxPwS(>@<{eB3$IK>5^;CS~(boV$9yA ziyOrj;j~eQRv8_5>skUIFsKXA^{fUYt>u8E@+yVWEUH2VEuL~{5rH~5jKhLA@y8X< zO%%4}fndProYze?(85wVtH|U#!jqH9^r-#{htfVd_)AtuqMBoRfmOO5JJ;0k#GG-E zeKq`<=i*awX#SNip}ExTt>d|ZD+r~5S=Js8BfdNHT%1;GrMc7OQ+Emi5dl3rX1{Bt zz0vvBFPnB&(==^9dkt1?YSC@4BvxB>1duu7KZS6YdS$koaSfwGZ9fBq>5BAVv^=>; zqo_}5_L9qDZ0*7Oi}PT9HNeVkE_JzMg4$VaU9fi#yZBd1jgEP0b~ZN}ewF3gPcwo} zRdLXNg=k;vIx8xDiudgf%kwB)Y(ABwVBW?`235AJA#85>iNMWkT--h2Mqu(zI2k$3 zZBCm+v_Jk54O2s# z{S^n6>=<=8>0Hglj;pJ9x53uBb?)dTyxlSqNo50|{{TLf=i*(F*+Zf6Z~PVm$NIJZ z0FQhr@D3j>G+hrxO;Oe3KfIDdvpMzv{&o05ZKO+s~?VCu7X+w6d2i6ReFHMv9rD<)o?v4qK4>_6^gDuTG$PX7;QwYaH2K1ZW+6fJ!_H6xsk9|L7c5^DO~4;H`J}BHMPuQcp6_U z@Zvx1Gwj3SU z2iSgwzdHW_VNVI0PlSFRzQ1CZH%Seic};vcj# zk+&z0psKf4YOA%+%sO*hMkX^va3aSZ(%Bt;l&Uu~qI|=z(x}X?@G_%-&7AkB)64}^ ze_o&pQd$9|Er~1vH~?a#irkj~mIw|{HGxq^gs>(T4f)k;t?L*?BW^Hw>sd-B#BjkF zML&)}=}}Cv%OFGtIOd?J?m*VX5Hq;WeL4z~HH}VHyMk*s4#w%&f=FhbaRd=faNSi= zNhk8E+LXFZjbi$)xvuEi1*};!eWKx2;{(+XIrgn7;iWB$=RQ;TnfrKt%wG(ro*Q2n zpBQQ}#9k|VXbY^Y2SbjP@aM!2_$qJ24OUCL4}^aYv|SfZx`2Ukal7Qt8RwAI^tcWm zl%>rr5u0biJ~jBY@vGu|3Z6drg{#~^s>}9!d09{bbNW{UX`$LdnWPflOvn|anYXiJ zxhB5n3xkC<%LQWz)GV8nOduE|fr`$WS)~mY^BDH8Mih=(l}FjdHlSJ?cNY^N!NKI? zt#%q`!~Xyf-ffl`Jk}_1q+k~9liIrBOyr!ddQOM%e&Pt?zt$2IWWiw@h6MZ9eQ{;s ztr{Ctx3>QPNd&aK@cx`vR3c>LXC|?0DBTsYvuxuS70c_sBY!*|SSSmT=~pG(##Ihx zO-XJuAqRKTxy#)^D=|AT2SRHWX6M-F-urVEX+CUc70$}^~HJSwebS_>uSR= zw?$GHXypB9v8lpc>sQx&&2aKIG0E%iSu#rOpEKl&#z}NCb0A&+04pgwg;|Eidy-14 z9{nqtrCS#nTA-~c+B@$s1D6nYqH z4oA{H7x)#WShQDq<KHp} z&6uq*8_BdXjy|;LqT9b}w%>a4>Q%nyr%s);FTriNvjKySwY#V3S2q%*P$ZX9J_4dC zW7n@8s~1q-PRGCabKoYwt=pgN3uvuX$X3WXXwT(eSa@6EPJ!XuYgi$$jL9AWVaVgs zxvJMZ`qlNaJvvJ`Z4wb~f-T14s)WWSUe2l}vh^QbY4T)jv0SmmNls+u62A0%b=|Dg|aCNNz#r z-m};T&v)~nI}aG?)}16ta}Y#hxM!L#rG#^`+ZAycEJ~al_o~-XNs;8^cYIWvK&w1X z!*C^B51We2l6h7!8H~7NjQ;?3f{Qk>Nf(mRKH^Ut^IJQnkoiG?kGP-+B!EPB4p*n8 zPiY)S21dxq`cPu`CgusASi#xQ=BBnR`?z$ zg%j^%(zT3qHG}A0wzoqVV-O_wBc)teCXLb19f0GJ)~dy}Nq7bm<=V%NJJpCRT|!_D zq<(cWiHwN_xrv*nw-p(;ZObTS^9K#aGAj~nT~`j0DyUvMXRQ%iNQDBn5Q?5)A3S4c zTrl8Z^`~1#XOUxfC_UfC87 zBM`V>=TRwG)+<{QqKxin#z(zOs{2?Ja6NHWnOC-jbU|&OHbcu68SU*^cXEsQgi)b< zangcK3uzurw&!}47|G)`YDh{U4mJ_qfQgG7jMJ11Gtg(fSZ(MISgT^0w^3rZjDp@_ zFW1tdx>C^wLIEDMgycyDy2%331nw&;GQ_?KqOBfWkbtzPK{Yn zU7H#GXf=#%IfN7JNXgyPC)S`A%M&qXV>peC%9^&MX?{D|COCk~7}7 zqFwj|0#tR+N`BC38CNpNE39uBP&nh9*3%;!RaqB+Gr_A)<0)zI%Z8dz4s(Hue6mJ% zmK$UT99D{8O%>otHxHL+#Z-Xe$sTjR)QVf&D5pxgTf{G;Y}h#N@laILiB)#!ln0W)?<` zjM*~hk4#oSl6Bbdyg1g(W`#Pp?mk1g^xfItTWrDx;aT-}|8@dd9 z*y;v5*M`A0+RU!SMZV%bq;{<;t7vaa;yzDS+L5v}?9Gg>)5q4OXeV%5Mj&&_ivEa< zZhkmKEhblnc%&*oA%=K0p)BbnML{a$azN`^mCnrKvF?NuwT~J8^;+Dj4$yJm0x?r|>InTB#?z)#4qw~Mx@9hJwYC3SyJTHA|ZJ>F?nLNBn zD*HF*`Pai&9w@qLWRP9lPWk)J*(R}@M^!p#=wjB}#8xQ-%I8rGRY5;{*iz|NS6&{} z?Pa@Xw75~UmKft8;|J+c9rQYsY<-R3U0&B+iq_X5Bz5x?g~sFc{442Q1H#W5#~sI* z2+l)#`_{%R^^HG9v9xJCs3PV*OJh6^Nd0S&@i@1V;?-=Pd2qQPj0HZ_@1=~TW0Z>G zJGpM+xoKdzOe$_)mHqnGyDs>ZqGo0s9RC1HlZ~MfU|52&QvGl%V&1^q+0AzhXsH_n zat|P$oPGv_IYX(7s#@;*JI5x&$sllkhMN}kLZrD-*PfJ|k%XdlIyR&<#tvpH50qnO zCj@R7&V933{vo}*(H%7VOL-!U1GaPkZ{7Sr^)(Jii(7NcwOb4qLb|>|;~#dIVo(VmN(mTSXgNN@qgKh=o-;t2 zE&ZJ&hvd(jo_Xz2EvqR3bGzPw*pxD?WeLN7I;tc>$NS=ej%iWxkyYfJV5lSv&>@CG z#2g;NtSf|4e6qw2loXwd5dQ!H`Ph0IttT$(Rn<;F_Mo`Sp)iJIC?-s?Z3mj$Kwk9#yeX(1k>%*M{cAYr<@wH@W(7ck#fZLtxqbgVPmw5VMc^;)cV$a)|8Wm zR8Y9-fzpx2>JYRh+7kq-?-nqv>FrdmwEYWE((g3gQCn*%C_v8B^!KUeT?>ra^Xi zeQVadHSp?N*#X$H{KT1)>0LFwm?cU?&bztC827GuKBqCM6}Hzaw6czKir7nUF%$vwcJvj+ zQe6e)PaGJ;WNuJ+&1pw!q^c+@=zVLRQZZ(Yy0Q!b&TunU+D2SpoM)zbRuh*&8CtHZ z6b%e;M={)-u^Ah^1#W2?Bi%y{?d%e+Ks!%t`q!Oar$k&gI`y;`(IG&nfO>YQF6Bhp z8?x7(I)_AJbCW`nxoyK~?VML9f2KwxI{;jD6;Nf}Bb~VL^!_EDOE`zx<&9 z!xhB%zxEEhztW}gG_yyiUbGJ*8HN$?I)(fz-plB@YHJ)tkIg?B{4>Ips~oo2mb)oUJZG2kk0851S=Keps#+N7Ing}GSJ@9HPngxyQWZ`0~6A{5-1|M zjbuhw$;TZlqA+C?ZfxEn!BclQ>C%~Q?z`igJOVOnSgS2Sfsf3m40`?*qY8;rle4u^ zGuXP8!)U?w;-(hFD=0ntcc8?lb!bi>c0F-f>lO>7i}KK4J0fcfH3mjZkaJk`p;yWR z7pDT3k#UvCh*ld*6~#d+p#)@~Pin=T5M@(k6p@|$wR7|7E(^3|l^wCoV&HdEk&a_! zc2l3rrAVMCAm?$YJ0UU3`$^~Usb!E(sk$^tla!T4Bu}FbYFrcC>Z6I2CCwLRkFEX# ze%b#382$%cSz125srbLa3d)jNT)8g-G^I}<&1Gy%RiP*L(&_#rw(h*v zzodE>jjZq0BQiSND8nO+6=B;I-@$Qfsls1yW<7Fi;O}Rl{ig`@G4HfUu2yKKwii~i z92l7Vg!++RnBTQ8{1bcO{{Y6-)x1~XIJEx&hMyAAjF8^xu>hAY2mH2Pgc|iQnE6wh zsTZm~Ym7Kg37uv2GVE+`39b64(o4;Mz^0;S2`ugk^G%i zA>C_y0l?fx-QC4~W$=&VzM10vI?UjSw4}d zG)-#p}&gB z{51Wp{uybX6Mi1vK(~85ty00H3oV_({pDoNdgi}C^i5}aM(W$WiLdd)iFkhzm1Y&P z+*r`B4I2Daq8^R>k@yP5ERhW~G25ZrL5#S9|#X8J3vqLSVlE2R> z;16@{UR`?Jiph!KaF*=pv7RX3 z9l20*Uk8k;=Pr30`y;E;VwMsZfLNZj(lxT5E=F&fyov5ZMVR(B7X!aFQe^?Ku5;d? zMLV5^4j7ikII3bc05L2F(t;%}hGpneg6vn`xm`+jk8o4DdUMwm*H3*+S0%W?_V)$Gf8WHmh$HrEIyU{P90jwpPl1;#?Pwi62c*uQ7(h#1a_`c=4*$! zRxZrM{qIp;v{~a+7Vg^N(n-9=PB_hRwgD{e6nTvEwIyn_|eAA-mzfrB=~(IZ_#|?h-liBV*<1?NcU*vA=4z*YQfeT)R(x zmEQPH(me}S(eH(X^DI&Vr2BjR73E^%WOiYq-pAul{1oTJ`p1ZWY>yegh}G?4x6o~D z?c!A6#z}qKhh9nRUz9hB>2_lCo^lV~Ba>efj+5tS*I^alj=w|?MjC;)nF)<-`j1EU2R$iH@*!V-m8V0zK%qLrvf>(@V3dgwa zGm2uisQtwFJFc7ST{>qBw(S&c^7>#`=x2fT2<43oQZvLp=M{r9sU2*6E1=BsMF|D7 z>zeetJI^hZQQtlD-nE9uFS9!H$erh~=I1Y}I;;O*La(k|%eZG2!GG0ro` z1PZ+$h#-?6IqStMBQ{9-xNHsh9^$H8>S?rNlb)EY9S2&YmM;+iypV8 z-|3_`+Fl}KZ|=8a&%Jd~m6;V`q5G--00hwZ{i|Gj4beUw>%JDS@fV16ok}}97n)#% zsUv^~IR5}XmHiUjYV%)D_I*c8ve7SMi9=h)Fe1YA?_WiSsC?cj+T{zs8NqcI_I1Xe zXXQjT`HDVbbKKW22a0W8?(PU-1@? ztnQJ-X%tz($?ARUIvy${kQy6qxf_7PVtQJL#NBC>aq(L|yWkgw zbRP|TFz|(jmvCI06q-c~!j|d>e!tGXS2LePeeO__gSq+j{{RIvlJa{W4z$e_8|`F7 zRZPgh2E%`!O8n0Kk@SuJ3e-kU&$Y_S<^#FTsJ^E3$hte9Jm~G26 zV``4LHJxw!z0AauU!7L9^gS59hLbvM3>br+1#4RdctB!zn#wBUY}Qbg@iSoWsuwBd z1^K%Em9>mpGqy;KsJSarBvUCZxptpQ7>FI^P$Q7zp0veM0FZs~bM+OJqy^}28I&EH zJ9FN&;$7;pD>pR;uw+w-*@2HZ=}%Z)qw?IJGp$6QLdr~yXbxTT=}(5%@FA6LrolPO z3=holQyOx5B5$szGvfaMh<^?|A*WsHUMunEhIHF#A`L8J(z9sRe{1l_$ zM}ZdUJSlCcc;i%D#DNnru_NzSv4P3zRd-0GE1weh`~C_$`$TxgE7*JsZKn7J8Pp<3 zBl+S?^&W=4MDd4=z94w=?eBbH@dLzK%#t{HQb{nZ-TGJAU~*_u)vK|&92l_C^vSL# zNQ2JU%O9BJdJ|B#tec9c*@N6yxe8V>l-njtnI$C`sr_p8o84X9+gZkv$YdlY)y^^3 zHPs4cGHmq?JK<)rtIux~Htvll${nNQ^X*-2hrs8vbe~w%Y_4#)k_g5RUdN?$!CO-) zN1@;8eiZPgi*p-V>CjCQ0u@NdKKScPb$9)nZz4m5ho7g?v@nyg#J`Gl7>&iMPCm~4 zKp4-~v6|*fu_=~pws_C-t(S9(bJWPXzlPdaW4L{+8+bW9fmF3=Ep8$=P$}}k;|D*5 zOr_Aw=C3bdh5(Rl-`@wVaWc(4{OE}raC`Qw#$Jz0no?bX2s)f}tMSdC*v8K@E8HpL zJ?J`N71Y4iJbh~nOe|YtsO{I&73KHdEWf^x%OuR_Ilwp{jRw~_$!?nApU-A;dFH8Y z+($K(re@vt6vF)gIr>%GZ7O?~3FWgN(z$9@Ne&e5b^14h?r-F19V6kFg?up9*SbxOq?36(yC5YSzw)kXlQ?SDJ4+ZH9i(^5w*vzJ3g6n% zqA+|h>yF~Ms!ZXOhsMG}MmR zQI*R=BqM|&zl%P#62L=~xB>K_qWb{r@)MkOCZLMiWG+~qx$8g+KIqW4Qs{}7Vg6_ChnO%s98vaX zXpqLhDg1L;5;h2kkn_kmIUTD;Yeozt=()})uoap$d6eS^+O0j1Mb6@1*V2F+8p|vt zBw|R{^aCV#%f$dsx zhf-Eo44tb;A-ME2?qd?jP@Jc&Hqt08otP4@+cm6WO@Jts-arUobCKSpxRnYBgEn{s z)k-1CXS5EvF|Oy&2Agn>b{0{Qjl(sOthOz*T%c7w!Q!&6CM_X_axu^v3`@`|kr4z8 z56+^UklZ9;hEGp=X%CyI@g!@Q$-{b6rf{&lY!4%?BE6waVul0~wB=K-PkNv25Tp#i z3A6fFIegs+ZEo5bSVjzhoQ=co)w`L5+g5N`6W1BV10hS35;A1%Jap?(qz?IQ-#^lT zC6-?)a86&PAdXFoHdlUndWr^yPdt+a$>eY`QIO1ul0oazg6ytGAS3|fu6?@Ic^$Tm zi;z9(mB>wNBuc~1jH_omNv1U7YsFbMe7t}MYNavQ&~1igASyZFdJ*kWs0l2KAqu(T zpE$LOCLf4mLDh)WiW%xb~+100CTJWBiH> zDqF^$V~EMwf_OdX@+NG_yKHzod(Z`o83;nMs1N*D>}tI6#$_Uyz?lct?JzCWYBt#bq3-jw%BT&T26lmG!1YjBq z>;C}jpqWO+8JQ!VBr*`~_eZI#NpT~IB0qZ^`--bHK(I3uW=R>b#YFyJIR`na_JCYi z;s`c?4m#8fT?(sw$_IY+X@ORFj`GCv2jx{@kp|~d%-+<%iP`ef0L*`tLvGJ?0hN@1 zbNLF+Q|NCMVd}XcH!0X2)d05M(mH@t4s+VG7}){Xy9OBXj8zELBg|5x9P&A}gG@puLU8Q8ayuH%NKOPY zT$pW=+}lZTyZB+%M}BJDTmbnhdje`pi|AI9%6x1lMlHx4sm3^23$hW8Jt!*Xd|pHO z}-ohJdGw41Aw`7x6is!`JWO(cpV`~Ay-JB2pwSHlINBGa; zZxr1=qpIsKb#`QO@$Sz)=jp{}PxXWE1s45iSYNvr^J@l?{u)-NZTG?Er#QP{uQy5(din*$rO`G5oqnn`4peJ zJu_TJp?A0UsK31<jdzgXrl!*1<}na(=;lTzw!s%aXDw}v<#(SQdHl1_T#rYT5im1L2oxe>@p%Z!dV z6u~3u_Ez&>-P$~oF;b}9t7iZa@5NweD;56$vIKr+T&VOT`*R zuBCOSX*aT7>CwX)Lva}U#4kTi^_#hzqulwk#XcvWRf!0iO~^j$_xx+mC)D11Ib*sd z0pZ9b52aju#+PG;yVM~~*_l-b7|%gmwxg>^n^rf%1CxW+qHC$ppmG|fvP?^t40+(! zD?Xy~MmgGX>DIF~RLmJ}ByvH|(x$etd$IxHM_wo`XlpK-w&<8$-%-tJTaBS}l_U93 zQlAM?YSg{=RsZl_|1NEQ{8)EVNrZ!?~*O`P0Mp)+*8pa*W zTbRiCmnz4%rBx$o45a6!1=v$f^0SQnezY04W=bP;+l4;WVkUTtZ(o-k=peBi`-8^V z$)-ASj*K|ZsGve^Rzfg6I#m{P8k{LTx=>tXRSZseK9qxg;qvj*6dGT!)wC_1agM(A zv8Gsg%&^A3WT&nv^0FQFJ!it62$t&QTKS@~wqh52g8(0MUXiT$m&0BQu^MKVBmV$w z#;v+Y*le4hU!fE=VmW#rDtM1yz1Hs<>izd)Ayk}&8Lk%g>k% z7Wr}%{J!<1Bh-n`$I$*9@J+6d_I8mYmQ(XHcLX0w^!J)c+@6eoi;gRzF+BRUiPd3M zMGW3)9M;qdy8?}@*r;cpQdb;`rO5=ZY*j-zNhFM;1GiKH@ejod?-LkqHAgW-k(FC_>Y~3v!C)0A*__sUv%q{& z;ol8>QI6sZ%WFGyL*)IB%sQ6>WJ{;A2H{v@<8X4_wW5Eu+Kt089x}KQO zO(c6rV0N5#sC4@Sre;T{%w!vQu7bxxx|{;a5RTdFPBfb`lzW!0CDN=MSV0};v#Yd% zDD5nh&6(sq6e#C4?7tF!WzX9K;Kzhu_=WLv_DT5P;GYBBMzX=IPoqorR7M$7BV!0i z=Lee8*c0r}4bv{{HLFN&>?elh89c%R4bk(AFzOC-#Znyn;zvBBfor09&gqBV+4a7pdbtIWS= zKR9gX1W8F-O&u%+Z$~QWpB8S-+U|`U;#FkE&^{kq)*-k~f zVj$c;VBIQ9DK9krNjSwQ`Q69D~Pkips4h%{a?c&topd&kt5LsXIz8 z>G`AeWAelxP&*s2#jf{Mt0m19}SL3`#lRPCv*TDAw03-c!`aSs3ONui80IOHi7eysC z{L5uE>-N0;QS{D{;wbNoX(MbejC0f)+-Ok9S|vFojEechtbavb`W{d5Kj5Fk{{V`b z1@?vG&k5LgmeNHh5+d$X&=JLdJ^ui;AN&)G;xEB%a{mCv{{RIZO>4rSnGT+bwp&y8 zvZQqt^!z!UO9P3GRNpUDy8i&dTch!h8T>D&#F=Z2B$g%`!T0YL`#-_k%<+GLAGAmO zB-fAOPZ6|Q7mRG=@?I&|V@wx}h4tf_{W$Osj#?P3<&sFQkgf_z%CPCuzuk`j{7a?8 z*$q1Knsw=}S=*~yOa9(k`rULt=7Y!o01dGmJ)P9%gN-_kw3=&`{iwdpKAn%Eegk}S z@!#xu@lQ(l)$o>ow0L4i68M`!Mq-z+AVcr_R;$*e$&1I{iuEw=sy zcq_zS){RWIqt+huf5P`(R(kKRH<9*skEtoxH)T#Z&0X;pfurlXPOG77mNxpQhcy^l z-tq}hGBOc^ka*~8__i;h`@A<2s?|T>o8PrP_r{Ng9vi%0*+a)yCVkfF zn|%*aa#+9s;Sl}w=rCDF-LJz-oiJWvc#dM~tPccNOkRg%UWYkzrnGO#J#n8(&wFQ1 z-!5tZka!jJb$nr@3BZ}yZZb|c(i1nMl5b7xjl3GS1nl`v?6-Xf;=fcr+;lW5<5l9yAhIc+ZFYWm1ARU z%3+K~c+Sy`{uT4tm0PPL*QEpKKZU*%x$!2UXFM$FX%xO=w!_tV#eRlq61axm8-{J* z1EH8+I5_A<``e*>UsTYQ5=xGk+YJy$4-^z$~QTr(D!FWWQo@&u4)7> z&Q*Xln~Nck00S`27;tmmt50>YLh{X@PL)xIbDgs$;Cb7N4{j@&)I6^(zET`IF(maK)ysHke6NZ=5HZ6f*8=TX4sqq=ft>ndJXgPvulA^Vqn4zukLgRo z-V~oy@P~zN+{R{mL=KBC<`^AF?V8uV_;{wy<&KpM@~GX)g3LXu_j+vjTwNPoGnBgU z#8$9>q*_UDAy7!h2>OcWn?pk{%#(^KBEdrcGCGV zsf>N#G1j$?=RDqf)_OJYsN2}LmcdsCn)J;t#IfoE(%yTubN~cj?tLqR6!bkD zD?cHB;IAGXZ6D)@gS<-(@{KRV8VWFFI4aTL08d^)&3-w(lX?5q+F}@h-SL|E{J|^S z`m7_;$8V(A&21!Q$dyhU?L05FcS{eNs!U;5wRtCNMun7cz~Qc-`$R*kla1evasDju zy^gVKsC}B%ZDg02$YX>c%J?;QSB`seWP zQ1jrne>fE%F4Y_#dc}%p`nSW{sZgu6K)@B>T52lJSIi%s2Q;Ipw7R*oeTIF~ae%zn zJL1obUJm$r_G#jMU@h$b0P5_mP|tF6)Awu0u85}0blOHjMua%y?`&Y!j75@NgKZzRtk3IZ95j;n!%8W`yZ6LRgc5ndBPaj(JC{Q>m zVzsgG?Ee4|J}~NXUC)27_=b6%@&x+z%Oa0u998M=ekW_%WxcP5d}-pp4fvW?5g9+X z=MfQ}yO^AQmE5UBTE9$?8{{Zk& zpW3^_lgu@L7DeNIF%~oA-&!tQj^X+2e@dE^6EvrYlFMMe!CXYgu zUSqkk*B{JTH?i%>?ON@tiOQsSVtdyUH%jJ3=Bi^G3l2E?S23t+AS1ABpISh8_lUJJ z#gu{>~xnPD%8vuWPeZOd7iH4ro_5+6B*yI3ONhSBCe4d0{n5p3 zOv<{@_b=Ih#v0#+J}h`MLeljw?8U$F1&nsTDfy&nKw+Bx;Ji!Wy=O?4JzG_>wYmFM zsvkAjeE3BhfE_wlvxn$>_BNUGw~D5FSQ>k4LFSY9RCT84@Lb+oq>W~BoVV7!IK{KZ zdOIBknc`S9sb^hFNRn%3QyguQJhtrIR>Wotv?kUv^Dy~H9s5+&r=^apGgq50dPh*ABSIB`sd+>kuHznT`tx+8)&yd8WGTArF_;o zS^1xHl|OZ#ogeT~==B{>UhqAn=Fl*;Z<)C%@|<9PHSk}+SmV*WJl6Y@?I|RSzBBT% z+;d+mo}}>2zKwooze%3CshK5GiI!8zHO=fOSy@jWqosa#Uwhc}>6#WXtFSIWC)T#o z20(#a9M&n=wu<-D>;g8Cx%4$d&oN--*+Anbt!`mr%u>AW2pd~Hs{6_#Pzo+r)4dG{ z&AE1wk(2)b)mEZpWI({@yY zT8@>XS)!L|t}ank0OygM*U!HYKWu;5d*Q?_9T&|_@A+!w|MH#TM zK!{I#p1Ag}tHESYj%=?e@m9I0_=e=}-m^;ESd-Tos4c&;^rR43*+Bw< zx8+a|=U-7ynu@X^&#;fHzs<3D=}i9sNw^~$l|Rol(;8-SnWJUl>#asaiq;FOjmHIo z9f13q_1_JC&z>#TRjrx=qda+tIDrrO%ot!>p+!*$6!c~?sH1DwlWsx6@oXmol@nSExV>NKVG$y;)b^nsCmIwA--1WSL}{C)I9QO zEEncU11TJu&ywN@?ZmN3y#XMua8%Xu*uqmeJH1)%{N>siae>Eb!3}zdQ+oj2vw>L4 z$fQjgSj7>N^6nAOLfrjp68pxQKA3_CZQ;0lpWYs|lZ!V<^X*H+hrZWT8uD*_y_`q$56 zvkPdM>tV23*`DR$uLSsG!;nV0c9M@elH25B$0x59*u@EoNhC-Dk3}3~+P+r4CANFC zs3oE_78#XQhSI07>r*5w+fFvOOji`9bw)NUGUv#S5XNFk;Q=`#*A?DqKMy=vt}TqV znq|V<%{Ic!xZ0z?HH&s8RV;ly;Lq9K8({P5TBn(EA0jzMNFItnuc9<>2 zWH3yV#ZrNMNc*baOA32rtO895O=cZ^e$A%7b>BmZf(p-8(X#oPZP8w%aw4Wy+O_*P%t~+uhxjKWHJkOLAy9Pq!%tr=Ak$n7;{YX z1;)~({Jil{;0616!j@MbE;v54>B)Co3^#1|rORUC$z(xq8g0qR!S<^=P@v@F6`^rt zY^Z=ct`JgPi+QcsM8ITqtEaf6QjG#4DQ?|;DhW17>jFuI>$^3imWE=*EU~)6=PUf_ zw+rXEA-UWtkXe}o zs1AA#2&~~TXN)jytHGcRNaEb5g=IaBQ=T=45vz;?&mAiUtZJ80>*WP3yGP;Ho920B z?jVXnyF#pDcG>U2?6qzm+>o*yj-7hYXjQn2&6W1B*bjP;0Hq@@xPF3xp=F6&kV)C- z4|>rlrhjHkuJ=o*h8r*j!oK~%rj1fDZd_tG)bZ<%l+vJm(}R(LO(KZPd4-IlzhPA4 zSt6ciz>zx~atEb1wSdzTlNcidZ%=Bh(ixZ+EuOUm^9+%t;{eGR?d?{}Awue-Z*WBb zrE5)$vXD6#sV9|`GK2+j*0bg`u*-Pk2;0~U(Il}bXt$ExfUS|I zArF>{8PuP1nubVLbvvDviQxAX8Q4{M;D%_iydD*Z=~eA**u^NFo=x3z{VA|4+Q$TL z(Gi9`f=B6EJEXUA_U#yDbu;6=CSU4qy4Hhe$jx+nfBqd_? z$9i{?o44;c?0qSymR6Z%kQmIH+;sX?Z@z{m05Cb`wYNYrC0{D%%3?9?{cA=xfs`zB zD~t?*)EZ_iXO;WLQisbUs5LMsC0Q0Ryl|tgJ!mw7DU@gPK2R8YRb`51eYg*S$2}=M zj+mM#Tk~obJy-Qtn7hVnq&_#(ll% zSO!~10VKtUq6B~kN}u~STZyf$;3eKy^3i&iC(@rQ0x4o^10}4`6_r@4h8+m1Gfe{` z#_kX?+Bxr9C|T+Vr6dL*ts4i%7a7MMw1gxrmJ7V_IO$X=JqAZ;WXWa>#Pswu*120` zdqbwAnM!y-rk1Lq^JwPoBf3?D7! zp2xK&$a1-vt7_J^HiB6kpa@v*a0Y+KuZsRM{?YO1w)%yahnnH;nM7}K8U+!Yat1n@ zz;IfhoZcYuwyA%0b2ZMRbEv$ZdPz^s`PY_BDc=78GaQ`bHJqi;?Sx1f`wWU`?d@3| z2^!Gs+M_3RZ(CbPuM*<-$S0HkI;=5#A)ISMf0uCoATt7!yIQIQ?+|n zl_UtFIY%psQFc7}NYA^}?`_~PBoX||se#7qRC{iuwl096Js1IyYeNRdT;Jbb>9$rE zl8K|U+{nOfBPX7o^rlLsX`qqx`*l$6Pu>U8ffR0aWnD_{1hJGtP%=n*1D=`n z#Y;YsJi9OFu$0@NNw*dIzJ{b}w}=n2{?4XO2CJa5`{0*M#e{$t(^n zq|0^v;o^{wIg;?0s<8r z(}LqHqdhArNa-=I=ULFRHdt^gJ})|Hf+~_aQ~}l7cx}@YO2C7HJq2m~o;XNEU4yyx zrofI(sBjnbs-{FaApF4obbypds-;OFnyr>H?FWvZg#bz|_qwYv$Jeb~Sk^A5<)FAN zOYxNQ*fGyJthrpYq^K&QgHi^Y7;FQcF;0dyavNhZ`%nVCzsxt}VCI#rn4@fLbDn$9 zM3+*;Q4=0rT>9iw3@k}NM&7*8XJRqAG4kUTVN-Z-m5GsCyKng0Mrww6acs8O8$73_W-@cxycB5GQsEYT_b z;tT@E>swmJv5!*+$KMu~;SQ7G`ypv-otw6DyjOxdIeG4;o_Qp07`v07!n2uCg^W9y z755FtapJkjRI8Dm_0KoZpz_XnJX6*qBZUI0FR&NV#rLWOKVHVWofkp6hI?y>)=cLd zbH}|}jm0Tg_rC~yJh;@|XYy5HOf-jnFg*rq==gL^J5EbgvV-jV0Lcx>t&-?@_=()u zj@kkckH4Icdb##boNiDQ4^EY$m5(xHZ32?pTWL|vNd#=Hc9tkV@!E#W%W?1Cq%L{< zt65@3Kv_Ox`qCM08)qlvA0~M@=~@eBRFbMO---(MY_x2F0I0z~rA-Z@x5@?>9DXzc zgEp-!-cnGHn-!qeeH0I4?OD!U4NFj3c}intE!M283)da{*CkmP$?9s^TH}@jX+0~Y ziqJ#@VDryP^J>T=Zl&ndw$jStG0t&Y*6J83OyJ|EdclpfcM?Tmb!8BaHHu|ka(esM z4X9k&+3!b?0s&*1!gCO>NfzE=_CRsD8=TjtX&PD6(Pf8;9d_qAIQR6gI<(Cp z*xe4uRk6ik*p4@mG`oyL*i zv!|q`L{D%J1Jtf->GG@{pE=7p>U=rkpA_ETYL{0xnuX4xaV(C-o%6TpUUPq{JcXy8 zeSvVhey0`nkiCT&>tnd^ri0>}sgnK;K4GP~2)Tu^$0dtn80lO-mGJLW`1^aW>o8qu z^W15-Pj3?K-mA5W?jU_Dq73&k$SKW5m-MfO`tOIe2b0A2aag6ig@4hqyT?qG(Kog@aOy+ zSMfXc=kYg){x*KqUOv}Tis(nF$krw;LqUz-2_%Fwd5e-1w;Yl3fO0A}*_gTa z*!)RLZ5-&3_=etLKAk2CzCa%ReJkys*q8nZt@~sD0KrAPX%B_}0B8RIhZ>%r;D0p* z?~1iZnhPC0Gs}6H`M3n&Wbwc?wuuwV)c*cI;F$ja@NU=adHV&}>7F_9-i4=peEpyq zqr14*b(?jT3mbqke#;AFE*qnqw;T{SuikGKcz?pWpN2IZC&XSI(eM}Or?*y# z(2Q-`MgZ;7xhhsy(8_5382zZ=8gO@`l zM0I?+5!>liBu&y4L?ay6G~?97u1g~js&XnVta5ShP;Cu`Xxl3I$J4b`p3+8fBRaQp znhjwqXj72@U=$NgiJfF%e<}^3GTT|BD1R$C&re#wxU-cDHo{nT1DaBe&e~HlU0k_F z47m2BC5A9-7OZ#EnE2-_x)&Z|9;)39dcVQXjsE}>ego?1fAH(X6aN5ZoyL78;zRa% z4_txR=D4x=7-A{9b6@ZubM817jd6JnX-6}`O4Fw9*GVq1ebZM*@8|53{{RIh@HfSV z(mXliyNfRb_}!2Xv&kmZkNsdar4+fa(;RkXLd zCN_vGu2%=tSCe+MKJCi-pOJsH$NUqQ!2bXjKeYUH@cO`b6XH#%630D(5gAAvla96d ziQtbFc=O?(i6;1O@n1~Tv|VBuR@%n)OqjI<=omLm)%|(&O7VhRKb=Phik+xdc7H#g zN3PpBZrVT3AEy5R(c+GOl~m1ebl0^??#o_ol3VZay{`FpyJzS(f_!BJ_R+yGjh#@% zyE*eK?tj>0_PW-8Vh@ZK`mm9k;CF~_65n01XKyaXXKV|F9TaoUEB$KmH-n?Z84e>X zy`4z=ulvzzQRwt?Nj|)-+Rsz`65$-h<$1L^&qSrmEA&rC>23Z;_T%vP#@a87{59dv z75H;gi&W4xJ9W9WxQX{8DH#|&`ilA!NV!X^Qv|tjj92*6s%Q2|@sI8M`x^KM_UZkX zJ}Q3A-w`z1Yq)h?GGxn-7|Z1;v=Gvq8(=ac9~eBLsl>ouYJBjK+NX&xK2i%!$w5X7UF$1YD?*H;uV zNaa9rIM z#PuevL%2!wHonbZ)=lOy7p40SF^^wb;_lJJ%xR>s&USb8!#EZwatvjuWWD(k=;Lp!Tn8BaQJ?{Z47c zJrC*6!5$~E@c#gWJUueoE!s(C69+&^Iqo7j}1+lY&MZXFmC^Lss!{f@^De=2(L^z#F}K^wHo|kz)O4mq=Yo z0dH|=Ns zgNt1}BJ9A(&qLJyRnrC3$)bM_&jpULKB0RQuJW$J1cVIs+KTzY)ia_e!XjE=fnm*s*DxAGm5A!OlK~~%D=R? z?L`N{Zw?4FOSQf6)}l?llxhh!#PPiTb@I1@^aAIZ9@GUdqZ|w;;iM0)9;-;4@_irhCWWR-@SmPw%Y++RXCwy4= zd!l$EOU-Y=(tpBE&R%)rmoZ?Tp>g!$y+}bl5#rUIozJMhW#8G4!Jo8mgLID`(D0SGm<8lU%aC`z!`lw%Ddd82h=&ubli(;2#wDX6smv`@$O9C9C;ZmmY-I)c*hl{w&@2e_Xb<()HvYRu(N zVVd$P(y{7Oszr0D;ewe7RyCD-ehg(8*E=p+>Uj5xwJ{V^IzJgX2d#W7@rT6H+1gyb z^+-TDJ@HsGSf7EPwJ*eLuNnB34+QA~Tbo8~-MDNJp8o)ic}|n1CYfsuv}byv1;}W^^ANFR6 zeHcX>_ORMjf$7?^Zre}OE|T1c)f=$ly{M&Q!KZa}dM@-W# zEOdP}ZBdLX0)x2qHS#%xpE>vWMg5MaDqmUML)?~a`-qKZe28FTXg04l{I;A}9?_D%7a;WT)N60=p{{VuOd=Stkxle~)8u3?;rD7H- z+TRhV9ZuhR`0vNx@KNvDE5?@h_P!L;G=BlJ5D+7l-XPI}~LAEj`xTIf1M7lPh0&B12mlkb}PN*Fl7a>ZD_ zaFBVF# z9x{3l(z;_n^Xk^QQ%^)%9DOks7<;1q5L5Mk?-Ocd^Xp*x6KR%Yg#u^JG6=Vyy`sW61P*cZu13xI8NuJ{7Z=hO zk=?qEyb<)QsTt+kNhi0`vU3`U=-@4$c&jM^e_U2ms%sdRQpL*<5s%?r2A$#io0;H< zTU!U%v4|VXT!H*H@>MkX+I)0oR23cG$;w#$xHSm+e`ec^3 z7in{-TmpBizEOv6J6Fu(GfU|c-ooJBuFqbE3v}|Kw6wOejc@`)yGPgSQ!HU!u;@yj zJ?rOc;u}3`bZko?NU(GJ!`s%bK^w@Z2srgUtCCLU(T$BuO*ZCh=qxSZxtdoSw<70g z_pfvCzrg)}Tb^0I)8r6f81Kz&$fu)hZlSXVAX{8+L{3p1!qYqsHO5+&ht6a(6j>p<+41 z$F!69cB*lYotXVO6*d<+VWvSE`C|>7=8+uSe7kdlnoSwDJgJG%%5$6^D*ce!%_0Kb zuxl28w=xs+V+;=ls7Ectj8iA&?^#Q7;~SHGt6>4i^atLoB&GK=4WM`Rt4vNd11d-k zTR0V-S(kuwo|&de9FZXD@}K8P$xsS{eSK@3(wSC5!AAAL&MP+Xk1f~^$E{%ZH;K-u zM=KxsH68pb2u56}9rIYpYG{hc`P}T>3Vaip91QNoI%G{7QY#1}XBh`IiE$z*a`|6# zS_&w~wPOI1c#AmC<|38PSZ(wW_7Ge`%Gx#rZl6)HH63uM49 z0~V7Gv@$RtGQ9ihd|6Y;+4QunlllN zNZhACO3pEpgE=$ zV(LR~QN;yC8toD?rWJ;GJ?YWGv3G6-RO6Z~Uou6Fj8v%uYYz2`s40z=VO8UaUZOn2GIqrREcIs&q`jB6v z&g!wY)eX=4RMpIE5!i?J?^#I{(Iko^8;NdDO0g6Q(4F8n9FJO)DJ@7P3aV9iDh@dB zMXXRVvoPF$DhU=#hJo_CLi^TA-Zj~L07xe%(t}vOgh_Q128=rHQ_d<~=plE{%iAXy ztYoz;vu_-#p_WW3=jtl#&YO0z=eM;AAW&e@5*5oYTvUcr<)_Nn6mq@B5xdEN2Hf+L zRz7rnu6GmCq|SB`m5(r#-7a1G-0#46EX(z0&G-UTCci3$U?j@~%pqLp&XupPbWGUFSP zIYo#lLK>SCVlb}93!I#HtlZh8W1%wzkg>+-^NtNdv3>ScEh6+J^H5PDTP`FHfuzS$ zYdS@ClK|yG?cSIH+Nz_SqN=QA=JP*^bB}RbMH_Pul1Y#V%Cd~))o(UcC81sH4>{~9 znOt=Da!O;3RQ%1(4+5@5HN?~PP%8GqDRF2(B_Qqty zpkYDAed;+@c;pfVcT#!BZ+ZYXJ zN|uqycv?ohj#-LV=rZ~-`}S?7w_$f^%+XcJduC02j*n1YFN20CO_ zxgBovu|zy=!0tzS+MK!*$~48fBSs;6b5vj@CowQ)jGdz=tx=>=EUOAg6DOWNl}cCg znH3i!)S6t#qA6A>CF%$JL)M?=#T0u3AZ+7~rkO4zjCK;J2wtn6^-4>Gj%dT2ccg1g z4UchG8;Md$$nDKjdA7=^jn6_ssf)R&>6>dJ7IEJ`zSKriR|~aO{*_{6cUIyj6Dts_ zlEc=R7+yjdqhwCQy#zTD!?hzoid}|xdJ57Plh~VklxZyP*AhhNd0ceG1oN{p;^uu! zPd&*kA!1qE?=e2LjKw3uy6)$XtyS*s!Aiqs+af7f@{};iE1Zu?WJ&gfR{*l)j(Ung zDO`>yBukkHVo;EJ^s7=rv!OCDMG3Es;#&`nY-jbF59h`dgdX|}hqMWmK0 zi)i~<&upJeSI3%H( zBF+29z`}wtoFAorvUm&jU(ZA9$Yl^y0Y-&lXFi7+TH;zKNViByqPYJx{k3#eGffU&T5#%fur_u##bx zg`4gl_D@>nyhq~usb;sek5{;dPlbn)yN}F3bKCLPcafP)NSOR+}3ijtYh5rJy%$r(_oWp9yqR7QPmto%;nkf`I?Iz2;=9} z7_z@O=mlV0+;4M()Yd$#=q9q#E^pFFqF>#wQhQfdrD>4cADpX6?mAJ*UGz64!vMZ! z(c9Xy9eliv+nAp9BpI&G4quh}RR`J_Z3GGgnB_uogUIVv7BUV8S_VzGc1R;Mvp5U# zx1|R0jf&oEtB@ooJ!wYr`OX@Fi{${oxT|X7B_K9)+JGaLN0c`pkEKayo?w44w&9Fm z_n-~SK=8*hz6fk*HCk~KG1>qCbHxBsCN_K(ZQn|-A{Ag%mc6 zO$1?MO2RG9L&Nf(21iQm^j`bsjM3$d~ma{UUThT4UU;9VYW8p;PF~QAbK8$;aRUHfJGml+>CVk*U_F8 z@Ex_fMRRnI=Hwl}!(CBUIqFFx*!1g2U_g+;9AFM`F`un;T4t37r+WpR#pm{XPu4@w zAO5{=qho?^x!Cxt!#3U;x?MIKxbG+O(b>S@5;MhfGe{(erWhWdT8VcsmAVz;w1wX? zXLdH^dQ^*SRatY4oN>n$2Ryee#c$>LVO5*)t&3!4+LA8z$>esRlU@sCK*X~Sd-tt1 zg-LotJxtf;n`Cv0AY;bB+*(T?NiLh~n z>z_}pV<{5kYsY5FQOIq?cdLKd@i$Gw)K?teKsGHbestNv=m9^@wr$|c1Sc);+PG$b z(pxf0M!z&;JZG(3iZ3K6jY6mxUlJ@Q4)AuT} zY{q%#n&hhN2>J`ee+_gW3+WazSX`s5sw9pvw3Socuy{Vz#KCOV&_9_TTR0d!MR_%u ztPxeBba3A=8R^)4DtvDsAG?lgh_Xvf9_r?FiV-X1@IdKbNq8T?J{<6_oBsd_kBx30 z>^q5qCR~E}JcHO*yOm)5q_5E!)I49}m&SSS8so!yM9E>{=2CXT=jP|3=Q*#A{7vE< z#SNWCeO8*jvCc zd^ooFmGLLUT8@LQ*-9=Z22~NT@8C?p=A?3~kE;#!fNKe_j6o z4L%9{HTX~A&klHR!TuD{EMU_u(%#;2YJyRu1{>ply0og5}ZK^>ON(KPhpjA&0-or9=IQY)XFnMA?S zwCOCNn@+olB(-o;YmA0ogc07q&Ex(KU;hAtQd|DTzqBlWwx_{Q4qaOQ&;CETkvvOj zX8|#28nO9{jD6IQmT)~powlgb66kYDYJW4jm6}A5N*QK~MGlUg7#{V`PZAJHj&sMo zIV}v@v6DP_48aMztC^tn}Et7(v1|GD-30TR( zmi|-~7h(32vu@r`_*I8!5_r7jGDpE69!&>DI)+U8WH&D%M)LT`&+@Kf?#63IA^v6U z?^7kA-A<{PQI1%GFniP?%91cmVs_J*yI_*$-s$|vE~6l%(J@y-JAy0pm-br!0D_8q zN%$|R>7Etw)~~8~gTSugW0W5aYo`zVeomY)*Uf0I9U@H54_{41I&l5OFt zSyYbtU*cchT|4Z5NS^{fXzvJoXwxItd=0GWnuEv}Y!JTJjN_10*VtMIiD0~mPEJ9? z^T0LvC2TJv<$I(3eZb?XVkt(w8FNBuH2bHjI_+0Ox7J~TTPYShkfb&-h8@LxEBjIY z%AOnep`c4?t7*Sy)K)Jt*5W9@XdE6HNE}sR>dKVkQk%4*?w@A1CmDvPUX-X+SB#TQ zcTYxsKuM!`&){!~f8iSORI|^gq{^0>gJcVZ^dR(MUsUOu<+i=1T-e`74b{EOMmZJ6 zdXLJ#-Jhc;iIC!s8KqKh_tcVv``s&FtNZnOKBxT8{WH8AslohRT~d$kD>o>+X|A@} zFFPje?z$hmfAB@0+lx`~z2g4HpB6RoGr-2h(K)_CfI``>c#Gm{ffBygk;cpT6Bf@|1QBQ+j7?C_<;i(qa#mQ+1-F2pu zx6F_Mmh#w+f4KQPCm)MJSo@lCKZjJ*?X?X)*H(b)9r3_Zw=m`FoPAu zs0IlKpsmuew0ArbXeCyWi%B77+*yuEsB^S!1OEW6S=46cecUXoxk=}*6`c%S7jMi> za>?C|9)+OzdP|p%R|Jf3F<(mfW5Dg@T3ubKShk#|c|VPC*E=cB$GQAD_&cijruehQ zw;Fm9>*b7O0(d0*SKl5D@YSD&^yIZmRd!VYNj#=2vsmD_3=zm831=lR~9|U+Z3rpzk;)=;t z@SAowa8G=3`B#0QXf`^#Ym(}|DzMWMIE&k?i}%=n2*rNWN|m%eOBl6i;$~esD`^rL zCwsm5^EU#deLZUlG)L6t3pDTr$sou&el_Vt@TVTd81xN3!5S9~7&&j<$iQdmoKwHB z?JnV!-Q`wZK;MB|LT5bbbUeFW@YMRBh_tIaOVj~DVHw6;5szB${5RmsiG0YTU|(tE z9lLS$t>Zq&JEn^F9u~g4OT~s&6G97RI3peT>sEX>p=(!Zdpj%u20{70vrd3-EOx;|V>n5L05T;L_ zfRF(7;C@EGm+RjRFNbHi()BBet#xZTWVN`pkl~|sZKM&`wS2}lne@0h*)+@cF-Czl zHwTLCw7Y2XLXGDf*OGb~9i%Y3qM(fJ=~m^jn*abDbnDWP9G{77rqcfavV2Kx8XJv1 zHUZuKc!kFaJW)&>-THa!_sW>v5~R!x9u_G`wtm- zw^EzKzA>A{{v3xQ+FOfdj#z>I5>yQ1=rh*8IQ&a(tZM!vv9OlQ`$I{_WMVQ4b{Ma7 z4?*tFp2Q~E^?$&h6!@p$&Bcw!g7jD{on|x7ZltM^Pg1?JU((;e@7aIiH|<^Uv%_B% zZZ$6kcyms;i}wQYo=J+1r0f`8bJY6Rxk*MbyFAF@CsLw1cGx$CX%tqMol}P zn;#dx6}GeDFBSN!;dh4g{UgHKJP5PqUT=@_J`a9BoqY9UqiY(4-He_d(k^v%-)q7 z>WYZobDo?E^J*TAIG!cron;m)f*5iRFnV!ckiWIR#mjFB_-j(VxVwtpeXg;nKQxR6 z00Od%ZgoaBKP2=UOU7BXE7uo#rQ?~M_VNMbD9@#IVk=mZLojrgZx}sIY(%5fonFIM*K|Ev-$(Hlu^YOVF3J#d(+7-yO8PtYtFQR^L~N!H3<0hzOmsT%yXbyc__s~9*8c!*j}pG0 zXwlkP$jHsVabiw0k6wRT{Ypq9x3IRgh?0tE0uY;_QPMRS`XLbQg8qwU&iIgFFR&a=>^)fXm-rID{l7v&-V;@>ej}drn zbo;GeU-4Ffqguwh*iR#oZubDHd@g>pHix${1~`)dBro(^k`J}qKT7iuAjgKS2{ zVbEvL*UMfo{{VuMc;ey-^p64jKGL*Ymqov43~`^m&$WBFY?5DTSZe7XBY3m+iTJzX z{mJ4F9ctrF-@EL#@|02Qk_~+Os9$MvyxwKE+PAlu?IW`@wtAeNYwEC=DAQI*IlCFR z8r(oPkdfQ=!i);Xn*QPA`8O8y9qZBdV5H2s=a4CRO9b2(I6Zn|wJrQ5uj&#i*=aYI zO^{C1KPvwKdlhkow=_{~^)Cs00rBsNH$2vWY0SqB0zrB0q3-&-y_^5!8Ik?_OJVu4cqQ3J2{qjs2_AH-wqt8v zHo7+9AbpIZ_`Pd}zVUO*65CI3O1tN;1pO(v*qhwvt~Kd$+Z|W|fIC(n+9PEz<{jDO zdRB6siR93$CG;_a<~h%`Qn}ZyB1Ix#;<+UwNK!c)?-%)dL1JGk4~>XEBl_4oMv5wJj_Rrwk6?V)x*okdR;nIVtQVBrAVepAx3k`dDA9uL0p zCGuO?*xb)B97@p>A3pxI^q++P0B2odla(JPX=PU-LZ6r#u5N@fb@Iv&HLy!y z)k}!XM5JtXlgGV5tP1{1jERd6$E87e1Z!`Q?D8Le)r^aY$xEl)Y%LoQ`?3fXR^n%# z23J-L4mllaB($-tSy7h=QI6R<Hb!Y*BoA2{jK zt{!G)gSO==pt;Tl2TFaLG!hRnOQ&!Cy=nw=Ow!#lEKZ}YdwnZX+Gm7_$vFKeF_z-V zaMuzD(mlB9M|!{t;VcmuT|no!z_P?+Q!vr%m;AX&rX`A{??!xE_|eqOnxwTLk;Ps%tX z)_jGy8uD8~Cfp9AwL|t~K=H6$r=g?Skk>+o*ucqD*hi;&zZ6LD5ZNcEJ*pWIjfPrS zq)5tSCM=%4t66Q5D8nKg9w{0{Tu(9bVn9xLtsfvXCoDFf&Vc1)5(yCr2Ph3>xf46E zJvz`1CoQgPf7uZZO$-BGzBn9?>{c_Cy~kRPXdds}8F zb_H7*7#(S{`E@El?p%zp8U1SGLb8HnVy?X@6lak<)1*qu>Zj)7wWNX6E1}p&Cz=y6 zkw)b_TdcDZv^3be0iZ%7@4*rLtI#H&D%a zN{~P!xRG5H%0>i&lMXWiB14u-MuNfGSqHDqi9|S6=g!r9vS+6wIy;D@MD)OcQ3bU znoD@*+bX+n9E?y^hse(Gv~p#M821#|Z50s|zFXh51kNI?Qbrh%SQ17t(uj6S>Y-VH z_MpziygUpT1!%iwsr;=e7*f4PII87lisL44Ey4r?=xMRZ3$6}B1Iejq(J~njs{*cF z2VN>^c9e-re4zF?xecvce;Y@=YGtwNr*9JJ75T>jugk%l~R z)YP%a>YE$`$ERAeA{f&Q<}~?_Q;vd_nq~PKGE@$@;Lrs)bjrU!a~6BrwIu=k)WF`S{>kDEWG zUQ4)9Rv(z;=ciAt08y6=?9q}JrZLu|$z%)PJkV_)Am1EeRn8oqIjELqS8@r@@}PDh zd(0Ito(_6;sQln#f0KAEl;e;o-=OS8Cm3cqr-*lgK{)zS11XY3o68IGoc8B6D#Td} zE_2fz4Q&m8ni6J2i#T=bo^w?%0|?b5jdBS&1DsV@Vp}3Dx)J6pw@}@xs>K|BX^l>D zN&3}BBXa0IKps48A#bk{2xF9ZyfCJnx;Pk;;|?4!qWp zjf@ChG$4G(Zti{RgF&)Z5jXDh_l+j)xE3JGy?J$mQUif8Ykvy$KjdwBR}Byv4Dpd-GA%D)$WJJ|Rt$5De%n%?(S^0!0_ z{E;_c*yNi0ukqi+pA`7JQMkI+^(DED$UaPN-e3Llc;c~?j;d(#yQ{e*1QYU(K9!Wt zLFxI|4MVCs4KiY&bI?{}7!EPTF5}lU0b&Mml~!(RO=N$ScOENfF`W*TbYpN>k;orf z`}6iZ{kA+!`!)EI$3yXy*Sgoj%bSm$C|3gCdBJksK^457l0D^%2%)TG^ zzu>($_OSQ`E9y6&Vvp^xTeklIIy3xZ9l-uo`OWYro6=8GkKNoA3*J%a*nW$-QvqX|@w>!LsBb7gmd1U&U%b5=OX3h`2ZONhL zRHjcprvs;;jy?FM5Cu6v_ za^9VVBKaCPJxb!?3AlCz0OStU$Iq%t;nDGo@kz-S762N>&IRU~HE_LIp|oTv4w6Y3Jo zjcFMNg5M~~6~k7oi>7MnUKEL*JKOT}NEa%d7oSmG#kxUf^2RndTJtMbIv{A=>bs+j z0~r`~K9!vJa!lc|h3#B2oy`!%lg<6p96xVr-qW->wL6&YV^Mpvc?F-re}~$>tD`{473YX9ArR^I%j#xs3HIuH zX1}pN**pFSq5Ca-3h`Bk#!rd51-HgOj)pkid;LXsSz62&tS}x9I~LDO;2O%T`AWggfaP;u7yCzk&z}sxYcGMn5k3NZUhw^wh`bZx9X?$? z@(GYPl*N8YP>^=IHrG}hf&l~&4Q&=>GyH~sZjacj;$Qp|*Y>dZiTfpdQHJg8Z038< z32O2}Vux7MNhT(UoQBHeU=xC@xyqXO#_}tOlXQs4-F6Ymn%+_{n(AUpEQ+W4aIp1lwKy1)o=ZOUC-}7qMwZN zg=p~JWl^}z{_Vbx`ES}<*>}-ye#-bG#t>?7T1uC3lyx8!V8Mty^siYhVX0e>v?5Ld zmBH;_n<-yY{Rg*W;=kHI_I%PlBlu?fPPj{WB~WI!n8T8?4o4tYvN9E0kw>m)^JO{y2ConA#O^Py9>pPxL=Q{6BJ+cIvKjaqC`L@x$QHubmO&(Jq-Utgvo9W^zk%bi`?3B#zqM!V$Ko&8pZ2i$_4_Ay zstd*bz||$V(B+vwFtp%qnd=aY`rBgeP^ ze)qLYKtA3bnI#G5^QKJ)n&5zQL6c0@v$2-}RX1_K>6-O#5BNTDY}%%vg4V_`8J13` zJplEsV;-c~!tr;+9a8@Qc7>-bdVYx-7|2DznEI1mU2@M90puyyoPS!o8$`{LeaZlC z{*=Xt3=n?ttR#+3DgOky%`jB&@UcVD^SRFRjc{kbJ9@~KnK0OWo(%T1}? zEZ#wwvM&O(iN!jGBw#;?S5aJxgoq$~^cm@0?S{E=r(HW4+hH9uT?rDM#FNBEY1Ba5 zC3e67b^6zL;C~z4=vugfT>{fmM{g~><^9nojFX<}XuQt(A-Yc0)sg6k`$!vR66Ubk@v9*@wbqr(#_32XR+J>3o@3u!amu+}m z3P$od1~N}kj`hzqb82qP?7SWE7S}@Y1)cqnwvzf2%q79x7!X1Ff@|>){t8dBa24%F^qw$gI#VtC#OVo4uDYw3T5zq7x9^?0=3 z82Fpw2aN9gL28BMNa4h6dME@OboKSGa|-o1F*dcCq2kXA3w=`WOSP6;i#5SnO5nKn z9=unB-}qNw&~=vaFoJDk!%#A`w$Q?S&c8Q5t}EN1kDbK6$I+h?b)ScNe}w!iu6RSl zLr>IiWQsV_RV?wA9H|)k*XY;m{e5%b-`VzU9`oV{j&4=tYlCA3r94*PwL8RZ^X>SCK&RNOblhl)(=DsNLkNgxLNbncMO*_GHL#b;Q ze`rg27{Gk6TcJ7Y)}p+$Gp9;T=zD&l@lRgYpuVwN$*gQHw!DzWa3mdYe>%sq@e%O4 zKB)zj{r$u%x;U+**&}n&PvKubR*Ka1Xho-?`YrJf;@7~Ri=PNQDxMyf;+KQGQ*UmP z&0}|SG?848xISXDl;HOm`gR`<{>(SpcZ5DH_=eK%{bc^you#+hc?EOZ*P8QcQb_s? zEZ)cLCY9n-acv8$kU+ublUH>OPDVoQH^`$sde@yJ*oMc<{{R;}XqrBceR2u}iZbPk zVAu1#@z2KEr^SzmmkeIkUkX}CN?>+3-Z^SB_S^mljqu0CnxBn+ zC;ri%AGUj|D2iz|Qx?L)K>7Ci=CGRNAa!1Lf=C%P>vP=kq>h`!kZ4+s z_07(iV|Ah^K)yoiOuDd({2}&~+QVV#sOxm?Wz!ChQhaa(Vg#UVbi0*E_IV zpO*gs3}k(G_NMr=;y85sn@bU^mK}6L_mZ@b#3rDD&K?#yev*@$sQ4J0rF`YJAV* zU)yu`S@>cmO>5#Tej~mL+al8km!n z2wdW$+5B9|_}50|gftCqr0Y~0bl9Qd1FzqixuwCNUCC+2lH z3M=Vf2>!=E5WGP>y~K_z>|6azhlJr4qeP$s9NZ3}3*N*)u#a!P-xv~EM3D z8=zLm+IYq~SCuDo(Tpr4aJ-mpr1RRepwlm}7^StdOCVslBLhELhV8i9vFd&u_&=>{ zQ~jQGxwT0Ybm+f`=Dwcrf55E=OpZs@?qt8ZL;+NiR!`|sI_EU%SoeJg!}c0os7pIo ztxoLbGy^`~xUQfovK3?bcCH$gPASyrUAJYAXgp@0I4ADD4Rbn&F=jZtxW-8*`BOFn zmv#$Twq)Wy81tNgw>dthrJgYxC{RH-Ja?o)UQD!rWPG?hb*s#Yuoq#TxHJKmJO1@R zT&JKNYfCY#C*<$I^c29&l2;6HrDD$+^!2NEGT~UD%7MVF=dp1`Xv_WbqX*KZXI-oc zlHbf$MRFC?My>>CL}Rz5Sdv9p_Qtyu^~laBxjcg-EdUa3`973OeBU5N8Dq%4zXpRy%b_IAxCRPI9YCzf8Kz7yG4gozsFW@~Vz?6`s3YY) z@zSWhsFAo$-1>E_+Obh&66uIkoHCK#sH74g>KKkG8b(NbmhPyo2h2K(r*jndQZJb1 zFfoEXs2Y~GA2^h%uI4Gw3Zk~Va)C0w^b;v`A&x2Fls}i|N4tUCRoMra$`mrNJ-@94 z8ybDP!@Xq;N#s_9kp03mRkT%9iJf~#OAl1}lk;?2{=clzxhM+n-pR>4)lMSCrbdrgftY)(< zNQoNa+EANVMtRAp;+5`ak={_;U~xfeL313T0>_P@^PftQW)Q?J(RXwCQs(Gg$0Tz> znTwobr>zm(t?Hpi+Jy0+T4FR}wsjH%gZR`l?Um6Kl^yX}%>bL!?t~Wzc@-?faf%f+vrE#ksYH>rsYs#{qCuo&{)GK^2oazzYIN#&e1bMQ4EA+{u{81Ay79(Fe4I ztbp;r&1WU3U#R190s^CH_NhG5;1(nwN}f<2BDe}xGqZQ-DX~ABaAG@^myUbXjY`C~ z8HZ@v&A5TbYO&;D1b}ZI)EX&Vv26gkE*BsGay@Dlg_cGrHm|3xS1Tx(r`{(jK+jIK z5}f71CAu1rE=J1gz>UCjnt~-JVj~P2+od$@7A!PQ``0}<QI-*81$%?HbySXlpcnFD$G-GnNf>p7|%*}_^>2y4AuXK2Mt&^%YZVEX^2Gw>%!khbtJiMSPMNO0UngvIgvCn**tdyu@IquQip- zr6KCksT`GVxXn9J4dIbNQO)ox_C8Bp`G>DzPN>u30@!goxXrsIk|BQUXyx5+P-Af<<3h4+lN!<0}DeE|2jX zS8=A?Sl-z+rRF4!hSG%owX&CBKS+OJPulBT{hD=$@K22{E__k&Usom;w43G@EJp=% zp1H<4S2z1!{4vseJ>whSiysW_-p{}qsPl0G@ozcjk~kTyV=GBX7|VSQC*dE)4Jrxk zH2(k-+?#(hWM$ld9C4N%tLfcb*;vkG)91F-Z5afJ(Y8hpO#9bgv^b>;950DAiM2}= zidZC$+9Qm(z?13iT&|VliS&YPV?~0=hlId8&9?T@D?fS=~U&kXr%}oKYl0ye6J~$cY>s5t4MNBITQ@gwM{K-uO95m z*L-39(@g%$7K83VSa@*!7^gW8*|( zPgDG;eXQU{r+3nlX7G*9=fd6#)qF>&TUgjw+}zD3epFuGr1ll`#*h0lTwA!CUcC@` zWE74D5)v`a?|RlPEzbHlCoPWG!(X#kg*;EL*=QG9jqRSJbujYT4oe<@70r470PRux z9(b$vWbuubjd!b9Yx)({uiJds;)%Fls3Tu2bW(FXJmE|X{{2FI#rJ>M5q;ca7g2*%_h1WGN{?1Xvn-iFnSZ(rfAgU z?<9)A%xdttTy7^lDXj|^5e339KR2ZSXvb<)AXC8NuA~f{g4oY~)f09T@-IaO>~MPH z(>1ScY19mmKb>cAl&o&s**8+0ALm=PmK&5XcTRc8q(?ce1Pdgn7@QA5+P34mqBy(HCDrL9dY#I6*u;A0f^`;2}_}>R?yqCv>s7&8Qe$l4wWghR8m$F%z3~c zdb#DX6N#&9rvCuTMgTX~v>GU&jmt^3ut><@3gN0|a!GA{uH8ry5gm}m*Ty#tb*`Sn zLxR#mHVwbt1Fd-&hpmmF9*14!La-qNqK@^8a+~EcmLXJQ73I{Cyj77vFbv6nbNS}9 zq1eF3v~I^4r%D~lIxh=&J5=!wsT>yeuOxeS7UzRsLnfc4d?C}Ny}vfMcds7*047hH zYaaFX8D0h}-(*Th!v6piej-h*YBv}9gy7Bz*t@b3bHE;z@&<@6{=r}HZr-)xYwr#GWc|9ekF!8sF5&Pkf!mcCDz|be`FmwXPr96nsLsvTi*Dx;CRc$N&%k! z?E@BnRa3%`VOlvO8ESjFji3wxjyR>Ml&(|)ii1F^k}r`W%8JKv!vXy3N_~lv=zaiy z!NNcAN@zdeqaU)I{ww%tq-o>!nD7{rSn$=(-Lh&hDBU%YfA+$Hx#M!EB|#>?%js7B zZ|!X(UD9r}UleJRwVtPGa4{qks}*3t@;MdJ9aW61wmFNNWlu3cIrr#m5$y{x3XCf= z8Ain=Tup*7%i9%wBvJv8!`Ti;vcTD=hLykgjk$RLg%W{D6=_ z5;tF zki-W2pb2A=eTFIUwtZ7A%&23jJ34Ys{*3(-j5vCZZ7qSr>6OVs|ld=;;1jp98@!s~Pv$&%odKC=Y@3C?oqMzwnNDx>%RyYiSSeoxtM?{&MH9&V#jo z7n+^4O*2UtLlGf^FGHSq{OeojZw-oHxI3dGE(Zj3scoZDz@BkPq9R?TV1#WPXBD}p z>5|<_k&JF5AY!zq8<8%^_AM8~`X`62msHp8QPL$6><5=)(R13kKN5KNRPiQl738$A zjO|2K1LYOb7!}+3Nk*n_(}F%L&EVtlwk5@F@@+dGoR&N%Vw<;s16DAug)_D{j{H%x}S4# zV{L*+_W7L-D*c>!+#e$~>=#_F(nh`=asZ))Il>q+#V82D>aUEvn#Lwvkr-}zUofLE;qy0mgsm5=D-;PsT= zE%ViulBh6RLd-bORK6}x%hyGJbxY3mXmHgYg4_UbKJBz%4^cXNr`kM72Bf_f_kMV7XjQlZk zCYPwlw;N>HCz3cT^~tV9qtvdJ-Z-?PB;=RR-}=?_BbCs;ggA{{RU+ zaY|UF9nPv47SE2neg6OjGX14IX?z#^XF~XM;o$j-%EAFGkuP=gYlFZ2zPwL$rb%J0 zc+ty)ITT56s#r8Eq@PwQ4>{xvCm&G zaax~A-hSI3vSsIu?kw~l8R**YgdnzAB)!uwR%U57{oD+X#2)p~cw^!h!yk<4Aoz9T zZ9e(ku@$6@66cFu&g;HRW3D;%uad>ZsWaWBEe?VRwq@KBIvUkM6QZ#UsJsp< zjH#BQRgmpga0g#{=)M~2R^AWzt)g69g^Jr%U$V<1ebr^L+9~Qx#Rx;82%3G-w-@wp?Isp zkbh@raCv`d(}5#lTxFAv=R8;HcZRR6Q{n#rhkQ4pct^xP+Y?&-n(l9~$+3YP9!5VJ z>s3!Oq%W!Q2Z_ID&)SE^zACx0&^`oS+GyrhhTl-Wm0^l}6Z0JM0mX3sKmP!NaePtn zCcEL?f5*N7@V1k!{iZ)IOG(l9x{d)L3}@cCD%ZNQH-!fs8P96}01EYQ0ctloPl)Xn z(&h;aYPruNxHZ4v&xD%C#P1MkJ{-|?JAEc;W##5V5wXtQ-HF9{RcbTPrB9*g{{R`Z zE8l>24W;;&=ScG|ZCpglC~b;9@%BICUnG9Y)*6Sze~oZ>qfflDhr*hCGMGyYA26Jj z+d;#;SSAj0f_m<)tNmsE%(;+bY0Yr6(2BA7L;H06Yt(!< zq+9qu!^t$-j;MTs6PAn|<&Urf^{>wV01o(aEh@?wwlFR8xo%jo>P<9?bLe!p@xkTC z5@A$(b*^UO)#V_u{n_G?oVL*8^`}ckVAxaAyq8_^7=S^iS-~atvwu8xcF`gdcROv( zZ$dX_EdJfU;GI7XG@sdv_Av1O0E8ve&*bU&?nwdadc`dgTu z+s~{_`dfo)51>Tv)j2WOU&w zyPppJ#@Zy_Bi6iqtxX))5>2m8^3N)S4oj1`vEvvu_wU4y6#OjsZDTf}<9~{N3hcgvv2lFt{W}2Hv5G&L@AxSn?a})m>s~$3o5DX8G~XEB=@KxygG_aq zdSg4+E1dh9{I&5H{1rDw(=>bCAK}Ns$vj6pMnX@hNwH!*n;lJf*qpIdw=wF{m9{=e z@lWml0Q*>Yx;fyr@nx5Tbh!YG+FC-mQS9ACe6_6V{weW&%(q@I@sEi7M9n9fW1i)T z2KE{0TVe9}Q&x&K=CdJcu>Q^$u0^3g0Nc%#nvuz%y(!E2& zzW_X0s9Z2@FvD&fE*%Np4{=+^W1^iW)cRw>f3daxvvihvj54K@E=1BuQ4g@k74uCK9$%~Y-^oyyERq#mg#Zq5TufgPA-I*4P8Ih50IMejaa}&i z9#u-FF0JFsm>^5I?i|3tn8KgEjQApV8Y7#Po_DTz;$mV6 zHuVPw1GRCtUM{=dc3jAc%eT~4GpKD&naoe(o0WIpAPMR_n!{~zhCW8pYHpM4Hah>gn6cU%ScAKr5@#JRzv+k}Nj%&vBfc$TA0| zao5DCtG0I0!`$~z4SWXHFYV#D)MSfGP*fF=eB_?sdRMaPKLvavqd_D$QOT~~mdKUP z)K73L<#D;C^oj3busU6ymtkXLrQ4)7R?yi>iMMhn4f*w{BblMxfj0&}d%b++O3$h4 z(xReV+mcS&K%g*R;x)?U-0q4st*nj9h$B1Y$8Jcjm&4u+*EQSEu*GGlM8xGxk$kQ* z*w$`nrjMX}Ir}+Ds9h7Q$#Vc~0E+uU74{YMCWG+L!@4OE8*wWp2nBd-S2aqfJxLwS zww-HbcGnO>w(8lyPK)d+c{3j>r}M5!)I9oD zO9=_~pn(?K5;UW8XRozIA>Sl>vK#})tpHkBB76tVj}Hr#twzR$Usk=_|{xhmuGG|@jhw&a7F&7z~Y_Mguzn8h(eMB}Gg#%S0s8Fsfh zIl$tx+5(_656Ykisu^4Sqj!5ZL?v_>Z_KnM)ev|<^z_UV9Si>px?kXR% zNMryO!0bIL;Ou22Z^da7#0KCw`Kq%-44YAaRXpalPQ)62X@o{&7%X_sDzp(iEL{r} z9eC?Sz|>WaWPG75kG+mop^g@T)F0k-=N)MlqFuTvIu$_5K*v4nD%v^i_eD6qeB$&N^)Wr>S^HBQbvv&l9=2lJ`rV3{xp9J`AEwC^!mWDG}_>5jCVdz4CK zZ0(E+oo662I*>=G>sd-BkY-)2(r z<95d%!$6Ue@GEMKGQ7oh;4f<1g4r@2GT*!TnBs$SvfYN3QiK;%gO0|uE@Vs8feT=% z+(l&cU{akL2+qja)2}sR9kOgp{KKcUE@lR#w+N7!c;B4ldsa=Pesi?SNO0L6^nlWu zWn~CdlbmNA>4+zV7&D9>z)%J2Wq6dxj(%Z^S8SNZ?6p@ptO?pVwj2@9@~1%pEKbaR zYLb+QOav%&1Rv6*vxu=~+RDKCb)+&|*h(WXc2m@Q)f-C zezmbtBy#vAn;S-cwO%<=Mf=6M?0QgNH*#-15z;>_uhwo4)Osp-g z5>QL+&nE`0$s4Ne&S)XV#R(E*jF76wIOVt%1j!6reAnH)@w8QPjwqe1OGI+5v~!Ed(#z_f~YDb>fWGG79)}jOtH_olhk_EXVY3Q znkSP0?omK$EO9*NEJ~F>m0EZ<fT0GUBweQ&#fofupupZ` z2aW|+j^*H&2wmdI>M9)0nkUWca1<*AJn_NlSKyb-MRJU)Il(;*e@dT^mB^9YF7gzd z?e(iI2bMxeyIc-){6AU*(FwI1i^(ACfq~ky?|i7#2#y;#>%pX9V zKjPQMZ4=?mmA;>;$rZM*I=t5SIWEJ1Hx7e}nK8xK{HXY?@x#SG5;d47@df3j=h@>a z0FBrPv)7K5^Sq6>5r%gh;IYX(`qmS6*zBhggq_AS%~v2UTbkvZx*ai%h#5)Xlh&eP zgN)WgBPvPAG{U5Hpa%5pX#8jbM8_PQ)s(>liU4`w@y%Sco#UBU4wUW<9>wAPWhB!M zl_no^?^#bQpG^KAm3@WqpW@8#;azj#FN-bh^?wfC12j|J9Fc|T^~tScE0{_r%Dy1* zb9igSGs7H0Jv+<|5N6z0Jm6-%m%{%55bmRc`#yVxF{TPI>V3Zo>5I9Hms7fz#5Wh# zs^z!l~Cjr41FeA%8g89X1m^`>PhSmkvcVPws;OkDu#4RiLIzmYw{I~ihS z+85rUp^?ODcaj!n!B9?5HP3ymipZ*2nDqj(1g=`N(IzAgqPl2ek~9Qv>4VasMk9OV z?#3uJjrx_ES76yZ_8zrGiwtr`duOEuBsGGs|a)9pN~t4Ob*DJ!vIw*dFa7!~;k`(|i=5Kn~s zb@5NfX7lWK7l~(VBvm*ks9$P{)KSrqR-shOjOxRvg&n&6&Ww_%FNzPXS|Bw6FQ#b+sWIuVNU zU=8hoSr-zs5Qsis=UI%Zh*^Lml53-}(hR{|GL57Xxa(CFabLOX8drve;kLDmG+to{ zpmk=ic<`@)ZEP-*OO!$7z6o=jAEkFvfyZ98m5*YyOBmnxa76*nL>M21X&DkVW{q1U z zu`)V)cz)R%xtQ7`_8H*wVaR^_#{&GRuEbB=2X$PSv; z*uDaV>@axZuf=JC$*>$8^saMQ&$+mkA&@AKpQTwETC7EY!Nzl0Np z@7}A~=yw+vEhWs7`DYjz;}ykPVu9NTAhashu>cnX7_5mWSi=&V8Xm>d+Q{RGkWhM69V@c#ftww5clyVRJKlgobIoh#u_jh`4Ky1kmp%|kw0cJrO1 zjw|nQ^kW?&M7ty6jaOXM^$W?&X?b&Tw?0@0Y01FJ?ah7H`z3q;I*zcuA^4x78%ty% zpe{2U-90*2r%IAYUdy@nKg6$!9tQY7YZrpP8w+Xf=eP3iOnkDI=&GG_^!2Z$KVeV! zB-ia-`)Fzq{73QK_20pNgECA?U0%lK>hVDtHt?Ke5J=s?J8BeH z3wJjPDnKc!ilvH-6V`%UM^Ql3Y!py1qts%mJCP(r0)o)645V~D#ebd`{2dAZ00gGE z{hmH5Kl~I+;9h}neiV3~>0tPQrrF!B%_{tiCEA7LEQFGBIDGPazz0=5>|*1s&*ZM+ z)h^?L@*T}>DhVTR@2TiTWIO^skm4bZDv^ErT zR|eG?-R2@RRcX%o8^3IG+@LEvpGMYR6i@k_~P0YdPoBXqZefo%U{=SwF}#XQRLWfK3WdAtot2a?@yRX1k5nm!R~7rM#rN{q3V|YEYr37abu~+ z0hz`OdvT62kb56`{Q~`n{{U@o9RAK){2mnXUaxcFFNK$~h_fMPlTRLi`e0XspJj2x z;oN$ySM}z8;owh+l{j;VDPm^du%Ee6cZ+-V)-KXrbhYf+{Z9NT_^F|I`@^~yi99>2 zE&YwshmEuIY&phx04O zmAJ5>x9>mv2}`F=r}_#0&VLs)Ka8IY{0Z@2!}pQg+G{#|6TZ{_u2O?~eh2wi z+ZHzl=T88h)&76u@HH^FiQ%g&N)5&Or)T(|JsDkHADsUH@Kb-;e@*?bzhO_>Kj0np zv{!nLp`l#dX@W%u%eqD16Z8GqQX}{p{{SLA14-0u>~$>zU5;yAb4k9NO1p+pwd0Z_ zw1x+eZ~@0`)^OEWw8ooaBqu+mSXfwY!k;i=R1aelNfAUDW1MklHH^sGJTv5z?p?+ng!R ze=4^t5>~ko$ch5|`1!L~-)9dhjAx4EsQMbg7NFCnk?@Iup7q*jx&)V#tVmR{V6YsK zP*LtWCx#)mNM?1!zWn3qU7?C3LkxU-`ic{=5|?7#yiOwp6w4qTJ!`Ad;%S>MN|hX* z*{99WAtUNPggT2s;mP!g9xeWHljQ@0li#m7uU~>klPsmOzP0)GYo%#i-VE#XmXpdN zL7e(_t(c@mETnwGyczCw#dJ69UjcS!1an$wrP#5`DC3%gro_?t3Rti^y{e7GtO#HZ z%=*>S+=-OlL}Fhg4_`{5aU^ochi}WAeQRa8kRbUaDOTgmROXL%%;PMOC%@m?wM=k}`jar-Cu6IJ-T zR}leAXuyt&#NjY(2Ixu5Wb< zv}KgB!OlncS3c9hYcd&MGJ}9SisSa|^%PaCYA=g4+mve~BW_W*X2a5`OQv{BP;ojN z2b}z_s&Gfvt{A3>sYWu~-|+am(Jo}V@b0gDrQET~G!8(=raD*Ae+~XH{7CR_v1P7l zo-e%8d_xS2G&+n^5hOAx1Vp~6t9t@M?hr%0cT`S^-mkBzCpArRI)lr<|)PbLR{7uk2yOViu zc!JAWw3EoZwU8B(83zOvJmS1;Wh1hUO)PYZvF`HaAwf9$R=if8RuCw4>CJeOjkG&c zxp^(NsLCqve;UWvwDvYo-a@iH-K>i|0Y^KO=A>!Z`xD_ej@QLnMWaJHODZ7@Gmb}4 zebp;(KwY>CLQJGRR+b!Ed}eGM`%IoDE?&*K^A? zTMPYlWYv6EsV(EF{{UZgARC+5lh+mG9xDB%d>inZ^3%g!8Pv4>e^Ud_{>~C9c9W-3 z$o8&Uw9)C%lRkR5@CS~5Jb3mG6L``+PSVM@y}q9v!$^?>*z$V{`@i8wf;1liX>e(} zZk=st>Y-Su$KhT@c%I!i(Dzs`BW4H`s|v*N-;eY^33yjs)-`F_E#bA0f}^A3kK}8K zK{0I#us;F*83G(WTt#hE@T_~T91 zBlvfqKbdBWZ}QyAhai^xGhUVsms6h+K3LrTqiyfL$!JB7+LpsxELc<18_3Oh7sPLf zz8&z6w*+4iJ|*}=LRkb=^Ng_?N8wKC-=;rE6_2O@%ifmT^sP$D*@feJkd1YAL%PYl2N#H+vs1U3@*#yfl(p+iB273B%=b zTaM0cvtphxt8)N zMUZ=ap?0$IpRZc_W5Zvvew700_ZPO2>`4rPcI8z4J$b2&E_OvEdxn$n1HyVvqPm5a zpCsqYQ8xa8y@2V~y=82mi%N$_wy?DFpe6FL4cPQ2(zk^-u;pGWLl#X@^u{nW=>@)W z5Oh;q#-ZZfA}feZ#l*A3&iG{{RpqmorPHG}fqC{LFG# zcc_&?M{}2##n;hW8+DwO4WFB;{x!$y9wBzze8+tA*R68SXG~&qa_e$93JC+;R(;;D zAqW(=PELB)B}p2T8u8jQAKu42)N8qv{KXoulh6mnZ#0?YeQLtkyYAdcHG!;S)VUUt z>z2kaGtYXL?8>>x86CUVG^NziF}{esW#P?RSdc@eK`qN*x7;KO^4e$3f9Fv21k9 z2sHB$z+@bpde_Nf@v@uL`Ya|A+nVxD9m}@jbDhNGwMMM0NdUEZGM7`=gcXXHio~f3 z*v={9FE9l`w*w@a!LnL5^vy2n`baHopt!r4*a5aSE6=L|fnMq1zuD`>n$z61>exbr zDOL=5LDYSDtSU~#%C9N(SB5?Z=vo!5@oF~7b*SzEHvQ0;=by^Gy2DA+w7V;7I~_9C z$i}$bgXVv7O>xwyVJt?a$iRbZG(?|VRVigM%2*GW8t0WmIaF+XvNMbmw2Gl5*a29L z!1d2s#lEb#W)@}L8_?^n+zKm=;o;#PTaf!U*DJU_8XmPJ8`pQ!%rwb6&{N#37G6us-k5 zR-|%ACfJv0I3IzaWK*-N{_6uAW7e%(%Mlo28Ha3lr(;;g#dgC=%A_1rfJV7eaq2xN zXrPi0wM`oh*c=b7SuXbM$l#vD`cdiyH)S%F&hGT$*AZcm5g0f$iIN`jI)KYD-om9@ zXJt}f=IiyKYq4F2n8ixqgWjZY4&Ynn9kE%;NMUZ}7y*K()Ksr1JC&GjH5Mr`s_PaQ zjo9LlG*XO?y+tb;qd8@h&y~{%tJKyF;c;+e-Gn^_12gWfqm2S?{pNoat+5M3<{$W zX;`)iImS&RpoZyQHeN#~QSDET-Q)sIryjnQ9EP!DJgCvYkdut|spO0l%z4S}RT$W! zpdMUK>443_s@_KZ%7s!+gPyd<5+egNL^C$=#~lq-TX6yq00Y0Z1FDfw9U{3=G`SeVGj zBXtkR{6#?{$(2Syf^t2m5d&@)OdaD2qa&XF^0M+)Y_gWK$y& z(*QpaR1erO!G-Lp8!^6m@^-}gWJ-Z8BR5VC^o5(I`A-f z#Z?haK76=J$&v$JW25TCw>tUQ4OwP%Vn1j&eq7!`*prx@i-0jGvqDeP{xdnx(rkgCl3S z^sZ-F*I=+kmgS5VyqxXNLCL6;tQ?m`$uZZbq!-o;Us9)nSy{w>?)CyIKa(eDO~7`dy%tz zz_(hgCkKuVdmo2&_-%7`j7`uOUU^fR36xXZ_X#XCj~;kO&$yaJ@ey(W zC*{hFkIxnJ9qZg%&LFv2?C#=_sa?cjg=rd(W0pwt{S(CU3mCUaB=RN{?*1>WX6qO7 zPja(k_e5ZTI5odJFqBS4{`y-@tfydZoPFxUmrw|xjAYcdXUbu`_ZNkiYc_ocYTnT_ zm?M^HF5@yYCIHSh`_eaxvDHNsYNTT-1_pZytTVXbThf4NhI}p?2kDw(qq)FrDfXa_ zLUC=ePFOSZRm>$=9j9kgiVYGVxp1xoYtMR!0NE!Zg4I6d8C;fS0H5Vd#t7#kg3_^i zF~e;GKJ{sSUzJbFXcL%(gvw)zYJ#M42%yce(r-MVJA2e`I{>TBPwHqbPq~~C(3llO=lxo6fu%^@%5{MG>?(`^Zx(@*7%F?>q%dT7M>~9>@>YsQ1atd=ujsFZuhU> z&)8$*=j`|JYxcbOVdDP)i(0>iue=bln?ohci0f$2_a-VwVn@=okHn73a(C4Jo`2x4 z{{R#|1z&%`Hoh=xx`&CpGq36Qwid79gJ*h#-Cmhcz+u{QMlwhr!VY+^^E~~rzB~Az z<5m6l!`Y|)$ncGf>2fULV9PVc04<+$UPR=bPFJmsAueXpKQuMCmfG%Iw*LT_mE#x{ z&9vO@2mb)AT`}C`sELx{WBb|N+ZF114~#5fvA4HdC?LL7X#D>G?_^_<_}11kNaAkn ze#<*Le)TsKk>8xxF{#Pt&m^8s!JK2#vT!zv(8H1q_`o%mwv#lWcAv_UjmB0SlW^s8G(fJXO#24XYvpHHoH z31bj*8^5vkKK0)SSn_cb8zc)Him?(`IQ(mF&~8A5PDfmf8nc6x-AKq%@s&^pGm6lV zypC4giCh7=u0JtYNp9|wV@5T1r&a@jGf4nxzfR609~XN#z-Qx;;|tE;BNHvtmN!T zyJcous6B8nE2NIi#y&=2--^OguovO8VJu-0h$j`kmWhQ5yyqALrDEN{=(PPSaYoxF z;&`s!Jq)~Sxks3O_7{rIaq0x`r$-878%p&!tP7d^$6Gr`PdJ0dGBH@oU?H>c=|(eL z%F|sA0LBy#VOu6YBXY{4f&8n>#Y)9R7_;2riQTz+^!+QGx|yb9i2|_cpGxv7O6=>V zic2bQ3eGlkEm@aWO&h9$#ANN-yq{{{4NC6J(H@`h_u-DS<9lmeM*B^g9X;gSvB)sM z5AP4wzLdMuw7&=FFpUy4hGxphRN(MA{44CRw7GUf&aXq_FO8oVpz!RMJ{+;TlILGw zNdVwRIp;s;rF@s5_;9RbokU*P3Bz1oj$?)Y>mIxF!f*n>^s-) zwY9aioDkYs+rw*X8ibB0&?+L1zzzVe3f1qS=+mZ6MS1d-&X}v{6jU2>prV5Spp1eI z03hRx@+oKlqJRo0CTl`Bj4=#2anRS2e0BII@aOiD_(S9Gfg3CM_TA^;#an(J#xDwY_2^)toar> zGrK?GShZmp&1eu3uEX)`RwG~BkZ>Cqq-5-wQ{)5}VlnMdT%Fj$;2d-m8b(7G&WU;- z@ux&dAihZJK+9_bPmF!c<2dP8H2X)I;u~m@q>@J1gCBVR0EJg81K2ICyf5(kPk$14 zwnaDbac^h1VrT9Re8b~k9bb6MRhsr+GS0v;7WTmL8q#R#rjIdz8O!1Yj zc6L(|DC7)EvmqVFQC^4PpAlSH6}8k>JBv@d^AElC6*7(VI^iy->nHpZ)Aq^L{to!Z zOZaQz-9lYU!5Wpu%PCxw_I6>7g^xkc0>7#c0r;NI@;hg=yf=1|#Ii;}I2jy@{L_hY z=+djr9WH;bA4X0#{@LMbRO(Bbt{?Yu*6z#Td$(>~75C+5JNrj`EYkied@1oJg*}?y zUF>^^i$}Z2kPL!9D*RLUQF;BGE_@$$r&%;l>E^aV}L>RAEke7{RDWG)5qfS zm$ag!o%=gl-gmkDfBQ@L8Wr-K9(@Jx({7t~=>6#Hyin3q!nN^O0W_-W9)sM*@hID&Kr-gIas$m*^N^ZDk#$&>yH_xm#4e#;;5 zRL|OT;rnTmX?_{;6~p+;Mj&mDSm$lhY#o4+q)tEQnXk<$M^oEUKR7W%O2iG)aIy3nfiQ-8W^KEeBE9Wz0BW*@m`O!{`OW6?A?EG=PZ?a^I{B;%4j z=?YBfRa7`^4o(*pC{LV)O{t#!sit$6VI&f&K*u$$X)~)RKrqJ*&q|i;R9%mH_&m(o zj;gHj1lXeu!TS5x)Rvx1n-(wz-U-K3Uk9D*U9@!5+}p9aVLKu$c^CtV>+RuNjJD9O zInFER=egRo9?|TRDCA?WwO=>8K;Yx0LApaDo;cZqwgEKTvdp8(Z0D_95T~()Ig&6? zGcxBb^{n~J#8N`UsrRkowJ|ew8C<~LSZ&SPxTzXaNFxuN4m#IFH!z=4l)K<%c?y$` zD~0h#`diytrNY6vxA~9I5JwoVQ!l(~sdi_bU8`z-?|cuFPLJWwhM!Hix}BQVGE9;W zoa2%QTJ{T_P7?uH?aMl!ybga#{euN3$eTVtGPg6a&P{lPG_Zzf&0$MD(NO+Np(m&{ z?^BkCgUat?OGlP@?w~~vFf2EyINS$O`2%0gFZ>nz;vT2*JL83y!#36mcw@uREYR6T znNKm!NN(BV`PZ9_sCsxf+e7kNHj>^)jE^Z00n?Ado|n+02XY&pxy8i%zp=v*}H^k_^34CU` zyw`tc-xN-e!F_PeBWUxHv<#E?2`irCf;v~Ng|E=^@t9=Q&+LOqznjAP#)abTD&Xp# z6S-u%ftEngT|#-<#BrPv{Oj}g_S^l2WcbPBok#YC{hzFCG~HwD!SD2#93i`9<(p{x z%ts#e>PniDJS3cDsrf}|sKnZp&WWg7O{I8(-L_oW&V^ngI5`L2yDuOr0vqN7(!5+w z9><|hLnSU#<(S-YL*+wT(LF-sa7K$X3Y&)|BCJXR_(Kgi$nc<%T+Dy(Y%y+WOsLyp9{Fa7Nbw zvGmVM^)S(~%T=5Xt?);}TC7@vHl1xXt;(I~M^bv%%F_PF7P=Os*Pai)zVNI?+2oE1 z2ofIL9tC>vo`(fReaZ&g_Jr_STxm8l{{X^WqdNJ1T)|bN1N8iQ*H_`s5Z>uF^51K| z0lbG%5$Uq#d?_`Ixxtt0jtcv5D&+eA0E%@z zKHlF&@cO>sB_>F`wgI|)*v@^bWP+UyPbB!6@U!D*#7j*-L9y|ix)zGF11u{O4=^6T zFgX>!;4j!?!1@lY4~aDhO57}SQxQC?fCTs6u&?_HxLyKodzryWSXhcDo-hI9N}@nxQes(6b}@W+ADWP9yG zY1TC{kG{ELImLe2_;2>({{Vu1e#YMoYXV5~l1X!R^0V{DEKOxRO1_6p zEDg6ct)sh=D0JkGSGEjHOS3yc_0Qv7MURCqCeM>#<}z?u6O7lNTB+&LppmkE9O^0y zU5Mjhlk-f21K*nEyh&l<4I0g(zSZEG@j-0FK|(p>KDFW3?0Z;fSot@^UK?$DQPd~X zbo=pcTX5i!_-2bQfx5=21Y}1gjPhXR;@nr**D}!c=*GvRcysn{Zz9%v)x5fs%_u>O z-|1gO>7TPia-?Q0G$p|R0#gMAXtg?1K9TUp?DUb@#*t|+dF7y1S6pQJjxsCVbZ>!{ zR!M0jRy!x-Dr3$mDq-y`dkvq%+bt%_JEug76E4!g4!HjS>(*`dq2b*zXSe%C`?X>t zjIUpEdsjs~F^x=9I2~8Vnk*0OlY z#}!OVK6~+B#;pcOt!}LKE1RZNW|0()r01w0`eM9WUHH*wI)kQa6S5T!cP=)Q+P6`$ z$tkvZ4y*Ag=f07ed7dCS&MOo_pI9)Vi5C6Vt_P^21s73 zT}GYZ-B$Z+c?^*rc^s4UsF7+1UuofRk^cOjTxXos;iF4&aIk4QUZa0A5Wl;Dii7pW zE1IO#RoT@_iw=yx$nwj#K`>R~_C!xt!t&eZ; z*Mf9!4EJ{i~8sQ!=If#K8iD@5N?7Wl-Ul4eCcVCedVb%5dyekOPmcWXJpGE=v^$ipEb; zjR{#|gqLIO&0e&0NS6(@y4FrYXwg~Z4uo%UEG{9kL62wAXVJb9C3<{Kq@;4BL{i&2k0uClCVeIPaF)@0aiC`ZpIt*HD*ar zp;lwPhIkcmjlho1Fav^ij=86>K;_hc0m02n0kcgS1Skp5r)rKaaKkx1wK9#sbm5vN zP{Ch4{VA5A0<#h~gN|rXMiZBDvLm#K4kX*0=QVXA*(xdm%6j`%Sk5vhdttn?0Aua# zQ+<^g1ba?E$v*Xr(a{4a+Y+GdZ09(sHsvxL{v)M9WqEi++zK{v!0TF;sg*?l3<`+F zpd+5%Np4U^yZ}#LwWVatt0KCUE7RVrnJbc}ZsaL~z;TMW&>Ll974{A|HLPXPnW(ZG z7=xJ|+dh?l>}swhP{`fLJw;h@g^K%Rn&pr1amT$}lG_OGgALb;xU$G>)R_ae-MBgW z)yZNL28|mJ>P0qyrDY_D^B^s~PCm5*T+4FIg=Acuoc{n?mk_xFIk%MvS7av->??T7 z42V`IQYuArE_gqBBw0R1A2vIhva*AXl0P2(Dkemk4Ex!Y(Y}ABM5bvXlrbqM)0|dA zi+xL0kVw&f@RHf@#ZZ}KhVPI{ zutf@d#^QryU@nszUaa!D#y($q+mgxzPcwS%JYWujvXuJ_irU^0A{hxQ^yyZmw~K2P zW5qZyG6lqqI9ARV9Fx|p-A`|F zGT{njVAY|Go%YJH!U^>_>raMwSx#5X!74!==nIfssx7~j3W)j0$E6nV!eRzTD&Bx} zscS)y2;}oxHjJ3@_q$b@BS>OoMmvvxN+qxnTg@1U%i=`_mPG#mR?4CBbJy_GX zClrfyIY7Xuu9YAIuv&fHj($m!m?e){OBn= zlvxb#DC3cVidYlL0s|wy2GCDaO)-dKP|67{gU`J|J4UFns2y>iTE1`?v+Q4(v+<9m zMJ$;K)k*8eN`aB3&9clS8_-Q$B$}8k=n&uxf{=kRkDcL1Rk|5z)3CL z%)VJ(cMiguLXtCLk_fJn8N;2!JBM$rY)aPhkpe)@JhQq}{0GzV{*>h#Xei3XIHYxr zV{mhm^r)vSC5rCc?3N%`<>PfpYC|Wxo=6Zy8kWx76OF$0XJp8L%L&Nz=BY}+$e`32 zk>RJZ#zLu1##% zbCsp}qm-c=f#_+mIl!B7^8;fU>r$zZs=Jlagp+@ zay#3C(gTGAsNbi3U%rhcbLFfBPWzm7WyOAW{AB&7Z@g1_EPN|H{+FiPOz=pJ zfMs5DpRHv$n!)xyK-9IFZdylq8`(ybu5k5|;LEtDPbu16=ma$YaJ(RFP| z>UuTX&lH7=s}5A>j(gRp89HpswA2#M1991mp7qnoa3r=08H$mS>?>0j4#yp?NV4o$ zS=bH-sQ&;w)h$0qp7nw{Hq3(D^c2z(hMJv%*y)xqVm;a1aD8f@m?P#r+0Wj^Hpy(d z*LaJ|^72XT+MrpP0R;Tr=@LTwn28QT^c+<1#>A@z!k>CYMmJ*3CzH8>EdG@rnyniW z2t9t3u5?9oChLv|p)G^%-I&{JH`M)W-RIW)UH0iOrq^#S9%6$N_6m3k zYjd(OKVbg=V4sZE9x&5&&xC$6zPpo0xPoh23w!&9xe;7#`{=GnLQkcBZvNDt34BxV zf8wUIr)v6R>9$uBAG66IBuEcD9@#a`QjBkYq;p!M^FAl>b&7{umyNfasX5@9^En+s zA~Tbk!@I zGUN}!wRGPPz1-jsMm;;#!3oUvuMT`SYng23mI-2vC~W8DEABrE`X^1&tTfAiF46%U z0Oy4Ox7NK1X&kkxu7;XO%B5lqqd8U{vHm7^Y)N7pImgUm~1?^0fA=i$9l{Tj?Yaj zGNgqbwYL_Z`_mZ&uTQN-LCKx$In z+-W`;hUE;RRasT?v2l;@JN z{SEjT`z8Eq_prbYy(f+3%OMMzwQj4y({`7@E60s1AH#<-k;$QhrSlk zd?VqzR1w2zV*9;FIh&d!SSr7nk|70@WCHjHc(P*71p&J<7q zMF12~0Yv~6425CLxb6Y1DZYkrm5;>l_%0{>5~D-^0D_->%nzgZO2wR4~ol0gQtp65&;POz8xh-_mgjw_|N@U_*}mNht%N3=a04iDp8 z{JNV(*ypCUj@?r&!wrP$W7*0n2tCRhth(MYnO&I+&~f)C+e)^Ge1 zC-$$=emeXsvGAi_OrH>ZKB7D5rjrIp$rxqNBynFE#yCk%oN7nx-v0nQAKHII4lsrj zI<1t|cKXC`A2~wr{{TsH{{Vy2_N&8p=HTvl#OVJ3E1~`+$0ENCziJPL+Q-3<+LKq- zbX^`$UV)Jb)-<$j4qO}6w&Yux=7{{VtU{9upakL|7DShX4NY_vZZT7P0l7D45U zfyxF`>+4_KmxS*8sh$TPamwTAU(`QK9J&;EqBUTW_LQLCn@&-?`6RXMe~8{0S9LO^ zr0>fqFHXOy+UqNr!Nv|VU&Al_9pC#o!>0JB_E7z>bjv4OcbZ=c>z7fCq>ycfEyB`C1mt58LnN#~-?XOu_Hdy!dtY{uq!Bu0LnJ`M)8@3kv0ySWk6M2gY92EIG%+tM;R&3b5k%u@&kj|n#iXl1^}*-N^nOb>q_%s z!W20A*3by|E6o=CfOc*;tSj=7v#X8oj8@dl+)ibta_(@Hk8k12+%421%i0(AVAh$9Gw`3d; z7=J3}?(PI3;V20!!1NXC#_1kawK&_!-aBjK4ZP+}higVk?Dyiom_OQ|!;j)WjXw}I z8D_hWQx_~GiT?nKFuy71pIY*9hpU8%`Om9B3A>6S%+X5GzDGF*xk&?#qn!4yoT_`& zki2qD*LFx8n~5 z>US0;Ze%6Rl8@a6C$GqOK8i(tqj)pMekJhUt*2aA7^Ap}u*yzB1adj+Uqy$N)tU2{ zh}oVu`%iw%{uceDuA}ijg``<{FXDdv{{U&XZz(Ux94wysuY)z8fu9vTA9X&F;_n3A zY13OSUgad;45OYw$F^v%L2N}i>vPENG^rV6XyauWIXvJIS;I`)@wd;tc|6yRR+X98 z5^1#9wFo4%nNg9!2XO6NE{EdZ6Z{X?2BW5-)I1+Fr_Z)vK!~2}j?_|(nRY)!{u_K( z@W;d*E-TLu+$%{MD_q80e(3k_n)(kx)a}s5Lye9&K9%TFMRNr$O&S>ABRCj6 z>!6ED`+96_IX%y6?t(npk!Ff~HcRGM;juR|V<%wAHH~-hia57NKA$p5PJVdKe=6yU zGBB>b7wOTGt!-rAHgIj!arsqw{2^r=qzh|!MgaK`cBzy`nXx+P_Ffy4OI<3_?+n60 za?A6m#xN_+FIs5O!5RfXbGUb|ImN4;5s}MX6Bg%o`FhtYeW;FMR#Ce-EO-OfxaBT~ zWi)&}`$2xt>EOApJOSY=s5MU(P7FdwWDbymI-Gh}&A$q?jdQ>@y0?h0HQ5(e)N;2{ z5<@;t>}2zb=abOtjrJ_~kH>oNg{P4MGcPM1E;9Hza!3gX`ZOJRN5-CT&Mh0A!Gb zRG(wcYY9Z!G@Cpl#lN%+(atXPjXp~x`-LPS$OpbF=l=i}d}i@>xfR8fn$fk>+!QfI z9u7}%!~7}6Cd!%Nn$7N`sLc!_<6F8_AcPlgs(8jo&ox&@@C-M|Wd6re*(?jL;>4c$ zuF7>gobc<{I8!t73nAt+7Y*b32-%AKjZ{TkhYwtW-rQWL?rEwg} z9H+i$AG5!mXC$c`!j3@0CO|ds z`X}u9d2X;ux_D@rN6yK?$E9SVbtPlowBOmYO0u)GzP`M(wYy@jB0Vu(#ka#9DW!%x zBD#d+WQD?o#{dpN@xIozr$*#XT@Gu+x}SygDems9?iSSBC=a>DLFvG+EV%gn;mtkW zBD{s>F}sgD8($s0yH|BAF~d_4ZI78eW&2U-@2AN22IVEoHWiN2M{ipB_gDR+bzM$7 z%}UbZJAFjJU~sF#9An#>=~OIodwZWR__N~Ah;@H5DK(4OrCcJqt1nN48Hy6&fntHd)?ARml?^(*CM_oE6qUj$Gd_ANGHkOiVw?G}Z zPFN1r)Z2VE@dmKglSgf1qFBg4EEBW-~H{DBeu;aQHrLPTxuRFX3xB67y5I z)itZtA%aNzV^iOO)K{o!+HQ}gAcs%W;jxb!NJC!@m}a#rJ$60(E(S0(nPCzM2nEk` z+*I43X2#vC^{*mTdNa`WXknPNrZr5ZOZIjrC>S55N@WvUY1bNs!oh8AJ>10OWNVT> zwcqH!2>es7+WEG6ech~{V&i)9qc}MqN^RJgO2^QC6aAT^v6PP(ymFzzFrXpZJccLw zSJ7HG!v6pX=z3I;S!ofOw*rjkC2{FowJMx-E4`7|=^9<7n=(GwRk6-EU%*t;`E2CH z^Wncb;i)EaN};hF5Hwz4*ckCpc?hnm4;9TVjHN4)-fUkf5PaFHtLA5B3Nijwflz%4 z^2N4&jg#Jsn7pKBQQD?k9TdzNqkkpjb$3?aRXEkr6}GbTSeg%=e8)(`t~&iH^fvo8 zw({8Gv5*?Jh+aZ>bQs1fMVHBuJfe8)J5n)}O}OrGm{0-l^{S}KZXK0BcyKtYQ!tcl zUi(w42pvFS(~5L$lGr)t9@TMoCd7)W7?QXj%B#ySoZA#{LBQg*gXj$kO2@T}9i#L$ zWIk~rRc)u`Q(8A+2$I_{Jc8qsP;O8eg8eHgOQ6yrS-^Z0CC@qZ6&=a>Mgc5%>r!rs zcd|sOg&6OSYZmbuSrmfoGt<_P62z>4hEVJ{=e0pA@==8VSBcaXQiV3)4D>Xz1dtH< z81(Bv5rzQmRy(?5H9pMYKs{&zjlc>-MVlQDwO>e?Ez~JIbfB4cD8V$d&mi*T+Jq@2 zaB9QA{{TF{I*(6U4q39)A2NdFoq*#fnw#wg5x1TFMHe8NJ>%vel|4mHvAl|^7_Y5k zCv$kdq8KLF%NqQ^@$FQSDV9cA0L@9dWtk8a3Ab_1YTCrm!6d+)nD0Q!P`rkADj0+7 zS0}mJb~1$Zpe{>oarR>wSRO@YvM}-SCZ@;ffY`2VX849`Lwg(#!%vq5_p;sK#i+31Ou1dZ+_oPWiNhBk5OhMhv zS%jb&T;%X+lO>@X};F0M`yAsWbOcBL^bCI8|XGWhXo-_DX zQkBG>rMQ>Qf0ToPo}KCPD{nXpzaLE0qfuIK-GUGA7a0|rldZ+Wyuk6m0M`1z15bM(jyU9!FxekpN{azv`Wu^h+jJ%^rw%dD)<>B4H!Bc5PAM~3vc<)U zL_l^1RXD1WNd(FwWZ57%$nGmBrF$~TzRsWkhqqdeNU;-!JD3~{9<`$K13p_vScIf! zy+>lU%o}Q9hIqyg)|ia-x-sgv5zdMu3JyW!*0g?0qckVXR_T#h%$U28!vIXOyLI56 z)pk`-R{-zseQPr82hRxQ3EPaGI#gD$;I#Wme);HV6DGX4i_1HADihM8f@f4QgM~da z+OM6Mv0_y-Z3A+SxUCp49k&h0dVjM=J1QhoMVo-CKxH`wtxGeigk@GddsG^gq=PKZ zgKkLqb6U3XTkI{kmOPQ~RTZcdw-v zJ%(ae$p;&O>_uTZWyO_ux`jB(9vjyc0?Mf|bYddNITg<+*xoYe3_x{k9#3jyk_UB- zlz=$SI@FpK?^EpJHjXykfzVVcyU~aYTfRqn8t4e9t#Y$0ZwTP`?^4dwLd)faRL)2u zvy*!l%tDfucW~HsImoKJKq7bYtHz};=*kd8*g;F0l+G)};i*9#p-H)YaGUPut;t9q$_o~tv zVwyFU2H3+O)pIjQvhWxRQ*ieJsf-CrVBj8o>Pu*N+|0%{8&6+RRNgr}rjB?5` zpK5IOflxYt&72Uu>OG-k4#pAks}?;;?NLUpDwDGq=kcT335y!;W?2w|I%HK@0BePK3N($?3_ce{wppkZ)vgX(FUsP_xoOHk3GgXV+52NhMV zUO7NwJgjTPn`BY|&N<`I)kPf23 zl}L$~r{`bM=j7&b9&naj(W4@Q**E}t=e2y9@ssv|(0n8>G`|jCS?Zd>V1odaKzKRy zB7;ao{Os|E#P1dOn^Aj>Pgb~{ae)zYvN79g*Oy#Ry_iUH$Eh9b8j?EW6E)m7%5zZj z?_5)n(HMxwhU4b+#Wk0?2lA|p<+zNzWmi8+M&mipG#Zey^#BTtt_fcB0ThD-XE~^_ z4+KyIY@jh5k=mds*9L$i^)(_4V9*8h0Dya%lLTWKpb6KvIXx=M$WcQQa3})pwaOfv zpH6)$^4uZ-5lw9epqsGxCSByXz!kX_^rK{Ic*Z()syXE=9Tt(NSlr!4+NpTr``Axf z^eLN3x3!Yi!D1>v+)4mXKczeLGxmoIc?u&DkQXP9N~lsW0MC9ssS+Cylexen^{5+W zPb01~K!-~fV(2P)NOk{{;Y_U6P6S-KfN$e;zCs3>p-p_ijO9wc} zOylc72*rV6xYIXn$jKA{$!-SxMh@Pb)9o%@cSK0%BPNu5%W@#NW4Ng$svH%=Y-|p+ z$N@fagWj&eGVNf;-heNeV04W^+nx_S>ZI(EIRJ_ai?JF?u`!>Kt}N*1(E3Z@zmFsEhl;eX5k-A-1^ibFDB3>qs{&W?1Fe3u z{@q$0o%=+56Yy8Y&kI~xo0N?syMO{m$~R<;WFDjGic-CjHxA#cs05}XvG*s0G@mMRpdYl;GNZRh%(AM zLi>UFvy-0H>;C`^WbmG)btD?q^p@AD$|+BlPi*(Csl?}$x}RJ_X%)I6s1Fk;2-x6^ zcEw9AqACU~G5y@vOj*NPL~e)6DgajgA9|VuU6LKAcK~3HD3q>pnAdjhvwh>Tq=Lnr z({r~Zi~-i9mm{{*Y!)cMX4+4$TG>cUyc90oD>+M`ZfslWg`<&~)dH!&J^iZfji&Tg zR{1*CQk8__jU}{1a$Gy{+P2}cQH2STeFb1-ZNX`^xEaT#Zoz0uhT6RQ&<8_fV!H~r zL)R6#ZDQLHnSuF<$Q?&vQ$2v_S4>G)qj{&O6}xSw%e(;*-~)_ytW4?~_WEp$18pkV z=zCX9VPzCyI%g+2AEiX!LJbSssI3r39wd_;y=yl}(r&dImXhLWB7`s?DDCfDRcB+S znmf5}f3o0`))xKF?b!$hPpR)&@2}d&Z#)w1^O$4|^&Yk3;wqhV*Hel&%`EPyz~JYv zN~x$yk_BMjHhUgLc~g;R9jV_mTM`_$az$rZ+g)mxw#jb?;L0WHu9@dsS4?Dh7p`^0`D&^#GqJ@&UU$72GPnL~ie2sk*;Oya)R z4?#vM#7Uo)e;fWkPvebYG_M2+Z1g3GlIHQG!x9fvuNm;2ggS-U(*~*L7Ww3M21niK z0OXTitvYr^LKi=wkN72T{1LC?XUF|lN%+O$oi|kYVc-EG$#1D&z+;l_H*)aAa9EHr zo|XNZ{6GDV{vCW0lS}cBfHe7ae~A`0-(~*O)LcB5Q4xn+V+)*i&rWj zwOd6g3bGX&)E~Ot#agZkk~`w8f{Mh_p5a9Xp+x``P;-S80}5{;iOAD1gGpSxkiK!3KwXsQoU)vjQorYd*F#a$EHws%+RHpbMvtz-dXK`o zBJ?FsOC0|Il;&bVY;^Xinj+hki1Zbd_ZK=c+-)QkC$&Q)WU7VWW|VgYG7W`J0Y9C0 zUK;Q=x8fVPVzjqrkMBy&z(w`VZ(~^7soD6u;%|gL5@@aAKLc7?U--Ic{{Ve`BkkrL&?U47LH!TEA^((@Pu}K4bmS-M*EBea(^X zUkd&e-gvN0sA|?%+J26RN=PHh%HudvduJ8*HJ^w67})$W)-=1s)1$J2Atc67q2iPb ze7@AVh?I}dZ;6^$hL!B)@XFhWe1YdYeI#uE0ER2WpHJN`Ng!0sK8CdCeGMCAXcVe} zjMv^wt$g#K={{Sy( zRF8e&($mSGo?ig|B-wZ~#eM?#i*7~qT5hKnqZ!XQ3YP3{{RF$U2WrE1b8#X zR#$&%O-D|G>5pJpK{fu7{V%Ywb+8z;z3IkDzeg6o89%?w{{Wos0HCN-uZD`!6MuGx z(K1eN5U60~K+S$F{{X>#KW5uc+F$+&Yw`0(HvWFM;cHj%Er|=3R<{OL{Lo6jjei|M z>vQkf{%R6@aC>is{uLT(h&)o3LMZ~b8}Wiq(B{5B)V1AS`sQoBM)FI$=W^0HCmHq~ zg?7S2F{PeMjl0L`TDFjG+DIUg`BIdwIIT{TPqf6z9BS^($RK)GvRL>k^2IGKZ^UEH zMV2HC2?~9E>z+*Lgbz^g{{V%)(84Jr#CXqKf0JFJY0y~0s;IHXJq19Xg;_($%x=5u1(+4_fz~D_BE|UogCU9iaF1ub<6n-&A%}XL(~PHe36= z4A#O+gx)YoI0MqYR-_KdyOvhxa`K88dYYO^RZ3w?{{Twolx{Kpd$bh zp>h1`lt!J1B)N7V7x`DvS3i5YM?rz_@xGJc?MCA6Sk>bI z3`l^IPCap6UM`92VJde&Aig1Z33Vv1JVgz(k*QxX(P7wBjt+SB;=V|_vzcdo(7Ftq zZvG+aE9S8@wLXf2xma3>ons@8_1t(v;eU&KW3EG{ctcO0S=1#1%Y`Gz$gT+|vFKBV zhqnAP{fNJ6kBq)B*1Rk5>)_9fyj`kWTbqem($U@l;4~hq##z-?q$2A((eOV!vLdZz}80x11^Kn))mrr_5t#t2#YD#n&ci zJk}COmZg3K2`TJtMm`<|5? zO4*(js_6d!*z+Z|!!q2CtF(emP@hV-)D<9+UP!ab;<#NqGpE`fF{*eI#6BI>XV!cN zs^4fgUTVm}Iyhh9BcTSqf$$&gd1a)}Z{gpH8g}}vsJhdmmyeZ^@EBKpDR(&PBiB4H@g~R^ zu5D+M#!TmNY;7XGmDB$KXgx0e_fNd>I(ToyqTW9!!7NIqVeY_n9`)Ny;*&ft;uns* zKd4_{URr5-UW;ujmxc&r+z@(Zygu{9mIaFm6L~*$RZ5-A)VdsQrLRFGrX}Aq2FAr4 zgY>Q^S--flx46_Vr?b**5M`vgog-Bl>T+{f%9YNVXUv{A{iVJPcrwa+zY%;<@U5I_ zxcPC;C20ukFl+NO_JIEYf|2Oj%zB20@V8Hs`!0CICjK@7pFNdNBDgBivOQWz_-n(T z9`3YVLVZHtLjv`V{{Xbk``$)9$vx@bCH7b;{I#%#S;GP{nIIppN|ghvm26V8@b`>u!<{v7yT>S$)xm&6GxZkJ-=VIGT`b~+Rc zuMudT5z+62T5QnU>9L@aGVZIpj`hyJk8~?5sH~#Dx1K=>bP=#6jyiSXwuKhV>eP%C z+4KJZioa}c3;25ZXVmoD?-eX>v8>W!8NloaJXg)$JN>U?xzt-#@YRgk6_octrMpN& zTLbQT;=LMlExF@jF^TMam*Ve_8s4R->K59Lp>ZXw@)ui$argsXNv?Rx;$1ict@*6X zTOqz>8T9R48Y7FE=alMt^l(}va9v%l*4$XOYn{6BeBWnam%dXRWDc!d)oS!KjWf@6 zPZ5@O^Bj(I#c_9jB0HFF$Uc?k)v9zx7CGDB5XzvcT)a#=5Zx=9pIpSK?K0yzJoT?W zbqm(CzK5sS_-5i5qmNFvveN`$7~CKv zk?UKrcv{YRjQ8_PJcNcT(MkL(=W&_ZvsCx)d$?S&t!8XRYX+Ypi&$WRIU{NSe>$}# z)3zDd$k^I5*n3yXVsQ>{np>XLDhevdY*PV(?Vsvtq`RHUyaU&@adT^9ppSOx6f-Kf zVVyW})00vFQF4_(|fuem0$L+S!R4RgnCnx&C$ZPM`ZV zM5zMmm$P}h0}zrCoR4aUI~Y!>?S2~gS>ZnqTSpzPl#6gNxyMp#(QNHL$GR(T+*|Gk zYVrBkG^(6)t8;N})zrx#BlqgcrzD;YMP(c>m31Cq zBvvil$h|GHLR2UldmPanv~iMOa|6?wmW1VFGv@P%z&LIy#m7IqSjymFpL)fvgNrGB z@XSU}V^wZrcU51UjQ0LinmS`5lAliI7583gOS zjD?Qu_oghY0V$jVO(3x>w;NHGK--U{EOB|5kvD#QDWoQ@JVvrA^OjTIr!YDwl#{R? z)vS?;n=kt9(GG)=>rZ*(bOlMyagR#QNJ2S9jY{LpsA6LB0_~CyPfC+$y$dp{GYmNh zI*fI!z}``2<$*k6f`{b}<`46FdsHMQ(nf11UD zZ8)IDXrIUh2FCe^HBvv`%reJ*eJdvxW@#$Uq~Mo}ACafV^CJu=%kC--;AnZv*!=y^ zN);kZmcc#fI!ZDxnIf{1oc-TQnaOlm12cBOpa_;1x7^0D-*^RL;_0=Its z>O#bFM=V8WM?Bz>jAE86r?{D%rT{;cRCfZz>SALy&zA$IdZ}d$d*_h`9G%@dn%K?E zv`eff&0@XC&jPCHS1oGhLP&_W%5&DDXr5!CzQ0R>=E~dIv$*#s-np18{Hf%)iJNma zPESvzV=az|txN5hPDtEqG}~^KoRS%ORtCkL=&Gx~w@&p|M%^I8Fd%csU#&3Z@3VU{+17T1HKgBQ>p1-5Dg0o|*Nl5Wx1%%LvRzo}8^+h)%`$A!#FIEJtJS zR|FzAEhBt_xy{GSQ=~*-@J4Dl=0)L~YU3nO25hV5NX9Z-j+p6Ftg!AMGx)Qv(RbJO z!%E7=e|v&(4r|e)hvwYmt6P-w>;C|Yi51Tt+CZl9Tx0!mzr;p86YuX!S}3D6l$@dLb*93`?cg%q}Gh|;VY6fF~f-o zES-6(GJNdv$DOOs(zzP3(xgO}GPGfCQNrit$m>m!wn(mrXRxF@iW%f%B!lNZ)n05e zl*ZN{l_wjQ70{^m%@}>5gJUP$RV9q_u^oi^jMQ=(Bxqa2Lx&`7>CaJ5)MB)nB}s#s z)w3Qt16mAZPJ?J{vvHG-m7Q?w_LN9~Di2ReOZ%KG0!}8 ztlSt8;&uCg`D>2#HQOw!Ziue)eQ1n8oJk~MVvx85bsg%e#Ni)v;d7oU`BAEv`0d(E zENoT1%|zaCmuiw@`=^STK(ZqOtl-AQi*P}x?=rbWcSarR5LmX8Ie_`j44eVSQBARk zC~{jTIO$s_aadW^l0*yh^NdxdaVFAJBzE_vX7@5a&g*#7#C)QsJf8KYlAEH+BpcKd zk6Hmr#!;0K{0Dmu#S*C2^8H>CoK7 zT4`i&FCbta;i`%PhneQbF2V?6az}4*K)T(Ci6w>s_pPH(us*tW(E~a9oul;aO$39`oOh%r+(rP5imuq}lR+_;LNYe; zO&(rDzD7j_kThk9I60Im;Z48R+K=|;N%^?~w`|>0Zs0TY>sy?4 zS-T9)CgKQEIP2D|M9=d8&7S zdgg#37*azMyZO^)WZ8h6`p^b`a6=uydU~4G)8UG3%Oiwf2?y}$KoCl!dBMmBxTY~U zD~+Q#;(#MaM;HWDvZA8rI6XeJ10Yrbmn5&PHfG7&+JHEv&l8S!GsD=7!~qG!$>A(Vh1L%rrTPXC^T6@ z<$3Q@AnTFRx}&ffa3F7#kUqWZO4=|9+(81aJDJK|4Ii^3Fl>{aYQ?R(MKZ7jPxY>t z%EnDx`V+z4HN3KpJA2vWxwT9P!yZ@Gy|&X_u+>4APLw^|EIzN@k4GO>#?z z9dJqSQAPo0j5~%Od(wlBOQ1y%nnRXnP;vhCbXJzF2^TE8Fh(=nP|jmfSW7BxBzESy zyGvAwH{p&(Yo2-Fc7id3`P6$sNt?EoGDcLgw!>XaRv^TM5be)g zR2bao?5yyM@{Qe3wRRSk&J$^m=cGfGjk{D(?qpmJ2O^@?^Dz_B$89!J)b&{9c$CIpVB3y^6~x>}=E`Mc z5dcpooC@)3%Tu<+33kL;k+R;^$Z8s@M=FGo&Ph>^TEZ0W$!u)m6L^Ef zI^B(11nd6*f(8E0U$VunkMR@Z zErdT8zA-w-aPeNKZ9hz#1Bl|s&PP1AQw70Rbg#>X! z3Is^hbPA(@J*v%l^(r2%IM}0Yr@?7)cX0@1X_zyN@sKfBs{=ryk)<%AgFvEy3Me_k ziUjrwj#&KI-aX8@7|7}Sz;5#W29kBh$(H0^uhtZ*@l!kRJrP3+T*k1U`+ zCp=}!gM))zP=SP`&-2Cq0D_eN0KsNIZ14Cfw!5xrdj7qt{22Y5E-u~dd^e{|(M@@7 z56CX01Q!Px+CW_PugR8Mcx~adgqYxoLM~2lD|W1jj9ONEnMUu*c2zs7u(^HxA8vd0 zu6gbR>dPrRNNSVp`-mVD?@BwAqR&zA55tSU5>GYk-dq|?5gFx`*d_q$jQds>#V?Ec zZj}0mgMJ^#ixP!duE$pO2e;u{8^$NfQ^;q!n(jhg;rV7KtxAYUAY}83&Tpa770|tF zZ1OopNhFjF+Z1K7oM#pGPr!eHms;MTCbz3vw5*s&QMdpR*XnbR!m)5Pb3Uu_Mz!JZ zf<6?TbxVa^GGY(eGlyp$gYoNMoF5QAA<5$HO6X~ZdmS2FffK*X`R+$bg%*tCsV9cK zBY&#d2EIm1eYhAHT2p_1m~NS{vE ztXbpKEN-H@iPY_7D!_~p$m9-vt0}=rILl^wI9bY_NX`z;G}Ax3-`R7<>*LRb-weD> zZFDa5i`^CptzAbsDhmcZbDY=NJ}mJ4w~Ra!;!h1;SlZmnb*0Z{jOm;PM*gH%;`n7M z6}gw$e~LfenpL4zoM#7hB%1VR^JVb&!_VP3_0NY_cMSL1MAtfO;f_elw$}FG@$|3m zzy1js@oFE5f3e@grF}*#onuF5(r*<;8CooXk@OY*srdPhd4~dJnS|}lDM7n=)0NlX z>VM7!T#k817G`-&{{ZFG4fHUuB2EI%6lB!3>*0OZ!T$h?9~nLs&uKK;pM^YUs%W!? z=p$L12kD&G&DR#7N=t*+oL5n!fg3@B6e%6Wbs9dMEbkm)M$GY($)H!U?tUEbve^k` zp50xUa;F(1>0Y^{cy}#tb$1z7+6Y!3cA=zc?Ge{pZG?b;FKj5`YM5m?StZ}!nmG*R zBCNy)0FYy>*}>hGBW5}Z&7&t9mLd-5s1TJM{VQVLJ*8AB-Tdn*_A_zT$5Cr+TWa9$ z?d@Imkm;wSWmu)b9Y<`|6WG!*v9V?X&L-!~&tF>f%??>oK{w2uKN|9}t3#@sk5|)m zGqnMfA@7max~p63c1H4MSy=VDUTe>#blWn&+{=v1Gw*37h+_zF|{RtmYGf+e_G=t zy;&Mvt)#44^&3G1gY1yW_klPhbT#x=y{FilaxNn&I~~~uzhcW3=*CZ~O!-W5_l^SQ z*Gz@Nyvyd1_et&RR#N@+i)FTgLF7uo%J4&DrbT=3*ztK$RV=5xBX5$Mk9G<(_|`9s zz8%lvi%AKWx1V$Dia)o&;OBP6DjXkNf-&EvdB^+|1O5wT z`#OHxzADvqZ723t@h^l-voVVL`WT~?RQKAMImc|&tRh<+{PiO{eV+dSrH{n_0Eu2E z_;KQI5l^XnJn-G#k70$}E=CAA=Z~#;{oSm$4oeNneW`mhqn-6FX?`5My>w`;q>)MB zDC^q3gz)FWSuUorv5`>RyT)U;L-Wbc^sOmG#-!3esE^po;ro08_(Ntc-aDOdSBHG@ zmB*0~ISNSY+w!lnrSay6s#(O^Wwo?8!pO@ZBO`(^ee3A3G|!R8O>;6h^%>_xlGmoRClQub_n_^geoZ9_OsZ@o!Gjw74|&@XXg!1HGq7K5wQn1$B47 z7=9J_yZa`~RPY7Wl>0on?n8XQkK)<@6`fo<>Qy{LM}+)F_*vkO6@ey;KAWt@4pEj5 zDnviyUID6p&!*N*MtcjJyE}wHV}fYL);;iXn&6%pY>w)9x76W(;X(M22R#D5RU^87gQ zMfHtiC_dBtBXg;?B}KfWx4!cL_zEwB;Es zPfXK4ZA-l(NbLN1@UzC=6p=>hq>46lV0vSz{VS%o{kgss$vG418upzS84oSC0RI4Z zoB>)wsH$PR9aaAT?S1gJ-%U4HUO3T{g^&Yso0NKyn)plO5BwFs!Tu7G<3aFFn;(uZ zmO{Ji$+x8YiQa~R9m(&?Ta)b&-8OLczxyor8f25Ak>x6ap;z2ike5Tgo*vpW>Awqp##d8YNZOvCZR9x<1(yqj_Rm`P zj|u+Cx_qJKHi_h>5UMUWeifmou|4y{zq3|@Yc-osr`<@3aOxu%UrcrWRrJ?}egFzNxJE z+fO$I%8O`NNZ=2|Vzs9SEr^_yH$G?9{yh9T@ZE}DX-R#kube}NaK9)x;~e_e%^p4d ztx+!)%T0#a?Pl{O%0JHvfx?sCy-FA>?s=8-9+5s?@ptVhd8}yG^A^3by?o(jBO!Cf za7}!*<1dJ}SC?t2F1M-MPJ@9R!Ck}C>Fr*WXhtaVr-^cBj!E$jd6!UTk~?V{LR)l$ zE$&aPdETqz1iGCXO+r)U=K)(GzO~O*qC<=u+~PGq8kZ&!CPz`Y*DXJbqz+}?OBKgc z(!9#JgRY$;p1$!@%a$_8TOAdRb5|Z9VxXB$Gn{6)Cs^x^I~aGKB6r+b%K_Y+n&oBJ zWiKPEA5LqMbGf0NE~_k=`SaV3)t@cH$a<5_bIMmKMY1B!{{Sfltih*T+`6PF(q!Om z?@(<{lRXDQ_;Iaj)1pJC+)bQ-xFL&r3i>m`zq2=pZeoV-Rf5k;L-S%nGI3eTqDO5y z2e#sEmC$HsRscWa`IwGuoAJ8=2CL!N%nA!TZdAO`{ ziaV%b9HnAQkoQsvt{z!jbS01FP`8$MZb93%e6}YUDeikzFv<&*Q7e4g4$+(tJ5wH3 zUA=3_sWY+(kuw<>@>-tC+mbzvxSlw!IZU}pnj=WRy8YFKjosYY0HQ{6zUSJ#TSNFU z;@=W|k{AQ&p@`kSEyMAwB~z&~t7F^r581Zb8KAk=Z@$sA=2VQ4yB&b^uX^yW!ygCf zlgoAei38p+8y^GY!SCzEV=BirOh-f3VY9Wf%37*H9&iGv1dmUpT8&a!7-TB}!St*p zE1Z+7aFHQa5vvl|mJE4ra4=wXqHX;aSc}@ub0P9d- z@|mPK>za~fD-$4DfecAs_T>4dawq$Lm1$}E7Y;?zCK1&6W*n)P|H?(NF9Isly-YjLkv6@a4<2;;Hmlmx9 zsK!v9J!(CnMX3Q@rB@>ur>uJh;na4ji@6fmy3!vhM(iyL+wuS^!1IyTnTug8k1oW( z+wE2(iz=;hKgSH{=j;*V?0d znQ$Quxcb(FIEW#5lx|(exd*ALZi*jzpj98ODMsdEw2>Ihn@cu7Dr8W(B2qc+&0^84 zNoFh&hy=cR)NqAVWp&*By{QyeXp}j|U)HY2ZjwUB1bt{SmgQ%(RZIY(su>}UBxfiy zjBdwDzH$nw7*z*xBdaa^Sixk#;74| zfLL_)tQoyM%=TTxjE%q6kwPm4ec9`ZMy1AqA2LQ53W_^-^Ocm9+v`9V<%J|eyfII1 z=BwJ<#!hAjsRF4+;0Dx1DPYV~`=oWKZ6cNL$vj1mmzo+C&8edD`TK`B80l4^%My9r zoK%dq(8i%jCw_6w0JNcy95!)^cj!9`$nYs(aNo|VK@qrjEHXjoG%mo=QdE*D8I%wO zXhfpn6@zU4_n@uNicJ)zb_jQ(ocjvVw2~>Kc-b=Jf(YqTBr=28rNKT(R142sbo8de z-e7c{N}T+e?^y_zM%solTb}iwZ!g*8Rbnv2@+zY2M9oItVv(JRkG^XsPcp=2kTzq< z;QCg#GB4b)y0w@_fFFNap=MY>@GxDaf#h;3XR%P+TZ?v$z})W%?fMTbb)X>^sMCjMa9gVoN{X;Sdx8|sAIq89D(amtV#)#wimxOa9Zjz%x&c( zbGdU&krjhT!IgN$YLT0PoLDWwD9KOdSMeJIv(}R(Eo?&sf+-#%3om0=S&$(Gf%?`a z$r+PI@y!WSxHEP1t8-espziq%AR)DNw=(bv0|Xj~$Gn-glK%io1kp9Lj=Q%v%js7Y zpURR0bJSH^WshOp zMk<19LhC{ptDqZ)N^*J4fg^1>?NtrTCT`oy6|4^O?o|qK*x(;iUyWb2r|pY<;hlR? z@JGWt*3>*=lL%zER{hPta;M(D--WO-uQz>CJZxNLBjcSj_OAHnEcOFjw!NEAjzRNU zD;APfIo-Rk74JS1{kXm*>bk@cUTST5ezRic4M~}tN1gyUz~a8bSz=l(j|!y(rF4C< z@b~tQ@HfQWBTDdrG^UYc@}5BxEddhW`Lr z^&P9kuYvch$)O~kr_eTDA=5RhSXpFfZuW;LNFraSrB&1;QL7OT4Ds8tkXczi~*2GB+}gc zkgFAB-Pno*NRTkKUD#!DoCDIcV}Z<)1q3P_W{X&v7IjI4R-~xO$N*!#XW6yP5vts< zbB@b_KyzzmO=l~xYyz#gYK>5&uaKY}%uX?mML};I<8hs{ zgN~J~Rkt;R=ofLc5yx|l>c@Z&T5PZ{&e88lF`l%gE{26$ZNV7G&WAYXy*gNS!d`KA+!8c z&UrwhjSF2pypt4Fz`#87RwvWa&E`nvdz4~N%rF4-6;Wn(Gwju(jgi%2{ox-`QV@a2 z#^%rEU3BC-ADQ13elvI{;fy!88m_vRcc~m@A%Jt{FwX$+K(EW+iC-JFe;@dUZBl4v ziqQ#MZSC_i;~6SA9jp2ZQnC5$7Kegd&hkp~3@I#50OFZ%JH;S&T;tSqtR+67YUq?YO|*47Z)?B zKwlS{O-GPpW*0(vTBHVi;jZi2&^&L$;Wb(?K z?HTVuoK=ekaJf0gMryETV#Gc{_3c4L=DCg-)gvtUIrcRSw~@;$vP0#e?VRlt0!E&d z6|MBb8Rkn-&KT2mD;Oc1tWI4)#|OOysCO~0BSzV|NZN8fwNZl;!7D+ai)rR>^CcUz z-}+PS)gj8b51yIqXaTny8CPn2`RnOaUA(l$RL})I`-tFVanhxU+Bq?tFHgdu%nJ=N z1{gRQ?^2t%S~XD^-U;V5JnRT0ofsfMRFBq~BP^@CEUY-iQlD@mEQ+~3M|z0NnH*$$ z)qxv0?dw(KLo^IJw+9?oZQ&mg-e_8-mGl=kDJ(3dKzt|w^N~`i z-J3a|PW(@gPVt9^Z9H69&8sq~xoHpjusRX-ua+gYNkg(>(O9WqIL&CNSm%_lpyiE5 z0QywxwXg}m=~6+YupwNep2DohZ0Bbu6bYkl6plEA4K?b#g@9-L$Iy9@6jEx&$V`e z6v&_*@^v6~`qepD;HwL2Y}!W}qbY==XM^qOir9hv(o6(^RCDW!hck{!#?7^eTn&Sh z!N==eEv38Qp#-jQ2d}MTIRVsI*kxB6v(p`obhdhAnOvw}TEvs0TNt30INhINBP4dM zXtdM2Dn6O-Sx;~@?X>iBumQb#jCHMBYb8>_m4P0Dpc*!tNwbS0( z;f>Y7V0_d3J#qm2zbfFZF~KpH_d+-p5Y6Uw>Bc^_$jNf-?uc7w*QI#%>K*jrRuVYQ z=j0Ckt2*xGl}J!u+uPQ-j?!zsQuv1y>-GtSqf6w2u!aZJ zSD}QVcXK(^Nc!8sz6Q}e2c>1 zvoyH*nsAu`RGJ_fkF)HMr)h8uX)WV1UE0036;jfrRQ(fwRY2uwI+lck26*|{YP1f^LSTcqkt=q zc6nX4hGCozdeqBvSw_Rw2*E8XmBlfw!#?#tDI5ysXF86hiyJv6xL9LiuEbztsIOw73Sj*xc6I@59Xz{6#w15rR{t=$0sYcqJ5rN{r6uvLdt(bf_;OVBY@WKYmV{5rR zhjCs6knBGwIXy}0-sj$&o7mk`b}a~o(AhbyT`x|$zL3Xj3r@fi0PboMxF=)uL*O^; z?SK854!L`$+dbx^Yqcb}`GR2dQP|hfz9aDuhyDk6Mr~8XDi-JxkXyo_GrEqazA3)M z+oAa_<6jtfm*TIAWY%>luXPD#1#K+BE#=3Yjw{o=3-G|&ZPYc(dui@i3?UzJeLl5~ zMtWFmKBuxKleyYEc)YlmqNwRudWM)%LmbenhR+N-*CqO%lBAL4I`4sDx_5hc)+zIx z=K{P>#9B4gwY~Mcu#!;=_3Mt}txvde*`L>^{1T7FQh2}iLijq#D4pyC+G{eN6v9Z_ zeef&x$HS5c<%U@Un{`&sI_GKs0P9!dwdH!VPrLlj_Sb;1e%m3zR<*gQQ-6FS&*!V- zj)ez+ziXe4I$T!oYPa`xnv6>7MpUL4jQ;?&>0i;e{18LpO~u{U$1j9;cXr=ug5o`5 z+zcsXk$M67=D*ZeiJm*bdR6Ls(u#-vOHoGpc^}~?j@WOhc(a(%*;JI}^OT(b0O0=s znf)?o(N5RU6=w3t`MvA3ZI-vzlQ|w<{f(ZRPY3iSzl&*{NBL*}0Ks^^1pffSk^caK zseaTN6{K?L`X7pHZTweesJU5PlnI>i!7`a^04+h%zVNT?&H)lJc`!0S#(xUyTN=dF zwbNvtNMnp-mJ5@1rPvyp= z8QeIa$*UPMpoPE0~v?Ax#arqhNYAD zOJ^In0A)z%YnRkKHnz@rDc(ijsNW1J7lu&s2R zX3Fv#lRe33#yKoTD5)En##Ujh_;LJaX>+1#cG2Bgy5&T?fPHJ^ABaB$=1a?U(`=)% zu!AP!2yr6%X1u&b3!auA5o78vfnTym?D_Fe!g_*yL((kmZdw4bOShKD><)5k!#*wl z0Ko~q75J+~xYoQYs@x>oo9xEWZEku3zSZMYqa@F6mMI?#`2PU@2uJ%^_#?u4&xkw` zYZr)Z7CrGrCK72=A9H7|eqng$_8j>2;A_a>*E}Jp>GwG*$}HLAKTuBZv!BH~c4eEvw{Z~=Z@6-K#z^$5_Mfv)kECmPuWg~z?YA!Q$k|0bd8X+Z%Bnr@ zz+bawqh&3nwvVLT>k`dBGCSlVo_AO2_w4)oA+Lq?pZHim5UlN-#|UjY*^cGN;1*sF zde)T})SyaFXiLPZ=X5kLolj@7rMT3J~}VU7hw>wr7g&|zU?<}q_u zI-7gtL{&&f%gfc;VY>+jLzncF5Fl2Ig^sio>&l07MfL?fNO%ZKd!}n*zBLQxf z<44Jq$nuYeWXL+e#rjvNF1&8mRplP;h0ESIkA*gaK{C_ zYxWxmAtSET1MxM>D!q?JG!iYaxKR|6ZI2_SdHU2_V`&+SyPR`bbsL3^NTRWe1sCSr zLhl^o(x=})?|_8D0ppLo^sUKIIxQzj)$Zi-4Yk6I6Ojojzf)bkzku~?&mcgsNdu@k zcE&U9L98eqx#9l+fLflXJf2iD&g_6}T(ai9$HCvSABuG=`+v0Pw-7c1s1TA{w|Z=lG#bsBl4T{FNSVjwUsL#7_B`;^HhNOWX*#R@;Dc)Q^#-zXxzh-r zROmmmr-bxb>9WJ`QL)evb~bu4}q{R!bU3B1a%rPS_Z)I+w(M0K5k^@VoKEK4dY096Jy1UmXKv zit2?qOGJ#PS`q4TzAgQ-J`ea$L~Cs-3p=aXomv-Z0TM9md9Rv2FaH3+Njz~bn{lOR z^LTs7bw)=dFO!eq7_U->Tl~kBiOmvLiSRGPZ`7@jRmRHdoqUN!jNeDXDv8o0NQ4001c zJ?-`Cr1go8KK@ zUT@zq;j!t`xoTrhh|xK1L&TD^JF|`bI#)dYCGv=H#lY>JzSY536LX>kufxv{&u?}#)YYYliDi(KM)cym+W5q_JsNmZ z(=7i0v-HA7pQYH@uHwj6Kbbv&Jk_Y~~q_SjL4<=Q=Wr8 ztI4fe`<=9@TVZz|0`B1EmE NC%AcuR5&F;5yDY-NxxvNnpGj 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

    2. @)28DWrU2cQ&4CYL~TkkRGbPB*O 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

$g4&VcLp8o7QDN+6M*(5qkg-Q;7Bpl`w$ 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�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