From 7c3888361a46ba7ee6ac162ba370fa04c1e59ba2 Mon Sep 17 00:00:00 2001 From: nyama8 Date: Fri, 25 Oct 2024 18:04:49 -0700 Subject: [PATCH 01/24] Base implementation of the qdlscan scan controller --- src/qdlutils/applications/qdlscan/__init__.py | 0 .../qdlscan/application_controller.py | 257 ++++++++++++++++++ .../applications/qdlscan/application_gui.py | 0 .../qdlscan/config_files/__init__.py | 0 src/qdlutils/applications/qdlscan/main.py | 53 ++++ src/qdlutils/applications/qdlscan/test.ipynb | 33 +++ 6 files changed, 343 insertions(+) create mode 100644 src/qdlutils/applications/qdlscan/__init__.py create mode 100644 src/qdlutils/applications/qdlscan/application_controller.py create mode 100644 src/qdlutils/applications/qdlscan/application_gui.py create mode 100644 src/qdlutils/applications/qdlscan/config_files/__init__.py create mode 100644 src/qdlutils/applications/qdlscan/main.py create mode 100644 src/qdlutils/applications/qdlscan/test.ipynb diff --git a/src/qdlutils/applications/qdlscan/__init__.py b/src/qdlutils/applications/qdlscan/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/qdlutils/applications/qdlscan/application_controller.py b/src/qdlutils/applications/qdlscan/application_controller.py new file mode 100644 index 0000000..ccdd595 --- /dev/null +++ b/src/qdlutils/applications/qdlscan/application_controller.py @@ -0,0 +1,257 @@ +import logging +import time + +import numpy as np + +from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter +from qdlutils.hardware.nidaq.analogoutputs.nidaqposition import NidaqPositionController + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +class ScanController: + ''' + This is the main class which coordinates the scaning and collection of data. + ''' + + def __init__(self, + x_axis_controller: NidaqPositionController, + y_axis_controller: NidaqPositionController, + z_axis_controller: NidaqPositionController, + counter_controller: NidaqTimedRateCounter): + + self.x_axis_controller = x_axis_controller + self.y_axis_controller = y_axis_controller + self.z_axis_controller = z_axis_controller + self.counter_controller = counter_controller + + # On initialization move all position controllers to zero. + # WARNING: it is assumed that the zero is a valid position of the DAQ + try: + # Set the positions to zero + pass + except Exception as e: + logger.warning(f'Could not set axes to zero: {e}') + + + # This is a flag to keep track of if the controller is currently busy + # Must turn on whenever a scan is being performed and remain on until + # the scanner is free to perform another operation. + # The external applications are required to flag this when in use. + + # TODO: Logic here is probably not right.... + self.busy = False + + # This is a flag to keep track of if a scan is currently in progress + # Must turn on whenever a scan is actively running (via the class + # method `self.scan_axis()`). + # Use this flag to tell the controller to stop in the middle of a scan + self.scanning = False + + # This is a flag set by external applications to request the application + # controller to stop scanning. + self.stop_scan = False + + def set_axis(self, axis: str, position: float): + ''' + Outward facing method for moving the position of an axis specified + by a string `axis`. + ''' + # Block action if busy + if self.busy: + raise RuntimeError('Application controller is currently in use.') + # Reserve the controller + self.busy = True + + # Get the axis controller depending on which axis is requested + if axis == 'x': + axis_controller = self.x_axis_controller + elif axis == 'y': + axis_controller = self.y_axis_controller + elif axis == 'z': + axis_controller = self.z_axis_controller + else: + raise ValueError(f'Requested axis {axis} is invalid.') + + # Call the internal movement function + try: + self._set_axis(axis_controller=axis_controller, position=position) + except Exception as e: + logger.warning(f'Movement of axis {axis} failed due to exception: {e}') + # Free up the controller + self.busy = False + + + + def _set_axis(self, axis_controller: NidaqPositionController, position: float): + ''' + Internal function for moving the axis controlled by the given controller. + This avoids logic required to determine which axis is to be moved, for example + in the case of scans where only one axis is used repeatedly. + ''' + # Try to move the axis + axis_controller.go_to_position(position=position) + + def scan_axis(self, + axis: str, + start: float, + stop: float, + n_pixels: int, + scan_time: float): + ''' + Outward facing scan function. + Scans the designated axis between the `start` and `stop` positions in + `n_pixels` over `scan_time` seconds. Returns the counts at each pixel + not normalized to time. + ''' + # Block action if busy + if self.busy: + raise RuntimeError('Application controller is currently in use.') + # Block the controller from additional external commands + self.busy=True + + # Get the axis controller depending on which axis is requested + if axis == 'x': + axis_controller = self.x_axis_controller + elif axis == 'y': + axis_controller = self.y_axis_controller + elif axis == 'z': + axis_controller = self.z_axis_controller + else: + raise ValueError(f'Requested axis {axis} is invalid.') + + data = self._scan_axis(axis_controller=axis_controller, + start=start, + stop=stop, + n_pixels=n_pixels, + scan_time=scan_time) + + # Free up the controller + self.busy = False + return data + + + def _scan_axis(self, + axis_controller: str, + start: float, + stop: float, + n_pixels: int, + scan_time: float): + ''' + Internal scanning function + ''' + # Set the scanning flag + self.scanning = True + + # Calculate the time per pixel + sample_time = scan_time / n_pixels + # Configure the counter controller + self.counter_controller.configure_sample_time(sample_time=sample_time) + + # Generate the positions to scan according to the usual + # numpy.linspace implementation. + # Note that this means that `stop` > `start` is technically valid and + # will scan from large to small, however the output datastream will be + # ordered accordingly and thus resulting images might be flipped. + # It is on the calling functions to manage these nuances. + positions = np.linspace(start=start, stop=stop, num=n_pixels) + + # Create a buffer for the data + output = np.zeros(shape=n_pixels) + + # Then iterate through the positions + for index, position in enumerate(positions): + # Move to the desired position + self._set_axis(axis_controller=axis_controller, position=position) + # Get the counts + counts = self.counter_controller.sample_batch_counts() + # Store in the buffer + output[index] = counts + + # Set the scanning flag + self.scanning = False + + # Return the buffered output + return output + + + + def scan_image(self, + axis_1: str, + start_1: float, + stop_1: float, + n_pixels_1: int, + axis_2: str, + start_2: float, + stop_2: float, + n_pixels_2: int, + scan_time: float): + ''' + This is an experimental implementation of the scanning function using the + `yield` keyword in Python. The method implements a generator which can be + queried like + + >>> for line in scan_image(**kwargs): # do stuff with line + + where each line is one scan along the `axis_1` defined by the start, stop, + and number of pixels. For each line the `axis_2` is moved to the next + pixels also defined by its start, stop, and step size. The speed of a scan + over each axis is determined by the scan time. + ''' + + # Block action if busy + if self.busy: + raise RuntimeError('Application controller is currently in use.') + # Reserve the controller + self.busy = True + + # Get the axis controller depending on which axis is requested + if axis_2 == 'x': + axis_controller_2 = self.x_axis_controller + elif axis_2 == 'y': + axis_controller_2 = self.y_axis_controller + elif axis_2 == 'z': + axis_controller_2 = self.z_axis_controller + else: + raise ValueError(f'Requested axis_2 {axis_2} is invalid.') + + # Get the positions for the slow scan axis + positions_2 = np.linspace(start=start_2, stop=stop_2, num=n_pixels_2) + + # Then iterate through the positions + for index, position in enumerate(positions_2): + # Move axis 2 to the desired position + self._set_axis(axis_controller=axis_controller_2, position=position) + # Scan axis 1 + single_scan = self.scan_axis(axis=axis_1, + start=stop_1, + stop=stop_1, + n_pixels=n_pixels_1, + scan_time=scan_time) + # Update the buffer + #output[index] = single_scan + + # Yield a single scan + yield single_scan + + # If the stop is requested then terminate + if self.stop_scan: + logger.info('Stopping scan.') + self.stop() + + self.busy = False + + + def stop(self) -> None: + ''' + Stop running scan + ''' + self.scanning = False + # Stop the DAQ + self.counter_controller.stop() + logger.info(f'Stopping counter task on DAQ.') + # Free up the controller + self.busy = False + # Reset the stop scan flag + self.stop_scan = False \ No newline at end of file diff --git a/src/qdlutils/applications/qdlscan/application_gui.py b/src/qdlutils/applications/qdlscan/application_gui.py new file mode 100644 index 0000000..e69de29 diff --git a/src/qdlutils/applications/qdlscan/config_files/__init__.py b/src/qdlutils/applications/qdlscan/config_files/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/qdlutils/applications/qdlscan/main.py b/src/qdlutils/applications/qdlscan/main.py new file mode 100644 index 0000000..e0e7586 --- /dev/null +++ b/src/qdlutils/applications/qdlscan/main.py @@ -0,0 +1,53 @@ +import importlib +import importlib.resources +import logging + +import tkinter as tk +import yaml + +from qdlutils.hardware.nidaq.analogoutputs.nidaqposition import NidaqPositionController +from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter + +logger = logging.getLogger(__name__) +logging.basicConfig() + + +CONFIG_PATH = 'qdlutils.applications.qdlscan.config_files' +DEFAULT_CONFIG_FILE = 'qdlscan_base.yaml' + + +class LauncherApplication(): + ''' + This is the launcher class for the `qdlscan` application which handles the creation + of child scan applications which themselves handle the main scanning. + + The purpose of this class is to provde a means of configuring the scan proprties, + control the DAQ outputs and launching the scans themselves. + ''' + + def __init__(self, default_config_filename: str): + + pass + + +class LineScanApplication(): + ''' + This is the line scan application class for `qdlscan` which manages the actual + application controllers and GUI output of a single scan. It is meant to handle + 1-d confocal scans. + ''' + + def __init__(self, default_config_filename: str): + + pass + +class ImageScanApplication(): + ''' + This is the image scan application class for `qdlscan` which manages the actual + application controllers and GUI output of a single scan. It is meant to handle + 2-d confocal scans. + ''' + + def __init__(self, default_config_filename: str): + + pass diff --git a/src/qdlutils/applications/qdlscan/test.ipynb b/src/qdlutils/applications/qdlscan/test.ipynb new file mode 100644 index 0000000..756c0ac --- /dev/null +++ b/src/qdlutils/applications/qdlscan/test.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qdlutils.applications.qdlscan.application_controller import ScanController" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qdlutils", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.9.20" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 666e9e5ebdbfc43f87d04a5903ebc518a99b5063 Mon Sep 17 00:00:00 2001 From: nsyama Date: Fri, 25 Oct 2024 19:09:14 -0700 Subject: [PATCH 02/24] Tested and bugfixed application controller --- .../qdlscan/application_controller.py | 37 +- src/qdlutils/applications/qdlscan/test.ipynb | 333 +++++++++++++++++- .../nidaq/counters/nidaqbatchedratecounter.py | 2 +- .../nidaq/counters/nidaqtimedratecounter.py | 16 +- 4 files changed, 369 insertions(+), 19 deletions(-) diff --git a/src/qdlutils/applications/qdlscan/application_controller.py b/src/qdlutils/applications/qdlscan/application_controller.py index ccdd595..ae488e0 100644 --- a/src/qdlutils/applications/qdlscan/application_controller.py +++ b/src/qdlutils/applications/qdlscan/application_controller.py @@ -19,12 +19,14 @@ def __init__(self, x_axis_controller: NidaqPositionController, y_axis_controller: NidaqPositionController, z_axis_controller: NidaqPositionController, - counter_controller: NidaqTimedRateCounter): + counter_controller: NidaqTimedRateCounter, + inter_scan_settle_time: float=0.01): self.x_axis_controller = x_axis_controller self.y_axis_controller = y_axis_controller self.z_axis_controller = z_axis_controller self.counter_controller = counter_controller + self.inter_scan_settle_time = inter_scan_settle_time # On initialization move all position controllers to zero. # WARNING: it is assumed that the zero is a valid position of the DAQ @@ -90,7 +92,8 @@ def _set_axis(self, axis_controller: NidaqPositionController, position: float): This avoids logic required to determine which axis is to be moved, for example in the case of scans where only one axis is used repeatedly. ''' - # Try to move the axis + logger.debug(f'Attempting to move to position {position}.') + # Move the axis axis_controller.go_to_position(position=position) def scan_axis(self, @@ -110,6 +113,9 @@ def scan_axis(self, raise RuntimeError('Application controller is currently in use.') # Block the controller from additional external commands self.busy=True + # Start the counter + logger.info('Starting counter task on DAQ.') + self.counter_controller.start() # Get the axis controller depending on which axis is requested if axis == 'x': @@ -129,6 +135,7 @@ def scan_axis(self, # Free up the controller self.busy = False + self.stop() return data @@ -205,7 +212,17 @@ def scan_image(self, raise RuntimeError('Application controller is currently in use.') # Reserve the controller self.busy = True + + # Get the axis controller depending on which axis is requested + if axis_1 == 'x': + axis_controller_1 = self.x_axis_controller + elif axis_1 == 'y': + axis_controller_1 = self.y_axis_controller + elif axis_1 == 'z': + axis_controller_1 = self.z_axis_controller + else: + raise ValueError(f'Requested axis_1 {axis_1} is invalid.') # Get the axis controller depending on which axis is requested if axis_2 == 'x': axis_controller_2 = self.x_axis_controller @@ -216,6 +233,10 @@ def scan_image(self, else: raise ValueError(f'Requested axis_2 {axis_2} is invalid.') + # Start the counter + logger.info('Starting counter task on DAQ.') + self.counter_controller.start() + # Get the positions for the slow scan axis positions_2 = np.linspace(start=start_2, stop=stop_2, num=n_pixels_2) @@ -223,12 +244,14 @@ def scan_image(self, for index, position in enumerate(positions_2): # Move axis 2 to the desired position self._set_axis(axis_controller=axis_controller_2, position=position) + # Let the axis settle before next scan + time.sleep(self.inter_scan_settle_time) # Scan axis 1 - single_scan = self.scan_axis(axis=axis_1, - start=stop_1, - stop=stop_1, - n_pixels=n_pixels_1, - scan_time=scan_time) + single_scan = self._scan_axis(axis_controller=axis_controller_1, + start=start_1, + stop=stop_1, + n_pixels=n_pixels_1, + scan_time=scan_time) # Update the buffer #output[index] = single_scan diff --git a/src/qdlutils/applications/qdlscan/test.ipynb b/src/qdlutils/applications/qdlscan/test.ipynb index 756c0ac..a7fc1d4 100644 --- a/src/qdlutils/applications/qdlscan/test.ipynb +++ b/src/qdlutils/applications/qdlscan/test.ipynb @@ -2,11 +2,330 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from qdlutils.applications.qdlscan.application_controller import ScanController\n", + "from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter\n", + "from qdlutils.hardware.nidaq.analogoutputs.nidaqposition import NidaqPositionController\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "rate_counter = NidaqTimedRateCounter(\n", + " daq_name = 'Dev1',\n", + " signal_terminal = 'PFI0',\n", + " clock_rate = 100000,\n", + " sample_time_in_seconds = 1,\n", + " clock_terminal = None,\n", + " read_write_timeout = 10,\n", + " signal_counter = 'ctr2',\n", + " trigger_terminal = None)\n", + "\n", + "x_control = NidaqPositionController( \n", + " device_name = 'Dev1',\n", + " write_channel= 'ao0',\n", + " read_channel = None,\n", + " move_settle_time = 0.0,\n", + " scale_microns_per_volt = 8,\n", + " zero_microns_volt_offset = 5,\n", + " min_position = -40.0,\n", + " max_position = 40.0,\n", + " invert_axis = False)\n", + "\n", + "y_control = NidaqPositionController( \n", + " device_name = 'Dev1',\n", + " write_channel= 'ao1',\n", + " read_channel = None,\n", + " move_settle_time = 0.0,\n", + " scale_microns_per_volt = 8,\n", + " zero_microns_volt_offset = 5,\n", + " min_position = -40.0,\n", + " max_position = 40.0,\n", + " invert_axis = False)\n", + "\n", + "z_control = NidaqPositionController( \n", + " device_name = 'Dev1',\n", + " write_channel= 'ao2',\n", + " read_channel = None,\n", + " move_settle_time = 0.0,\n", + " scale_microns_per_volt = 8,\n", + " zero_microns_volt_offset = 5,\n", + " min_position = -40.0,\n", + " max_position = 40.0,\n", + " invert_axis = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "scan_controller = ScanController(\n", + " x_axis_controller = x_control,\n", + " y_axis_controller = y_control,\n", + " z_axis_controller = z_control,\n", + " counter_controller = rate_counter)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "scan_controller.set_axis(axis='z', position=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qdlutils.applications.qdlscan.application_controller:Starting counter task on DAQ.\n", + "INFO:qdlutils.applications.qdlscan.application_controller:Stopping counter task on DAQ.\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACfQklEQVR4nO29eZxcZZn2f51ae+9Od9Lp7BC2JCwhBoQAIkuGVQRhHJ0fOiAo40yiAvM6io7LjOPEcX0d3wjjO0h8BxmUGXYVRQgBJGGJBAhCSCCQkKQ7S6f37lqf3x9Vz3OeOnX2c6rqnKr7+/nko3RXOqe6qs65z3Vf93UrjDEGgiAIgiCIABGp9QEQBEEQBEFooQKFIAiCIIjAQQUKQRAEQRCBgwoUgiAIgiACBxUoBEEQBEEEDipQCIIgCIIIHFSgEARBEAQROKhAIQiCIAgicMRqfQBuyOfz2Lt3L9rb26EoSq0PhyAIgiAIGzDGMDo6itmzZyMSMddIQlmg7N27F/Pmzav1YRAEQRAE4YLdu3dj7ty5po8JZYHS3t4OoPAEOzo6anw0BEEQBEHYYWRkBPPmzRPXcTNCWaDwtk5HRwcVKARBEAQRMuzYM8gkSxAEQRBE4KAChSAIgiCIwEEFCkEQBEEQgYMKFIIgCIIgAoejAmXNmjU49dRT0d7ejt7eXlxxxRXYtm2b+P7g4CA+85nP4LjjjkNzczPmz5+Pz372sxgeHi75Obt27cKll16KlpYW9Pb24vOf/zyy2aw/z4ggCIIgiNDjqEDZsGEDVq1ahU2bNuHRRx9FJpPBBRdcgPHxcQCFfJK9e/fiu9/9LrZu3Yp169bhkUcewfXXXy9+Ri6Xw6WXXop0Oo1nnnkGP/vZz7Bu3Tp89atf9feZEQRBEAQRWhTGGHP7lw8cOIDe3l5s2LABZ599tu5j7rnnHnzsYx/D+Pg4YrEYfvOb3+ADH/gA9u7di5kzZwIAbrvtNnzhC1/AgQMHkEgkLP/dkZERdHZ2Ynh4mMaMCYIgCCIkOLl+e/Kg8NZNd3e36WM6OjoQixUiVzZu3IgTTzxRFCcAcOGFF2JkZASvvvqq7s9IpVIYGRkp+UMQBEEQRP3iukDJ5/O48cYbceaZZ+KEE07QfczBgwfxjW98AzfccIP4Wn9/f0lxAkD8d39/v+7PWbNmDTo7O8UfirknCIIgiPrGdYGyatUqbN26FXfffbfu90dGRnDppZdiyZIl+PrXv+72nwEA3HLLLRgeHhZ/du/e7ennEQRBEAQRbFxF3a9evRoPP/wwnnzySd1lP6Ojo7jooovQ3t6O++67D/F4XHyvr68Pzz33XMnjBwYGxPf0SCaTSCaTbg6VIAiCIIgQ4khBYYxh9erVuO+++/D444/jyCOPLHvMyMgILrjgAiQSCTz44INoamoq+f6KFSvwyiuvYP/+/eJrjz76KDo6OrBkyRKXT4MgCIIgiHrCkYKyatUq3HXXXXjggQfQ3t4uPCOdnZ1obm4WxcnExATuvPPOEkPrjBkzEI1GccEFF2DJkiX4+Mc/jm9/+9vo7+/HP/zDP2DVqlWkkhAEQQSMp7cfxN7hSfzFKeT9I6qLozFjo+2Dd9xxB6699lo88cQTOPfcc3Ufs3PnThxxxBEAgHfeeQd/8zd/gyeeeAKtra245ppr8K1vfUtM+lhBY8YEQRDV4bR/+T0GRlJ45ovnYXZXc60Phwg5Tq7fjhQUq1rmnHPOsXwMACxYsAC//vWvnfzTBEEQRA0YmsgAAIYnM1SgEFWFdvEQBEEQujDGkM7lAQDpbL7GR0M0GlSgEARBELpk8wxcFE9RgUJUGSpQCIIgCF1k1SSVzdXwSIhGhAoUgiAIQhe5QKEWD1FtqEAhCIIgdOH+E4BaPET1oQKFIAiC0CWVIQWFqB1UoBAEQRC6pHOq74Q8KES1oQKFIAiC0CWVpRYPUTuoQCEIgiB0IZNsY/LI1n6c8s+P4rP/9WJNj4MKFIIgCEKXNCkoDcnwZBoHx9IYT2VrehxUoBAEQRC60BRPYzKWKviNWpOOtuH4DhUoBEEQhC4U1NaYcOWEChSCIAgikJQUKBlSUBoFXqC0JaM1PQ4qUAiCIAhd5BaP/P+J+maMFBSCIAgiyKRIQWlIVAWFChSCIAgigJSMGZOC0jCQSZYgCIIINKUeFDLJNgpkkiUIgiACDY0ZNybjaTLJEgRBEAGGkmQbE2GSTZCCQhAEQQQQykFpTKjFQxAEQQQaavE0JuNFkyxN8RAEQRCBhFo8jUc+z4QHhRQUgiAIIpCkaFlgwzGRyYGxwv8nBYUgCIIIJKSgNB7cfxJRgKZ4bUsEKlCqxPaBUXzgR0/h938aqPWhEFXk/zy+HX/5k02YogwJIoSUelDoPdwIyDH3iqLU9FioQKkSv321H1v3jOChl/fW+lCIKnLXs7uw8a1D+NO+kVofCkE4Ji0VJdTiaQyCEnMPUIFSNQ6OpQEAGYqLbigy+UIzN0MndyKEUIun8QjKokCACpSqcWAsBQBIZ1mNj4SoJtliQZrJ0etOhA+5xZPNM+Ty9D6ud8YDsocHoAKlahwcLRQo2TzdhTQS2WJhQsoZEUa0qgmpKPWP2uKpbcw9QAVK1ThYVFDoQtVYZIoFKW2CJcKItiAho2z9M0YelMbj0Dj3oJBE2khwSZwKUyKMaI2xZJStf4IScw9QgVIVMrk8hiYy4v8TjQFjTBSk9LoTYUSr/FGLp/6hKZ4G41BxggdQPQlE/SMbCkk5I8IItXgajzEyyTYW3H8C0J10I5EtKVDodSfCR3mBQu/jeocUlAbjABUoDUlJgUIn9lCTzeWxe3Ci1odRdbQtHipQ6p8xvigwQVM8DQEfMQZI6m8kstLJnV73cPO1B1/F+769Hs++dajWh1JVuIKSiBUuFakMFSj1DplkGww+wQOUXrSI+kYuSmjMONxs3z8GAHjmzcYsUDqaChcreh/XP9TiaTBkBSVNd9INQ448KHXDRFH2fr2/cXYq5fNMtCn5xSpFSy/rHjLJNhiySZaSZBuHTEmLh173MDORLpy0X+8frfGRVA9ZLWlvigMgD0ojQC2eBuOgNGZMZsnGIUtjxnXDZLFA2TU4IU7g9Y5cjHAFhXJQ6h9q8TQYJWPGtGyrYchJahmd2MMNP2kzBrwx0Bgqivye5XfTpKDUP+o2Y5riaQhKWjwk9TcMsmpCLZ5wMyl5LxqlzcNbPIlYBMl44VKRpqC2uiaby4siNHQKypo1a3Dqqaeivb0dvb29uOKKK7Bt27aSx/zkJz/BOeecg46ODiiKgqGhobKfMzg4iKuvvhodHR3o6urC9ddfj7GxMU9PJKjk8gyD0hRPnoFWljcIWSpQ6oJ0Nl9SbG5rlAKleKFKRiNI8jFjUlDqmvGUWoCGzoOyYcMGrFq1Cps2bcKjjz6KTCaDCy64AOPj4+IxExMTuOiii/ClL33J8OdcffXVePXVV/Hoo4/i4YcfxpNPPokbbrjB/bMIMIcn0tDWI3SxagwyecpBqQe4/4Tz2r7GmOSRM1CoQGkMRlOFnXGJWATxaO0bLI5KpEceeaTkv9etW4fe3l5s3rwZZ599NgDgxhtvBAA88cQTuj/jtddewyOPPILnn38ep5xyCgDgRz/6ES655BJ897vfxezZsx0+hWDD2zutiSjGiye6TC6Ppnjt+3tEZZGVMsqPCC8TmVJT7Ov9o2CMQVGUGh1RdeB7dwoFSuF8RV6q+oYrKEFo7wAePSjDw8MAgO7ubtt/Z+PGjejq6hLFCQCsXLkSkUgEzz77rO7fSaVSGBkZKfkTFg6OFto7s7qaxddoYWBjUDJmTCf20MJP2s3xKKIRBcOTGQyMpCz+VvjRV1DIg1LPBMkgC3goUPL5PG688UaceeaZOOGEE2z/vf7+fvT29pZ8LRaLobu7G/39/bp/Z82aNejs7BR/5s2b5/awqw5XUHrbk4gUb7ioxdMYkAelPuAtnq6WOBZObwUAvNYAgW2iQIlGRNQ9KSj1jchASYRcQVm1ahW2bt2Ku+++28/j0eWWW27B8PCw+LN79+6K/5t+wQuUnrYkYsWeHo0aNwZZ8qDUBePFFNnmRBSLZnUAAF7fV/9G2VSOPCiNRpAyUACHHhTO6tWrhbl17ty5jv5uX18f9u/fX/K1bDaLwcFB9PX16f6dZDKJZDLp5lBrDg9pm96WQCIaKUwE0Ie8IcjSLp66gCsoLYkoFvW146GXgG2NpKBIHhQqUOqbsQClyAIOFRTGGFavXo377rsPjz/+OI488kjH/+CKFSswNDSEzZs3i689/vjjyOfzOO200xz/vKDDFZTpbUnEooUeD8XdNwZZ2sVTF3AFpSURw6K+dgCNkYVCLZ7GI9QKyqpVq3DXXXfhgQceQHt7u/CMdHZ2orm5YALt7+9Hf38/duzYAQB45ZVX0N7ejvnz56O7uxuLFy/GRRddhE996lO47bbbkMlksHr1anz0ox+tuwkeQC1QZrQlxdhWOktyfyNAu3jqgwlZQSm2eHbsH0M6mxcXbjswxrB7cBLzupurNgE0NJGGAgWdLXHHf5dMso0HnzQNSoHiSEG59dZbMTw8jHPOOQezZs0Sf37xi1+Ix9x2221YtmwZPvWpTwEAzj77bCxbtgwPPvigeMzPf/5zLFq0COeffz4uueQSnHXWWfjJT37i01MKFkJBaU8gHiEFpZEo2WZMRWlo4S2e1kQMszub0N4UQzbP8NZBZ+GS//7kWzj7O+vxwJa9lTjMMjK5PFZ+/0lc/MMnkXfhe+NtyWRMVVCoxVPfBK3F4+goGLN+k3/961/H17/+ddPHdHd346677nLyT4cWPmY8vS2JePFDTnfTjQFN8dQHsklWURQs6mvH828fxuv7RrGor8P2z9k+UChoXts3giuWzanIscoMTWTEDdJUNocWh5MZ5EFpPNQWT8jHjAlrGGM4NC5N8RQVFJroaAxKkmRJNQstqoJSOGnzosTpqPFUsT0yNJHx8eiMkRNw3XhHZA8KTfE0BkFTUKhAqSDDkxlRjPS0JoQHhe6mG4MSBYVaPKFFBLUVFYjjikZZpzt5UsWFg0OTaYtH+oOcgOuqQJHGjMkk2xiMU4HSOPAR4/amGJriUVGgUJJsY0BTPPXBZIZP8RQUlMWzipM8DrNQpjKF90AtFBQ3ykeKTLINR11F3RPmyBM8ABAvjhlTJkZjkJVeZ3rNw4s8xQMAx84sFCj9I1MYmrCvhkxlatjicfH+U1s8UdUkm6H3cT1DLZ4GQs5AASCSZElBaQxIQakP+F0lN5m2N8Uxd1ohVsFJHorwoFSpxTOZ8cmDIi8LpPdxXTNeL7t4CGsOjqojxkDBbAbQxapRKJ3ioaI0rPAWj3zS5kbZ1/fZN8pWu8Uz4dUkm5O2Gce5gkItnnomaEFtVKBUEO5B6WnlCgqf4qECpRGQ825yeVaSi0KEB3mbMUf4UBwoKLzlksrmRbunkpQoKB5aPMlYRNxckYJS31CLp4HQtnjUKR66UDUC2teZCtNwou7iUU/ax7mIvJcNpocdeFfc4teYcVJWULJ5W3lYRPhgjIU7SZZwhlgUWGzxxGkXT0OR1RQkVKCEEz6u26LT4tnWP2o7pXVKMphWo83j2YMibzOOFp47Y3SDVa+ksnmh8pKC0gCUmWQjlCXQSGTzWgWFTuxhZCJVOsUDAEf0tCAZi2Ayk8OuwQlbP0du61SjQJnwOGZcEtQWVy8V1OapT3h7BwBa4mSSrXuMWjzaCxdRn2iVMlJQwsmEtIuHE4tGcMzMNgD22jzZXL7kcz9chUmeKY8eFDkHhXtQADLK1itjU0X/SSKKSKQ6yyytoAKlQjDGpAJF0+KhC1VDoB0nJ+UsfOTzTLRKmhOld5ViksdG5P2U5rU/XBUFxWOSrFSgRCIK5TjVOUEzyAJUoFSM8XRO9Jy1CkqapP6GgEyy4Uf2cbRqlu0tchB5r53aqYoHJS0FBXrxoBTPW2JhIIW11SVBGzEGqECpGDwDpTkeFRVpjBSUhiJX1uKhwjRs8E3GigI0xUtPl6qC4qJAqUKLZ7JkF4/ztoysoACghYF1Dn+vk4LSAPAtxnyCB6CgtkYjU2aSpdc9bPBR3eZ4FIpS2pdfVMxCefvQuGWuSVmBMl4NBcWnqPtiYUILA+ubsaIZPCgpsgAVKBXjwGhxxLjY3gHkoDa6k24EtEoZ9e7Dx4ROBgqnpzWBiFIYvR2ZNC84pjRtkWooKCVTPC7aMvz9mixTUMgkW49Qi6eB0E7wAHJQG12oGgFtcmyG7jxDBzeatiTK7yoVRRHpspNOFZQqeFC8TvHIywIBUlDqnXEyyTYO2gkeQBozJgWlISg3ydLrHja0m4y1NBeVFesCpfSiPmyhuPiB5108ZR6UokmWCpS6hKZ4Ggh9BYV28TQSlIMSfsZ1QtpkmhOFU6js99CDqxn8HFCNqHvfgtqoxdMQcAWlnQqU+uegngelmCSrNU8S9YlWMWkkDwpjDH9z52Z8+b5Xan0onuCTMHoeFEBdIGhZoBQv6r3tTQDC0eJJ5fRNsqSg1CeqSZYKlLpHTPHICkrxA05ehMagzIPSQAXKnqFJ/GZrP37+7K5QP2/LFo9tD0rhdzCrs1CgVGOjsZcWD2OsJOoeoDHjeoc8KA2EWBQoe1AitCywkWjkZYGHpTHacWnHR9jQ28Mj02SzQOHf72lLIFY8D1RSRWGMeVoWKKt/NGbcGKhTPDRmXPfwoLbp7eVTPJQk2xjwk3w00njj5bLHYnQqxAUKV1AM7ip5/L1Vi4fvr2mKR9HVEgdQWR+K1pTrtKiQW0JJMsk2BGSSbRCmMjmMFl/s6a3lOSiUJNsY8BYP3wzaUApK3RQoRQ+KwXZX3uKxG9TWFIuis7lQoFRSQdEqOk49KHJBU97iIZNsPUJJsg0Cn+BJRCPoaFZfbEqSbSwyxVYev8tuJO/R4XG1QBkLc4vHcszYmQelORFFV0uh7VvJjcbyokDAhYJSfHwsoojNttTiqW/4xBoFtdU53H/S05YoiceOiQKlcaT+Robn3YgCpYFe90FJHRidqvzESqWwbPGIKR7zizZXUJLxCKa1VF5B0So6bgsUXpQA1OKpd0SLx2BirRZQgVIBDulkoACUg9Jo8FYev4g10phx/SgoxkmygPraTmTMnyMfMy60eAoKyuEKFigTGk9MymmLJ1f4+3KBIsaMaZtxXUJR9w2CXoosQEmyjUaWe1ASje1BGQm1B8V4Fw+gqmNTlkFthddeNslWch+P1rTrVEFJaUaMAdWDwosXon7I55l4r9OywDpHbfFoFRTyoDQSvEBpbvACZSzUBYq5gmJ3zFiYZOMRdBVNssOVVFDKWjzOigrdFk+cFJR6ZVzyLJFJts45MKrf4hHbjCkHpSHIiBZPrPjfjaOcyTkoY6k68KBYBrXZ86A0xaPoauUtngqOGRePm2euuJ3iKWnxiJgEOn9Vm4l0FvtHpir287lBNhZRhFIWBIJzJHWEUYtHTPFkG+dC1cjkNC2eRpp+qJ8xY3stHutdPLzFoyoolTTJ8uPmI82+tHiKxRgpKNXnY//xLN737fXi2uI3cgaKPNhRa6hAqQD8TTSjXV9BoSTZxoB7jRrdg1LPLR7+dbs5KM2SB6WSG415y6mzxV2Bwh8v300no5SDUite2zeKVDaPNwZGK/LzxwJokAWoQKkIasy9vgelke6kGxneymtqsKC2yXSuJMm0Pkyy5h4Ube6IFj7Fk4xH0VWc4qloUFvxuLtcKijpnLEHhVo81SWdzYuCk9sH/EbdwxMcgyxABUpFMBwzLm4zztI247onl2dgxZe50XJQBjXeirB6UBhj1i0e2x6UYrEaq07UfVmLxwcPSpLGjGuCrLRVqkAJYsw9QAWK72RyeZFv0KPxoKhR941xoWpk5DZeS4PloMgZKEB4PSjpXF71ERncWTY7bPE0xSOiQKnkRmN+x81TazM5hryDGyPtJmNASpJtkPdxUJALlP0VVlCC1uIJ1tGEjLXrd+D/bXxb3CkDAD8HRBRgWot+Dko6lwdjLFBmJMJf5CK00aLutcpAWIPa+CZjwHoXj32TbBRtyRiiEQW5PMPQRAZ9nf7L6pPFlhNXUIDCeacpYu/fSum1eGJkkq0FJQVKhSZ5xgOYIgtQgeKJu57dhYER/Yr2pLldYosthyfJAoUWQCxKBUq9olugNMidJ1cQu1sTGBxPh9Yky7NEEtGIWFOhxXkOShSKoqCrOY5D42kMTabR19nk41Gj5HjKChSDQkuL2uJRH0/LAmuDvLOpUgrKWIqHtAWrJAjW0YSMkeKOkZ98fDnmTGsu+d7RvW1lj49LJ7lMjiEWLD8S4SNy1k1Lg3lQeItnXncLBsfToW3xcBXCqL0DOFkWqLZ4AKCrpVCgyHkxfsI9KB1ygeJAwTNt8TSIEhgUqtviCdZFiQoUl+TzTEjXJ8/vQm+79V2QrJhk8nk0I1hvBsI/uHchGlGQiDaYB6XY4pnf3YKXdg8hncsjlc2JFkFY4OFVRu0d+XvpbMGvolVNgcJOJpEqXHx8wRsyXrGNxrwgaklEkYhGkM7l3RUotCyw5siJw5Vq8Ygx46ZglQRkknXJRCYnvCcdTXHzBxfhUzxA4/gRGhXezolGlIZbEskVlLmSqhhGFcVqkzGgKiiAsYoyJX3WeYul0mFt8ni0G+WD79tJ6iwLJAWlugxPqp+dkalsRYzV4zTFU1/wvrqTaOBIRBF3WDRqXN9wD0o8oiAea6wdTIN8iq01IaYCwuhDsQppA0ov4EZGWfmCwh/fKRYGVqZAmZQ8L26mb0zHjH0sUH7zyj48vf2gbz+vHtEG+lVi1Jjv4gnaFA8VKC4ZLfpP2pqcRQPzu2m6C6lveAEai0YabsXBULHFM61FLVBCraCYFCiKooi2jdGdLf96MhYR5wo+4VepLJTJdGmLB/DuQUlKhY6TkWUjDo2lsOquP+K6dc+XjaYTKtoCZf+o/20eYZIN2BQPFSguGS1KYu0Oe3YU1tYY8ByUeFRpuC3Wg8WLTXdrQnw+RkMY1qYqKOafcSujrDxizKn0RuNJKVo/4UL50EuSlf+/H36q/aMp5FnhZ/3qlX2ef169UhUFpR5aPGvWrMGpp56K9vZ29Pb24oorrsC2bdtKHjM1NYVVq1ahp6cHbW1tuOqqqzAwMFDymF27duHSSy9FS0sLent78fnPfx7ZbLjusPgdYVvSnv+E02hyf6PCWzyyB6VRTLLcVzGtNSFMd+Fs8RQv8iYKCmCdhaKd4AEgwtoq7UFpdulBSZmYZOXve0G+8D6wZY/nn1evjBR/T9weUIlJnqAGtTkqUDZs2IBVq1Zh06ZNePTRR5HJZHDBBRdgfHxcPOamm27CQw89hHvuuQcbNmzA3r17ceWVV4rv53I5XHrppUin03jmmWfws5/9DOvWrcNXv/pV/55VFeAnXKcKCl9/TgVKfcNf31gkIhSURkkQ5grKtJY42osG8jC3eFotChReeBgrKKofhNNZbPEMVWqKJ60qKEkvHhSpxSPnOPmRhSIXKM+/fRi7Byc8/8x6hP+eFvS0AAD2G2RveWGsHnbxPPLII7j22mtx/PHHY+nSpVi3bh127dqFzZs3AwCGh4dx++234/vf/z7OO+88LF++HHfccQeeeeYZbNq0CQDwu9/9Dn/6059w55134uSTT8bFF1+Mb3zjG1i7di3S6fD0Ifl+kXaHFacq9zfGxcoN+4YnKxYBXi34mHE8qoi70EYoSqcyOXGhntaaEJ+PMKbJ2m3x8O9btngkBWJaBRUUxpgImWtJxNxN8egoKIqiDgT44aHTti4efGmv659Tzx4WXsQeU8zWqoQHpS4UFC3Dw8MAgO7ubgDA5s2bkclksHLlSvGYRYsWYf78+di4cSMAYOPGjTjxxBMxc+ZM8ZgLL7wQIyMjePXVV3X/nVQqhZGRkZI/tWbUpYISF/t46v9i5YbdgxM481uP46//c3OtD8UTmZIWT+PsMOGmz1hEQXsypnpQpsLoQbE2yQIOWjwJ2YNSuY3GmRwTBXKzW5OsjgcF8HeSh7cuuAJ134t7wJizG7fxVBaX/ttTOP/7Gyw3SocVXsgdO7MdQKVaPMFMknVdoOTzedx4440488wzccIJJwAA+vv7kUgk0NXVVfLYmTNnor+/XzxGLk749/n39FizZg06OzvFn3nz5rk9bN8QHhTHBUrjXKzc8Hr/KPIMeOndoVofiidUk2ykoXJQeDJqV0sCiqKoUzxhVFBS9goUXngYFijFdkhTTMeDUoEWj3wczSVjxvZVSV7MaCMUePS9nwrKxSfMQiIWwY79Y3h1r7Obz/94aifePTyJwfE0dh4ct/4LISOVzQkFjqeT+93iSWfz4npUNwXKqlWrsHXrVtx9991+Ho8ut9xyC4aHh8Wf3bt3V/zftMKtSTbWYH4EpwyOFz58QxMZITuGEXXMWFHHjBvgNT88ofpPAITbJMsnYaymeCw9KDpTPMXfz1TG/43G/DhikUJ70U1bRs+DAviroPACZe60Zqxc3AvAmVn20FgKP3nyTfHfew5Pej6moMF/R4oCLJzOWzz+FijyedbKb1VtXBUoq1evxsMPP4z169dj7ty54ut9fX1Ip9MYGhoqefzAwAD6+vrEY7RTPfy/+WO0JJNJdHR0lPypNcKD4lBBSTTQ3bQbDkm95L1D4T3h8AJUNsnm8qr0Xq8Ig2xroYURZpMs38VjddK2m4MiT/HwjcaA/20e3urgx+UuSdaixeNDUcUvvp3NcVx+8hwABR+K3c/I/1m/A+OSWhTm84URvA3WnoxhZmcSAHBoPOWrRYD7w5rixksxa4Wjo2GMYfXq1bjvvvvw+OOP48gjjyz5/vLlyxGPx/HYY4+Jr23btg27du3CihUrAAArVqzAK6+8gv3794vHPProo+jo6MCSJUu8PJeq4taDEmugu2k3DI6pBcq7IT7hZMUUj5okC9R/YcpD2rqLUyphNsnyvrzlmLFVi0dniodvNAb8b/Nox6O5CuIoB0XHJCv/tx8tal6YdTbHcc5xM9DZHMfASAqb3jpk+Xd3D07g55t2AQCOn124Yd0T4vOFEaKIa4mjpzWJiAIwVnoj55WgpsgCDguUVatW4c4778Rdd92F9vZ29Pf3o7+/H5OThTdGZ2cnrr/+etx8881Yv349Nm/ejE984hNYsWIFTj/9dADABRdcgCVLluDjH/84XnrpJfz2t7/FP/zDP2DVqlVIJpP+P8MKMeY2qI0UFFPqRUHJSC0eeTyz3l/3wXGegVK4+IbaJJuxl67JCw/LMWPNssTOCk3yTGU0BYqboDajFk/xuaYy/rV4OpvjSMaiuOTEWQCA+1+0bvP84NE3kM7lcebRPbjqPQUVf+9QZRbp1RL5dxSNKJjeVrhG+ulD4e3XoPlPAIcFyq233orh4WGcc845mDVrlvjzi1/8QjzmBz/4AT7wgQ/gqquuwtlnn42+vj7ce++94vvRaBQPP/wwotEoVqxYgY997GP4q7/6K/zTP/2Tf8+qCrgOauMelHx9X6jcIhcoYe4p52STrLwkss6Vs8NSzD2gelDC2OKZSFnv4pG/P2GooHAPSunplv+OhnyOu5+QMlAAdy0evaA2AEj6aPIfkS6+AHDFybMBAI9s7Tf15by2bwT3Fb0qX7hoEeYUl1KGWXE1YljzO+rtKBQoB8b8K8ZEBkrAYu4BwNER2RkBa2pqwtq1a7F27VrDxyxYsAC//vWvnfzTgUPs4nGbg9Ige1mcwk2yQMgVFOFBURCJKIhFFGTzrO4VlLICpR528Vh8xm17UDSFTqU2Gk9qFZRocfLGSVBbjk/xlB5zMs7VGB89KEUl6dQjujGnqxl7hibx2Gv7celJs3T/3nd+uw2MAZeeOAsnze1CRCnEXYT5fGEEf2/wsfTe9iYAI74qKLyVGfoWD6HitsUjkmRJQdFF9qCEuaesRt0XPmJxF1kUYeSwFHMPqCbZMHpQJkXYmVWSrEWLJ2vR4vF5o/GkJr/Fr6A2QPKzeGzxMMbK1IFIRMEHiyrK/QbTPM/tHMTjr+9HNKLg7y44FgAwp6ugoBwYTYU+4FEL/x11cAWlvdji8XGSZzygKbIAFSiucR3UxlNF6/xC5QbGmMaDEt6esrwsECh4UYD696AcHi8dM+afj7FU1nEIV63hJ+7muFeTbPmYMVC5sDZ5USDgrUDR5qBwBcVri2cinROj+LxAAYAritM8T2zbX9b6YozhW795DQDwkVPnYeGMwthtV0tcPNf+4fCeM/Qoa/GIAqUCLZ4AKijBO6IQkMszIf/yO0S7xIsKCm0zLmcinSsx8vWPTCGbywdu9M0OYsy4eOyNkoVSPmZcOMXk8gyTmZxlbHwl2PzOYbz87hCuPeMIKIpi/RdQOF7+XrQ6cTfbNcmWeVB4i6dSUzyF43aVg2I4ZuyPSZZfeONRpaQAPK6vHYtndeC1fSP4X/e8hHndLerfmcjgj7uG0BSP4HPnHyO+rigKZnc14c0D49gzNIkjprd6OrYgoS1QZnQ0AfDXJBvUmHuAChRXyKFTrj0odX6hcgO/uCViETDGkMkxDIymhIQbJriCwlt66ute3wqKdsy4OR5FNKIgl2cYm8rWpEC5+Zdb8M6hCSyd14X3zJ9m6+/Isel2o+6NPSgGCkqFp3ha4qVjxnZVDzmvRzvF4/RnGSFfeLVF45XL5uCb+0bw+9f26/1VXHfmkZhZvFBz5kxrEQVKPaE1EleixTOWJgWlrhgthrQlY5GyOwwrYg1yoXIDb+9Mb00gFo1g1+AE9g5NhrJAkU2yABCPFf63nlccpLI5EZzFTbI87n54MoORqSx6q5yxeGA0hXcOFbbkOpH/ebsmopS3ObSIqHuHCkqlNhqLoDaXHhT5cWUKCjfJevR6yBkoWj6+YgEYWNkyQQDoaIrjmjOOKPv6nK5CwVJvRtkyBaVYoByoiAcleOVA8I4oBLg1yAK0LNAMPsHT3ZZAezKOXYMT2HN4EqceUdvjckMuX9riUae36vd15xedaEQp+WzwAqUWRtktu4fE/3cSbjUujKYxy7YQVyqMx4z1TbIVm+JJF95jbnNQTAsUn6LutRdemaZ4FDecfZSjn8dvYsIcTaCHkQflwGgKjDHbLUsz+BRPewALlPA19wOAmoHipkDhEim1eLQcKk7wdLcmMZufcEJ6R8QLUF6QNoIHhbfouprjiETUE2ctw9pekgoUeULMCq0KYQZ/zJTVskDNz1JzUPw2yWqi7h22ZVLFpYKKoiqAHDehb3poWxde4eeLvcPhPF8YYaSgpHN53943QTbJUoHigjExweP8wxUjBcUQfoHraU2I8KWwFig8STZaZx6U3YMThrtSRAZK0SDLaa/hwsBSBcW+LM5bPHaWp1mbZIseFK2CUqGNxsZjxvbaMnKKrPYOXZhkK6iguKHeFRT+XknGouL/++VDoTHjOmPEZUgbIN9Jh/tCVQl4gdLdmgh9T1lVUHiLJ/welP946i2879vrcccfdup+/zCPuW8pveiIsLYqt3jyeVaioLhp8VhtMgYcRN2XeVAqs9GYt5qaXI4ZG2WgyF/zGtTmd4GiKihTyNfJhORUJieK2w7p99Trsw8lyFM8VKC4wIsHJVYM7srUyYfITw5JBcrskN8R8THyepniGRxP43//fjsA4KntB/Ufo0mR5dRqo/FbB8dKiiInLR67m4wBqcWTyeteHI2meNortNFYGzDndMGfmiJbfnlwM7Ksh98FSl9nEyJK4bgOOlDKggxvgylKqT+kkCbrXxYKtXjqDC5Vt7kxyRanOerZLOmWQ2OFE8v0toSQbPcOTYYu4AvQyUGJhbtAWbt+hziRvd4/ovuYIanAlGmrUYvnxV1DAFT1atCJgmJzkzFQGuSm1/pI6WwzBiq30XhSs4sn6TDF2GhRIOB/i6fDpwIlHo2I0eMwBzzKiN9RU6mny+9RY4q6rzNEiqwbk2yELwsM30W30qgtHtUkO57O6Y4bBh3DHJQQ7mB69/AE/nPjO+K/B0ZSIjFWhisoXVoFJVkbk+xL7w4BAN57ZDcAZy2eCZsx90Bp4aHX5hEm2Xj56bYSG43VoLbKtXiCpqAACL3qqsXodzSjw9+NxkEeM6YCxQVqi8f5h6sevAiVQm7xNMWjmN5WuNCF0SirKii8QAnvDqYfPLod6Vwepy/sxrzuwkXg9f7Rssfxi2x3a+nnQo67rybcIHveopkACiZeu/4EtcVjfdKORhTR+pAD3oCCF4lPbmlNskBlRo2nPEbdmxUoSZ88KEMVKFBk1bUeMCpQ/GzxMMYwniaTbF0hTLJuPCjFO2ma4ilHnuIBJONbCCVbrpDFNcsCw9ba29Y/intffBdAYbX9or5C0ppem0eMGWsUlFqYZKcyOby+r1BEnbeoF0Ahm2bEporjpMUjP05rdp2SXm9tiwdQf1d+xt1PSBkugHMPSsog5l7+ml9jxtr3ihfCHk2gxbhA8a/FM5nJgdfs1OKpE8ZcLgoEGiMPww1TmZw4sXYXlRN1dHCiZsflFu414SbIsL7u3/nt62AMuOj4PiybPw2L+9oBQFz8ZbQx95xamGS37hlGNs8wvS2JI3paRJvJbpuHt2rsyt5i1DhdeuGWCxY902lXBTYai2WBidI9UE6D2vQ9KMFt8YQ9mkCLYYvHxykermoqivVSzFpABYoLvAS1NcpWW6fwC0c8qoiLiTw6GDZ4iyceLfWghKm19/zbg/j9a/sRUYD/deFxAIDjzBQUkYOiGTMWJtnqeVB4e+fkeV1QFEUUvXaNsnY3GXOMslB4gZKMRUqMjpxKbDSe1IxIO23xpExbPN5NsoyxyhQoIY8m0CJ+Ry0GCsqI9/OiMMjaSEyuBVSguIBXnR2uPCjhnuaoFINjqv+Ef1DCHL6U1Ubdx8JVmDLG8K+/eR0A8BenzMPRvYXV9otmFRSUNwbGygLb1BwU/aC2aioovEBZNr8LgDpZdMjmqLEIarPZlzfKQjEaMeZwBWXYpymebC4viuAWrQcll7c1Ead6UMqP2Q+T7Hg6J947/hYohc3H9aKgGO0r6i1OK42nc6KQdkuQDbIAFSiu4AWKqzFjkSQbLqm/0vCUz+7WpPhamHvKYd9m/Nhr+/HCO4eRjEVw48pjxdeP6GlFMhbBZCaHXYNq6y2dzYvPhXbMuD1ZOMFW0yTLC5Slc7sAqL4muwrKhIOgtsLjeItHX0HRm+AB1AKFF3dekQskfkzJaOF/GbM3PWinxePFJMuVgUQ0Yvh7ccPsooIyNJHxfOEOAkbrANqSMTFd5tWHMhbgFFmAChRXjHpIkg3bhapaaA2ygKSghLFA0UzxhMmDksszfOe32wAA1555BPo61dX20YiCY2dyH4ra5uH+k4hSriy2VVlBOTiWwruHJ6EowEnzOgGoRdOgzRAvPtnQ4rjFU/ocU1n9DBROl88bjXmBokhbmOVWjR3lg0fimwW1eWnxDE+oGSh+thXam+LoKL7X6qHNY9YG8ytNdsyDXaEaUIHiglEPJtlYiC5U1WRQJ+SLm94OjKY8jzVWG16AxjRTPF7NhdXg1b3D2DYwirZkDH/7/qPLvr+IG2WlUePDE+pUhtZrIY8ZVyOGnMfbHzWjTRRLPW2FE7ptk6zDFo+qoJS+vvy/9UaMAf/HjOWQNn7xd1ygmEzxcA+Kl/exeuH1/6IYZtVVi3mB4s+osTpiTAVKXZDO5sXdA5eunRAnk6wuh3QKlGktcSEB7wvZqDHvsWtNsmF43Q8WE32PnN5aZtADgEWzyo2y6ohx+ePlu7PxdOVVFNkgy3Ha4nGyiwewNslatXj8CiPUxtwDBdWLT5PZMWmbtnjiPigoFTDIcsKsumox+z35FdYW5Jh7gAoUx8h9dHceFEqS1YObZOUWj6IooQ1fyohdPOEzyQ5ys2urfkaFnoJiNGIMFNob/GJXjTaP8J9IBUq3wwLFyS4eQC1QynNQLFo8xSmewz7loGgXBXISDhQ80yTZ4s/J5ZnrLCduCPYzA4XDVdewnS/0sNPi8epBCfKiQIAKFMfwnl1LIiruSpwQJqm/mggFpa30pBVWyZafvKMh9KCoxYb+HS4vUHYNTogTnFHMPaetSmmy+TxTJ3h0ChS7Uzzjmrh4K4xNshZTPK3+bjSeSpcrKICzgDWzoLakpAS5HZmvpIJST3H31WjxjKWctTKrDRUoDhnxYJAF1KmObAgjzysJn+LpkaZ4AGBuSMOXcgZJsmHIQTFKhOX0tCUxoz0JxoA3BgoqilHMPaetSvt43jo4jtGpLJKxCI4rFlKA+r46ZNMkO6lJY7XCeMzYvMUjbzT2o80zoVkUyHEyHmxHQQGAVCZ4BcqcEKdPy0xlcqKY1Guz+mWSpTHjOkPdw+PuBVW32gb/TrqaiCkerYLSGU7JVphkiwqKCOgLgXLG2w3acWEZbZuHv35GbaFqZaFwg+yJczpFUQigJKjNKguEMSZ26jht8RgXKPo/R1EUcaH2o82jpsgatHg8elBi0YgjP4sefm8ylgmr4qqFjxhHlEKImpYZ7f54UESLx2YhXm2oQHGISJF1EdIGqApKGLwI1UQOapMJ6wlHBLWFMAdFDVwzfo/zAmVbsUDh2421IW0crqBUusWjZ5AFVG9TJscsdwKlsnmxn8R+i6fw+mpbPPwu2GiKB3DefjJj0kBBcRJRb6agyD/LvYJS+P1XQkHhimv/yFSo950NSUWcXgJxLzfJem7xkIJSV4ylim8clwqKMMmSgiJIZXPiotGjKVBU01u4JFs1B6V0H0oYlDM1st5MQSlM8rxWzEI5bGKSBaq3j0fPIAsUFAzuyxi0KAQmpCLDbouHT/s4DWoDILZ28+kpL3DlR3vcjlo8xQu7Xg6K/LPcjv5XssUzoy2JeFRBLs98WaZXK6x+R9yDcngi4y3Vl0yy9YWXPTxAuO6kqwW/Y49GlLKQL3lssBoZGn5hlCQbBg8KN8kaqSEAhL/j9f5RMMYwKHJQ9E+oIgulggXKVCYnCiatggJISoXFJA8/aSdjEdtGeKMWz6TBVI3M9GJGy0E/FBQDU64ad29dVNhWUFxeGCtZoEQiCmZ1hlN1lRk2iLnnTGuJiwiDAx4KW7GLx+UNd6WhAsUhXkLaACnqPs9s7cVoBLhxcZpOyFdfZxMUpXDStBuyFQTUZYHcJBue1t6gwU4dmaN72xCNKBiezGBgJKVO/lh6UCpnkn1170hxg3FCSP0ydrNQnG4yBkw8KBZjxoBcoHi/459Mq1OGMq7GjHU8KID3hYFGEe5+MbsOlgZaFXGKomBGm3ejLLV46gyxh8dFSBugSv5AsOT+V94dxiU/fAob3jhQ9X9bL+aeE49GMLMoZ4bpjogXIvwOPB4Lh3LGGLMsNoDCBXfh9FYAwGv9I5aTP2KKp4IeFP7e5RuMtdiNuzeahDGDe1DKclAsxowBqcXjQ0tCL6gNcDZmbJYkK3/dbWuBv78qV6AUitN3QzxqbMdIPKO4NNDLVmMenNhGY8b1gdjD41FBAYI1avzgS3vwp30j+OULu6v+b+vF3MuEMXxJmyQrPCjZ4BSleoymssLga9Su4fA2z6t7hoWyaPQaVnofz7o/7MS/PbYdAPD+43p1H9Pdai/ufiKlr0KYIcaMXXlQ/FNQjILanLRlUrZbPM49KIwxjBTfA1bvL7fMDWm4o4ydNpgfYW00Zlxn8B66V5MsEKyL1TuHCptp3zowXvV/m08vaEPaOGEMXxJJsqLFEw4FhU/jtCSipnf9ALC4GHm/6a1BAIUFdUYnVG6S9duDwhjDD3+/HV9/6E8AgE+ceQSufu983cfyEXa7JtkWP1o8thQUPz0o5gqKHy0eJ2qMlrFUVhTvlVZQwqS4auEFSleFCxTR4gnomHEwjyrAeDXJxiSPRSZACsquwUKBsvPgGPJ5pjvaVinMWjxAOPdr8BHHuDDJesuOqBZ86Z+Z/4TDR41feKdQoHQ2xw1Npe0VGDPO5xn++Vev4ad/2AkAuHHlMfjc+ccYbsi1G3fvdJMxoE7NlI8Z21BQiheaQ754UAxyUBws+bNrknXT4uEX3kQsYlkAuyWMiqsWOz4dPslzwOWocTaXFwU0TfHUCaMiqM1d9a8oSuAMk4wx7C4WKFOZPPZ56Gm6QW9RoMyckJne8nkmcjSimimeoI+XizwTg0RYGd7i4Sc5oxFjwH+TbDaXx9//z8uiOPnqB5bgxpXHGhYngP0pHqebjAEbQW0mOSjqmLF1iJwVIqjNaBePnaA2Cw+KF5NsJSd4OLLiGtZBhCE7BYrHhYHjUjFNLZ46QQ1qc/+C8gVyQblYDY6nS96sb+4fq/K/z2PuLVo8ISlQ5EWQIgclJCbZwzZGjDlzupqFMgKYewqsTLI7D47j1ifeFDkeZuTzDJ/5rxfx35vfRTSi4HsfXorrzjrS8u/ZneKZcLjJGACaeFBbJldyUZy0SJIF1BZPOpcX/gy3TBgqKM5bPFY5KF4UlEoWKFxxHU/nMDJp7/f54q7DuPu5XYGJMrDze+JTPG5bPNx/kohGDIvRWhPMowowPKjNiyQWNLn/naJ6wnnrQLULFB5zn9T9ftgkW9n8zF/rsOSgDFokwsooioJFs9R9N2ZTP1Ym2W/95jX86yOv474X91j+u8/uHMRvtvYjEY3gx1e/B1ctn2v5d+Tjsy5QnLd4uGLBWKmywNWlpEmLpykeFecTr0bZKQMPiqsk2aj+8/dikq30iDFQ+H3yYtTuTc2X7tuKL977Cv77j+9W7LicYMsk2+FtzFg1yAZzggegAsUxXk2yQPDk/t3aAuVgdY2yVi0erqAcnsjYusOuNfL4eFTjQQm6gqIu/bMuUACULOQzGjEGIAL4jEyyW/cUAtbsmLTfLBbQZx87HRce32frOAFVqbBaGKiaZJ1P8QClo8ZTBi2X8mPzZ9TYaIpHDWrzb8w4qC0eQL2psVugcBX3fz/6hi9bpb1iZ8xYFNwT7lqDQc9AAahAcQRjzJcWT9AmOnYVJ3j4nVG1J3n4FI9Ri6ejKS48DGFQUeQdIHybcVii7nnMvd0RUB55D1goKMWT4GQmV/a+H5nKiAsJnyYzgxu653W32DpG7fFNZfKmha4oUByMGcejEVGETpYUKNZTPIB/kzxGW5hdBbVZeFDctHiGLBJS/cLpklFebO0dnsKdm96p2HHZxU4hx1XOdDZf5n2yg0iRpQKlPkhl88Jf4NYkC0ibbYNSoBRP+CuO6gFQ3RZPJpcXH0azC9ycEIUv8THKiAIxDcWL0lyeie8HkcMWapaWxVKLx6wtJBf04xofyhvFhYNAuZqnBy+oFzgsUFoSUVGEmy3mM9pnYwUvQuRdPikbHhTAvrpjhaFJ1klQWwVzUKqloDj1rcmqyf9ZvwMjFUw8tnMs/DXoNLlRaElExWtk1bbUgxSUOoO/aRXFWX9aS9DuprkH5ZxjZwAo3EVUq5XCTZmKYt4imCPCl/yfMMrk8ugf9u/najNQADVJlv97QeXwhHkirJZjZ8oFivHJNB6NiFFbrQ/lNalA2TU4YSlX84J6fo+zAkVRFKHSmU3yjLtQUOTHy6PGUzbGjAFgers/LZ5Jg2O3a2xljKktHsOo+2CbZAFnLR7GmFC6ZnYkMTSRwU82vFXR4zOD/46iEaXEhK5FURTxmePKlBOCHtIGUIHiiDEpA8VLTghXUIKyDpzftZ40r0u84XdWyYcimzLNFrPxO6LfbN3neouqEd9+5HWc8a3HfIv556+rnHkjJwgHukAp7uExGxmWaW+Ki703ZtuP+WOB8gJlW/+I+P+TmZxpm0MeiZ/vUEEB1DBAs7h7o4u8FVy14HfjuTwTNyFmY8YA0FNMuT3gocWTzzPDqSG7Y8by9yuxLLBqBYqDaAL5OX/+wkUAgNuf3ukpQt4Lwn/SFDMdmwdU1dKNghL0mHuAChRHcEnMrKq1Q5AmOqYyOfQXP4gLuluwcEYbAODNKvlQeKqnVUvhQ++Zg0Q0gqe2H8Qnf/ZCWZvAC6/sGUaeAf+50Z/eM28DlhQokWDuYNJy2KEHBQD+9pyjcdbR00WL0AijsLbX942W/PcukzbP4YmMGFWeO81FgcLj7ivY4uFFgtw2sGzxtHuPu5cLBmMFxby4l1URqzHjVCa4BQo3l9pZrTAlPY/Lls7CsvldmMzk8G+Pb6/Y8Znh5HfECxT+uXUC/90ENUUWcFGgPPnkk7jsssswe/ZsKIqC+++/v+T7AwMDuPbaazF79my0tLTgoosuwvbtpS/01NQUVq1ahZ6eHrS1teGqq67CwMCApydSDfwwyAKq9B+EKZ49Q5NgDGhNRNHdmhAL4KrlQ7Ga4OG8Z/403PGJU9GSiOKp7QfxsdufFSvJvcLNYhve2C8WmXlBu8kYKHhReMESVAWFMSZOdHY9KADw/502H3d+8jQxqWNEm05YG2MMrxdbPHySZdegcXHMi5eZHUlXSaR2slDcmGQBNXuEKzCycdHoYs+ZIcLa3BcoclvWyINi1ZaRv2+1zdjNDVY1xowBtSC0M5HDFdmIUnjOX7iooKLc/dxuvF3liUbAmZGYf04Pu1FQ6rHFMz4+jqVLl2Lt2rVl32OM4YorrsBbb72FBx54AC+++CIWLFiAlStXYnxcfaFvuukmPPTQQ7jnnnuwYcMG7N27F1deeaW3Z1IFeIHixSALAIkAmWS54XBedwsURREKSrUmeaxi7mXOPHo6fv7J09DZHMeLu4bwkZ9sxH6XMc8y/IOayTH86pV9nn8ef11j0VJ5Nu5gkqIWjKWyQt2xk4PiFD6JJSso7x6exFgqi3hUwdnHFDxQuw4Zy/K8QFnQ3erqGOxkoUwYTMJYoU2T5RfHZCxi2RL2Y2EgP269fy9pc8w4LbUnjY6ZZ7p4MslWaFEgp8lB2i1XgpKxKBRFwekLe3DucTOQzTN893fbKnqcetgZMebwxOdBDx6Uupriufjii/HP//zP+NCHPlT2ve3bt2PTpk249dZbceqpp+K4447DrbfeisnJSfzXf/0XAGB4eBi33347vv/97+O8887D8uXLcccdd+CZZ57Bpk2bvD+jCiI2GXt8QXmSbCYA0xy7NP38o2YUFZSDwVJQOMvmT8Mv/3oFetuTeL1/FB++baOtyQ8z5Avm/TaCwqxQWzylH6+gZ6HwO7emeKQsidQPRJqsJLtvK6onR81ow1G9heLYrMWz2+WIMcdO3L2bbcZAuQfF7ogxIE3xePCgGIW0AfbHjK0meJz8LD2q1eLhpmQnCopsZP77ixZBUYCHX96HV94drsxBGuCmxeNG+R1L8ZUOdVSgmJFKFar/pqYm9R+IRJBMJvH0008DADZv3oxMJoOVK1eKxyxatAjz58/Hxo0bDX/uyMhIyZ9aIDwoHls8fKIjE4A7aXFHWpyI4ArKzgPjVdljYRVzr8dxfe2459MrMK+7Ge8cmsCHb9voOk0RKB17ff7tw3j3sLeCJ5fXV1DUuPvaF6Z6cFXBrkHWKXom2deLBtlFfe2i6DArON85VFD23BhkAZstnozzXTwA0JQoHTMWe3gsJngA1YMykc65nqATMfc6BZHTFo9ZS0pVUJydv/J5VsUCpaig2PDJTEkKCmfxrA5ccfIcAMD3Hq2uiuKmQHFlkk01mEmWFxq33HILDh8+jHQ6jX/913/Fu+++i337CtJ5f38/EokEurq6Sv7uzJkz0d/fr/tz16xZg87OTvFn3rx5fh62bdQWj8cCpSidZgOwzViroMzvbkE0omA8ncOAyyVUThh0qKBwFvS04p6/PgMLZ7Sif2QKP3zsDVf/fj7PxFjpMcU7+Ae27HX1szi8AIlF9Fs8QVVQnI4YO6VNmGRVOZqPGC+a1SHeg+/Y8KDM72l2dQy2FBQXu3gANXqAt3jUO3PrC0CrlNFycNSdiiIyUPQUFJuTNykbCopYFujQJDuWzoolmtUqUNK5vGXukNHG6RvOXggAeG7nYAWO0BgnPh3e4nE1ZpyuQw+KGfF4HPfeey/eeOMNdHd3o6WlBevXr8fFF1+MSMT9P3XLLbdgeHhY/Nm9e7ePR22fMZ96duoUT+3vpGUPClA4MfELRTWMsiJF1mAPjxl9nU34lw+dCMC9oW1CkoA/dvoCAIU2jxf1KJvTb/HEAraDSYsbg6wT2nX28fAWz6K+dhG8NjCSMpTmdw8W/CnzXXpQeizGjLO5vFARnGYd8cJgKq1p8ViMGAOFTAve5jng0ocyabAoEHA+ZmynxZNy+D7mpvZkLOLK4OwEWQGy8soYteL4e0W7ALLScAXFziSdFwWlIYPali9fji1btmBoaAj79u3DI488gkOHDmHhwkI12tfXh3Q6jaGhoZK/NzAwgL4+/b0ayWQSHR0dJX9qgV8m2aDkoDDGyhQUAGKS580qFChOTLJ6nL6wB+d4MLRxmTOiAFcsm4NELILt+8fwp33u24hZgxaPUFAC0NrTg2egOBkxdoIwyRY/R1OZnCiCF/V1oKslLkaR9dps6Wwee4d5geLWg1IoAgYNvB5ywepkFw9gbJK10+IBvI8a83+3JV5+wXHa4jGa4AGkFo/DePVqtXcA7W4k8+csm5ll+PgtY9Y/w0+q5UGpS5OsXTo7OzFjxgxs374dL7zwAi6//HIAhQImHo/jscceE4/dtm0bdu3ahRUrVlTqcHzBL5NsIiBjxgfH0pjM5KAopZkSC2fwAqXykzyixdPm/q797y90b2iT7yI6m+M4f1EvAG9tHqGgaE7yQUsQ1lJpBaUtWTjhjhQLlB37x5BnhYJoZkcSiqIIJU/PKPvu4QkwVigEprt8v/DnNp7O6ao0E0XjYDSimF6k9dDmoPD/TdpUC7yOGotFgSYtHvsmWeNjdmuSrdaIMVB4/bgp3UpB4W0t7eske3nGq7ik1EmBIi8MdEpd7uIZGxvDli1bsGXLFgDAzp07sWXLFuzatQsAcM899+CJJ54Qo8Z/9md/hiuuuAIXXHABgELhcv311+Pmm2/G+vXrsXnzZnziE5/AihUrcPrpp/v3zCqAXyZZv6X+nQfHsXb9DvHGtgu/CMzubC6RdMWosU8ZALsHJ/AfT71VZv7L5Zn4YHm5KC6Z3YHLl84GAHz7t687+rvau4grlhWMcQ9s2eN6Zw5XUOIV9qD85pV9+NXL3seiOXKqbyVQx4wL79PXpfYOT8zkysgunaWBstpnlbBpREdTTFy49GRxNaQt6vjfUHNQCq8vv+u22mTM8TrJoyoo5f+e7TFjOx4UbkB1WKBUU0EB1NaaWwUlElFUVSztTC3yAldD7I0ZqwswnR5jGFo8jo/shRdewLnnniv+++abbwYAXHPNNVi3bh327duHm2++GQMDA5g1axb+6q/+Cl/5yldKfsYPfvADRCIRXHXVVUilUrjwwgvx4x//2ONTqTy+mWR9VFBefncI1/z0ORyeyCCVyeHmC46z/Xd5INa87lLDod9hbT/4/Ru49497sGtwAv90+Qni60MTafDWrteL4t9dcBx+9co+PLX9IP6w4yDOPHq6rb+n/ZCec9wMdDTFMDCSwrNvHcIZNn+ODFdItNH9cR8L0/2jU1h11x8RjSg4f3GvLz19brQz26njhTZNDsrr+/gEj9qy5dNk7+goKLtd7uCRKewvSWD/aAqD42mxQoHjNqQN0Bszdtji8ZiFMlksrvQ9KPY2EPP3ZtKsxeMy6r7aBUoyHsVoKms5asyfh95nqCURxWQmV7IAstIMTxZeRzu/p9ZEFPGogkyuELLYnLBnHmeM1WeL55xzzgFjrOzPunXrAACf/exnsXv3bqTTabzzzjv4xje+gUSi9OLT1NSEtWvXYnBwEOPj47j33nsN/SdBYswnD4pfd9Ib3zyE/+//PovDxQvLk9sPOvr7PBBL28/neRR7hiZt5QhYwRfx3fXsLjEmCqh3sJ3N8ZLUVTfM627B1acVTK7/+sjrtk1t45osgGQsiktPmgUAuH+Lu0wUrrxon5OfCsozOw4hzwrFkF93d0JBqVCLp0NjkpUVFI7ZqLGeX8oNZpM8bkPaALVA4SqMWqDYK3Z6PLZ4uHJjNsXjSw6Kzdh8LVVXUGxmoRgpKIDqQ6pWi4cx5qgVxgtuwJlRNpXNi7wmp+P01YR28TjALw+KCOzyMGb8+z8N4Jo7nsNYKouT53UBKKgpTuLf1QyU0omIntYEOppiYAx4+5D3Ng+/M8/mGb73O3Uc+JBHg6yW1ecdjdZEFC+/O4xfv6I/sq5FLwuA5x/85pV+VwWaUZKsmoPivUB5SipGp3xansg9KJVq8XAPypi2QJmlKijzTTwo7xzyp0DhSoXeJI/c4nGKaPGIMWP7UzzycbkdM57IFBUUkxyUbJ4hb9K6tNXi8aig2Gld+AE/TqsWj6mCUjQcV6vFM5XJCxXLbiGnGmXtn/vl7Ke62sXTyPAlZX7t4slk3bV47n9xD/76zs1IZ/P4syUzcfcNp2PhjFbkGbDxrUO2f45RKqccef/mfu8FiuyNefClvdi6p2BkdZuBYsT0tiQ++b7CtNh3f7fNViEgWjzSh/TUI7oxu7MJo6ksHn99v+PjME6S9fa6cxhj+MMOqUDxacKg4iZZSUE5MJrCwbEUFAU4dmabeIxcoGhVMN8VFB2vhx8tnskM96BUt8UzZXLscsFh1mLko8NmBmE5U8XJ+O1Q1RWUYsvNcszYWEHhRaefy0nN4OfKaESxfSOsxt3bL2y5ctySiFquYaglVKDYhDHmX5Ksh6C2/9z4Nm765Rbk8gxXLpuDW69+D5riUZxV9Eo8veOA7Z/FA7H0Tvh8kscPHwo3fXGl59u/LYwDO425t8Onzl6IntYEdh4cxy9fsM7L0evDRiIKPlhUUdxE32elfSYyfihnQGH8u19aBe9HG66wKLA6Y8bpXB6v7BkCUNigLbdT5kxrRkQpFF1yOjBjzHPMPadiLZ6yHBRnLZ4Z7YXjcpuDMmEjBwUwVz746LCdoDbA2USak3wPP7CbJmu2koC3PyZ9+IzZQW6D2TVpuxk1DoNBFqACxTbj6ZwwdLYna+NB+eOuw/jKA6+CMeCaFQvw3Q8vFWoML1D+sMOegjKVUZNi9QqUo3ya5Eln8yKp9R8/eDxiEQVPvnEAz7x5UGRR9HgYMdbSloxh9XlHAwBufeJNy8cbbfT8UHGaZ/22/Y7vnoSCUqEclKc1XiM/CpSJdE7I+5VSUGSV6vm3DwMoNcgChd8RN67KbZ7B8TTG03wk3l2KLEfE3esoKPwk70ZB0Y4Ziwh1h1M8o1PWxk49RJKszr8Xl96LZj4UO0FtTkLQZKo5ZgyoypX1mLGx0tVcbPFwxaHSuPHpTLOxvkEL99QE2SALUIFiG943j0UU25KtETGXeRhPvlFQR1Yunomvf/D4Emnu9KN6EI0o2Hlw3NYuGf6YtmRMd2rDr0meocnChyaiACfO6cRfvnc+AOBfH9mGQ0UPgN8XxMuKI8fvHp60HBU2Wph1XF87OpvjyOQY9gwZb9fVg09naU2yfuWgPL2jtEBx6gXQg5/ckrGI7bFYp8iy9QtvF+LDj5MMshw9Hwqf6unraPI8scQzd/QUFN7SO2FOp+Ofqw1qm3TY4ulsjgvVzU0y6KRJi0dRFNXcanJj5GRZoPx4O9RuzNhekmxSxyvEFRS3+5Gc4sanw3dnHXbwnlEVlOAaZAEqUGwjDLJNMdcZDBy3W21f2j0EADjr6J6yY+hoimPp3MJJ9Q87rKd5rDIlRBaKx6WB3LTb2RxHJKLgM+cfjeZ4FC/tHhIZHjzd0y/kFtzYlPmJxWxhVl9HYekln0KyC2/hlI8Z28uiMP3ZuTw2vVW4uKsmQO93d+qIccLz+9sMXqC8VAzUWzzLXoHiV3sHkBcGlrZS+oenhIfrg8Ui1wlGLR67BZ+iKJ4meURQm8G/l7QRsGYnSTYihdg5KY6rP8VjLwfFTEFpEdk21VFQuILn5HfEW2aHXZhkg2yQBahAsc2ojzPjbnJQGGPYUixQTp4/TfcxvM3zlI1x410WExELeloQUQrP221PHIDkayiceHvbm/DJ9x0JwP8pHk4ypi5eG5ky/9COmSzM6ut0V6DkhIKiKVBi7gpTmZd2D2EslcW0ljiWzC60R/wwyXKDXaVGjDncKMsvhNoWDwDdNFmr96sTRNy95o7zwZf2gDHg1COmuSqExJhxcXeLmbfBCC9GWRHUZnDRsTNqbGebsfyzglyg2C3gUyYKimjxVKlAcfM74gr0YUcmWWrx1BV+ZaAA7u6kdw1O4PBEBoloRPeuEwDOOmYGAOCZNw+ZjhICqmRuFHrVFI+K+Pu3PETe690R3HD2wpK2kp8eFA5/nUZtKii6BQpXUEacKigWUzweChTe3jnj6Oni7s6JD8CIITFiXNmLh6xuNcejugUHD2uT02TFSLwvBYp+i+f+FwvrDS4vGqSdwhWUXJ4hk2Omd+ZGeBk1FssCDQoiWwWKDQ8KICXT2ixQ8nln+R5+kPRBQREm2Sq1eNTfkf3CgZtknRQoRq3toEEFik1EiqwPL6ibZYFcPVkyu0O30gcKUzItiSgGx9OWy+7sSObqTp5SH8rgeBrXr3seX/yfly2Pe0jHud/eFMeqc48W/10JU6YaCmahoEwZ30nM7HRXoGSNclB88KBwg+xZR0+33WO3Q6VD2jjy7/nYvnbdEUczD4qXFFkOV+xGp7LiAvvGwCj+tG8E8aiCS0+c5ernyoXBZEbd9WM3BwWAp43GwiRrYPBVPSjG7xc7LR5AzkKx994bS2fB75mqlYMigtpsbjPWVVD4mHGAFRT+meXLPu1gdmMWJKhAsQnfH+J1xBhwd6F6cdcQAHVUV/fnxiI4fWEPAGsfip070oXTVR8KZ9/wJP7i3zfisdf34+7nd1uax4Ylb4PMx1cswHEz29HdmsARmqA4P2jXpJYaYTZuN8tli0fNQTHwoLg0tY5OZfCi8CFNF1tl/WjxHK5wzD2nQ1IgF+sYZAG1QNk/mhKqgJ8elM7muPAH8btOPk7+/mN7XRdp8agifu5UJueuxdPu3YNiqKDY8I3YMcnK37f7XubngWQs4staBjvYHTM2VVAS1Q1qc1WgCA+KmxYPmWTrAn6h8xrSBqh31k6k/pfeHQJgXqAAEDtotJMeMowxW6FX2iyUtw+O489v3Ygd+1VFxWqx2WED01cyFsX9q87E0184tyJVPL9Ls/KgqON2/plkjbYZe23xPPvWIHJ5hgU9LZjX3SLuzP1o8fAJgO4KpchyZAVFb4IHKLxXeIH57uEJTGVyQsXyw4MSiSjipH5oLI18nont1Vcsc26O5ShK6XI5EQDmoMUzw8PCwCnhQXHf4knZbvE4WxhY7QwUQJri8UFBqfYUjxsFZcJgQ7ceo6Sg1Bd+LQoEnF+o0tk8Xt1baNlYFSjvO6ZQoDy3c9DwzXpgNIWpTB4RBWXL0mREgXJwHK/tG8Gf37YRe4YmceT0VnGisRqH1GvxcJoTUVeBWHawq6Bod/HIzHTpQTHcZuzRJMuLTm6Gtttjt0O1TLLy50fPIAsULvRiaeChCewZmgRjhcVofhmqu6XsiBfeOYw9Q5NoS8awcvFMTz9XzkKZdBjUBrjfx8MYExdRyxaPjwqK3eK42gZZwMUuHpMpnuq3eOy/z9uTMaHW2lVRyCRbZwgFxWNIG6BOd2QtjKyc1/aNIJ3No6slLk7cRhzT24be9iRS2Tz++M5h3cdw9WRWZ7PpiYiHte0enMBH/n0jDo6lsHhWB3751yswp1jYWBUoXNrtquKJCVDD9Cw9KCYfVN7iGRxPO1IpMgYKilcPyh80BYrdE7Adhiq8h4fTVlKg6CsoQKkPhZtl5xmMxLtBNcqmxFLIi07o89x+aE4UXpPC3WxxeV8VpnjSubzweBgWKE5aPDY9KLZbPDUoUIRPxsMunjC0eBRFEVOSdn0o5EGpM/z0oDj1InCD7NK5XZYnaEVR1HFjgzaPuiTQvNjpbU+iLRlDngEjU1ksXzANd99wOma0J8UJ3upEyoPaKn1nrsWOgpLJ5cVroFegdLXERQG3f8T+BSNXgRyU/uEpbN8/BkUBzjiKFyg+KijFE1u1TLIzO5Km/5Y8auzXDh6ZnuKo8cDIlMjj4enBXmiOq8bllAsFRS1QnLV45AuopykemwpKMm5d7MjURkGxG9RmYxdPgFs8ANDd6syHQlH3dYZfe3gAdfzUroLCA9qs2jucM0XsvXmBYnXCVxRF3OW+75jp+M/r3ys+OD0245V5RV/NExOgjhmbeVBKNnrqfFAVRREqyj4HPpSsUQ6Kh6h7/lqeNKcTncV2md0eux2qNWbcW2ybnTiny/Rx/L25u0IFCi+w7/3jHgxPZtDbnhQGcy80S3fcUx7GjA9PpB1N+fF2UjyqlCUYc5J2kmRzNnNQovbUCU61NxkD9pcFBkVBYYypBYrDz2GXw1Fj3toOukk22OVTgBg1GUd1SsKhF0ENaOuy9XheoLyyZxiHx9Nld6qyZG7FmitPxHNvD+LPl88tMZEZhV1pUc1x1VVQOoo5AiMmCgovOhOxiOFJfWZHE945NOHIh2Kcg+LegyL8J0WPEQBpisfHMeMKv04XLJmJb1xxAt5fzOwxYkF3wf+0a3BCjCJbKX5O4AXK6/2jAArJsVrFyw3NxddkPJ0VrTwnY8bdrQlEFCDPCq8JL+issJrgAXxWULhJ1uZ7uZYeFOtlgdYKykQVCpTJTE68ZxwrKA7j7ilJts4Y9TGoTSgoNrwIwxMZsbDv5Lldtn5+X2cTjultA2MQ0d0yTu5Ij5nZjqtPW1DmcO8x2Wciw+/Mq+5BsRHUpt5FGH9I1Uke+/t4DHNQYu48KIwxUaDw4hMAmmz22K2YTOfEXWSlWzxN8Sg+fvoCyzwT2YPyzqHC+9+PEWOONhzwCh/aO4BaIMgXCictnmhEkdqn9ts8kyabjDn8M2wv6t78mEWLx2ZxXBMPig0FhTFmrqBUcRcP/x1FIwpaHS6rnCZaPPY8KNTiqTPELh4fo+7teBG2FMeLj+hpcXTxONMk9t6uB8WMbhstHnmTcaXvzLW02whqs7MwS81Cse9ByRooKPy/nXpQ3hgYw4HRFJriESxfoK45EDkPHls8fIInEY04PjFWilldTYhGFKSyeWwvjrVXwoMCAEf3tuH42foTRU7hBYJ8obBql2hxY5S1irkH1LaMnRaP5RSPQz+VvJOrWqhBhiZj1VKxpvc6tRSj7jM55jq/yC5yEefUDM7Pr3aXTIZliifYRxcg/PSgxB0kyW4pBrQttek/4bzvmOlY98zbePKNA2JzLFD4oO0fLZz4vJzwjeLCZbhBVlH8+b05wY5J1o7MyUeNBxy0eIwUFLctHq6evPfInhIlyy+T7GGRIuv8xFgp4tEIZnc1YfdgYcRYUYA504xH4p0ipxdfcfJs3543f024FyARi+im5ZrhZtR40mJRID8WwJ+gtqTN9gmnNgqKdQtUPn69352sSE2mc5a/Fy94mXh0EnefzzNx4xh0BSXYRxcgxiqQg2KnxWM3oE3LaQt7EIso2DM0iT+/bWPZ99ubYp5OFkYbYWW0m4yrCU8s5bst9LBzF6GaZB20ePJGywLdBbVtfLPQpjvr6FITp19jxoerNGLslPndLdg9WPi9z+poMlzx4IbpUovH7e4dPUSLp/jedzJizHGjoHCPhFFIG2AzqM3mmDFvAQV6iseWglL4vUWU8uRngPvTFGRyDBOZLDpRueP3YiQWcfc2WjwT0vmi2jeOTgn20QWEnFRx+iGJ8TtrK3m0ZIOxwwKlLRnD6vOOFgmZMgqAD58yz9Ndo2jxmPTJRUhblf0ngFqgmCkodvqwfB/PgIMxY16ARDUtHpGDknXmQXn3cKElpw02s9Njt0O1DLJOmd/dij+gUJz5sYNH5qgZbfjw8rmY1dXsq7dF60FxMsHDcTNqzItU7ybZXMljjeDqhNMclKomydrwycjrCIzOh83xKDK5rPCsVQovRZwYM7bR4uE3ZtGI4rj9WG2oQLHBmDSO6kfUPb9QWY0Z7x6cxOB4GvGogiUueuQ3rjwWN6481tUxWsF7+OPFeGU9eXRoojYTPIB6Z1Bwxud1p3TsKCh9Uosnn2e2lKAcV1AMclCcKij8TppfuDjqOnlvLR7+OnGjXVCQW5B++k+AQtz9dz681NefCagKBlel3AS/qRuNnSsoZiZZ1TdisizQ5pix02WBtcxBMVN51D08xr+31mQMI1PZio8ae/kdORkzFjdmCeOiLCgEu3wKCNxomYhFfJGZecJoLs+QNylSXtxdSIJdMst4g3Gt6GhW45WNjFn8w1LNuyaOXEiOGagoah/W+Hc7oz2JiFIoJg+atLNkjJJk4zaVM5lcnonf73TN5IndICorgqugVK5AqRRNxQKBF31ORow5/HU+aNPwCKhTJtUaM3ayLDCfZyKPqBY5KOlcXtw0aFH38Bg/32rt4/GkoDgYMw6LQRagAsUWvOLs8KlfJ3sTMnnjD7jb9k41UBTFcpKnVjH3QEGt4Cdro7A2Oy2eeDQi7mgHbE7y8F08RtuMnSgohyfSyBdNot2aKa4mhwvbzP4NINgFip9tmErSHNcqKC5aPO3OFRSrRYGAdTx9VorLt466t//eG01lwYo/txY5KICx0mNHQWmpUhaKlwKFf3bH0zlLVSssI8YAFSi28DOkDUBJu8EsE+MlhwFt1cZqkodP8dSixQOoYW1GPhS7dxJOjbLqNmP9HBQ75mgOb+9Ma0mUKTJOTLJPvnEAH/rxH/DGwGjZ9w6LFk/AChTJd7Kgp7WGR2IfXqDwi1nSTYun1b1J1s4Uj5GCJ3/dz2WB3KjeFPdHgbaL/G8ZtUHtKCh8dDvIBUp7U0wEDQ5ZGGXNFqQGDSpQbMBbBH74T4DSAsVo1DidzWOr2GA8TfcxtYaPQxpN8qgelNp4G6zi7u3eSTgdNTbKQXGzi+fgqH57B5B67DY8KPf+8V28uGsIa9fvKPsel4W7A+ZB6WyOY1FfO7pa4jimt63Wh2MLrQfElQelXS38zVrAMpM2FJSExQ4w+evWSbL2WzxDNchAAQomUK5WGxXxvMAyKyRbqrSPx0uBEokoQqm2ykIJU4sn+EcYAEZ5BooPm4yBwgdHUQDGjC9Wr/cXNhh3NsdxhM8TDH7B4+4PGUwbDNWwxQNYZ6HY3ejZx8Pa7BYoxde0fBeP8xwUI4MsUN5jN4tq536b3706gPFUtuQ5q16hYCkoAHD/qjORyuZDcbcHlBckTS6mJLgBPZdnGJrMlLX29Jh0EHVv1JbhxYZiMHIrk7SRqcKphUGW0xQrTOAYFSh2FJRq7eNxu4eHM601gUPjaUujrJ2AyqBACooNRIqsjzPjcYu4e7HBeJ71BuNaYbUwsNYtnnaLLBS7C7P6HC4M5G07bcEgxoxdtHh6dAoU+aRqJbXzE/RkJoff/am/5HtCQQlggdIUj9bkwuYWbYFgNlVjRCIWEc/ZbpuHKyimUzwWqoecgWJ1znGioIgR4+bqv7+SFpM8UzY2TldrH4/XQk41ylq1eMiDUlf4GdLGsbqb5gmyQTTIcoQHxUpBqVGLp8NCQRmzuTCrz2GLR4wZl03xqNNbRlMFWngWhlmLB7AeNZZPrve/WJqNIzwoASxQwoa2xeJmigeQJnlsFihqUJv7qHu7MfeAM5NsLTYZc6x8Wvz4zT0o1ZniGfFYoPDzrJWCEqYWDxUoNhCLAn18QWMWd9N8B8+yMBQoRgpKDXNQAOuFgXY/qE4VFDHFY5AkC9hv85i1eOQeu5WCIsvTT20/gAPFCZHJdE7cfQctByWMlLV4XEzxAM7D2kRQW8L437NSUNI2Ltban2XHJFvTFo/FOgg7Cko1TLKMMc9eHX4+tho1HiOTbH3BTZZ+bDLmmI2cTmVyeOtAYYPrCXM6ffs3/cYq7r5Wm4w5HRYLA0WBYqGMCQXFYYun3CQrjZc7LFBm6BQogL04b0BtATTFI8gz4OGXCyoKv9uKRZRQ3FEFHT9MsoDzsDZehJsqKDYLFKsRY0AtvCZtTJDVskARYYaGY8bFJNkaKygT6Zww17tXUOzF3ZOCUmfwFoZ2RbsX1IWB5QqKfMffE7DRTxmzHBR5k3HtpnhstnhsKijj6ZzpdmROTkzxaBSUiKyg2G3xFBWUdv33QdJmWBtXUD5w0mwAwP1bSguUaa2JwHqdwoTWg+JmzBhw3uLZX2w/9rbrF7KA5BvxocXTWfSTWI20AsFQUIzi7vnnJmmidFUjB4X/jmIRxXQSywwRd29lkk2rSbJBhwoUGxwwkdndYjZyKky5yVjVl+w5gRdsei0e/oFTFHUvTrUxGzNmjIkCxepOoiURE2pMvw0VJWOwzTgSUUTRYltBEWPGBgqKzSwUfvf3F6fMQzSi4KXdQ9h5cFwY6oJokA0j2gLFe4vHukDJ5dUN5byY1oMv+LNUUGwUKPzmZHQqa/leVr0V1b9jVz8f5sZgM69QNVo8chHn9kaBKyhWY8bcU0ktnjpBnaTw7yQeEwpK+QeHXziDvmmSjxmPTmXLTnq8vVOLTcYcs6C2qYyammnng+pk1DhrYJKVv2Zn+oExhkPjxlM8gP19PPz7c6c146yjpwMA7n9xT03XEdQjZS0etybZdvselENjKWTzDBHFuBUIOGjx2FJQ4uDXUSsVhU/zuR2f9YKatuxeQeHjuJVs8XgdMQbUm4whMsk2FrwPbPbhd4rZyKnfybWVoqs5Dl57aGXFWm4y5vDcGr22jLwAssWGDN/X2QzA2ijLmDqho5dL4iQLZWQyK94fRq0+YQI0MStmc3mh1LUkorhiWaHN88AWtUCxk7VBWJOMRSDfALsZMwZUBeWQDQWFF80z2pNlacMyTsaMrYhGFNGysWopBKHFY6ygFL1ZJoWkNh24EvjxO+JJ0IO2c1CCfX0BqECxJJ3NY6RYMPjZ4uEKit4untEKjDVXgkhEEaOp2lFj4UivYevAzIMyLm30tKPw9HXwfTzmBYq8oToeKf948YuEHQ8Kby22N8UMzZZ20mRlI2NTPIoLlvShOR7F24cmsP71/QCCGdIWRhRFKWnzuG/xFF6PAzZMsrztyItoI8TkjQ8eFMD+gjr14luLHBSLMWMe1GbqQSm2eFIBL1CK6suQVQ5KmgqUuoFL7DHpjsEPxBSPzt2M8EbUyLvhBDXuXlug8AV0NVRQTDwoTu8i+CSPVYtHNj1rPSiAs4WBVhM8gHoBNBv35AbZiFK4w29NxnDB8TMBAOu3HQAQvJj7MFNSoLhs8fCW4sBoyjIzh78neRFthBx1z1j5z1RbPPaO2W7uxnCNou4BNa/FcMzYzrJA3uLJVK7F4zUDBZB8QanylruMGlBJBUro4SbFnraEr14KkSSrc/IZFWPNwX8DqVkopXd6tY65B1QPyoiJgmL3Q8rvTq1MsrIiZlag2NnHY5aBwlHHjE0KFLGnJSYMeFecPKfkMRTS5h9NJQqKuwKlt70JsYhSNMCav+eEgtJhbJAFSpURPQXPyZgxIOVumHhQ8nkmVoXUpsVjMWZsa1lgsUCpoILix76ijia15c59P3pQ1H0dYeci4YZ4zNiLMFaBYLhKwfeGlCkoNY65B1QFJZ3NlykMTmXOvs7C83SkoOi0eIQHxYZJlnufjEaMAeseO6C/6fasY6aX+FqoQPEP2Xdi1jowIxpRhIqy57D5Fm27LR75IqxXIKez1oZRGTtTI6NTWXCxprYeFAOTrA0FpbXKUzxuiUQUNQvFoM2TyeVFIUoKSh1wwGQXihf4xUvXJBsil7VRFkqtNpjKyL8/rQ9FTVO0dxfR12FPQeEpsopiZJK170HhExy8CNRDneIxPnmqMejqc41HI/jASbPEf5NJ1j+afVBQAGB2V+E9t2fIokDhLZ5Oey0eQN8oy4uWpEMFxWxqhF94m+NR294WP7EKMlQVFOtdPJOZnO3t0k7xy0jM225GReO4NBxAHpQ6QFVQ/D2Bm3kRVJNs8H0BRnH3fIqnlh6UqJSOqi1QnLd4Cnezh8bTpn4PrqDoGWQBZx4U3jYzU++SNhQUEYOuuVhevkxt89CYsX/44UEBgLlOC5QOcwVFzuHRLVAcjBkD8sXQuMVTywkewNqjNWVDNZILezvJuW7wa1+R1agxb+8kYhHdGISgEfwjrDF8OsXPEWNATpI1M8kGv8IVJtmyKZ7at3gA1cej3WjsdKPntJa4OHHvHzGerOAFip7/BFBfdzselAM8pM20xWNtkuUKinbkddm8Lrxnfhe6WuJYOKPN8ngIezRJv2e3Y8aAqqDsNSlQGGNSi8fcgwKYjxqnHBYodnI3RAZKzQoU8yk3/nWzQrIpFhWj45Vq8wz7FMtgNWrMDbJhsA8ALgqUJ598Epdddhlmz54NRVFw//33l3x/bGwMq1evxty5c9Hc3IwlS5bgtttuK3nM1NQUVq1ahZ6eHrS1teGqq67CwMCApydSKSrmQTHNQQmfSdawxVPjO/MOg4WBTqd4FEWxNcnDWzx67R3A3RSPqUnWhoIyaaCgKIqCuz51Op754nk1bcXVGy0+jBkDwJxpRQXFxIMymsqKi6aVSRaQCpRc+YXWqUnWTu5GrRUUqxaoHQUlElGkLJTKTPL4McUDSKPGBsblMGWgAC4KlPHxcSxduhRr167V/f7NN9+MRx55BHfeeSdee+013HjjjVi9ejUefPBB8ZibbroJDz30EO655x5s2LABe/fuxZVXXun+WVQQq10obomZBHaFySTLC5SDAZziAeQsFH0FxYnPRxQoJj4UsxRZQM5B8XmKx3TMmC+SK79LbIpHTRfMEc6RVRMvLR5VQTF+v/H3Ymdz3JZaw4uPlA8KyjQbOSh+tS7cYhVkOGVDQQEqH3fvR5IsIBWNFh6UsBQojo/y4osvxsUXX2z4/WeeeQbXXHMNzjnnHADADTfcgH//93/Hc889hw9+8IMYHh7G7bffjrvuugvnnXceAOCOO+7A4sWLsWnTJpx++ununkmFsNqF4hZ+otAfMw5Ri8dgimdYeFCC0eIxNMk6uDiLuHuTAkXs4bFSULLmZjvGmKMcFNMxYz7FE4LlYPWAH2PGADBH8qAwxnR3tNgdMeaYtXgcB7WJ5XTWHpRaeZwsd/HYiLoHKrswkDEmPHveFRQ++m1eoLSFYMQYqIAH5YwzzsCDDz6IPXv2gDGG9evX44033sAFF1wAANi8eTMymQxWrlwp/s6iRYswf/58bNy4UfdnplIpjIyMlPypFmIPj8kkhRu4gqJ3olB38QRfdled/Bnhp0ln8+I51Np8aRTWNu4iC8DOPh7hQTEsUOx5UMbTOXFSNdsBZSdJdoLnoHi4WBL2kVtpZvkaVszuKrzfxlJZ3SwfQJ7g8aFAcWySLbwvhyczul46/j2ghi0eyzHjooJi8dlQCxT/Wzzj6ZwI4/P6e7JK9637Fo8VP/rRj7BkyRLMnTsXiUQCF110EdauXYuzzz4bANDf349EIoGurq6Svzdz5kz09/fr/sw1a9ags7NT/Jk3b57fh61LNpcX/VW/WzxxoaCUf7BHpG3GQUee0uF3UvIm41oXWUZhbW5aPDNteVC4SdZ8isfohM7hO1ia41HTk4mdMeMpA5MsURmaE4XXJBGLeAp3bEnExOfLyCjrWEExafFwr5LdtpTcvh2e1FdR/PJWuEVdFlj+fBljoihrsijKKqmg8N9dPKqU+cScIiarDFStsLV4KlKgbNq0CQ8++CA2b96M733ve1i1ahV+//vfu/6Zt9xyC4aHh8Wf3bt3+3jExhyeyICxwoXW73X0RiZZxpiocjtC0OKJRSNls/fDRed+R1Pc0CxaLdqFSbb0A+vmTmKWjRYPLzyMpnjMlkTK2PU+CQXFJPjNaIqHqAz8ImN10bODlVGWF8szbSooSRMFZb+0dNAOsWhEnKOMWgq1VlDMWqDyZyZpqaBwD4r/Coq8CkCvjecEq2ya8eK5oC0kvjNfj3JychJf+tKXcN999+HSSy8FAJx00knYsmULvvvd72LlypXo6+tDOp3G0NBQiYoyMDCAvr4+3Z+bTCaRTPrbYrEDv0h0tyRMt4S6wWir7UQ6J5IXw+BBAQofiqGJTDG3o10oKbXMQOEYeVB4kqwrBcWOSdYiB8WqxXPApvfJlgfFYIqHqAy8aPTiP+HM7mzG1j0j2DtsrqDMctri0Xn/8WLH7s8CCp/9kamsoQ+l1gWK2S4euS0aBAXFDyOxlUm2oVs8mUwGmUwGEc3JORqNIl9sZSxfvhzxeByPPfaY+P62bduwa9curFixws/D8UylRowBOUm29IPDL6TRiHe5r1pM1xhlg7DJmCM8KGU5KMU7CQdFID9xD4xMGSZK8gLFcMzYZMWBjN33XtJiSgFQTbJ6UzyE//C7bT8UK0sFxSeTLGMMA8OF99xMmz8LsL4g1jpRWuQE6RTw/DMTjSiWN6CV3MfjVwYKoJpkR6eyuueYsJlkHZdRY2Nj2LFjh/jvnTt3YsuWLeju7sb8+fPx/ve/H5///OfR3NyMBQsWYMOGDfh//+//4fvf/z4AoLOzE9dffz1uvvlmdHd3o6OjA5/5zGewYsWK4E3wVGjEGFBPFFmN1D+WUv0nXuW+aqHNQhEhbQHI1ugwnOIp3kk4kDpntCehKIUi5NB4WlcK5y2euGFQm70xY7sFilWUNyC3eMJx1xR2uAfFy4gxZ45FmuyAU5NsVL9AGRxPC1XFUYFiYcoM8pjxlPDcWN+ntyQrN2bsp0+n0CYCGCsUh9pzVNgUFMdH+cILL+Dcc88V/33zzTcDAK655hqsW7cOd999N2655RZcffXVGBwcxIIFC/DNb34Tn/70p8Xf+cEPfoBIJIKrrroKqVQKF154IX784x/78HT8pVIjxoA65aGVWrmZMwwGWU53ccqEp+7WerRQRgS1pbznoMSjEUxvS+LAaAoDI1O6BUomZ26SdexBsVixQC2e4NEcL7yn/BjrNitQUtmcWDHhVEFJac47vL0zvS3haGeOOtYazBYPL1AyOYZcnpUom9yDYuU/AdQJuIlMBTwoPv6OohEFnc1xDE1kcHii/CYqbCZZx0d5zjnngDHjk2tfXx/uuOMO05/R1NSEtWvXGoa9BYVKjRgD6gWsTEERe3jC8QYCILbicgWFG+ZqnYEC6HtQ8nkm7oScrhyf1dmEA6Mp7BuewglzOsu+z6eyrHJQ9EyKMrzYs2zx2FBQqMVTXVYs7MFZR0/HFdKuI7eYxd3zlQuJWMT2zUCi+H7Rvv94q8iJegKoPjM9k2wuz8TnrtY5KEChoJNDCR0pKBVs8fi9DqC7peAJ1FO1RGu7XguURoJvk61Ii8fAJKtmoITnpSlv8dR+kzGnXSfqflxy4ju9kyicwIcNR41zeatdPD63eGzs4iEFpbp0tsRx5ydP8+VncQ/K/tEU0tl8ibqxTzLI2m0HG7V43BhkAdWDoncxlCfnam2SBQpFvHzP5EhBqWCLx2+VqcukaAxbi4eWBZpQUZOsgdSv7uGp/cXdLupG48LvayhALR55WSBX/vhdRCyiOA7SUkeN9T0BosVjNMVj2yTLFRSbY8amHpTCSYnGjMNHT2sCyVgEjJVPj4kRYweqh5FJdsC1gmKcXMovvC2JaM0250YjivCDadug/L/tnAMqGdQ2PFmMlfBLQWk1bruNuQiorCVUoJhgJ2rcLUZ30qMh9KBo4+75XH8QChT+oc/mmWiDcCNyqwsjsjpqrL/R2Moka9uDMsoN2lYKSlGyz+WFeqOFP29SUMKHoiiGPpQBhyPGgJSDolkWuM/FzwLM4+5r7T/hqEby0ucsNhnbUVAquIvH798TLxr1JqvceO9qCRUoJlRSQeEXMG2SbJj28HC0LR5+N9UVAA9KayIKbgfh6tSYhz4sNyMOGLR4MlZjxjZyUKYyOYwWTyR2WzyAcZtnwmRZIBF8ZhsUKPscjhgDxkFtbtQYwHyKJygFihp3X/qcxSZjBwrKZBgKFJO2G7V46oR8nqlGxQp4UIyWxoXRg8J3xQyOp5HPs8BsMgYKd6C8EOETUm728HC4osGLVy05kSRrHtSWMTHJ8p+dkJI6jdD22PUQEeakoIQSvpNHa5Qd8LHFI/JUXHpQBnVaPPw8UKsRY46YdMu6V1B4e3S8Ai2eEdES9+c6M7+7BQDw/DuHS77OGCMFpV4YnsyI0C2uEPgJn/LIlCkoRQ9KSN5AgHoXlWcF/8mwzx84r2gXBnq5i+ABR0ZSr5oka74s0MyDwgvjnraEZQvKrMcOFAptXriQghJO5nQVLjjasLZ9RR+Uk7ZMwkDBc22SlRYGaluMQVFQjHxaThQUnpcUBgXlohP6EI0oeGn3EHYeHBdfn8rkwV8iUlBCDjd8djTFSu5S/SIe0/eghGmTMScRiwjFZ2BkSjyHIETdA+od3KhGQXFzF9Eq3Pz6d1KWOSgxaw+K09aiUY8dKL1rJJNsOBEKyrBWQSkmvzopUHgOiqSgjKey4rPhtMXDfWaMlS8MDE6Boq+gTDnyoFRGQWGM+f57mt6WxFlHTwcA3P/iHvF1fl4GwrPZnAoUA8QuFJuLs5zCd7Voc1DCaJIF1CwUXrEHYZMxR81CKZwIxl2kyHL435E/7DI5uzkoJgqK3ZA2TtJkYaCs9PiRbEpUH724+3yeiRaPIwVFp8XD1ZO2ZMzxZzYeVW9OtJM8Iz5GuHuB32Bq4+5TLjwofptkx1JZoTz5WchdsWw2AOCBLXuk6UV+3ot62rJdTahAMaCSBllAlfq1F6rREAa1AWob7M39YwCCscmYo4275yZZNzInP1FNZfSnZlQFxX0OykGbIW0cszRZLkk3xSOhOSkRpchTPPxic3A8hWyeIaI4mzLUK1DUEWN35zojo2zgFBRti8fFFM9kOmcaVOoU/jtKRCMlhnevXLCkD83xKN4+NIEtu4cAhM8gC1CBYkglR4wBkyTZVPimeACgp/h7equooARhxJijhrWVKihuFmbJH269No+aJGtkkrX2oBwojhj32C5QjNNkuUG2hfbwhJa+ziYoSkEh45NyfLHf9Lako03reh6UfS4NspxpBrkbokCp8bnAcMzYgYLC26PZPLPcRO4EeVeRn7vXWpMxXHD8TADAA1v2AgjfiDFABYohTmV2pyQMc1C4STY4F3g78BbPWwcKCkpQDLKAHNbGFRT3dxLJWEQoQ+M6sde84LRcFpi140Gx9zs06rED0qLAkPSciXKSsai4UeKjxm4MsoB5i6evo9nV8XXz5NLAKih+5KCoj/HTKKv+jvwvGq44ubBq4aGX9iKTywv/DCkodQBfFGj3LtYpMXEnHf5dPIDa4nnrQFFBCcCIMafDQEFx80FVFAWtJoa5rMhBsRgztjHFo7eMUA+jHjugnkzJIBtuuA+Fjxq7GTEG9HNQ1I3I3lo82lHjWm8y5iTj5cbgwn+r7U8r4tGIuKkc97FA8XOTsZazjpmOntYEDo2n8fSOg57yn2oFFSgGVN6DUmzxSGPGuTwTb/6wtXh4gcIDxoLV4in1oPDCwu0HlRc24zpGWaskWSPvkYzjKR6DHjsATGYopK0e4GFt7xaNsm7HgoWCotvicaegqC2e0gIlKDu5jFqg/L/tTmm2JHlYm3+TPJWMZIhHI/jASbMAAA+8uCd0m4wBKlAMOThubxeKW4QXQarq5cmQsCkoPZrfU5AUFDUHxbtJVv57ei0eniRr7EGxY5J1N2aslyQ7mbYvYxPBZY7YalwoJnhR4WTEGAAS0fJtxkJBcajGcKYZtHgqqQ44gatG5WPG9hUUQB3N1fvcu6XSbbDLixu1f/vqgPC2ufHe1QoqUAywuwvFLeJCJU2C8AIlEY1UJHulknS3lv6eAulBKTPJuixQeItHR0HJWUzxWOWgZHJ5YTa070ExNslSzH19oE7yTABwX1ToeVDc7uHh6Jlkc3km1NRaFyiGHpSsUwXF/308lVaZls3rwoKeFkxmciIThRSUkMMYq8IUT/k0h7rJODxvIE6PJm03SC0eP4PaAElB0ZF6MzZzUIwUFD6lEVHsF3lJkzFj/jUyyYab2QYKitPJG21QWyaXF+c6p34Wjt6Y8YgU2lbzAiVm1OIpTvHYVVD4Pp6M/y2eSvl0FEXB5UWzLJ+wJA9KyBlLZcUHuFIeFG64YgwiT2MshIsCOdp1AEEqULRBbV5XjvORXbMpHuNdPOZjxlyG7W5N2s6RMVdQyCRbD2g3Gg+4WBQIlI8ZHxhNgbHC+1J7k2EXUaBIHhR+4W1NREVRXit4C6c8qM2ZgtIcwhYPAFxx8uyS/yYFJeTwoKzWRLRiJ3b5AsYvVmFNkQV0CpTm4LR4tEFtXhUUdR+PcQ6KkUlWHS/Xb/EccuF9MuqxA2oOCiko4YYXKIPjaewfnRJmercKCm/xcCWmt73JdZBft06LJygjxoBUwHv0oPALe2XGjCv3e1o4ow1L53aK/6YCJeRwybNSI8ZA6QVMFCgh3GTMaYpHhTcDCJqCoo4ZFzZ6ejPJtpiYZLmCYqR+8LvJXJ7pJtFy75PdEWPAuMcOqCdT8qCEm47mmCio//jOUOFrTTHHAXzaMWN1xNhdewdQTbJDE4Vt5kBwRowBWUHRjhk7VFAqsI+nWkZi3uYByCQbeg5VOKQNUHfxAOrdtGjxhCykjdMt/b6CaJLNs4IpjcvbbguUNhMPirrN2KDFEytXzmTcjLerUzzGSbKkoIQbRVHE0sA/7joMwF1RoR0z7veYIguon/U8U43oQVJQeAHiWUFxuY/nK/dvxefveUkUbzLV+j19YOks8HsmUlBCzgGHu1DcEIko4i47K1o8xbuOECooQOkkT5DGjJvjUWFa5fkRAEoUHye0mEzx8KLDeBdPuXIm4ybB2GwXj+pBCed7ilDhbZ7N7/ACxXluSUKj4PV7HDEGCkUPL9q5yXsoQAWKUU4QL+jtjuDL+3jsMjSRxn9uegf3bH4Xr/WPlH1fzUGp7O+pt70Jl588B7GIguNnd1r/hYBABYoOlR4x5vCLJr+bCeseHg432SlKMKRdjqIoQkXhd4xN8YijHSYyrcIkqzNmnLcwyeooZzLc/+SkvchPsFoJG6AWTz3BJ3le2TMMAOhzsdwvISl46WxeVVA8FCgAMK21mIVS9KEEJQMFULd9awt4McVjYxcP4K7Fwz0+APCHHQdLvpfPs6oqTd/+85Pw4lf/DEdOb634v+UXVKDoUOkUWU5CszAwzCZZQDXLBWmTMYf7UPYWd5h4+R2rY8YmUzwGzz8SUcT3fGvxmG0zphZP3cALFO4fcVNUGBYoHlo8QPmocZBaPIbLAh3s4gFUxdWJgiIrtk9tLy1QxtJZ8K5PNX5P8WhEnAfDAhUoOqgZKJX1UWizUEbFHp5wvYk4PE02SAZZjlZB8dKH5ePJui0eixwUQDXKpnU8I3zM2NkUj36PHVAnjWjMOPzMnVba0nHT4olFFPClualcTm3x+FWgFEeNhwMScw/ot3jy0lZi+wqK8Y2JEf2SgvL824MlRRL/HSViEUp6NoAKFB3cyOxuiGlGTsdShTds2Fs8QfKfcPjCQC65tnrwZLSanKjUbcbGHy2zLBR1zNiNgqJnki18jRSU8MMVFI6b5X6KogjlNpXJ++JBAeRR41IFJQg3K6IFKt0QyP/fuYJiv8UjFyhTmTz+WPQPAcFSmYIKFSg6HKpyi0eroITVJDunqwWA97uxSsAVlH0+tHhaTBQUdZuxsYJiFHefzzNhMnQyZpwUJ2C9MWOKuq8X5mgLlA53y/34+2//aEqoeG5TZDm8EBkcL53iCYIXjSskclCb/Flx6kFxMsUjFygA8LTkQwmSTyeoUIGiw8Gxyi4K5PAWDw/3GvMYIFZr/mzJTHzjihPwpUsW1/pQyuBts31DvMXj/oLNX58Jk23GRlM8gHHc/eGJtDDZaoPvzDCK8gZUD0oTFSihp7e9NF3Y7Y0AvyDvGixEn/e0Jkq8KW7oLrZ4hiYC6EHRCWrjn5VYRLFtlm9x0+IpKlSnL+wGUGqUDdLvKKhQgaJhKpMThUKlp3hUL0KpSTasHpRELIKPn74AC3qC5xJXFRTvHhR+ohozUVDMWzzlK+8BtTDuaok7igc3NcnSFE/dEItGRCsmEYuIgDSncOX2nUOFxYN+KJ5dxYJ6MIgm2WKBksmp4YhcQbGrngDuWjw8CO+q98wFALy8ZziQRVxQoQJFAzcpJmIRtFdYyeBGSq6ghH2KJ8jwthlXFLz8jtukraaMlbZpRA6KqUm26EHJagsUd61Fs108vEAhD0p9wNs8fR1NUBR3k3IJoaBMiJ/lFVVBCV5QmxzExov4KYcTPIA0ZuxgFw+/IVo6rwvHzmwDY8DGNw8BkHw6AfgdBRUqUDTIW4zdngDsonoRSoPawhh1H3S0vXBPCkqxPZSVJgE4IgfFIEkWkFs8pcWNm5A2QL/HDhS2ck/wMWNSUOqCOdPUAsUtokDxUUHhOSiDE2lkc3mhLgaiQJGi7NUChafI2v9ciF08OkqlHpPpnChCZnY04cyjpwMAniq2eYLk0wkqVKBoUCd4Kh/VruZhMKSzeeEspwLFf7S/U09jxtIEkPZuKiO2GdsxyZYWN+qIsUsFRWOSTWXz4AIPKSj1AY+7n+mhqKiEgjJN8qCMTKktkCBcfCMRaXKpeI5V9/DYvwSq24zttXi4/6Q5HkVHUwzvO6ZQoHAfSpDSdoMKFSgaqjXBA5SaJeU3fZh2JYQFra/Hy8KsaEQRsrH2ZGW1zbjwPX0Pyp/2FqKwj5rR5uh49HrsQGmgFBUo9cHlJ8/Be4/oxl+eOs/1z+AX6/3FgthLscORNxpzj0VrIurIS1VJxMZvjYKSdKGgpLJ53UWfWvgEz6zOQjvuvUf2IBZR8M6hCewenAhUGyyoBOPdEyDcyuxuiEtJstx/0hwPzoe6ntAqKF4XMqpZKKUFSi5np8Wjn4OyZfcQAODk+V2OjkXuscvjk7y9k4i6j/UngsWxM9vxy0+vwBnFdoEbtBM7s/wwyRYNu7k8w7uHJ4tfC87C0KTGp+VGQZGN5nbaPNwgy0e425IxLCt+tp/ecZDGjG1AZy0NB6uwKJDDL1TpXB6jIQ9pCzodTVoPijdFQcTda1s8RQXFLAdFb8x4eCKDtw4Wxj5Pntvl6FhKe+zqzxQGWfKfEBKJWOn7wY8WTzIWFVMubx8qvI+D0N7hiEm3rNaDYv8SmIxFRAqvXsSAln2SgsI56+gZAICntx8kBcUGVKBoOFDFFk9MR0Gp9ORQo1KuoHj7PRttNLaXJFssULKqTPzSu0MAgAU9LZjmIAMFKO2xy6PGNGJM6JHQvDf9ClbkisnbBwvels7m4JzLmjQLA1UFxf5nQ1EUoZzaCWsTCopcoBzTAwD4w5sHRepuZwDSdoMKFSgaqrXJGJCWBebzGBMZKMH5UNcTWg+KV5+POmqsFiiMMZGDYh7UVrrFGpDaO/O6XB2PtscO0KJAQh+5rdGaiPqWu8R9KFxBCZIywJUSviDQjYICONtozFOrZYVq6dwutCVjGJrIYPdg4ftB+j0FDSpQNFTTg8IvYumsOpZHLZ7K4LuCkuRhbWpBIBvn7CwLzPpZoOhkodCiQEIP2YPi51oKrvy9fTCABUqsdB2EGwUFcLbRuH+kcC2Rf8exaASnL+wpeRzloBhDBYqG6npQuILC1AwUj+ZNQp+meLRE2vauoPC9HOqdVFYuUExaPAlNDgpjzHOBIu4QS+K8SUEhypE/B74WKMVWBR9fDlKBktQs1HSvoNhv8fTrKCgAxLgxJ0henaBBBYpEOpsXxqVqmmQz2TxGSUGpOB1ST9yrSVbs5ZAUFNn0akdB4S2e3YOTGBxPIx5VsHhWh6vj0UuTnSCTLKGDrKB4XRIow7NQeKEepAJF3VdVVFBcBLUBqp9rwqLFk83lRa6RdkrqTGkCKxmLOD6GRoIKFAm+RyIaUaoiuwmzZF4yyVKBUjHkXrvXFk+bmOJRT1Ryi8fUJBsrHTPeUjTILpnV4fpkpZ1SAMiDQugjFyh+jBhzpmnGigNVoBiaZJ1dAltsbjQ+OJZGnhWuJT2am92jZrSK33uQfkdBhAoUCe4/6WlNIGJyB+wXPCsjk5NMsjTFUzF48RdRvF+0W3TMcnJ0vdnbRztmvGXXEAD37R1A6rHTFA9hQYkHxUcFpbu19GIbpNaFaPFktS0edwqK1UZjbpDVbqAGCtNAXEWhAsUcKlAkqjliDKh30tlcXnhQqMVTOXiB0pqIed6z1KqjoMgpsmY/X+tB2bL7MADnAW0y2h47QDkohD6lHpRm336uNpgtSEFtfikofMzYaqMxHzE28vi8/9gZpt8nCtDVUGJ+dws+d/4xrteYOyUeUS9UfIrHr5E/ohwe1ubHKoFWnTuprI0UWUDyoGTzSGfz2FqMuD953jTXx6PtsQNqkmxznD7mhEoyXikFJcAtnlipR8utgmJ3ozEPaTP6/V5y4iwMTWawYmG3o3+/0XCsoDz55JO47LLLMHv2bCiKgvvvv7/k+4qi6P75zne+Ix4zODiIq6++Gh0dHejq6sL111+PsbExz0/GK0fNaMNNf3Ysrj3zyKr8e7LUzz0oXr0RhDFCQfFokAXUMeNSBcU6AwUofd1f7x9BOptHZ3McR/S0uD4efqLld4aArKCQUEqoyArKzE7/1OIge1CSmik3rx4Uq6j7fgsFJRpR8PHTF+Do3nZH/36j4fjMNT4+jqVLl2Lt2rW639+3b1/Jn5/+9KdQFAVXXXWVeMzVV1+NV199FY8++igefvhhPPnkk7jhhhvcP4uQEpN2spBJtvJwdcqPIlAEtaVkBaVw0jOb4AFKTbIvFceLl87r8tR2Uls8eh4Uek8RKvyiHIsomN7qY4Gi8aAEqUAxUlCcLAsE1M+S1RTPgIWCQtjD8Znr4osvxsUXX2z4/b6+vpL/fuCBB3Duuedi4cKFAIDXXnsNjzzyCJ5//nmccsopAIAf/ehHuOSSS/Dd734Xs2fPdnpIoSUhRd2rLR66mFQKVUHx/jvmd1JjqXKTrNViPtmD8qLH/BOO7pixSxmbqG+4SXZmR5OvwwBaBaUjQOcyNUmW7+LxOMVjt8VDHhNPVFT7HRgYwK9+9Stcf/314msbN25EV1eXKE4AYOXKlYhEInj22Wd1f04qlcLIyEjJn3ogJi8L5EFt5EGpGB2VUFDSOiZZKwVFykHhAW3LvBYo/A4xS1M8hDk8PXVmh7/DAE3xqJiOa0vGArVBWxTwosXjcopHfO7NCxRhkiUFxRMVfQf97Gc/Q3t7O6688krxtf7+fvT29pY8LhaLobu7G/39/bo/Z82aNejs7BR/5s2bV8nDrhqyF0FE3ZMHpWL82ZKZOH1hNz5yqvf3D5d65ah77kGJ2vSgHBxN4a0DhVjwpR4LFN0WTyZbPFYqUAiVM47uwRlH9eATFfDacaNskNo7gJQTJFo8+eLXHRYocetdPIwxUlB8oqIFyk9/+lNcffXVaGry9iLdcsstGB4eFn92797t0xHWFp4kO57KifYAjRlXjnndLbj7hhU4f/FMzz9LV0Hhm4wtp3gKrzvfYDy/u6VsAsIp2h47oCoo1OIhZHrbm3DXp07HZUv9b6d3FScgg5SBAuiNGRc9KG5NsiYKyvBkRphw/UzqbUQqdjV86qmnsG3bNvziF78o+XpfXx/2799f8rVsNovBwcEy/wonmUwimaxONkk14eOoPMEWANrI0BgKWsQunhzyeYZIRFFNshYKSiJWejfn1X8ClPfY+bEBpKAQ1YMX2kFbgMcLkVTWo4Jio8XDJ3imtcTp5sAjFVNQbr/9dixfvhxLly4t+fqKFSswNDSEzZs3i689/vjjyOfzOO200yp1OIEkXvzQHJ4oFChtyVhVEmwJ78itOG5GFWPGNnNQOP4UKOVjxrQskKg23CgbtBZP0veoe+MWD2/vkHriHce362NjY9ixY4f47507d2LLli3o7u7G/PnzAQAjIyO455578L3vfa/s7y9evBgXXXQRPvWpT+G2225DJpPB6tWr8dGPfrShJngA1UzJFRSa4AkPyVgEEQXIM2AilUVbMiZMsnZzUDheEmQ5TToeFFoWSFQbHnIZtALF/2WBxgoKHzH2c89Ro+JYQXnhhRewbNkyLFu2DABw8803Y9myZfjqV78qHnP33XeDMYa//Mu/1P0ZP//5z7Fo0SKcf/75uOSSS3DWWWfhJz/5icunEF74hYpX82SQDQ+KoohxZW5wFmPGllM8Ssn/X+Jyg7GMdkoBoGWBRPU5aW4XAOCEuZ21PRANWpOsewXFusVDBln/cHxFPOecc8AYM33MDTfcYBq81t3djbvuusvpP113aO+0ySAbLloTMYxOZcXJKuswBwUAFnvYYCyT1PhaAApqI6rPVcvn4uxjZ2BGe7A8g2oLNIdcniGdc+dBaZVaPIwx3XBFdcTYvz1HjUpwBtUbkITmQkYZKOGCG2W5giJaPJZJsurr7of/BCjvsWdyeeGJIQWFqCZBK06A0iDDlKQyOlVQeLs0z0r9XjJqzH3wfg9hgwqUGqK9026nFk+o0I4a21VQZA+KXwWKtscuS9DkQSEaHXWKJ4eUpDI696BI5niDNk8/mWR9gwqUGhLXtHjIJBsu1Lh7PsVjL0lWVlh8K1DipX4m3t6JRpSy9xlBNBq8EMnkmAhZi0cVRB1OTUYjiih2jCZ5uIIyq5NaPF6hAqWGaKc5yCQbLtSFgbzFY2+bMQ+z6mlN4IieVl+ORbuLhxtkW+JRT0sICaIe4AU8UAhSA9TIf6eYTfJMZXIYmij8fIq59w5dEWuItkAhD0q44HLvuNYka5GDMndaC3740ZMxd1qLb7k3wgQoWjyFoqmJ2jsEIVqggFqgyEWLE1oSMRyeyOgWKLy90xyPoqOZLq9eod9gDaEpnnDDx4zHxZixvRwUALj85Dm+HouY4snyba2UIksQnEhEQSIaQTqXx/CETwpKqrzFI48Yk3LpHWrx1JCyKR5q8YQKPnLIe9p2k2Qrgdxjz+WZGtJGEzwEAUBdqClaPK4VFOMWD20x9hcqUGqI9k6bTLLhQqug5IoFSi1MqbJcPZXJCZMsTfAQRAGumAx59qAUvWcZnRbPCIW0+QkVKDWkzCRLBUqoaOULA1Nq9ggAx5MBfiD32FPZvGqSpQKFIACoRbx3D4pxi4dGjP2FCpQaEo+QSTbMaKPuuUlWW3hWA95jBzQKCrV4CAKA2gZVp3hcFigmG437aQ+Pr1CBUkPiMY1JljwooaJVs5cjYzNJtlIkpYWB6qJAek8RBCApKBNcQXHZ4okbbzTeN0IKip9QgVJDtGZK8qCECzWorehBKSoo0RoFoyVjahaKuiiQPuIEAahtUNHicelBaTYzyZKC4it09qohlCQbbsqi7rlJtgZTPIC0sTWbo0WBBKGBKyZDk2kA7qd4hPdMU6Bkc3kcGEsBIJOsX1CBUkMURRHtgGhEIb9AyGgRUzylJlk7OSiVoElaGMhPnn5sSiaIeoB7TrwqKLzo3z86VfL1g2Np5PIM0YiC6W20KNAPqECpMdxQ2ZaMUbBPyGhLluagqGPGtVVQaIqHIMoRJtkJbzkoi2e1AwB+/Uo/vv+7bWCs8LnnI8a97cmaTPLVI1Sg1Bh+t00G2fAh8hCEglL0oNTo5MTvCFOZHCaLRROpcgRRgBcko0XPmFt18dzjevG/LjgWAPBvj+/APz70J+TzDP3DkwDIIOsndFWsMXw0lPwn4YOPGadzeaSzebHNuFZTPPLCQGGSJQWFIACon4+i4OF6zFhRFKw+7xh0NMfx1Qdexbpn3sbIZAZLZncAIIOsn9BVscZwBYUKlPDRKl38J9LZmuagANI+HnnMmBQUggBQ7jnx6s/6qxVHoKMpjr+75yXc++Ie/PbVfgCkoPgJtXhqjOxBIcJFLBoRRcFYKqsqKAEwydKyQIIoRZsc61ZBkbli2Rz8+8eWIxGLiK3mNMHjH1Sg1Ji4aPFQimwYaZVSJbmCUvOgtmxeCmqjAoUggPLdO0mf1MWVS2biZ594r1BUj+hp8eXnEtTiqTk8C4X28IST1mQUg+MFBSVTw23GgKqgpEqC2qhAIQigXEFp8kFB4aw4qgcPrD4TG98axPmLZ/r2cxsduirWGH4xIw9KOGmVJnlytW7x8CRZCmojiDK0nhO/FBTO0b3tOLq33def2ehQi6fGcAWlnTwooUSOu8/kaq2gSMsCxRQPfcQJAqisgkJUBnqFagx5UMJNqxR3n61xkqy8i4eWBRJEKZVWUAj/oQKlxiRiNMUTZniLZzydU3fx1GyKp/Bemkhnkc4WiiXyoBBEAa1JlhSU4ENXxRrzl++dDwA4+9gZNT4Swg2tYh9PVpriqa1J9nAxyhugMWOC4Gij7UlBCT5UoNSYy5bOxmVLZ9f6MAiXiM2mcg5KzZJkCyfgoYnCtlZF8SfrgSDqgfKgNvpsBB16hQjCA1xBGUtJOSg1WxbIFZRCgdIcj9ICSoIoUh7URgpK0KEChSA8wMOZJtJZZGo8ZsxPuEPjhRYP+U8IQkVrkiUFJfjQK0QQHlAVlCxyfBdPjTwo2m2tlCJLECplBQopKIGHChSC8IAIakvnRJJstFYeFM0JlxQUglApa/GQghJ46BUiCA/ICgrPQan1mDGHJngIQqVsFw8pKIGHChSC8EBLUvWg8ByUWptkOdTiIQgVuYCPR5WaKZ2EfahAIQgPiKC2VO23GZcVKNTiIQiB3AIl/0k4oAKFIDzAc1DG5RyUwLR4KOaIIDiRiIJEUd0k/0k4oFeJIDygKii1XxZYFuVNCgpBlMALE/KfhAMqUAjCAyLqvricDyCTLEEEFV60k4ISDuhVIggP8BaPTGDGjKlAIYgS+OoH8qCEAypQCMIDhTj50q/FazTFI/fYATLJEoQWrqBQimw4oFeJIDygKIrwoXBqNcUDlErXpKAQRClN5EEJFVSgEIRHtG2eWuYryMZY8qAQRCm8tUMKSjigV4kgPCIrKLGIUtMNwrzHDtAUD0FoESZZUlBCgeMC5cknn8Rll12G2bNnQ1EU3H///WWPee211/DBD34QnZ2daG1txamnnopdu3aJ709NTWHVqlXo6elBW1sbrrrqKgwMDHh6IgRRK/gkD1C7DBQOKSgEYQxXTkhBCQeOX6Xx8XEsXboUa9eu1f3+m2++ibPOOguLFi3CE088gZdffhlf+cpX0NTUJB5z00034aGHHsI999yDDRs2YO/evbjyyivdPwuCqCFyIVCrTcYc+cRLJlmCKIUrJ6SghAPHUZMXX3wxLr74YsPvf/nLX8Yll1yCb3/72+JrRx11lPj/w8PDuP3223HXXXfhvPPOAwDccccdWLx4MTZt2oTTTz/d6SERRE2RFZRorRUU6cRLJlmCKCVJCkqo8PVVyufz+NWvfoVjjz0WF154IXp7e3HaaaeVtIE2b96MTCaDlStXiq8tWrQI8+fPx8aNG3V/biqVwsjISMkfgggKJS2emisocouHou4JQkYNaqPiPQz4ejbdv38/xsbG8K1vfQsXXXQRfve73+FDH/oQrrzySmzYsAEA0N/fj0Qiga6urpK/O3PmTPT39+v+3DVr1qCzs1P8mTdvnp+HTRCeaJVbPLVWUKjFQxCGLJnVAQBYPKu9xkdC2MHXW6x8cVna5ZdfjptuugkAcPLJJ+OZZ57Bbbfdhve///2ufu4tt9yCm2++Wfz3yMgIFSlEYAiSSVburZNJliBK+djpC3Dh8X2Y0Z6s9aEQNvC1QJk+fTpisRiWLFlS8vXFixfj6aefBgD09fUhnU5jaGioREUZGBhAX1+f7s9NJpNIJukNRQQTWUGpdYtHDmqjMWOCKIeKk/Dg69k0kUjg1FNPxbZt20q+/sYbb2DBggUAgOXLlyMej+Oxxx4T39+2bRt27dqFFStW+Hk4BFEVSj0otW7xkIJCEER94FhBGRsbw44dO8R/79y5E1u2bEF3dzfmz5+Pz3/+8/jIRz6Cs88+G+eeey4eeeQRPPTQQ3jiiScAAJ2dnbj++utx8803o7u7Gx0dHfjMZz6DFStW0AQPEUpaSlo8NTbJSi0eUlAIgggzjguUF154Aeeee674b+4Nueaaa7Bu3Tp86EMfwm233YY1a9bgs5/9LI477jj8z//8D8466yzxd37wgx8gEongqquuQiqVwoUXXogf//jHPjwdgqg+bcngmWSTsUhNI/cJgiC84rhAOeecc8AYM33Mddddh+uuu87w+01NTVi7dq1h2BtBhAl5nLfWRQFXTSgDhSCIsENpNQThkTapxROUJNkWau8QBBFyqEAhCI/IZtSgjBk3kYJCEETIoQKFIDxSEnVf8xZPUUGhAoUgiJBDBQpBeEQuUOK1nuIptnZa4hRzTxBEuKGzGEF4pDSorbYKyllHT8eZR/fgL06hpGWCIMINFSgE4RF5iqfWCkpPWxI//yTlCREEEX6oxUMQHknEIkgUC5Nae1AIgiDqBSpQCMIHWothbbWe4iEIgqgXqEAhCB/gbZ5a56AQBEHUC3Q2JQgf4GFtpKAQBEH4AxUoBOEDLbzFQx4UgiAIX6AChSB8QFVQ6CNFEAThB3Q2JQgf4Mmt1OIhCILwBypQCMIHWosmWWrxEARB+AMVKAThAzM6kgCAruZEjY+EIAiiPqAkWYLwgU+9byHmdDXj8pPn1PpQCIIg6gIqUAjCB6a3JfFXK46o9WEQBEHUDdTiIQiCIAgicFCBQhAEQRBE4KAChSAIgiCIwEEFCkEQBEEQgYMKFIIgCIIgAgcVKARBEARBBA4qUAiCIAiCCBxUoBAEQRAEETioQCEIgiAIInBQgUIQBEEQROCgAoUgCIIgiMBBBQpBEARBEIGDChSCIAiCIAJHKLcZM8YAACMjIzU+EoIgCIIg7MKv2/w6bkYoC5TR0VEAwLx582p8JARBEARBOGV0dBSdnZ2mj1GYnTImYOTzeezduxft7e1QFMXXnz0yMoJ58+Zh9+7d6Ojo8PVnBwV6jvUBPcf6gJ5jfUDP0R6MMYyOjmL27NmIRMxdJqFUUCKRCObOnVvRf6Ojo6Nu32Qceo71AT3H+oCeY31Az9EaK+WEQyZZgiAIgiACBxUoBEEQBEEEDipQNCSTSXzta19DMpms9aFUDHqO9QE9x/qAnmN9QM/Rf0JpkiUIgiAIor4hBYUgCIIgiMBBBQpBEARBEIGDChSCIAiCIAIHFSgEQRAEQQQOKlAk1q5diyOOOAJNTU047bTT8Nxzz9X6kDzx5JNP4rLLLsPs2bOhKAruv//+ku8zxvDVr34Vs2bNQnNzM1auXInt27fX5mBdsGbNGpx66qlob29Hb28vrrjiCmzbtq3kMVNTU1i1ahV6enrQ1taGq666CgMDAzU6YufceuutOOmkk0Qw0ooVK/Cb3/xGfD/sz0+Pb33rW1AUBTfeeKP4Wtif59e//nUoilLyZ9GiReL7YX9+nD179uBjH/sYenp60NzcjBNPPBEvvPCC+H7YzzkAcMQRR5S9loqiYNWqVQDq47XM5XL4yle+giOPPBLNzc046qij8I1vfKNkf05VXktGMMYYu/vuu1kikWA//elP2auvvso+9alPsa6uLjYwMFDrQ3PNr3/9a/blL3+Z3XvvvQwAu++++0q+/61vfYt1dnay+++/n7300kvsgx/8IDvyyCPZ5ORkbQ7YIRdeeCG744472NatW9mWLVvYJZdcwubPn8/GxsbEYz796U+zefPmsccee4y98MIL7PTTT2dnnHFGDY/aGQ8++CD71a9+xd544w22bds29qUvfYnF43G2detWxlj4n5+W5557jh1xxBHspJNOYp/73OfE18P+PL/2ta+x448/nu3bt0/8OXDggPh+2J8fY4wNDg6yBQsWsGuvvZY9++yz7K233mK//e1v2Y4dO8Rjwn7OYYyx/fv3l7yOjz76KAPA1q9fzxirj9fym9/8Juvp6WEPP/ww27lzJ7vnnntYW1sb++EPfygeU43XkgqUIu9973vZqlWrxH/ncjk2e/ZstmbNmhoelX9oC5R8Ps/6+vrYd77zHfG1oaEhlkwm2X/913/V4Ai9s3//fgaAbdiwgTFWeD7xeJzdc8894jGvvfYaA8A2btxYq8P0zLRp09h//Md/1N3zGx0dZccccwx79NFH2fvf/35RoNTD8/za177Gli5dqvu9enh+jDH2hS98gZ111lmG36/Hcw5jjH3uc59jRx11FMvn83XzWl566aXsuuuuK/nalVdeya6++mrGWPVeS2rxAEin09i8eTNWrlwpvhaJRLBy5Ups3LixhkdWOXbu3In+/v6S59zZ2YnTTjsttM95eHgYANDd3Q0A2Lx5MzKZTMlzXLRoEebPnx/K55jL5XD33XdjfHwcK1asqLvnt2rVKlx66aUlzweon9dx+/btmD17NhYuXIirr74au3btAlA/z+/BBx/EKaecgg9/+MPo7e3FsmXL8H//7/8V36/Hc046ncadd96J6667Doqi1M1recYZZ+Cxxx7DG2+8AQB46aWX8PTTT+Piiy8GUL3XMpTLAv3m4MGDyOVymDlzZsnXZ86ciddff71GR1VZ+vv7AUD3OfPvhYl8Po8bb7wRZ555Jk444QQAheeYSCTQ1dVV8tiwPcdXXnkFK1aswNTUFNra2nDfffdhyZIl2LJlS108PwC4++678cc//hHPP/982ffq4XU87bTTsG7dOhx33HHYt28f/vEf/xHve9/7sHXr1rp4fgDw1ltv4dZbb8XNN9+ML33pS3j++efx2c9+FolEAtdcc03dnXMA4P7778fQ0BCuvfZaAPXxXgWAL37xixgZGcGiRYsQjUaRy+XwzW9+E1dffTWA6l0/qEAh6oJVq1Zh69atePrpp2t9KL5z3HHHYcuWLRgeHsZ///d/45prrsGGDRtqfVi+sXv3bnzuc5/Do48+iqamplofTkXgd54AcNJJJ+G0007DggUL8Mtf/hLNzc01PDL/yOfzOOWUU/Av//IvAIBly5Zh69atuO2223DNNdfU+Ogqw+23346LL74Ys2fPrvWh+Movf/lL/PznP8ddd92F448/Hlu2bMGNN96I2bNnV/W1pBYPgOnTpyMajZY5rQcGBtDX11ejo6os/HnVw3NevXo1Hn74Yaxfvx5z584VX+/r60M6ncbQ0FDJ48P2HBOJBI4++mgsX74ca9aswdKlS/HDH/6wbp7f5s2bsX//frznPe9BLBZDLBbDhg0b8G//9m+IxWKYOXNmXTxPma6uLhx77LHYsWNH3byOs2bNwpIlS0q+tnjxYtHKqqdzDgC88847+P3vf49PfvKT4mv18lp+/vOfxxe/+EV89KMfxYknnoiPf/zjuOmmm7BmzRoA1XstqUBB4QKwfPlyPPbYY+Jr+Xwejz32GFasWFHDI6scRx55JPr6+kqe88jICJ599tnQPGfGGFavXo377rsPjz/+OI488siS7y9fvhzxeLzkOW7btg27du0KzXPUI5/PI5VK1c3zO//88/HKK69gy5Yt4s8pp5yCq6++Wvz/enieMmNjY3jzzTcxa9asunkdzzzzzLIx/zfeeAMLFiwAUB/nHJk77rgDvb29uPTSS8XX6uW1nJiYQCRSWh5Eo1Hk83kAVXwtfbPbhpy7776bJZNJtm7dOvanP/2J3XDDDayrq4v19/fX+tBcMzo6yl588UX24osvMgDs+9//PnvxxRfZO++8wxgrjIl1dXWxBx54gL388svs8ssvD9XI39/8zd+wzs5O9sQTT5SM/U1MTIjHfPrTn2bz589njz/+OHvhhRfYihUr2IoVK2p41M744he/yDZs2MB27tzJXn75ZfbFL36RKYrCfve73zHGwv/8jJCneBgL//P8u7/7O/bEE0+wnTt3sj/84Q9s5cqVbPr06Wz//v2MsfA/P8YKI+KxWIx985vfZNu3b2c///nPWUtLC7vzzjvFY8J+zuHkcjk2f/589oUvfKHse/XwWl5zzTVszpw5Ysz43nvvZdOnT2d///d/Lx5TjdeSChSJH/3oR2z+/PkskUiw9773vWzTpk21PiRPrF+/ngEo+3PNNdcwxgqjYl/5ylfYzJkzWTKZZOeffz7btm1bbQ/aAXrPDQC74447xGMmJyfZ3/7t37Jp06axlpYW9qEPfYjt27evdgftkOuuu44tWLCAJRIJNmPGDHb++eeL4oSx8D8/I7QFStif50c+8hE2a9Yslkgk2Jw5c9hHPvKRknyQsD8/zkMPPcROOOEElkwm2aJFi9hPfvKTku+H/ZzD+e1vf8sA6B57PbyWIyMj7HOf+xybP38+a2pqYgsXLmRf/vKXWSqVEo+pxmupMCZFwxEEQRAEQQQA8qAQBEEQBBE4qEAhCIIgCCJwUIFCEARBEETgoAKFIAiCIIjAQQUKQRAEQRCBgwoUgiAIgiACBxUoBEEQBEEEDipQCIIgCIIIHFSgEARBEAQROKhAIQiCIAgicFCBQhAEQRBE4KAChSAIgiCIwPH/A4cGOQD7FHTuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = scan_controller.scan_axis(\n", + " axis = 'x',\n", + " start = -40,\n", + " stop = 40,\n", + " n_pixels = 80,\n", + " scan_time = 5)\n", + "plt.plot(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qdlutils.applications.qdlscan.application_controller:Starting counter task on DAQ.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for line in scan_controller.scan_image(\n", + " axis_1='x',\n", + " start_1=-40,\n", + " stop_1=40,\n", + " n_pixels_1=10,\n", + " axis_2='y',\n", + " start_2=-40,\n", + " stop_2=40,\n", + " n_pixels_2=10,\n", + " scan_time=5):\n", + " plt.plot(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scan_controller.stop_scan" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "from qdlutils.applications.qdlscan.application_controller import ScanController" + "from threading import Thread\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def scan_thread_function() -> None:\n", + "\n", + " for line in scan_controller.scan_image(\n", + " axis_1='x',\n", + " start_1=-40,\n", + " stop_1=40,\n", + " n_pixels_1=5,\n", + " axis_2='y',\n", + " start_2=-40,\n", + " stop_2=40,\n", + " n_pixels_2=5,\n", + " scan_time=5):\n", + " \n", + " data.append(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:qdlutils.applications.qdlscan.application_controller:Starting counter task on DAQ.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([2919., 2838., 2775., 2853., 2747.])]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAACUCAYAAABbRsnbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAO80lEQVR4nO3df0zV9aPH8dcBA6I4GP7giKBUlmgKBChhza8liT/morVdKzeQGa0Nu7rjbUkrmdrCpjlckuIf5h/JdLW0Hyuc4cKVFAix1Kve6S3lNg/gSAQqRM65f5QnmWLZ1w+f8/Y8H9tn8/Pm/T682IfJa5/zPuc4fD6fTwAAAIYIsTsAAADAjaC8AAAAo1BeAACAUSgvAADAKJQXAABgFMoLAAAwCuUFAAAYhfICAACMQnkBAABGobwAAACjWFZe2tvbtXDhQjmdTg0dOlSLFy9WV1fXddfMmDFDDoej3/HCCy9YFREAABjIYdVnG82ZM0dnz55VRUWFent7VVBQoClTpqiysnLANTNmzND999+v1atX+8ciIyPldDqtiAgAAAw0xIoHPXbsmKqqqlRfX6+MjAxJ0ttvv625c+dq/fr1iouLG3BtZGSkXC6XFbEAAMAtwJLyUltbq6FDh/qLiyRlZ2crJCRE3377rZ588skB1+7YsUPvvfeeXC6X5s+fr9dee02RkZEDzu/p6VFPT4//3Ov1qr29XcOGDZPD4bg5PxAAALCUz+dTZ2en4uLiFBJy/V0tlpQXj8ejkSNH9v9GQ4YoJiZGHo9nwHXPPvusxo4dq7i4OH3//fd6+eWXdeLECX344YcDriktLdWqVatuWnYAAGCf5uZmxcfHX3fODZWXFStW6M0337zunGPHjt3IQ/bz/PPP+/89efJkjRo1SjNnztSpU6d07733XnNNcXGx3G63/7yjo0NjxozR6cZEOe/kxVR2m/zpIrsj4ArjdvxqdwT84cx/2p0Al43J/2+7I0DSJfXqK32mqKiov5x7Q+Vl+fLlWrRo0XXn3HPPPXK5XGptbe0f6tIltbe339B+lszMTEnSyZMnBywv4eHhCg8Pv2rceWeInFGUF7uF3B5hdwRcYcgQS/bn4x8IHfjZcAyyIY7b7I4ASfrjv6e/s+XjhsrLiBEjNGLEiL+cl5WVpfPnz6uhoUHp6emSpP3798vr9foLyd/R1NQkSRo1atSNxAQAALcwS25NTJgwQbNnz1ZhYaHq6ur09ddfa8mSJXr66af9rzT66aeflJSUpLq6OknSqVOntGbNGjU0NOjHH3/Uxx9/rLy8PE2fPl3JyclWxAQAAAay7HmVHTt2KCkpSTNnztTcuXP1yCOPaOvWrf6v9/b26sSJE/rll18kSWFhYfriiy80a9YsJSUlafny5Xrqqaf0ySefWBURAAAYyJJXG0lSTEzMdd+QLjExUVe+P15CQoJqamqsigMAAG4R7GgFAABGobwAAACjUF4AAIBRKC8AAMAolBcAAGAUygsAADAK5QUAABiF8gIAAIxCeQEAAEahvAAAAKNQXgAAgFEoLwAAwCiUFwAAYBTKCwAAMArlBQAAGIXyAgAAjEJ5AQAARqG8AAAAo1BeAACAUSgvAADAKJQXAABgFMoLAAAwCuUFAAAYhfICAACMQnkBAABGobwAAACjUF4AAIBRKC8AAMAolBcAAGAUygsAADAK5QUAABiF8gIAAIxCeQEAAEahvAAAAKNQXgAAgFEoLwAAwCiUFwAAYBTKCwAAMArlBQAAGGVQykt5ebkSExMVERGhzMxM1dXVXXf++++/r6SkJEVERGjy5Mn67LPPBiMmAAAwgOXlZdeuXXK73SopKVFjY6NSUlKUk5Oj1tbWa84/ePCgnnnmGS1evFjfffedcnNzlZubqyNHjlgdFQAAGMDy8rJhwwYVFhaqoKBAEydO1JYtWxQZGalt27Zdc/7GjRs1e/ZsvfTSS5owYYLWrFmjtLQ0bdq0yeqoAADAAJaWl4sXL6qhoUHZ2dl/fsOQEGVnZ6u2tvaaa2pra/vNl6ScnJwB5/f09OjChQv9DgAAcOuytLycO3dOfX19io2N7TceGxsrj8dzzTUej+eG5peWlio6Otp/JCQk3JzwAAAgIBn/aqPi4mJ1dHT4j+bmZrsjAQAACw2x8sGHDx+u0NBQtbS09BtvaWmRy+W65hqXy3VD88PDwxUeHn5zAgMAgIBn6Z2XsLAwpaenq7q62j/m9XpVXV2trKysa67JysrqN1+S9u3bN+B8AAAQXCy98yJJbrdb+fn5ysjI0NSpU1VWVqbu7m4VFBRIkvLy8jR69GiVlpZKkpYuXap//etfeuuttzRv3jzt3LlThw4d0tatW62OCgAADGB5eVmwYIHa2tq0cuVKeTwepaamqqqqyr8p98yZMwoJ+fMG0LRp01RZWalXX31Vr7zyiu677z7t2bNHkyZNsjoqAAAwgMPn8/nsDnEzXbhwQdHR0fr5f+6RM8r4/cjGu3vP83ZHwBXu3/6r3RHwh9P/ZXcCXDb2Pw7bHQGSLvl69aU+UkdHh5xO53Xn8tcdAAAYhfICAACMQnkBAABGobwAAACjUF4AAIBRKC8AAMAolBcAAGAUygsAADAK5QUAABiF8gIAAIxCeQEAAEahvAAAAKNQXgAAgFEoLwAAwCiUFwAAYBTKCwAAMArlBQAAGIXyAgAAjEJ5AQAARqG8AAAAo1BeAACAUSgvAADAKJQXAABgFMoLAAAwCuUFAAAYhfICAACMQnkBAABGobwAAACjUF4AAIBRKC8AAMAolBcAAGAUygsAADAK5QUAABiF8gIAAIxCeQEAAEahvAAAAKNQXgAAgFEoLwAAwCiDUl7Ky8uVmJioiIgIZWZmqq6ubsC527dvl8Ph6HdEREQMRkwAAGAAy8vLrl275Ha7VVJSosbGRqWkpCgnJ0etra0DrnE6nTp79qz/OH36tNUxAQCAISwvLxs2bFBhYaEKCgo0ceJEbdmyRZGRkdq2bduAaxwOh1wul/+IjY21OiYAADDEECsf/OLFi2poaFBxcbF/LCQkRNnZ2aqtrR1wXVdXl8aOHSuv16u0tDS98cYbeuCBB645t6enRz09Pf7zjo4OSdKFLu9N+inw7/D++pvdEXCFS5e4HoGi7xe7E+CyS75euyNA0iX9fh18Pt9fzrW0vJw7d059fX1X3TmJjY3V8ePHr7lm/Pjx2rZtm5KTk9XR0aH169dr2rRpOnr0qOLj46+aX1paqlWrVl01Pjbtx5vyM+DftdLuALjC/9kdAH/KtzsALvtfuwOgn87OTkVHR193jqXl5Z/IyspSVlaW/3zatGmaMGGCKioqtGbNmqvmFxcXy+12+8+9Xq/a29s1bNgwORyOQclshQsXLighIUHNzc1yOp12xwlqXIvAwbUIHFyLwHIrXA+fz6fOzk7FxcX95VxLy8vw4cMVGhqqlpaWfuMtLS1yuVx/6zFuu+02Pfjggzp58uQ1vx4eHq7w8PB+Y0OHDv1HeQOR0+k09hfxVsO1CBxci8DBtQgspl+Pv7rjcpmlG3bDwsKUnp6u6upq/5jX61V1dXW/uyvX09fXp8OHD2vUqFFWxQQAAAax/Gkjt9ut/Px8ZWRkaOrUqSorK1N3d7cKCgokSXl5eRo9erRKS0slSatXr9ZDDz2kcePG6fz581q3bp1Onz6t5557zuqoAADAAJaXlwULFqitrU0rV66Ux+NRamqqqqqq/Jt4z5w5o5CQP28A/fzzzyosLJTH49Fdd92l9PR0HTx4UBMnTrQ6akAJDw9XSUnJVU+JYfBxLQIH1yJwcC0CS7BdD4fv77wmCQAAIEDw2UYAAMAolBcAAGAUygsAADAK5QUAABiF8hKAysvLlZiYqIiICGVmZqqurs7uSEHpwIEDmj9/vuLi4uRwOLRnzx67IwWt0tJSTZkyRVFRURo5cqRyc3N14sQJu2MFpc2bNys5Odn/ZmhZWVn6/PPP7Y4FSWvXrpXD4dCyZcvsjmI5ykuA2bVrl9xut0pKStTY2KiUlBTl5OSotbXV7mhBp7u7WykpKSovL7c7StCrqalRUVGRvvnmG+3bt0+9vb2aNWuWuru77Y4WdOLj47V27Vo1NDTo0KFDeuyxx/TEE0/o6NGjdkcLavX19aqoqFBycrLdUQYFL5UOMJmZmZoyZYo2bdok6fd3JE5ISNCLL76oFStW2JwueDkcDu3evVu5ubl2R4GktrY2jRw5UjU1NZo+fbrdcYJeTEyM1q1bp8WLF9sdJSh1dXUpLS1N77zzjl5//XWlpqaqrKzM7liW4s5LALl48aIaGhqUnZ3tHwsJCVF2drZqa2ttTAYElo6ODkm//9GEffr6+rRz5051d3f/7Y98wc1XVFSkefPm9fvbcasLuE+VDmbnzp1TX1+f/92HL4uNjdXx48dtSgUEFq/Xq2XLlunhhx/WpEmT7I4TlA4fPqysrCz99ttvuvPOO7V79+6gexf0QLFz5041Njaqvr7e7iiDivICwChFRUU6cuSIvvrqK7ujBK3x48erqalJHR0d+uCDD5Sfn6+amhoKzCBrbm7W0qVLtW/fPkVERNgdZ1BRXgLI8OHDFRoaqpaWln7jLS0tcrlcNqUCAseSJUv06aef6sCBA4qPj7c7TtAKCwvTuHHjJEnp6emqr6/Xxo0bVVFRYXOy4NLQ0KDW1lalpaX5x/r6+nTgwAFt2rRJPT09Cg0NtTGhddjzEkDCwsKUnp6u6upq/5jX61V1dTXPJyOo+Xw+LVmyRLt379b+/ft199132x0JV/B6verp6bE7RtCZOXOmDh8+rKamJv+RkZGhhQsXqqmp6ZYtLhJ3XgKO2+1Wfn6+MjIyNHXqVJWVlam7u1sFBQV2Rws6XV1dOnnypP/8hx9+UFNTk2JiYjRmzBgbkwWfoqIiVVZW6qOPPlJUVJQ8Ho8kKTo6WrfffrvN6YJLcXGx5syZozFjxqizs1OVlZX68ssvtXfvXrujBZ2oqKir9n3dcccdGjZs2C2/H4zyEmAWLFigtrY2rVy5Uh6PR6mpqaqqqrpqEy+sd+jQIT366KP+c7fbLUnKz8/X9u3bbUoVnDZv3ixJmjFjRr/xd999V4sWLRr8QEGstbVVeXl5Onv2rKKjo5WcnKy9e/fq8ccftzsaggjv8wIAAIzCnhcAAGAUygsAADAK5QUAABiF8gIAAIxCeQEAAEahvAAAAKNQXgAAgFEoLwAAwCiUFwAAYBTKCwAAMArlBQAAGIXyAgAAjPL/4Hn149pf9/YAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([2919., 2838., 2775., 2853., 2747.]), array([2882., 2795., 2805., 2774., 2791.])]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([2919., 2838., 2775., 2853., 2747.]), array([2882., 2795., 2805., 2774., 2791.]), array([2750., 2824., 2741., 2757., 2759.])]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([2919., 2838., 2775., 2853., 2747.]), array([2882., 2795., 2805., 2774., 2791.]), array([2750., 2824., 2741., 2757., 2759.]), array([2872., 2818., 2894., 2760., 2689.])]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([2919., 2838., 2775., 2853., 2747.]), array([2882., 2795., 2805., 2774., 2791.]), array([2750., 2824., 2741., 2757., 2759.]), array([2872., 2818., 2894., 2760., 2689.]), array([2779., 2796., 2828., 2796., 2724.])]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = []\n", + "scan_thread = Thread(target=scan_thread_function)\n", + "scan_thread.start()\n", + "current_length = 0\n", + "while len(data) < 5:\n", + " if current_length != len(data):\n", + " print(data)\n", + " plt.imshow(data)\n", + " plt.show()\n", + " current_length = len(data)" ] }, { @@ -19,12 +338,20 @@ ], "metadata": { "kernelspec": { - "display_name": "qdlutils", + "display_name": "qdlutilsdev", "language": "python", "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", "version": "3.9.20" } }, diff --git a/src/qdlutils/hardware/nidaq/counters/nidaqbatchedratecounter.py b/src/qdlutils/hardware/nidaq/counters/nidaqbatchedratecounter.py index 0dc1f57..b57c04c 100644 --- a/src/qdlutils/hardware/nidaq/counters/nidaqbatchedratecounter.py +++ b/src/qdlutils/hardware/nidaq/counters/nidaqbatchedratecounter.py @@ -209,7 +209,7 @@ class docstring. def start(self) -> None: ''' Configure the DAQ and start the clock task. - This method is called externally before a measurement is set to begi. + This method is called externally before a measurement is set to begin. ''' # If currently running, stop the clock task if self.running: diff --git a/src/qdlutils/hardware/nidaq/counters/nidaqtimedratecounter.py b/src/qdlutils/hardware/nidaq/counters/nidaqtimedratecounter.py index 39cc997..a7c3deb 100644 --- a/src/qdlutils/hardware/nidaq/counters/nidaqtimedratecounter.py +++ b/src/qdlutils/hardware/nidaq/counters/nidaqtimedratecounter.py @@ -125,14 +125,14 @@ class NidaqTimedRateCounter(NidaqBatchedRateCounter): def __init__(self, - daq_name = 'Dev1', - signal_terminal = 'PFI0', - clock_rate = 1000000, - sample_time_in_seconds = 1, - clock_terminal = None, - read_write_timeout = 10, - signal_counter = 'ctr2', - trigger_terminal = None,): + daq_name: str = 'Dev1', + signal_terminal: str = 'PFI0', + clock_rate: int = 1000000, + sample_time_in_seconds: float = 1, + clock_terminal: str = None, + read_write_timeout: float = 10, + signal_counter: str = 'ctr2', + trigger_terminal: str = None): # Save the only new attribute self.sample_time_in_seconds = sample_time_in_seconds From fa8d72ebbc41729494f5fb958d02a88f417a829c Mon Sep 17 00:00:00 2001 From: nsyama Date: Sat, 26 Oct 2024 00:03:58 -0700 Subject: [PATCH 03/24] Created YAML file and controller GUI --- src/qdlutils/applications/qdlple/main.py | 2 +- .../qdlscan/application_controller.py | 23 ++- .../applications/qdlscan/application_gui.py | 154 ++++++++++++++++++ .../qdlscan/config_files/qdlscan_base.yaml | 63 +++++++ src/qdlutils/applications/qdlscan/main.py | 37 ++++- 5 files changed, 267 insertions(+), 12 deletions(-) create mode 100644 src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml diff --git a/src/qdlutils/applications/qdlple/main.py b/src/qdlutils/applications/qdlple/main.py index 5e975e1..94a6d84 100644 --- a/src/qdlutils/applications/qdlple/main.py +++ b/src/qdlutils/applications/qdlple/main.py @@ -524,7 +524,7 @@ def save_data(self, event=None) -> None: 'scan_id', 'timestamp', 'original_name'], dtype='S')) - ds.attrs['application'] = 'qdlutils.qt3ple' + ds.attrs['application'] = 'qdlutils.qdlple' ds.attrs['qdlutils_version'] = qdlutils.__version__ ds.attrs['scan_id'] = self.id ds.attrs['timestamp'] = self.timestamp.strftime("%Y-%m-%d %H:%M:%S") diff --git a/src/qdlutils/applications/qdlscan/application_controller.py b/src/qdlutils/applications/qdlscan/application_controller.py index ae488e0..e797b9a 100644 --- a/src/qdlutils/applications/qdlscan/application_controller.py +++ b/src/qdlutils/applications/qdlscan/application_controller.py @@ -31,18 +31,19 @@ def __init__(self, # On initialization move all position controllers to zero. # WARNING: it is assumed that the zero is a valid position of the DAQ try: - # Set the positions to zero - pass + # Set the positions to zero on start up, this is necessary as it establishes + # a `last_write_value` for the controllers so that the position is defined. + self._set_axis(self, axis_controller=self.x_axis_controller, position=0) + self._set_axis(self, axis_controller=self.y_axis_controller, position=0) + self._set_axis(self, axis_controller=self.z_axis_controller, position=0) except Exception as e: - logger.warning(f'Could not set axes to zero: {e}') + logger.warning(f'Could not zero axes on startup: {e}') # This is a flag to keep track of if the controller is currently busy # Must turn on whenever a scan is being performed and remain on until # the scanner is free to perform another operation. # The external applications are required to flag this when in use. - - # TODO: Logic here is probably not right.... self.busy = False # This is a flag to keep track of if a scan is currently in progress @@ -55,6 +56,15 @@ def __init__(self, # controller to stop scanning. self.stop_scan = False + def get_position(self): + ''' + Returns the position based off of the last write values of the controllers + ''' + x = self.x_axis_controller.last_write_value + y = self.y_axis_controller.last_write_value + z = self.z_axis_controller.last_write_value + return x,y,z + def set_axis(self, axis: str, position: float): ''' Outward facing method for moving the position of an axis specified @@ -83,8 +93,6 @@ def set_axis(self, axis: str, position: float): logger.warning(f'Movement of axis {axis} failed due to exception: {e}') # Free up the controller self.busy = False - - def _set_axis(self, axis_controller: NidaqPositionController, position: float): ''' @@ -138,7 +146,6 @@ def scan_axis(self, self.stop() return data - def _scan_axis(self, axis_controller: str, start: float, diff --git a/src/qdlutils/applications/qdlscan/application_gui.py b/src/qdlutils/applications/qdlscan/application_gui.py index e69de29..75afc62 100644 --- a/src/qdlutils/applications/qdlscan/application_gui.py +++ b/src/qdlutils/applications/qdlscan/application_gui.py @@ -0,0 +1,154 @@ +import logging + +import matplotlib +from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk +import matplotlib.pyplot as plt + +import numpy as np +import tkinter as tk + +from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter + +matplotlib.use('Agg') + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +class LauncherApplicationView: + + ''' + Main application GUI view, loads SidePanel and ScanImage + ''' + def __init__(self, main_window: tk.Tk) -> None: + main_frame = tk.Frame(main_window) + main_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=40, pady=30) + + self.control_panel = ControlPanel(main_frame) + +class ControlPanel: + + def __init__(self, main_frame: tk.Frame): + + # Define frame for scan configuration and control + scan_frame = tk.Frame(main_frame) + scan_frame.pack(side=tk.TOP, padx=0, pady=0) + # Add buttons and text + row = 0 + tk.Label(scan_frame, + text='Scan control', + font='Helvetica 14').grid(row=row, column=0, pady=[0,5], columnspan=2) + # Confocal image section + row += 1 + tk.Label(scan_frame, + text='Confocal image', + font='Helvetica 12').grid(row=row, column=0, pady=[0,5], columnspan=2) + # Range of scan + row += 1 + tk.Label(scan_frame, text='Range (μm)').grid(row=row, column=0, padx=5, pady=2) + self.image_range_entry = tk.Entry(scan_frame, width=10) + self.image_range_entry.insert(10, 80) + self.image_range_entry.grid(row=row, column=1, padx=5, pady=2) + # Number of pixels + row += 1 + tk.Label(scan_frame, text='Number of pixels').grid(row=row, column=0, padx=5, pady=2) + self.image_pixels_entry = tk.Entry(scan_frame, width=10) + self.image_pixels_entry.insert(10, 80) + self.image_pixels_entry.grid(row=row, column=1, padx=5, pady=2) + # Scan speed + row += 1 + tk.Label(scan_frame, text='Time per row (s)').grid(row=row, column=0, padx=5, pady=2) + self.image_time_entry = tk.Entry(scan_frame, width=10) + self.image_time_entry.insert(10, 1) + self.image_time_entry.grid(row=row, column=1, padx=5, pady=2) + # Start button + row += 1 + self.image_start_button = tk.Button(scan_frame, text='Start scan', width=20) + self.image_start_button.grid(row=row, column=0, columnspan=2, pady=5) + + # Single axis scan section + row += 1 + tk.Label(scan_frame, + text='Position optimization', + font='Helvetica 12').grid(row=row, column=0, pady=[10,5], columnspan=2) + # Range of scan + row += 1 + tk.Label(scan_frame, text='Range XY (μm)').grid(row=row, column=0, padx=5, pady=2) + self.line_range_xy_entry = tk.Entry(scan_frame, width=10) + self.line_range_xy_entry.insert(10, 3) + self.line_range_xy_entry.grid(row=row, column=1, padx=5, pady=2) + # Number of pixels + row += 1 + tk.Label(scan_frame, text='Range Z (μm)').grid(row=row, column=0, padx=5, pady=2) + self.line_range_z_entry = tk.Entry(scan_frame, width=10) + self.line_range_z_entry.insert(10, 20) + self.line_range_z_entry.grid(row=row, column=1, padx=5, pady=2) + # Number of pixels + row += 1 + tk.Label(scan_frame, text='Number of pixels').grid(row=row, column=0, padx=5, pady=2) + self.line_pixels_entry = tk.Entry(scan_frame, width=10) + self.line_pixels_entry.insert(10, 80) + self.line_pixels_entry.grid(row=row, column=1, padx=5, pady=2) + # Scan speed + row += 1 + tk.Label(scan_frame, text='Time (s)').grid(row=row, column=0, padx=5, pady=2) + self.line_time_entry = tk.Entry(scan_frame, width=10) + self.line_time_entry.insert(10, 1) + self.line_time_entry.grid(row=row, column=1, padx=5, pady=2) + # Start buttons + row += 1 + self.line_start_x_button = tk.Button(scan_frame, text='Optimize X', width=20) + self.line_start_x_button.grid(row=row, column=0, columnspan=2, pady=[5,1]) + row += 1 + self.line_start_y_button = tk.Button(scan_frame, text='Optimize Y', width=20) + self.line_start_y_button.grid(row=row, column=0, columnspan=2, pady=1) + row += 1 + self.line_start_z_button = tk.Button(scan_frame, text='Optimize Z', width=20) + self.line_start_z_button.grid(row=row, column=0, columnspan=2, pady=[1,5]) + + # Define frame for DAQ and control + daq_frame = tk.Frame(main_frame) + daq_frame.pack(side=tk.TOP, padx=0, pady=0) + # Add buttons and text + row = 0 + tk.Label(daq_frame, + text='DAQ control', + font='Helvetica 14').grid(row=row, column=0, pady=[15,5], columnspan=2) + # X axis + row += 1 + self.x_axis_set_button = tk.Button(daq_frame, text='Set X (μm)', width=10) + self.x_axis_set_button.grid(row=row, column=0, columnspan=1, padx=5, pady=[5,1]) + self.x_axis_set_entry = tk.Entry(daq_frame, width=10) + self.x_axis_set_entry.insert(10, 0) + self.x_axis_set_entry.grid(row=row, column=1, padx=5, pady=[5,1]) + # Y axis + row += 1 + self.y_axis_set_button = tk.Button(daq_frame, text='Set Y (μm)', width=10) + self.y_axis_set_button.grid(row=row, column=0, columnspan=1, padx=5, pady=1) + self.y_axis_set_entry = tk.Entry(daq_frame, width=10) + self.y_axis_set_entry.insert(10, 0) + self.y_axis_set_entry.grid(row=row, column=1, padx=5, pady=1) + # Z axis + row += 1 + self.z_axis_set_button = tk.Button(daq_frame, text='Set Z (μm)', width=10) + self.z_axis_set_button.grid(row=row, column=0, columnspan=1, padx=5, pady=[1,5]) + self.z_axis_set_entry = tk.Entry(daq_frame, width=10) + self.z_axis_set_entry.insert(10, 0) + self.z_axis_set_entry.grid(row=row, column=1, padx=5, pady=1) + # Get button + row += 1 + self.get_position_button = tk.Button(daq_frame, text='Get current position', width=20) + self.get_position_button.grid(row=row, column=0, columnspan=2, pady=[1,5]) + + # Define frame for DAQ and control + config_frame = tk.Frame(main_frame) + config_frame.pack(side=tk.TOP, padx=0, pady=0) + row = 0 + tk.Label(config_frame, text="Hardware Configuration", font='Helvetica 14').grid(row=row, column=0, pady=[15,5], columnspan=1) + # Dialouge button to pick the YAML config + row += 1 + self.hardware_config_from_yaml_button = tk.Button(config_frame, text="Load YAML Config") + self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=1, pady=5) + + + diff --git a/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml b/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml new file mode 100644 index 0000000..460f609 --- /dev/null +++ b/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml @@ -0,0 +1,63 @@ +QDLSCAN: + ApplicationController: + import_path : qdlutils.applications.qdlscan.application_controller + class_name : ScanController + configure : + counters : Counter + x_axis_control : PiezoX + y_axis_control : PiezoY + z_axis_control : PiezoZ + + Counter: + import_path : qdlutils.hardware.nidaq.counters.nidaqtimedratecounter + class_name : NidaqTimedRateCounter + configure : + daq_name : Dev1 # NI DAQ Device Name + signal_terminal : PFI0 # DAQ Write channel + clock_terminal : # Digital input terminal for external clock (blank if using internal) + clock_rate: 100000 # NI DAQ clock rate in Hz + sample_time_in_seconds : 1 # Sampling time in seconds (updates later in scan) + read_write_timeout : 10 # timeout in seconds for read/write operations + signal_counter : ctr2 # NIDAQ counter to use for count + + PiezoX: + import_path : qdlutils.hardware.nidaq.analogoutputs.nidaqposition + class_name : NidaqPositionController + configure: + device_name: Dev1 # NIDAQ Device Name + write_channel: ao0 # DAQ Write channel + read_channel: # DAQ read channel + move_settle_time: 0.0 # Time in seconds to wait after movement + scale_microns_per_volt: 8 # Number of microns moved per volt + zero_microns_volt_offset: 5 # Value of voltage at position 0 microns + min_position: -40.0 # Minimum position in microns + max_position: 40.0 # Maximum position in microns + invert_axis: True # If True, modifies scale and offset internally to invert axis + + PiezoY: + import_path : qdlutils.hardware.nidaq.analogoutputs.nidaqposition + class_name : NidaqPositionController + configure: + device_name: Dev1 + write_channel: ao1 + read_channel: + move_settle_time: 0.0 + scale_microns_per_volt: 8 + zero_microns_volt_offset: 5 + min_position: -40.0 + max_position: 40.0 + invert_axis: True + + PiezoZ: + import_path : qdlutils.hardware.nidaq.analogoutputs.nidaqposition + class_name : NidaqPositionController + configure: + device_name: Dev1 + write_channel: ao2 + read_channel: + move_settle_time: 0.0 + scale_microns_per_volt: 8 + zero_microns_volt_offset: 5 + min_position: -40.0 + max_position: 40.0 + invert_axis: True \ No newline at end of file diff --git a/src/qdlutils/applications/qdlscan/main.py b/src/qdlutils/applications/qdlscan/main.py index e0e7586..03f33fe 100644 --- a/src/qdlutils/applications/qdlscan/main.py +++ b/src/qdlutils/applications/qdlscan/main.py @@ -8,6 +8,10 @@ from qdlutils.hardware.nidaq.analogoutputs.nidaqposition import NidaqPositionController from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter +from qdlutils.applications.qdlscan.application_gui import ( + LauncherApplicationView +) + logger = logging.getLogger(__name__) logging.basicConfig() @@ -27,7 +31,24 @@ class LauncherApplication(): def __init__(self, default_config_filename: str): - pass + # Load the YAML file based off of `controller_name` + #self.load_controller_from_name(yaml_filename=default_config_filename) + + # Initialize the root tkinter widget (window housing GUI) + self.root = tk.Tk() + # Create the main application GUI + self.view = LauncherApplicationView(main_window=self.root) + + def run(self) -> None: + ''' + This function launches the application itself. + ''' + # Set the title of the app window + self.root.title("qdlscan") + # Display the window (not in task bar) + self.root.deiconify() + # Launch the main loop + self.root.mainloop() class LineScanApplication(): @@ -37,7 +58,7 @@ class LineScanApplication(): 1-d confocal scans. ''' - def __init__(self, default_config_filename: str): + def __init__(self, ): pass @@ -48,6 +69,16 @@ class ImageScanApplication(): 2-d confocal scans. ''' - def __init__(self, default_config_filename: str): + def __init__(self, ): pass + + + +def main(): + tkapp = LauncherApplication(DEFAULT_CONFIG_FILE) + tkapp.run() + + +if __name__ == '__main__': + main() From 459f892a5305fd88e565735fabf9cfbb10fb475f Mon Sep 17 00:00:00 2001 From: nsyama Date: Sat, 26 Oct 2024 01:56:53 -0700 Subject: [PATCH 04/24] Added backend for single-axis line scans. --- src/qdlutils/applications/qdlmove/main.py | 5 +- .../qdlscan/application_controller.py | 7 +- .../applications/qdlscan/application_gui.py | 12 + .../qdlscan/config_files/qdlscan_base.yaml | 6 +- src/qdlutils/applications/qdlscan/main.py | 320 +++++++++++++++++- 5 files changed, 337 insertions(+), 13 deletions(-) diff --git a/src/qdlutils/applications/qdlmove/main.py b/src/qdlutils/applications/qdlmove/main.py index 0bbcc69..2de037c 100644 --- a/src/qdlutils/applications/qdlmove/main.py +++ b/src/qdlutils/applications/qdlmove/main.py @@ -103,9 +103,8 @@ def configure_from_yaml(self, afile: str) -> None: This method loads a YAML file to configure the qdlmove hardware based on yaml file indicated by argument `afile`. - This method configures the wavelength controller and the readers - based off of the YAML file data, and then generates a class - consctrutor for the main application controller. + This method constructs the positioners and configures them, then + stores them in a dictionary which is saved in the application. ''' with open(afile, 'r') as file: # Log selection diff --git a/src/qdlutils/applications/qdlscan/application_controller.py b/src/qdlutils/applications/qdlscan/application_controller.py index e797b9a..ae9b1c4 100644 --- a/src/qdlutils/applications/qdlscan/application_controller.py +++ b/src/qdlutils/applications/qdlscan/application_controller.py @@ -33,9 +33,9 @@ def __init__(self, try: # Set the positions to zero on start up, this is necessary as it establishes # a `last_write_value` for the controllers so that the position is defined. - self._set_axis(self, axis_controller=self.x_axis_controller, position=0) - self._set_axis(self, axis_controller=self.y_axis_controller, position=0) - self._set_axis(self, axis_controller=self.z_axis_controller, position=0) + self._set_axis(axis_controller=self.x_axis_controller, position=0) + self._set_axis(axis_controller=self.y_axis_controller, position=0) + self._set_axis(axis_controller=self.z_axis_controller, position=0) except Exception as e: logger.warning(f'Could not zero axes on startup: {e}') @@ -142,7 +142,6 @@ def scan_axis(self, scan_time=scan_time) # Free up the controller - self.busy = False self.stop() return data diff --git a/src/qdlutils/applications/qdlscan/application_gui.py b/src/qdlutils/applications/qdlscan/application_gui.py index 75afc62..02ea148 100644 --- a/src/qdlutils/applications/qdlscan/application_gui.py +++ b/src/qdlutils/applications/qdlscan/application_gui.py @@ -151,4 +151,16 @@ def __init__(self, main_frame: tk.Frame): self.hardware_config_from_yaml_button.grid(row=row, column=0, columnspan=1, pady=5) +class LineScanApplicationView: + + def __init__(self): + self.data_viewport = LineScanDataViewport + +class LineScanDataViewport: + + def __init__(self): + pass + + def update(): + pass diff --git a/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml b/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml index 460f609..a7ba383 100644 --- a/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml +++ b/src/qdlutils/applications/qdlscan/config_files/qdlscan_base.yaml @@ -2,11 +2,13 @@ QDLSCAN: ApplicationController: import_path : qdlutils.applications.qdlscan.application_controller class_name : ScanController - configure : - counters : Counter + hardware : + counter : Counter x_axis_control : PiezoX y_axis_control : PiezoY z_axis_control : PiezoZ + configure : + inter_scan_settle_time : 0.01 Counter: import_path : qdlutils.hardware.nidaq.counters.nidaqtimedratecounter diff --git a/src/qdlutils/applications/qdlscan/main.py b/src/qdlutils/applications/qdlscan/main.py index 03f33fe..17ffcb6 100644 --- a/src/qdlutils/applications/qdlscan/main.py +++ b/src/qdlutils/applications/qdlscan/main.py @@ -1,15 +1,20 @@ import importlib import importlib.resources import logging +import numpy as np +import datetime +from threading import Thread import tkinter as tk import yaml from qdlutils.hardware.nidaq.analogoutputs.nidaqposition import NidaqPositionController from qdlutils.hardware.nidaq.counters.nidaqtimedratecounter import NidaqTimedRateCounter +from qdlutils.applications.qdlscan.application_controller import ScanController from qdlutils.applications.qdlscan.application_gui import ( - LauncherApplicationView + LauncherApplicationView, + LineScanApplicationView ) logger = logging.getLogger(__name__) @@ -19,6 +24,9 @@ CONFIG_PATH = 'qdlutils.applications.qdlscan.config_files' DEFAULT_CONFIG_FILE = 'qdlscan_base.yaml' +# Dictionary for converting axis to an index +AXIS_INDEX = {'x': 0, 'y': 1, 'z': 2} + class LauncherApplication(): ''' @@ -31,14 +39,35 @@ class LauncherApplication(): def __init__(self, default_config_filename: str): + # Attributes + self.application_controller = None + self.min_x_position = None + self.min_y_position = None + self.min_z_position = None + self.max_x_position = None + self.max_y_position = None + self.max_z_position = None + + # Number of scan windows launched + self.number_scans = 0 + # Most recent scan -- maybe not needed? + self.current_scan = None + # Dictionary of scan parameters + self.scan_parameters = None + # Load the YAML file based off of `controller_name` - #self.load_controller_from_name(yaml_filename=default_config_filename) + self.load_yaml_from_name(yaml_filename=default_config_filename) # Initialize the root tkinter widget (window housing GUI) self.root = tk.Tk() # Create the main application GUI self.view = LauncherApplicationView(main_window=self.root) + # Bind the buttons + self.view.control_panel.line_start_x_button.bind("