From ac2026e5c028507c3acc130fde355066ea0ba54f Mon Sep 17 00:00:00 2001 From: Genevieve Buckley <30920819+GenevieveBuckley@users.noreply.github.com> Date: Thu, 13 Feb 2020 14:49:46 +1100 Subject: [PATCH 01/82] Increment version number for development --- piescope/_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/piescope/_version.py b/piescope/_version.py index b794fd4..1606ce1 100644 --- a/piescope/_version.py +++ b/piescope/_version.py @@ -1 +1 @@ -__version__ = '0.1.0' +__version__ = '0.2.0-dev' From f5adbcb7b734b01a29cdff18ca603c8f7f4a0f5e Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Tue, 2 Mar 2021 14:40:21 +1100 Subject: [PATCH 02/82] Added structured fill, pulse function for single and multi lines --- piescope/lm/structured.py | 54 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 piescope/lm/structured.py diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py new file mode 100644 index 0000000..2f83a84 --- /dev/null +++ b/piescope/lm/structured.py @@ -0,0 +1,54 @@ +"""Module for communication with the national intstruments controller. +""" + +import niqadmx +import time +from datetime import datetime +from niqadmx.constants import (LineGrouping) + +LINES = {'P00': 'Dev1/port0/line0', + 'P01': 'Dev1/port0/line1', + 'P02': 'Dev1/port0/line2', + 'P03': 'Dev1/port0/line3', + 'P04': 'Dev1/port0/line4', + 'P05': 'Dev1/port0/line5', + 'P06': 'Dev1/port0/line6', + 'P07': 'Dev1/port0/line7', + 'P10': 'Dev1/port1/line0', + 'P11': 'Dev1/port1/line1', + 'P12': 'Dev1/port1/line2', + 'P13': 'Dev1/port1/line3', + 'P14': 'Dev1/port1/line4', + 'P15': 'Dev1/port1/line5', + 'P16': 'Dev1/port1/line6', + 'P17': 'Dev1/port1/line7', + 'P20': 'Dev1/port2/line0', + 'P21': 'Dev1/port2/line1', + 'P22': 'Dev1/port2/line2', + 'P23': 'Dev1/port2/line3', + 'P24': 'Dev1/port2/line4', + 'P25': 'Dev1/port2/line5', + 'P26': 'Dev1/port2/line6', + 'P27': 'Dev1/port2/line7' + } + + +def single_line_pulse(delay, pin): + task = niqadmx.Task() + task.do_channels.add_do_chan( + pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + task.write(True) + time.sleep(delay/1e3) + task.write(False) + task.close() + + +def multi_line_pulse(delay, *pins): + task = niqadmx.Task() + for pin in pins: + task.do_channels.add_do_chan( + pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + task.write(True) + time.sleep(delay/1e3) + task.write(False) + task.close() From c0d476b78e0282204b12d6ba290a5596cdbea2dd Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Tue, 2 Mar 2021 14:41:30 +1100 Subject: [PATCH 03/82] Changed volume function to work with TTL --- piescope/lm/volume.py | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index edeae07..9ac416f 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -5,6 +5,7 @@ import piescope.lm.detector import piescope.lm.laser import piescope.lm.objective +import piescope.lm.structured logger = logging.getLogger(__name__) @@ -69,13 +70,13 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, # Initialize hardware if detector is None: detector = piescope.lm.detector.Basler() - if lasers is None: - lasers = piescope.lm.laser.initialize_lasers() + # if lasers is None: + # lasers = piescope.lm.laser.initialize_lasers() if objective_stage is None: objective_stage = piescope.lm.objective.StageController() - - for laser_name, (laser_power, exposure_time) in laser_dict.items(): - lasers[laser_name].laser_power = laser_power + # + # for laser_name, (laser_power, exposure_time) in laser_dict.items(): + # lasers[laser_name].laser_power = laser_power # Move objective lens stage to the top of the volume original_center_position = str(objective_stage.current_position()) @@ -94,10 +95,16 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, for channel, (laser_name, (laser_power, exposure_time)) in enumerate(laser_dict.items()): print("z_slice: {}, laser: {}".format(z_slice, laser_name)) logging.debug("laser_name: {}".format(laser_name)) + + for pattern in range(9): + piescope.lm.structured.multi_line_pulse(10, 'P25', 'P27') + piescope.lm.structured.single_line_pulse(10, 'P24') + + # Leftover code, remove when tested # Take an image - lasers[laser_name].emission_on() - volume[z_slice, :, :, channel] = detector.camera_grab(exposure_time) - lasers[laser_name].emission_off() + # lasers[laser_name].emission_on() + # /// ask sergy volume[z_slice, :, :, channel] = detector.camera_grab(exposure_time) + # lasers[laser_name].emission_off() # Move objective lens stage target_position = (float(original_center_position) + float(total_volume_height / 2.) From f6ff1e4f4ff50b12f10d3c85a27fac1e73c99f78 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 14:01:55 +1100 Subject: [PATCH 04/82] Fixed nidaqmx importing --- piescope/lm/structured.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 2f83a84..5860890 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -1,10 +1,10 @@ """Module for communication with the national intstruments controller. """ -import niqadmx +import nidaqmx import time from datetime import datetime -from niqadmx.constants import (LineGrouping) +from nidaqmx.constants import (LineGrouping) LINES = {'P00': 'Dev1/port0/line0', 'P01': 'Dev1/port0/line1', From 07952f6ccb25b44511a0b65c16aa03918a61ad7c Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 14:04:57 +1100 Subject: [PATCH 05/82] Added hardware triggering for camera_grab --- piescope/lm/detector.py | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 5c4b4b1..feb6d91 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -18,30 +18,46 @@ def __init__(self): self.currentImageIndex = 0 self.image = [] - def camera_grab(self, exposure_time=None, flip_image=True): + def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True): """Grab a new image from the Basler detector. Parameters ---------- exposure_time : int Exposure time, in microseconds (us). + trigger_mode : str + Trigger mode, possible values: + 'hardware' + 'software' Returns ------- self.image : numpy array """ self.camera.Open() - self.camera.ExposureMode.SetValue('Timed') - if exposure_time is not None: - try: - self.camera.ExposureTime.SetValue(float(exposure_time)) - except Exception as e: + self.camera.StopGrabbing() + + if trigger_mode is 'software': + self.camera.TriggerMode.SetValue('Off') + self.camera.ExposureMode.SetValue('Timed') + if exposure_time is not None: try: - self.camera.ExposureTimeAbs.SetValue(float(exposure_time)) + self.camera.ExposureTime.SetValue(float(exposure_time)) except Exception as e: - self.camera.Close() - raise e + try: + self.camera.ExposureTimeAbs.SetValue(float(exposure_time)) + except Exception as e: + self.camera.Close() + raise e + elif trigger_mode is 'hardware': + self.camera.TriggerMode.SetValue('On') + self.camera.TriggerSource.SetValue('Line4') + self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.AcquisitionFrameRateEnable.SetValue(False) + else: + raise ValueError('Select "software" or "hardware"') + self.camera.StopGrabbing() self.camera.StartGrabbingMax(self.imageCount) self.image = [] From 9daeb5a91ab8ed5c034cc41aa54d1859dc6f8176 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 14:11:23 +1100 Subject: [PATCH 06/82] Added nidaqmx to requirements --- requirements/default.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements/default.txt b/requirements/default.txt index f60d958..9aca3a5 100644 --- a/requirements/default.txt +++ b/requirements/default.txt @@ -4,3 +4,4 @@ scikit-image>=0.15.0 scipy>=1.3.0 pyserial PyYAML +nidaqmx \ No newline at end of file From 83840f86516311607d5d2b64f0ab1b365870cb06 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 14:12:06 +1100 Subject: [PATCH 07/82] Fixed references to nidaqmx --- piescope/lm/structured.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 5860890..1b4fef6 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -34,7 +34,7 @@ def single_line_pulse(delay, pin): - task = niqadmx.Task() + task = nidaqmx.Task() task.do_channels.add_do_chan( pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(True) @@ -44,7 +44,7 @@ def single_line_pulse(delay, pin): def multi_line_pulse(delay, *pins): - task = niqadmx.Task() + task = nidaqmx.Task() for pin in pins: task.do_channels.add_do_chan( pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) From 52853b08e30a35aaa2ba8011b98b24b03597be82 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 14:12:55 +1100 Subject: [PATCH 08/82] Minor spacing fix --- piescope/lm/detector.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index feb6d91..bf89b19 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -97,4 +97,4 @@ def maximum_exposure(self): max_exposure = self.camera.ExposureTimeAbs.Max except Exception as e: raise e - return max_exposure \ No newline at end of file + return max_exposure From 7bb283d864406506615735959e983dd774a45044 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Wed, 3 Mar 2021 15:37:57 +1100 Subject: [PATCH 09/82] Fixed function calls --- piescope/lm/structured.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 1b4fef6..2809bff 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -34,9 +34,11 @@ def single_line_pulse(delay, pin): + print(pin) + print(LINES[pin]) task = nidaqmx.Task() task.do_channels.add_do_chan( - pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(True) time.sleep(delay/1e3) task.write(False) @@ -46,9 +48,10 @@ def single_line_pulse(delay, pin): def multi_line_pulse(delay, *pins): task = nidaqmx.Task() for pin in pins: + print(pin) task.do_channels.add_do_chan( - pin, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) - task.write(True) + LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + task.write([True]*len(pins)) time.sleep(delay/1e3) - task.write(False) + task.write([False]*len(pins)) task.close() From 3319fde54042ee5120d13cba6c2972618b3f2524 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 10:08:20 +1100 Subject: [PATCH 10/82] removed unused import --- piescope/lm/structured.py | 1 - 1 file changed, 1 deletion(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 2809bff..ca4fa92 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -3,7 +3,6 @@ import nidaqmx import time -from datetime import datetime from nidaqmx.constants import (LineGrouping) LINES = {'P00': 'Dev1/port0/line0', From 26a570665bf886049039dcc5247ba77b45f2c3a6 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 10:08:43 +1100 Subject: [PATCH 11/82] Fixed camera_grab parameters --- piescope/lm/detector.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index bf89b19..8686b0e 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -4,6 +4,7 @@ import numpy as np from pypylon import pylon +from piescope.lm import structured class Basler(): @@ -29,6 +30,8 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr Trigger mode, possible values: 'hardware' 'software' + flip_image : bool, optional + Whether to flip images, by default True Returns ------- From 2ece58e286e193a32bd7e534b6d4846a8e0d766e Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 11:03:43 +1100 Subject: [PATCH 12/82] Removed unecessary prints --- piescope/lm/structured.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index ca4fa92..c563fe6 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -33,8 +33,6 @@ def single_line_pulse(delay, pin): - print(pin) - print(LINES[pin]) task = nidaqmx.Task() task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) @@ -47,7 +45,6 @@ def single_line_pulse(delay, pin): def multi_line_pulse(delay, *pins): task = nidaqmx.Task() for pin in pins: - print(pin) task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write([True]*len(pins)) From ae77043b462bf52e808c5f0fe8af1b636b11d521 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 11:14:07 +1100 Subject: [PATCH 13/82] Delay given in us, changed division factor to match --- piescope/lm/structured.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index c563fe6..0c97a84 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -37,7 +37,7 @@ def single_line_pulse(delay, pin): task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(True) - time.sleep(delay/1e3) + time.sleep(delay/1e6) task.write(False) task.close() @@ -48,6 +48,6 @@ def multi_line_pulse(delay, *pins): task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write([True]*len(pins)) - time.sleep(delay/1e3) + time.sleep(delay/1e6) task.write([False]*len(pins)) task.close() From d3c6601050ea57e5a4d1cbdd391d409d36e4bcce Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 11:15:05 +1100 Subject: [PATCH 14/82] Changed laser_name to pin for multi_pulse --- piescope/lm/volume.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 9ac416f..cdc2783 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -67,6 +67,12 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, z_slice_distance = int(z_slice_distance) total_volume_height = (num_z_slices - 1) * z_slice_distance + LASER_TO_PIN = {"laser640": 'P01', + "laser561": 'P02', + "laser488": 'P03', + "laser405": 'P03', + } + # Initialize hardware if detector is None: detector = piescope.lm.detector.Basler() @@ -74,7 +80,6 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, # lasers = piescope.lm.laser.initialize_lasers() if objective_stage is None: objective_stage = piescope.lm.objective.StageController() - # # for laser_name, (laser_power, exposure_time) in laser_dict.items(): # lasers[laser_name].laser_power = laser_power @@ -97,14 +102,14 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, logging.debug("laser_name: {}".format(laser_name)) for pattern in range(9): - piescope.lm.structured.multi_line_pulse(10, 'P25', 'P27') - piescope.lm.structured.single_line_pulse(10, 'P24') + piescope.lm.structured.multi_line_pulse(exposure_time, 'P25', LASER_TO_PIN[laser_name]) + piescope.lm.structured.single_line_pulse(10, 'P27') # Leftover code, remove when tested # Take an image # lasers[laser_name].emission_on() - # /// ask sergy volume[z_slice, :, :, channel] = detector.camera_grab(exposure_time) # lasers[laser_name].emission_off() + # Move objective lens stage target_position = (float(original_center_position) + float(total_volume_height / 2.) From 74b92bd603e67be2bdb59abfa7e0af42cb60d47e Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 11:59:10 +1100 Subject: [PATCH 15/82] Small documentation fixes --- piescope/lm/detector.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 8686b0e..f5e4b5d 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -27,11 +27,13 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr exposure_time : int Exposure time, in microseconds (us). trigger_mode : str - Trigger mode, possible values: - 'hardware' - 'software' + Trigger mode. + Available values are "software", "hardware" flip_image : bool, optional Whether to flip images, by default True + laser_name : str + Name of laser to use in live imaging. + Available values are "laser640", "laser561", "laser488", "laser405" Returns ------- @@ -81,7 +83,7 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr return self.image def minimum_exposure(self): - """Minimum alloable exposure time.""" + """Minimum allowable exposure time.""" try: min_exposure = self.camera.ExposureTime.Min except Exception: @@ -92,7 +94,7 @@ def minimum_exposure(self): return min_exposure def maximum_exposure(self): - """Maximum alloable exposure time.""" + """Maximum allowable exposure time.""" try: max_exposure = self.camera.ExposureTime.Max except Exception: From 34dc4a64e5dfb55b9982c89f3a3acda30055af34 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 12:00:21 +1100 Subject: [PATCH 16/82] Implemented hardware triggering as default --- piescope/lm/detector.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index f5e4b5d..041da53 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -18,8 +18,9 @@ def __init__(self): self.imageCount = 1 self.currentImageIndex = 0 self.image = [] + self.camera_pin = 'P07' - def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True): + def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None): """Grab a new image from the Basler detector. Parameters @@ -42,6 +43,14 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.Open() self.camera.StopGrabbing() + if laser_name is not None: + LASER_TO_PIN = {"laser640": 'P01', + "laser561": 'P02', + "laser488": 'P03', + "laser405": 'P04', + } + laser_pin = LASER_TO_PIN[laser_name] + if trigger_mode is 'software': self.camera.TriggerMode.SetValue('Off') self.camera.ExposureMode.SetValue('Timed') @@ -67,6 +76,9 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.image = [] while self.camera.IsGrabbing(): + if trigger_mode is 'hardware': + structured.multi_line_pulse(exposure_time, self.camera_pin, laser_pin) + grabResult = self.camera.RetrieveResult( 5000, pylon.TimeoutHandling_ThrowException) From 720d07dae022bbd90c6f5d7d8cac636c7e8e1316 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Thu, 4 Mar 2021 12:00:40 +1100 Subject: [PATCH 17/82] Changed volume shape to include patterns --- piescope/lm/volume.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index cdc2783..644feea 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -67,11 +67,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, z_slice_distance = int(z_slice_distance) total_volume_height = (num_z_slices - 1) * z_slice_distance - LASER_TO_PIN = {"laser640": 'P01', - "laser561": 'P02', - "laser488": 'P03', - "laser405": 'P03', - } + pattern_pin = 'P27' # Initialize hardware if detector is None: @@ -92,7 +88,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, # Create volume array to put the results into array_shape = np.shape(detector.camera_grab()) # no lasers on volume = np.ndarray(dtype=np.uint8, - shape=(num_z_slices, array_shape[0], array_shape[1], len(laser_dict))) + shape=(num_z_slices, array_shape[0], array_shape[1], len(laser_dict), 9)) # Acquire volume image for z_slice in range(int(num_z_slices)): @@ -102,8 +98,9 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, logging.debug("laser_name: {}".format(laser_name)) for pattern in range(9): - piescope.lm.structured.multi_line_pulse(exposure_time, 'P25', LASER_TO_PIN[laser_name]) - piescope.lm.structured.single_line_pulse(10, 'P27') + volume[z_slice, :, :, channel, pattern] = detector.camera_grab(exposure_time, trigger_mode='hardware', + laser_name=laser_name) + piescope.lm.structured.single_line_pulse(10, pattern_pin) # Leftover code, remove when tested # Take an image From 8b7123af87350babbf260f2460d831ddfb58a9d0 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Mon, 8 Mar 2021 18:09:28 +1100 Subject: [PATCH 18/82] Changed laser and camera pins --- piescope/lm/detector.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 041da53..61b904e 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -18,7 +18,7 @@ def __init__(self): self.imageCount = 1 self.currentImageIndex = 0 self.image = [] - self.camera_pin = 'P07' + self.camera_pin = 'P03' def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None): """Grab a new image from the Basler detector. @@ -44,10 +44,10 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.StopGrabbing() if laser_name is not None: - LASER_TO_PIN = {"laser640": 'P01', - "laser561": 'P02', - "laser488": 'P03', - "laser405": 'P04', + LASER_TO_PIN = {"laser640": 'P10', + "laser561": 'P05', + "laser488": 'P12', + "laser405": 'P13', } laser_pin = LASER_TO_PIN[laser_name] From d02843e53dc6de5716fb3d08c49d723cc31ed533 Mon Sep 17 00:00:00 2001 From: DavidDierickx Date: Mon, 8 Mar 2021 18:10:35 +1100 Subject: [PATCH 19/82] Added single_line_onoff function for pattern --- piescope/lm/structured.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 0c97a84..50d33fd 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -51,3 +51,11 @@ def multi_line_pulse(delay, *pins): time.sleep(delay/1e6) task.write([False]*len(pins)) task.close() + + +def single_line_onoff(onoff, pin): + task = nidaqmx.Task() + task.do_channels.add_do_chan( + LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + task.write(onoff) + task.close() From e0ff56cd91534734ed63cbdf88546cd92f954b9b Mon Sep 17 00:00:00 2001 From: DavidDierickx <> Date: Tue, 9 Mar 2021 11:37:19 +1100 Subject: [PATCH 20/82] Forced negative laser power to 0, >100 power to 100 --- piescope/lm/laser.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 8691935..4070207 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -173,6 +173,12 @@ def laser_power(self, value): Laser power percentage is limited to between 0 and 100. """ value = float(value) + if value <=0: + value = 0 + + elif value >= 100: + value = 100 + if 0 <= value <= 100: command = "(param-set! '" + self.ID + \ ":level " + str(round(value, 2)) + ")\r" From fd702b9a18723b853ea5cb5c8a5840c3d8a2487a Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 8 Dec 2021 15:15:57 +1100 Subject: [PATCH 21/82] update to github --- piescope/fibsem.py | 28 ++++++++++++++++++++--- piescope/lm/detector.py | 2 ++ piescope/lm/objective.py | 2 +- piescope/lm/volume.py | 48 ++++++++++++++++++++++++++++++++++------ piescope/utils.py | 39 +++++++++++++++++++++++--------- 5 files changed, 98 insertions(+), 21 deletions(-) diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 637616f..9b440ca 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -31,6 +31,7 @@ def initialize(ip_address='10.0.0.1'): # x = -55.4915 mm <- LIMIT HIT # + def move_to_light_microscope(microscope, x=50.0e-3, y=0.0): """Move the sample stage from the FIBSEM to the light microscope. @@ -56,8 +57,13 @@ def move_to_light_microscope(microscope, x=50.0e-3, y=0.0): stage_pos.t = the tilt of the FIBSEM sample stage (in radians) """ from autoscript_sdb_microscope_client.structures import StagePosition + current_position_x = microscope.specimen.stage.current_position.x + if current_position_x > 10e-3 or current_position_x < -10e-3: + print('Not under electron microscope, please reposition') + return new_position = StagePosition(x=x, y=y, z=0, r=0, t=0) microscope.specimen.stage.relative_move(new_position) + print("Moved to light microscope.") return microscope.specimen.stage.current_position @@ -86,9 +92,13 @@ def move_to_electron_microscope(microscope, x=-50.0e-3, y=0.0): stage_pos.t = the tilt of the FIBSEM sample stage (in radians) """ from autoscript_sdb_microscope_client.structures import StagePosition - + current_position_x = microscope.specimen.stage.current_position.x + if current_position_x > 60e-3 or current_position_x < 40e-3: + print('Not under light microscope, please reposition') + return new_position = StagePosition(x=x, y=y, z=0, r=0, t=0) microscope.specimen.stage.relative_move(new_position) + print("Moved to electron microscope.") return microscope.specimen.stage.current_position @@ -142,6 +152,7 @@ def new_electron_image(microscope, settings=None): return image +# i'm pretty sure Gen coded that somwhere, might save you some time figurting it out def last_ion_image(microscope): """Get the last previously acquired ion beam image. @@ -220,6 +231,17 @@ def create_rectangular_pattern(microscope, image, x0, x1, y0, y1, depth=1e-6): pixelsize_x = image.metadata.binary_result.pixel_size.x pixelsize_y = image.metadata.binary_result.pixel_size.y + if x0 > x1: + temp = x0 + x0 = x1 + x1 = temp + + if y0 > y1: + temp = y0 + y0 = y1 + y1 = temp + + width = (x1-x0) * pixelsize_x # real space (meters) height = (y1-y0) * pixelsize_y # real space (meters) @@ -268,7 +290,7 @@ def pixel_to_realspace_coordinate(coord, image): return realspace_coord -def autocontrast(microscope): +def autocontrast(microscope, view=2): """Automatically adjust the microscope image contrast. Parameters @@ -281,7 +303,7 @@ def autocontrast(microscope): Automatic contrast brightness settings. """ from autoscript_sdb_microscope_client.structures import RunAutoCbSettings - microscope.imaging.set_active_view(2) + microscope.imaging.set_active_view(view) autocontrast_settings = RunAutoCbSettings( method="MaxContrast", resolution="768x512", # low resolution, so as not to damage the sample diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 61b904e..e6d93bd 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -66,6 +66,7 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr elif trigger_mode is 'hardware': self.camera.TriggerMode.SetValue('On') self.camera.TriggerSource.SetValue('Line4') + self.camera.ExposureMode.SetValue('TriggerWidth') self.camera.AcquisitionFrameRateEnable.SetValue(False) else: @@ -92,6 +93,7 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.Close() if flip_image is True: self.image = np.flipud(self.image) + self.image = np.fliplr(self.image) return self.image def minimum_exposure(self): diff --git a/piescope/lm/objective.py b/piescope/lm/objective.py index 1d6aa84..85f920f 100644 --- a/piescope/lm/objective.py +++ b/piescope/lm/objective.py @@ -40,7 +40,7 @@ def __init__(self, host='169.254.111.111', port=139, timeout=5.0, if not testing: # try: self.connect((host, port)) - print('Successfully connected to SMARACT objective lens stage') + print('Successfully connected to SMARACT objective lens stage controller') # except socket.timeout: # # handle the timeout # except Exception as e: diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 644feea..ece9eb5 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -12,8 +12,8 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, - time_delay=1, count_max=5, threshold=5, - detector=None, lasers=None, objective_stage=None): + time_delay=1, count_max=5, threshold=5, phases=1, + angles=1, mode="widefield", detector=None, lasers=None, objective_stage=None): """Acquire an image volume using the fluorescence microscope. Parameters @@ -40,6 +40,20 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, is close enough to the target position. Must be a positive number. By default 5 + phases : int, optional + The number of phases for structured illumination, typically 3. + Must be a positive number. + By default 1 for widefield imaging + + angles : int, optional + The number of angles for structured illumination, typically 3. + Must be a positive number. + By default 1 for widefield imaging + + mode : str + Imaging mode, by default widefield. + Possible values are "widefield" and "sim". + detector : piescope.lm.detector.Basler(), optional Fluorescence detector class instance. Default value is None. @@ -68,7 +82,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, total_volume_height = (num_z_slices - 1) * z_slice_distance pattern_pin = 'P27' - + pattern_on_pin = 'P25' # Initialize hardware if detector is None: detector = piescope.lm.detector.Basler() @@ -88,7 +102,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, # Create volume array to put the results into array_shape = np.shape(detector.camera_grab()) # no lasers on volume = np.ndarray(dtype=np.uint8, - shape=(num_z_slices, array_shape[0], array_shape[1], len(laser_dict), 9)) + shape=(len(laser_dict), angles, num_z_slices, phases, array_shape[0], array_shape[1])) # Acquire volume image for z_slice in range(int(num_z_slices)): @@ -97,10 +111,30 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, print("z_slice: {}, laser: {}".format(z_slice, laser_name)) logging.debug("laser_name: {}".format(laser_name)) - for pattern in range(9): - volume[z_slice, :, :, channel, pattern] = detector.camera_grab(exposure_time, trigger_mode='hardware', - laser_name=laser_name) + if mode == "widefield": + piescope.lm.structured.single_line_onoff(True, pattern_on_pin) + for phase in range(2): + image = detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name) + image = np.fliplr(image) + volume[channel, 1, z_slice, phase, :, :] = image # (CAZPYX) + piescope.lm.structured.single_line_pulse(10, pattern_pin) + + #try volume[channel, 1, z_slice, 1, :, :] = + # detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name) + piescope.lm.structured.single_line_onoff(False, pattern_on_pin) + + else: + piescope.lm.structured.single_line_onoff(False, pattern_on_pin) + piescope.lm.structured.single_line_onoff(True, pattern_on_pin) piescope.lm.structured.single_line_pulse(10, pattern_pin) + for angle in range(angles): + for phase in range(phases): + image = detector.camera_grab( + exposure_time, trigger_mode='hardware', laser_name=laser_name) + volume[channel, angle, z_slice, phase, :, :] = image # (CAZPYX) + + piescope.lm.structured.single_line_pulse(10, pattern_pin) + # Leftover code, remove when tested # Take an image diff --git a/piescope/utils.py b/piescope/utils.py index c962d7b..a807814 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -7,6 +7,7 @@ import skimage.color import skimage.io import skimage.util +import tifffile def save_image(image, destination, metadata={}, *, allow_overwrite=False, @@ -60,7 +61,7 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, if allow_overwrite is False: while os.path.exists(destination): base, ext = os.path.splitext(destination) - regex_match = re.search("_\([0-9]*\)$", base) + regex_match = re.search("_\\([0-9]*\\)$", base) if regex_match: current_idx = int(regex_match.group(0)[2:-1]) # strip "_(" ")" suffix_len = len(regex_match.group(0)) @@ -86,13 +87,21 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, # Make sure we have the right datatype to svae for ImageJ if image.dtype.char not in 'BHhf': # uint8, uint16, int16, or ? image = skimage.util.img_as_uint(image) # 16 bit unsigned int - # If it's a volume image, must move channel axis before saving - if image.ndim == 4: # (ZYXC) - image = np.moveaxis(image, -1, 1) # move channel axis (ZCYX) - metadata.update({'axes':'ZCYX'}) - skimage.io.imsave(destination, image, imagej=True, - metadata=metadata) - logging.debug("Saved: {}".format(destination)) + # If it's a volume image, must split channels and save individually + if image.ndim == 5: # (AZPYX) + tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) + + + if image.ndim == 6: #(CAZPYX) --> (AZPYX) + volume_split = np.zeros(image.shape) + for i in range(image.shape[1]): + volume_split[:, i] = image[:, i] + metadata.update('axes:AZPYX') + destination = destination.replace('.tif', '') + '_channel_' + str(i) + '.tif' + logging.debug("Saved: {}".format(destination)) + tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, + metadata=metadata) + if image.ndim == 3: # (YXC) image = np.moveaxis(image, -1, 0) # move channel axis (CYX) metadata.update({'axes':'CYX'}) @@ -124,6 +133,15 @@ def max_intensity_projection(image, start_slice=0, end_slice=None): projected_max_intensity numpy array """ + results = [] + # if image.ndim == 6: #CAZPYX + # + # for channel_image in image: + # max_intensity = np.max(channel_image, axis=(0, 2)) + # results.append(max_intensity) + # projected_max_intensity = np.stack(results, axis=0) + # + # # Check input validity if image.ndim != 4: raise ValueError("expecting numpy.array with dimensions " @@ -134,7 +152,7 @@ def max_intensity_projection(image, start_slice=0, end_slice=None): else: image = image[start_slice:end_slice, ...] image = np.moveaxis(image, -1, 0) - results = [] + for channel_image in image: max_intensity = np.max(channel_image, axis=0) results.append(max_intensity) @@ -167,7 +185,8 @@ def rgb_image(image): "Expected an image with 2 or 3 dimensions, " "but found {} dimensions".format(image.ndim)) if image.ndim == 2: - rgb_image = skimage.color.gray2rgb(image) + rgb_image = image + # rgb_image = skimage.color.gray2rgb(image) return rgb_image elif image.ndim == 3: if image.shape[-1] == 1: From 113f68717f0d842e2129ebcea0e9d2f69e78da41 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 15 Dec 2021 15:51:30 +1100 Subject: [PATCH 22/82] NIcontroller python --- piescope/lm/mirror.py | 27 +++++++++++++++++++++++++++ piescope/lm/structured.py | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 piescope/lm/mirror.py diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py new file mode 100644 index 0000000..5cadca9 --- /dev/null +++ b/piescope/lm/mirror.py @@ -0,0 +1,27 @@ +from pipython import GCSDevice + + +class NIController: + def __init__(self): + super(NIController, self).__init__() + with GCSDevice('C-867') as self.device: + self.device.ConnectRS232(comport=4, baudrate=9600) + + if GCSDevice.IsRunningMacro(self.device): + startup_macro = GCSDevice.qRMC(self.device).strip('\n') + print(type(startup_macro)) + print(startup_macro) + print(f'Currently running macro: {startup_macro}, closing...') + GCSDevice.MAC_STOP(self.device, [1]) + else: + print(f'Not running any macros on startup') + + def testing(self): + self.device.InterfaceSetupDlg(key='sample') + print('connected: {}'.format(self.device.qIDN().strip())) + if self.device.HasqVER(): + print('version info: {}'.format(self.device.qVER().strip())) + GCSDevice.MAC_START(self.device, macro='TEST') + + +control = NIController() \ No newline at end of file diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 50d33fd..1511917 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -4,6 +4,8 @@ import nidaqmx import time from nidaqmx.constants import (LineGrouping) +import threading +from pipython import LINES = {'P00': 'Dev1/port0/line0', 'P01': 'Dev1/port0/line1', @@ -59,3 +61,34 @@ def single_line_onoff(onoff, pin): LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(onoff) task.close() + + +def read_line(pin): + task = nidaqmx.Task() + task.di_channels.add_di_chan( + LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES + ) + + data = task.read() + while not data: + data = task.read() + while data: + data = task.read() + task.close() + + +# single_line_onoff(onoff=True, pin='P03') +# read_line('P06') +# single_line_onoff(onoff=True, pin='P03') +# read_line('P06') +# single_line_onoff(onoff=True, pin='P03') +# read_line('P06') + + +def live_structured_worker(stop_event, run_time): + pass + +def continuous_reading(run_time): + stop_event = threading.Event() + _thread = threading.Thread(target=live_structured_worker, args=(stop_event, run_time)) + _thread.start() From a83062772eeff17cf3901ce16734ab139b95424c Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 16 Dec 2021 09:35:12 +1100 Subject: [PATCH 23/82] removed incorrect import --- piescope/lm/structured.py | 1 - 1 file changed, 1 deletion(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index 1511917..f608629 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -5,7 +5,6 @@ import time from nidaqmx.constants import (LineGrouping) import threading -from pipython import LINES = {'P00': 'Dev1/port0/line0', 'P01': 'Dev1/port0/line1', From dd9ec6bba7dbeb91b3cfa18ed8ba0999cb9cfc2f Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 24 Jan 2022 11:50:26 +1100 Subject: [PATCH 24/82] added arduino and PIStage controls --- piescope/lm/__init__.py | 3 + piescope/lm/arduino.py | 48 ++++++++++++++ piescope/lm/detector.py | 81 +++++++++++++++++++++--- piescope/lm/laser.py | 4 +- piescope/lm/mirror.py | 104 ++++++++++++++++++++++++------- piescope/lm/structured.py | 28 +++++++-- piescope/lm/volume.py | 128 ++++++++++++++++++++++---------------- piescope/utils.py | 48 +++++++------- 8 files changed, 326 insertions(+), 118 deletions(-) create mode 100644 piescope/lm/arduino.py diff --git a/piescope/lm/__init__.py b/piescope/lm/__init__.py index c94b038..40c43eb 100644 --- a/piescope/lm/__init__.py +++ b/piescope/lm/__init__.py @@ -1,4 +1,7 @@ +import piescope.lm.arduino import piescope.lm.detector import piescope.lm.laser +import piescope.lm.mirror import piescope.lm.objective +import piescope.lm.structured import piescope.lm.volume diff --git a/piescope/lm/arduino.py b/piescope/lm/arduino.py new file mode 100644 index 0000000..a0ab480 --- /dev/null +++ b/piescope/lm/arduino.py @@ -0,0 +1,48 @@ +import time +import serial +import serial.tools.list_ports + +DEFAULT_SERIAL_PORT = 'COM7' # default laser serial communication port + +class Arduino: + """Arduino Class""" + def __init__(self, serial_port=DEFAULT_SERIAL_PORT): + self.SERIAL_PORT = serial_port + self.connection = connect_serial_port(self.SERIAL_PORT) + + def send_volume_info(self, laser_dict): + string_to_send = 'E' + for laser_name in ['laser640', 'laser561', 'laser488', 'laser405']: + if laser_name in laser_dict.keys(): + string_to_send += str(int(laser_dict[laser_name][1]/1e3)) + ' ' + else: + string_to_send += str(0) + ' ' + + self._write_serial_command(command=string_to_send) + + def _write_serial_command(self, command): + self.connection.close() + self.connection.open() + time.sleep(1) # required, not sure why + self.connection.write(bytes(command, 'utf-8')) + self.connection.close() + + +def connect_serial_port(port=DEFAULT_SERIAL_PORT, baudrate=115200, timeout=3): + """Serial port for communication with the lasers. + + Parameters + ---------- + port : str, optional + Serial port device name, by default 'COM6'. + baudrate : int, optional + Rate of communication, by default 115200 bits per second. + timeout : int, optional + Timeout period, by default 1 second. + + Returns + ------- + pyserial Serial() object + Serial port for communication with the lasers. + """ + return serial.Serial(port, baudrate=baudrate, timeout=timeout) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index e6d93bd..9904735 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -4,6 +4,9 @@ import numpy as np from pypylon import pylon + +import piescope.lm.mirror +from piescope.lm.mirror import StagePosition, StageMacro from piescope.lm import structured @@ -18,9 +21,9 @@ def __init__(self): self.imageCount = 1 self.currentImageIndex = 0 self.image = [] - self.camera_pin = 'P03' + self.camera_pin = 'P14' - def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None): + def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None, laser_pins=None): """Grab a new image from the Basler detector. Parameters @@ -35,6 +38,9 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr laser_name : str Name of laser to use in live imaging. Available values are "laser640", "laser561", "laser488", "laser405" + laser_pins : list of str + Pin names to trigger pins via hardware. + Individual names passed as 'PXX', with XX being the port and pin number, respectively Returns ------- @@ -44,13 +50,24 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.StopGrabbing() if laser_name is not None: - LASER_TO_PIN = {"laser640": 'P10', - "laser561": 'P05', - "laser488": 'P12', - "laser405": 'P13', - } + if laser_pins is not None: + LASER_TO_PIN = {"laser640": laser_pins[0], + "laser561": laser_pins[1], + "laser488": laser_pins[2], + "laser405": laser_pins[3], + } + else: + LASER_TO_PIN = {"laser640": 'P00', + "laser561": 'P01', + "laser488": 'P02', + "laser405": 'P03', + } laser_pin = LASER_TO_PIN[laser_name] + else: + # raise ValueError('No laser selected') + pass + # TODO: Check this out if trigger_mode is 'software': self.camera.TriggerMode.SetValue('Off') self.camera.ExposureMode.SetValue('Timed') @@ -64,11 +81,19 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.Close() raise e elif trigger_mode is 'hardware': + # set input + self.camera.LineSelector.SetValue('Line4') self.camera.TriggerMode.SetValue('On') self.camera.TriggerSource.SetValue('Line4') self.camera.ExposureMode.SetValue('TriggerWidth') self.camera.AcquisitionFrameRateEnable.SetValue(False) + + # # set output + # self.camera.LineSelector.SetValue('Line3') + # self.camera.LineMode.SetValue('Output') + # self.camera.LineSource.SetValue('ExposureActive') + else: raise ValueError('Select "software" or "hardware"') @@ -78,7 +103,8 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr while self.camera.IsGrabbing(): if trigger_mode is 'hardware': - structured.multi_line_pulse(exposure_time, self.camera_pin, laser_pin) + structured.single_line_pulse(delay=exposure_time, pin=laser_pin) + # structured.multi_line_pulse(exposure_time, self.camera_pin, laser_pin, 'P27') #TODO remove direct reference to pin 27 grabResult = self.camera.RetrieveResult( 5000, pylon.TimeoutHandling_ThrowException) @@ -96,6 +122,45 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.image = np.fliplr(self.image) return self.image + def grab_slice(self, n_images=9, mirror_controller=None, arduino=None, laser_dict=None, flip_image=True): + """Grab a slice using Arduino and NI controller""" + + self.camera.Open() + self.camera.LineSelector.SetValue('Line4') + self.camera.TriggerMode.SetValue('On') + self.camera.TriggerSource.SetValue('Line4') + + self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.AcquisitionFrameRateEnable.SetValue(False) + + self.camera.MaxNumBuffer = 27 + self.camera.StopGrabbing() + # self.camera.StartGrabbing(pylon.GrabStrategy_OneByOne) + self.camera.StartGrabbingMax(n_images*len(laser_dict)) + self.images = [] + + arduino.send_volume_info(laser_dict=laser_dict) + mirror_controller.stopAll() + mirror_controller.start_macro(macro_name=StageMacro.MAIN) + + while self.camera.IsGrabbing(): + grabResult = self.camera.RetrieveResult( + 5000, pylon.TimeoutHandling_ThrowException) + if grabResult.GrabSucceeded(): + image = grabResult.Array + if flip_image is True: + image = np.flipud(image) + image = np.fliplr(image) + self.images.append(image) + + else: + raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + + grabResult.ErrorDescription) + grabResult.Release() + self.camera.Close() + print(self.images) + return self.images + def minimum_exposure(self): """Minimum allowable exposure time.""" try: diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 4070207..7f6d31d 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -24,8 +24,8 @@ _laser_id_to_name = {i[1]: i[0] for i in _available_lasers} -def initialize_lasers(serial_port=None): - """Initialize all available lasers. +def initialise_lasers(serial_port=None): + """Initialise all available lasers. Parameters ---------- diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index 5cadca9..cf26f43 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -1,27 +1,85 @@ from pipython import GCSDevice +from enum import Enum, auto -class NIController: +class StagePosition(Enum): + WIDEFIELD = [3, 3] + HORIZONTAL = [2, -3] + SIXTY = [-3, -3] + ONETWENTY = [-2, 2] + + +class StageMacro(Enum): + MAIN = auto() + PHASE = auto() + MOVEA = auto() + MOVER = auto() + ONTARGET = auto() + + +class StageMode(Enum): + WIDEFIELD = auto() + SIM = auto() + + +class PIController: def __init__(self): - super(NIController, self).__init__() - with GCSDevice('C-867') as self.device: - self.device.ConnectRS232(comport=4, baudrate=9600) - - if GCSDevice.IsRunningMacro(self.device): - startup_macro = GCSDevice.qRMC(self.device).strip('\n') - print(type(startup_macro)) - print(startup_macro) - print(f'Currently running macro: {startup_macro}, closing...') - GCSDevice.MAC_STOP(self.device, [1]) - else: - print(f'Not running any macros on startup') - - def testing(self): - self.device.InterfaceSetupDlg(key='sample') - print('connected: {}'.format(self.device.qIDN().strip())) - if self.device.HasqVER(): - print('version info: {}'.format(self.device.qVER().strip())) - GCSDevice.MAC_START(self.device, macro='TEST') - - -control = NIController() \ No newline at end of file + super(PIController, self).__init__() + self.COM_PORT = 4 + self.device = GCSDevice() + self._open_device() + self.axes = self.device.allaxes + self.move_to(StagePosition.WIDEFIELD) + self.current_position = StagePosition.WIDEFIELD + self.mode = StageMode.WIDEFIELD + + def home(self) -> None: + """Returns the stage to 0 on all axes""" + GCSDevice.MOV(self.device, self.axes, len(self.axes)*[0]) + + def move_to(self, stage_position: StagePosition) -> None: + self.stopAll() + GCSDevice.MOV(self.device, self.axes, stage_position.value) + self.start_macro(StageMacro.ONTARGET) + self.current_position = stage_position + print(f'Current position: {self.current_position.name}') + + def get_current_position(self): + """Returns currently set position, not necessarily actual position""" + return self.current_position.value + + def next_position(self): + """Moves to the next SIM angle""" + if self.mode == StageMode.WIDEFIELD: + return + self.stopAll() + if self.current_position == StagePosition.SIXTY: + self.move_to(StagePosition.ONETWENTY) + elif self.current_position == StagePosition.ONETWENTY: + self.move_to(StagePosition.HORIZONTAL) + elif self.current_position == StagePosition.HORIZONTAL: + self.move_to(StagePosition.SIXTY) + + def set_mode(self, mode=StageMode.WIDEFIELD): + self.mode = mode + + def get_mode(self): + return self.mode + + def start_macro(self, macro_name: StageMacro, *args) -> None: + GCSDevice.MAC_START(self.device, macro=macro_name.name, args=args) + + def stopAll(self) -> None: + """Stops all movement and macros""" + GCSDevice.StopAll(self.device, noraise=True) + + def _open_device(self) -> None: + # self.device.InterfaceSetupDlg() + self.device.ConnectRS232(comport=self.COM_PORT, baudrate=115200, autoconnect=False) + # stop any previous or start-up macros + if GCSDevice.IsRunningMacro(self.device): + startup_macro = GCSDevice.qRMC(self.device).strip('\n') + print(f'Currently running macro: {startup_macro}, closing...') + self.stopAll() + else: + print(f'Not running any macros on startup.') diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index f608629..facbcdf 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -38,7 +38,7 @@ def single_line_pulse(delay, pin): task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(True) - time.sleep(delay/1e6) + time.sleep(delay/1e6) # us to s task.write(False) task.close() @@ -48,8 +48,9 @@ def multi_line_pulse(delay, *pins): for pin in pins: task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) + task.write([False]*len(pins)) task.write([True]*len(pins)) - time.sleep(delay/1e6) + time.sleep(delay/1e6) # us to s task.write([False]*len(pins)) task.close() @@ -63,22 +64,36 @@ def single_line_onoff(onoff, pin): def read_line(pin): + timeout = 3 + start_time = time.time() task = nidaqmx.Task() task.di_channels.add_di_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES ) + triggered = False + data = task.read() - while not data: + while not triggered: data = task.read() + if data: + triggered = True + if time.time() >= start_time + timeout: + print('Stage settling timed out') + break + while data: data = task.read() + if time.time() >= start_time + timeout: + print('Stage settling timed out') + break task.close() -# single_line_onoff(onoff=True, pin='P03') -# read_line('P06') -# single_line_onoff(onoff=True, pin='P03') +# single_line_pulse(3e6, 'P02') +# multi_line_pulse(3e6, 'P14', 'P13') +# read_line('P13') +# a# single_line_onoff(onoff=True, pin='P05') # read_line('P06') # single_line_onoff(onoff=True, pin='P03') # read_line('P06') @@ -87,6 +102,7 @@ def read_line(pin): def live_structured_worker(stop_event, run_time): pass + def continuous_reading(run_time): stop_event = threading.Event() _thread = threading.Thread(target=live_structured_worker, args=(stop_event, run_time)) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index ece9eb5..ff28829 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -6,6 +6,8 @@ import piescope.lm.laser import piescope.lm.objective import piescope.lm.structured +import piescope.lm.mirror +from piescope.lm.mirror import StagePosition, StageMacro logger = logging.getLogger(__name__) @@ -13,7 +15,8 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, time_delay=1, count_max=5, threshold=5, phases=1, - angles=1, mode="widefield", detector=None, lasers=None, objective_stage=None): + angles=1, mode="widefield", detector=None, lasers=None, + objective_stage=None, mirror_controller=None, arduino=None, laser_pins=None): """Acquire an image volume using the fluorescence microscope. Parameters @@ -66,6 +69,15 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, Objective lens stage class instance. Default value is None. + mirror_controller : piescope.lm.mirror.PIController(), optional + Stage controller for structured pattern mirror. + Default value is None. + + laser_pins : list of str + Pin names to trigger pins via hardware. + Individual names passed as 'PXX', with XX being the port and pin number, respectively + Default values is None. + Returns ------- volume : multidimensional numpy array @@ -81,17 +93,17 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, z_slice_distance = int(z_slice_distance) total_volume_height = (num_z_slices - 1) * z_slice_distance - pattern_pin = 'P27' - pattern_on_pin = 'P25' # Initialize hardware if detector is None: detector = piescope.lm.detector.Basler() - # if lasers is None: - # lasers = piescope.lm.laser.initialize_lasers() + if lasers is None: + lasers = piescope.lm.laser.initialize_lasers() if objective_stage is None: objective_stage = piescope.lm.objective.StageController() - # for laser_name, (laser_power, exposure_time) in laser_dict.items(): - # lasers[laser_name].laser_power = laser_power + for laser_name, (laser_power, exposure_time) in laser_dict.items(): + lasers[laser_name].laser_power = laser_power + if mirror_controller is None: + mirror_controller = piescope.lm.mirror.PIController() # Move objective lens stage to the top of the volume original_center_position = str(objective_stage.current_position()) @@ -99,66 +111,72 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, time.sleep(time_delay) # Pause to be sure movement is completed logger.debug('Objective lens stage moved to top of the image volume.') + if mode != 'widefield': + angles = 3 + phases = 3 + # Create volume array to put the results into array_shape = np.shape(detector.camera_grab()) # no lasers on volume = np.ndarray(dtype=np.uint8, shape=(len(laser_dict), angles, num_z_slices, phases, array_shape[0], array_shape[1])) # Acquire volume image + # For each slice for z_slice in range(int(num_z_slices)): logging.debug("z_slice: {}".format(z_slice)) - for channel, (laser_name, (laser_power, exposure_time)) in enumerate(laser_dict.items()): - print("z_slice: {}, laser: {}".format(z_slice, laser_name)) - logging.debug("laser_name: {}".format(laser_name)) - - if mode == "widefield": - piescope.lm.structured.single_line_onoff(True, pattern_on_pin) - for phase in range(2): - image = detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name) - image = np.fliplr(image) - volume[channel, 1, z_slice, phase, :, :] = image # (CAZPYX) - piescope.lm.structured.single_line_pulse(10, pattern_pin) - - #try volume[channel, 1, z_slice, 1, :, :] = - # detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name) - piescope.lm.structured.single_line_onoff(False, pattern_on_pin) - - else: - piescope.lm.structured.single_line_onoff(False, pattern_on_pin) - piescope.lm.structured.single_line_onoff(True, pattern_on_pin) - piescope.lm.structured.single_line_pulse(10, pattern_pin) + + if mode == "widefield": + mirror_controller.stopAll() + mirror_controller.move_to(StagePosition.WIDEFIELD) + for channel, (laser_name, (laser_power, exposure_time)) in enumerate(laser_dict.items()): + print("z_slice: {}, laser: {}".format(z_slice, laser_name)) + logging.debug("laser_name: {}".format(laser_name)) + + image = detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name, laser_pins=laser_pins) + image = np.fliplr(image) + volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) + + else: + # n_images = angles * phases * len(laser_dict) + slice = detector.grab_slice(mirror_controller=mirror_controller, arduino=arduino, laser_dict=laser_dict) + + + slice_reshaped = np.array(slice).reshape(len(laser_dict), angles, phases, array_shape[0], array_shape[1]) + # assert slice_reshaped.shape == () + + img_index = list(range(len(slice))) + for channel in range(len(laser_dict)): for angle in range(angles): for phase in range(phases): - image = detector.camera_grab( - exposure_time, trigger_mode='hardware', laser_name=laser_name) - volume[channel, angle, z_slice, phase, :, :] = image # (CAZPYX) - - piescope.lm.structured.single_line_pulse(10, pattern_pin) - - - # Leftover code, remove when tested - # Take an image - # lasers[laser_name].emission_on() - # lasers[laser_name].emission_off() - - # Move objective lens stage - target_position = (float(original_center_position) - + float(total_volume_height / 2.) - - (float(z_slice) * float(z_slice_distance)) - ) - objective_stage.move_relative(-int(z_slice_distance)) - time.sleep(time_delay) # Pause to be sure movement is completed. - # If objective stage movement not accurate enough, try it again - count = 0 + # get the index for each parameters image in the slice + # see notebook for details + idx = img_index[channel::len(laser_dict)][angle::angles][phase::phases][0] + # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] + slice_reshaped[channel, angle, phase] = slice[idx] + + # Channel, then phase, then angle + volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) + + # Move objective lens stage + target_position = (float(original_center_position) + + float(total_volume_height / 2.) + - (float(z_slice) * float(z_slice_distance)) + ) + objective_stage.move_relative(-int(z_slice_distance)) + time.sleep(time_delay) # Pause to be sure movement is completed. + # If objective stage movement not accurate enough, try it again + count = 0 + current_position = float(objective_stage.current_position()) + difference = current_position - target_position + while count < count_max and abs(difference) > threshold: + objective_stage.move_relative(-int(difference)) + time.sleep(time_delay) # Pause to be sure movement completed. current_position = float(objective_stage.current_position()) difference = current_position - target_position - while count < count_max and abs(difference) > threshold: - objective_stage.move_relative(-int(difference)) - time.sleep(time_delay) # Pause to be sure movement completed. - current_position = float(objective_stage.current_position()) - difference = current_position - target_position - logger.debug('Difference is: {}'.format(str(difference))) - count = count + 1 + logger.debug('Difference is: {}'.format(str(difference))) + count = count + 1 + piescope.lm.structured.single_line_pulse(100000, 'P04') + # TODO: add to pins in main # Finally, return the objective lens stage too original position objective_stage.move_absolute(original_center_position) diff --git a/piescope/utils.py b/piescope/utils.py index a807814..112228f 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -91,18 +91,17 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, if image.ndim == 5: # (AZPYX) tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) - - if image.ndim == 6: #(CAZPYX) --> (AZPYX) + elif image.ndim == 6: #(CAZPYX) --> (AZPYX) volume_split = np.zeros(image.shape) for i in range(image.shape[1]): volume_split[:, i] = image[:, i] - metadata.update('axes:AZPYX') + metadata.update({'axes': 'AZPYX'}) destination = destination.replace('.tif', '') + '_channel_' + str(i) + '.tif' logging.debug("Saved: {}".format(destination)) tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, metadata=metadata) - if image.ndim == 3: # (YXC) + elif image.ndim == 3: # (YXC) image = np.moveaxis(image, -1, 0) # move channel axis (CYX) metadata.update({'axes':'CYX'}) skimage.io.imsave(destination, image, imagej=True, @@ -134,29 +133,30 @@ def max_intensity_projection(image, start_slice=0, end_slice=None): numpy array """ results = [] - # if image.ndim == 6: #CAZPYX - # - # for channel_image in image: - # max_intensity = np.max(channel_image, axis=(0, 2)) - # results.append(max_intensity) - # projected_max_intensity = np.stack(results, axis=0) - # - # + # TODO: make this consistent + if image.ndim == 6: #CAZPYX + + for channel_image in image: + max_intensity = np.max(channel_image, axis=(0, 1, 2)) + results.append(max_intensity) + projected_max_intensity = np.stack(results, axis=-1) + # Check input validity - if image.ndim != 4: - raise ValueError("expecting numpy.array with dimensions " - "(pln, row, col, ch)") - # Slice image stack - if end_slice is None: - image = image[start_slice:, ...] else: - image = image[start_slice:end_slice, ...] - image = np.moveaxis(image, -1, 0) + if image.ndim != 4: + raise ValueError("expecting numpy.array with dimensions " + "(pln, row, col, ch)") + # Slice image stack + if end_slice is None: + image = image[start_slice:, ...] + else: + image = image[start_slice:end_slice, ...] + image = np.moveaxis(image, -1, 0) - for channel_image in image: - max_intensity = np.max(channel_image, axis=0) - results.append(max_intensity) - projected_max_intensity = np.stack(results, axis=-1) + for channel_image in image: + max_intensity = np.max(channel_image, axis=0) + results.append(max_intensity) + projected_max_intensity = np.stack(results, axis=-1) return projected_max_intensity From 4db96248e6cd3b3225ace6ec740c48e6618c56a8 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 21 Feb 2022 10:20:43 +1100 Subject: [PATCH 25/82] fixed calibrations for mirror/shift --- piescope/lm/mirror.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index cf26f43..f4efb8d 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -3,12 +3,13 @@ class StagePosition(Enum): - WIDEFIELD = [3, 3] - HORIZONTAL = [2, -3] - SIXTY = [-3, -3] + WIDEFIELD = [2, -3] + HORIZONTAL = [-3, -3] + SIXTY = [3, 3] ONETWENTY = [-2, 2] + class StageMacro(Enum): MAIN = auto() PHASE = auto() From e0ba5eb69874f97002ff15d87a65a24da5495d74 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 16:14:49 +1100 Subject: [PATCH 26/82] refactored laser.py --- piescope/config.yml | 21 +++ piescope/lm/laser.py | 300 ++++++++++++++++++++++--------------------- piescope/utils.py | 52 ++++++++ 3 files changed, 230 insertions(+), 143 deletions(-) create mode 100644 piescope/config.yml diff --git a/piescope/config.yml b/piescope/config.yml new file mode 100644 index 0000000..ab6b371 --- /dev/null +++ b/piescope/config.yml @@ -0,0 +1,21 @@ +serial: + port: 'COM15' + baudrate: 115200 + timeout: 1 +lasers: +- name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 +- name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 +- name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 +- name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 7f6d31d..13a1178 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -1,27 +1,13 @@ """Module for laser control via serial communication.""" -import collections -import time +import os import warnings +from dataclasses import dataclass -import time -import warnings - -import serial -import serial.tools.list_ports +import numpy as np +import piescope +from piescope import utils -DEFAULT_SERIAL_PORT = 'COM3' # default laser serial communication port -_available_serial_ports = serial.tools.list_ports.comports() -_available_port_names = [port.device for port in _available_serial_ports] -_available_lasers = (("laser640", "laser1", 640), # (far-red) - ("laser561", "laser2", 561), # (RFP) - ("laser488", "laser3", 488), # (GFP) - ("laser405", "laser4", 405)) # (DAPI) -_laser_name_to_wavelength = {i[0]: i[2] for i in _available_lasers} -_laser_wavelength_to_name = {i[2]: i[0] for i in _available_lasers} -_laser_wavelength_to_id = {i[2]: i[1] for i in _available_lasers} -_laser_id_to_wavelength = {i[1]: i[2] for i in _available_lasers} -_laser_name_to_id = {i[0]: i[1] for i in _available_lasers} -_laser_id_to_name = {i[1]: i[0] for i in _available_lasers} +config_path = os.path.join(os.path.dirname(piescope.__file__), "config.yml") def initialise_lasers(serial_port=None): @@ -41,156 +27,184 @@ def initialise_lasers(serial_port=None): try: serial_port = connect_serial_port() except Exception: - warnings.warn('Default laser serial port not available.\n' - 'Fall back to {}'.format(_available_port_names[0])) + warnings.warn( + "Default laser serial port not available.\n" + "Fall back to {}".format(_available_port_names[0]) + ) serial_port = connect_serial_port(_available_port_names[0]) - all_lasers = {name: Laser(name, serial_port) - for name in list(_laser_name_to_wavelength)} + all_lasers = { + laser["name"]: Laser(laser["name"], serial_port) for laser in _available_lasers + } return all_lasers -def connect_serial_port(port=DEFAULT_SERIAL_PORT, baudrate=115200, timeout=1): - """Serial port for communication with the lasers. +@dataclass +class Laser: + name: str + serial_id: str + wavelength: float + power: float + exposure_time: float # us + enabled: bool - Parameters - ---------- - port : str, optional - Serial port device name, by default 'COM6'. - baudrate : int, optional - Rate of communication, by default 115200 bits per second. - timeout : int, optional - Timeout period, by default 1 second. - Returns - ------- - pyserial Serial() object - Serial port for communication with the lasers. - """ - if port == DEFAULT_SERIAL_PORT: - if DEFAULT_SERIAL_PORT not in _available_port_names: - warnings.warn('Default laser serial port not available.\n' - 'Fall back to port {}'.format()) - port = _available_port_names[0] - return serial.Serial(port, baudrate=baudrate, timeout=timeout) +class Laser_Controller: + def __init__(self): + + settings = utils.read_config(config_path) + + self.lasers = {} + self.serial_connection = utils.connect_serial_port(settings) + # grab available lasers + for laser in settings["lasers"]: + current_laser = Laser( + name=laser["name"], + serial_id=laser["ID"], + wavelength=laser["wavelength"], + power=0.0, + exposure_time=0.0, + enabled=False, + ) + self.lasers[current_laser.name] = current_laser -class Laser(): - """Laser class.""" + # set initial laser values + for laser in self.lasers.values(): + self.enable(laser) + self.set_laser_power(laser, laser.power) + self.set_exposure_time(laser, laser.exposure_time) + self.emission_on(laser) + import time - def __init__(self, name, serial_port, laser_power=0., - exposure_time=0., selected=False): - """Initialize instance of Laser class. Laser enabled by default. + time.sleep(1) + self.emission_off(laser) + + def set_laser_power(self, laser: Laser, power: float) -> None: + """sets power level of laser Parameters ---------- - name : str - Laser name string for serial communication. - Available options: - * "laser640" with wavelength 640nm (far-red) - * "laser561" with wavelength 561nm (RFP) - * "laser488" with wavelength 488nm (GFP) - * "laser405" with wavelength 405nm (DAPI) - serial_port : pyserial Serial() object - Serial communication port for the laser. - laser_power : float, optional - Laser power percentage, by default 1%. - exposure_time : float - Feature request from our users - sometimes they want the ability - to set different exposure times (as well as different laser powers) - for different wavelengths. - selected - bool - Whether the laser currently selected. - Eg: For use a volume acquisition later on, etc. + laser : Laser + laser to set the power level of + power : float + percentage of total power to set + + Raises + ------ + TypeError + Laser power percentage must be a float """ - self.NAME = name - self.ID = _laser_name_to_id[self.NAME] - self.WAVELENGTH = _laser_name_to_wavelength[self.NAME] - self.SERIAL_PORT = serial_port - self.laser_power = laser_power - self.exposure_time = exposure_time - self.selected = selected - self.enable() - - def emission_on(self): - """Start emitting laser light""" - command_turn_on = "(param-set! '" + self.ID + ":cw #t)\r" - self._write_serial_command(command_turn_on) - return command_turn_on - - def emission_off(self): - """Stop emitting laser light""" - command_turn_off = "(param-set! '" + self.ID + ":cw #f)\r" - self._write_serial_command(command_turn_off) - return command_turn_off - - def enable(self): - """Enable the laser. + if not isinstance(power, float): + raise TypeError(f"Power must be a float. {type(power)} was passed.") + + power = np.clip(power, 0.0, 100.0) + command = ( + "(param-set! '" + laser.serial_id + ":level " + str(round(power, 2)) + ")\r" + ) + utils.write_serial_command(self.serial_connection, command) + laser.power = power + + def get_laser_power(self, laser: Laser) -> float: + """returns the laser power + + Parameters + ---------- + laser : Laser + laser to get the power level of Returns ------- - str - Serial command to enable the laser. + float + laser power as percentage of total """ - command = "(param-set! '" + self.ID + ":enable #t)\r" - self._write_serial_command(command) - self.enabled = True - return command + return laser.power - def disable(self): - """Disable the laser. + def set_exposure_time(self, laser: Laser, exposure_time: float) -> None: + """sets exposure time of laser - Returns - ------- - str - Serial command to disable the laser. + Parameters + ---------- + laser : Laser + laser to set the exposure time of + exposure time : float + exposure time to set in microseconds + + Raises + ------ + TypeError + Laser power percentage must be a float """ - command = "(param-set! '" + self.ID + ":enable #f)\r" - self._write_serial_command(command) - self.enabled = False - return command + if not isinstance(exposure_time, float): + raise TypeError( + f"Exposure time must be a float. {type(exposure_time)} was passed." + ) - @property - def laser_power(self): - return self._laser_power + exposure_time = np.clip( + exposure_time, 0.0, 10.0e6 + ) # unable to reverse the flow of time + laser.exposure_time = exposure_time - @laser_power.setter - def laser_power(self, value): - """Laser power percentage. + def get_exposure_time(self, laser: Laser) -> float: + """returns the exposure time for the laser Parameters ---------- - value : int or float - Laser power percentage. + laser : Laser + laser to get the exposure time of Returns ------- - str - Serial command to set the laser power percentage. + float + exposure time + """ + return laser.exposure_time - Raises - ------ - ValueError - Laser power percentage is limited to between 0 and 100. + def enable(self, laser: Laser) -> None: + """enables the laser using serial commands. + See documentation file for command structure. + + Parameters + ---------- + laser : Laser + the laser to enable + + """ + command = "(param-set! '" + laser.serial_id + ":enable #t)\r" + utils.write_serial_command(self.serial_connection, command) + laser.enabled = True + + def disable(self, laser: Laser) -> None: + """disables the laser using serial commands. + See documentation file for command structure. + + Parameters + ---------- + laser : Laser + the laser to disable + + """ + command = "(param-set! '" + laser.serial_id + ":enable #f)\r" + utils.write_serial_command(self.serial_connection, command) + laser.enabled = True + + def emission_on(self, laser: Laser) -> None: + """turn on the laser + + Parameters + ---------- + laser : Laser + the laser to turn on + """ + command = "(param-set! '" + laser.serial_id + ":cw #t)\r" + utils.write_serial_command(self.serial_connection, command) + + def emission_off(self, laser: Laser) -> None: + """turn off the laser + + Parameters + ---------- + laser : Laser + the laser to turn off """ - value = float(value) - if value <=0: - value = 0 - - elif value >= 100: - value = 100 - - if 0 <= value <= 100: - command = "(param-set! '" + self.ID + \ - ":level " + str(round(value, 2)) + ")\r" - self._write_serial_command(command) - self._laser_power = value - else: - raise ValueError('Laser power percentage must be between 0 - 100') - return command - - def _write_serial_command(self, command): - self.SERIAL_PORT.close() - self.SERIAL_PORT.open() - bytelength = self.SERIAL_PORT.write(bytes(command, 'utf-8')) - self.SERIAL_PORT.close() - return bytelength + command = "(param-set! '" + laser.serial_id + ":cw #f)\r" + utils.write_serial_command(self.serial_connection, command) diff --git a/piescope/utils.py b/piescope/utils.py index 112228f..e68dc3c 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -2,12 +2,16 @@ import logging import os import re +import yaml import numpy as np import skimage.color import skimage.io import skimage.util import tifffile +import serial +import serial.tools.list_ports +import warnings def save_image(image, destination, metadata={}, *, allow_overwrite=False, @@ -207,3 +211,51 @@ def rgb_image(image): raise ValueError("Wrong number of image channels! " "Expected up to 3 image channels, " "but found {} channels.".format(image.shape[-1])) + + +def read_config(config_filename): + with open(config_filename, "r") as file: + settings_dict = yaml.safe_load(file) + return settings_dict + + + + +def connect_serial_port(settings): + """Serial port for communication with the lasers. + + Parameters + ---------- + port : str, optional + Serial port device name, by default 'COM3'. + baudrate : int, optional + Rate of communication, by default 115200 bits per second. + timeout : int, optional + Timeout period, by default 1 second. + + Returns + ------- + pyserial Serial() object + Serial port for communication with the lasers. + """ + + _available_serial_ports = serial.tools.list_ports.comports() + _available_port_names = [port.device for port in _available_serial_ports] + + port = settings['serial']['port'] + baudrate = settings['serial']['baudrate'] + timeout = settings['serial']['timeout'] + + if port not in _available_port_names: + warnings.warn( + "Default laser serial port not available.\n" + "Fall back to port {}".format() + ) + port = _available_port_names[0] + return serial.Serial(port, baudrate=baudrate, timeout=timeout) + +def write_serial_command(serial_connection, command): + serial_connection.close() + serial_connection.open() + serial_connection.write(bytes(command, 'utf-8')) + serial_connection.close() From cda96ece45a9929acf81379e5f5251a723a2d659 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 16:16:42 +1100 Subject: [PATCH 27/82] remove unused initialise_laser function --- piescope/lm/laser.py | 29 ----------------------------- 1 file changed, 29 deletions(-) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 13a1178..e625119 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -9,35 +9,6 @@ config_path = os.path.join(os.path.dirname(piescope.__file__), "config.yml") - -def initialise_lasers(serial_port=None): - """Initialise all available lasers. - - Parameters - ---------- - serial_port : pyserial Serial() object, optional - Serial port for communication with the lasers. - - Returns - ------- - dict - Dictionary of Laser() objects for all available lasers. - """ - if serial_port is None: - try: - serial_port = connect_serial_port() - except Exception: - warnings.warn( - "Default laser serial port not available.\n" - "Fall back to {}".format(_available_port_names[0]) - ) - serial_port = connect_serial_port(_available_port_names[0]) - all_lasers = { - laser["name"]: Laser(laser["name"], serial_port) for laser in _available_lasers - } - return all_lasers - - @dataclass class Laser: name: str From 9c6a308b0dc11689652235ee8489d37ab33cc9e0 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 16:18:42 +1100 Subject: [PATCH 28/82] remove internal path dependence --- piescope/lm/laser.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index e625119..c26561a 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -1,13 +1,9 @@ """Module for laser control via serial communication.""" -import os -import warnings from dataclasses import dataclass import numpy as np -import piescope from piescope import utils -config_path = os.path.join(os.path.dirname(piescope.__file__), "config.yml") @dataclass class Laser: @@ -20,7 +16,7 @@ class Laser: class Laser_Controller: - def __init__(self): + def __init__(self, config_path): settings = utils.read_config(config_path) From 546e46ab771247a8f952f2a3c9e545bb9d01014b Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 16:47:36 +1100 Subject: [PATCH 29/82] remove config path creation --- piescope/lm/laser.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index c26561a..dabbcc5 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -15,10 +15,8 @@ class Laser: enabled: bool -class Laser_Controller: - def __init__(self, config_path): - - settings = utils.read_config(config_path) +class LaserController: + def __init__(self, settings): self.lasers = {} self.serial_connection = utils.connect_serial_port(settings) From adf1883a67fbce1e030e3829a177bfd30dc93b5c Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 17:03:41 +1100 Subject: [PATCH 30/82] add ip and offline to config --- piescope/config.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/piescope/config.yml b/piescope/config.yml index ab6b371..ccd0ffa 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -1,3 +1,6 @@ +system: + ip_address: 10.0.0.1 + offline_mode: True serial: port: 'COM15' baudrate: 115200 From c5c1e7bbdb27b53b43300baa348332e9ffd033c3 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 17:10:23 +1100 Subject: [PATCH 31/82] fix initialise initialize inconsiztency --- piescope/fibsem.py | 4 ++-- piescope/lm/objective.py | 2 +- piescope/lm/volume.py | 2 +- tests/test_fibsem.py | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 9b440ca..d2dcf2d 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -4,8 +4,8 @@ """Module for interacting with the FIBSEM using Autoscript.""" -def initialize(ip_address='10.0.0.1'): - """Initialize connection to FIBSEM microscope with Autoscript.""" +def initialise(ip_address='10.0.0.1'): + """Initialise connection to FIBSEM microscope with Autoscript.""" from autoscript_sdb_microscope_client import SdbMicroscopeClient microscope = SdbMicroscopeClient() microscope.connect(ip_address) diff --git a/piescope/lm/objective.py b/piescope/lm/objective.py index 85f920f..c59e36c 100644 --- a/piescope/lm/objective.py +++ b/piescope/lm/objective.py @@ -55,7 +55,7 @@ def disconnect(self): def initialise_system_parameters(self, relative_accumulation=0, reference_mark=0, reference_hold=1000, start_position=0): - """Initialize the fluorescence objective lens stage controller. + """Initialise the fluorescence objective lens stage controller. Parameters ---------- diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index ff28829..445cc0d 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -93,7 +93,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, z_slice_distance = int(z_slice_distance) total_volume_height = (num_z_slices - 1) * z_slice_distance - # Initialize hardware + # Initialise hardware if detector is None: detector = piescope.lm.detector.Basler() if lasers is None: diff --git a/tests/test_fibsem.py b/tests/test_fibsem.py index 6f2ef60..214cbeb 100644 --- a/tests/test_fibsem.py +++ b/tests/test_fibsem.py @@ -19,7 +19,7 @@ def test_initialize(): """Test connecting to the microscope offline with localhost.""" - microscope = piescope.fibsem.initialize("localhost") + microscope = piescope.fibsem.initialise("localhost") @pytest.fixture From 280ad0271d1421cb1de85eadde76f203fba5f1e5 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 17:14:13 +1100 Subject: [PATCH 32/82] really fix it this time --- piescope/lm/volume.py | 2 +- tests/test_fibsem.py | 2 +- tests/test_lm/test_laser.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 445cc0d..75223ac 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -97,7 +97,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, if detector is None: detector = piescope.lm.detector.Basler() if lasers is None: - lasers = piescope.lm.laser.initialize_lasers() + lasers = piescope.lm.laser.initialise_lasers() if objective_stage is None: objective_stage = piescope.lm.objective.StageController() for laser_name, (laser_power, exposure_time) in laser_dict.items(): diff --git a/tests/test_fibsem.py b/tests/test_fibsem.py index 214cbeb..84cadec 100644 --- a/tests/test_fibsem.py +++ b/tests/test_fibsem.py @@ -17,7 +17,7 @@ allow_module_level=True) -def test_initialize(): +def test_initialise(): """Test connecting to the microscope offline with localhost.""" microscope = piescope.fibsem.initialise("localhost") diff --git a/tests/test_lm/test_laser.py b/tests/test_lm/test_laser.py index 892c88a..a6fccbc 100644 --- a/tests/test_lm/test_laser.py +++ b/tests/test_lm/test_laser.py @@ -18,8 +18,8 @@ def dummy_laser(): return laser.Laser("laser640", SerialTestClass(), laser_power=1.) -def test_initialize_lasers(): - output = laser.initialize_lasers(serial_port=SerialTestClass()) +def test_initialise_lasers(): + output = laser.initialise_lasers(serial_port=SerialTestClass()) assert len(output) == 4 assert output["laser405"].NAME == "laser405" assert output["laser405"].WAVELENGTH == 405 From af1c6bf925989e9f8ab16232bcce0fb4f81a0533 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 17:53:04 +1100 Subject: [PATCH 33/82] added default laser --- piescope/config.yml | 36 +++++++++++++++++++----------------- piescope/lm/laser.py | 12 ++++++++---- 2 files changed, 27 insertions(+), 21 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index ccd0ffa..1b15b6b 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -5,20 +5,22 @@ serial: port: 'COM15' baudrate: 115200 timeout: 1 -lasers: -- name: laser405 - wavelength: 405 # nm - pin: P00 - ID: laser4 -- name: laser488 - wavelength: 488 # nm - pin: P01 - ID: laser3 -- name: laser561 - wavelength: 561 # nm - pin: P02 - ID: laser2 -- name: laser640 - wavelength: 640 # nm - pin: P03 - ID: laser1 +lm: + default_laser: laser488 + lasers: + - name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 + - name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 + - name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 + - name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index dabbcc5..0323a80 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -1,4 +1,5 @@ """Module for laser control via serial communication.""" +from wsgiref.simple_server import demo_app from dataclasses import dataclass import numpy as np @@ -22,7 +23,7 @@ def __init__(self, settings): self.serial_connection = utils.connect_serial_port(settings) # grab available lasers - for laser in settings["lasers"]: + for laser in settings["lm"]["lasers"]: current_laser = Laser( name=laser["name"], serial_id=laser["ID"], @@ -39,11 +40,14 @@ def __init__(self, settings): self.set_laser_power(laser, laser.power) self.set_exposure_time(laser, laser.exposure_time) self.emission_on(laser) - import time - time.sleep(1) - self.emission_off(laser) + default_laser = settings['lm']['default_laser'] + if default_laser not in self.lasers: + raise ValueError(f"Default laser set in config not found in available lasers. Default laser is {default_laser}") + self.current_laser = self.lasers[default_laser] + print(self.current_laser) + def set_laser_power(self, laser: Laser, power: float) -> None: """sets power level of laser From a57311d8c470ffe986c50f43f7298ca0a1cee2a0 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 22 Feb 2022 18:28:49 +1100 Subject: [PATCH 34/82] cleanup of laser init --- piescope/lm/laser.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 0323a80..14a55a9 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -37,9 +37,6 @@ def __init__(self, settings): # set initial laser values for laser in self.lasers.values(): self.enable(laser) - self.set_laser_power(laser, laser.power) - self.set_exposure_time(laser, laser.exposure_time) - self.emission_on(laser) default_laser = settings['lm']['default_laser'] if default_laser not in self.lasers: @@ -47,7 +44,7 @@ def __init__(self, settings): self.current_laser = self.lasers[default_laser] print(self.current_laser) - + def set_laser_power(self, laser: Laser, power: float) -> None: """sets power level of laser From c55b2c089c53f74a332b11a1d092cab00ea0df57 Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Wed, 23 Feb 2022 15:31:43 +1100 Subject: [PATCH 35/82] send to other computer --- piescope/config.yml | 7 ++++ piescope/lm/detector.py | 77 ++++++++++++++++++++++++++++++++++------- piescope/lm/laser.py | 3 +- piescope/utils.py | 23 ++++++++++++ 4 files changed, 96 insertions(+), 14 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 1b15b6b..4fccfce 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -24,3 +24,10 @@ lm: wavelength: 640 # nm pin: P03 ID: laser1 +imaging: + lm: + trigger_mode: hardware # default: 'software', other option is 'hardware' + autosave: True + color: False + ib: + autosave: False \ No newline at end of file diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 9904735..ed6baa3 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -1,13 +1,11 @@ """Module for the Basler fluorescence detector.""" -import sys - import numpy as np - +from piescope.lm import structured +from piescope.lm.laser import Laser +from piescope.lm.mirror import StageMacro from pypylon import pylon -import piescope.lm.mirror -from piescope.lm.mirror import StagePosition, StageMacro -from piescope.lm import structured +from piescope.utils import TriggerMode class Basler(): @@ -23,7 +21,61 @@ def __init__(self): self.image = [] self.camera_pin = 'P14' - def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None, laser_pins=None): + def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: + self.camera.Open() + self.camera.StopGrabbing() + + trigger_mode = settings['imaging']['lm']['trigger_mode'] + + # set software triggering mode settings + if trigger_mode == TriggerMode.Software: + self.camera.TriggerMode.SetValue('Off') + self.camera.ExposureMode.SetValue('Timed') + try: + self.camera.ExposureTime.SetValue(float(laser.exposure_time)) + except Exception as e: + try: + self.camera.ExposureTimeAbs.SetValue(float(laser.exposure_time)) + except Exception as e: + self.camera.Close() + raise e + + # set hardware triggering mode settings + if trigger_mode == TriggerMode.Hardware: + self.camera.LineSelector.SetValue('Line4') + self.camera.TriggerMode.SetValue('On') + self.camera.TriggerSource.SetValue('Line4') + + self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.AcquisitionFrameRateEnable.SetValue(False) + + # take images + # self.camera.StopGrabbing() + self.camera.StartGrabbingMax(self.imageCount) + image = None + + while self.camera.IsGrabbing(): + if trigger_mode is TriggerMode.Hardware: + structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) + + grabResult = self.camera.RetrieveResult( + 5000, pylon.TimeoutHandling_ThrowException) + + if grabResult.GrabSucceeded(): + image = grabResult.Array + else: + raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + + grabResult.ErrorDescription + ) + grabResult.Release() + + self.camera.Close() + image = np.flipud(self.image) + image = np.fliplr(self.image) + return image + + + def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None, laser_pins=None): """Grab a new image from the Basler detector. Parameters @@ -44,7 +96,7 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr Returns ------- - self.image : numpy array + image : numpy array """ self.camera.Open() self.camera.StopGrabbing() @@ -99,7 +151,6 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr self.camera.StopGrabbing() self.camera.StartGrabbingMax(self.imageCount) - self.image = [] while self.camera.IsGrabbing(): if trigger_mode is 'hardware': @@ -110,7 +161,7 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr 5000, pylon.TimeoutHandling_ThrowException) if grabResult.GrabSucceeded(): - self.image = grabResult.Array + image = grabResult.Array else: raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + grabResult.ErrorDescription @@ -118,9 +169,9 @@ def camera_grab(self, exposure_time=None, trigger_mode='software', flip_image=Tr grabResult.Release() self.camera.Close() if flip_image is True: - self.image = np.flipud(self.image) - self.image = np.fliplr(self.image) - return self.image + image = np.flipud(image) + image = np.fliplr(image) + return image def grab_slice(self, n_images=9, mirror_controller=None, arduino=None, laser_dict=None, flip_image=True): """Grab a slice using Arduino and NI controller""" diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 14a55a9..9292c99 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -14,6 +14,7 @@ class Laser: power: float exposure_time: float # us enabled: bool + pin: str class LaserController: @@ -31,6 +32,7 @@ def __init__(self, settings): power=0.0, exposure_time=0.0, enabled=False, + pin=laser["pin"] ) self.lasers[current_laser.name] = current_laser @@ -43,7 +45,6 @@ def __init__(self, settings): raise ValueError(f"Default laser set in config not found in available lasers. Default laser is {default_laser}") self.current_laser = self.lasers[default_laser] - print(self.current_laser) def set_laser_power(self, laser: Laser, power: float) -> None: """sets power level of laser diff --git a/piescope/utils.py b/piescope/utils.py index e68dc3c..0bdff10 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -12,6 +12,18 @@ import serial import serial.tools.list_ports import warnings +from enum import Enum + + +class TriggerMode(Enum): + Hardware = 0 + Software = 1 + + +class Modality(Enum): + Light = 0 + Ion = 1 + Electron = 2 def save_image(image, destination, metadata={}, *, allow_overwrite=False, @@ -216,9 +228,20 @@ def rgb_image(image): def read_config(config_filename): with open(config_filename, "r") as file: settings_dict = yaml.safe_load(file) + settings_dict = parse_config(settings_dict) return settings_dict +def parse_config(config): + mode = str(config["imaging"]["lm"]["trigger_mode"]).title() + if mode in TriggerMode.__members__: + config["imaging"]["lm"]["trigger_mode"] = TriggerMode[mode] + else: + config["imaging"]["lm"]["trigger_mode"] = TriggerMode.Software + + return config + + def connect_serial_port(settings): From 74eb62f6f79406989c7634c1873a127ff9f8cc6b Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 23 Feb 2022 17:12:14 +1100 Subject: [PATCH 36/82] change requirements --- requirements/default.txt | 5 ++++- setup.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/requirements/default.txt b/requirements/default.txt index 9aca3a5..35a2c1a 100644 --- a/requirements/default.txt +++ b/requirements/default.txt @@ -4,4 +4,7 @@ scikit-image>=0.15.0 scipy>=1.3.0 pyserial PyYAML -nidaqmx \ No newline at end of file +nidaqmx +pypylon +pipython +opencv-python \ No newline at end of file diff --git a/setup.py b/setup.py index 417f34a..55bade7 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ def parse_requirements_file(filename): URL = 'https://github.com/DeMarcoLab/piescope' DOWNLOAD_URL = 'https://github.com/DeMarcoLab/piescope' VERSION = __version__ -PYTHON_VERSION = (3, 5) +PYTHON_VERSION = (3, 7) INST_DEPENDENCIES = parse_requirements_file( os.path.join('requirements', 'default.txt') ) From f7caeac0c16ccb1e468919c08fb46de5c85dc0f4 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 23 Feb 2022 17:12:26 +1100 Subject: [PATCH 37/82] change grab image and load_iamges --- piescope/config.yml | 2 +- piescope/lm/detector.py | 4 ++-- piescope/utils.py | 23 ++++++++++++++++++++++- 3 files changed, 25 insertions(+), 4 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 4fccfce..ecf2898 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -2,7 +2,7 @@ system: ip_address: 10.0.0.1 offline_mode: True serial: - port: 'COM15' + port: 'COM3' baudrate: 115200 timeout: 1 lm: diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index ed6baa3..708aa5d 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -70,8 +70,8 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: grabResult.Release() self.camera.Close() - image = np.flipud(self.image) - image = np.fliplr(self.image) + image = np.flipud(image) + image = np.fliplr(image) return image diff --git a/piescope/utils.py b/piescope/utils.py index 0bdff10..dca3d4b 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -1,6 +1,7 @@ from datetime import datetime import logging import os +from pathlib import Path import re import yaml @@ -13,7 +14,9 @@ import serial.tools.list_ports import warnings from enum import Enum - + +from autoscript_sdb_microscope_client.structures import \ + AdornedImage class TriggerMode(Enum): Hardware = 0 @@ -25,6 +28,24 @@ class Modality(Enum): Ion = 1 Electron = 2 +def load_image(filename: Path, adorned: bool = True): + + # check file + if not os.path.exists(filename): + raise FileNotFoundError("File not found") + + # open file + if adorned: + image = AdornedImage.load(filename) + try: + image.metadata.binary_result.pixel_size.x + except AttributeError: + raise AttributeError("Image must be AdornedImage type") + else: + image = skimage.io.imread(filename) + + return image + def save_image(image, destination, metadata={}, *, allow_overwrite=False, timestamp=True): From 8c308fbc20dac6c38247dbea17c62d64fe8c8aa1 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 24 Feb 2022 11:07:48 +1100 Subject: [PATCH 38/82] add github actions workflow --- .github/workflows/python-package.yml | 42 ++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 .github/workflows/python-package.yml diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml new file mode 100644 index 0000000..cdad8ed --- /dev/null +++ b/.github/workflows/python-package.yml @@ -0,0 +1,42 @@ + +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: Python package + +on: + push: + branches: [ main, develop, cleanup ] + pull_request: + branches: [ main, develop, cleanup ] + +jobs: + build: + + runs-on: ${{ matrix.os }} + strategy: + fail-fast: true + matrix: + python-version: ["3.7", "3.8", "3.9"] + os: [ubuntu-latest, macOS-latest, windows-latest] + + steps: + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -r requirements/default.txt + python -m pip install . + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + pytest \ No newline at end of file From 3fa36f0b79aad44bee51c3ca411c7e57fc465023 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 24 Feb 2022 11:10:34 +1100 Subject: [PATCH 39/82] update actions --- .github/workflows/python-package.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index cdad8ed..46c25d2 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -29,7 +29,6 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install -r requirements/default.txt python -m pip install . - name: Lint with flake8 run: | From 3a8165c72516be52e4adc7f4d97e53e2fbc29702 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 24 Feb 2022 11:12:57 +1100 Subject: [PATCH 40/82] update actions --- .github/workflows/python-package.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 46c25d2..2f24471 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -29,6 +29,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip + python -m pip install flake8 pytest python -m pip install . - name: Lint with flake8 run: | From 6896488ad55c3d245a77e4f8172d209757ad8327 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 24 Feb 2022 14:56:02 +1100 Subject: [PATCH 41/82] github actions --- .github/workflows/python-package.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 2f24471..94674e8 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -29,7 +29,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install flake8 pytest + python -m pip install flake8 python -m pip install . - name: Lint with flake8 run: | @@ -39,4 +39,5 @@ jobs: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | + python -m pip install pytest pytest \ No newline at end of file From 357404f0e058e6ec4b5e13e9aa246d601dd2876c Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Thu, 24 Feb 2022 15:02:53 +1100 Subject: [PATCH 42/82] update_display rework --- piescope/config.yml | 50 ++++++++------ piescope/lm/detector.py | 139 ++++++++++++++++++++++--------------- piescope/lm/laser.py | 2 +- piescope/utils.py | 148 ++++++++++++++++++++++++++-------------- 4 files changed, 210 insertions(+), 129 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index ecf2898..49f3bd2 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -2,32 +2,42 @@ system: ip_address: 10.0.0.1 offline_mode: True serial: - port: 'COM3' + port: "COM3" baudrate: 115200 timeout: 1 lm: default_laser: laser488 lasers: - - name: laser405 - wavelength: 405 # nm - pin: P00 - ID: laser4 - - name: laser488 - wavelength: 488 # nm - pin: P01 - ID: laser3 - - name: laser561 - wavelength: 561 # nm - pin: P02 - ID: laser2 - - name: laser640 - wavelength: 640 # nm - pin: P03 - ID: laser1 + - name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 + - name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 + - name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 + - name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 imaging: lm: - trigger_mode: hardware # default: 'software', other option is 'hardware' - autosave: True + trigger_mode: hardware # (str) 'software' [default] or 'hardware' + autosave: False color: False + filter_strength: 0 # int or None + camera: + pin: P14 + max_num_buffer: 5 # max number of images to store in the buffer + image_frame_interval: None # (float) time between frames if desired ib: - autosave: False \ No newline at end of file + autosave: False + filter_strength: 3 # int or None + crosshairs: + thickness: 0.1 # in % of image width + length: 10 # in % of image width + color: xkcd:yellow diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 708aa5d..f959e40 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -8,29 +8,28 @@ from piescope.utils import TriggerMode -class Basler(): +class Basler: """Class for the Basler detector""" - def __init__(self): + + def __init__(self, settings: dict): super(Basler, self).__init__() self.camera = pylon.InstantCamera( - pylon.TlFactory.GetInstance().CreateFirstDevice()) - print("Using device ", self.camera.GetDeviceInfo().GetModelName()) - self.camera.MaxNumBuffer = 5 - self.imageCount = 1 - self.currentImageIndex = 0 - self.image = [] - self.camera_pin = 'P14' + pylon.TlFactory.GetInstance().CreateFirstDevice() + ) + print(f"Using {self.camera.GetDeviceInfo().GetModelName()} for light imaging.") + self.camera_pin = settings["imaging"]["lm"]["camera"]["pin"] + self.camera.MaxNumBuffer = settings["imaging"]["lm"]["camera"]["max_num_buffer"] def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.Open() self.camera.StopGrabbing() - trigger_mode = settings['imaging']['lm']['trigger_mode'] + trigger_mode = settings["imaging"]["lm"]["trigger_mode"] # set software triggering mode settings if trigger_mode == TriggerMode.Software: - self.camera.TriggerMode.SetValue('Off') - self.camera.ExposureMode.SetValue('Timed') + self.camera.TriggerMode.SetValue("Off") + self.camera.ExposureMode.SetValue("Timed") try: self.camera.ExposureTime.SetValue(float(laser.exposure_time)) except Exception as e: @@ -42,16 +41,16 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: # set hardware triggering mode settings if trigger_mode == TriggerMode.Hardware: - self.camera.LineSelector.SetValue('Line4') - self.camera.TriggerMode.SetValue('On') - self.camera.TriggerSource.SetValue('Line4') + self.camera.LineSelector.SetValue("Line4") + self.camera.TriggerMode.SetValue("On") + self.camera.TriggerSource.SetValue("Line4") - self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.ExposureMode.SetValue("TriggerWidth") self.camera.AcquisitionFrameRateEnable.SetValue(False) # take images # self.camera.StopGrabbing() - self.camera.StartGrabbingMax(self.imageCount) + self.camera.StartGrabbingMax(1) image = None while self.camera.IsGrabbing(): @@ -59,14 +58,18 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException) + 5000, pylon.TimeoutHandling_ThrowException + ) if grabResult.GrabSucceeded(): image = grabResult.Array else: - raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + - grabResult.ErrorDescription - ) + raise RuntimeError( + "Error: " + + grabResult.ErrorCode + + "\n" + + grabResult.ErrorDescription + ) grabResult.Release() self.camera.Close() @@ -74,8 +77,14 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: image = np.fliplr(image) return image - - def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=True, laser_name=None, laser_pins=None): + def camera_grab2( + self, + exposure_time=None, + trigger_mode="software", + flip_image=True, + laser_name=None, + laser_pins=None, + ): """Grab a new image from the Basler detector. Parameters @@ -103,26 +112,28 @@ def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=T if laser_name is not None: if laser_pins is not None: - LASER_TO_PIN = {"laser640": laser_pins[0], - "laser561": laser_pins[1], - "laser488": laser_pins[2], - "laser405": laser_pins[3], - } + LASER_TO_PIN = { + "laser640": laser_pins[0], + "laser561": laser_pins[1], + "laser488": laser_pins[2], + "laser405": laser_pins[3], + } else: - LASER_TO_PIN = {"laser640": 'P00', - "laser561": 'P01', - "laser488": 'P02', - "laser405": 'P03', - } + LASER_TO_PIN = { + "laser640": "P00", + "laser561": "P01", + "laser488": "P02", + "laser405": "P03", + } laser_pin = LASER_TO_PIN[laser_name] else: # raise ValueError('No laser selected') pass # TODO: Check this out - if trigger_mode is 'software': - self.camera.TriggerMode.SetValue('Off') - self.camera.ExposureMode.SetValue('Timed') + if trigger_mode is "software": + self.camera.TriggerMode.SetValue("Off") + self.camera.ExposureMode.SetValue("Timed") if exposure_time is not None: try: self.camera.ExposureTime.SetValue(float(exposure_time)) @@ -132,13 +143,13 @@ def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=T except Exception as e: self.camera.Close() raise e - elif trigger_mode is 'hardware': + elif trigger_mode is "hardware": # set input - self.camera.LineSelector.SetValue('Line4') - self.camera.TriggerMode.SetValue('On') - self.camera.TriggerSource.SetValue('Line4') + self.camera.LineSelector.SetValue("Line4") + self.camera.TriggerMode.SetValue("On") + self.camera.TriggerSource.SetValue("Line4") - self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.ExposureMode.SetValue("TriggerWidth") self.camera.AcquisitionFrameRateEnable.SetValue(False) # # set output @@ -150,22 +161,26 @@ def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=T raise ValueError('Select "software" or "hardware"') self.camera.StopGrabbing() - self.camera.StartGrabbingMax(self.imageCount) + self.camera.StartGrabbingMax(1) while self.camera.IsGrabbing(): - if trigger_mode is 'hardware': + if trigger_mode is "hardware": structured.single_line_pulse(delay=exposure_time, pin=laser_pin) # structured.multi_line_pulse(exposure_time, self.camera_pin, laser_pin, 'P27') #TODO remove direct reference to pin 27 grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException) + 5000, pylon.TimeoutHandling_ThrowException + ) if grabResult.GrabSucceeded(): image = grabResult.Array else: - raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + - grabResult.ErrorDescription - ) + raise RuntimeError( + "Error: " + + grabResult.ErrorCode + + "\n" + + grabResult.ErrorDescription + ) grabResult.Release() self.camera.Close() if flip_image is True: @@ -173,21 +188,28 @@ def camera_grab2(self, exposure_time=None, trigger_mode='software', flip_image=T image = np.fliplr(image) return image - def grab_slice(self, n_images=9, mirror_controller=None, arduino=None, laser_dict=None, flip_image=True): + def grab_slice( + self, + n_images=9, + mirror_controller=None, + arduino=None, + laser_dict=None, + flip_image=True, + ): """Grab a slice using Arduino and NI controller""" self.camera.Open() - self.camera.LineSelector.SetValue('Line4') - self.camera.TriggerMode.SetValue('On') - self.camera.TriggerSource.SetValue('Line4') + self.camera.LineSelector.SetValue("Line4") + self.camera.TriggerMode.SetValue("On") + self.camera.TriggerSource.SetValue("Line4") - self.camera.ExposureMode.SetValue('TriggerWidth') + self.camera.ExposureMode.SetValue("TriggerWidth") self.camera.AcquisitionFrameRateEnable.SetValue(False) self.camera.MaxNumBuffer = 27 self.camera.StopGrabbing() # self.camera.StartGrabbing(pylon.GrabStrategy_OneByOne) - self.camera.StartGrabbingMax(n_images*len(laser_dict)) + self.camera.StartGrabbingMax(n_images * len(laser_dict)) self.images = [] arduino.send_volume_info(laser_dict=laser_dict) @@ -196,7 +218,8 @@ def grab_slice(self, n_images=9, mirror_controller=None, arduino=None, laser_dic while self.camera.IsGrabbing(): grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException) + 5000, pylon.TimeoutHandling_ThrowException + ) if grabResult.GrabSucceeded(): image = grabResult.Array if flip_image is True: @@ -205,8 +228,12 @@ def grab_slice(self, n_images=9, mirror_controller=None, arduino=None, laser_dic self.images.append(image) else: - raise RuntimeError("Error: " + grabResult.ErrorCode + '\n' + - grabResult.ErrorDescription) + raise RuntimeError( + "Error: " + + grabResult.ErrorCode + + "\n" + + grabResult.ErrorDescription + ) grabResult.Release() self.camera.Close() print(self.images) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 9292c99..4356141 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -1,6 +1,6 @@ """Module for laser control via serial communication.""" -from wsgiref.simple_server import demo_app from dataclasses import dataclass +from wsgiref.simple_server import demo_app import numpy as np from piescope import utils diff --git a/piescope/utils.py b/piescope/utils.py index dca3d4b..03f809f 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -1,22 +1,23 @@ -from datetime import datetime import logging import os -from pathlib import Path import re -import yaml +import warnings +from dataclasses import dataclass +from datetime import datetime +from enum import Enum +from pathlib import Path import numpy as np +import serial +import serial.tools.list_ports import skimage.color import skimage.io import skimage.util import tifffile -import serial -import serial.tools.list_ports -import warnings -from enum import Enum - -from autoscript_sdb_microscope_client.structures import \ - AdornedImage +import yaml +from autoscript_sdb_microscope_client.structures import AdornedImage +from matplotlib import pyplot as plt + class TriggerMode(Enum): Hardware = 0 @@ -28,8 +29,9 @@ class Modality(Enum): Ion = 1 Electron = 2 + def load_image(filename: Path, adorned: bool = True): - + # check file if not os.path.exists(filename): raise FileNotFoundError("File not found") @@ -47,8 +49,9 @@ def load_image(filename: Path, adorned: bool = True): return image -def save_image(image, destination, metadata={}, *, allow_overwrite=False, - timestamp=True): +def save_image( + image, destination, metadata={}, *, allow_overwrite=False, timestamp=True +): """Save image to file. Parameters @@ -85,9 +88,9 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, """ destination = os.path.normpath(destination) # Make sure the output file format is acceptable - SUPPORTED_IMAGE_TYPES = ('.tif') + SUPPORTED_IMAGE_TYPES = ".tif" if not destination.endswith(SUPPORTED_IMAGE_TYPES): - destination += '.tif' + destination += ".tif" # Append timestamp string to filename, if needed if timestamp: timestamp_string = datetime.now().strftime("_%Y-%m-%dT%H%M%S%f") @@ -102,14 +105,12 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, if regex_match: current_idx = int(regex_match.group(0)[2:-1]) # strip "_(" ")" suffix_len = len(regex_match.group(0)) - destination = ( - base[:-suffix_len] + "_({})".format(current_idx + 1) + ext - ) + destination = base[:-suffix_len] + "_({})".format(current_idx + 1) + ext else: destination = base + "_(1)" + ext # If directory does not currently exist, create it directory_name = os.path.dirname(destination) - if not directory_name == '' and not os.path.isdir(directory_name): + if not directory_name == "" and not os.path.isdir(directory_name): os.makedirs(directory_name) try: image.save(destination) # eg: for AutoScript AdornedImage datatypes @@ -122,37 +123,38 @@ def save_image(image, destination, metadata={}, *, allow_overwrite=False, # numpy array metadata is saved with regular metadata (not OME-TIFF) if isinstance(image, np.ndarray): # Make sure we have the right datatype to svae for ImageJ - if image.dtype.char not in 'BHhf': # uint8, uint16, int16, or ? + if image.dtype.char not in "BHhf": # uint8, uint16, int16, or ? image = skimage.util.img_as_uint(image) # 16 bit unsigned int # If it's a volume image, must split channels and save individually if image.ndim == 5: # (AZPYX) tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) - elif image.ndim == 6: #(CAZPYX) --> (AZPYX) + elif image.ndim == 6: # (CAZPYX) --> (AZPYX) volume_split = np.zeros(image.shape) for i in range(image.shape[1]): volume_split[:, i] = image[:, i] - metadata.update({'axes': 'AZPYX'}) - destination = destination.replace('.tif', '') + '_channel_' + str(i) + '.tif' + metadata.update({"axes": "AZPYX"}) + destination = ( + destination.replace(".tif", "") + "_channel_" + str(i) + ".tif" + ) logging.debug("Saved: {}".format(destination)) - tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, - metadata=metadata) + tifffile.imwrite( + destination, volume_split[:, i], bigtiff=True, metadata=metadata + ) elif image.ndim == 3: # (YXC) image = np.moveaxis(image, -1, 0) # move channel axis (CYX) - metadata.update({'axes':'CYX'}) - skimage.io.imsave(destination, image, imagej=True, - metadata=metadata) + metadata.update({"axes": "CYX"}) + skimage.io.imsave(destination, image, imagej=True, metadata=metadata) logging.debug("Saved: {}".format(destination)) else: # Save all other images without changes - skimage.io.imsave(destination, image, imagej=True, - metadata=metadata) + skimage.io.imsave(destination, image, imagej=True, metadata=metadata) logging.debug("Saved: {}".format(destination)) else: raise ValueError( "Cannot save image! Expected a numpy array or AdornedImage, " "instead found image.dtype of {}".format(image.dtype) - ) + ) def max_intensity_projection(image, start_slice=0, end_slice=None): @@ -171,7 +173,7 @@ def max_intensity_projection(image, start_slice=0, end_slice=None): """ results = [] # TODO: make this consistent - if image.ndim == 6: #CAZPYX + if image.ndim == 6: # CAZPYX for channel_image in image: max_intensity = np.max(channel_image, axis=(0, 1, 2)) @@ -181,8 +183,9 @@ def max_intensity_projection(image, start_slice=0, end_slice=None): # Check input validity else: if image.ndim != 4: - raise ValueError("expecting numpy.array with dimensions " - "(pln, row, col, ch)") + raise ValueError( + "expecting numpy.array with dimensions " "(pln, row, col, ch)" + ) # Slice image stack if end_slice is None: image = image[start_slice:, ...] @@ -218,22 +221,26 @@ def rgb_image(image): Raised if the image dimensions or channels is not allowed. """ if not (image.ndim == 2 or image.ndim == 3): - raise ValueError("Wrong number of dimensions in input image! " - "Expected an image with 2 or 3 dimensions, " - "but found {} dimensions".format(image.ndim)) + raise ValueError( + "Wrong number of dimensions in input image! " + "Expected an image with 2 or 3 dimensions, " + "but found {} dimensions".format(image.ndim) + ) if image.ndim == 2: rgb_image = image # rgb_image = skimage.color.gray2rgb(image) return rgb_image elif image.ndim == 3: if image.shape[-1] == 1: - rgb_image = np.zeros(shape=(image.shape[0], image.shape[1], 3), - dtype=np.uint8) + rgb_image = np.zeros( + shape=(image.shape[0], image.shape[1], 3), dtype=np.uint8 + ) rgb_image[:, :, 0] = image[:, :, 0] return rgb_image elif image.shape[-1] == 2: - rgb_image = np.zeros(shape=(image.shape[0], image.shape[1], 3), - dtype=np.uint8) + rgb_image = np.zeros( + shape=(image.shape[0], image.shape[1], 3), dtype=np.uint8 + ) rgb_image[:, :, 0] = image[:, :, 0] rgb_image[:, :, 1] = image[:, :, 1] return rgb_image @@ -241,9 +248,11 @@ def rgb_image(image): rgb_image = image return rgb_image else: - raise ValueError("Wrong number of image channels! " - "Expected up to 3 image channels, " - "but found {} channels.".format(image.shape[-1])) + raise ValueError( + "Wrong number of image channels! " + "Expected up to 3 image channels, " + "but found {} channels.".format(image.shape[-1]) + ) def read_config(config_filename): @@ -263,8 +272,6 @@ def parse_config(config): return config - - def connect_serial_port(settings): """Serial port for communication with the lasers. @@ -286,20 +293,57 @@ def connect_serial_port(settings): _available_serial_ports = serial.tools.list_ports.comports() _available_port_names = [port.device for port in _available_serial_ports] - port = settings['serial']['port'] - baudrate = settings['serial']['baudrate'] - timeout = settings['serial']['timeout'] + port = settings["serial"]["port"] + baudrate = settings["serial"]["baudrate"] + timeout = settings["serial"]["timeout"] if port not in _available_port_names: warnings.warn( - "Default laser serial port not available.\n" - "Fall back to port {}".format() + "Default laser serial port not available.\n" "Fall back to port {}".format() ) port = _available_port_names[0] return serial.Serial(port, baudrate=baudrate, timeout=timeout) + def write_serial_command(serial_connection, command): serial_connection.close() serial_connection.open() - serial_connection.write(bytes(command, 'utf-8')) + serial_connection.write(bytes(command, "utf-8")) serial_connection.close() + + +@dataclass +class Crosshair: + rectangle_horizontal: plt.Rectangle + rectangle_vertical: plt.Rectangle + + +def create_crosshair(image: np.ndarray or AdornedImage, settings: dict): + if type(image) == AdornedImage: + image = image.data + + midx = int(image.shape[1] / 2) + midy = int(image.shape[0] / 2) + + cross_width = int( + settings["imaging"]["crosshairs"]["thickness"] / 100 * image.shape[1] + ) + cross_length = int( + settings["imaging"]["crosshairs"]["length"] / 100 * image.shape[1] + ) + + rect_horizontal = plt.Rectangle( + (midx - cross_length / 2, midy - cross_width / 2), cross_length, cross_width + ) + rect_vertical = plt.Rectangle( + (midx - cross_width, midy - cross_length / 2), cross_width*2, cross_length + ) + + # set colours + colour = settings["imaging"]["crosshairs"]["color"] + rect_horizontal.set_color(colour) + rect_vertical.set_color(colour) + + return Crosshair( + rectangle_horizontal=rect_horizontal, rectangle_vertical=rect_vertical + ) From b06daefcf714047e5bd2faf49a4ebcb5e2d9fafc Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Thu, 24 Feb 2022 17:22:09 +1100 Subject: [PATCH 43/82] repo cleanup --- .appveyor.yml | 25 ---- .appveyor_support/create_env.bat | 31 ----- .../environments/requirements_py36.txt | 98 --------------- .appveyor_support/environments/tst_py36.yml | 112 ------------------ .appveyor_support/install_miniconda.bat | 49 -------- .appveyor_support/install_pylon.bat | 65 ---------- .github/ISSUE_TEMPLATE/bug_report.md | 45 ------- .github/ISSUE_TEMPLATE/feature_request.md | 26 ---- .github/PULL_REQUEST_TEMPLATE.md | 25 ---- .pep8speaks.yml | 10 -- .travis.yml | 12 -- .travis_support/install_pylon.sh | 28 ----- LICENSE | 2 +- conftest.py | 0 DEVELOPERS.md => docs/DEVELOPERS.md | 0 INSTALLATION.md => docs/INSTALLATION.md | 0 piescope/_version.py | 2 +- requirements-dev.txt | 5 - requirements.txt | 16 ++- requirements/_frozen_env.txt | 99 ---------------- requirements/default.txt | 10 -- requirements/development.txt | 4 - requirements/documentation.txt | 4 - requirements/release.txt | 3 - requirements/test.txt | 5 - setup.py | 12 +- 26 files changed, 24 insertions(+), 664 deletions(-) delete mode 100644 .appveyor.yml delete mode 100644 .appveyor_support/create_env.bat delete mode 100644 .appveyor_support/environments/requirements_py36.txt delete mode 100644 .appveyor_support/environments/tst_py36.yml delete mode 100644 .appveyor_support/install_miniconda.bat delete mode 100644 .appveyor_support/install_pylon.bat delete mode 100644 .github/ISSUE_TEMPLATE/bug_report.md delete mode 100644 .github/ISSUE_TEMPLATE/feature_request.md delete mode 100644 .github/PULL_REQUEST_TEMPLATE.md delete mode 100644 .pep8speaks.yml delete mode 100644 .travis.yml delete mode 100644 .travis_support/install_pylon.sh delete mode 100644 conftest.py rename DEVELOPERS.md => docs/DEVELOPERS.md (100%) rename INSTALLATION.md => docs/INSTALLATION.md (100%) delete mode 100644 requirements-dev.txt delete mode 100644 requirements/_frozen_env.txt delete mode 100644 requirements/default.txt delete mode 100644 requirements/development.txt delete mode 100644 requirements/documentation.txt delete mode 100644 requirements/release.txt delete mode 100644 requirements/test.txt diff --git a/.appveyor.yml b/.appveyor.yml deleted file mode 100644 index 700582d..0000000 --- a/.appveyor.yml +++ /dev/null @@ -1,25 +0,0 @@ -build: false - -platform: - - x64 - -environment: - matrix: - - PYTHON_VERSION: 3.6.7 - PYVER: "36" - PYPYLON_WHEEL_MD5: "41533230249fe528f8e4d3729e21ae43" - -init: - - "ECHO %PYTHON_VERSION%" - -install: - - cmd: set PATH=C:\\Miniconda3;C:\\Miniconda3\\Scripts;%PATH%" - - cmd: conda config --set always_yes yes --set changeps1 no - - cmd: conda create -q -n test-environment python=%PYTHON_VERSION% pip - - cmd: activate test-environment - - cmd: pip install -r .appveyor_support\environments\requirements_py%PYVER%.txt - - cmd: call .appveyor_support\install_pylon.bat - - cmd: pip install . - -test_script: - - pytest diff --git a/.appveyor_support/create_env.bat b/.appveyor_support/create_env.bat deleted file mode 100644 index 5ee1c0a..0000000 --- a/.appveyor_support/create_env.bat +++ /dev/null @@ -1,31 +0,0 @@ -:: Show each command and output -@echo on - -:: Check CONDA_ENV_TYPE was set. -if "$%CONDA_ENV_TYPE%" == "" ( - echo "Set $CONDA_ENV_TYPE externally." - exit 1 -) - -:: Activate conda. -call "%MINICONDA_DIR%\Scripts\activate.bat" -if errorlevel 1 exit 1 - -:: Create a temporary directory for the environment. -python -c "import tempfile; print(tempfile.mkdtemp())" > tmp_dir.txt -if errorlevel 1 exit 1 -set /p CONDA_ENV_PREFIX= "%MINICONDA_INSTALLER%.md5" -if errorlevel 1 exit 1 -type "%MINICONDA_INSTALLER%.md5" -if errorlevel 1 exit 1 -set /p MINICONDA_MD5_FOUND=<%MINICONDA_INSTALLER%.md5 -if errorlevel 1 exit 1 -set "MINICONDA_MD5_FOUND=%MINICONDA_MD5_FOUND: =%" -if errorlevel 1 exit 1 -echo "%MINICONDA_MD5_FOUND%" | findstr /c:"%MINICONDA_MD5%" -if errorlevel 1 exit 1 -start /wait "" %MINICONDA_INSTALLER% /InstallationType=JustMe ^ - /AddToPath=0 ^ - /RegisterPython=0 ^ - /S ^ - /D=%MINICONDA_DIR% -if errorlevel 1 exit 1 -del "%MINICONDA_INSTALLER%" -if errorlevel 1 exit 1 -del "%MINICONDA_INSTALLER%.md5" -if errorlevel 1 exit 1 - -:: Activate conda. -call "%MINICONDA_DIR%\Scripts\activate.bat" -if errorlevel 1 exit 1 - -:: Configure conda. -conda.exe config --set show_channel_urls true -if errorlevel 1 exit 1 -conda.exe config --set auto_update_conda false -if errorlevel 1 exit 1 -conda.exe config --set add_pip_as_python_dependency true -if errorlevel 1 exit 1 - -:: Patch VS 2008 for 64-bit support. -conda.exe install --quiet --yes "conda-forge::vs2008_express_vc_python_patch" -call setup_x64 diff --git a/.appveyor_support/install_pylon.bat b/.appveyor_support/install_pylon.bat deleted file mode 100644 index 1b4301e..0000000 --- a/.appveyor_support/install_pylon.bat +++ /dev/null @@ -1,65 +0,0 @@ -:: Show each command and output -@echo on - -:: Config for Basler Pylon software suite -:: https://www.baslerweb.com/en/sales-support/downloads/software-downloads/ -set "PYLON_VERSION=5.2.0.13457" -set "PYLON_MD5=91f40fb37acfb474a19e6ca6f745650b" -set "PYLON_INSTALLER=Basler_pylon_%PYLON_VERSION%.exe" -set "PYLON_URL=https://www.baslerweb.com/fp-1551786641/media/downloads/software/pylon_software/Basler_pylon_%PYLON_VERSION%.exe" - -:: Install the Basler Pylon software -:: Download -powershell -Command "(New-Object Net.WebClient).DownloadFile('%PYLON_URL%', '%PYLON_INSTALLER%')" -if errorlevel 1 exit 1 -:: Check file hash -( certutil -hashfile "%PYLON_INSTALLER%" md5 | findstr /v ":" ) > "%PYLON_INSTALLER%.md5" -if errorlevel 1 exit 1 -type "%PYLON_INSTALLER%.md5" -if errorlevel 1 exit 1 -set /p PYLON_MD5_FOUND=<%PYLON_INSTALLER%.md5 -if errorlevel 1 exit 1 -set "PYLON_MD5_FOUND=%PYLON_MD5_FOUND: =%" -if errorlevel 1 exit 1 -echo "%PYLON_MD5_FOUND%" | findstr /c:"%PYLON_MD5%" -if errorlevel 1 exit 1 -:: Install -%PYLON_INSTALLER% /s -if errorlevel 1 exit 1 -:: Clean up -del "%PYLON_INSTALLER%" -if errorlevel 1 exit 1 -del "%PYLON_INSTALLER%.md5" -if errorlevel 1 exit 1 - - -:: Python pypylon library (installed after the pylon software suite) -:: https://github.com/basler/pypylon/releases -set "PYPYLON_VERSION=1.4.0" -set "ARCH=win32" -set "PYPYLON_WHEEL=\pypylon-%PYPYLON_VERSION%-cp%PYVER%-cp%PYVER%m-%ARCH%.whl" -set "PYPYLON_URL=https://github.com/basler/pypylon/releases/download/%PYPYLON_VERSION%/pypylon-%PYPYLON_VERSION%-cp%PYVER%-cp%PYVER%m-%ARCH%.whl" - -:: Install the python pypylon package -:: Download -powershell -Command "(New-Object Net.WebClient).DownloadFile('%PYPYLON_URL%', '%PYPYLON_WHEEL%')" -if errorlevel 1 exit 1 -:: Check file hash -( certutil -hashfile "%PYPYLON_WHEEL%" md5 | findstr /v ":" ) > "%PYPYLON_WHEEL%.md5" -if errorlevel 1 exit 1 -type "%PYPYLON_WHEEL%.md5" -if errorlevel 1 exit 1 -set /p PYPYLON_WHEEL_MD5_FOUND=<%PYPYLON_WHEEL%.md5 -if errorlevel 1 exit 1 -set "PYPYLON_WHEEL_MD5_FOUND=%PYPYLON_WHEEL_MD5_FOUND: =%" -if errorlevel 1 exit 1 -echo "%PYPYLON_WHEEL_MD5_FOUND%" | findstr /c:"%PYPYLON_WHEEL_MD5%" -if errorlevel 1 exit 1 -:: Install -pip install %PYPYLON_WHEEL% -if errorlevel 1 exit 1 -:: Clean up -del "%PYPYLON_WHEEL%" -if errorlevel 1 exit 1 -del "pypylon_wheel.md5" -if errorlevel 1 exit 1 diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md deleted file mode 100644 index c82d1d0..0000000 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ /dev/null @@ -1,45 +0,0 @@ ---- -name: Bug report -about: Create a report to help us improve -title: '' -labels: '' -assignees: '' - ---- - -## Bug Report - - - -## Versions -- [] `piescope` version (include branch name, and latest commit hash if you are working from a development version) - -## To Reproduce - -Steps to reproduce the behavior: - -1. -2. -3. - -## Expected behavior - - - -## Actual behavior - - - -## Error messages - - - -## Environment - - - Please copy and paste the result of `conda env export` here. - - - Any other relevant information: - -## Additional context - - diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md deleted file mode 100644 index ef1fdd7..0000000 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ /dev/null @@ -1,26 +0,0 @@ ---- -name: Feature request -about: Suggest an idea for this project -title: '' -labels: '' -assignees: '' - ---- - -## Feature Request - -### What the new feature should do - - - -### What improvement will this lead to? - - - -### What changes would need to be made for this new feature to happen? - - - -### Additional context - - diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md deleted file mode 100644 index df3be8f..0000000 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ /dev/null @@ -1,25 +0,0 @@ -# Description - - - -## Type of change - -- [ ] Bug-fix (non-breaking change which fixes an issue) -- [ ] New feature (non-breaking change which adds functionality) -- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) -- [ ] This change requires a documentation update - -# References - - - -# How has this been tested? - -- [ ] example: the test suite for my feature covers cases x, y, and z -- [ ] example: all tests pass with my change - -## Final checklist: -- [ ] My PR is the minimum possible work for the desired functionality -- [ ] I have commented my code, particularly in hard-to-understand areas -- [ ] I have made corresponding changes to the documentation -- [ ] I have added tests that prove my fix is effective or that my feature works diff --git a/.pep8speaks.yml b/.pep8speaks.yml deleted file mode 100644 index 6e08464..0000000 --- a/.pep8speaks.yml +++ /dev/null @@ -1,10 +0,0 @@ -scanner: - diff_only: True # Errors caused by only the patch are shown, not the whole file - -pycodestyle: - ignore: # Errors and warnings to ignore - - W391 # blank line at the end of file - - E203 # whitespace before ,;: - - W503 # newline before binary operator - -no_blank_comment: True # If True, no comment is made when the bot does not find any pep8 errors diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 73db201..0000000 --- a/.travis.yml +++ /dev/null @@ -1,12 +0,0 @@ -language: python -python: - - "3.6.7" -before_install: - - pip install -r requirements.txt - - pip install -r requirements-dev.txt - - source .travis_support/install_pylon.sh -install: - - pip install -e . -script: - - py.test --cov . -after_success: coveralls diff --git a/.travis_support/install_pylon.sh b/.travis_support/install_pylon.sh deleted file mode 100644 index 29099e1..0000000 --- a/.travis_support/install_pylon.sh +++ /dev/null @@ -1,28 +0,0 @@ -#!/bin/bash - -# Config for Basler Pylon software suite -# https://www.baslerweb.com/en/sales-support/downloads/software-downloads/ -export PYTHON_VERSION="36" -export PYLON_VERSION="5.2.0.13457" -export PYLON_MD5="fe9831729afeaf91005e93abc5e51d5b" -export PYLON_INSTALLER="${HOME}/pylon.tar.gz" -export PYLON_DIR="${HOME}/pylon-${PYLON_VERSION}-x86_64" -export PYLON_URL="https://www.baslerweb.com/fp-1551786516/media/downloads/software/pylon_software/pylon-${PYLON_VERSION}-x86_64.tar.gz" -# Python pypylon library (install after the pylon software suite) -# https://github.com/basler/pypylon/releases -export PYPYLON_VERSION="1.4.0" -export PYPYLON_MD5="aa47574b0067b7404568a0b17b7abd47" -export PYPYLON_WHEEL="${HOME}/pypylon-${PYPYLON_VERSION}-cp${PYTHON_VERSION}-cp${PYTHON_VERSION}m-linux_x86_64.whl" -export PYPYLON_URL="https://github.com/basler/pypylon/releases/download/${PYPYLON_VERSION}/pypylon-${PYPYLON_VERSION}-cp${PYTHON_VERSION}-cp${PYTHON_VERSION}m-linux_x86_64.whl" - -# Install the Basler Pylon software. -curl -L "${PYLON_URL}" > "${PYLON_INSTALLER}" -openssl md5 "${PYLON_INSTALLER}" | grep "${PYLON_MD5}" -tar -xvzf "${PYLON_INSTALLER}" -tar -C /opt -xzf */pylonSDK*.tar.gz -yes | ./*/setup-usb.sh - -# Install the python pypylon package -curl -L "${PYPYLON_URL}" > "${PYPYLON_WHEEL}" -openssl md5 "${PYPYLON_WHEEL}" | grep "${PYPYLON_MD5}" -pip install "${PYPYLON_WHEEL}" diff --git a/LICENSE b/LICENSE index 833a8fa..6629fb2 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2019 DeMarcoLab +Copyright (c) 2022 DeMarcoLab Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/conftest.py b/conftest.py deleted file mode 100644 index e69de29..0000000 diff --git a/DEVELOPERS.md b/docs/DEVELOPERS.md similarity index 100% rename from DEVELOPERS.md rename to docs/DEVELOPERS.md diff --git a/INSTALLATION.md b/docs/INSTALLATION.md similarity index 100% rename from INSTALLATION.md rename to docs/INSTALLATION.md diff --git a/piescope/_version.py b/piescope/_version.py index 1606ce1..2385e83 100644 --- a/piescope/_version.py +++ b/piescope/_version.py @@ -1 +1 @@ -__version__ = '0.2.0-dev' +__version__ = '0.3.0-dev' diff --git a/requirements-dev.txt b/requirements-dev.txt deleted file mode 100644 index 4d30d7b..0000000 --- a/requirements-dev.txt +++ /dev/null @@ -1,5 +0,0 @@ --r requirements/default.txt --r requirements/development.txt --r requirements/documentation.txt --r requirements/release.txt --r requirements/test.txt diff --git a/requirements.txt b/requirements.txt index 64c9401..95cdb60 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,15 @@ --r requirements/default.txt +matplotlib==3.0.2 +numpy +scikit-image>=0.15.0 +scipy>=1.3.0 +pyserial +PyYAML +nidaqmx +pypylon +pipython +opencv-python +# dev +flake8 +pytest +ipython +jupyter diff --git a/requirements/_frozen_env.txt b/requirements/_frozen_env.txt deleted file mode 100644 index bd23594..0000000 --- a/requirements/_frozen_env.txt +++ /dev/null @@ -1,99 +0,0 @@ -appdirs==1.4.3 -atomicwrites==1.3.0 -attrs==19.1.0 -autopep8==1.4.4 -backcall==0.1.0 -black==19.3b0 -bleach==3.1.0 -chardet==3.0.4 -click==7.0 -cloudpickle==1.2.1 -colorama==0.4.1 -coverage==4.5.3 -coveralls==1.7.0 -cycler==0.10.0 -dask==1.2.2 -decorator==4.4.0 -defusedxml==0.6.0 -docopt==0.6.2 -easyprocess==0.2.7 -entrypoints==0.3 -flake8==3.7.7 -idna==2.8 -imagecodecs==2019.5.22 -imageio==2.5.0 -importlib-metadata==0.17 -ipykernel==5.1.1 -ipython==7.5.0 -ipython-genutils==0.2.0 -ipywidgets==7.4.2 -jedi==0.13.3 -jinja2==2.10.1 -jsonschema==3.0.1 -jupyter==1.0.0 -jupyter-client==5.2.4 -jupyter-console==6.0.0 -jupyter-core==4.4.0 -kiwisolver==1.1.0 -markupsafe==1.1.1 -matplotlib==3.1.0 -mccabe==0.6.1 -mistune==0.8.4 -mock==3.0.5 -more-itertools==7.0.0 -nbconvert==5.5.0 -nbformat==4.4.0 -networkx==2.3 -nose==1.3.7 -notebook==5.7.8 -numpy==1.13.3 -opencv-python==4.1.0.25 -pandocfilters==1.4.2 -parso==0.4.0 -pickleshare==0.7.5 -pillow==6.0.0 -pluggy==0.12.0 -prometheus-client==0.6.0 -prompt-toolkit==2.0.9 -py==1.8.0 -pycodestyle==2.5.0 -pyflakes==2.1.1 -pygments==2.4.2 -pyparsing==2.4.0 -pyqt5==5.11.3 -pyqt5-sip==4.19.17 -pyqt5-tools==5.11.3.1.4 -pyrsistent==0.15.2 -pyserial==3.4 -pytest==4.5.0 -pytest-cov==2.7.1 -pytest-faulthandler==1.6.0 -pytest-mock==1.10.4 -pytest-mpl==0.10 -pytest-qt==3.2.2 -python-dateutil==2.8.0 -python-dotenv==0.10.3 -pyvirtualdisplay==0.2.3 -pywavelets==1.0.3 -pywinpty==0.5.5 -pyyaml==5.1 -pyzmq==18.0.1 -qimage2ndarray==1.8 -qtconsole==4.5.1 -requests==2.22.0 -scikit-image==0.14.0 -scipy==1.3.0 -send2trash==1.5.0 -six==1.12.0 -terminado==0.8.2 -testpath==0.4.2 -tifffile==2019.5.22 -toml==0.10.0 -toolz==0.9.0 -tornado==6.0.2 -traitlets==4.3.2 -urllib3==1.25.3 -wcwidth==0.1.7 -webencodings==0.5.1 -widgetsnbextension==3.4.2 -zipp==0.5.1 diff --git a/requirements/default.txt b/requirements/default.txt deleted file mode 100644 index 35a2c1a..0000000 --- a/requirements/default.txt +++ /dev/null @@ -1,10 +0,0 @@ -matplotlib>=3.0.0 -numpy -scikit-image>=0.15.0 -scipy>=1.3.0 -pyserial -PyYAML -nidaqmx -pypylon -pipython -opencv-python \ No newline at end of file diff --git a/requirements/development.txt b/requirements/development.txt deleted file mode 100644 index 2b7710a..0000000 --- a/requirements/development.txt +++ /dev/null @@ -1,4 +0,0 @@ -autopep8 -flake8 -ipython -jupyter diff --git a/requirements/documentation.txt b/requirements/documentation.txt deleted file mode 100644 index 8eea79d..0000000 --- a/requirements/documentation.txt +++ /dev/null @@ -1,4 +0,0 @@ - -recommonmark -Sphinx!=2.4.0 # 2.4.0 is bugged, see https://github.com/sphinx-doc/sphinx/issues/7126 -sphinx-rtd-theme diff --git a/requirements/release.txt b/requirements/release.txt deleted file mode 100644 index 28da105..0000000 --- a/requirements/release.txt +++ /dev/null @@ -1,3 +0,0 @@ -twine -pygithub -tqdm diff --git a/requirements/test.txt b/requirements/test.txt deleted file mode 100644 index 77833a7..0000000 --- a/requirements/test.txt +++ /dev/null @@ -1,5 +0,0 @@ -coveralls -mock -pytest>=4.3.0 -pytest-cov -pytest-mpl diff --git a/setup.py b/setup.py index 55bade7..81da01b 100644 --- a/setup.py +++ b/setup.py @@ -11,18 +11,19 @@ def parse_requirements_file(filename): return requires -descr = """DeMarco lab FIB-SEM package for automated controls.""" +descr = """DeMarco lab PIE-scope package.""" DISTNAME = 'piescope' -DESCRIPTION = 'DeMarco lab FIB-SEM tools.' +DESCRIPTION = 'Integrated correlative light-electron microscopy tool' LONG_DESCRIPTION = descr -MAINTAINER = 'Genevieve Buckley' +AUTHOR_EMAIL = 'Patrick.Cleeve@monash.edu, David.Dierickx1@monash.edu' +MAINTAINERS = 'Patrick Cleeve, David Dierickx' URL = 'https://github.com/DeMarcoLab/piescope' DOWNLOAD_URL = 'https://github.com/DeMarcoLab/piescope' VERSION = __version__ PYTHON_VERSION = (3, 7) INST_DEPENDENCIES = parse_requirements_file( - os.path.join('requirements', 'default.txt') + 'requirements.txt' ) if __name__ == '__main__': @@ -32,7 +33,8 @@ def parse_requirements_file(filename): url=URL, description=DESCRIPTION, long_description=LONG_DESCRIPTION, - author=MAINTAINER, + author=MAINTAINERS, + author_email=AUTHOR_EMAIL, packages=find_packages(), install_requires=INST_DEPENDENCIES, ) From 6c063da7f732c1f7c42c04263a606a59e43afe61 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 24 Feb 2022 18:27:03 +1100 Subject: [PATCH 44/82] live imaging Co-authored-by: DavidDierickx --- piescope/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 49f3bd2..0771ab1 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -1,6 +1,6 @@ system: ip_address: 10.0.0.1 - offline_mode: True + online: True serial: port: "COM3" baudrate: 115200 @@ -33,7 +33,7 @@ imaging: camera: pin: P14 max_num_buffer: 5 # max number of images to store in the buffer - image_frame_interval: None # (float) time between frames if desired + image_frame_interval: NULL # (float) time between frames if desired ib: autosave: False filter_strength: 3 # int or None From daf5f3cc0520692c7f2fa20e0448d21d4945557b Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Fri, 25 Feb 2022 15:49:26 +1100 Subject: [PATCH 45/82] fix live imaging bug, add cmap --- piescope/config.yml | 3 ++- piescope/lm/laser.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 0771ab1..553fbe6 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -3,6 +3,7 @@ system: online: True serial: port: "COM3" + # port: "COM15" baudrate: 115200 timeout: 1 lm: @@ -29,7 +30,7 @@ imaging: trigger_mode: hardware # (str) 'software' [default] or 'hardware' autosave: False color: False - filter_strength: 0 # int or None + filter_strength: 3 # int or None camera: pin: P14 max_num_buffer: 5 # max number of images to store in the buffer diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 4356141..21ab0e6 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -30,7 +30,7 @@ def __init__(self, settings): serial_id=laser["ID"], wavelength=laser["wavelength"], power=0.0, - exposure_time=0.0, + exposure_time=1e6, enabled=False, pin=laser["pin"] ) @@ -107,7 +107,7 @@ def set_exposure_time(self, laser: Laser, exposure_time: float) -> None: ) exposure_time = np.clip( - exposure_time, 0.0, 10.0e6 + exposure_time, 1.0, 10.0e6 ) # unable to reverse the flow of time laser.exposure_time = exposure_time From c649f7bed7a0a1abea1adf6e96523ccd3a1d77f3 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Fri, 25 Feb 2022 15:52:19 +1100 Subject: [PATCH 46/82] update gitignore --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 51ed9f3..ac11781 100644 --- a/.gitignore +++ b/.gitignore @@ -68,3 +68,7 @@ nosetests.xml # Data directories notes/ + + +# conf +config.yml \ No newline at end of file From b0cd360e2ee58a641efa6d068308bf2c3373284f Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Fri, 25 Feb 2022 19:04:32 +1100 Subject: [PATCH 47/82] working volume imaging with SIM Co-authored-by: DavidDierickx --- piescope/config.yml | 8 ++ piescope/lm/arduino.py | 11 ++- piescope/lm/detector.py | 166 +--------------------------------------- piescope/lm/laser.py | 4 +- piescope/lm/mirror.py | 8 +- piescope/lm/volume.py | 149 +++++++++++++++++++++++++++++++++++- 6 files changed, 170 insertions(+), 176 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 553fbe6..ec33694 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -38,6 +38,14 @@ imaging: ib: autosave: False filter_strength: 3 # int or None + volume: + time_delay: 0.1 #sec + autosave: True + count_max: 2 + threshold: 10 + SIM: + angles: 3 + phases: 3 crosshairs: thickness: 0.1 # in % of image width length: 10 # in % of image width diff --git a/piescope/lm/arduino.py b/piescope/lm/arduino.py index a0ab480..c158d40 100644 --- a/piescope/lm/arduino.py +++ b/piescope/lm/arduino.py @@ -2,6 +2,8 @@ import serial import serial.tools.list_ports +from piescope.lm.laser import LaserController + DEFAULT_SERIAL_PORT = 'COM7' # default laser serial communication port class Arduino: @@ -10,11 +12,12 @@ def __init__(self, serial_port=DEFAULT_SERIAL_PORT): self.SERIAL_PORT = serial_port self.connection = connect_serial_port(self.SERIAL_PORT) - def send_volume_info(self, laser_dict): + def send_volume_info(self, laser_controller: LaserController): string_to_send = 'E' - for laser_name in ['laser640', 'laser561', 'laser488', 'laser405']: - if laser_name in laser_dict.keys(): - string_to_send += str(int(laser_dict[laser_name][1]/1e3)) + ' ' + for laser_name in ['laser640', 'laser561', 'laser488', 'laser405']: # order matters + laser = laser_controller.lasers[laser_name] + if laser.volume_enabled: + string_to_send += str(int(laser.exposure_time/1e3)) + ' ' else: string_to_send += str(0) + ' ' diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index f959e40..9bb4141 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -6,7 +6,7 @@ from pypylon import pylon from piescope.utils import TriggerMode - +from enum import Enum, auto class Basler: """Class for the Basler detector""" @@ -49,7 +49,6 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.AcquisitionFrameRateEnable.SetValue(False) # take images - # self.camera.StopGrabbing() self.camera.StartGrabbingMax(1) image = None @@ -58,7 +57,7 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException + 10000, pylon.TimeoutHandling_ThrowException ) if grabResult.GrabSucceeded(): @@ -77,167 +76,6 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: image = np.fliplr(image) return image - def camera_grab2( - self, - exposure_time=None, - trigger_mode="software", - flip_image=True, - laser_name=None, - laser_pins=None, - ): - """Grab a new image from the Basler detector. - - Parameters - ---------- - exposure_time : int - Exposure time, in microseconds (us). - trigger_mode : str - Trigger mode. - Available values are "software", "hardware" - flip_image : bool, optional - Whether to flip images, by default True - laser_name : str - Name of laser to use in live imaging. - Available values are "laser640", "laser561", "laser488", "laser405" - laser_pins : list of str - Pin names to trigger pins via hardware. - Individual names passed as 'PXX', with XX being the port and pin number, respectively - - Returns - ------- - image : numpy array - """ - self.camera.Open() - self.camera.StopGrabbing() - - if laser_name is not None: - if laser_pins is not None: - LASER_TO_PIN = { - "laser640": laser_pins[0], - "laser561": laser_pins[1], - "laser488": laser_pins[2], - "laser405": laser_pins[3], - } - else: - LASER_TO_PIN = { - "laser640": "P00", - "laser561": "P01", - "laser488": "P02", - "laser405": "P03", - } - laser_pin = LASER_TO_PIN[laser_name] - - else: - # raise ValueError('No laser selected') - pass - # TODO: Check this out - if trigger_mode is "software": - self.camera.TriggerMode.SetValue("Off") - self.camera.ExposureMode.SetValue("Timed") - if exposure_time is not None: - try: - self.camera.ExposureTime.SetValue(float(exposure_time)) - except Exception as e: - try: - self.camera.ExposureTimeAbs.SetValue(float(exposure_time)) - except Exception as e: - self.camera.Close() - raise e - elif trigger_mode is "hardware": - # set input - self.camera.LineSelector.SetValue("Line4") - self.camera.TriggerMode.SetValue("On") - self.camera.TriggerSource.SetValue("Line4") - - self.camera.ExposureMode.SetValue("TriggerWidth") - self.camera.AcquisitionFrameRateEnable.SetValue(False) - - # # set output - # self.camera.LineSelector.SetValue('Line3') - # self.camera.LineMode.SetValue('Output') - # self.camera.LineSource.SetValue('ExposureActive') - - else: - raise ValueError('Select "software" or "hardware"') - - self.camera.StopGrabbing() - self.camera.StartGrabbingMax(1) - - while self.camera.IsGrabbing(): - if trigger_mode is "hardware": - structured.single_line_pulse(delay=exposure_time, pin=laser_pin) - # structured.multi_line_pulse(exposure_time, self.camera_pin, laser_pin, 'P27') #TODO remove direct reference to pin 27 - - grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException - ) - - if grabResult.GrabSucceeded(): - image = grabResult.Array - else: - raise RuntimeError( - "Error: " - + grabResult.ErrorCode - + "\n" - + grabResult.ErrorDescription - ) - grabResult.Release() - self.camera.Close() - if flip_image is True: - image = np.flipud(image) - image = np.fliplr(image) - return image - - def grab_slice( - self, - n_images=9, - mirror_controller=None, - arduino=None, - laser_dict=None, - flip_image=True, - ): - """Grab a slice using Arduino and NI controller""" - - self.camera.Open() - self.camera.LineSelector.SetValue("Line4") - self.camera.TriggerMode.SetValue("On") - self.camera.TriggerSource.SetValue("Line4") - - self.camera.ExposureMode.SetValue("TriggerWidth") - self.camera.AcquisitionFrameRateEnable.SetValue(False) - - self.camera.MaxNumBuffer = 27 - self.camera.StopGrabbing() - # self.camera.StartGrabbing(pylon.GrabStrategy_OneByOne) - self.camera.StartGrabbingMax(n_images * len(laser_dict)) - self.images = [] - - arduino.send_volume_info(laser_dict=laser_dict) - mirror_controller.stopAll() - mirror_controller.start_macro(macro_name=StageMacro.MAIN) - - while self.camera.IsGrabbing(): - grabResult = self.camera.RetrieveResult( - 5000, pylon.TimeoutHandling_ThrowException - ) - if grabResult.GrabSucceeded(): - image = grabResult.Array - if flip_image is True: - image = np.flipud(image) - image = np.fliplr(image) - self.images.append(image) - - else: - raise RuntimeError( - "Error: " - + grabResult.ErrorCode - + "\n" - + grabResult.ErrorDescription - ) - grabResult.Release() - self.camera.Close() - print(self.images) - return self.images def minimum_exposure(self): """Minimum allowable exposure time.""" diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 21ab0e6..769c06f 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -15,6 +15,7 @@ class Laser: exposure_time: float # us enabled: bool pin: str + volume_enabled: bool class LaserController: @@ -32,7 +33,8 @@ def __init__(self, settings): power=0.0, exposure_time=1e6, enabled=False, - pin=laser["pin"] + pin=laser["pin"], + volume_enabled=False ) self.lasers[current_laser.name] = current_laser diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index f4efb8d..8abc3c1 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -18,7 +18,7 @@ class StageMacro(Enum): ONTARGET = auto() -class StageMode(Enum): +class ImagingType(Enum): WIDEFIELD = auto() SIM = auto() @@ -32,7 +32,7 @@ def __init__(self): self.axes = self.device.allaxes self.move_to(StagePosition.WIDEFIELD) self.current_position = StagePosition.WIDEFIELD - self.mode = StageMode.WIDEFIELD + self.mode = ImagingType.WIDEFIELD def home(self) -> None: """Returns the stage to 0 on all axes""" @@ -51,7 +51,7 @@ def get_current_position(self): def next_position(self): """Moves to the next SIM angle""" - if self.mode == StageMode.WIDEFIELD: + if self.mode == ImagingType.WIDEFIELD: return self.stopAll() if self.current_position == StagePosition.SIXTY: @@ -61,7 +61,7 @@ def next_position(self): elif self.current_position == StagePosition.HORIZONTAL: self.move_to(StagePosition.SIXTY) - def set_mode(self, mode=StageMode.WIDEFIELD): + def set_mode(self, mode=ImagingType.WIDEFIELD): self.mode = mode def get_mode(self): diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 75223ac..c3c8363 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -7,12 +7,155 @@ import piescope.lm.objective import piescope.lm.structured import piescope.lm.mirror -from piescope.lm.mirror import StagePosition, StageMacro - +from piescope.lm.mirror import StagePosition, StageMacro, ImagingType +from pypylon import pylon logger = logging.getLogger(__name__) +def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, +laser_controller, mirror_controller, objective_stage, detector, arduino, settings ): + + time_delay = settings['imaging']['volume']['time_delay'] + angles = settings['imaging']['SIM']['angles'] + phases = settings['imaging']['SIM']['phases'] + + total_volume_height = (num_z_slices - 1) * z_slice_distance + + # Move objective lens stage to the top of the volume + original_center_position = str(objective_stage.current_position()) + objective_stage.move_relative(int(total_volume_height / 2)) + time.sleep(time_delay) # Pause to be sure movement is completed + logger.debug('Objective lens stage moved to top of the image volume.') + + # temporarily set power to 0 to get image shape from detector + temp_power = laser_controller.get_laser_power(laser_controller.current_laser) + laser_controller.set_laser_power(laser_controller.current_laser, 0.) + array_shape = np.shape(detector.camera_grab(laser_controller.current_laser, settings)) # no lasers on + laser_controller.set_laser_power(laser_controller.current_laser, temp_power) + + volume_enabled_laser_count = 0 + for laser in laser_controller.lasers.values(): + if laser.volume_enabled: + volume_enabled_laser_count += 1 + + laser_controller.volume_laser_count = volume_enabled_laser_count + + volume = np.ndarray(dtype=np.uint8, + shape=(volume_enabled_laser_count, angles, num_z_slices, phases, array_shape[0], array_shape[1])) + + for z_slice in range(num_z_slices): + if imaging_mode == ImagingType.WIDEFIELD: + mirror_controller.stopAll() + mirror_controller.move_to(StagePosition.WIDEFIELD) + + channel = 0 + for laser in laser_controller.lasers.values(): + if laser.volume_enabled: + image = detector.camera_grab(laser, settings) + volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) + channel += 1 + + if imaging_mode == ImagingType.SIM: + slice = grab_slice(laser_controller=laser_controller, detector=detector, + settings=settings, mirror_controller=mirror_controller, arduino=arduino) + + slice_reshaped = np.array(slice).reshape(volume_enabled_laser_count, angles, phases, array_shape[0], array_shape[1]) + + img_index = list(range(len(slice))) + for channel in range(volume_enabled_laser_count): + for angle in range(angles): + for phase in range(phases): + # get the index for each parameters image in the slice + # see notebook for details + idx = img_index[channel::volume_enabled_laser_count][angle::angles][phase::phases][0] + # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] + slice_reshaped[channel, angle, phase] = slice[idx] + volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) + + # Move objective lens stage + target_position = (float(original_center_position) + + float(total_volume_height / 2.) + - (float(z_slice) * float(z_slice_distance)) + ) + objective_stage.move_relative(-int(z_slice_distance)) + time.sleep(time_delay) # Pause to be sure movement is completed. + # If objective stage movement not accurate enough, try it again + count = 0 + current_position = float(objective_stage.current_position()) + difference = current_position - target_position + + count_max = settings['imaging']['volume']['count_max'] + threshold = settings['imaging']['volume']['threshold'] + + while count < count_max and abs(difference) > threshold: + objective_stage.move_relative(-int(difference)) + time.sleep(time_delay) # Pause to be sure movement completed. + current_position = float(objective_stage.current_position()) + difference = current_position - target_position + logger.debug('Difference is: {}'.format(str(difference))) + count = count + 1 + piescope.lm.structured.single_line_pulse(100000, 'P04') + # TODO: add to pins in main + + # Finally, return the objective lens stage too original position + objective_stage.move_absolute(original_center_position) + logging.debug("Volume acquired, stage returned to its original position.") + logging.debug("Volume array shape: {}".format(volume.shape)) + logging.info("Fluorescence volume acquistion finished.") + return volume + +def grab_slice(laser_controller, + detector, + settings: dict, + mirror_controller, + arduino, + ): + """Grab a slice using Arduino and NI controller""" + detector.camera.Open() + detector.camera.LineSelector.SetValue("Line4") + detector.camera.TriggerMode.SetValue("On") + detector.camera.TriggerSource.SetValue("Line4") + + detector.camera.ExposureMode.SetValue("TriggerWidth") + detector.camera.AcquisitionFrameRateEnable.SetValue(False) + + angles = settings['imaging']['SIM']['angles'] + phases = settings['imaging']['SIM']['phases'] + + detector.camera.MaxNumBuffer = len(laser_controller.lasers) * angles * phases + detector.camera.StopGrabbing() + detector.camera.StartGrabbingMax(angles * phases * laser_controller.volume_laser_count) + images = [] + + arduino.send_volume_info(laser_controller=laser_controller) + + mirror_controller.stopAll() + mirror_controller.start_macro(macro_name=StageMacro.MAIN) + + while detector.camera.IsGrabbing(): + grabResult = detector.camera.RetrieveResult( + 10000, pylon.TimeoutHandling_ThrowException + ) + if grabResult.GrabSucceeded(): + image = grabResult.Array + image = np.flipud(image) + image = np.fliplr(image) + images.append(image) + + else: + raise RuntimeError( + "Error: " + + grabResult.ErrorCode + + "\n" + + grabResult.ErrorDescription + ) + grabResult.Release() + detector.camera.Close() + return images + + + def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, time_delay=1, count_max=5, threshold=5, phases=1, angles=1, mode="widefield", detector=None, lasers=None, @@ -176,7 +319,7 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, logger.debug('Difference is: {}'.format(str(difference))) count = count + 1 piescope.lm.structured.single_line_pulse(100000, 'P04') - # TODO: add to pins in main + # PO4 IS OBJECTIVE READY PIN # Finally, return the objective lens stage too original position objective_stage.move_absolute(original_center_position) From 9ef5be3c282480ea55f1b24898fe02f5fbeab34b Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 28 Feb 2022 15:02:33 +1100 Subject: [PATCH 48/82] added double click functionality --- piescope/config.yml | 4 +++- piescope/fibsem.py | 24 ++++++++++++++++++++++++ piescope/lm/detector.py | 1 + 3 files changed, 28 insertions(+), 1 deletion(-) diff --git a/piescope/config.yml b/piescope/config.yml index ec33694..1f1c804 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -30,12 +30,14 @@ imaging: trigger_mode: hardware # (str) 'software' [default] or 'hardware' autosave: False color: False - filter_strength: 3 # int or None + filter_strength: 0 # int or None camera: pin: P14 max_num_buffer: 5 # max number of images to store in the buffer image_frame_interval: NULL # (float) time between frames if desired + pixel_size: 5.86e-6 # acA1920-155um ib: + pretilt: 52 # TODO: check if this can be always assumed autosave: False filter_strength: 3 # int or None volume: diff --git a/piescope/fibsem.py b/piescope/fibsem.py index d2dcf2d..a5e1c3a 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -342,3 +342,27 @@ def update_camera_settings(camera_dwell_time, image_resolution): dwell_time=camera_dwell_time ) return camera_settings + + +def y_corrected_stage_movement(expected_y, stage_tilt, settings): + """Stage movement in Y, corrected for tilt of sample surface plane. + ---------- + expected_y : in meters + stage_tilt : in radians Can pass this directly microscope.specimen.stage.current_position.t + beam_type : BeamType, optional + BeamType.ELECTRON or BeamType.ION + Returns + ------- + StagePosition + Stage position to pass to relative movement function. + """ + # TODO: add settings, need to read pretilt, flat_to_ion magic number + from autoscript_sdb_microscope_client.structures import StagePosition + + tilt_adjustment = np.deg2rad(52 - settings['imaging']['ib']['pretilt']) # MAGIC_NUMBER + tilt_radians = stage_tilt + tilt_adjustment + y_move = +np.cos(tilt_radians) * expected_y + z_move = -np.sin(tilt_radians) * expected_y + logging.info(f"drift correction: the corrected Y shift is {y_move:.3e} meters") + logging.info(f"drift correction: the corrected Z shift is {z_move:.3e} meters") + return StagePosition(x=0, y=y_move, z=z_move) \ No newline at end of file diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 9bb4141..895c9a8 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -19,6 +19,7 @@ def __init__(self, settings: dict): print(f"Using {self.camera.GetDeviceInfo().GetModelName()} for light imaging.") self.camera_pin = settings["imaging"]["lm"]["camera"]["pin"] self.camera.MaxNumBuffer = settings["imaging"]["lm"]["camera"]["max_num_buffer"] + self.pixel_size = 5.86e-6 def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.Open() From 707c9af6b73ca368b3a1a68f30c7ebe5000f8838 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Tue, 1 Mar 2022 17:13:08 +1100 Subject: [PATCH 49/82] fixed MIP/RGB/Live/double and clean --- piescope/config.yml | 5 ++ piescope/lm/detector.py | 13 +++++ piescope/lm/laser.py | 4 +- piescope/lm/volume.py | 2 +- piescope/utils.py | 114 ++++++++++++++-------------------------- 5 files changed, 62 insertions(+), 76 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 1f1c804..0707873 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -1,6 +1,7 @@ system: ip_address: 10.0.0.1 online: True + default_path: log/ serial: port: "COM3" # port: "COM15" @@ -13,18 +14,22 @@ lm: wavelength: 405 # nm pin: P00 ID: laser4 + colour: [0, 0, 255] - name: laser488 wavelength: 488 # nm pin: P01 ID: laser3 + colour: [0, 255, 0] - name: laser561 wavelength: 561 # nm pin: P02 ID: laser2 + colour: [255, 143, 51] - name: laser640 wavelength: 640 # nm pin: P03 ID: laser1 + colour: [148, 43, 35] imaging: lm: trigger_mode: hardware # (str) 'software' [default] or 'hardware' diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 895c9a8..69dd55e 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -22,6 +22,19 @@ def __init__(self, settings: dict): self.pixel_size = 5.86e-6 def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: + """Grabs a single fluorescence image + + Args: + laser (Laser): the laser to use when taking the image + settings (dict): settings dictionary + + Raises: + e: exception + RuntimeError: times out if takes too long to obtain an image + + Returns: + np.ndarray: an image of dimension (row, col) + """ self.camera.Open() self.camera.StopGrabbing() diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 769c06f..314e8a1 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -16,6 +16,7 @@ class Laser: enabled: bool pin: str volume_enabled: bool + colour: list class LaserController: @@ -34,7 +35,8 @@ def __init__(self, settings): exposure_time=1e6, enabled=False, pin=laser["pin"], - volume_enabled=False + volume_enabled=False, + colour=laser["colour"] ) self.lasers[current_laser.name] = current_laser diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index c3c8363..2ec304b 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -15,7 +15,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, laser_controller, mirror_controller, objective_stage, detector, arduino, settings ): - + #TODO: PROPER DOCSTRING, always returns CAZPYX time_delay = settings['imaging']['volume']['time_delay'] angles = settings['imaging']['SIM']['angles'] phases = settings['imaging']['SIM']['phases'] diff --git a/piescope/utils.py b/piescope/utils.py index 03f809f..d1cfb30 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -157,103 +157,69 @@ def save_image( ) -def max_intensity_projection(image, start_slice=0, end_slice=None): +def max_intensity_projection(image: np.ndarray) -> np.ndarray: """Returns maximum intensity projection of fluorescence image volume. - Parameters - ---------- - image : expecting numpy array with dimensions (pln, row, col, ch) - start_slice : expecting integer. First image index of z sub-stack - end_slice : expecting integer. Last image index of z sub-stack, not incl. + Args: + image (np.ndarray): expecting numpy array with dimensions: + (ch, angle, pln, phase, col, row) - Returns - ------- - projected_max_intensity - numpy array + Raises: + ValueError: only accepts 6-D volumes of shape (ch, angle, pln, phase, col, row) + + Returns: + np.ndarray: maximum intensity projected to ndarray of dimensions (col, row, ch) """ results = [] - # TODO: make this consistent - if image.ndim == 6: # CAZPYX + if image.ndim == 6: for channel_image in image: + # collapse angles, phases and planes, keeping cols, rows and channels max_intensity = np.max(channel_image, axis=(0, 1, 2)) results.append(max_intensity) + + # put channels on last axis projected_max_intensity = np.stack(results, axis=-1) + return projected_max_intensity - # Check input validity else: - if image.ndim != 4: - raise ValueError( - "expecting numpy.array with dimensions " "(pln, row, col, ch)" - ) - # Slice image stack - if end_slice is None: - image = image[start_slice:, ...] - else: - image = image[start_slice:end_slice, ...] - image = np.moveaxis(image, -1, 0) - - for channel_image in image: - max_intensity = np.max(channel_image, axis=0) - results.append(max_intensity) - projected_max_intensity = np.stack(results, axis=-1) - return projected_max_intensity + raise ValueError( + "expecting numpy.array with dimensions " "(ch, angle, pln, phase, col, row)" + ) -def rgb_image(image): - """Converts input image to RGB output image. +def rgb_image(image: np.ndarray, colour_dict: dict) -> np.ndarray: + """Convert an image into an RGB representation - Parameters - ---------- - image : ndarray - Input image array to convert to an RGB image. - Must have 2 (grayscale) or 3 (color) image dimensions. - The number of color channels must be less than 3. + Args: + image (np.ndarray): expect ndarray of dimension (col, row, ch<=4) + colour_dict (dict): dictionary of colour mapping - Returns - ------- - ndarray (M, N, 3) - RGB numpy image array. + Raises: + ValueError: image expected to be 3 dimensions - Raises - ------ - ValueError - Raised if the image dimensions or channels is not allowed. + Returns: + np.ndarray: rgb version of image with shape (col, row, 3) """ - if not (image.ndim == 2 or image.ndim == 3): + + if image.ndim != 3: raise ValueError( "Wrong number of dimensions in input image! " - "Expected an image with 2 or 3 dimensions, " + "Expected an image with 3 dimensions, " "but found {} dimensions".format(image.ndim) ) - if image.ndim == 2: - rgb_image = image - # rgb_image = skimage.color.gray2rgb(image) - return rgb_image - elif image.ndim == 3: - if image.shape[-1] == 1: - rgb_image = np.zeros( - shape=(image.shape[0], image.shape[1], 3), dtype=np.uint8 - ) - rgb_image[:, :, 0] = image[:, :, 0] - return rgb_image - elif image.shape[-1] == 2: - rgb_image = np.zeros( - shape=(image.shape[0], image.shape[1], 3), dtype=np.uint8 - ) - rgb_image[:, :, 0] = image[:, :, 0] - rgb_image[:, :, 1] = image[:, :, 1] - return rgb_image - elif image.shape[-1] == 3: - rgb_image = image - return rgb_image - else: - raise ValueError( - "Wrong number of image channels! " - "Expected up to 3 image channels, " - "but found {} channels.".format(image.shape[-1]) + + rgb = np.zeros(shape=(image.shape[0], image.shape[1], 3), dtype=np.uint8) + + for i in range(3): # for RGB + for channel in range(image.shape[-1]): # for each laser channel + rgb[:, :, i] = ( + rgb[:, :, i] + + image[:, :, channel] * float(colour_dict[channel][i]) * 1 / 255 ) + return rgb + def read_config(config_filename): with open(config_filename, "r") as file: @@ -336,7 +302,7 @@ def create_crosshair(image: np.ndarray or AdornedImage, settings: dict): (midx - cross_length / 2, midy - cross_width / 2), cross_length, cross_width ) rect_vertical = plt.Rectangle( - (midx - cross_width, midy - cross_length / 2), cross_width*2, cross_length + (midx - cross_width, midy - cross_length / 2), cross_width * 2, cross_length ) # set colours From 8c33f8a5f2e5dc81e40ff2616bf87bf30e47acab Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 2 Mar 2022 10:49:14 +1100 Subject: [PATCH 50/82] clean unused structured functions --- piescope/lm/structured.py | 62 ++++++++------------------------------- 1 file changed, 12 insertions(+), 50 deletions(-) diff --git a/piescope/lm/structured.py b/piescope/lm/structured.py index facbcdf..e0e89a9 100644 --- a/piescope/lm/structured.py +++ b/piescope/lm/structured.py @@ -4,7 +4,6 @@ import nidaqmx import time from nidaqmx.constants import (LineGrouping) -import threading LINES = {'P00': 'Dev1/port0/line0', 'P01': 'Dev1/port0/line1', @@ -34,7 +33,10 @@ def single_line_pulse(delay, pin): - task = nidaqmx.Task() + try: + task = nidaqmx.Task() + except Exception as e: + raise ConnectionError('Could not connect to nidaqmx device') task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(True) @@ -44,7 +46,10 @@ def single_line_pulse(delay, pin): def multi_line_pulse(delay, *pins): - task = nidaqmx.Task() + try: + task = nidaqmx.Task() + except Exception as e: + raise ConnectionError('Could not connect to nidaqmx device') for pin in pins: task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) @@ -56,54 +61,11 @@ def multi_line_pulse(delay, *pins): def single_line_onoff(onoff, pin): - task = nidaqmx.Task() + try: + task = nidaqmx.Task() + except Exception as e: + raise ConnectionError('Could not connect to nidaqmx device') task.do_channels.add_do_chan( LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES) task.write(onoff) task.close() - - -def read_line(pin): - timeout = 3 - start_time = time.time() - task = nidaqmx.Task() - task.di_channels.add_di_chan( - LINES[pin], line_grouping=LineGrouping.CHAN_FOR_ALL_LINES - ) - - triggered = False - - data = task.read() - while not triggered: - data = task.read() - if data: - triggered = True - if time.time() >= start_time + timeout: - print('Stage settling timed out') - break - - while data: - data = task.read() - if time.time() >= start_time + timeout: - print('Stage settling timed out') - break - task.close() - - -# single_line_pulse(3e6, 'P02') -# multi_line_pulse(3e6, 'P14', 'P13') -# read_line('P13') -# a# single_line_onoff(onoff=True, pin='P05') -# read_line('P06') -# single_line_onoff(onoff=True, pin='P03') -# read_line('P06') - - -def live_structured_worker(stop_event, run_time): - pass - - -def continuous_reading(run_time): - stop_event = threading.Event() - _thread = threading.Thread(target=live_structured_worker, args=(stop_event, run_time)) - _thread.start() From d180eb2ccda51c054cfa808c776f8034624a74df Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Fri, 4 Mar 2022 09:36:47 +1100 Subject: [PATCH 51/82] added objective ready pin --- piescope/config.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/piescope/config.yml b/piescope/config.yml index 0707873..04de186 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -7,6 +7,8 @@ serial: # port: "COM15" baudrate: 115200 timeout: 1 +lm_objective: + pin: P04 lm: default_laser: laser488 lasers: @@ -49,7 +51,7 @@ imaging: time_delay: 0.1 #sec autosave: True count_max: 2 - threshold: 10 + threshold: 10 SIM: angles: 3 phases: 3 From 3c361a732f4d95ccbcced59a0e1144890206cb19 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 7 Mar 2022 15:31:58 +1100 Subject: [PATCH 52/82] + example config. + config writing --- piescope/config.yml | 91 +++++++++++++++++++++++-------------- piescope/example_config.yml | 84 ++++++++++++++++++++++++++++++++++ piescope/lm/laser.py | 4 +- piescope/test_config.yml | 84 ++++++++++++++++++++++++++++++++++ piescope/utils.py | 12 +++++ 5 files changed, 239 insertions(+), 36 deletions(-) create mode 100644 piescope/example_config.yml create mode 100644 piescope/test_config.yml diff --git a/piescope/config.yml b/piescope/config.yml index 04de186..a302fee 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -1,10 +1,9 @@ system: ip_address: 10.0.0.1 - online: True + online: true default_path: log/ serial: - port: "COM3" - # port: "COM15" + port: COM3 baudrate: 115200 timeout: 1 lm_objective: @@ -12,44 +11,68 @@ lm_objective: lm: default_laser: laser488 lasers: - - name: laser405 - wavelength: 405 # nm - pin: P00 - ID: laser4 - colour: [0, 0, 255] - - name: laser488 - wavelength: 488 # nm - pin: P01 - ID: laser3 - colour: [0, 255, 0] - - name: laser561 - wavelength: 561 # nm - pin: P02 - ID: laser2 - colour: [255, 143, 51] - - name: laser640 - wavelength: 640 # nm - pin: P03 - ID: laser1 - colour: [148, 43, 35] + - name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 + colour: + - 0 + - 0 + - 255 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 + colour: + - 0 + - 255 + - 0 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 + colour: + - 255 + - 143 + - 51 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 + colour: + - 148 + - 43 + - 35 + power: 0 + exposure_time: 0 + volume_enabled: false imaging: lm: - trigger_mode: hardware # (str) 'software' [default] or 'hardware' - autosave: False - color: False - filter_strength: 0 # int or None + trigger_mode: Hardware # (str) 'Software' [default] or 'Hardware' + autosave: false + color: false + filter_strength: 0 # int or None camera: pin: P14 max_num_buffer: 5 # max number of images to store in the buffer - image_frame_interval: NULL # (float) time between frames if desired - pixel_size: 5.86e-6 # acA1920-155um + image_frame_interval: null # (float) time between frames if desired + pixel_size: 5.86e-06 # acA1920-155um ib: - pretilt: 52 # TODO: check if this can be always assumed - autosave: False - filter_strength: 3 # int or None + pretilt: 27 # TODO: check if this can be always assumed + autosave: false + filter_strength: 3 # int or None volume: - time_delay: 0.1 #sec - autosave: True + time_delay: 0.1 # sec + autosave: true count_max: 2 threshold: 10 SIM: diff --git a/piescope/example_config.yml b/piescope/example_config.yml new file mode 100644 index 0000000..a302fee --- /dev/null +++ b/piescope/example_config.yml @@ -0,0 +1,84 @@ +system: + ip_address: 10.0.0.1 + online: true + default_path: log/ +serial: + port: COM3 + baudrate: 115200 + timeout: 1 +lm_objective: + pin: P04 +lm: + default_laser: laser488 + lasers: + - name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 + colour: + - 0 + - 0 + - 255 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 + colour: + - 0 + - 255 + - 0 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 + colour: + - 255 + - 143 + - 51 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 + colour: + - 148 + - 43 + - 35 + power: 0 + exposure_time: 0 + volume_enabled: false +imaging: + lm: + trigger_mode: Hardware # (str) 'Software' [default] or 'Hardware' + autosave: false + color: false + filter_strength: 0 # int or None + camera: + pin: P14 + max_num_buffer: 5 # max number of images to store in the buffer + image_frame_interval: null # (float) time between frames if desired + pixel_size: 5.86e-06 # acA1920-155um + ib: + pretilt: 27 # TODO: check if this can be always assumed + autosave: false + filter_strength: 3 # int or None + volume: + time_delay: 0.1 # sec + autosave: true + count_max: 2 + threshold: 10 + SIM: + angles: 3 + phases: 3 + crosshairs: + thickness: 0.1 # in % of image width + length: 10 # in % of image width + color: xkcd:yellow diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 314e8a1..ad75e8b 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -32,10 +32,10 @@ def __init__(self, settings): serial_id=laser["ID"], wavelength=laser["wavelength"], power=0.0, - exposure_time=1e6, + exposure_time=laser["exposure_time"], enabled=False, pin=laser["pin"], - volume_enabled=False, + volume_enabled=laser["volume_enabled"], colour=laser["colour"] ) self.lasers[current_laser.name] = current_laser diff --git a/piescope/test_config.yml b/piescope/test_config.yml new file mode 100644 index 0000000..a302fee --- /dev/null +++ b/piescope/test_config.yml @@ -0,0 +1,84 @@ +system: + ip_address: 10.0.0.1 + online: true + default_path: log/ +serial: + port: COM3 + baudrate: 115200 + timeout: 1 +lm_objective: + pin: P04 +lm: + default_laser: laser488 + lasers: + - name: laser405 + wavelength: 405 # nm + pin: P00 + ID: laser4 + colour: + - 0 + - 0 + - 255 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser488 + wavelength: 488 # nm + pin: P01 + ID: laser3 + colour: + - 0 + - 255 + - 0 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser561 + wavelength: 561 # nm + pin: P02 + ID: laser2 + colour: + - 255 + - 143 + - 51 + power: 0 + exposure_time: 0 + volume_enabled: false + - name: laser640 + wavelength: 640 # nm + pin: P03 + ID: laser1 + colour: + - 148 + - 43 + - 35 + power: 0 + exposure_time: 0 + volume_enabled: false +imaging: + lm: + trigger_mode: Hardware # (str) 'Software' [default] or 'Hardware' + autosave: false + color: false + filter_strength: 0 # int or None + camera: + pin: P14 + max_num_buffer: 5 # max number of images to store in the buffer + image_frame_interval: null # (float) time between frames if desired + pixel_size: 5.86e-06 # acA1920-155um + ib: + pretilt: 27 # TODO: check if this can be always assumed + autosave: false + filter_strength: 3 # int or None + volume: + time_delay: 0.1 # sec + autosave: true + count_max: 2 + threshold: 10 + SIM: + angles: 3 + phases: 3 + crosshairs: + thickness: 0.1 # in % of image width + length: 10 # in % of image width + color: xkcd:yellow diff --git a/piescope/utils.py b/piescope/utils.py index d1cfb30..0e595df 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -227,6 +227,18 @@ def read_config(config_filename): settings_dict = parse_config(settings_dict) return settings_dict +def write_config(config_filename, config): + current_path = os.path.dirname(os.path.abspath(__file__)) + print(current_path) + print(f'Config path {config_filename}') + print(config) + + config['imaging']['lm']['trigger_mode'] = config['imaging']['lm']['trigger_mode'].name + print(config) + + with open(os.path.join(current_path, 'test_config.yml'), "w") as file: + yaml.safe_dump(config, file, sort_keys=False) + def parse_config(config): mode = str(config["imaging"]["lm"]["trigger_mode"]).title() From 205e7cfae4e377728e5bf9199ba181a6fb1fba19 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 7 Mar 2022 16:51:42 +1100 Subject: [PATCH 53/82] load/save ui state from config files Co-authored-by: DavidDierickx --- .gitignore | 3 ++- piescope/config.yml | 48 ++++++++++++++++++++++---------------------- piescope/lm/laser.py | 2 +- piescope/utils.py | 7 +------ 4 files changed, 28 insertions(+), 32 deletions(-) diff --git a/.gitignore b/.gitignore index ac11781..bc66a79 100644 --- a/.gitignore +++ b/.gitignore @@ -71,4 +71,5 @@ notes/ # conf -config.yml \ No newline at end of file +config.yml +piescope/test_config.yml diff --git a/piescope/config.yml b/piescope/config.yml index a302fee..8e5907e 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -12,66 +12,66 @@ lm: default_laser: laser488 lasers: - name: laser405 - wavelength: 405 # nm + wavelength: 405 pin: P00 ID: laser4 colour: - 0 - 0 - 255 - power: 0 - exposure_time: 0 + power: 0.0 + exposure_time: 1000.0 volume_enabled: false - name: laser488 - wavelength: 488 # nm + wavelength: 488 pin: P01 ID: laser3 colour: - 0 - 255 - 0 - power: 0 - exposure_time: 0 + power: 10.0 + exposure_time: 1000.0 volume_enabled: false - name: laser561 - wavelength: 561 # nm + wavelength: 561 pin: P02 ID: laser2 colour: - 255 - 143 - 51 - power: 0 - exposure_time: 0 - volume_enabled: false + power: 10.0 + exposure_time: 1000.0 + volume_enabled: true - name: laser640 - wavelength: 640 # nm + wavelength: 640 pin: P03 ID: laser1 colour: - 148 - 43 - 35 - power: 0 - exposure_time: 0 - volume_enabled: false + power: 10.0 + exposure_time: 500.0 + volume_enabled: true imaging: lm: - trigger_mode: Hardware # (str) 'Software' [default] or 'Hardware' + trigger_mode: Hardware autosave: false color: false - filter_strength: 0 # int or None + filter_strength: 0 camera: pin: P14 - max_num_buffer: 5 # max number of images to store in the buffer - image_frame_interval: null # (float) time between frames if desired - pixel_size: 5.86e-06 # acA1920-155um + max_num_buffer: 5 + image_frame_interval: null + pixel_size: 5.86e-06 ib: - pretilt: 27 # TODO: check if this can be always assumed + pretilt: 27 autosave: false - filter_strength: 3 # int or None + filter_strength: 3 volume: - time_delay: 0.1 # sec + time_delay: 0.1 autosave: true count_max: 2 threshold: 10 @@ -79,6 +79,6 @@ imaging: angles: 3 phases: 3 crosshairs: - thickness: 0.1 # in % of image width - length: 10 # in % of image width + thickness: 0.1 + length: 10 color: xkcd:yellow diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index ad75e8b..2fe2592 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -31,7 +31,7 @@ def __init__(self, settings): name=laser["name"], serial_id=laser["ID"], wavelength=laser["wavelength"], - power=0.0, + power=laser["power"], exposure_time=laser["exposure_time"], enabled=False, pin=laser["pin"], diff --git a/piescope/utils.py b/piescope/utils.py index 0e595df..f6fa453 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -228,15 +228,10 @@ def read_config(config_filename): return settings_dict def write_config(config_filename, config): - current_path = os.path.dirname(os.path.abspath(__file__)) - print(current_path) - print(f'Config path {config_filename}') - print(config) config['imaging']['lm']['trigger_mode'] = config['imaging']['lm']['trigger_mode'].name - print(config) - with open(os.path.join(current_path, 'test_config.yml'), "w") as file: + with open(config_filename, "w") as file: yaml.safe_dump(config, file, sort_keys=False) From 658833bebe3ee1b18e11a4aabcc3fcf529299842 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Tue, 8 Mar 2022 14:06:40 +1100 Subject: [PATCH 54/82] added lamella config --- piescope/config.yml | 12 +++++- piescope/test_config.yml | 84 ---------------------------------------- 2 files changed, 11 insertions(+), 85 deletions(-) delete mode 100644 piescope/test_config.yml diff --git a/piescope/config.yml b/piescope/config.yml index 8e5907e..4fc154b 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -52,7 +52,7 @@ lm: - 148 - 43 - 35 - power: 10.0 + power: 17.0 exposure_time: 500.0 volume_enabled: true imaging: @@ -82,3 +82,13 @@ imaging: thickness: 0.1 length: 10 color: xkcd:yellow +lamella: + lamella_width: 12e-6 + lamella_height: 10e-6 + total_cut_height: 10e-6 + milling_depth: 5e-6 + milling_current: 2.4e-09 + hfw: 150e-6 + size_ratio: 2.0 + trench_height: 5e-6 + offset: 0e-6 diff --git a/piescope/test_config.yml b/piescope/test_config.yml deleted file mode 100644 index a302fee..0000000 --- a/piescope/test_config.yml +++ /dev/null @@ -1,84 +0,0 @@ -system: - ip_address: 10.0.0.1 - online: true - default_path: log/ -serial: - port: COM3 - baudrate: 115200 - timeout: 1 -lm_objective: - pin: P04 -lm: - default_laser: laser488 - lasers: - - name: laser405 - wavelength: 405 # nm - pin: P00 - ID: laser4 - colour: - - 0 - - 0 - - 255 - power: 0 - exposure_time: 0 - volume_enabled: false - - name: laser488 - wavelength: 488 # nm - pin: P01 - ID: laser3 - colour: - - 0 - - 255 - - 0 - power: 0 - exposure_time: 0 - volume_enabled: false - - name: laser561 - wavelength: 561 # nm - pin: P02 - ID: laser2 - colour: - - 255 - - 143 - - 51 - power: 0 - exposure_time: 0 - volume_enabled: false - - name: laser640 - wavelength: 640 # nm - pin: P03 - ID: laser1 - colour: - - 148 - - 43 - - 35 - power: 0 - exposure_time: 0 - volume_enabled: false -imaging: - lm: - trigger_mode: Hardware # (str) 'Software' [default] or 'Hardware' - autosave: false - color: false - filter_strength: 0 # int or None - camera: - pin: P14 - max_num_buffer: 5 # max number of images to store in the buffer - image_frame_interval: null # (float) time between frames if desired - pixel_size: 5.86e-06 # acA1920-155um - ib: - pretilt: 27 # TODO: check if this can be always assumed - autosave: false - filter_strength: 3 # int or None - volume: - time_delay: 0.1 # sec - autosave: true - count_max: 2 - threshold: 10 - SIM: - angles: 3 - phases: 3 - crosshairs: - thickness: 0.1 # in % of image width - length: 10 # in % of image width - color: xkcd:yellow From 249293f46691ffb3edfc5c90d9dcb1c0c742671f Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Tue, 8 Mar 2022 15:39:37 +1100 Subject: [PATCH 55/82] fix volume bug --- piescope/lm/laser.py | 10 ++++++++++ piescope/lm/volume.py | 4 ++++ 2 files changed, 14 insertions(+) diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 2fe2592..2a274ff 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -50,6 +50,16 @@ def __init__(self, settings): self.current_laser = self.lasers[default_laser] + # TODO: improve this function + def set_volume_enabled(self, laser: Laser, enabled: bool) -> None: + """_summary_ + + Args: + laser (Laser): _description_ + enabled (bool): _description_ + """ + laser.volume_enabled = enabled + def set_laser_power(self, laser: Laser, power: float) -> None: """sets power level of laser diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 2ec304b..4bed836 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -33,13 +33,17 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, laser_controller.set_laser_power(laser_controller.current_laser, 0.) array_shape = np.shape(detector.camera_grab(laser_controller.current_laser, settings)) # no lasers on laser_controller.set_laser_power(laser_controller.current_laser, temp_power) + + print(f'Lasers: {laser_controller.lasers.values()}') volume_enabled_laser_count = 0 for laser in laser_controller.lasers.values(): if laser.volume_enabled: volume_enabled_laser_count += 1 + laser_controller.volume_laser_count = volume_enabled_laser_count + print(f'volume_enabled_laser_count: {laser_controller.volume_laser_count}') volume = np.ndarray(dtype=np.uint8, shape=(volume_enabled_laser_count, angles, num_z_slices, phases, array_shape[0], array_shape[1])) From b71ae0d27570199545590aac33dc5d9591e02ca4 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Tue, 8 Mar 2022 17:38:54 +1100 Subject: [PATCH 56/82] working milling position saving --- piescope/config.yml | 23 +++++++++++------------ piescope/fibsem.py | 13 ++++++++++--- 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 4fc154b..e277204 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -2,6 +2,7 @@ system: ip_address: 10.0.0.1 online: true default_path: log/ + pretilt: 27 serial: port: COM3 baudrate: 115200 @@ -19,7 +20,7 @@ lm: - 0 - 0 - 255 - power: 0.0 + power: 10.0 exposure_time: 1000.0 volume_enabled: false - name: laser488 @@ -42,7 +43,7 @@ lm: - 143 - 51 power: 10.0 - exposure_time: 1000.0 + exposure_time: 200.0 volume_enabled: true - name: laser640 wavelength: 640 @@ -52,7 +53,7 @@ lm: - 148 - 43 - 35 - power: 17.0 + power: 9.0 exposure_time: 500.0 volume_enabled: true imaging: @@ -67,7 +68,7 @@ imaging: image_frame_interval: null pixel_size: 5.86e-06 ib: - pretilt: 27 + relative_angle: 52 autosave: false filter_strength: 3 volume: @@ -83,12 +84,10 @@ imaging: length: 10 color: xkcd:yellow lamella: - lamella_width: 12e-6 - lamella_height: 10e-6 - total_cut_height: 10e-6 - milling_depth: 5e-6 + lamella_width: 1.2e-05 + lamella_height: 1.0e-05 + milling_depth: 5.0e-06 milling_current: 2.4e-09 - hfw: 150e-6 - size_ratio: 2.0 - trench_height: 5e-6 - offset: 0e-6 + hfw: 0.00015 + upper_height: 5.0e-06 + lower_height: 2.5e-06 diff --git a/piescope/fibsem.py b/piescope/fibsem.py index a5e1c3a..32a8848 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -344,7 +344,7 @@ def update_camera_settings(camera_dwell_time, image_resolution): return camera_settings -def y_corrected_stage_movement(expected_y, stage_tilt, settings): +def y_corrected_stage_movement(expected_y, stage_tilt, settings, image): """Stage movement in Y, corrected for tilt of sample surface plane. ---------- expected_y : in meters @@ -358,8 +358,15 @@ def y_corrected_stage_movement(expected_y, stage_tilt, settings): """ # TODO: add settings, need to read pretilt, flat_to_ion magic number from autoscript_sdb_microscope_client.structures import StagePosition - - tilt_adjustment = np.deg2rad(52 - settings['imaging']['ib']['pretilt']) # MAGIC_NUMBER + beam_type = image.metadata.acquisition.beam_type + if settings["system"]["pretilt"] == 0: + return StagePosition(x=0, y=expected_y, z=0) + if beam_type == 'Ion': + tilt_adjustment = np.deg2rad(settings["imaging"]["ib"]["relative_angle"] - settings['system']['pretilt']) + elif beam_type == 'Electron': + tilt_adjustment = np.deg2rad(-settings['system']['pretilt']) + else: + raise ValueError('Beam type of image not found') tilt_radians = stage_tilt + tilt_adjustment y_move = +np.cos(tilt_radians) * expected_y z_move = -np.sin(tilt_radians) * expected_y From 66fb4d67d9625f43905620c4e0888998ac3321cb Mon Sep 17 00:00:00 2001 From: David Dierickx Date: Tue, 8 Mar 2022 17:57:54 +1100 Subject: [PATCH 57/82] update TODOS --- piescope/fibsem.py | 1 - piescope/lm/laser.py | 9 +++++---- piescope/lm/volume.py | 22 +++++++++++----------- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 32a8848..3651f63 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -356,7 +356,6 @@ def y_corrected_stage_movement(expected_y, stage_tilt, settings, image): StagePosition Stage position to pass to relative movement function. """ - # TODO: add settings, need to read pretilt, flat_to_ion magic number from autoscript_sdb_microscope_client.structures import StagePosition beam_type = image.metadata.acquisition.beam_type if settings["system"]["pretilt"] == 0: diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 2a274ff..63949f7 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -50,14 +50,15 @@ def __init__(self, settings): self.current_laser = self.lasers[default_laser] - # TODO: improve this function def set_volume_enabled(self, laser: Laser, enabled: bool) -> None: - """_summary_ + """Sets volume enabled flag Args: - laser (Laser): _description_ - enabled (bool): _description_ + laser (Laser): laser to set the flag of + enabled (bool): value to set the flag to """ + if not isinstance(enabled, bool): + raise TypeError(f"Volume enabled must be a boolean. {type(enabled)} was passed.") laser.volume_enabled = enabled def set_laser_power(self, laser: Laser, power: float) -> None: diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 4bed836..6e1d475 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -33,18 +33,18 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, laser_controller.set_laser_power(laser_controller.current_laser, 0.) array_shape = np.shape(detector.camera_grab(laser_controller.current_laser, settings)) # no lasers on laser_controller.set_laser_power(laser_controller.current_laser, temp_power) - + print(f'Lasers: {laser_controller.lasers.values()}') - volume_enabled_laser_count = 0 + volume_enabled_laser_count = 0 for laser in laser_controller.lasers.values(): if laser.volume_enabled: volume_enabled_laser_count += 1 - - + + laser_controller.volume_laser_count = volume_enabled_laser_count print(f'volume_enabled_laser_count: {laser_controller.volume_laser_count}') - + volume = np.ndarray(dtype=np.uint8, shape=(volume_enabled_laser_count, angles, num_z_slices, phases, array_shape[0], array_shape[1])) @@ -58,14 +58,14 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, if laser.volume_enabled: image = detector.camera_grab(laser, settings) volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) - channel += 1 + channel += 1 if imaging_mode == ImagingType.SIM: slice = grab_slice(laser_controller=laser_controller, detector=detector, settings=settings, mirror_controller=mirror_controller, arduino=arduino) slice_reshaped = np.array(slice).reshape(volume_enabled_laser_count, angles, phases, array_shape[0], array_shape[1]) - + img_index = list(range(len(slice))) for channel in range(volume_enabled_laser_count): for angle in range(angles): @@ -76,7 +76,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] slice_reshaped[channel, angle, phase] = slice[idx] volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) - + # Move objective lens stage target_position = (float(original_center_position) + float(total_volume_height / 2.) @@ -100,7 +100,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, logger.debug('Difference is: {}'.format(str(difference))) count = count + 1 piescope.lm.structured.single_line_pulse(100000, 'P04') - # TODO: add to pins in main + # TODO: add to pins in main/config # Finally, return the objective lens stage too original position objective_stage.move_absolute(original_center_position) @@ -109,7 +109,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, logging.info("Fluorescence volume acquistion finished.") return volume -def grab_slice(laser_controller, +def grab_slice(laser_controller, detector, settings: dict, mirror_controller, @@ -126,7 +126,7 @@ def grab_slice(laser_controller, angles = settings['imaging']['SIM']['angles'] phases = settings['imaging']['SIM']['phases'] - + detector.camera.MaxNumBuffer = len(laser_controller.lasers) * angles * phases detector.camera.StopGrabbing() detector.camera.StartGrabbingMax(angles * phases * laser_controller.volume_laser_count) From 3b5097ccb6455564f3569bf61249c35c92486d47 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 9 Mar 2022 11:19:17 +1100 Subject: [PATCH 58/82] added external code --- piescope/external/PI Macros/MAIN.txt | 28 +++ piescope/external/PI Macros/MOVEA.txt | 6 + piescope/external/PI Macros/MOVER.txt | 6 + piescope/external/PI Macros/ONTARGET.txt | 2 + piescope/external/PI Macros/PHASE.txt | 3 + piescope/external/piescope_arduino.ino | 283 +++++++++++++++++++++++ 6 files changed, 328 insertions(+) create mode 100644 piescope/external/PI Macros/MAIN.txt create mode 100644 piescope/external/PI Macros/MOVEA.txt create mode 100644 piescope/external/PI Macros/MOVER.txt create mode 100644 piescope/external/PI Macros/ONTARGET.txt create mode 100644 piescope/external/PI Macros/PHASE.txt create mode 100644 piescope/external/piescope_arduino.ino diff --git a/piescope/external/PI Macros/MAIN.txt b/piescope/external/PI Macros/MAIN.txt new file mode 100644 index 0000000..539a730 --- /dev/null +++ b/piescope/external/PI Macros/MAIN.txt @@ -0,0 +1,28 @@ +VAR 0DX 0.0082 +VAR 0DY 0 +VAR 60DX 0.007101 +VAR 60DY 0.0041 +VAR 120DX -0.007101 +VAR 120DY 0.0041 +MAC START MOVEA -2 -2 +MAC NSTART PHASE $1 +MAC START MOVER ${0DX} ${0DY} +MAC NSTART PHASE $1 +MAC START MOVER ${0DX} ${0DY} +MAC NSTART PHASE $1 +MAC START MOVEA 2 -2 +MAC NSTART PHASE $1 +MAC START MOVER ${60DX} ${60DY} +MAC NSTART PHASE $1 +MAC START MOVER ${60DX} ${60DY} +MAC NSTART PHASE $1 +MAC START MOVEA 2 2 +MAC NSTART PHASE $1 +MAC START MOVER ${120DX} ${120DY} +MAC NSTART PHASE $1 +MAC START MOVER ${120DX} ${120DY} +MAC NSTART PHASE $1 +JRC -24 ONT? 1 = 1 +JRC -25 ONT? 1 = 0 +JRC -26 ONT? 1 = 1 +JRC -27 ONT? 1 = 0 diff --git a/piescope/external/PI Macros/MOVEA.txt b/piescope/external/PI Macros/MOVEA.txt new file mode 100644 index 0000000..175b4ff --- /dev/null +++ b/piescope/external/PI Macros/MOVEA.txt @@ -0,0 +1,6 @@ +MAC START ONTARGET +DIO 3 1 +MOV 1 $2 +MOV 2 $1 +MAC START ONTARGET +DIO 3 0 diff --git a/piescope/external/PI Macros/MOVER.txt b/piescope/external/PI Macros/MOVER.txt new file mode 100644 index 0000000..314bd1d --- /dev/null +++ b/piescope/external/PI Macros/MOVER.txt @@ -0,0 +1,6 @@ +MAC START ONTARGET +DIO 3 1 +MVR 1 $2 +MVR 2 $1 +MAC START ONTARGET +DIO 3 0 diff --git a/piescope/external/PI Macros/ONTARGET.txt b/piescope/external/PI Macros/ONTARGET.txt new file mode 100644 index 0000000..2cbc79d --- /dev/null +++ b/piescope/external/PI Macros/ONTARGET.txt @@ -0,0 +1,2 @@ +WAC ONT? 1 = 1 +WAC ONT? 2 = 1 diff --git a/piescope/external/PI Macros/PHASE.txt b/piescope/external/PI Macros/PHASE.txt new file mode 100644 index 0000000..aa75457 --- /dev/null +++ b/piescope/external/PI Macros/PHASE.txt @@ -0,0 +1,3 @@ +MAC START ONTARGET +WAC DIO? 2 = 1 +WAC DIO? 2 = 0 diff --git a/piescope/external/piescope_arduino.ino b/piescope/external/piescope_arduino.ino new file mode 100644 index 0000000..160d15d --- /dev/null +++ b/piescope/external/piescope_arduino.ino @@ -0,0 +1,283 @@ +#include +#include +#include +#include "math.h" + +using namespace std; + +//DIGITAL PINS USABLE FOR INTERRUPTS +//Mega, Mega2560, MegaADK: 2, 3, 18, 19, 20, 21 +//Micro, Leonardo, other 32u4-based: 0, 1, 2, 3, 7 + +// Pin assignments +const int LASER_640 = 15; +const int LASER_561 = 4; +const int LASER_488 = 5; +const int LASER_405 = 11; + +const int LASER_640_INTERRUPT = 18; +const int LASER_561_INTERRUPT = 19; +const int LASER_488_INTERRUPT = 20; +const int LASER_405_INTERRUPT = 21; + +const int camera = 17; +const int camera_done = 9; +const int stage_interruptPin = 2; +const int slice_interruptPin = 3; + +// Laser variables +int LASERS[] = {LASER_640, LASER_561, LASER_488, LASER_405}; +long int exposure_405; +long int exposure_488; +long int exposure_561; +long int exposure_640; + +// state for checking interrupts +volatile byte state = LOW; + +// counter for the 9 sets of images to be taken per slice +const int n_sets = 9; +volatile int set_counter = 0; + +// flag for starting a new set of images (1 means ready for new slice) +volatile bool ready_to_slice = 1; +volatile bool waiting_on_objective = 0; +volatile bool objective_ready = 1; + +// Serial communication variables +int N = 0; +String input = ""; +String numbers[12]; +String temp = ""; + +// counter for timeout on stage not moving +unsigned long finish_time = 0; +unsigned long elapsed_time = 0; + +//***************************************************************************************************** +void setup() { + Serial.begin(115200); // use the same baud-rate as the python side + + // Pin Modes + pinMode(camera, OUTPUT); + pinMode(camera_done, OUTPUT); + pinMode(LASER_640, OUTPUT); + pinMode(LASER_561, OUTPUT); + pinMode(LASER_488, OUTPUT); + pinMode(LASER_405, OUTPUT); + + digitalWrite(LASER_640, LOW); + digitalWrite(LASER_561, LOW); + digitalWrite(LASER_488, LOW); + digitalWrite(LASER_405, LOW); + // Interrupts + pinMode(LASER_640_INTERRUPT, INPUT_PULLUP); + pinMode(LASER_561_INTERRUPT, INPUT_PULLUP); + pinMode(LASER_488_INTERRUPT, INPUT_PULLUP); + pinMode(LASER_405_INTERRUPT, INPUT_PULLUP); + attachInterrupt(digitalPinToInterrupt(LASER_640_INTERRUPT), ChangeState640, CHANGE); + attachInterrupt(digitalPinToInterrupt(LASER_561_INTERRUPT), ChangeState561, CHANGE); + attachInterrupt(digitalPinToInterrupt(LASER_488_INTERRUPT), ChangeState488, CHANGE); + attachInterrupt(digitalPinToInterrupt(LASER_405_INTERRUPT), ChangeState405, CHANGE); + + pinMode(stage_interruptPin, INPUT_PULLUP); + pinMode(slice_interruptPin, INPUT_PULLUP); + attachInterrupt(digitalPinToInterrupt(stage_interruptPin), StageComplete, FALLING); + attachInterrupt(digitalPinToInterrupt(slice_interruptPin), ObjectiveReady, RISING); +} +//***************************************************************************************************** + +// Main loop for reading serial comms +void loop() { + +// digitalWrite(1, LOW); +//} + // wait for objective if imaging is complete + if (waiting_on_objective) { + finish_time = millis(); + while (!objective_ready) { + elapsed_time = millis() - finish_time; + if (elapsed_time > 5000) + { + waiting_on_objective = 0; + Serial.println("TIMED OUT WAITING FOR OBJECTIVE"); + break; + } + } + if (objective_ready){ + TakeSliceImages(); + } + } + + // if not waiting on objective, wait for serial + while (Serial.available()) { + delay(2); + if (Serial.available() > 0) { + char c = Serial.read(); + input += c; + } + } + + if (input.length() > 0 && input[0] == 'E') { + N = 0; + // print incoming serial comm + Serial.print("Received "); + Serial.println(input); + + // go through each character + for (int ii = 1; ii <= input.length(); ++ii) { + // if the char is a digit, append it to an array + if (isdigit(input[ii]) ) { + temp += input[ii]; + } + + //this 0 is not an integer, is null string + else if (input[ii] == ' ' || input[ii] == 0) { + numbers[N] = temp; + temp = ""; + if (input[ii] == ' ') N++; + } + } + N++; + + exposure_405 = stringToInt(numbers[3]); + exposure_488 = stringToInt(numbers[2]); + exposure_561 = stringToInt(numbers[1]); + exposure_640 = stringToInt(numbers[0]); + + // reset slice variables + ready_to_slice = 1; + set_counter = 0; + Serial.println("running TakeSliceImages"); + TakeSliceImages(); + Serial.print("Waiting on objective flag: "); + Serial.println(waiting_on_objective); + Serial.println("finished TakeSliceImages"); + + + for (int jj = 0; jj < N; jj++) + numbers[jj] = ""; + } + + input = ""; + Serial.flush(); +} + +//***************************************************************************************************** +void TakeSliceImages() { + waiting_on_objective = 0; + objective_ready = 0; + set_counter = 0; + while (set_counter < n_sets) { + if (ready_to_slice) { + // reset ready_to_slice + ready_to_slice = 0; + + // increment set_counter + set_counter++; + TakeImages(); + + // Prints 'Image set X taken.' + Serial.print("Image set "); + Serial.print(set_counter); + Serial.print(" / "); + Serial.print(n_sets); + Serial.println(" taken."); + } + } + + waiting_on_objective = 1; +} + + +void TakeImages() { + long int exposures[] = {exposure_640, exposure_561, exposure_488, exposure_405}; + Serial.println("Taking image set "); + for (int index = 0; index <= 3; index++) { + if (exposures[index] != 0) { + // camera and laser on + digitalWrite(camera, HIGH); + digitalWrite(LASERS[index], HIGH); + + // wait for exposure time + delay(exposures[index]); + Serial.print("Exposing for "); + Serial.print(exposures[index]); + Serial.println(" ms."); + + // camera and laser off + digitalWrite(camera, LOW); + digitalWrite(LASERS[index], LOW); + + delay(125); // Required for falling edge to trigger on camera + } + } + digitalWrite(camera_done, HIGH); + delay(100); + digitalWrite(camera_done, LOW); +} + +void StageComplete() { + Serial.println("Stage finished moving"); + Serial.println("setting ready_to_slice to 1"); + ready_to_slice = 1; +} + +void ObjectiveReady() { + Serial.println("Objective ready for next slice"); + Serial.println("setting objective_ready to 1"); + objective_ready = 1; +} + +//***************************************************************************************************** +void ChangeState640() { + state = digitalRead(LASER_640_INTERRUPT); + + Serial.println("Laser: 640"); + Serial.print("State: "); + Serial.println(state); + + digitalWrite(LASER_640, state); + digitalWrite(camera, state); +} +void ChangeState561() { + state = digitalRead(LASER_561_INTERRUPT); + + Serial.println("Laser: 561"); + Serial.print("State: "); + Serial.println(state); + + digitalWrite(LASER_561, state); + digitalWrite(camera, state); +} +void ChangeState488() { + state = digitalRead(LASER_488_INTERRUPT); + + // Serial.println("Laser: 488"); + // Serial.print("State: "); + // Serial.println(state); + + digitalWrite(LASER_488, state); + digitalWrite(camera, state); +} +void ChangeState405() { + state = digitalRead(LASER_405_INTERRUPT); + + // Serial.println("Laser: 405"); + // Serial.print("State: "); + // Serial.println(state); + + digitalWrite(LASER_405, state); + digitalWrite(camera, state); +} +//***************************************************************************************************** +unsigned long stringToInt(String num) { + int len; + unsigned long dec = 0; + len = num.length(); + for (int i = 0; i < len; i++) { + dec = dec * 10 + ( num[i] - '0' ); + } + return dec; +} +//***************************************************************************************************** From fbb3eed306bd856835f61fcf6623da5aec476138 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 9 Mar 2022 17:08:23 +1100 Subject: [PATCH 59/82] refactored correlation --- piescope/config.yml | 20 +++-- piescope/correlation.py | 164 ++++++++++++++++++++++++++++++++++++++++ piescope/fibsem.py | 102 ++++--------------------- piescope/lm/volume.py | 6 +- 4 files changed, 196 insertions(+), 96 deletions(-) create mode 100644 piescope/correlation.py diff --git a/piescope/config.yml b/piescope/config.yml index e277204..a55e9e5 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -3,6 +3,10 @@ system: online: true default_path: log/ pretilt: 27 + relative_lm_position: + - 0.0499092 + - -0.0001143 + save_config_on_exit: false serial: port: COM3 baudrate: 115200 @@ -10,7 +14,7 @@ serial: lm_objective: pin: P04 lm: - default_laser: laser488 + default_laser: laser640 lasers: - name: laser405 wavelength: 405 @@ -21,7 +25,7 @@ lm: - 0 - 255 power: 10.0 - exposure_time: 1000.0 + exposure_time: 600.0 volume_enabled: false - name: laser488 wavelength: 488 @@ -43,8 +47,8 @@ lm: - 143 - 51 power: 10.0 - exposure_time: 200.0 - volume_enabled: true + exposure_time: 100.0 + volume_enabled: false - name: laser640 wavelength: 640 pin: P03 @@ -53,8 +57,8 @@ lm: - 148 - 43 - 35 - power: 9.0 - exposure_time: 500.0 + power: 21.0 + exposure_time: 1000.0 volume_enabled: true imaging: lm: @@ -73,7 +77,7 @@ imaging: filter_strength: 3 volume: time_delay: 0.1 - autosave: true + autosave: false count_max: 2 threshold: 10 SIM: @@ -83,6 +87,8 @@ imaging: thickness: 0.1 length: 10 color: xkcd:yellow + correlation: + autosave: false lamella: lamella_width: 1.2e-05 lamella_height: 1.0e-05 diff --git a/piescope/correlation.py b/piescope/correlation.py new file mode 100644 index 0000000..103c561 --- /dev/null +++ b/piescope/correlation.py @@ -0,0 +1,164 @@ +import os +import time + +import numpy as np +import scipy.ndimage as ndi +import skimage +from skimage.transform import AffineTransform + +import piescope.utils + + +def point_coords(matched_points_dict): + """Create source & destination coordinate numpy arrays from cpselect dict. + + Matched points is an array where: + * the number of rows is equal to the number of points selected. + * the first column is the point index label. + * the second and third columns are the source x, y coordinates. + * the last two columns are the destination x, y coordinates. + + Parameters + ---------- + matched_points_dict : dict + Dictionary returned from cpselect containing matched point coordinates. + + Returns + ------- + (src, dst) + Row, column coordaintes of source and destination matched points. + Tuple contains two N x 2 ndarrays, where N is the number of points. + """ + + matched_points = np.array([list(point.values()) + for point in matched_points_dict]) + src = np.flip(matched_points[:, 1:3], axis=1) # flip for row, column index + dst = np.flip(matched_points[:, 3:], axis=1) # flip for row, column index + + return src, dst + + +def calculate_transform(src, dst, model=AffineTransform()): + """Calculate transformation matrix from matched coordinate pairs. + + Parameters + ---------- + src : ndarray + Matched row, column coordinates from source image. + dst : ndarray + Matched row, column coordinates from destination image. + model : scikit-image transformation class, optional. + By default, model=AffineTransform() + + + Returns + ------- + ndarray + Transformation matrix. + """ + + model.estimate(src, dst) + print('Transformation matrix:') + print(model.params) + + return model.params + + +def apply_transform(image, transformation, inverse=True, multichannel=True): + """Apply transformation to a 2D image. + + Parameters + ---------- + image : ndarray + Input image array. 2D grayscale image expected, or + 2D plus color channels if multichannel kwarg is set to True. + transformation : ndarray + Affine transformation matrix. 3 x 3 shape. + inverse : bool, optional + Inverse transformation, eg: aligning source image coords to destination + By default `inverse=True`. + multichannel : bool, optional + Treat the last dimension as color, transform each color separately. + By default `multichannel=True`. + + Returns + ------- + ndarray + Image warped by transformation matrix. + """ + + if inverse: + transformation = np.linalg.inv(transformation) + + if not multichannel: + if image.ndim == 2: + image = skimage.color.gray2rgb(image) + elif image.ndim != transformation.shape[0] - 1: + raise ValueError('Unexpected number of image dimensions for the ' + 'input transformation. Did you need to use: ' + 'multichannel=True ?') + + # move channel axis to the front for easier iteration over array + image = np.moveaxis(image, -1, 0) + warped_img = np.array([ndi.affine_transform((img_channel), transformation) + for img_channel in image]) + warped_img = np.moveaxis(warped_img, 0, -1) + + return warped_img + + +def overlay_images(fluorescence_image, fibsem_image, transparency=0.5): + """Blend two RGB images together. + + Parameters + ---------- + fluorescence_image : ndarray + 2D RGB image. + fibsem_image : ndarray + 2D RGB image. + transparency : float, optional + Transparency alpha parameter between 0 - 1, by default 0.5 + + Returns + ------- + ndarray + Blended 2D RGB image. + """ + + fluorescence_image = skimage.img_as_float(fluorescence_image) + fibsem_image = skimage.img_as_float(fibsem_image) + blended = transparency * fluorescence_image + (1 - transparency) * fibsem_image + blended = np.clip(blended, 0, 1) + + return blended + + +def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_points_dict): + """Correlates two images using points chosen by the user + + Parameters + ---------- + fluorescence_image_rgb : + umpy array with shape (cols, rows, channels) + fibsem_image : AdornedImage. + Expecting .data attribute of shape (cols, rows, channels) + output : str + Path to save location + + matched_points_dict : dict + Dictionary of points selected in the correlation window + """ + if matched_points_dict == []: + print('No control points selected, exiting.') + return + + src, dst = point_coords(matched_points_dict) + transformation = calculate_transform(src, dst) + fluorescence_image_aligned = apply_transform(fluorescence_image_rgb, transformation) + result = overlay_images(fluorescence_image_aligned, fibsem_image.data) + result = skimage.util.img_as_ubyte(result) + + # plt.imsave(output_path, result) + piescope.utils.save_image(result, output_path) + + return result diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 3651f63..0c2e733 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -1,6 +1,9 @@ import logging +from re import M import numpy as np +from piescope.utils import Modality + """Module for interacting with the FIBSEM using Autoscript.""" @@ -11,95 +14,23 @@ def initialise(ip_address='10.0.0.1'): microscope.connect(ip_address) return microscope -# Too far! even futher than the fluorescence position -# x = 54.5085 mm <-- LIMIT HIT -# -# Fluorescence position (roughly) -# x = +48.4295 mm -# y = -10.1004 mm -# -# FIBSEM position (roughly) -# x = -1.5225 mm -# y = -9.9092 mm -# -# Too far! even further than the FIBSEM place -# x = -51.4745 mm -# y = -9.718 mm -# z = -4.0000 mm -# -# LIMIT! -# x = -55.4915 mm <- LIMIT HIT -# - - -def move_to_light_microscope(microscope, x=50.0e-3, y=0.0): - """Move the sample stage from the FIBSEM to the light microscope. - - Parameters - ---------- - microscope : Autoscript microscope object. - x : float, optional - Relative movement in x to go from the FIBSEM to the light microscope. - By default positive 50 millimeters in the x-direction. - y : float, optional - Relative movement in y to go from the FIBSEM to the light microscope. - By default this is zero. - - Returns - ------- - StagePosition - FIBSEM microscope sample stage position after moving. - If the returned stage position is called 'stage_pos' then: - stage_pos.x = the x position of the FIBSEM sample stage (in meters) - stage_pos.y = the y position of the FIBSEM sample stage (in meters) - stage_pos.z = the z position of the FIBSEM sample stage (in meters) - stage_pos.r = the rotation of the FIBSEM sample stage (in radians) - stage_pos.t = the tilt of the FIBSEM sample stage (in radians) - """ +# TODO: add parameters to config +def move_to_microscope(microscope, settings: dict): from autoscript_sdb_microscope_client.structures import StagePosition + x, y = settings['system']['relative_lm_position'] current_position_x = microscope.specimen.stage.current_position.x - if current_position_x > 10e-3 or current_position_x < -10e-3: - print('Not under electron microscope, please reposition') - return - new_position = StagePosition(x=x, y=y, z=0, r=0, t=0) - microscope.specimen.stage.relative_move(new_position) - print("Moved to light microscope.") - return microscope.specimen.stage.current_position - - -def move_to_electron_microscope(microscope, x=-50.0e-3, y=0.0): - """Move the sample stage from the light microscope to the FIBSEM. - - Parameters - ---------- - microscope : Autoscript microscope object. - x : float, optional - Relative movement in x to go from the light microscope to the FIBSEM. - By default negative 50 millimeters in the x-direction. - y : float, optional - Relative movement in y to go from the light microscope to the FIBSEM. - By default this is zero. + if -10e-3 < current_position_x < 10e-3: + pass + print('Under FIBSEM, moving to light microscope') + elif 40e-3 < current_position_x < 60e-3: + x = -x + y = -y + print('Under light microscope, moving to FIBSEM') + else: + raise RuntimeError('Not positioned under the either microscope, cannot move to other microscope') - Returns - ------- - StagePosition - FIBSEM microscope sample stage position after moving. - If the returned stage position is called 'stage_pos' then: - stage_pos.x = the x position of the FIBSEM sample stage (in meters) - stage_pos.y = the y position of the FIBSEM sample stage (in meters) - stage_pos.z = the z position of the FIBSEM sample stage (in meters) - stage_pos.r = the rotation of the FIBSEM sample stage (in radians) - stage_pos.t = the tilt of the FIBSEM sample stage (in radians) - """ - from autoscript_sdb_microscope_client.structures import StagePosition - current_position_x = microscope.specimen.stage.current_position.x - if current_position_x > 60e-3 or current_position_x < 40e-3: - print('Not under light microscope, please reposition') - return new_position = StagePosition(x=x, y=y, z=0, r=0, t=0) microscope.specimen.stage.relative_move(new_position) - print("Moved to electron microscope.") - return microscope.specimen.stage.current_position def new_ion_image(microscope, settings=None): @@ -152,7 +83,6 @@ def new_electron_image(microscope, settings=None): return image -# i'm pretty sure Gen coded that somwhere, might save you some time figurting it out def last_ion_image(microscope): """Get the last previously acquired ion beam image. @@ -371,4 +301,4 @@ def y_corrected_stage_movement(expected_y, stage_tilt, settings, image): z_move = -np.sin(tilt_radians) * expected_y logging.info(f"drift correction: the corrected Y shift is {y_move:.3e} meters") logging.info(f"drift correction: the corrected Z shift is {z_move:.3e} meters") - return StagePosition(x=0, y=y_move, z=z_move) \ No newline at end of file + return StagePosition(x=0, y=y_move, z=z_move) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 6e1d475..5c4ec7f 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -13,7 +13,7 @@ logger = logging.getLogger(__name__) -def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, +def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, laser_controller, mirror_controller, objective_stage, detector, arduino, settings ): #TODO: PROPER DOCSTRING, always returns CAZPYX time_delay = settings['imaging']['volume']['time_delay'] @@ -49,7 +49,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, shape=(volume_enabled_laser_count, angles, num_z_slices, phases, array_shape[0], array_shape[1])) for z_slice in range(num_z_slices): - if imaging_mode == ImagingType.WIDEFIELD: + if imaging_type == ImagingType.WIDEFIELD: mirror_controller.stopAll() mirror_controller.move_to(StagePosition.WIDEFIELD) @@ -60,7 +60,7 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_mode: ImagingType, volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) channel += 1 - if imaging_mode == ImagingType.SIM: + if imaging_type == ImagingType.SIM: slice = grab_slice(laser_controller=laser_controller, detector=detector, settings=settings, mirror_controller=mirror_controller, arduino=arduino) From 8610dac20b86de77fb0c449f7d85cb4d509d7932 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 9 Mar 2022 18:58:46 +1100 Subject: [PATCH 60/82] Updated save, YOLO, TODO --- piescope/config.yml | 12 +- piescope/correlation.py | 13 +- piescope/example_config.yml | 2 +- piescope/fibsem.py | 15 +- piescope/lm/detector.py | 4 +- piescope/lm/mirror.py | 8 +- piescope/lm/objective.py | 2 +- piescope/lm/volume.py | 291 +++++++++++++++++++++++------------- piescope/utils.py | 99 +++++------- 9 files changed, 260 insertions(+), 186 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index a55e9e5..be92165 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -6,6 +6,11 @@ system: relative_lm_position: - 0.0499092 - -0.0001143 + fibsem_min_position: -10.e-3 + fibsem_max_position: 10.e-3 + lm_min_position: 40.e-3 + lm_max_position: 60.e-3 + save_config_on_exit: false serial: port: COM3 @@ -67,7 +72,6 @@ imaging: color: false filter_strength: 0 camera: - pin: P14 max_num_buffer: 5 image_frame_interval: null pixel_size: 5.86e-06 @@ -77,9 +81,10 @@ imaging: filter_strength: 3 volume: time_delay: 0.1 - autosave: false + autosave: true count_max: 2 threshold: 10 + slice_interrupt_pin: P04 SIM: angles: 3 phases: 3 @@ -93,7 +98,8 @@ lamella: lamella_width: 1.2e-05 lamella_height: 1.0e-05 milling_depth: 5.0e-06 - milling_current: 2.4e-09 + milling_current: 10.1e-12 + # milling_current: 2.4e-09 hfw: 0.00015 upper_height: 5.0e-06 lower_height: 2.5e-06 diff --git a/piescope/correlation.py b/piescope/correlation.py index 103c561..99971f1 100644 --- a/piescope/correlation.py +++ b/piescope/correlation.py @@ -1,6 +1,5 @@ -import os -import time +import logging import numpy as np import scipy.ndimage as ndi import skimage @@ -58,8 +57,7 @@ def calculate_transform(src, dst, model=AffineTransform()): """ model.estimate(src, dst) - print('Transformation matrix:') - print(model.params) + logging.info(f'Transformation matrix: {model.params}') return model.params @@ -133,7 +131,7 @@ def overlay_images(fluorescence_image, fibsem_image, transparency=0.5): return blended -def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_points_dict): +def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_points_dict, settings): """Correlates two images using points chosen by the user Parameters @@ -149,7 +147,7 @@ def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_ Dictionary of points selected in the correlation window """ if matched_points_dict == []: - print('No control points selected, exiting.') + logging.error('No control points selected, exiting.') return src, dst = point_coords(matched_points_dict) @@ -159,6 +157,7 @@ def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_ result = skimage.util.img_as_ubyte(result) # plt.imsave(output_path, result) - piescope.utils.save_image(result, output_path) + if settings['imaging']['correlation']['autosave']: + piescope.utils.save_image(result, output_path) return result diff --git a/piescope/example_config.yml b/piescope/example_config.yml index a302fee..6758e02 100644 --- a/piescope/example_config.yml +++ b/piescope/example_config.yml @@ -67,7 +67,7 @@ imaging: image_frame_interval: null # (float) time between frames if desired pixel_size: 5.86e-06 # acA1920-155um ib: - pretilt: 27 # TODO: check if this can be always assumed + pretilt: 0 autosave: false filter_strength: 3 # int or None volume: diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 0c2e733..550ca09 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -14,18 +14,21 @@ def initialise(ip_address='10.0.0.1'): microscope.connect(ip_address) return microscope -# TODO: add parameters to config def move_to_microscope(microscope, settings: dict): from autoscript_sdb_microscope_client.structures import StagePosition x, y = settings['system']['relative_lm_position'] current_position_x = microscope.specimen.stage.current_position.x - if -10e-3 < current_position_x < 10e-3: - pass - print('Under FIBSEM, moving to light microscope') - elif 40e-3 < current_position_x < 60e-3: + fibsem_min = settings['system']['fibsem_min_position'] + fibsem_max = settings['system']['fibsem_max_position'] + lm_min = settings['system']['lm_min_position'] + lm_max = settings['system']['lm_max_position'] + + if fibsem_min < current_position_x < fibsem_max: + logging.info('Under FIBSEM, moving to light microscope') + elif lm_min < current_position_x < lm_max: x = -x y = -y - print('Under light microscope, moving to FIBSEM') + logging.info('Under light microscope, moving to FIBSEM') else: raise RuntimeError('Not positioned under the either microscope, cannot move to other microscope') diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 69dd55e..c6f0a78 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -1,5 +1,6 @@ """Module for the Basler fluorescence detector.""" import numpy as np +import logging from piescope.lm import structured from piescope.lm.laser import Laser from piescope.lm.mirror import StageMacro @@ -16,8 +17,7 @@ def __init__(self, settings: dict): self.camera = pylon.InstantCamera( pylon.TlFactory.GetInstance().CreateFirstDevice() ) - print(f"Using {self.camera.GetDeviceInfo().GetModelName()} for light imaging.") - self.camera_pin = settings["imaging"]["lm"]["camera"]["pin"] + logging.info(f"Using {self.camera.GetDeviceInfo().GetModelName()} for light imaging.") self.camera.MaxNumBuffer = settings["imaging"]["lm"]["camera"]["max_num_buffer"] self.pixel_size = 5.86e-6 diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index 8abc3c1..fa9fc95 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -1,6 +1,6 @@ from pipython import GCSDevice from enum import Enum, auto - +import logging class StagePosition(Enum): WIDEFIELD = [2, -3] @@ -43,7 +43,7 @@ def move_to(self, stage_position: StagePosition) -> None: GCSDevice.MOV(self.device, self.axes, stage_position.value) self.start_macro(StageMacro.ONTARGET) self.current_position = stage_position - print(f'Current position: {self.current_position.name}') + logging.info(f'Current position: {self.current_position.name}') def get_current_position(self): """Returns currently set position, not necessarily actual position""" @@ -80,7 +80,7 @@ def _open_device(self) -> None: # stop any previous or start-up macros if GCSDevice.IsRunningMacro(self.device): startup_macro = GCSDevice.qRMC(self.device).strip('\n') - print(f'Currently running macro: {startup_macro}, closing...') + logging.info(f'Currently running macro: {startup_macro}, closing...') self.stopAll() else: - print(f'Not running any macros on startup.') + logging.info(f'Not running any macros on startup.') diff --git a/piescope/lm/objective.py b/piescope/lm/objective.py index c59e36c..b0401d2 100644 --- a/piescope/lm/objective.py +++ b/piescope/lm/objective.py @@ -40,7 +40,7 @@ def __init__(self, host='169.254.111.111', port=139, timeout=5.0, if not testing: # try: self.connect((host, port)) - print('Successfully connected to SMARACT objective lens stage controller') + logging.info('Successfully connected to SMARACT objective lens stage controller') # except socket.timeout: # # handle the timeout # except Exception as e: diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 5c4ec7f..f352b4b 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -4,21 +4,49 @@ import piescope.lm.detector import piescope.lm.laser +from piescope.lm.laser import LaserController import piescope.lm.objective +from piescope.lm.objective import StageController +from piescope.lm.detector import Basler +from piescope.lm.arduino import Arduino import piescope.lm.structured import piescope.lm.mirror -from piescope.lm.mirror import StagePosition, StageMacro, ImagingType +from piescope.lm.mirror import PIController, StagePosition, StageMacro, ImagingType from pypylon import pylon logger = logging.getLogger(__name__) -def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, -laser_controller, mirror_controller, objective_stage, detector, arduino, settings ): - #TODO: PROPER DOCSTRING, always returns CAZPYX - time_delay = settings['imaging']['volume']['time_delay'] - angles = settings['imaging']['SIM']['angles'] - phases = settings['imaging']['SIM']['phases'] +def acquire_volume( + num_z_slices: int, + z_slice_distance: float, + imaging_type: ImagingType, + laser_controller: LaserController, + mirror_controller: PIController, + objective_stage: StageController, + detector: Basler, + arduino: Arduino, + settings: dict, +): + """acquires a volume through hardware triggering. + + Args: + num_z_slices (int): number of slices in the volume + z_slice_distance (float): distance between each slice + imaging_type (ImagingType): mode of imaging (options are widefield and SIM) + laser_controller (LaserController): Laser Controller + mirror_controller (PIController): Mirror Controller + objective_stage (StageController): Objective Stage Controller + detector (Basler): Basler Detector + arduino (Arduino): Arduino + settings (dict): configuration settings of the user interface + + Returns: + np.ndarray: volume stack of images, always 6 dimensional (CAZPYX) + """ + time_delay = settings["imaging"]["volume"]["time_delay"] + angles = settings["imaging"]["SIM"]["angles"] + phases = settings["imaging"]["SIM"]["phases"] total_volume_height = (num_z_slices - 1) * z_slice_distance @@ -26,27 +54,37 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, original_center_position = str(objective_stage.current_position()) objective_stage.move_relative(int(total_volume_height / 2)) time.sleep(time_delay) # Pause to be sure movement is completed - logger.debug('Objective lens stage moved to top of the image volume.') + logger.debug("Objective lens stage moved to top of the image volume.") # temporarily set power to 0 to get image shape from detector temp_power = laser_controller.get_laser_power(laser_controller.current_laser) - laser_controller.set_laser_power(laser_controller.current_laser, 0.) - array_shape = np.shape(detector.camera_grab(laser_controller.current_laser, settings)) # no lasers on + laser_controller.set_laser_power(laser_controller.current_laser, 0.0) + array_shape = np.shape( + detector.camera_grab(laser_controller.current_laser, settings) + ) # no lasers on laser_controller.set_laser_power(laser_controller.current_laser, temp_power) - print(f'Lasers: {laser_controller.lasers.values()}') + logging.info(f"Lasers: {laser_controller.lasers.values()}") volume_enabled_laser_count = 0 for laser in laser_controller.lasers.values(): if laser.volume_enabled: volume_enabled_laser_count += 1 - laser_controller.volume_laser_count = volume_enabled_laser_count - print(f'volume_enabled_laser_count: {laser_controller.volume_laser_count}') - - volume = np.ndarray(dtype=np.uint8, - shape=(volume_enabled_laser_count, angles, num_z_slices, phases, array_shape[0], array_shape[1])) + logging.info(f"volume_enabled_laser_count: {laser_controller.volume_laser_count}") + + volume = np.ndarray( + dtype=np.uint8, + shape=( + volume_enabled_laser_count, + angles, + num_z_slices, + phases, + array_shape[0], + array_shape[1], + ), + ) for z_slice in range(num_z_slices): if imaging_type == ImagingType.WIDEFIELD: @@ -57,14 +95,25 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, for laser in laser_controller.lasers.values(): if laser.volume_enabled: image = detector.camera_grab(laser, settings) - volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) + volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) channel += 1 if imaging_type == ImagingType.SIM: - slice = grab_slice(laser_controller=laser_controller, detector=detector, - settings=settings, mirror_controller=mirror_controller, arduino=arduino) + slice = grab_slice( + laser_controller=laser_controller, + detector=detector, + settings=settings, + mirror_controller=mirror_controller, + arduino=arduino, + ) - slice_reshaped = np.array(slice).reshape(volume_enabled_laser_count, angles, phases, array_shape[0], array_shape[1]) + slice_reshaped = np.array(slice).reshape( + volume_enabled_laser_count, + angles, + phases, + array_shape[0], + array_shape[1], + ) img_index = list(range(len(slice))) for channel in range(volume_enabled_laser_count): @@ -72,16 +121,19 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, for phase in range(phases): # get the index for each parameters image in the slice # see notebook for details - idx = img_index[channel::volume_enabled_laser_count][angle::angles][phase::phases][0] + idx = img_index[channel::volume_enabled_laser_count][ + angle::angles + ][phase::phases][0] # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] slice_reshaped[channel, angle, phase] = slice[idx] volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) - # Move objective lens stage - target_position = (float(original_center_position) - + float(total_volume_height / 2.) - - (float(z_slice) * float(z_slice_distance)) - ) + # Move objective lens stage + target_position = ( + float(original_center_position) + + float(total_volume_height / 2.0) + - (float(z_slice) * float(z_slice_distance)) + ) objective_stage.move_relative(-int(z_slice_distance)) time.sleep(time_delay) # Pause to be sure movement is completed. # If objective stage movement not accurate enough, try it again @@ -89,18 +141,18 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, current_position = float(objective_stage.current_position()) difference = current_position - target_position - count_max = settings['imaging']['volume']['count_max'] - threshold = settings['imaging']['volume']['threshold'] + count_max = settings["imaging"]["volume"]["count_max"] + threshold = settings["imaging"]["volume"]["threshold"] while count < count_max and abs(difference) > threshold: objective_stage.move_relative(-int(difference)) time.sleep(time_delay) # Pause to be sure movement completed. current_position = float(objective_stage.current_position()) difference = current_position - target_position - logger.debug('Difference is: {}'.format(str(difference))) + logger.debug("Difference is: {}".format(str(difference))) count = count + 1 - piescope.lm.structured.single_line_pulse(100000, 'P04') - # TODO: add to pins in main/config + piescope.lm.structured.single_line_pulse(100000, settings["imaging"]["volume"]["slice_interrupt_pin"]) + # Finally, return the objective lens stage too original position objective_stage.move_absolute(original_center_position) @@ -109,61 +161,74 @@ def acquire_volume(num_z_slices, z_slice_distance, imaging_type: ImagingType, logging.info("Fluorescence volume acquistion finished.") return volume -def grab_slice(laser_controller, - detector, - settings: dict, - mirror_controller, - arduino, - ): - """Grab a slice using Arduino and NI controller""" - detector.camera.Open() - detector.camera.LineSelector.SetValue("Line4") - detector.camera.TriggerMode.SetValue("On") - detector.camera.TriggerSource.SetValue("Line4") - - detector.camera.ExposureMode.SetValue("TriggerWidth") - detector.camera.AcquisitionFrameRateEnable.SetValue(False) - - angles = settings['imaging']['SIM']['angles'] - phases = settings['imaging']['SIM']['phases'] - - detector.camera.MaxNumBuffer = len(laser_controller.lasers) * angles * phases - detector.camera.StopGrabbing() - detector.camera.StartGrabbingMax(angles * phases * laser_controller.volume_laser_count) - images = [] - - arduino.send_volume_info(laser_controller=laser_controller) - - mirror_controller.stopAll() - mirror_controller.start_macro(macro_name=StageMacro.MAIN) - - while detector.camera.IsGrabbing(): - grabResult = detector.camera.RetrieveResult( - 10000, pylon.TimeoutHandling_ThrowException - ) - if grabResult.GrabSucceeded(): - image = grabResult.Array - image = np.flipud(image) - image = np.fliplr(image) - images.append(image) - - else: - raise RuntimeError( - "Error: " - + grabResult.ErrorCode - + "\n" - + grabResult.ErrorDescription - ) - grabResult.Release() - detector.camera.Close() - return images +def grab_slice( + laser_controller, + detector, + settings: dict, + mirror_controller, + arduino, +): + """Grab a slice using Arduino and NI controller""" + detector.camera.Open() + detector.camera.LineSelector.SetValue("Line4") + detector.camera.TriggerMode.SetValue("On") + detector.camera.TriggerSource.SetValue("Line4") + + detector.camera.ExposureMode.SetValue("TriggerWidth") + detector.camera.AcquisitionFrameRateEnable.SetValue(False) + + angles = settings["imaging"]["SIM"]["angles"] + phases = settings["imaging"]["SIM"]["phases"] + + detector.camera.MaxNumBuffer = len(laser_controller.lasers) * angles * phases + detector.camera.StopGrabbing() + detector.camera.StartGrabbingMax( + angles * phases * laser_controller.volume_laser_count + ) + images = [] + + arduino.send_volume_info(laser_controller=laser_controller) + + mirror_controller.stopAll() + mirror_controller.start_macro(macro_name=StageMacro.MAIN) + + while detector.camera.IsGrabbing(): + grabResult = detector.camera.RetrieveResult( + 10000, pylon.TimeoutHandling_ThrowException + ) + if grabResult.GrabSucceeded(): + image = grabResult.Array + image = np.flipud(image) + image = np.fliplr(image) + images.append(image) - -def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, - time_delay=1, count_max=5, threshold=5, phases=1, - angles=1, mode="widefield", detector=None, lasers=None, - objective_stage=None, mirror_controller=None, arduino=None, laser_pins=None): + else: + raise RuntimeError( + "Error: " + grabResult.ErrorCode + "\n" + grabResult.ErrorDescription + ) + grabResult.Release() + detector.camera.Close() + return images + + +def volume_acquisition( + laser_dict, + num_z_slices, + z_slice_distance, + time_delay=1, + count_max=5, + threshold=5, + phases=1, + angles=1, + mode="widefield", + detector=None, + lasers=None, + objective_stage=None, + mirror_controller=None, + arduino=None, + laser_pins=None, +): """Acquire an image volume using the fluorescence microscope. Parameters @@ -256,16 +321,25 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, original_center_position = str(objective_stage.current_position()) objective_stage.move_relative(int(total_volume_height / 2)) time.sleep(time_delay) # Pause to be sure movement is completed - logger.debug('Objective lens stage moved to top of the image volume.') + logger.debug("Objective lens stage moved to top of the image volume.") - if mode != 'widefield': + if mode != "widefield": angles = 3 phases = 3 # Create volume array to put the results into array_shape = np.shape(detector.camera_grab()) # no lasers on - volume = np.ndarray(dtype=np.uint8, - shape=(len(laser_dict), angles, num_z_slices, phases, array_shape[0], array_shape[1])) + volume = np.ndarray( + dtype=np.uint8, + shape=( + len(laser_dict), + angles, + num_z_slices, + phases, + array_shape[0], + array_shape[1], + ), + ) # Acquire volume image # For each slice @@ -275,20 +349,32 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, if mode == "widefield": mirror_controller.stopAll() mirror_controller.move_to(StagePosition.WIDEFIELD) - for channel, (laser_name, (laser_power, exposure_time)) in enumerate(laser_dict.items()): - print("z_slice: {}, laser: {}".format(z_slice, laser_name)) + for channel, (laser_name, (laser_power, exposure_time)) in enumerate( + laser_dict.items() + ): + logging.info("z_slice: {}, laser: {}".format(z_slice, laser_name)) logging.debug("laser_name: {}".format(laser_name)) - image = detector.camera_grab(exposure_time, trigger_mode='hardware', laser_name=laser_name, laser_pins=laser_pins) + image = detector.camera_grab( + exposure_time, + trigger_mode="hardware", + laser_name=laser_name, + laser_pins=laser_pins, + ) image = np.fliplr(image) volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) else: # n_images = angles * phases * len(laser_dict) - slice = detector.grab_slice(mirror_controller=mirror_controller, arduino=arduino, laser_dict=laser_dict) - + slice = detector.grab_slice( + mirror_controller=mirror_controller, + arduino=arduino, + laser_dict=laser_dict, + ) - slice_reshaped = np.array(slice).reshape(len(laser_dict), angles, phases, array_shape[0], array_shape[1]) + slice_reshaped = np.array(slice).reshape( + len(laser_dict), angles, phases, array_shape[0], array_shape[1] + ) # assert slice_reshaped.shape == () img_index = list(range(len(slice))) @@ -297,7 +383,9 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, for phase in range(phases): # get the index for each parameters image in the slice # see notebook for details - idx = img_index[channel::len(laser_dict)][angle::angles][phase::phases][0] + idx = img_index[channel :: len(laser_dict)][angle::angles][ + phase::phases + ][0] # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] slice_reshaped[channel, angle, phase] = slice[idx] @@ -305,10 +393,11 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) # Move objective lens stage - target_position = (float(original_center_position) - + float(total_volume_height / 2.) - - (float(z_slice) * float(z_slice_distance)) - ) + target_position = ( + float(original_center_position) + + float(total_volume_height / 2.0) + - (float(z_slice) * float(z_slice_distance)) + ) objective_stage.move_relative(-int(z_slice_distance)) time.sleep(time_delay) # Pause to be sure movement is completed. # If objective stage movement not accurate enough, try it again @@ -320,9 +409,9 @@ def volume_acquisition(laser_dict, num_z_slices, z_slice_distance, time.sleep(time_delay) # Pause to be sure movement completed. current_position = float(objective_stage.current_position()) difference = current_position - target_position - logger.debug('Difference is: {}'.format(str(difference))) + logger.debug("Difference is: {}".format(str(difference))) count = count + 1 - piescope.lm.structured.single_line_pulse(100000, 'P04') + piescope.lm.structured.single_line_pulse(100000, "P04") # PO4 IS OBJECTIVE READY PIN # Finally, return the objective lens stage too original position diff --git a/piescope/utils.py b/piescope/utils.py index f6fa453..e9814ed 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -88,73 +88,50 @@ def save_image( """ destination = os.path.normpath(destination) # Make sure the output file format is acceptable - SUPPORTED_IMAGE_TYPES = ".tif" - if not destination.endswith(SUPPORTED_IMAGE_TYPES): - destination += ".tif" + if not destination.endswith(".tiff"): + destination += ".tiff" + # Append timestamp string to filename, if needed if timestamp: timestamp_string = datetime.now().strftime("_%Y-%m-%dT%H%M%S%f") base, ext = os.path.splitext(destination) destination = base + timestamp_string + ext - # Modify filename to prevent overwriting, if allow_overwrite is False - # Appends filenames with "_(1)", "_(2)", etc. - if allow_overwrite is False: - while os.path.exists(destination): - base, ext = os.path.splitext(destination) - regex_match = re.search("_\\([0-9]*\\)$", base) - if regex_match: - current_idx = int(regex_match.group(0)[2:-1]) # strip "_(" ")" - suffix_len = len(regex_match.group(0)) - destination = base[:-suffix_len] + "_({})".format(current_idx + 1) + ext - else: - destination = base + "_(1)" + ext - # If directory does not currently exist, create it - directory_name = os.path.dirname(destination) - if not directory_name == "" and not os.path.isdir(directory_name): - os.makedirs(directory_name) - try: - image.save(destination) # eg: for AutoScript AdornedImage datatypes + + os.makedirs(os.path.dirname(destination), exist_ok=True) + + if isinstance(image, AdornedImage): + image.save(destination) logging.debug("Saved: {}".format(destination)) - # Metadata for AdornedImage types is saved in the OME-TIFF metadata. - # You can load the image and metadata back in using .load(), eg: - # from autoscript_sdb_microscope_client.structures import AdornedImage - # returned_image = AdornedImage().load("autoscript_save_filename.tif") - except AttributeError: - # numpy array metadata is saved with regular metadata (not OME-TIFF) - if isinstance(image, np.ndarray): - # Make sure we have the right datatype to svae for ImageJ - if image.dtype.char not in "BHhf": # uint8, uint16, int16, or ? - image = skimage.util.img_as_uint(image) # 16 bit unsigned int - # If it's a volume image, must split channels and save individually - if image.ndim == 5: # (AZPYX) - tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) - - elif image.ndim == 6: # (CAZPYX) --> (AZPYX) - volume_split = np.zeros(image.shape) - for i in range(image.shape[1]): - volume_split[:, i] = image[:, i] - metadata.update({"axes": "AZPYX"}) - destination = ( - destination.replace(".tif", "") + "_channel_" + str(i) + ".tif" - ) - logging.debug("Saved: {}".format(destination)) - tifffile.imwrite( - destination, volume_split[:, i], bigtiff=True, metadata=metadata - ) - - elif image.ndim == 3: # (YXC) - image = np.moveaxis(image, -1, 0) # move channel axis (CYX) - metadata.update({"axes": "CYX"}) - skimage.io.imsave(destination, image, imagej=True, metadata=metadata) - logging.debug("Saved: {}".format(destination)) - else: # Save all other images without changes - skimage.io.imsave(destination, image, imagej=True, metadata=metadata) - logging.debug("Saved: {}".format(destination)) - else: - raise ValueError( - "Cannot save image! Expected a numpy array or AdornedImage, " - "instead found image.dtype of {}".format(image.dtype) - ) + return + if isinstance(image, np.ndarray): + if image.dtype.char not in "BHhf": # uint8, uint16, int16, or ? + image = skimage.util.img_as_uint(image) # 16 bit unsigned int + + # if saving a volume: + if image.ndim == 6: # (CAZPYX) --> (AZPYX) + volume_split = np.zeros(image.shape) + for i in range(image.shape[0]): + volume_split[:, i] = image[:, i] + metadata.update({"axes": "AZPYX"}) + destination = (destination.replace(".tif", "") + "_channel_" + str(i) + ".tif") + tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, metadata=metadata) + return + + # otherwise save regular image + if image.ndim == 3: # (YXC) + image = np.moveaxis(image, -1, 0) # move channel axis (CYX) + metadata.update({"axes": "CYX"}) + + skimage.io.imsave(destination, image, imagej=True, metadata=metadata) + + logging.debug("Saved: {}".format(destination)) + + + else: + raise ValueError( + "Cannot save image! Expected a numpy array or AdornedImage, " + "instead found image.dtype of {}".format(image.dtype) + ) def max_intensity_projection(image: np.ndarray) -> np.ndarray: From 73793984f26fc38e09b8fcac948c23381a06a88b Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 9 Mar 2022 19:01:12 +1100 Subject: [PATCH 61/82] lower indentation in save images --- piescope/utils.py | 50 +++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/piescope/utils.py b/piescope/utils.py index e9814ed..e1e3e12 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -103,35 +103,33 @@ def save_image( image.save(destination) logging.debug("Saved: {}".format(destination)) return - if isinstance(image, np.ndarray): - if image.dtype.char not in "BHhf": # uint8, uint16, int16, or ? - image = skimage.util.img_as_uint(image) # 16 bit unsigned int - - # if saving a volume: - if image.ndim == 6: # (CAZPYX) --> (AZPYX) - volume_split = np.zeros(image.shape) - for i in range(image.shape[0]): - volume_split[:, i] = image[:, i] - metadata.update({"axes": "AZPYX"}) - destination = (destination.replace(".tif", "") + "_channel_" + str(i) + ".tif") - tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, metadata=metadata) - return - - # otherwise save regular image - if image.ndim == 3: # (YXC) - image = np.moveaxis(image, -1, 0) # move channel axis (CYX) - metadata.update({"axes": "CYX"}) - - skimage.io.imsave(destination, image, imagej=True, metadata=metadata) - - logging.debug("Saved: {}".format(destination)) - - - else: + if not isinstance(image, np.ndarray): raise ValueError( "Cannot save image! Expected a numpy array or AdornedImage, " "instead found image.dtype of {}".format(image.dtype) - ) + ) + + if image.dtype.char not in "BHhf": # uint8, uint16, int16, or ? + image = skimage.util.img_as_uint(image) # 16 bit unsigned int + + # if saving a volume: + if image.ndim == 6: # (CAZPYX) --> (AZPYX) + volume_split = np.zeros(image.shape) + for i in range(image.shape[0]): + volume_split[:, i] = image[:, i] + metadata.update({"axes": "AZPYX"}) + destination = (destination.replace(".tif", "") + "_channel_" + str(i) + ".tif") + tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, metadata=metadata) + return + + # otherwise save regular image + if image.ndim == 3: # (YXC) + image = np.moveaxis(image, -1, 0) # move channel axis (CYX) + metadata.update({"axes": "CYX"}) + + skimage.io.imsave(destination, image, imagej=True, metadata=metadata) + + logging.debug("Saved: {}".format(destination)) def max_intensity_projection(image: np.ndarray) -> np.ndarray: From 491f52663f21aa5011e91af118fa64125018216e Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 21 Mar 2022 12:46:23 +1100 Subject: [PATCH 62/82] fixed stage movement, added gui elems to dataclass Co-authored-by: DavidDierickx --- piescope/config.yml | 2 ++ piescope/lm/laser.py | 30 +++++++++++++++++++++++++++--- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index be92165..0c54f90 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -75,6 +75,8 @@ imaging: max_num_buffer: 5 image_frame_interval: null pixel_size: 5.86e-06 + objective_mag: 20 + telescope_mag: 3.333 ib: relative_angle: 52 autosave: false diff --git a/piescope/lm/laser.py b/piescope/lm/laser.py index 63949f7..eb99dec 100644 --- a/piescope/lm/laser.py +++ b/piescope/lm/laser.py @@ -1,9 +1,8 @@ """Module for laser control via serial communication.""" from dataclasses import dataclass -from wsgiref.simple_server import demo_app - import numpy as np from piescope import utils +from PyQt5.QtWidgets import QDoubleSpinBox, QLineEdit, QCheckBox @dataclass @@ -17,6 +16,9 @@ class Laser: pin: str volume_enabled: bool colour: list + spinBox: QDoubleSpinBox + lineEdit: QLineEdit + volumeCheckBox: QCheckBox class LaserController: @@ -36,7 +38,10 @@ def __init__(self, settings): enabled=False, pin=laser["pin"], volume_enabled=laser["volume_enabled"], - colour=laser["colour"] + colour=laser["colour"], + spinBox=None, + lineEdit=None, + volumeCheckBox=None ) self.lasers[current_laser.name] = current_laser @@ -61,6 +66,25 @@ def set_volume_enabled(self, laser: Laser, enabled: bool) -> None: raise TypeError(f"Volume enabled must be a boolean. {type(enabled)} was passed.") laser.volume_enabled = enabled + def set_double_spin_box(self, laser: Laser, spinBox: QDoubleSpinBox) -> None: + if not isinstance(spinBox, QDoubleSpinBox): + raise TypeError(f"Must set the double spin box as a QDoubleSpinBox. {type(spinBox)} was passed.") + + laser.spinBox = spinBox + + def set_line_edit(self, laser: Laser, lineEdit: QLineEdit) -> None: + if not isinstance(lineEdit, QLineEdit): + raise TypeError(f"Must set the line edit as a QLineEdit. {type(lineEdit)} was passed.") + + laser.lineEdit = lineEdit + + def set_check_box(self, laser: Laser, checkBox: QCheckBox) -> None: + if not isinstance(checkBox, QCheckBox): + raise TypeError(f"Must set the check box as a QCheckBox. {type(checkBox)} was passed.") + + laser.volumeCheckBox = checkBox + + def set_laser_power(self, laser: Laser, power: float) -> None: """sets power level of laser From 91f48f900bc322474574272ba2609f00baa1ac05 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 21 Mar 2022 13:07:15 +1100 Subject: [PATCH 63/82] fixed milling currents, error window --- piescope/config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/piescope/config.yml b/piescope/config.yml index 0c54f90..9abdd6a 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -100,7 +100,7 @@ lamella: lamella_width: 1.2e-05 lamella_height: 1.0e-05 milling_depth: 5.0e-06 - milling_current: 10.1e-12 + milling_current: 0.89e-9 # milling_current: 2.4e-09 hfw: 0.00015 upper_height: 5.0e-06 From 07a0d3d740c4add044334708e96cd831b6a6ccaf Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 21 Mar 2022 13:40:49 +1100 Subject: [PATCH 64/82] fix volume imaging --- piescope/lm/volume.py | 425 ++++++++++++++++++++-------------------- piescope/notebook.ipynb | 168 ++++++++++++++++ piescope/utils.py | 11 +- 3 files changed, 390 insertions(+), 214 deletions(-) create mode 100644 piescope/notebook.ipynb diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index f352b4b..b53a489 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -45,8 +45,12 @@ def acquire_volume( np.ndarray: volume stack of images, always 6 dimensional (CAZPYX) """ time_delay = settings["imaging"]["volume"]["time_delay"] - angles = settings["imaging"]["SIM"]["angles"] - phases = settings["imaging"]["SIM"]["phases"] + if imaging_type != ImagingType.WIDEFIELD: + angles = settings["imaging"]["SIM"]["angles"] + phases = settings["imaging"]["SIM"]["phases"] + else: + angles = 1 + phases = 1 total_volume_height = (num_z_slices - 1) * z_slice_distance @@ -212,211 +216,212 @@ def grab_slice( return images -def volume_acquisition( - laser_dict, - num_z_slices, - z_slice_distance, - time_delay=1, - count_max=5, - threshold=5, - phases=1, - angles=1, - mode="widefield", - detector=None, - lasers=None, - objective_stage=None, - mirror_controller=None, - arduino=None, - laser_pins=None, -): - """Acquire an image volume using the fluorescence microscope. - - Parameters - ---------- - laser_dict : dict - Dictionary with structure: {"name": (power, exposure)} with types - {str: (int, int)} - - num_z_slices : int - Amount of slices to take for total volume - - z_slice_distance : int - Distance in nm between each z slice - - time_delay : int, optional - Pause after moving to the top of the imaging volume, by default 1 - - count_max : int, optional - Maximum number of attempts to move the stage to its target position. - By default 5 - - threshold : int, optional - Threshold cutoff for deciding whether the current stage position - is close enough to the target position. Must be a positive number. - By default 5 - - phases : int, optional - The number of phases for structured illumination, typically 3. - Must be a positive number. - By default 1 for widefield imaging - - angles : int, optional - The number of angles for structured illumination, typically 3. - Must be a positive number. - By default 1 for widefield imaging - - mode : str - Imaging mode, by default widefield. - Possible values are "widefield" and "sim". - - detector : piescope.lm.detector.Basler(), optional - Fluorescence detector class instance. - Default value is None. - - lasers : piescope.lm.lasers.Laser(), optional - Lasers. - Default value is None. - - objective_stage : piescope.lm.objective.StageController(), optional - Objective lens stage class instance. - Default value is None. - - mirror_controller : piescope.lm.mirror.PIController(), optional - Stage controller for structured pattern mirror. - Default value is None. - - laser_pins : list of str - Pin names to trigger pins via hardware. - Individual names passed as 'PXX', with XX being the port and pin number, respectively - Default values is None. - - Returns - ------- - volume : multidimensional numpy array - numpy.ndarray with shape (z_slices, columns, rows, channels) - - Notes - ----- - It's good to assume a minimum of 0.5 microns per step, - and a maximum 300 microns total height for the volume acquisition. - """ - logging.info("Acquiring fluorescence volume...") - num_z_slices = int(num_z_slices) - z_slice_distance = int(z_slice_distance) - total_volume_height = (num_z_slices - 1) * z_slice_distance - - # Initialise hardware - if detector is None: - detector = piescope.lm.detector.Basler() - if lasers is None: - lasers = piescope.lm.laser.initialise_lasers() - if objective_stage is None: - objective_stage = piescope.lm.objective.StageController() - for laser_name, (laser_power, exposure_time) in laser_dict.items(): - lasers[laser_name].laser_power = laser_power - if mirror_controller is None: - mirror_controller = piescope.lm.mirror.PIController() - - # Move objective lens stage to the top of the volume - original_center_position = str(objective_stage.current_position()) - objective_stage.move_relative(int(total_volume_height / 2)) - time.sleep(time_delay) # Pause to be sure movement is completed - logger.debug("Objective lens stage moved to top of the image volume.") - - if mode != "widefield": - angles = 3 - phases = 3 - - # Create volume array to put the results into - array_shape = np.shape(detector.camera_grab()) # no lasers on - volume = np.ndarray( - dtype=np.uint8, - shape=( - len(laser_dict), - angles, - num_z_slices, - phases, - array_shape[0], - array_shape[1], - ), - ) - - # Acquire volume image - # For each slice - for z_slice in range(int(num_z_slices)): - logging.debug("z_slice: {}".format(z_slice)) - - if mode == "widefield": - mirror_controller.stopAll() - mirror_controller.move_to(StagePosition.WIDEFIELD) - for channel, (laser_name, (laser_power, exposure_time)) in enumerate( - laser_dict.items() - ): - logging.info("z_slice: {}, laser: {}".format(z_slice, laser_name)) - logging.debug("laser_name: {}".format(laser_name)) - - image = detector.camera_grab( - exposure_time, - trigger_mode="hardware", - laser_name=laser_name, - laser_pins=laser_pins, - ) - image = np.fliplr(image) - volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) - - else: - # n_images = angles * phases * len(laser_dict) - slice = detector.grab_slice( - mirror_controller=mirror_controller, - arduino=arduino, - laser_dict=laser_dict, - ) - - slice_reshaped = np.array(slice).reshape( - len(laser_dict), angles, phases, array_shape[0], array_shape[1] - ) - # assert slice_reshaped.shape == () - - img_index = list(range(len(slice))) - for channel in range(len(laser_dict)): - for angle in range(angles): - for phase in range(phases): - # get the index for each parameters image in the slice - # see notebook for details - idx = img_index[channel :: len(laser_dict)][angle::angles][ - phase::phases - ][0] - # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] - slice_reshaped[channel, angle, phase] = slice[idx] - - # Channel, then phase, then angle - volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) - - # Move objective lens stage - target_position = ( - float(original_center_position) - + float(total_volume_height / 2.0) - - (float(z_slice) * float(z_slice_distance)) - ) - objective_stage.move_relative(-int(z_slice_distance)) - time.sleep(time_delay) # Pause to be sure movement is completed. - # If objective stage movement not accurate enough, try it again - count = 0 - current_position = float(objective_stage.current_position()) - difference = current_position - target_position - while count < count_max and abs(difference) > threshold: - objective_stage.move_relative(-int(difference)) - time.sleep(time_delay) # Pause to be sure movement completed. - current_position = float(objective_stage.current_position()) - difference = current_position - target_position - logger.debug("Difference is: {}".format(str(difference))) - count = count + 1 - piescope.lm.structured.single_line_pulse(100000, "P04") - # PO4 IS OBJECTIVE READY PIN - - # Finally, return the objective lens stage too original position - objective_stage.move_absolute(original_center_position) - logging.debug("Volume acquired, stage returned to its original position.") - logging.debug("Volume array shape: {}".format(volume.shape)) - logging.info("Fluorescence volume acquistion finished.") - return volume +# def volume_acquisition( +# laser_dict, +# num_z_slices, +# z_slice_distance, +# time_delay=1, +# count_max=5, +# threshold=5, +# phases=1, +# angles=1, +# mode="widefield", +# detector=None, +# lasers=None, +# objective_stage=None, +# mirror_controller=None, +# arduino=None, +# laser_pins=None, +# ): +# """Acquire an image volume using the fluorescence microscope. + +# Parameters +# ---------- +# laser_dict : dict +# Dictionary with structure: {"name": (power, exposure)} with types +# {str: (int, int)} + +# num_z_slices : int +# Amount of slices to take for total volume + +# z_slice_distance : int +# Distance in nm between each z slice + +# time_delay : int, optional +# Pause after moving to the top of the imaging volume, by default 1 + +# count_max : int, optional +# Maximum number of attempts to move the stage to its target position. +# By default 5 + +# threshold : int, optional +# Threshold cutoff for deciding whether the current stage position +# is close enough to the target position. Must be a positive number. +# By default 5 + +# phases : int, optional +# The number of phases for structured illumination, typically 3. +# Must be a positive number. +# By default 1 for widefield imaging + +# angles : int, optional +# The number of angles for structured illumination, typically 3. +# Must be a positive number. +# By default 1 for widefield imaging + +# mode : str +# Imaging mode, by default widefield. +# Possible values are "widefield" and "sim". + +# detector : piescope.lm.detector.Basler(), optional +# Fluorescence detector class instance. +# Default value is None. + +# lasers : piescope.lm.lasers.Laser(), optional +# Lasers. +# Default value is None. + +# objective_stage : piescope.lm.objective.StageController(), optional +# Objective lens stage class instance. +# Default value is None. + +# mirror_controller : piescope.lm.mirror.PIController(), optional +# Stage controller for structured pattern mirror. +# Default value is None. + +# laser_pins : list of str +# Pin names to trigger pins via hardware. +# Individual names passed as 'PXX', with XX being the port and pin number, respectively +# Default values is None. + +# Returns +# ------- +# volume : multidimensional numpy array +# numpy.ndarray with shape (z_slices, columns, rows, channels) + +# Notes +# ----- +# It's good to assume a minimum of 0.5 microns per step, +# and a maximum 300 microns total height for the volume acquisition. +# """ +# logging.info("Acquiring fluorescence volume...") +# num_z_slices = int(num_z_slices) +# z_slice_distance = int(z_slice_distance) +# total_volume_height = (num_z_slices - 1) * z_slice_distance + +# # Initialise hardware +# if detector is None: +# detector = piescope.lm.detector.Basler() +# if lasers is None: +# lasers = piescope.lm.laser.initialise_lasers() +# if objective_stage is None: +# objective_stage = piescope.lm.objective.StageController() +# for laser_name, (laser_power, exposure_time) in laser_dict.items(): +# lasers[laser_name].laser_power = laser_power +# if mirror_controller is None: +# mirror_controller = piescope.lm.mirror.PIController() + +# # Move objective lens stage to the top of the volume +# original_center_position = str(objective_stage.current_position()) +# objective_stage.move_relative(int(total_volume_height / 2)) +# time.sleep(time_delay) # Pause to be sure movement is completed +# logger.debug("Objective lens stage moved to top of the image volume.") + +# if mode != "widefield": +# angles = 3 +# phases = 3 + + +# # Create volume array to put the results into +# array_shape = np.shape(detector.camera_grab()) # no lasers on +# volume = np.ndarray( +# dtype=np.uint8, +# shape=( +# len(laser_dict), +# angles, +# num_z_slices, +# phases, +# array_shape[0], +# array_shape[1], +# ), +# ) + +# # Acquire volume image +# # For each slice +# for z_slice in range(int(num_z_slices)): +# logging.debug("z_slice: {}".format(z_slice)) + +# if mode == "widefield": +# mirror_controller.stopAll() +# mirror_controller.move_to(StagePosition.WIDEFIELD) +# for channel, (laser_name, (laser_power, exposure_time)) in enumerate( +# laser_dict.items() +# ): +# logging.info("z_slice: {}, laser: {}".format(z_slice, laser_name)) +# logging.debug("laser_name: {}".format(laser_name)) + +# image = detector.camera_grab( +# exposure_time, +# trigger_mode="hardware", +# laser_name=laser_name, +# laser_pins=laser_pins, +# ) +# image = np.fliplr(image) +# volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) + +# else: +# # n_images = angles * phases * len(laser_dict) +# slice = detector.grab_slice( +# mirror_controller=mirror_controller, +# arduino=arduino, +# laser_dict=laser_dict, +# ) + +# slice_reshaped = np.array(slice).reshape( +# len(laser_dict), angles, phases, array_shape[0], array_shape[1] +# ) +# # assert slice_reshaped.shape == () + +# img_index = list(range(len(slice))) +# for channel in range(len(laser_dict)): +# for angle in range(angles): +# for phase in range(phases): +# # get the index for each parameters image in the slice +# # see notebook for details +# idx = img_index[channel :: len(laser_dict)][angle::angles][ +# phase::phases +# ][0] +# # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] +# slice_reshaped[channel, angle, phase] = slice[idx] + +# # Channel, then phase, then angle +# volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) + +# # Move objective lens stage +# target_position = ( +# float(original_center_position) +# + float(total_volume_height / 2.0) +# - (float(z_slice) * float(z_slice_distance)) +# ) +# objective_stage.move_relative(-int(z_slice_distance)) +# time.sleep(time_delay) # Pause to be sure movement is completed. +# # If objective stage movement not accurate enough, try it again +# count = 0 +# current_position = float(objective_stage.current_position()) +# difference = current_position - target_position +# while count < count_max and abs(difference) > threshold: +# objective_stage.move_relative(-int(difference)) +# time.sleep(time_delay) # Pause to be sure movement completed. +# current_position = float(objective_stage.current_position()) +# difference = current_position - target_position +# logger.debug("Difference is: {}".format(str(difference))) +# count = count + 1 +# piescope.lm.structured.single_line_pulse(100000, "P04") +# # PO4 IS OBJECTIVE READY PIN + +# # Finally, return the objective lens stage too original position +# objective_stage.move_absolute(original_center_position) +# logging.debug("Volume acquired, stage returned to its original position.") +# logging.debug("Volume array shape: {}".format(volume.shape)) +# logging.info("Fluorescence volume acquistion finished.") +# return volume diff --git a/piescope/notebook.ipynb b/piescope/notebook.ipynb new file mode 100644 index 0000000..a74918e --- /dev/null +++ b/piescope/notebook.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2_channel_3.tif']\n" + ] + } + ], + "source": [ + "import tifffile as tf\n", + "import glob \n", + "filenames = sorted(glob.glob(r\"C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\21-Mar-2022_13-22PM/*.tif\") )\n", + "print(filenames)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4, 1, 4, 1, 1200, 1920)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD0CAYAAACSA/HcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvcmrZXl27/fdp+/7c24TN5qMyKaqlFJVqVSWoJAwGIPtiUY2tsH4GYMmfgODB5b8F7yR4aGBQWCDHhieDTbYgxLGWPLAA5VKVkilLEVGRkV3m7jNuafvm32OByc/66xzM0sZcvHyBaq7Icm4955m71+z1nd913etX7Ber3V73V631+11e/3yXZF/3Tdwe91et9ftdXv967luHcDtdXvdXrfXL+l16wBur9vr9rq9fkmvWwdwe91et9ft9Ut63TqA2+v2ur1ur1/S69YB3F631+11e/2SXl+7AwiC4N8JguBpEAQ/C4Lg97/u77+9bq/b6/a6vTZX8HXWAQRBEJX0maR/W9KppB9L+o/W6/XffW03cXvdXrfX7XV7Sfr6I4B/Q9LP1uv1i/V6PZf0LyX97td8D7fX7XV73V63l75+B3BH0on7+fTz391et9ftdXvdXl/zFfuavy/4kt/tcFBBEPyepN+TpGQy+b29vT3FYtvbnM/nSiQSikQiymazCoJAs9lM8/lcYRhqsVhoOp0qkUgoFotpPB5rtVopFospGo0qGo1qvV5rtVppuVwqEolotVppsVhoPp8rGo0qFospEolouVxqNptJkmKxmBKJhMIwVBAEWq1WCsNQYRgKGi0IAvt/PB5XGIabB1yvlUgkFI1G7fP4zmg0qlQqpdVqJUn2d0mKRCKKRqMKgkDpdNruezqdKgxDRaNRxeNxrddrTSYTeTqPvy2XSy0WCwVBoGQyaffNfUWjUUmyz4vFYorH4wqCwJ5tsVjYv9frtf2Nz+BeGZcgCOy1vCYIAvuPsVwsFnZv/rOj0agSiYSWy6XW67XCMLTxiUQiO5/L/PnPiMViOz/z3i8svM//7j+TObz5Ov4WiUQUj8d3xsStXfs7cxeGoebzuX3OarX6wufFYjHFYjHN53Mtl0t7Tl7rx87Pi18nfpxjsZh9Dt9xcwwYo+VyufM9vI7v8vfBWLH/ZrPZF55luVx+Yf79mN4cL17rf5a0c083P+fm63lmXsszfdn33RxP/1nMD5/n18+XPRPzxu8Zc/93SbaOI5GIksmkjd1isfjCvMTjcSUSCUkbW8A+i0Qitk79M7FXsX/uul6v13V9xfV1O4BTSXfdz0eS3vgXrNfrP5L0R5L0/vvvr//gD/5A/X5f9+/fVzab1ZMnT1Sr1VSv17W/v68wDPWTn/xEnU5Ho9FIp6enKhQKeu+999RqtfQXf/EXGg6Hevjwob7//e8rm82qXq/r+PhYjx8/1nK51Js3b9TtdjUcDpXP55XP55VKpfT69Wu9fPlSYRiqXq/r4ODAnEokEtFwONR0OlW/31c6ndbBwYEkaTAYqFwuq9vtSpJ6vZ4kqVKpmHEbDAYKw1DJZFIPHz5Uo9HQcDjUaDTSZDJRr9dTtVrVvXv3FI/HVa/Xlc1m1W63dXZ2psePHyuVSun+/fuqVCr6yU9+ouPjY/X7fbv/VCql6XSqXq+nYrGou3fvajKZqN/v22KdTCaaTqcKgsDGtdFoaLlcqt1uazQa6eLiQsvlUpPJxBbweDzWZDKxeUun08pkMmZ8ZrOZ/ZdOp1UqlexvxWJR8Xhc8/lczWZT8/lci8XCFnm5XLax7Pf7ms1mur6+1mKx0He/+12dnp6q0+loPp+bw5I2GyYWiymVSqlUKqnVau0Y1MlkojAMzThLsjmYTCYGFHK5nGazmb3OG9TJZGIgAuOQzWaVyWQUhqFyuZzK5bLK5bJyuZz6/b5evXqlTqdjTh/gEY1GlUwmlc/ndXh4qMvLS/X7fS0WCxvXxWKhVCqlg4MDVatVxWIxnZ6e6uzszAAPn8N85PN5c/yz2UzJZFLJZFLxeNzmLR6P2+ddXl5qNBopCAI1Gg2FYWjPm0wmFYvFNBwONZvNzGCl02kDDfV6XbPZTPF4XM1m08bYf0apVFK32zWHiHFcrVZarVaKRqM2/6vVyuYUBzmfz+1eRqORGVwMf6FQUDKZVCKR0PX1tabTqYE8jH69XlepVFI6ndZsNtNoNDIQMhwONZ/PzZHhyJPJpL2W33OPpVJJ2WzWQAprlXtPJpPK5XIaDodaLpfK5/N69OiRJOnJkydqNpsGzFhLmUxG6XRa8XhcvV5Pk8nEHEcymVShUDDAC7jlu5j/WCymxWLx+i3s8dfuAH4s6YMgCN6TdCbpP5T0H/+8FwdBoHK5rMlkouFwqIuLC/X7fU2nU41GIw0GAy0WC52enqrVaimdTiudTiuZTOrq6soWtUfYh4eHun//vh49eqTT01P99V//tbrdri4vLxWJRJTP59VsNiVJ0+nUNthyudR0OpW02WDValWj0cgMLIu41WrZ+3AAkjQcDu3f0WhUpVJJ5XJZlUpFz549M8RerVYViUR0enqq1Wql6+trxWIxFQoFSdL3vvc9nZ2dqdFoSJLq9brCMLQNUCqVFIahZrOZGSDunXEEkSYSCSWTSQ2HQ00mE8ViMR0dHUmSms2mLi4u7J494o3FYrZJ+e5sNmtOJ5VKaTgc6vr6WsPhULlcTtFoVMViUaPRSK1Wy4wxBsBHEv1+3+afzR+GodLptD755BO99957tmmJjogYMNbdbtcMqUfNbF7WA1ESDgEHV61Wbc5wDtIWUXr0u1qtNB6PLcKLxWKaTCYaDAZqNpsaj8eazWaG1DD+3onM53MzqqPRSOPxWPF43MaGdYaB+M53vqPr62udnp6aU4nFYprNZur3+4rH42awGYfJZGKv9c/sHQ5GBcedSCTM6aVSKa3Xa83nc/X7fTOwnU5HQRBoMpkokUhoNBrt7GOM9mQyUTabtbU6m83MKeB8Qe/8jDNZLBZar9fm3IfDod0PUfFsNlMikdB0OtV8PjfDz1rPZDJqNBrqdrsGDsIwtPllPrkfnKh3TkRby+VSzWZT3W5X6XR6x7nj+DwAwlFdX19rvV6r1+spFospk8kokUhotVoZGJNkQCAejyudTtv4eUcEa8Ga9o7Lz+nfd32tDmC9Xi+DIPinkv4PSVFJ/8N6vf7pz3t9t9vVn/3Zn+njjz/Wq1evzDAUCgUNh0PFYjE1m00dHx8rl8vZwkmn0xoOh3rz5o1KpZIGg4EikYi63a5tkDAMVSqVlM/nzbGk02l1Oh2l02lNJhMtl0szCPV6XY8ePdJqtdKdO3cUj8dt8v/mb/7GJrvb7drvPYqUZBMqSeVyWY1GQ8lkUu+//75arZZt+FKppNVqpV6vZ4Z3Op0qGo2q3++r0+losVgon8/r7OxMnU5HFxcXeH5JskUXiUQMqQ0GA63Xa0OFy+XSEAX3mkqllM1mzUDF43GlUilDF57CikQihvwzmYwKhYImk4lyuZxt5Hg8bvfV6/XMaXt6AZQnyd7X7XaNtmPslsulHj58qFarpUgkolwuJ0nKZDKq1Wq2Jq6urszgQmFBUXlKyH8/Y+bXHiE4iN1HG4VCwf6Gw2WtACAmk4mNrf8MSTsoeTabaTgc7hh93s93LJdLDQYDZTIZLRYLc97JZNLWSDqdttd6amE+n2s2mykaje48+3Q6VaFQMKOOEVqtVhYxJJNJzedzxeNxFQoFxeNxdTodAxKz2cwiijAMlUql7BkZX/bSer1WqVRSLpczp8Lz4gQ9LekdNc/Bz7lczuYA4zidTs1pe+MPjbpcLvXixQstFgu1221D6J4O9pSknweeR5KtAf4+n8+VzWaVTCY1Go1uUjFaLpdG1fZ6PaP6oHtw1Dgevw4w5rFYTOl0WpVKRWEY6uLiYsfocz/xeFzZbFbj8fgL9vTLrq87AtB6vf6hpB++zWsTiYRyuZx+/OMfq1KpSJJx/BjYXq9nG79YLCqZTCqTySiZTGo6narT6VjYt16vdXl5qTAM1e129erVK7XbbUMbIJ/RaGQ0BQi2Xq+rUCioUCjo3r17ho4xNMvlUpeXl0YJHBwcKJPJqNVqKQiCnXtMpVIqFova29tTv99XNps1BME9xGIxXV9fazAYmEMqFAp6+fKlpM1kX1xcqN1umwGQZBTGcDhUpVIxOmM8HisMQ6MqWq2WstmsKpWK6vW6oYl2u61Wq6VWq2Uh9WAwMM6SzQnSyGQyhv6JLI6Pj23Bg7Axhq1WS+VyWYeHhxoOh7aIQaeS7Du8s2FTXl5eqlQqqVgsqtlsGvKbz+eaTqdmVDHWN+mU1WqlRCJhnweNgnHjXpgvxjQajWqxWCiZTCqVSllOp9Vq2XeAWNl80EeSbD1iNJbLpXHpktRqtWwdzmYzM6SAHtZFv983p+457Hg8rkqlYsjaU1reiGJgMX4gU8ABlBgAYjabqVKpKJVKabFYKJ1O6+Liwoz/TVqENQLVgyEmOq1Wq4pGo8rlcnr9+rU5Qm/MMMZcrCsAjSRzOul0WqlUSuPx2HIYrE2MaBiGFoWMx2MzvrlcTplMRuPx2GgYqBScgc/JYWD5Xu/8AQAADmmbF2HdAESYG2gjHLZH8DzvcDhUJBJRoVDQBx98YHt7PB4bfUXE4YHI215fuwP4h1zT6VQXFxcaDoeq1WpmGPDOJycntgiPjo706NEjFQoFPX/+XIvFwsKoQqGgWCymFy9eSJIuLy/1+vVrtdttpVIpM8S5XM5QxnK5VDabVaPRsIl59uyZgiBQq9VSs9k0IxkEgabTqYX65CCgLwhZ+RyMjSTj+nA8nU5H5XLZDBWIplwuKwgC4+NzudwO4gItESKvViu1223jD7vdrgaDgTlSUDYRUy6X03q91tXVlfHEGIlyuSxpQwuBVgjj0+m0yuWyRqORlsul5TugEtiEoGsMKfmWTCZj431ycmKJdRLpngJaLBbG24J+4aavrq4soqlUKrYprq6uDBBI0mg0MsQmbdEZxpJ/Q/F4BLZYLDSZTIxS8glTz2mzwYmkeOYgCHacqCQzeNls1jhkDBHUQhiGisfjhphBvZ5v5nMKhYJRMN65QmN42o2oEiPnn2M4HNrfJpOJ8vm8GfN0Om2OCePKffoEJZROPp9XoVCwPNdwOLT9iXHn9V8WnQFuoFkxuMPhUKVSycCLzyPhGFgjjBPfw+cCGiQplUrtUIQ3E/K8h89jnRBdMu9BECifz+/Qb4PBYGd9ZbNZAySlUsmcDo4tm80qHo9bZMP6HQ6Htg95P3PKWmVu3uZ6px0A/Nz+/r4ymYwlHwmz4MUPDw+VTqcViUTMOBMm492Z0KurK1UqFQ0GA3U6HRWLRSUSCVUqFRUKBbXbbeMqMRLxeFyj0ciSS1dXV+a9+ftwOFS32zV0kEwmje/r9/s6ODhQNBrV1dWVGZt+v69ms6lms6l0Oq1oNKrxeGyfy3OORiO7n+Vyqfl8rm63q0qlYoYWpwDCIek2Ho8taY2TYazIU0QiERWLRRtzlFUswMPDQ+PVuaAgoCT4DwPgk6yz2UzlclnJZFKtVkuj0UiZTEZ7e3uqVquGmD/99FOjyTCAIK7lcmkRw2Qy0fX1tSQZ946DgcZKpVJ2v6DaQqFgkQIbDWPARmajFwoFQ1meUiGfAp3ik6z8HSPk50va0hJ8RxAEymQyyuVyZsDh1jEcHmVDDRQKBXudR82ej5a2UQOGU5J9P+jVOxCci+fhGRtooWw2a5SQp25YE+wH3kOktFqtdHV1ZZEe/4emiUQiOwo/xpG963NFGGaew0fP0tbxYAOq1aoSiYRFLRhMn5dj/lhvPDdG20ejXlnHxbpnPSWTSXNwiUTCQCugjdeT0+F5cQS5XE6VSkXtdtvWAc6TiBw611N7OPp3MgfwD71AQgcHBzo8PDQaBPqFTSTJjOnl5aVevXqlQqGgR48eWXJztVpZ0vb09NTeCxrd3983b4ySZLFYmHEiOsAowM9Km/AdZUOhUFAqldKLFy8sGZVIJFQoFFSv1y1Jxn+np6cKw1CJREL5fF7FYlHtdludTscUR/P5XK1Wy7hkqJzLy0sL40FVYRjq9PTUuNZms7kTBntZq08uYcS8oWXD9ft9Mz6ZTEaSjEbAwEHzMFa5XM4c42QyUSqVsjlDBlqv11WtVtXpdPT8+XP7O2qP5XJpzhRDyFz3+/0dPh0D0O/3lUwmNRgMJOkLzgM6B+Pmja2PLLi8moSLucbx8DmsWUkWdRKyt9ttQ9geuVWrVdVqNUO1UAJ+7YHCQY3z+dzoFU/veHoBQ+dVJoyV59F5Le/n3kDRRBQklm9GEZLMyDN33ljiYDC20HU+n+LzMFCqfJYkAwKAkl6vp1QqpXQ6baifSJH5wThOJhOVSqUdCbSP3HB4yEI9OIpEIpaklWTzQUTpE9kYYgAIcmbyQuwVwBWOjKjWo3/mBCq1Xq8bKIzFYsYQsA/ZK+T6vI38quuddgBBEKhareob3/iGDg4ONJvNLPzh/9VqVa9evdJwONSrV680Go0Mqezt7RnCbzabarfb5o25xuOxLXSUIxh/FiuGIwxDQ7Lj8di4R0mGcklEdTod43krlYqOjo6Uy+WUTCZ1fHz8BckfCgeoFFAqi0TaqI/4bhyaVzmhoOG+2QR+U7OBoYnYpCxMohaMMElAIilCaxJa8Lls+tFoZMltbyz6/b4ZYTbkYrHQxcWFnjx5YpERypNkMmmolaQ9dBuRH+hf2kYc5ERwVsxJoVCwqIGN4hVeni/GaJTLZdtIbDC/8SQZYpO0QwP5ZGwYhhatgdylrYYb40AEdRPBYchZDzgtz5OjKIHawZBK+gI6JjLhOzyNgzFhrXigA78NDSdtkTtGmHWWyWRMxMDYeX7bG19UMPwdx+bHif2HoSXpjeKKe0aUwGtRnXlH6Wt0/L5YLBamUCN6YR1zpVIpHR4e2rMCOPza4LuheqPRqK6vry1nw/3zWh+JMKYIHSaTiUlrb0qSyUlSD/X69WuVSiU9ePDgH4cDwMuOx2MdHx9L2tItoK5ms2kKHvjgBw8e6IMPPlChUNCDBw/U7XZVLBZ1dHSkWq2mXC6nTz75xIxSEARm/EFhjUbDFgKLvF6v23fv7e0pk8loOp1apDEej3V1dWWcHbQM70O91O12dX19rXa7bciGDekNtyRD3vl83nhBwlfUQMg9QWJwmV69EIlEzOgRvkJxSVspIAlznCAqIOit1WqjUoA6oq6CsYtEInrz5o2q1arm87kpsCRZNAZqevr0qYbDoaFeEF8QBBqNRra5PUIk6QyKB6EjCuC99XpdkUhElUpF0+nUinY8PYKhZp0xZvw7l8tZ5MKzoUHHSPnPBAEScUynUxMZ8J2SDLkuFgu9ePHCXtPtdi3JTERwEyn7cfS/g+LCuCWTSatvYR6hgrhv1p03+lzewbE2MpmMqcOkbSEe70NaWq1WbT0QwRFdcQFUeN/NMWJ+eH7oGygsFDTMCe+JRCJWBxOLxdTr9XR9fW1Gk3En+X2T/gRskIPyDiAIgh25sZca36SsoF4LhYLVhJBzw2H693H/ODsiTCI5/j4ajXacWaPRMCYDO0X0+zbXO+0ASK6en58b4vbInE2PBEuS9vf39d577+k3f/M3NZ/Pdf/+feVyOQu/USN8+9vf1p/+6Z/qt3/7t/Xq1StJMtoFnbPnhTH28/ncEqPX19fK5/NmJG8aYVCZJOPtX7x4oV6vZ7pkdL++uCOTyahYLKrT6UjabgrQEVwxhsYvQvhkScZDeqMGIru6ulIul1M6nd6RvWEMs9msKTlwkv752NDUIfgoYDKZ6OLiYgdZ+UU7n881Go0s0SjJjDqJOZ7bc++TyUTlctkoAZRFy+XSZH3QYOPxWNls1mSn0E4ACvh4kCvcrZfqxmIxNRoNHR8f70Rqnu/3VBJzxFh4GsZXdO7v76vVahmd2O12TUOPMep0OpaE9hQC0Z+vaOe+0cFDW2QyGV1fXysajapcLmu9XptjZXx90tOjYe/g/H3wOp6LZwLIEKVxz8wV74US8+sBtI0hIzeB05pOp+aofWQ0GAx2ihFxvp46ZC8i0USGyVplrn31rb8vABgXa5QxgH7kwgFEIhENBgP1+31L2PuL13jggVPz+TPA3E2Fj69NIWplLwCW3+Z6px2AJFPISDLNOhpgkifpdNoUPaD+dDpt6J9Qv1AoWMjdbrf14YcfWkjZ6XRMv723t2cLkbwBnGwqlVK5XDZP3Wq1JG1QHf/OZrNWlCbJfn9ycqLT01MLe7l4/cHBgSEU5IWg1GazqVQqZREQ6Ao6wEcGh4eHymQyOj8/t/Be0g6SgG5gE6P4YcFKG+URqPby8lLS1ujBceMMMHZQTjgVj274P5pwNjkOnKQt34HDRuJHIhQk6PMa3llLG+PAa3yO42bikYt1Beoix4Cx8EbSJwqJ3LgHSZbAWy43VeY+t+KdJ0VRs9lMl5eXpqKCA16tVqZSA3EyHp6S4j5xDkhOkYzCa/sCNX95+sc7Av8d0Wh0pwKX8eNZeM9sNjOny3xTCcu4+sQz40VuLJvNGifOc8HtA16IkAEKkmw+yM8dHx/v5OTK5bIWi4UymYw5DeaN56E9CYYZ0OarbFerlTqdjqbTqalufCIee3RwcKCTkxN7dk+RoeDzwJLxYJ1j0P1+laRqtWo/Z7NZFYtFE1bgILxY46uud9oBMDGETEdHR7q8vDRkcXR0pEwmo6dPnyoMQ925c8c8/dXV1Q7CrFar+tGPfmSDc3FxoVwup7OzM11dXVkyuFarWTXtycmmbx1/IwQmvPMFKCxqJohNXKvVFIlEdH5+bhXM2WxWiUTCZJrValV7e3t67733dHJyovF4rMFgYOXvLOrXr19b1AN694lpr+1mk1Cj4FEKSDiVSmm5XCqTyahSqRinOhqNFI/HNZ1OLZJJpVLq9XqKx+MqlUr2vMfHx8ZNplIpM6A8m1eXsOF5rkqlonK5vCPHI0HI60GavBeO3/ctKhQK5hy8ZpzIxKtSSNzeVHUkEokvaO7JxWD0+Q6Mmqe2oFZ8Qhpu2ucJptOpLi8vValUtL+/b07L5wBYc9Fo1KTQjUbDDA6JbZwzjg6ajsgPagyHiuH/MqfMWBL1eXkm8+BzA3wPBs4rc6SNQa7VajZf5BK4VwALjpnn9vQI64RCNQCPdxCpVGpnzBkjKEqcKGIFP5eMMywCNgdjzrPTZ4u9z+vg5X09BeN+dHSkUqmk9Xpt64AxJZ8mbfNbPAMiAb7n5hyxvzz6x+aRU/IFoV91vdMOgFCUoqVms2mocDKZWCLV84m5XE4/+9nPbII9Xx+JREwV8/LlS5OCsvFzuZyy2axyuZw5BbTXSB6RkOKFwzBUPp/XfD7X3t6eaeL9ZpRkhprFTxhMBW0ul7MFAIrmZ8JqX8VLKEqDuuVyUylaLBatUGQwGFj4LO1WulJFy71hxJCdUXw2n89NIhuJRAxJ3blzx4rGlsul9WpCI+3bDki78jTyESzYarWqi4uLnSZwhO28l+jCI3FJxnt72atHdXwf1BhadY+qQGOeOiP8Z+NJUrFYNATnqTtQvbSVWXa7Xdvc/oLmaLfbFrWw/qrVqg4ODgzAEH1A+THPvI/xuTkm/M63+mi1WjtFaV4N5mkm1tdgMPiCuofIEPDhZaPkEaA9E4mERXeTyWSHqvERnpdNEiX5SM7Thx7lU/NQLpc1Ho/VbDbNKTI+cPqobnzxH1Sd741FJM46g5b0KjGewzs8IlicUbfb1bNnz3acuxee4NiYW/YDr73ZFJA5o2rYS0bPz88NbDCftVpNp6enepvrnXYAJJTg7brdrjKZjLrdrvXVOD09tYKQaDRqnHi73dY3vvGNHSVMLLZppEUPDzLw0WjUGrWB7jKZjOr1uqmE6C66v7+vFy9e7CgfisWibSiSuPT0yWQythFevHix0wcHCmCxWOjZs2c6OjrSy5cvTVYG0kqn02o0Gkaz0BKCZ8No0kwuFosZbSXJ+FCahEkbQ1SpVNTtdtXr9YxH73Q6O3w+qooHDx4YuoJfb7fbGgwG1k4AFOO1yzcNE9dqtbIKacYDA8UzE8lAXfjiMK9wyWQyO/woqBsj76MFknBQDdwjhpx59vJFDNt6vVY6ndbe3p5ROE+fPjUjAgVCnYC0SzNJ2yJGErwk/rl3clQ+kp3NZjtqM9YFlIJXkRBJ4Fw9EkSpxvh7VH9TB49Bo9EdORaiGRzRarUydRDJa8ALiWl4f2lLNzGmPA8RG38j0vBo96aDgybhnokubj7zbDb7Av3GOLE+cXbk7IjUHzx4oPF4rF6v9wUHzH++eAtgxTgx/6xBQB8Uk3cAzL9H9x44DQYDE4Tg4BhXxlPaBXdfdb3TDgB0vb+/r7OzMx0fH1vbBIz0+fn5Tu+QSCSiR48emV54MBiY9yQkHgwGlmxtNBrq9/s7nSzh0R48eGAaaD6DltEgO/TsUDYoe8IwtM6KNAH78MMP9dlnnxmHH41G1ev1zGBeXl4aByxtWzrTfgJjifwSh8dmoG7AF0WBYqgLANVSLHV+fm4LE6QGgifkvL6+toKlXC6nRqOh6+trdTodRSIRUw5dX19bryJpi5L8xTys12u1221DYVBPhPle7khYi3rGV6xiqDHA0EVsAnhk1EE+GZfP580I+Q2KXpvvgJoiBxSLxVSpVEw37u+Neg2cJZEUiM8bMe+gwzBUr9fT+fn5TrI2m83aPGAQcD60NoDn90bZF+jxHRhCnw/BITJXsVhMBwcHKhaLOy1IEomEzs7OdlRkPgnNXOGs+d579+7tRK3sMU/ZSFtDjTGu1+vmWFkvXvCBDYDS29vbkySLrJhTnrVYLNoYeyrspoP2MsvVaqXT01PbT0QtPBtOGFk6MnHWH4BtvV6bc6BXFvPGPoeCyuVypqBbrVYmQMBRtNttW5fYqnQ6bfQnQO5tr3faAczncz19+lTValXr9doSuqAySYa+2aSgQUmmlHj58qXx5oRstVpN0kbX++bNGzPU3W7XCrcWi00biYODA3M8rz7vHyRti31IFmM4vNZ7Pp+bUshzsiBUEnpcPvT1SRd8AAAgAElEQVRjowdBYEaVCAKDx+vR7WN02ODo4ff39+1zURz5cNtru30vG8bgyZMnOjg4MOfWbretr9JqtdL5+bnRFLQHBtmzGaXdoh9J5sAIySXZHHrDgqHAMSBVZVPzHXx+PB43OmU4HBoyjEQilhj0VdQgLUlmvDHkjJtXXhBtMdf7+/taLBZGORCS41Ch+nwFLyifKIvxB6D4CNLz7jg58iRUFMdiMbXbbTNEy+XSkvfw7RhwxleSKXBwNN6IYHSkjTIJI42h3Nvb24km+IxWq2VtCyqVio0jhWWeHoRyIhdTKBRUKpV28hBEMzhzKudJSvPdhULB9oqvdCYqxwH6WhD2BKpD7AcFkL6I0TtxKGDGl7ockuCML3m40WhkiWYvXECoQM4qn88rl8uZ5PP4+HiHjgMwISSJRCJ2jzABb3u90w7A819UyDJRhHzQBVTHgorPz89NNtftds07knw8OjrSeDzWz372M0O8iUTCmp9JUq1WU6/X03Q6tZ4jw+HQEkJo6Qn5UQdg4IksZrOZcdS+yRhIjc6XflOiJMEIXl5e7lTo8ns4VG+o8vm8hYtHR0fWNZH7l7YdIll4GFlvnH1yTZIpY7xxS6fTlpuBqpI23TRBet64egeH0UHe6kN4kn8kbn1hGe+nx5JXnEhbmsTTDqwjeOdKpbLTXdK/n2fmnARvdGezmV69emXIC/7+9evXOwlnaCoSfBQu7e/vG89L4RYIcG9vz5Ltz549s/oAHBZOlCQtiB8qDZBBFSoSRiIE9tFisbDcF+sGoxiGoa6vr22s+U7GVdrUijD/PiHLvQFMGC/kmlBfODLWMbQpnxGNRs0JYth9oR4JWOaM/eHfD1AhVxOGoXXc9ZfPh5DwZ39zv9gNxpKx8REq1F29Xlc+n9fl5eUOYICu8vQi6577Q+F1fn5u52F4EYFvdslzUWjmo4Qvo1x/3vVOOwCSe48ePTIO+urqyhqQsYBZvCwS2gqEYWihIYoKJHV7e3s6PT01+dnJyYlSqZQVXM3nc52dnZmO+Pnz5ybHpF3EYDDQ1dWVhcP07sEJgGrpjw8i4mcmXdr2oSfUr1arKpfL6nQ6ur6+tkWKISVk9AtU2qpaWJRsMsJl0L0/kYtEM7QS4bZPDoKY9/b2zEGSZOPZMWyRSMScKd9XKBTs2XyzKowE0QudRVGygI739vasgyRKrul0avwzUQFGglwENSBEcCBlz1/zLJ4S8BuKv0WjUXOcUAuZTEadTsdQGTkJryrp9XqWaCSZztiSW2i32yZUaLfbBjR88RRqM39PVL0SSTC38PE4vUwmo1KppMPDQ+3v7+sv/uIvFI/HDY17sQB7j7XkKcVoNKp8Pq9EImH5IwqkcGbcG6CAaIYx8s35IpFtjyO+F+qLeU4mkxZhobojivVjyF64WefAd3MhQWae0d+D4nmvtE3q30zm4xB8rgk7k8/nja3wgIfokxoblIRc3D+UEnsA50gUs1hsWquzZ1Elelv4ttc77QBSqZQ+/PBDffzxx2q1WtY6eTbbtICYzWbWFoAEMdRAr9fTy5cvbSI9t//BBx/o8vLSCq7oVcMGpZcGVAcJVZBMo9FQp9Mx2ggFTSKRsJOqMCQc5sHpWig6kLZJW8RC2wgcAyol1FBsRk9PUNbPopdkRh20fnV1ZfeCbA26i+iA34/HYwv5Wcw+yV0oFPTRRx8pk8no+fPnevr0qUUG9Fm6mUCFApjNZrp//74ikU0vek75AsX5Bm2E6iTg6cJK+wwiLC647Ol0aucR4PhAgyBfSaaO4d/Stuuj76WOEwcUsNnH47FyuZwePnyoFy9e2Il0OIZ+v69qtapKpWLGaTab6eLiQvF43JRPSDoXi83BRi9fvrT11Gg0LMID8TGn9AaCVmJtYmgYG9bJwcGBnZGBHNlX9UL9QBVhcKDHfN0KCBw07qMIL7EFiPgzJnx9At8LnePRMpEPrd8BBeQk/IE0gAYkl+wBP4eAAyIaIkcAzk3pJPeH04PH94lYqDcM+XA41MuXL3fyWP79tIGndTo5DeoruG/GlXVN/m29Xls7E0ATbWCYP8DN217vtANYr9eq1WqaTCY6OjqyogxQNAkTqIxYLKZ6vW7tg6GAoGvq9c0RmZxyBF9L4ol+5Qz68+fP7eQhz1MjBSUpHI/HrUoZzpbFThUtaBt9PYsjCAIzyPSZh8sl0QqSx1BBfUWjUTu3gNyF31iE5yyMfD5vzoXXw9cmk8md/kUsyslkYotcklVDZzIZqzLGcIKQvfKH5BcO6s6dO9rf39fV1ZUikYhFN/DTVOl6WdtgMLCN1263zZF5TtY/N5QR6JaE/83WGJIsusFw+Q6g9F7a29uz9eSjO8564PlB5p6CCoJAxWLRjCbtO+hYi3OStENn7e3t6aOPPlK73Va/39+pJvb8sSRbc6jHyEVwr7FYTMfHxzZXVNYDPIhIGRtp9+wEnwy/6WhA+axRnwDmbxxk8tFHH+nly5fWxwtqyhs8STvtDlarlbVyIO9w8/WsR09jsh5B1b6QkIt1ShTJZ4KkeSbyhrRkR/FEkpzx8sDPN6GUtl1koaGQb/voge+GFiOS9jlQ2kkAqHyRHPUPHgx+1fXOO4BUKmUHlIzH451KOKoo4b2j0agho0ajYYgbB4LW/vLy0o6FOzw8VKlUMrqBzUMyh41E8ZYkS/KQNwChQKt4GaUkQ2+e5vGVrOQuSL4h+fRhOZtckvXvpy6BZ8SZkAdZr9c7B8r4NhJQUmxaKKJYLGaIl/CXCmnknufn5zo7O7ON7BVW3B+bzxdphWGop0+fKhKJ2Bm5ID0qtXFyOA7kv4ThcOkPHz60RX9xcWHSPtaNN/JEaSA+b9C4by+rjMfj1soXZ4mCxnPbRGI8m5ekUlDV7/e1v79vevgHDx5oOp3q5OTECveIcIiKMLqc7YABJ1LACFKIOJlMVK1WreKXvlQYH4y2pwoZo3Q6bQqZL+OOi8XijkHFUQIUfHQlycYFaSbGOpFI6OHDhyoUCjo5OTFj5vcJr10sFgbSMNAUdt2cJ2kbFbHOyC3xvGEY2hpm/n3BICACUAHFLG27mDL3RHOMw2w223HQJHJRKd2MBACeOBecupd/ekCDMMIrvDxdBgjzecF/NDmAaDSqvb09dbtd49oXi4Xu3bunV69eWVJzNptZ8QlNuObzubUyYJGdnJzYhIDekQYiOwNZ+2QaHLkkk2Fy+lculzOpG5uz2WwafcLns3hJNIF4iVI8iqJzIN/N/31izhtMkGOj0dDBwYGNFYsGw0eyEHTqD9EgrAV5wOt6ZU25XFYqlTLHiLNl4fnEHAiaQ7ol2XswFsh8GZfRaGSO7ejoSGEY6vLy0mgpvu/hw4f6tV/7NZVKJX366acWJbAWaHfAs/lNgfH20k9QIagO2g0n7+/Z52l8ctlTOTQmBEVzeBDKFoANihfyRC9evLDPn81mevz4sRl0hAYkRkG0PA8iCGlLf4CauU/+7R0BVA8HmGBwoVTg8KEI+U7vjKTdhCYR0my2qQjn4PRms2mn/AE6EBLweYwx+599SJ0Ja4z1Sa6C97B+vdSVZL2nG3kOnJSnh9iTNF8kQvWGm+iSRDGXz3l4oQYg0c8nF7kBokefryDRjtOjczFzTT7EFzN6IcdXXe+0A0in06pWq4rFNl39RqORbaZer6dOp2OUAXw4qHC53LQ4INRuNpuaTDbNxFDi0MVyOp0qn89rb29P3/nOd/Ts2TO9evXKWtrCSZP8xHiAuNgEnU7HjtbzVYXe6EgyTpV8BqoKz53yNzbrcrnU/v6+VTKDFokSaHN9fX1tx2SyOOEkaTHtDTaGjLMKbmqvU6nUTlJzOp3uFDp5QwqCAv3GYjE7GF7aVtz6im5po8cvlUq6vr42nTSonCSjtK1axeAz19Qf+ISpVy95PtdTBJHIRkmEEgtu2vPRhOPe0PkkWyQS2TmBzB9NCIXiNe+gNowl0SUOAVXK2dnZTvWoJFMDeWqnXC7b2mo0Gka5oDoBHfI8hULB6FQcJeo6cmCz2czmHhVPpVJRtVo1IwVv7pUnHnnyGiIknKhX83gJJhf7eH9/32pkvKRSkrUu960ipO3Zvax1uHMcErkxP/+AMcYT+hE6xbd5ABTwfKjUfAM3DPXNn4MgsFocOvkSJcznc/sZ5wXLgS3zzovxIDpeLBYqFot2wl6/3//H0Q6acMv30Oj3+6pUKnb0oLQtXoG358QpqBV4VJQ3HHIiyRY9Rhn5FjLGer1uRUoYMhYyRu/y8tKSW+j+Pa9YLpeN+wPtUo2K9x8Oh0ZBkcMIw9B6xkB95PN5STLOdzgcWmsCHJTnutkcbDKScZ5Dns/n6vV61vKB5nqLxcKcGRQbYTpdUQmLPWpj4XoqAvTpOU8iMKiOxWJhjfNw/BcXF5pOp+Y8ZrOZKaOQCy4WC9VqNTUaDaOlSPb6zc6mxHmnUilbN+l0Wufn55Y0pmDQSw4ZT6+QwRgRqnuaiPXl8wMYZH6PjPOm3BBEj0GCF4eGw+EwLoPBQI1Gw9oO30TUGKp0Oq179+6pVCqp2Wya88TwHhwc6OzszCgX3ziPxOVN5QygwtNIKJrYI/4ZMNoo1XyUDs3KMzJWHgFzefky9ThcUD9et898eG6eOZG27ZiZD5Lp0HGsa6IPDnviWZlnn6PBaCMAoP8TOTqAkpfP+n3m1xv362kfcnRHR0e6d++eVquVPv30059nUr9wvdMOYDwe6/Hjx0qn0zo7O9PZ2ZlNKKXUd+/eVaVS0Te+8Q2Vy2XrEYR06sGDB+Zdpa3agTCdz+JUph//+MeGjKTtggQ9sElZsPQNYjLYaBgHqkA5oF2S3rx5Y1pujypAG77YrFqt6oMPPjDOnsVH0ljaaoypEgSRE/p7nXyhUNjZhMvl0tpokAgn8kJVA7rEoTGWFN5QhUjVKqhX2nQULZVKSiQS6vV6FpF5+gJlCs6BKM+jcAwe8xuPx81Y++/FuBPF8BkoVBhz5HfUiODgqUGIRCI75yX4z/IoEgknVB9jxNj76l3oBCgCb7xZa9Hopv3JvXv3LBn5+vVrywF4dImhwnm8fPnSqBgvP+SzSfjyzDRDRJVEA7NUKqWTkxMr7GPcjo+PrQLfOwSeU9rKOKEq+AwPEvx6r9VqqtfrWq1WVkXN3vfjTdSA0oo9xvxDjzHvKKlwIBhu//38jD3gwKZWq2XRGPewXq9Nf+95fcQoxWLxCwonoimcAT3EyDnye5orQutwRgYO1o+Dn3Mibk4//N73vqfHjx/vJJW/6nqnHcBoNNKbN2/MKHBQi2/tUK1W9Vu/9VtGc4Bs+v2+PvnkE8ViMVWrVZN60kGUBTYYDFSv160PO9pyIonz83PbAGxsEDHemAUvbXvcYKDYAKgUMpmMgmB7qpW0PUjDJ6fYaEx6JpPR6empLZxarWabjmQji4XQmJ99kdDr168NdVG4defOHeNiPYKt1WqmZLq6urLqUorlMEQsXCKuwWBgydBarWZNu+joiE7c88jNZtNyGiQsGVfUTCBSkDFzjgPkPAcMLmohNgvnKnNS1Xw+twTyzaQiF/kWr0LB+EvbaAsUXKlUbMyhnKD44O8xkoTr/Ezkd3V1pWg0qv39fetOy7kYvsEchv7mIULIk6VtzoJ/8znkXKDzQPwo0FarldGlKFjIlR0eHiqZTOrVq1c7OS32AMCEe8UYe16cnFO1WtXdu3cN6fZ6PWvXgBKN3AmAjT0qbYzst771LTure7FYmPhjsVjs0Hm+XgiDT94IFgDqFsUhSJyWHzwXVC8G2Ce1GQ/m1a8TqCXWBs9BfsVXHbOn0fh72S42hpzCixcvtFgs9OTJk3887aDX67W1G0BeCDJbLBZ67733FIvFVCqV9Nlnn+n8/FyXl5emojg4OLCBZcNTHXtxcaGLiwvblJ1OR/V6Xdls1srnUVlw0TAORNvtdjUYDMy4YahAuCQtvXoAhQLozy+C4XCo6+trc04g1c8++8yQJigTBZKv1vXcPkVEGH+/+eiPtFqtrO5A2i5OyvcpWsFo+oWFsYGzBJ2RMyBJBjold0FExH363j0c2+iRP5sJtI3hn81mdmgOBh5UKG0P0+DfGEvyGcg9cZigeqp+2dx8JxvWXyA9NmOhUFCtVrPkO9QWuQmiC6KQVCpl84hjBeFdXFxYvyYu377Cjw33AVKG0+Z1PgKczWbWgptoAiUMdRZ8tleeAF7u3r1rqB3HAGeO8IHPRnkG9cmeZryZC+hYImgvn2buiWCYa8/rM4bMEc9905b4XAJ9oO7fv29rq9vt7hRmhWG4I5bw6juKPiVZDYi/ZxLfFACyhrx8FbBDHzHk115l5BP+dANlL+OUBoOBnjx5oqdPn9o6e9vrnXYAq9XKimXg4KiS5fCU6+tr/d3f/Z0ikc1RhGdnZ6rVakomk3r27JlKpZKOjo50eHioZrNp1bjwefP5XNfX1+p2u7p7967Oz8+ttwwoDnRMU7fLy0vbAEwC7Z/pKw+Hv16vVSgULMJgYjudjhkNSsD5TjTELGgSTtJugzcm39cyYFyIMKgcJCpAVQViffXqlVENPjGM4orwFKOEkfenNPlOlRgVnA4HsxANgdopvMF5IEdEHSJte6iw+EG6OGiPxFFsSLJ5IwpgI11fX5ux8+XzXhaKAYb+gaeVthuLnz3Cp1Hecrnpv8OzkddBpcS6Zl155+tpJSgXutbyey6qkBeLhRUoASj8XPKMHgBAlfjiMk95+GZpjA3G9vT0VLPZzJQpHLI0nU531C88G7UqdI9lbuhvBQDziU9yGESqoHlAB+snn89rNpvp9evXdiKfd3Y4RyIQaduKZDqd6sGDBwZIaCnt0bafcxypT8pChXnjzzji9L2Kzuc0oD/9s0E3e1mrb0/N57E3AE1E24BDf99fdb3TDoDQlMFEkXDnzh3dv39fz549s140hUJBy+Wm6vSDDz4wQ/SXf/mXllQhDIVGSaVSunPnjmazmfb3982YYuSlzUCSXSfJCNJaLpdmDL3hBFUSstGnHx4dNMOmQlERjUZ1dHRkShsqPalGDsNQBwcHqlQqGg6H5mz8QpK2/UEODg6UTCZ1fn5u0kYKnwqFgiaTiTqdjhlnSbbooE5ms81B8VQT+8SUJEsY+6QeC52NhaHx6Im6BT6r3W4b0vJRkbRt08Ac8pyMGcl0abeEX9KOkfXKE56V97BJKSzEafqkI2vw5nf5nju+YRoyRJRVXnuObJTPxOFjYEj+TiYTS/z7e+ZzoN1ojLdcLg25s4d4H2v2+vpa6/XaTraTtrUq0HmoeOhvhNMYj8d6/fq19T5CwuojAd+sETUbf8fI8/msGUk76ijm2wM1fo8xxXhD+eAofZI3mdwcWxqPx22tL5dLi7YrlYparZba7bY1fqNRJHsLxRrj4FVLzLU38qx5Kuu9KID7Z23wM3kErxLibHHskFfw8X35fN7O5hgOh1+orfiq6512AEwih37UajVVKhXr8SJtO1eGYaiHDx9qMpnou9/9rt577z398Ic/1MnJiTWK8iXj0mbR4wCYKJq7+T4bxWJRQRAon8+bXvf8/Nz41eVyaYeFEKl4Dhheksx/PB639ghogmlLTXLOnxkM/7lcbgrFMJweNbKQ/AI7OjqyzoKPHz/eqQxmQ4K8PE1G+4her6fj42PLgcCtw4XjZP09gFRvKqbgXdm4N7lZxsxXeeIIfCTAdzA+jBUJSZ7dq3d8ewJfLOWpJiKQRCJh9Rs8E9JKDIePuIhKmVdopfV6c5ARFA4UAoi6XC6r2+3aWuMQe5q08RmsESguojHuvdFo2DqDbvDoj3n1c7xYLFSpVHTnzh3duXNHn3zyiclti8XijniAYwdfv35tYwstSlXz/v6+CoWCIehkMmkiBo+OJZkSCaoD1Rm0EFGMv2+/TriWy6XtKQAAUSX7hrmjCygFmLyfpDOOjTWKY12tVur3+7buuSeoLvaqjwywW5HItouq35fk+wAyAEdyQew/ai8ODw+NfvUiDIAsggeUfP5s7Le5/n87gCAI7kr6F5L2Ja0k/dF6vf7nQRBUJP1Pkh5IeiXpP1iv151gM/L/XNK/J2ks6Z+s1+u/+vu+w8v1qI5FMkkl7+npqfb3981gU7Dx6tUrC/XhvBeLhVE3ePaLiwtLtpbLZeMgS6WSRqOR7t69a4lLPo+eHrFYTPfu3TM5JnJTaXu0HE3R4HvJQyAHZeLpdSNte9j7whAmHxQDguf7QHIgDRJV77//vklM2TS8BooKo+LljR7dYujJvXjnRk0Fz4vmG2oFJxmG4U6fIRwJqJ/7+bIL/h55JPdPpOJRLEaCjRaJRHbaU4Cu+Zl/S1uOHmPGRvMo2ifXPadLSO/zAtAtPJt32PDjjAUVv3yON3xEE35feGkg6NVz3xhVXyAkbXM38Mrk2Ji/fr9v9CHPfZPWAwT5szIymYwlaVmPUJfQUijObtYI+IgKQ46CzoMb9gbqIvawJOPuAUdQee12W4lEwvIKGF0/Jv5IVSgdoksSualUStfX1xYVBkFguRQiU6IP3x6EvA5rABtVKBTUarUsslmtVnbkKmMPxYXNYM/hgMMw1OnpqY0le/vg4MAaYn7V9YtEAEtJ/9V6vf6rIAjykv7fIAj+T0n/RNL/tV6v/1kQBL8v6fcl/deS/l1JH3z+329K+u8+///PvVarjWxxb2/P6JByuayrqyvTqZ+fn0uSvvWtbxkCevXqlTqdjp48eWJcO5z2crk0j0nihYTh3t6eRqORnZCFYUIdAwVVq9V0eXmpw8NDa7Vwfn6uZrNpi5WqWWn31KpisWgLGD2vD5Hpm0JvcV4jbTlnSTt93nmP5zojkYhOTk4UiUSsNTYyz0gk8oX2CtAeGDkS3j7pxHjgLOhECaL2ShkuUBVJZbpnEglg3OBO2XwYaubNUztwyMvl0vqmY0gwnjThg5f1yXxoB+6bEJ//zs7OLLHreyCxyZG+euPkN7vXoPMcXIwdERLGsdlsWrsIfu9pS5wX90i0QWsN7sUbZ3IJfD9OJRbbNO57/vy5cfMUBIKIGXMkwlBDIFP/nf4kOpwJ64J5q9VqlqcZj8caDod2pKuPJAFZrGHWN7+D9/Z5HNYlBpB6GZwElejeOXmQUy6Xba1Eo5seXhzMhEPwhpe1jBCE5m7YEU+1+hyPBzDse8QaQRBYdArowPkgocbR8qx0LvA5BOS8/8odwHq9Ppd0/vm/B0EQPJF0R9LvSvo3P3/ZH0v6v7VxAL8r6V+sN6vxz4MgKAVBcPD55/zcixOY2EzdbtfOuyRBCX8JDUCBy8XFhRk6aVv2LsmQKv27Wbx7e3tWsr5cLu34NUK9TCZjFZL9ft8QLSFkv983LXUul7OEsE+a9vt9vX792hK23N/+/r4++ugjQ+octyhtEAHtKjxaJ1zlcBq4x1gspn6/rz//8z9XGIbWSxytuS9sAf1hBEC21AT4aISFiqGDm/QXBpCNUK1W9fHHH+vevXt6/PixPv30UzMYOB6MGuOO7NaPz+drzdD9YrEwzh1pLQ4LY819ewRJkaA/D4DPoH2FP0uWy7cbWSy2PZ/8wSUoNbhPL9vDyIESGfvZbGb3yf+lbS7H8+IYCYABTgJBAevYU2neYKNQAa37A3mkjaHyld70zcJJ3sxbEJmxJpCFcjHuXrabTqf15s0bM3bsbQ8euF/yJUT4HGzEZ8Xjm6Z8RAAkUD3Fx35hbbJPfe4FaTjrAJUPYKLT6SgIAt2/f1+/8iu/YlFcq9VSGIYWwXW73R21EOuZugooSzoMExHgOEqlklGNUKk0QmSccXi+G4FXi33tOYAgCB5I+q6kH0naw6iv1+vzIAgan7/sjqQT97bTz3/3cx0ARokzfOEJuagLSKVSdp4tFYfweywoaJhcLrfTMZTPfP/993V4eKh0Oq1vfvObVgmay+Vs0YFc1+u1FUqxgTDCvnoTrh1Dl0qlFI/H1Ww2TaMehqG1oGZxcN8YbsJRUDgGAU7Yl52jmPKOis3LwgMd8z4uz5HS7po8AU4BB4KRh566qVK5qVm+vLzUfD43aoX381o4chy+R/0YBiIUUJG0pRoYF2/oPb3kuV/aZngDI20P3h4OhztyRv4P0mJMcSx8Bs6Z7/ORAZuXe5ZkKN1/Ps6U9+NIIpGI9vb2DLnejD64f+8QGBufdCQKBED4xCufi2EhAoS+AnWzFj/f47Y2yJ95+op7JO/V7/d3pL7kFHiNjx5ZG7yOKxaLWQM736QN2o15Zo/xGeTNmBNAhkf3/v55HdLdWq1mLSpgGuLxuMrlsqnGPHCIx+MmLPGyaZocQk1j/EHz0ra4c7FY2P5fLpc7LR7CMNxp/wCo8oDkq65f2AEEQZCT9L9I+i/X63WfjfZlL/2S362/8KIg+D1JvyfJ2iTjaYfDoX71V3/VkFA0GrVWvRwOT8tVQnSShaVSyQxOMplUo9GwymEcQ7fbValUUqlU0sHBgY6Pj1Wr1fS9733PPP2bN292ytWlzUTUajXTacPleSNIOEgBDn3AQdLlctkakZ2enu6chiRtw1a4Y3+4N6jPy8AwHhSeJZObQ+Ep/aeEnIScL6CSNiiCXij379/faVWcTqftoPCbiTrGAwROCL5cbipVW62WPRdOym9eNqZ/NozdTXUQtKA/xQ2DguGWtr2X+FzQIgZ5sVjY/AAciCLgV/3m9JuMMcxkMqrVanrx4sVOVTN1H3wWdAKGlefEmDF3tKImwlitVlYF62sYeD05FgyoP+sA40PEwdrh71BGjCmfyT5DxEB1ea1WsxwTholKcNYba8gnLMk3ILPmnrwTA6gxZnw3uYlWq2WN6yRZchQ5qqdYJH1pUpw1lc/nrdiNaJgIgHnmHAKKElE8PX/+XIPBQB9//PFOZS/fCWAlAgBEMYaeVoXegc0gyvaKOJwIQMs7BMZjsfOawZ8AACAASURBVFjYCYhve/1CDiAIgrg2xv9/XK/X/+vnv76E2gmC4EDS1ee/P5V01739SNKbm5+5Xq//SNIfSVK9Xl/v7+9rOp2q2WzaQdWEPdK2fwd8MKcUDQYDRSIRHR0dmbxS2rRhmM1m1l6ZqtDT01NVq1U9f/5c5XJZmUxG+XzeBhmaab1eq9fr2YEghKeSdvq+k3fwnC668AcPHuiv/uqv7KB3ogAOgDk9PTWjSNIbOR3o2SNGUApnFGAkqXeQNkaZCMaX8LPJeQZCajYIxXG+x0ytVjNj49U2N+ZxJzfgNzyGnvvyp2Wl02kLjwn7uS8axGE02PQc1sL4Qu+B1DHYvvaA/klw6/CzOCi+D8TmnQLoGS32o0ePVCqVjK67uLgwGs9L/XC8oNZYLGaVtURGHvHeTFpj+EHMXCS6R6ORHaKC8+TvkizipPqZ/IB33jgtSVZt77X10Wh0JyeFoWK/rNdrjcdjAyUkZafTqV6+fGkUKPcHUIBSwSiixvJKGtaQr4aezWbWdiIWi5lIgqjRMwZ8DmsglUqpXq9bvqfT6exExTiEMAytTcR0OrWqX2lDkV1cXGi1Wu20nGHdk5vzIgC/phl/7BUHv7AGksmkSbi/LMfG/QGIAQlve/0iKqBA0n8v6cl6vf5v3Z/+d0n/qaR/9vn//zf3+38aBMG/1Cb52/sq/l/aJHdR/AwGA+P0Y7GYSfWgIaicxIOi9T06OjLj7o0RxwReX18bEpakjz76yDh+WlHTMZJD2VHVEPZipD1/jwHJZDLmoIg46OwYiUSsPzznD38+vqrVaqrVasbL0uURjtDro+FW4X/Pzs5so/m+R0RGIEN05ByWc3p6umNgKHJqtVrK5XJqt9saDAbWrwdKgrGEx/StKTzPijGEgtvb21M8vm1s5ykMqAY/3uRlarWaYrGYOTm+j2ppT30QAeFAs9msarWanX0LupO2x/LhOMg34CCkrRPDmHCy2cXFhbUIwPjjtED5qGWi0agePny4E4lCu4H2oZn8vWN8iZyIXKByQItQRzc5dZLnOBfmBlSMwWeNsu5xqjwbnynJRAOSdH5+bmsUapRIFFTM/mS8+Qyekf/7lt6e+uIemV+Oi+QcYX7vi7lurkUig8vLy506HNRDADBoIyIqOhKDznE4PnpmbMNwc6Igzou55fI0FOPPPgXg5HI5y+cgSGAP8RyFQsFqRXxS/G2uXyQC+IGk/0TS3wZB8Nef/+6/0cbw/89BEPznko4l/fuf/+2H2khAf6aNDPQ/+6ovgKOMx+NWMk7FrbRtpQul4jczCxXOmqpDQm34cQwOC2w22xz6TQIZySlKEl6HgeC9HnH4BBJqGSiVxWKhcrmsH/zgB3r8+LG9xoessVjMTju7c+eOXr9+bd/DwvKHcYN8WbD0ePEbhfHEEFN2vlhsOmmiy6Z9BfdNSbufE5ygT0xx2Djor1gsmlzUOzw4TZ+08rI4Sca/+/CduQEZ31wjGHwMLRvEgwGMgO9AyncSleBomBefK/IGhaii1WqZE2D8ML7Shsaklw3PSO5kMBjo6OjI5hTOnXlCceOTmT7hh1NiXXJMIcbU5wj4TCgfQIC0cfJ8F+2seS15sePjY3OOfoyJgkej0U6PfJ/jQgVGHiIajZr2nrFff9680ecdvK6e/3Pv/pmYQ1RwvhX7zWjX5wikrayUyATaxq8xQABOGuBUKpU0mUzs0BwYBXI20iYS5oAYAANGm2JOf3/+eXEc5LJ8TiwajZrQYzabGdPxtm2guX4RFdD/oy/n9SXp3/qS168l/Rf/kO9YLpf60Y9+ZJv2zZs3RgFhCPwhziBBQjkGF+kmCT4aTdE8DFoBmuP09NQmGqchbVHX+fm5JR1pS93tdg1RepoCpMPmwkh0u10rpIEuwqCjVV4ul3r69KnRNiCzwWCgMAwtaYkRYMPjACTtGEWQLPSLtNWLe+ONs0EBhcOjnQVdR3EylUpFsVhsp2mZtEV1GETUDOv12gppoDWIljCAFLjwTCTVUHlcX1/bWbOS7HhGxp4N4it5MXoUK4VhqHq9bs4eZwp9hSPH8DGfVHiyYYk4PP3H8yMRRCWCwgRj9eMf/1jFYnHnnlCxsAcwHtAZGHfWCUYLXToGyjvBxWJhESrIEYdRqVQMoLCOGONms7kTNXN5Ga1H1tJut1SeYTAY6N69ezuN+zyV4RVxOB8f8fq1zPrk+3Be0lYYUSwW1Ww2rYLeUzt8nqe7ZrNNjZEvlmTt+ugBp9loNCx6hiqKRCIqFovKZDIGCPgczh7h3Anv5BgvKDnyYYAynp25RG4MxQYo4+hI77y+6nqnK4Hh3+GbCa0wFEgviQLgAKFFMKzkEKgEfvnypSTt1AKQaJvP56pWqztcIq/5wQ9+oOVyqdPTU/30pz+16shGo2HaZigGNLk4FZwIRsyjG1AuUQ4/U1kJvwf14zl3kDGJJhYTRoWxAhmRUGPhY/il7eEuGAx4ZRARJffS9qwGOE0S8PDcGFqcRiwW22n3y8KH+7xZIeoTy/F43OoXcHidTkeZTEYPHz7U3t6eRT6gLWkTSdy/f994716vZ5suCDYHdNBDhw3ppaG+wpj5KZfLGo/HVgtAYh4DjfGSNvmN6+tri6SosIa3JnHrHSAVqDgADCKJY8byprSVSAFn7gvmQI8e3RJFkndBYcSaZz1IW2PvK6zZh3D90radhEeq8NigU4/KfWKe19+M7iiAYhxYm/z95vtJwPqWDdCJPuHtqS+qoP1ZxF4ZxVh4VREqOiq+2deFQkHvv/++EomE9c4aj8fa29szUOLzAah4vOP30QKAAmNP9Oxtxmg00uXlpdGftJN4m+uddgB47eVyuSP7arfblvjxxRGZTMY2KPJLJgyddLfb1XvvvWcHxJBXYHFJMgQbhuGOR12tNkVAv/7rv67RaKQnT57sUA9IDDHGKINI/PmNI8loKzYWiIp7Rinj+VKMI0iXRSLJikoIf4kuoJi8LNJvUr/p+Kx0Or3jGH2ZfywWM3qHUn/ujcpkH3WQ2AWtQ4VRsl+tVi2XQnUzKAzjB3qllxDj7s8ylrYHq4P2qYKu1WpWFT4ejzUej+3ULZ+cw7jicBlXkvg4qmRy02wQQ+KpNgw8TiUMQ0PXXknlI57lcmkbmzHz9RVeGuvXo5836CjGDbTMBX3EPUCxdbtdEzrAPQMEiF5Qx+DAQMQ4T79nvcGitQFGCeeIU6AoztOJfo1DIeEcZ7Ntw0SoIy+59XJO9nM2m7WCNq+8Ajl7Ogk7QBEdjReJYolUfCEl+5aonI7ERKSRSMTa2jM3rGsoL5RmvJ5INxKJ2FgS3bDOWCNQa7zuZl3O33e90w4gnU5bnxGQFidg5XI53b171wzk5eWlefmPPvpIzWZTx8fHKhaLdlgD58qykYvFosrlsvGb+Xze+FwMFsao3W7rs88+M86WBCUGkQWOESGhA90BpYTRRlLGoieRRy8S+pfwWV6CCB8JxcVGRw3FZoVKgcZisXLv5BR8lMBmoNAGZZO0OVwcpRFGazabWa8lFjHGyt/TeDxWJpNRtVq1DUQIDic8mUy0t7cnaWOcGA/UDRgraXuwD03kCLm9AgKjyLkGdAP1iB/jxcE1hO/S7jkLOLvVamXcL1Wt/N1HdXDVmUzGpKm+oEuSfR6OGokwr/HUD/PMGiCCImnp5YvewEiyU+2oWGduQMM4aBx5KpUyeojzn0HtoGeUVJLsQCDAEs7QUxwon6rVqhl39oMHeuxzfs9zlMtlQ8/eKCKk4PLj7Mc7Gt2caYwKEOfiKRjuwVNa/JviQSIMkD1rnHm/vr62qNbvWdYltoPf+7yBj7hIDiOL9cbf53igYn2fM+zk21zvtANYrVY6OTkxo03YiAqkWq2qXq/r5cuXpviZTqcWBTQajR1j1ul0rFlSIpHQ4eGhotFNzw3OpcWbQ9swyfCDP/3pT02miHHDmGH8qUilzzeGwRtgkFilUlGtVlO73bYmd4eHh4Y8oKJAlT5JyYaLRCI7h9T4Hvk8B5whY+NDWz4bSRwbGgUD5yvA22M8ubzUMZFImMPGqGFw4dDj8bjx6HRBvLq60nQ61d7enimSkFPSHdEbCxyvJDPGy+XyC6obNqsvZsOgQn2VSiXdu3dP3/rWtzSbbVpBc74z6y5wLa0ZF6rDpd0iOpB6Op3eifJ8wtlHSpHI9uhBfua6mcTlvGQSgMnkpo9Qp9MxAwBKRZefTqctP4MRYYwkWfUqdQpEz9B+GGQfUZJTQ6QBDZnNZs0pEdn6iMzn6nwuj3H0smqAjTdoyGAlmeqJ3zNeHsmzDyXtHKXIemQPeeBCpHEzuubkOT7P5yP4mXwAkQnOwzsYT895x85n8DuAFrk5wCJ5NyL6o6MjU7v1er2vtxDsX+U1n89NvVOpVMxI5fN5PXr0yLh6qn8pnfYyRlBtLpezJC0LGtSPEae7ZKPRUKlUsgMWbm52dOvS7iHQLFw2FOgRBJhKpezEKBYY1AwG21fwwol7GRoaZo9eeU4qk9kg6JbhTUELnhsmqfnw4cOdo/mePn26Q6f41hixWMySpqis2EBQRrFYbMcYgRaRk3rnBZ1E+Ty8JgkzxpqEpZ/f0Wi00y6Z10ajm6MVMdgYSySlkoxGrFarOjw8VKvVMqqLPEmhULBaEQzaTYUNz5/NZtVqtQyZ44wuLy8tyvIX48oaoxjIFwSB6LhfIkd/TgFjg5PD2RNhcAYGgKJer5tIwuvGvVSTSMujWCgLcnOSdnh8nLAXMviocjbbHP/Js4OMfcTii9lYXxhyf1odewTn7JPO3lFKm1wa8ly/X3genyjmOaFgfLSIlJt79slnnol5x7EByFibPorzii+fECdvwnpdLBa2hikYXSy2J5+1223V63WLFqideJvrnXYAXtOKomI4HFor3Uhk0/Ds7OxMkszIkmxMp9M6OjqyHhwgJBYnkQXhoD99TJLu3LljCBIpqOemU6mUTS6IFOUIxowLgw8iA9mTPA7D0M4Nxpj7k5L4DKgUUASbq9frWb7hZsUsKIaQWdqGxbVazZAFyN0jVY+EvKKGBQolxfdwlgLVsURbUA7tdlvdbnen2CWRSKjRaNi5xxScYehx0kQAnpOlAMhHA4lEwvoh+c6Rkuy1/v6DINBPf/pTUyWhyJC2Bi4MN/1eQHVeiUMhHuE9RoTzd324jhHwHD+V6RzNKcnajZPoxHAQnWJkcdCxWMwSyl5NMpttO2ZKMvoUZMkz4gRot85YecPqFWP+d4ADkpthGNq4Yjhx+CRSeQ+FfMwPkYRfZ8yFd+7kdfxBO4wxr280GlYlCzDyOTDyHQAdDLJPZvMfNCbrFeNMdC3tUk6envMJfV7nnRj70+9nv07JRS4WC3NWy+XSWsWzvqgZgPZ9m+uddgDx+ObcUBYZ3Cs9/vf29oxmkbZ9XphUwsdIJGLSSXqvQEGQmNrf37cOnWwwiqBAH4TQaO5JCPJ3X+5drVZtMgiNQSw31Q/wrkxqq9X6QmjJeBBxgLYI6SeTiRkAdP7QFnwO94syqlwuKxqN6t69eyoWi+ZUKcCRtsiUBBhtM7hor40TI2FKu+pisWgbFtUVaikMU6PRMKro9PTUqCLQFq0eoGDYFFzT6dQ2ExEXY8Cmx9izqXzC0Pdr8eoWnpto5iYSl7ZnBsPfh2Fo4gRvDHG4kiwxKm0daSKRMJQehqF1msQJ43Q4YhIng1EFDUKD+bwO0R/RBQV9jBeURi6X0507d8wRemqCi/vg3qFsiHZZp7lcTtls1nIz7DmiXnh4no/1CpWGrLVUKmmxWOwIM3C8s9nMCgIBKuwrqF2MIzQVa4N1UigUzEFIG+PMeOCwcV6s3XK5vFMdzuf7YjHyF+SCEGgQjRP9MXc4YJ5jMBjYvmW8KeLD6ONMoRB5Jh+VfNX1TjsASrU5oQfP2ev1NBqNdHx8LGlj+FksIEIayKEcmc/nZlwwRKvVygwaSR3aSEynUzvOkA2LAaFQiqQWXDNoYL3enN9LH5HFYnMOQS6X07Nnz6wimQ3kpY/Ivur1uj788EMlk0n95Cc/0cXFhSWu8e5EExh5ONpYLGYN7xgzFgf8PosW5Hh2dmaoEr0+ixEenJCcv7FBfHsDkqREMu12W4VCQffu3dP777+vx48f6/Ly0trt+sQuCfd4PK5qtWrOU9q2suA9PpHIJi4Wi7ZZE4mErq6ubHOxgT13DscNX04nRowyLTBms5nOz893esaApDmOEcNE8RjUnVd+QNNgBECg+/v7uri42DmDgGfDqDJ/RCDS1jBUq1VVKhUDAJHIph059ADSS8aM1gUYKF+YRqIVR0LLDKIbnzT1CBVgBBV67949o8A40a5SqViCnUJD6AyS7GEY2r45OjracXRQMowrFJencpjjWCymZ8+efcGAY1cQXZB78ZJRX3fgnQCqHlpeMC8gb/a+pB0Bx005rG+3DUXmGzwSOXk1HDQXe5kqcKJjhB4wH297vdMOgMVQqVQM0Zyfn1vVIEkPkiVUXHIwN1RJNBrV69evdyp0oQdA7fDNHCKPhJAJ4GekhNIWvfmQGgUAE8LhMl4u1m63rXUCiWYWN58ryZB0vV5Xp9OxXujT6dS4ckJGDBkbolKpaLnctHRuNpvW/I0+RuVy2RZdp9PZSbZ7vpqNR0TEOQfJZFK9Xs8iD1AJfXlY5ByHyb2z2XyoD3WH4SuVSnYeweXlpVFDGFJQN/fHmJVKJesFRaM6kCw0H5sSh4nx5zAg3yaZ+V+tVtYmGqEB37tYLCzq8evGH67OBXUAasMpwCX7hDNREJQL4wJq9DQnaJl8GHkKT3tJW/URzgWnwFhCfdw0gOwjnAZrBKrR1x1QaMhB6dAkrCNe42sfyuWyksmk5V84RGk0GunOnTuSZJ1yff6KzySa98VzRPGsL3IC7EvGyCdrWSOgdYzzTRrMc/9e08+9eeqOsWL9E7lSw8Rn+qjWC0eYA9aKj3KoCfBO3Ocq3+Z6px2AR697e3t6+vSpLXom6+rqaqczYyQS0cXFhdbrtX7nd35HZ2dnCsNQf/Inf2IVrIR+0qaB2/Hxsa6urqwLIZPtKSWfRCVBNB6Plc/nrZsfTsU3M5vP53r9+rVV6RWLRSs8IfzDaYCioJU485jEHMbJKy6gX9gQyMFYQMlkUg8ePLCqTjYjp4qRJGVc0SX7UNzLKzlMHCNMCwCMK+iDewXhPX/+XP1+XxcXF5bYxbmizPL0TLPZtBYfPteCo/fcab/fN+UO0RQblA6t3mAQeYHu4K/9+co+QQ1SJefAZxHye/WP1/n7JB6Rp1dwSTJeuVQqqVqt2uHqsVjMDDrrlRyNFzrQjI7PInolZ1GpVCwPgaH2eQPumfv2LZV5JhKm3ojjRFHZ+PGFDuUzGVNPxRHR+SMoDw8PtVwuDaQMBgOdn5/bnmJOM5mMJpOJUbK+0Mtz6KiaPBUHLcwzegEDayEIAkP7fJ4ki1I85cn3kntjz7E+cd7UMAGusGGJRELZbNYcD44ZUIGzxB7yfwDHbLZ73vJNhd5XXe+0A5C0Y1BoiEaiDUOLQT45ObHK03R6c1j8N7/5Tf3xH/+xofbf+I3f0MuXL60xm+dlG42GIdjlcqnDw0NryvbmzRs7HzQej+vw8NCko3/7t39rtMt0OrXDLuBG2dCE0n5RQavM53OT9/G3TqdjiBaD6WkQjIevRIXmefbsmZLJpHWbBEk9f/7cNjDy1UgkokqlYvK39Xptxga05PXPPBtcbhhumpzx/BhSCvPoV358fLwTfaFUofirVCpZVISa5sGDB0btQF3EYjFDOjg1QnAMLZt9vV4bkvYbGYMFPQA4oN0vyXKeB8Tm5w46hNCbxCYJdVAuNBB1DyA6jDLGFEqR8WK9QcXg2KEyiVZxqJeXl/Y5FHOlUikTQpDfOj8/38kjcA84bNYH943z98aLynLmn9ezpvk3dQPIF3lWnH+r1dJ0OtX+/r6+//3v682bNwaIWEeoswBJvpgN2+CpKJREGHGidlC6p3RYAxhqUDwgjOfmwuCC7nEyUDLr9doiGBwizsrr/1kLXknG/fqKY5yHr/MggsTgA8CI7P7RFIKx+OjPMx6PrZAI9HF4eGiTx+KFF//ss8/0h3/4hzuqE2mTdIQnRCIGp0iovVgs7Fxg0CxJwSAIdHBwoG9/+9vq9/s6Ozszp0GEQOKQIq9Go6F4PK6TkxNDtvr/uHuXGMny7Lzvu5ERGREZGZHxyozMquyq6qmp6SE4hDn0wF4YNARrZVkwAUKyBBOGJAvgxhYEGIYleeWFDcgri4ABGYQFQyIM0LY20sLwxgRBLmgBHtEzaHZXT/d0VWZGPiIz8v2IjIyXF1G/c78b3ZyucVPjwlygUFWZ8bj3/zjnO9/5zvkrlY7Bx4JESJaxuZhs51kxzrVaLcaEsYAyKhaLoRmm8tURHkiXLpWO/jGqvMZPXZKUMbAuQWSBkgvhSEp4deS2s9lM3W43nDNN+pzKWltbU7VaDeOL82+32yFFxLjjQL3LohsvEKKUyhsX/8+8kODDYRNR8TfPzHi5hBMkB4ePkcUp4Tx9Dvr9fvSmZ81xX+jm7+7uwtgw3qPRSLu7u4FKuQ4PD2NPwKfXarVAqZyiBQ26KEt0A0O+B7Dg+5Pn430cuETB5snJSUQ43W43HDjOczweR9RGSwW+l0K0xYQnCjCiMFfPwMlTEOZon+92SgfA4PSYS32RGJPnwZDX6/UoFGVPeR7BE8TUtbC/YCxGo1GGDWAtl8tlvffee+Fo+E4XZDD/PB/Oge9+2+uddgAYkGKxGBV29IKp1+uS0upBEmSEvV7dWCgUAiWfnJyEg8AILapKQD4khpFXEj7e3d3p8PBQKysrOjo6ipYS5ANQ0pTLZZ2dnYWSicVXLpeD92RRgK5Y+CxyjAoTjUHjb3Tk3keEv2u1WnR63NnZiWPtJIWSB+dGj3hQK60Z2BiLm9ATmyhBkKmSpGYjcb8cMYmjktLDWjzZCw3GfDkfLymKXTAcbECMKkdxYiwlhREGpXF/zt0iY3W1GMYCp+dJWjphkkgESYPY+HwoBkmRc+D7WG+ec+L5+TxUYi45BSAw93w2uTHWNFLiXG7es4rKbiiMTqejZrOpUqmko6OjiMagN7hAojxPLjdvY07RI2tgZWVF+XxeGxsbOj09jQiew48WHQg5nYuLC+3u7mowGERuyfNZjL0/L5/tPDxAAAO5srISyXU+g/t3EQO/I8JlHWJXoLqIyNbX1zNRAk5yOp1mzjtYXV3V1tZWOCSPKnB22AVaTwDaUCkS6XsOplqtZlpbeOKe/NzbXO+0A5hOpzo4OFCr1YoJvr6+Dk4WusYPgGDSy+Wy+v2+fuM3fkO/8zu/E83Z2Fy0EAC10C4CvX+z2YxkHlSJc3InJyfqdDpqNBr68MMPI/QktIPHHAwGUbzEZ5AQ8kXrlyOtxcQSCVmSjHym1wqANkejkV6/fq3BYBCHSvhm8ijCpWYcXI+6gM8CQUINcW/T6TS6O7Ig2YAkUKGXyDdgxEA0/pwklYvFoj777LOQ2DnPC9pl87Cp19bWgkZB0UWCjPHxzccfjLKrMxgbQn1vgMd9SorP98Qd6Bs6yusGUKfx/HSKhJbDiUAXEVnSEiCfz0eUwHqDcnA+nHsEHBwfH2cOKOF7lpaWMlp4ByP5fD4TgblaDWMnKQzXZDJvgEdSl7Fz1djixalur1+/jrHEQJfL8yNaMYQU6bFuptNpJnnNOqJ1Q7vdDqcGleYABcTM87CeHVDgILEXLrNlXPjuRqOh4+PjTE4EFRRziwFnnXHIPOscdZPL252iWqSNkDtD6dXr9Z8PB0DWe3d3V5VKJeSXy8vLOjw8jIw+jeJAxWzmzc1Nff/739ev//qv6w/+4A9CnkhnRtA2RsQR5PPnz3V9fa0f/OAHgeZAVsViMfqqQD8wAc7XYYwvLi4yrQL4Oejfe4bzTM7pexgLyqZKFZSGfMwVGmx8jDeJJww+n+OoiMiJnilQKfV6PQyVpDiw3ruX1mq1TAES0RVKBag4tOlS2g8H9OThqycR+T/OkQIip1hQ5PzCL/yCxuP5Qdw//OEPM4U2kmIN8dmefMZQtFqtOF6P30P3cL/emdLnq16vhz794uJCOzs7sZ69V72vJeghErwecTBOvIe8lHcqZVyl1ClyP5KiCA+D7VEuRpdOsfDioHrGyWWpnkfBGA4Gg6BF/OeOjnmvU3M4IfJkrF9ota2traCIPv3005gnaEpJUSFNXqlQKISAgCQrdUQ8O6ANY8q1mANxG0FUhZNyxR5RHEYeEQg5PPaRrz++59GjR1pfX1e/39erV6/C4HsRo0c6LgiR0rwATu5tr3faAeDtGHgpPZDk8vIykP/19XW0W8UYQMXUajV9+OGHof2n9zmGjjDt6OgonMj777+v7e1tHR4eant7Wzs7O1E8IqWHmGP82KwUabD4PZMPFQV6csSMQeFzWUCEm1LaUGplZSX64iwvL+vp06fK5/MRCV1cXAQiYmOBWDBefC/owdGP5wEY93q9ru3tbTWbTXW73QiTXUHiPXokhRMEVfoGwtkUCvPjJx3RkFD2+3clhEdtbFDWCtEV8w4dwOcADLhHEtFo0n3zshbckboBo4ka98D8tFotSYreO+QpXCePXJkIYzQaqVqtRvGPRyieq8AYzWazQNdON7lTIzJwioy1RzEg4IK2xbTXRpnF2DCHfm9OMziqd6Ud4+z6fa+aZdwwyr53WCuj0UgfffSRKpVKNFf0/Ak5lyRJ1Ol0MlHZwcFB9Od3gMdYOLfOHpMU7RyYI1qyY3wBUNQI4QgYp6Wl+Vnl5XI5ijqJMqiPub+/j3kqFArRqPDVq1eh+sNBSSnVC1BxtRpnTYzH46hJeNvrnXYASZKo1Wpl+pIMBgM1Go0wlJKi3z+IldAaHu38/FyPpdw5zAAAIABJREFUHj0KoyrNESxaeCSV9MSh6x8Rw8bGRtAJ/r0gXjYxE0Bo6OcV8B42oG9u2iFzpCWqFiRsIEJO/aEgh2IkkAN8uZR2y3T+EirHpW+ePPZkmqSIGHgfB57zea4kkdLiFzYVz3d5eam1tbXgkSUFYoSzZHMToWGcSDQTPi/SL1wY+bOzM3W7XRWLxWhdzPPSngKEBJXgyi9pbiDcaDjSdceHQeXijOKlpSV1u91ItMLXjsdpUSLRgZ85gXzTeXLnflGgUBHqksHF2ggiQU+EYqic1/bzCJz+g0JDpSUpohecEfSJJ1/Jo9DUb39/P1PoiJGVlImi3Ki7I0MWyjrDkAKsmBPeQ/dgOvySyAW08DOchidTcXCMEWvAFVkuwMD45/P56F81HA7VarUi8q1UKgECUD15RTSRsTRX/XGIDRGnJ6hxnuwN9hpOmlP4voxm+9Oud9oBkMhk4pgECocoiLm/vw/DxKKYTuf9cXAMJOzYZJPJJBBXtVrVt771La2vr4ehGA6HwZvTHIukIj1u6NkjKaRlGBUKaKQUcUqKHAX6bJAkXPmLFy+iKpRFST1Es9mM56NtAwvG5aaSAtVjMHhmSYFI2PgoZ9hwjD3qnMFgfjqUd06Usp1EpbQ/OQaIDqqSoscOKD+Xy0X3UZLARB/S3Dg0m81wXNASdGyFZsBBeATz4YcfxgbyTY0xYz3A61I0xnyzOXGOOLTV1dW4Tx8nqqMZF17DnLIxZ7P5CXKLFc2MI06CSNANFmPgKg/v+QP9OJlMMi2SMRYAIqfT+DeGGakvUQWUENEiz10sFkOCzZpeXV1Vp9MJ9Nrr9TIVz8wp648Ii7YkThGxPolqWENE2I7aXXnFOdU4evYJY+tOhIQ0CJznx6DyXPwMqnQymWSOjGQfuTSVg4d6vV5QTCjx7u7uQtLKuOfz+UwfLPacR//MGayC9/tB9gr9+HPlAEaj+Rm6HNxC+1k8N8kx/pAgJaPO4mfSvTeMJ0zH43Ek2brdbvwMQ4wRcT4Z3h4DADLkvSR3zs7OMnI1dMHQOPzu/v5eu7u70XqChV0qlaL97qNHj8KRSYreQd6Wlw0GGqVFryf+QP201O71evEsi82t2KyLPUYwFEQ/3r+nUqmo0+no448/zmx8P+OZM3m9fB8njqMG9fIdcNg4TRwO/2fzYlzZrBhZWhhj2AjzPUIjIepRiKNN5h8DwTN7pMB9ePKYy5UgfAZID6PEffN5kkKSyHdx/1JakyClhXG815OjxWIxEvF8H9r6JEl0cnIStRVQhiQqcQjeMI+1z/jjrEg6e9XqIjVKFIMhpDiT+eDeRqN5N0yPICVFISR7gXWEk4f+4/IkLusfZ+vAhCjDE/t+eVsGxhUqk7nwjpzVajUiimq1qsPDw0xEyXOSj8H2+dkQft84B4ocUdJRR+PnbX/V9U47gMlkEtWwGGOKdRhs+uBz0ATtUF2aiJrFE7VssKurq6B2ODYSOsA5eAwgiAF0zwJEsyvNE3bb29uZVg0sJE6ogqrB+LMhWIAsyKWlpZCMSoqKWA45Qc7Hn+l0GqGtlLaJLpfLYdChX6rVqprNphqNRqafj9839ARUhFNHHKeIg5SUkY52u91ARW6QWdBsfsJ/irDgfheVGa4fX1tbU7FYjK6qrjrCeWL83JA6LZbL5TLV1JICTXuCDefvlI8jOM8VUFS0mMjlu/2ZnOrxf1cqlej5BG/O2oLzZU3zmfzxCnPGmdwHc896o30wipm7u7ugNHlOUHOtVoso2hVYvq7Za8wRzpV1yJwQtXljNHd+fDZ5GZyK06/uPFwl48lYXsdzczYDkRZj7vkVfub1GowlAAVU71E172WsPc/m98A9sxdpq4LTcfC1SAWSVCZyx5nyOw6lwiG+zfVOOwAMLsgflNBsNlWv1/Xy5Uvd39/r8ePHQRV5Bvzy8lKHh4dxyAU9eUjC0DqA6/T0NHPOa7VaDRQA70iYBVoBLTlVAZ/KEZTFYjHK3MkbEFlgnDwnIKWdFtGj393d6bPPPovP3draigO7nY/FUDlXSUJRSg0x1ASbEMTOfVG8AtqA/sIpNhqN+DwiCkJSNsfiM/E8noSDioCKkhSS3V6vFwgQg0tzQJw0SJvIjrFzRM7nuh5fkp49e6anT59qOBxqZ2dHr1+/jj4/jKOPm/OxuVwuNj1ORlKACcZ9ES1OJmk/Iik1UG5MXcM+Go2CiiMqAQCxRvzMBPYN9+gtKUgc44hJSCMN9jOfASTMJ0adPlzsC3hoT5Jj3L34EmfDGLgxZDzgxH3vU4yJQcQIQxPhTFwPj/HH0LIniQxwRESVjuQlxT7CoTgYwtlgqHlOHBbP5w5tOBxGy3pkvFwOeFzR40l76Cf2GGsOAQvST3JKPzeVwBg7SSFlBIn7BNAj/8WLF5G4vbq60kcffRRc/mw2C2Q1nU6j6MUpHBYdCBfayIuymFioJ2gWT5gOh3O9Oz2CisWitra24r6q1ao+//xz7e3tRYm6h/NsCBYaixTUUyzOW0yQdJSy5yez6ImWiBbgZSkQy+fzOj4+Vi43V820221Np9NowLa2thZ1E71eLygujGuSJNEtkrnwJC/OxWkoxpJF6vmUJEnUaDRC1wwy8oPS2STLy8s6ODiIaAxjwlxSACdlmwpKCjlqo9GIvAtnPqDacIXRYDDIUEmuqppM0l7t0FVLS0uZOgqeD0fphW/MNU6EhCRrTUqjAwzCcDhUp9PJGA+QIcaFqA9qgflhnEDEUJCXl5extjA6rvKCFmWduZKLnNciHeWIGiMMtbJIrxCZ40QWJbaMLxEugIC+PRhN6Er6BUkKdMxaYI06MGI+AQ3emZbaAT9MHgfEfTB3RNdc3iLCv8vBkdOD7GccJoDEmz2S48AhM1bUGrjj/arrnXYADN79/b1WV1e1ubkZCUsoGhJzkkKnzqJstVoRsrFwLy8v499eyed8MkabP4S3+Xw+07mRpAybiROVQE8UL7VaLZ2cnGhvby/TR3xlZSVK3THYLDo6mvo5Aa4HJpnI/9kE3jDq4eEhjD0V1W6MXrx4oV6vp4ODA/X7/eh4yWahyyQG5uTkRJKiVoFIjE3N4gM5UWcATbK2thb3PBgM4nuWlpbiXIG1tTXt7+8HNUceRUrDaj/aj9oQfk4ex89rBQky76VSSdPp/LjRo6MjtVqtQJ84Y0mZnA9OGOPPRSUsBgoJodNZbuD5LBAthosLw4ADcvTJ59zc3GhrayvapOfz+eCcWZfsEfh5l63yHbe3t/r8888zyq1araZSqRT8PWuZ52D9AJi8xw33z/rDgfPMADXGz+eE8eVZyXewLz2SZO96oz8i+1wuF+ob6CoECTw7FA4OiSjaI75cLhf7FwfkhtUjOn9+1jr3BCiCdvLoCGPvTpL3w+sDoPzeAB3kPAEVSHd/muuddgAgukqlotFoFK1iX7x4IUk6PDwMr7e6uhq9RpBivXjxItQdhNWSwkjMZrOQCsJ/ezKK17OhCPvZjNQBeKtiuHdCbVBXv98PrT46cOcC4VpBU7QoZmES2uHsoJa4JylNnsFDIo+VFEVNudy8JQD3ibafxCfJWHdi8JTVajXoBiSov/Irv6Ld3d3occS4gVAYP5Khju6RxJXL5UCYDw8PYXwmk0lQe7lcLt5LJW2tVtPGxoY2Njb04YcfKkmSDFUIMnLEzVGKo9EomqL1er0YD5AcFADvYW3g6KGmQOsYZ+6Ve4AXB7k7eAFxQhcxhw8PD6G6whDw2a5kKZfLsZagmxA+oEIiciEyAoCQDPcKdYotaUAopWjena+fIAatR4RObxzWJveOio/K7MXcjhvetbU1PXv2TMPhMLrCSilgm07nMt16vR7fTUsS1pxXgDM35XI5IzHld06/uTHmfTg7qBgcIRSvlBaf8hwusYY24nJKkP3NGLD+PKICFHq/oNPT05g3mIVSqZQpsnyb6513AP1+XysrK0qSRMfHx1pamp/0A1rwA9DR1+K1KTQikeohqMu9fPGxSEqlUoSBzl2i33a1Cw6ElhJEJSSUSTSCSpkgDpagCERKEZykiHxOTk4y3UL5PYif56J2AN4eZHJ2dpZRP5Hs5nl4dpCsF7XQygL0hLErl8va3NzMKIBA3iBMeuwXCoXg7JF3Ykz8+ElO/iLcleZOniQ1m5zn5/zk12/aXSB5xVG22209f/5c4/H8DNuDg4MMp8/foD02H6iT5Lej9VarpVKpFCddEQ1KirVwfX0dc+DUAOMEZ+4JRH5HQh2ngADCv2c2m+ng4CBD95F0xniAOEH+OGRyO/DH3W43EpDj8Vxzj9yaYjr2lCvZMMTckzduQ4SANJKx5Rm5Z/Ypf7OuaD2B0yOqBIhQ0byYZJeUcfS8V5KOj48DXZMXQVHGvZLbIAJbVL3xfRhrZNdLS0txIh3ryk/849n8crm5J74lxVr3fFG5XA4ZOBQtclLGDzuw+F0/6XqnHYA0pyG++c1v6ubmRi9fvozSeqIBUNlkMtHLly9DDorM0HXUcPe0ZgA50DvIvT4UEhwc3CwLaH19XWtra9rb21M+P+9Z8vjxY/3qr/6qSqWSXr16pZcvX2oymQSHDSftvUTYLPDo8NxwstQxYFg9yYtkc3NzU6urq3GoizTvrY4yiY0HpQEHC88PFYMxB7Fxjy6tc103huL169dheBeTfJPJRI8fPw5ERsGTGzwWOByuG/nhcKjj4+MwNGxilzxCu21vb0uaR0cUjjHv3v6DowIx7Bg5R/KMx2QyCbrBERgJVSIRpwuJUMjvMGfMPX8TdZEjQVb58PAQUR33Qg5FSg9uOTo60vr6eiYvARVIhOuRw9LSUqxB1HLMJ+gZ9F4oFLS5uRl1NovSVZ59NJofQYrz9f5Fk8kk9iBjzbwCvqjGdt6c4ij/XnrloIAhZ+NFWzhUXuNImM+nTUS5XI5zBpIk0ePHj8OI04YdJwe48ggPYMMap7bD8zZuiD0aZr0RJQIWoOV4faVSiVyDnwboNU0Un5VKpVDl/TTX13YASZIsSfq/Je3PZrO/mCTJ+5J+V1JT0r+U9B/NZrOHJEmKkv6JpH9d0qmkvzKbzV7/pM+eTqeBpqrVqtbX14OHR61DZSdGizAI6gMDS9EXCGd5eTkWGIdtSApEhKGgAyAJXw4wp7gHY4zhGI/HIU0cjUZRFOJHKfb7/VDgoITB+ZDlh6pgw4Lw4FBRcbRaraAFPEGFsofv5oByKY0yptNp9N13rhxkyYWhwFATnna73eCecVi8xqWQs9lM1Wo1NqwnsonEoCAkherDHRG0EtwpRo2maI8ePVK9Xo95Yvy73W5mE0mpxA/OX0oNLQaM9ce4QHFQKOWv57t887t6w/XrnJEwm83iaFAcjBdF4fBwkMPhMHTe0AYkOonUnEbwfBZqIoqNMKAIGRgHT94+PDyo0WhEcnY8TtucwM/zzBcXF8FrY4hdxkukRO6JNehjj1EmqvXDfTi2lVwcRm4wGMR44nwZD6+QJjFM9Mz+BjET7bMuJcXekZShYhYvnC5AiXXjDoD1y7qFgnSb5aIKBCvYhlqtpmq1Gl2I2edOHXkOxB3tV11/FhHA35b0saTam///t5L+u9ls9rtJkvwPkv6mpH/45u/z2Wz2zSRJ/uqb1/2Vn/TB0+k0Wv9iJDhujiQnBqdQKOg73/lO8JCS4hxXBgwOnqMfPeyvVCphDGl8Js1PDON9hKIPDw+B7sfjcVQfXl1d6fd+7/e0uroaBU6Sos3Dzs5ObEQ39J7gmU6nwYvTHx4lDBtLSg3V/f19VCAjmwRlsonoewTvTp4AY0J0gTGCamExgeCofcCxebQEwmQ8UeJ8+9vfDuf66tWrqA1g8eIUSab7osbRsNg5nY1+M+Q17u7udHR0FJEK9AaG0lEnOQVJGbqK8aczJUgRZY/3ffGKa54VigdkzGZnHL0Q6MWLF9Hqt9vtBlrGCIBO+/1+GHEMNEbJxwtnzVwv9sphrFiPRLIowqrVqrrdriaTecM4xoJ26E71QI0xhi6rLBQKccIX8+wHseAY+TzyelJ6vgIOh1wTc351dRWOVkpzZgBDCvswrF4h3Wg0AmAMBoMoBKRug3mU0kPnHx4eYg0BVlzXj5F1StbzCP68o9G8N1m9Xg/AQOQA6IPuJaJarOtZW1tTqVTS6empzs7OoucVdtHzST8zCihJkm1J/56k/0bSf5bMY9R/R9J/+OYl/1jSf6W5A/i1N/+WpH8q6b9PkiSZ/QTNUqlUUqvV0vHxsSaTSWj3Ud1IqSKGsn6OmVukMzCKcOl4TCbg9PQ0aAOcBFTB7e1t3MP6+np09yPKYMD5Wa/XC4+PQfBeNhgXVy/UarXoHYS0kaTcw8ODSqVSJMQo2PHDzXlW1A8sYKgekDQ5iVqtFvpy+EOQMgbU0TfjSHhPa23fTG60oeeKxfkB4ZL0ox/9KMN5Er6TbOZ7fTy5mG8QOEYB4zgajfTq1StJCkoFKkTKtq0gOmIO6PiJQSG6KxQKEUGQHCcSwTBKChEAORCMAsYZNQmNwNjkABuQrqSYBzp9kmys1+s6OjqKMVnc5BhUb2HBc8O5s9Zms1lGhQLoABwwjwcHB0FfurYd4+T1BowRUZgbbD9TWFKABc9lucCBvIc0j5iYa88XSV88wJ0x8+9ZWVlRp9PJREgYbp6ViAFghOKH7/aoAdqVz2ANuzjEC+VcvXV7e6u1tTWtra3FUbAeJSAz5R4BnqwtTtfj50SWSKkBBT+NEujrRgD/QNJ/Ian65v8tSRez2Yyd25X0+M2/H0vak6TZbDZOkuTyzev7/oFJkvympN+UFNJPOMHr62tdXV2p2Wxqc3NTkoIjH4/H+vjjj7W6uhroDMQEr5zPz9tEkFSW0l7uIBkWBIdue7FYsViMswFAl1AxhNK8H45TUqZnOok0P6ycP6A/jBShM1I3T9bBHXu/FbhbxgCj7XplTzSRdKUSFCcJF8nrOWaThYlRp/nXD3/4wy/on13lsrOzE84RXbyk2Kzez52F7cbfLxLuXJPJJBPNuezQaReMGHkXT1yzLhYlj9ACCAEwXBhmbyOBA8ERsr5oT4CjkVL9OfPGnGBEocmgz8gL8H3QV56IZQ9gQByhO7XB2GC8veUGR1Hy+Rgoj5S5nIYEueMYWSN8v9cqsA45CcvpSKeEvGr99PQ044BAyozj4eFh7I9F6sVpmbOzszjD2ttO+CEwvJb17zUf3BtRNsYfpWK1WtXNzY3Ozs4yc80aGY1G6vf7arfbUbsCCORiTbDesB+AUV5LPtMjii+jqL7q+v/sAJIk+YuSjmez2feTJPlz/PhLXjp7i9+lP5jNflvSb0tSuVyegXpYQL65kOAtLy8HPXF6eprhZ2ezmTY2NlQqlTIVgj7ZHtphQFDT0GoBVI6ShyrKJ0+ehKpob29PUhp2E2GAFnK5XBSi4SSgJfDgjm7gVsfjcYTm0FAsPhYCCbfNzc3YwNw7z+mbA0REroMwslAoBOePEcIJ8OzNZlMbGxv6xje+EU4XIwN6woDu7OyE0+RUKO6HP46eMHQ8m+vwx+O0FxA0BhsTB0Z0eHt7GwowEvQk2yjvT5J5X32QM07MDwxx5Q3qENYWv2NdMZ9QCxg8R+Onp6fxXb7uMHg8I7RKkiTRp0lK+9+4bh06UUqTj4AAR6QYTKLGyWR+eEsul1Or1QrO3w0/1CHOSUplvZzVzFrk/omgfbxwTqwRDJxHFNBmOHWcvdcB4HCIHJGX4sihRbzKHkPrc8t34EhYG4AFnCpRDK9z2S57G9CFmAJbBNXr1cSz2Uz7+/vRbpok+PX1dURl2DUpPd2OIz59XbG2yXOgLFuswv5J19eJAP4tSf9+kiR/QVJJ8xzAP5BUT5Ik/yYK2JZ08Ob1XUnvSeomSZKXtCbp7Isfm14YPhKCxWIxzuu9vLyMUHZjY0OtViuaVYHYMZQgdiYTFL2oPmBhOV3AfSDL8sX+6NEjbW9vh+E4OjrKIG4WApv52bNn6vf7gZLYEGtra+r3+1paWgpKhe+pVqvq9/tRcMM9oUqSlDE0o9G8wRs5C68mxHFJyvTvIQ9weXmZ6WCKobq7u1Oz2YzDruFEP/74Y11eXkY0AjfKRvEDVcrlcjhLzznUarXIJ3BPqCNqtZqOj48zkQHIjffDb2MMQEquIrq5uVGn09G3v/1tSdJnn30WhWg4FHe8HlVJWZRIVPZljpUEKobBZXmMDc/pn4/h8kpd1+xL85bhnU5Ho9FIvV4v3kcUyjoYDofBN1NVfXp6qmJx3g2V4xG9CItngC+HGiSiBOFjVLnXyWSiRqMRoIv+9zQ1Yy0wtktLS0Gr4DjIc0yn04wiiCJOInDGzhOcgCjGGUPO2BKBnp6eBkBgz4xGo+goS48gSeEgmBOexYvanDrGaQ0GA/V6vWADSNgzTtCsgI+rq6tQ4DHOOGqneLgXnpm5c4eJTcN5/kwqgWez2d+T9Pck6U0E8J/PZrPfSJLkf5P0lzRXAv01Sf/szVv++Zv//9Gb3//eT+L/uZgQFjVKnsvLy8iMs5hQDHnINplMon6AbLvzqBhzODbvtUFyuNVq6fz8PPr9SIpGVS9fvoxDVaT55KFM2Nzc1HQ6V9pAESEvvbmZnyPMBiGRyGdz6LSfouWoDsPCxPM9hJzIFqvVaibpyqbwZlNsGoqsMD7I5O7u7qJVxGg0io6RGAI/xo6CORDj7e2t6vV6HCpzcXERbXKJVKBVKGwiwdXv9yNicATGfUNNUV2MY2Is2RzMJ5uP84R5rV+MO+NJVALFQ/Wrc88geJJzOCR/D2PlfWswkCBHpHwom3CEKysr+u53v6tisRi95VGDADg8KqzX69ra2or1SEQFnYHBZRyJXDjEBgqSPcQ2ddqKfcfaoTUJe44opFwuBwhArUNrZKTB7Aspba+MY2acyC15nsMpWyTG/h4+j8Qvz4MDZwxwbMjDMaTsFWwB9A+5Je4DZ+DKIvJ2XidBLhB61g97yeVykZfjPU41Q09S2MeaI58I8OC7fhYRwJ92/R1Jv5skyX8t6Y8l/aM3P/9Hkn4nSZLPNEf+f/WrPsiTVyRjCUf5f/KmFxCZdKdfkLt5hlxKNblsGkdnLFycQ7PZVLPZ1OXlpXZ2dmKx3N/f6/Xr1yHTwujgMFgolGfn8/Oe35zmhYEcDodhOODCa7Va8NKuLmm321pfX9f19bVOTk60tLQU0krGis+nJexi0tDDbefp2QwYCpJdJJu9B/7t7W0oZWgBjaHG6HGBoNrttt577z0tLS3p/Pw8Q1sQneA4OEfA+WE2ryt6/Bxb8hgbGxsROXodxN7eng4ODiKyIaqUFN8Jn+t5BDY5nC9RlpQ9r5m15nw5VA3rzYUIPBNnQ3BBw52fn+vh4SEM18XFRSSod3Z2IpLgXovFYkYZAh1AK3LPHfnFvaKk4pldVsieK5fLoaRhPXnClTULd/78+fPINdGKhEQliVNJEVV5Ahdah/97/uD29jbTsdY1+jAEGGuPNolk+EwvSCsWi9HixKM2nnExByKlVA9cvOfycFQcxZrP59Xv9zPgBCPulB3UL07iyxoQLqrCPJJkfb/t9WfiAGaz2e9L+v03//5c0r/xJa+5l/SXf5rPBXGw2Eulkra3t2MQGLibmxt9/PHHmQXu2m8oGI69Y4HD83vSiL9LpVIkZEGlZ2dnmQ1NXQCcKMVMTFq329Xd3Z06nY5ub29DK18qlTIcIkgBowz6YbHyuePxOBzFysqKjo+PoxOhH5zD/YH8qOhE0sjChiIiOkBOu7GxEfeLggWU5Vww6LXRaETkU6lUtL+/H4fUuErp/Pw8wmDQOHJXPhuOG+dMxWe73Q4FFAbUi8ho9EeBFXLO4XAYZ0lwz9AFUppb8EQ784IKi/XhvDMgQ8oe1ycpFEZPnjxRt9tVr9fLjBljCBJlI3tU0Wq1wvFeXV3p9evXoSTxKuLxeBw9mYhqbm5u1Gw2o3qXHJXvC9A60QqFVa76AgThQFiH7Dn25mQyiboWxpcalZOTk3AKJycnEcWzLgFAODKn0zwn5z93kQD7jX0upf2ZvKke/P5wOC+u5LV8LqofjLM7I7dHvAf6kvFj3EiOUyk+HA715MmToISIFABhrF+XsLrqjsvzROwp/nBvTov+LOsA/pVd3nuDBe8PhjEjrPffo/ttNBoZ5QYIBmfhC8r53MlkkkEPnN4FwvIkXT6fj94qRBxebyApmrqVSqUMSke+tra2pu3tbe3t7YXR8jbXvV5PR0dH6vV60V/FkTHJILhKxsN5UvhwjprE8JHcxsBxyhhcsBeWgTB4dtQtGxsb2tzcVC6X0+XlZXRb5XsxYBTfQRdVKpVQdFH4dnV1lelOWSjMq1IZN7+Ilkiw4ugwqkSEICVfHyBE1DVsMrhVPn9zc1Pj8Vj9fj9ODcvlckHNMQ6guel0qu3tbT169Eibm5v6oz/6oyiY47Pr9XpwyRgr565XVlYyxVNnZ2dxnyBPjBXrl8Z8w+G8ehqDzfN6fqXdbkfraj7XIzJe6zSHN5TzefCaFP5/d3enTz75JPYRSfter6fz8/OYt1xuftIda0VKZaXcO1EEaxpb4JXOOG3uH/DkiVNpThsSObGH+E4+E6rMk6ruGHE+vV4vs14AJTh47hM70O/34/5cDAFQQwYK3cnF8zCP/HsymWTkzCD/P01B92XXO+0AFrvvjcfjOLydxUn4KKX0Bl5waWneN4icwcrKSlADzv+z8ByReY/1vb29jKGlCyGTTxtlknC9Xi/OLSA0xkmQnCXhx/nDcO98jzR3Gp1OJ+ocUGwQcnqL4qurq1iIpVIpI11FJYUBJAz1A0XcsHuDOowVtNZsNgvDAZW1uroa5y5QPQ36ok3Azc1NUAzQQhy1ubKyoufPn4ea6eTkJBA7+ZRcLhdRGDy702jD4TAQLA4LJIfx82hL6i72AAAgAElEQVQKGs8LtqRsi2BHn/1+P06a81YevMeTlIPBIOhCdPGtVivkjCDwer2eQfP+eUQkUmokCPE5Yerw8DCS6lBiOA2cuUtgJ5OJqtVqHIfJHoK2cm08RsqNjevOiaCRqQKUoMouLy+1v7+fQdHcB1GMq2cYi8XaDfJE7EUXGniuju8n+mY+WQc4yZOTk8zPWD8YeNaSj4EXizFGROzMHWOD4Wdv5HLzPlO9Xk/lcnqM46JMm4jXj7/kubgc+XNPCAVQJXK6H3mxr7reaQeQvOluCCXAoDGZoGsOJwHhgngpouJCpQHVksvlIuwjEcPkSWl1In1YSHyyYC8uLnR0dBRJaMJiwkM+k0mnOMvrEUhIEhYiD2MxcujLcDiMM11Bqm7cSFDDm/sihjPc3NwM9A868hDSDUCtVguHuLq6qo2NDV1eXurs7CwcB8+NM+G808vLy0B2tNyQ0lOcPJrD4C8vL2t9fV3r6+tBES1SHaenp2q1WhmERBEaCTI/FpSL+YSi8rHBKI1GoyiowUh5jgatNbQgjpc5WMxV9Pv9qFim+yzvldLjNJk/T4gT/UCJ8V1sehL8FC15IRn3gJNiDULdoKiCunQ1kJT26JlM5j2cACZ8Foo45MhUvBMFESH4+OJEXObMvLiCBSqUveRJV88RQOmwR9l3jsRZc6xxDKrXSZATWF1dDRUhkQ75Cimtz2B86QhL8RzjRf6Gewag+r5yft7rlXBCRMzYMG+xzme4UowIFqAGxfZz4QAKhYKeP3+ufr+v0WiUqfDFOK2vr8dGOTs7i8kCDUAp8H8pVV8gacTw+2KX5tK7YrGojY0N7e3tBQ3iFYIYFIwLYSUGDENO5OB8NBuCpCqvQZ54dXUV4TKdSblXEBELxZNUbCxUE7zn+Pg40Bc/o+qShercOGiWltmUw3tPd2R7LHZQGWMhpQk8jHmr1YrPhvq4v7/X/v5+8Mt8Pg747u5OrVYrjCMRABsPJFksFqMxFxELG2c0GkV7a2+ABxrN5/P6xje+ocFgoN3d3XBqUlYm6klg1B1EUCTPPeFJHoN5cue1urqakf3NZrNobQAAgnp8eHgIB7G+vq4kmR+gQ+tmDLlHLhgcoj8AgVfNAhpcScL9PX/+PHogufPA8SKYYH5xvB4RcW/Mv18+j+THRqNRNDxzLt4BIP3B1tbWIvpxmSpzxjoG5LkKkPXuAgzswnCYHgbln+OULaITamrc0KP0c1EAThQQh/1xx4b9AWRCHbOOWMfsW3eqrO+fmyMhnV8nJCbEgZ5otVrq9/uqVCqx+EjK5vP5UFMwcEjTGHTkdnh/Njeh1Ww206tXrzIFMcfHx3r9+nVsPKik9957L/rZuxQQSome3ci3fGFIacjLIuc5MLxUXnJ5zoL3O23A5yIFBG1BJywtLQWviwFksXNwDgad/uP+vBhAGpgh1eMzaJUB8qVBlydhWcBo1SXF2PBM9PvZ3NzU5eVlzJ9Hhp1OJ+M0XBEDUud+6SRLhMiBOdwnxvzo6CiDZFkvhPvMb7PZjOQ20ReghMNVoHEcBUIPMB/IbVutllZXVwMYUFPBWikUCkG33d7e6vnz5zFWg8EgaA6+gznkYuwWaTKX2ILIiZI7nY4++eSTcALQTQgMQJyemARlMybciycrFxuteT4BRwrI4p6IStkTUCMe+bIeeW5oJdYcvZ2YD/KBMARci1Ey43V8fByvcbkvHD65D6ggIjBygABSohvfd0hyAQDkzZwC8kQ4gHgwGGhvb+/nxwFICv2+c3REAxy7B6IhIclh5zRYIik7nU5j07DYQXCeLHKOFwWEJ62YWKdRRqNRhPwoVijs8O/3MJGJctUOiVd4eZ6bZKNL8djIbGYSpqAUSRmJqCMN5/pzuVxmkzmdgCqISmpUShgnKVse7wd5S/MzD3hmQnVaerhhlRQGGcPB74iYzs/PA/FzLVIf1Wo16CsiBk49W9xwoEE/m9gNmW9+1+4vUhme/MOgk7SElmOOiL5A3P4cGKzT09NobQ3lwlyS7Id/RsWFw7i9vY0cCe8nb0SbdIzceDwO3bnPA4bZnf79/X2ILlx9JaUHwuP0cPTuyDGSOE/2jx92s7S0FFETRWzsS/ImnveZTqfa3d0NQ+jqQKIKQAWgw2kp5ohcxuLeYb+TU+IZoKignJgXcnnuMFBGQVMTyTtVRm8u6FHUXOPxOPI96+vr6vf7kV+BviPvsgh23vZ6px0Am79YLEaydDAYhLae7ooYe1DM/f29zs7OQi0hpTwwVbWSMggSR8MC4rq7u1Oj0cjkI0jAOiVBsUmtVtPJyUkmHATF0AbAVTQeriKNQ3sPtYTBI6FLS2t/LxsbDTNUBMZGStGglBaL4DSkFO2gPPJq4Vqtpu985zuaTCba29uL5lxw5Z6whx6j8dV0Ope/ra2tqd1uK5/P6+joSNfX15m+Pt7fnZDdDSZGjQ6xJB8nk4m63W7kV54+fRqOBuO7yAHjwDAWJOA+++yzMGzMn4fmgI5yuRzr0ENzPp/24xhNR24g7nq9Hi0AQICMx+7ubqzbxWp1xhV1EIYQA+JtkH0N8nkYOSq7XSDAPRJ1Hh0dBQ2J3LdarcY9QbHm8/PDZqA+iHq8jgLnBe3jTdUAarT8JlLnHGu09M1mM4AIc8e9AJhcslyv16NQ8/T0NIBOoVDI5AfZYzgHnJGURqkYc8aTNbU4R0R+UJGj0Sjyh9QNMQ44U3KGqA2RxnJqXqfT0S//8i/rk08+yaj8AI/kSAAW/38Wgv2ZXZPJRL1eLxJ7oEjCYRDF9fV1KE9KpVKmsq9YLIbqR0ori6Fz4B5XV1ejnwgbFh6Q4i562mB84W+RcY3HaesKohJQBEkt78LooTmhNslAFhrFTKA4ohKMOZuDBQwqKBQKajaboUeGc2TTSKnTYdFAc4FypLkEjxPLcrmctre3Q9202H2RRKrTICArwvVnz54F7/rJJ5/EWJJLIF9CRIdT9yQg6I1iNxwcESBtQgjzaVVQr9clpU3o4FIlZSgcjCBRlfP2jA3jSaKa4jWQMUjMqQ+nqNbX1+NvDh/h+XF2bGTnnwEFl5eXWltbCyEBawOUT+TKvOHIEB+Uy2VdX18HVUaUzdhwNnA+P+8KOhgMVKlU1Gw2g764v78Pw1cqlVSr1bS6uhpGlnWH9JS8y3SaHrpeq9XCmXlOh2jG6w0ABgCpcrms7e3tUBx5bovCye9+97s6Pz/X4eFh/Jx1gELNcybsQZLrjB2RnOey+J3LVx8/fhz9uD788MMAB9gZckGMN3QRtNciVcbnAjCxeaj3sB/YKwrPSE5/1fVOOwBa6Q4GAzUajVhwJPym06kODg5ikLlAAKAJFrWHmxgVX/jeNx/uXVJwriBIR6UYZ0JBootFbTVGHzqE8NMX1Gw2y/Sol1Le0ekDNgMLB0kajgZU5YU9fiYsY8TYOsVE7oSIChS3s7Ojo6Oj6F//Zck0klCMLchHUvQy+vzzz0O5wbyRa+Ae2TCMDZvME26L0k4MFJvME8wYf0+44QyR3cFlO+WDEyK5zLhxJjBhO5QKCVtUZk7x4AgpeqtUKnGfOBoHAx6ZsOExDgcHBxHttNttHRwcxD2A/mmPzhrCqEqKYiT4alpqEM0w5tyTR2TT6TT2lFMNGGYoP/bNdDoNRw2V5x1D19fXg7JCksp+dBUYeZnr6+vMKX1w74wZzhrHzal3tIMZDAYhYwXoeQTGnmIePFHOGd2LghIcBN2LG41G9GtiPXGfRPe+NlhbUNAO0IjykPt6ZbBTUIDL+/t7tVqtL7WnX3a90w4AnpIFzOKGHx0Oh0HpsIGJDkjmYWRAjCweX5jQNoRbRAdPnjyJIwefPXum6XQaHfww0J5o8tCbUBtah9diHKEKiFaazWbGALHpQSO53FxWWa1Wo8BtZ2cn2upKKW8Ntyulya8kSb6glKHIBWc0HA5DTso9rq2tBb3kSgQ4f5ddjsdpfxNQi6OY6XSqH//4xzF3nueQFGiUi2cfDAbRO58jEB1Rg3q9540X7GB0PffDeGFgyAP47/gbZ8L8OX3Ed/DcKLDcQHlLEjqvFovz1gPe/wetPs8OgHE1F5LXpaUl7e/vh/FwNRBUIQ4UNRz35Kol/g395FRGt9sNYygpztpACsw6RQ13cnKiwWCgx48fB4giWUs0wBixN5A3UzUP0AJsuZILB8KeW1pa0qtXrzLqIiImuH1fg0Sm1JXc3d1Fzgdkzt5xYMYeRpHD+sUGsJYLhXknXc4sdhDHHoC+Ye04rcT8s364yDt5pIvTYS2h1AJQvO31TjsAUCHGiwrVq6srtdvtoFU4LAS0B6KFdhgOh3FAiG8oCmg8cQMKaDab+t73vqc//MM/1OnpqT799NMIHaF4MJQU+HhYBiIAqXFWMYdl0MvHPbgjWk4iQ4nEzz/44AOtrKxESAttgAN0Tl1KJZhIECuVShzkglEnt+GJZNA89BhOt9/vB4JF0UQS6vz8PBM5EM57ItTDVufWJ5NJ3DtGmOpRN8YYMigmjOLW1lZIFYnciOboEMoGoX8RxsENiqQMAiQaIwqD+nJaxY2qK1IkZepKJEUhG+vIzxzwrpRer7HYzRU+mqKj8XjeDgKeezQaqdPpqFwux2HoOE7Ghu9kzWOgK5VKjA06c+aN3kRugHz94Oy63W7cb6vV0vLysnZ3dyNRToRE9Hl0dBSOE8NPLYPTb8w1QIv1wO9cV09R4aeffhpJW+br8vIywOF4PNba2lq0wuY4V54HKfhoNIqaB+aZKBy7Q4QFSHA7xt8AFaIn9grj6klmXkNE5nQP3+PrlZ/7d3/V9U47AMJmT/SAZqCCQK+cvevUAf2+2ZxXV1dhXMklEGZ6lDEezwu5er1eJiQE+SB/kxR5AdcTs3i3trYCNRQKBV1eXur29vYLyWeQBkiJ76TBGQ7m4eFBr169CqrHC6DoI74YYWCgMOh0PEQ2SyEWhhi0Sz6E78ARVKtVPTw8xHzc39+r2+1Kyipn3LGxWT0hiWHD6fB+L/ySsq0/oGycEgPxT6dTvf/+++r3+1FyLymKeth0i/wq0lrGnu/he+lVRKuM29vb6BOFg8OQgao5CB1Hyu9pWAh9wibnvhgb1iX3AlfO3JLEZfzIj+BQAQJQQujlu91uRo7LmodaGI1GarfbAa7gp30/AmykNJcyGAziaEk/HY7LeyUx9yBoULpTivDcngOilTgO/fDwMJyZFyw2Go3oP+T5Op45l8vFHphMJnry5IkajUY4d/JF1MiQQCZPw7Ow/xF3eH4QMCcpcoWdTieiUgr33Khz8BWRGOPB/Lu4A2qQ3MNgMIgznqGY3/Z6px2ANJcRwtNTJESnwEePHsVRiSwiPDkbHa4WvowEmLcSkNKDJjCc3W43Eop8DkYADpjugbx/eXlZ1WpVJycnIdfyRlpwp270QFhMNKEoiU4WJ6+HksLosSBxGq4sAvl7rxs6cZKYlVI1FBJOfsYYumPiSE7Qssv5XJ6JM+W9IEb0zVBX8MEkIkneMi44OFCdlD0OkbCayMCLekByGEsppQ+Yf1RMtEzAuUhpJTiGGfqvUqmEPv/q6ipQqM8lUSufRy8g9OGM52ISj+dgXfIZ3uvKn5//extzaJXT09PMaXTUUTiNsdgXZzweh8YdygQnI315Mz1e62oY7z3F+qB61ukR1ocLMFgvOBckrvl8Pprk4ax9jQBy2N+uvpJSSpl1Q0T8/vvvS5L+5E/+JOPwoESh00D8OBLWGnvT6xqcISC36J8N4GKd8Pz5fD6cyqLkGeahVCppZWVF29vbur+//wIN5rTdV13vtANYXl7ONOICTS4tLWljYyM6QF5cXASXysNjpFZXV9Vut0P2NplMonMiRh9vzkRdXFwEj0d4hsbdE7BwhmxAJpGeQ0yYlEoXndv0MJCLRl2PHj0KdQ4aYpwdxgNk6d0PpVS+iFH2wjc2DElAkASUAnw1mxGHyOdiDHBSIGtXSICKocyglyRlpHdI4hYTdyAZvlPKyt08moCbPz4+jgZrOAUcIOgJapC/oTlwzBhaiou8jw6GFrEASVxOHQPJkyd4eJifT40qivHBILosFafNfebz89755F5A6G70vE0B6wAjxXrzWgt3NkhyWUe8hlyOc9Y+5o1GQ6urq5lDgKDXiBShOZAvE1XyeZyZzNwSFZDIZ2y4Jwy1n1+Bo8vlcrHGuB9yPTwPr/XqXsBTPj9v0fxLv/RLQQu6Ay8UCpHU5twLnBxrwXNiRNXj8Vjr6+sajUZaXl6OsyJ4HU6VjgLk5Wq1mvb39yMKSZIkJNnQ1KzZ29vbOCWMdbFIP77N9U47AJKxhGzOZ3Pk3/X1dQbh0dsHioUJJ/GCo4AuwqMvLy9HReXLly8jpMMwsMDu7+9VrVa1tbWlpaUlnZyc6OHhQWdnZ3Ev3DvGR1I0ckOxA+qu1Wp6//33g4oBnX7yySe6v7/PNEKbTqeRG6Cwhza2lUolqA8iG6fOMDadTieqU4fDodbX10NGenh4GK91lEmOBSdSLpejFa6UhvjT6TRC7VqtpidPnuju7k6ff/55RDSgfQzp9vZ20GMgY0nBb7vRdoqIMWZuptNp5jhQnCqUledZcPjML5+1+Ow40cV+UoPBQPv7+0ENePLY5bgerUkpHUW9CdGhd3eVFOIEkDm8t1MoNzc3qtfrWllZCcUJxqlQmJ8nwNzzvQCCJEmiGpXxxaEsUnA8s/Pt0DzSPELhaEhAF+iXNcjn4rgw/BiqYrGoTqcTrVh4XvYI1NtwOFS32401BiV5f38fUbqvdaJaaR4NMsfMD0Do008/DUfmOSGklyB91plHFbR5Zi8SbXNvkjLFai41xoEUi8UAEhzABKjCoEOFSQqJpx8dSifeL8sD/qTrnXYAo9H8+LvhcBg9P0jiSelgSmnIifFBAy7NW8Aii2NiQS25XE77+/txtB0FKVTqSWk458qSzc1N9fv9OMyDxAvhMRtAyrbX5fcYr0ajEY3lWq2Wut1uhM4Uq4By2Lz0qWfDO1/IxcJY7DeEVpxEnOccuF9QMRecKBw3CIv8iSezMdrr6+ux+Ug6g8Bc6cPC5n0gaJ4JyoXv8jDbaT6Qnq8d0BHdWzF2OB/G1NGxh+aj0SiTh6KVNvkYjKXnNgjhi8Vi9KbiWl9fV61W0/Pnz3VwcKCLi4toq+CSWrqnYnhZjzhr5pp17fJNl4sixUXogNF1Q4zBZu+wxzAmbuwuLi4C4QIEiISTJImoAkNI5MfrWT/QpY729/b2Yi2B0Bc7onJWNc/kDfp4vSumJGUqslkX7GnG6ujoKAQmyH55BuoRWGt8br1eDwCDPTk5OYm1SgQ2Go2iHY1fFE8ifvAksOcx/Xnr9XpEVLVaLaJfokP2t4Okr7reaQdA8paHZPFIqUcvFou6uLjI9AoH7VxdXenp06fBW2MIeS+G+OHhIfoJbW1thTOhMpGFjkpiMBjEubJQShSg+cSxcEjMEJK+9957YUi73a7u7++jJz58MfkK5F0XFxdf0MR7N0hQBWiehURERI0CyTOMum92jD6JROebica8eAaUxcJzzfTt7a0ODg6i6pEQn3AcWWe3242FjEHCcONIOp1OAAGKvEBQTlEhm8SpuCFibeAUCbu9r5CU0h7QUBh75lVShucmsszl5oo1OqcyZihJBoOBOp2Onj17Fj9n84M6qcMgguU7oOJY/+TAisViJGYpCsOQADBYd1Kao+C7qADGGC0W9nmOaTwex9pyA+tOlkiR6ng+g3sZDoehwfdE8SJ9xlqbTqdR2HR3dxegzLl8gAhz5z/nu5eWlrS2thYRNuudOSWKY7zX19ej4vjq6iqKKZ1bn06narfbEaVQLMe84qw8IczFPgNkEMEtqpwAnFBnw+EwOn4yD9w7TIefzvc21zvtAHK5nDY2NqLKD2dwdnYWPV9Qw4AupflGv7+/1+3trX784x9nknuu6qErZD6fj/4bk8lEW1tbqtfr0YcfasOlcM79eYLHE2ygYrzy8vKyms1mhMwkZT///POgKby4Y2trS7lcLlouSCk1glqETZvPz8vkoQ9IJpJAx3g4jwit5MgRQ+PRBMYWdYaUJr35fOeiSY6iAUcmyrj4ZxPBuPIDOq9Sqei9994LHp0weZEfxqkgdwR5Q/EtRm9QQHy/G0pQKzkRl67ynFAJrA2nCKFkKpVKRHunp6dhaKHp4IZRhVEZzFrC2PLZHuGx7jhrGtRLdEhtB8+GoSHJz+ucUuMznDuH9/eEKmuQ9YChRzABeGAcGR9XesHnM0c4GlqBg+yJpjiPgo68rAFH5J5X8eiFthFeGUv0x3pkDFiDp6enkcsDwECZufQSUIYDQ8breTGXRLvzAex43oSCtS+TGfOM0DuFQiGAHCAVSunnJgLI5XKqVquq1+uRkGERwpdRHYz+3EN1NzosqKWleZVktVoNyRXIHlro5OREpVJJGxsbEaJjFNloJJg551fKduckwUrYC8qkuyhISEo3VKfTCcPQ7/czCgRpjig59cmpH5em0TSKqIdNSLiJUXG1CzQCr/MCHgwGihjUTxh11DugQha6d6/EkO/t7cXm9nHiPF4fYzYJyg7aM7vMDYfhbSFwpDhAPsOpBYyWlKponjx5ImlOF9LnCPQ5Ho91cHAQc+XJdintBY+OHJoJNCfNgcHu7m70QqpUKjo4OIj7r9frkVfxvARrFAeL8wYN0jeGaIZqVYqZQO7MCxQXz85c4OiIinkfRtEdEXOHofIkNOPCMxAl4YQKhULsHyIyaZ5L8JPOSIJ6szZ6OzHvLgpZROiTySTqXJyG83t06SnAin2FUo7++o1GI6K14TB7jOXS0pIePXoUYPLRo0fa3d0N1RNneLuDBUC5BJ09TMKYyMntChQdTQfJx5EvINJ62+uddgBJkkRTLQyqn0ZFoy3+RnkAHQQ3iVyTxYz2mUgBysL13KAgR6gYM8rVO52OisVinHSFPpqFJM0rNPlcKS2H92QQmxcUT3MtmnB5a2CKblzpAFrFuS2GnHyPJ1MXZZ6LobEjNo8wXEHCa6nBcP6SZl70hmF8BoOB2u22+v1+5HOKxWI0ETs5OYkoaGlpSa9fv46kvRszogIpTbhjkHkvBsr73DOn3qqDkNrpknw+H4lW1hKG0o0X/wbN+0aFoqvValGZfXR0JEnBgTPG8LorKyuZ6IM58kphp0547XA4jPVHVME+cYOQz6cH1PD5GH8/KImxdbURWnkQO+vI1zxzU6vVNJlMoossAMTpGtYp0TBae6ceASEXFxdR78Kz8zluIPl7sb6GfQF4wMk4IufziNqn06n6/X6GWydHw7itrq5qa2srcj78fmNjI9O2gvwL90Y9BRS2iwkYf8bHlVqe5wL4YZegs9zhfdX1TjuAh4cH9Xq9kD1JCokdySYelgH2Y9rIsBcKhYwTYSLgsj1pCxJx3XWpVIpJQ+3ApiF073a7cT4nqBFeVUrbQDhl4JN5dHQUi9+P9iPSwSC4tA+HxgLheEX6iWBYcGZStiydy3vcYwSIXtCmDwbzpnCMeb1ezxSjuWYZdAVny32jtuIzMP6VSiUjk3XjgMN06scRKXJNnkNK9fsu/yTsBwVDo7F2Hj16FIoh0NVwONTh4aHa7bbK5XLcC8+KkWecJGl7ezsMMuDk6upKjUYjoj6oA9YaleHeSkRSOB9vr+xJaQwx1A65J+8Ku5jjYLwwZtAQSF6llL4kKsYYtVqtuA8p7W/loAKH9PjxY7148UI/+MEPIor02oFFZ+01Nb5fQN0OTL4MsDx//lzT6VS9Xi+iP7cN5KuwH+58eQ35LJLGgAwAAxd5Q2lOtbJGoPpYRycnJ7HOAA6sCUAd8zEcDmNcPWr0Z0fFxT2jXDo9PY1iTuzE217vtAOYTqcZCRvGm8QXk8NkIQljgkGvjnxdhsZmYqKpmMRIgN4uLi5Ur9cD1ZJI3t3d1ebmZubeOAaRjnxsaFQwICEm1PuCnJycZBJvJLA8wUwIyPODDqX5ZtrZ2ckgCF8UbCCMMogSYwaqgVIh2hqP54fZD4dD3d/fa2VlRfV6PdAlGxInC8rk2XZ2djKdUaVs73bCaedX3WgxFq5TB6F5hIYDYx2Qs2k2m2q329rZ2YmeKiBaosq9vb1AZBjjyWQS7S3gdD2amEwmarfbQYnd3t6q3W5Hbury8jJaC1xfX0ckRNTGc21ubgbPniRJPOPKykrQBFA6zsO7lNLzMMwZTomIyvM/Tnc4b47j9tbNHsFSnQ5idWfrleidTic+m8ih0+lE/gxnj6jAk+mL65QLCoxiQdYvfXoAYOfn57GmoFAxsj4ufvleAhTiQMgRsp+IKsll3N3dRZNEqD/ul+9e/B7mATaBqmP2JU7f8xPVajUzl55o9///3BSCUSWXz+ejvJ6FLqWFDyxC9LoYBww2A8KkefiOcyFJ522R4dZIMLJIHR1zyhcIk/wDntq9OQvHw3gpDYeXlpZiEXPoPBJRZKrkLHzjO13l3O10Og2d8vn5eaATKAJHOmxi7hUFhPeOIaJxZwdC415YjKhoSFSxuKW0pbIjZwwgm8ydks8lCA5kxRjzOYwdtCD3nMvlwrkzN8PhMD7r8PAwDDQ5IymtHG61WiFnRQlGUg66iJoVEv17e3uxFlB3uTTYDRjcLWsDdUij0QjDyP0AGKgFQZ/vXTJZ4zgu9hFz44l+5gyUTOTpVAyIlz3InnNaBtB0dXWlP/7jPw5HTqQFCHJDv6i9Zx3xHtYEFB/zDwXFON7c3AQNAmXpkSYn/HH/fA/fsUgHjUajyD3S119K6RgcMJEGbWdcUbRI5wDcABLst9FoFA7eaTG3WYyr52d872EP+by3vd5pB8BAIyHECBFmUry1srKi8/PzKMoiKYSSBs3szc1NlORTMs73sMD9gG1aCJdKJR0cHMTiwFh5Ys4PdEDGKXCpkEkAACAASURBVKVIjcjD0ZaULhJvVYERvLq60vHxceQ2MEC8b3NzMxQfJC6da0Ud8PDwkKGiSMjx7BhDlzl6K2kMCpEUfC3PLqV9m6S0GRYGgjbP5GTYFGwIEOmiZA6E1Ww2YwNvbGzo5OQkksw4Lu8R5BSdR30bGxva3NzURx99FOG5lNYCwJ/yvWxuwnQ3WIzZ3t6epHSjlkol9Xo9FYtpO3EQ6tnZWSZPwPj3er34Xj8DgGQj+wBAgpHxdcZYMM/kWyRFRPro0SNdXFyE41iUc7oiCAfL9+VyuZBPA4I4DMYBjRtKX1+SwsjxexwugILf0T8LJ+WKNRQ6UErMGzQje5gDm3A6ACDEDVyDwSBzXKRTLOS12DfYCcAMhpjiTEQaSHHZx77XiFaJNpmzo6OjjJqQ+1ikdBgTz6Vwv4Ayrxr/quuddgBSKuk8PT2Nc0Lb7XYoV5DOgbwp4iD8o28GVX3OKU4mkzhNjLBrOBxGo7jRaBSe3ZO2HjZjOKn6I8R39AryIHJxpCOluvvBYKBut6unT58GjYFqBtTPhkEfD6IjCrm+vo4FgS47l0sLwui8yH0SnvoGRrKKhp2xJZQHhSzyrHCoJKih8Bgn8inMD5trOk1L7xdRDJuOE5VIFK6srGS4+bW1tTBSflraeDwOw1ur1UIO6Gc8dzqdmH+UF6enp3HiF0BhOBzGge1sbjYpkSPRB2ODUyLPgtGC/uM53QBiYKFiQNjo4aEB+e5SqaR2u61qtRrtCoieUSWRw2q325leOhQFtlotjcfj4NBRvvgaRA2G8s37J7HOoIAWc0KSIufA/RGhIs9mHMhneDEjCWY+j9/xM6gX9gIgMJfLxalrtFZgT1er1WiLzj6EZmTd+LNNp/O27VBz1KYcHx9nWlk41el2jM8HpLTb7WAXjo+PY54BvZKijmV9fT3WkEfYADLWEUD5ba932gHQ4RIURpLv4eFBGxsburi40P7+fkYixsHLhFlHR0cRIvp5qYT/hOWgq52dnUhyYrxxGiTPfLId+fb7/Yz80ENKkBMXCR02Pv1lLi4udHR0FAdL3N3dZZAT9I40X/SXl5ehPPDNyAbAoIMIuW8c2M3NTYaCYNNsbm5GURyOCe52OBxqa2sroqzpND1rGU7TUaGrTaAvCHFJhpEgBo0tLy9HRTcRDlFHsViMvjQuf+OIzlevXunq6iqcMuNMH6Vms6lGoxHabfhWKa09YXxBlkgCR6ORHj9+HIYDJQiRCN9BrsqNG5/vUaxHZu4A4NdrtZpqtZru7+91fX0d61FSREadTke/+Iu/qNFopFevXunk5CSoQqcmX79+HbQb8392dqZCoRBKLtZAq9VSpVKJM2lRIV1fX8d+rFar2t7ejh42Nzc3Ojg4yOSboDbZK6x31oFLap3TZg8+PDyo3W5LUqZtu4s+oGD8FDWfP28X72fyej4ApQ/OBZC2SNUWCgV1Op1Y4zs7O5nXeWtsB4CAJvbBcDhvNFev18PRAH4AizgT7Bd0r5+17GCUz/2ZJYGTJKlL+h8lfUfSTNJ/LOkTSf+LpGeSXkv6D2az2Xkyd2+/JekvSLqT9Ndns9m//KrvIFniRUjS/HAKR6VSKnGTUuXE5eVldEAktIUrlxRIdDQa6fLyMhBxtVoNdQXUE4gZ1QqoyJNLvmDcE8Ot+iLjQoVB6Ev0go5YUhiY8/NzzWazSE6SNPSFIKV9YUDL/hkYTKdjUFph/Le3t7W1tSVp3suEqIa8AQlLP30I2sq/AxqqWJwfQuNKEHINPh58Ppw/qiaMKpJRDB/GGWNJcpkL48zmd6071dho+xkH1h1jI6UHvlQqlUCkyHXZfIwB68JzKk6nkTCWsmosjBd0A2uFJDzGlz+MLQfeUCVKrkhKqQQHMnw+c0R0wOto7cxaXl5ejj5XyKDh1d1oOW3ICWUYQWgtntlrMgApfB/R6nQ6b/FNxEgX3lwuF/e0WCzHM1MkCUDg+SRl1htzjw1xKpT75jmgPgF05H8kBchyJ85n82we3aKu4/8Yd76TMcYZ+R71/euV1S4LddDxk66vGwH8lqT/Yzab/aUkSZYlrUj6LyX9n7PZ7O8nSfJ3Jf1dSX9H0r8r6cWbP/+mpH/45u8/9UJyRtJNUmiu6bbJZsAA0J6X05Gk1BB7ohOkQ7KMgaSnOAdBEOZJacfBJEm0ubkZuvXl5eVMrYGjSYwTFM3V1ZV6vV4gWaejaDftJ4hJ0re//W3d3NxEszacG2MipT1scGYYaZc6giwJ0Xmta7zpvVMoFOJAcCRqoMp8Pq+7u7uQCSJXBP06+kG9A93i94dRB1GS2FxaWsqcO9Dv92OzMYfkBDhYB0UF9IGUorIvM+7QGawpECTV42xk5oJKcahH19mT5HbnyKbGQEF5QN/we1+TqMlYE+VyOQ7+YT16kvD8/Dwas1F9fH5+HkYKyu3Zs2caj8fhGKDcMMLcD2tuOp2GNt0NvNfJUNcAeuUzOF7S3+fSZd7PuPI+b0kCFcJ6IA/HvfOecrmsVqsVjSE9d+NR5mKOCVUeeQXWK/vCE928j/2Myo1cG+AKo+45J4w/EQHzRvTntUc8M1HN4vqBGpOUKcwkivRI62fiAJIkqUn6tyX99TcP9iDpIUmSX5P059687B9L+n3NHcCvSfons/ms/F9JktSTJNmazWaHP+E7QtvMQIGIkUfW63Wtra2FPHF3d1dSmq33ySXc92pLH2RCLzwqG8mLjEgmsVlBcywaRzJwnsViMbpwSqlSyI0li6RSqeib3/ym9vf3dXJyonK5HFWERAfeKwTaa2trS0mSRNvsQqEQ8jq42PX1dR0cHITx903J4iUKoB02lcHQNxgguMlarRYIFQPlfy4vL0MdwyaRUjWJn9uMkeY+cKqMEzUDtNs+PT0NxEqh0MrKSiYERhUkpdQK4TT5JJdkeqO5cnl+qA+VnIw/oIGcR61Wi3H2TozMLWPr6xgqxjfqdDqNw9VfvHiho6MjvX79OnPAiedGGEPG6Uc/+lGACca22WzqG9/4RkhbUcrRUZaxcnUK8+8Inbl3pO3cOePXbDb1/vvvazQaqd/vB0XruTGcIFEEDpmxA1iQq0BMQAIWQIgIA8fHnpDS5pB0C/AxJjL2iIjPBlhA7QFCqUL3NTqdpr2KOCkP24Ej9fnCPhC5IUzBWUF3eoSGUWevr62tZaJ71iqXK7fe5vo6EcA3JJ1I+p+SJPnXJH1f0t+W1MGoz2azwyRJNt68/rGkPXt/983PMg4gSZLflPSbUoqAWZgsYCRgtVpNT58+lTQP0TGY5+fn8R42DYgBmSje3I0/A8kmvLq6CgPOoBMGFgqFoGyYIDf8b54lEAzIwFEC9AFVptxDr9fTzc2Ner2ecrm0fbH3+QD1LiYKqfK8uLiIVhKEhn4sHnwpBlZKjQoGxJ/N8xlSGt3c3Nxoa2srQ+eATKRsbyScKwiGcniXXWJMUHRwj3zmeDyO7opQYBRo8WzuVL1lLvfOvaDcWl1d1dnZWdBrqHZarZby+XzmLFqQGfw6Elp/Bl6LQQBkuCzRwQK/w2kXi0X1+/043QpqhfGHAqPWwqMhAAvfs76+HtEajQeZY5RSvsbg+ln3rA+e0ROPzpODSOv1uu7u7gIYLNKigACviSApSxTm+QP4b8a63W4rl8vFEZPNZjOoYPItTsM4n+9zA+2FsSeK8V5c7BtaWbBHj46OwhmMRqMw2u5ooAF9vIjYiYCazaaOj4/jvhFIuNLPI8Varabt7e1oPOe/88jaHc9XXV/HAeQl/YqkvzWbzf5FkiS/pTnd86ddX9aibvaFH8xmvy3ptyUpl8vNpCyH6vw4YSGHa0+n0wiLpbmM0zcdxgxEzCKXUjkYZ932+33t7OxkuDU2AiiI8Nc57zf3zbNEohaJIBsgSZI4UJ2EJNTBxcVFODG+G6TjoS0G28NDb0vNa9m4GE7GkgK46TRVFXhtxSL1xWJmsU2ncxUHdBYOjPvC0N/e3gaf6R1SmQO4zA8++CCoLubc75EIiYN/QN4gWTa0R2O+Zjyc5xkY7/39/ajzuL29Df23K8eYW1dzYTgxeIy9lBZgsfaopIUvB7F6pECinsiJGhiQPU50NBrFYUnQO1JaBU3DwbOzMx0dHUVdyXQ6byN9fn4eTopng6by9slIFgFMGHSXJ0IZUh1+fX2t169fx5p04QVjx7+hRXFKGGycCRJPPh8Axl68u7vLCC8wzC4pJvJA4YO6jejQK9qHw2EUPQL0XBW3tLQUwIOfcTiQo3LX+jN2XA8PD+p2u8FmAGY5HIl1wHqDAisWizo+Po617fUG3OdPg/6lr+cAupK6s9nsX7z5/z/V3AH0oHaSJNmSdGyvf8/evy3p4Ku+hEWGoSYReX19rcFgoNevX8cZv3hF0AN8Igk/FgHRBFycv+/m5kanp6eRIITuYYHBq9I7nMnCOHvSy5NNLCg2sieM/AzYq6ur+N5KpaL19fWQC2KAWeTOMbIpPalXq9V0e3sbFb0sNGm+KWiIh8EE+W5ubmo6nUYXUhwqKNz7o6MMgj/3JK+kkOXhIHwjkNQmp9JqtdRoNGJuidrId6BOwdiPx+OQvaL0wOnkcmn/HCmlrKB+QLYcos4YoPHmvZ5cZ3Ox0aj2RlsOYvuyi1oQX8eTySQjq3WZMePn6hTWC2sOjp4q1+l0GsIBkowOEqBcPIpcNPqMQfKmYygJVcbWK6ElBTKfTOYtkBcpMCkFEFAf3lhwUVqNUfZjM9l71DAwl4VC4QtN7zwqcXqXNUElc6FQiIptHDXjy/iwBh8eHlStVoO+Qo7LXMAUeEKYPQlV7AlxOhXz3bPZLObKFT5uPxBROCXnYgDfj2/L/0tfwwHMZrOjJEn2kiT5YDabfSLpz0v66M2fvybp77/5+5+9ecs/l/SfJknyu5onfy9/Ev/P5VwpGl4MGtpwOFAmHOqHhCycHS2kvaBmOBxGonc0GmWMJR7e9bncE5MJFUM47V64UCjEmcagVJAxyI2M/yLN4hJBNjnIQ8rK07g3KBUMCj9nMxCmgiJXV1cDRdMhdWNjI9A6nRi50IDz/WyOfr8fzoHCMzYTYanz11K2GRcH3KBbZ3zpfOq1Bshw8/m8dnd3M7/H+FMxTLTG/fJz7o3jDZ2fhYrwPAYySB93EsisNxKjGDGKD925S+mhKnwWlKYnBDFoHl26g3cVWz6fD5Ubc53P5yPhy9r3aAMjxHcQgTA2OAuMGnU0TnNxn0RQbnRA70mSnvmMMYN6A4hg1BF7eBKU+4Uioz4Bx0nky57wsZLSXjo4Go8CEF0wF4wldIwDGQCg5xgYb4Al6+bi4iJj7ImqS6WSHj9+rPv7e52fn6vX6wUrwBnT5CFcvUSuhPodGu0t1kU4iKMW5G2ur6sC+luS/uc3CqDPJf0NSTlJ/2uSJH9T0q6kv/zmtf+75hLQzzSXgf6Nt/kCDDsoBQRAhn55eTlzFKBX3PqB37lcLgxeqVTSixcvdHV1pZcvX8ai8QSalGqNMQxEDPwc54RhYkMgR6V/EI4hBv1NFTMVzNyvo7zxeBy9P7xRGGG485xSuiFZNJJiwboT9FYYLBTabNze3oaBmkwmkWT1DUELbO8PQztjnCwHXHCfbGacGggJh4rc9tNPP9Xa2poqlUoYIP8c+GFJGZQMqh8OhxkU6HkDkrVELIwDztkdaqFQULvdDt090R7zsnialSfhcNYkOrk/1laj0QigAR3kc7KYR3L60+kfN4xOaxHtcr/kT7xdydbWVnDN3D+OjnwHvDfOaTKZZBqi4WhQd3HvGH9eD9DBOAOISP7WarVYL+4AeR72NOvGVWsu+fXk/SI48mQ7BpRDXtgTDlqQZXuBHwAG++IUGG1AmDfAJJHmeDzWkydPApwQbUEb0lsLRRvg8+LiIpM3LBbnBaCIOWABoChZl74ev+r6Wg5gNpv9P5K+9yW/+vNf8tqZpP/kp/l8CjwYbCbSddSSIqOONt0Tl3CrvIcNz0lUp6enER6yebhctYLih78XFyncIMYTAyspjplk4XB6E4vGUbUnplz6ysLhYpEzRkw8m98XqNcckNMgebm8vBynFw0Gg6BkPBzm/Y76MYRESUQgFBZhtJMkybSu9ntns/LdHvpDx/n7JAXlAjctpRt8MaENJ43zJJFGd06iov39/TDQhUIhWjI3m82QG7sxZ94wsihE7u/vtba2Fmolfg+y5ki/x48fa39//wvFVTh4DCY/Y/7h7kGW3l8J3hxkz8+psIZ+guJ59OiRWq2WXr16JSk9N9gjWNRSjCfRpVd6Y8A8KmbdMA7sXdYO653IBVqF717MpQAiEBCw7gF3LoVk/eO8iIaHw3nhFfakWq1GfiGXSyvlfe+jApIU63zxSEwA12JuiPskr/TjH/84WqMjlz49PQ3ZLO3R/Tk9wUsB58XFRSjhONebvQ+wcTvxVdc7XQlMeMrpRs7r8XNJEWZ6ARCLCRRIyAQPTcsAEkSdTieKvljMqC/wvCxWDB6biepCVADj8TiUEHDphK18P9wu4TNojjB+eXk50A6o6fb2NlQcUooS+btUKkUXRuf2XfImKTj7yWQSEZWUrRVg3LyBmn8vUQXJPJQYixfP6w7TNc6SIozn2UB4yD8x3q6saLfb4VhPT09jM3sE5NLAwWAQUk7UHjhAL94i0mi327EZfUN5jkdKQQLz5r1nuHgGWgYQ4mNI0a+TLGX+MPDMQ6vVUq1Wi46vGBkpdc7sDRwavPLy8rJ2dnYy+TBacENFuIoJVO+nU9VqtTgwh/eyhthLOFjX3Ver1VCqUdvhTdOIBKBnGFecjDsWoiUAFWc20KIDbr5YLKrdbmcq+rvdrk5OTqJ4EQDAXLDmGUtXzTk9C8BibvkMfuf7AIfe6/V0enqaoahojc5pYzhJj4JgL3CeLiDwc0/q9XqII5AMv831TjuAJJm39qWXSz6fD75sOBzGgMANSgoum9fjFBZ5aCIImkaxMJlQdPoUmEkppSClB6XjZDgkAqOBphykgCFGKz4ejzPUAk6H94D+uHgdhstVL2xSJI0guaurq2iRgVNiLDCuLgVcpJPIDYzH4xhrDCbOmXsjGUWvGueKndbwMNs3OJcntEnsgezIMUCh1Ot1PX78WJJi/J3393GjTw/zxR9HxnDc+fz86EZ6vjhV4ve8qPOXFCBjUfuOEfKCJ19rTnMyVovRD6oxSTGvRDdSWjXvSh1vpEhksGhUUeMUi8UooGTf8LxQPUhnJUW7c8YNkIJ23mmJZrMZewIn58ec3t/fRwEmYgkcCM6I15LrcVoOmnQ6TYUfq6ur+uY3vxk0CQVj9O3n2SVFKxZvz+4UIxGlAwzGhegM6bZLnfkOxt9bPuOcPdpedHpOr81ms0wfLfYtc8e6+JlRQP+qLzTC6NmLxXmv9tvbWz158iQ0wnCivrnz+XwkyECd7qVJgiIlozdPLpeLpBchpjT39FAlGFC02Gx6DwsdeaMcQqrqmXw2Ku8FHVJQAkplwYPWpKx6iIZ2fAfUArw5zszDRAwbRtb5ehadJ0mhE3gGFjKcd7VaDTrHE+nuyLxhFsgexwCizeXmagaoBSIjKS3koQkcSJzfkfjk/1K2KjWXy6nRaIRqCPVNqVSKZ5NS1RDvYYww0Dh5d54YK5cK83ooIl5Xq9XUaDQyCWHmMJfLhfoLR3pzcxO0pctzSTiDgKFXOp1OGCHkrBhP3ufRGFp8ErIuMcT4QM+he69UKnGEoffg8YpUnCSAypE9hvLh4SHuhbGFqvSIhvXJZzIGbpBxiOyNV69eZShQKLVFmhiH7Alc7pU15MYf+8R7oJ1YAzwfoIixcWoOZ1ypVDLRIGOQvOmFhmIROogCOO6Z09ccnL7t9U47AJBJq9UKbnN7e1vf+ta3tL6+Hgd83N3dBa1zf38fqI5+QRzWjLqBRdRoNKKrZrfbDU7SUSqbkgUBikOVtNhygknh9fycugUQHxOG8ccgefMtECsSOyIYktnO/xHav3r1StPpVO12O5QlOEUpW1yCQYBL58KAsRGoCQDZudRPUhSV+VkMfBc5GZwmP+cAn7W1NVWrVR0dHUVju1wup+3t7YyzJhoAQXurAj7bE6I4HZK/oGMiAXI0RC/NZjPzjFJ6VCEOACqFMSmXy5l2zYgEpBQ5MwasSVDdyspKptkeY4MhhFt3KoWk9JcZRbTorN3BYKBWqxUHrZN0XtT38wynp6eB8lmzUlpXgDOkLTpAhII56A0Om2cMHEkz90Sefha1RwSu3CLXAY2by+UyBhwQsjj20C6AHK96dscEAMjl5h1g+RxoTo/ssC3sN6Jq1j7iBdasK90AkjgQ7hVqx+8Jo+/5F9bReDwOUMbvTk5OJOmnagPN9U47AMI5knm5XE7Pnj1Tp9OJnj1+AhYelUlkY3sShfCpWJyfFfC9730vogo066BIipxIXDmyX1paioEHYRDyOULBQJF8mr3piEiuAQUMnUq5L9AexhZOEoRBvoKFs7q6GigO+Sa/J7lJVEOkQ6KMsBTHCM2DgWVMyXFg7EjSuSRuETFJ+kISFZklCbyLi4sMnefj5zwnz+rJXnTYjPsivUOlMMiaRB6Ha3C5zBNnwfNBXTjlRStkcjWsOc8FobtHzYXyBnrSpcOMjd8D/0b9wr+hHEajUSSgHVHyhzXizpHfIT/l+2ml4cYahItzROfPONRqNX3wwQc6PDyMPv1QUDhKjLUbOObClXE4AVAuc8vaAvXyOThN5hpj7t+H1BMDCyXsuRNX/zA2rC3WD2uLvUX7mePj47gn6mDYn6jvWO/NZjNTs+B2BIfTarUicveW4+wrZOBOGS0+N/f9ttc77QBGo3k/EQw5LYG9Qs/DUgZmNpsFcvfNRR8UkkijUdoiGE/O5KEAYBEzuUmSBPqW0kVDwzdf/NPpNNNczSV6JJbL5XIYe5D37u5ubFoMCgZoMplkpGGgpdlspkajEad9SdlEeC6XnvHKfbN4kP4RXhIRgERubm6imMv5SYwYqJHfeQjNzzEuPMNoNAoulj4woHFqM9jc6+vrWllZCZ7XE8JsEqKjXC6X0YxzP7nc/EQw7pUmaqA5uH8iDSqQXZFB1IAzxPBiXLxNOM6tXC5rc3MzkCHqH3darEW+H3RIgSHGn59TpIWklfthzbmBxFljHKS0cpeaF/bHInXghtLnF3rm7u5OvV4vuoR6cZpHTp5ngkbj9UQyJIFR9JAngw7CUHoEwH2zvguFQqi+3Blx71TfQ//i+HA0UHpSKoNF7LDYxoFD5vlsr6Ln2fmsQqEQcw5F5fMNBcnlwIP9y3rHJsCOuLPL5XKZHMPbXO+0A5CktbW1ONgFThBU483KvCiCcBVv7b2/2WAY9ePjY33yySfRd4cTw1h00nwx1Gq1jPbcE54UlrmcE2RID/tmsxndPFnMnU5HT58+VT6f1+effx7cdj6fj/YWXtRE1evV1VWmzByDSRsBn3zvV8N9cw/SPHfgvXRcL00pPqgIrhEeHXoC5Ytz4KBgT0j9v9y9W4hsaXbn999xyYi8xD0i85zMrHO6VCVVt2TREjJuyw9i0BjjGQx68Xhkg5GHMXqxMfjJYzDI2IORwWAMA2MEIyz5YeTRYBiBjezB9uAXWcgzEmr1TV3nUnnyHpGXyEtkRsbND3F+a//3PtVd2dJYHHpDUVWZkTv2/r71rfVf//X/1kch3lEtWYvLbXd2dtTpdNTpdOKM5Tdv3oTElMUKeqvX64HA5vN5dKok6FHEp9jvxUcprQ0QcNjXwOY79kOw4OD//W+haBiT0WikjY2N4OGbzaZevnwZLRjG47EGg0HQk/DGLj2UUnkn/Lm0pAmbzWbQiVATBAZs3W2RrK9cLsfhOQAo3p2g7QhVSvvwu6OZz+fxc6jKfOZERswacnoF1Q3Bs16vZ4ri3rW0UCjEAejQYtCo7vixNcYS5wkaJ3NcXV2Nnv7b29s6OzvT0dFRdOP1YIsdQdV6fQ75NZ8h22AuyMrOzs4i++G5GBP/t0vSyZoBqzwPc4VfnE6n7xwT+4Nc73UAIFKurKzo/v5epdKyLwoSO5ApCxI0CkqZzZbHzjUajXDs0nJRwN1/9tln7ygWpLQZmaNZBhnD4/csTlD8fD6PZ2QRkNKBOOAccdCuzLm9vc1QLAQ96CMvCHmHU2994FQLFBkGTOuFH/uxH9OLFy/09a9/PcZrPp/H+bgYG04t33MHJOlZDZ9jETl/yWLlou+8pNg1irPb2dnRz/3cz6ndbmtvby/06vkiHEoxMq/pdHkACBp09jywMKFBptNpBG7QGM6dOo+0RG/VajVkpLwD7TnIELx2hGMjIK+srAQ4gLfme8keuXD+0ESuuCLDGY/HcdCR7w7nPpeXlyqVlpsRW62WqtVqZJVsmENaze5THBP1Bc8IqH342OPw/Gc8PzWJzc1NjcfLXlgET97XVWm0rgCcUEsCfXvtxAMTY+nCApy9O1rWAMEJCThtzMmcoXi8lkJWjyoPVsL19vgI3p/nBGSxjjxTRdDBxbugFOKdWT/UzPBLjB02ij3NZrOoyTzmeq8DAJMwHA5DCXN8fJw50g5OFPkZ6gbfHIYxUbiV0vMAMHgirWvb4cRJoUm/PM1ztCWlipNerxfI1gtdpGnj8ThqCC75RIXhBS2/h48L+nAWHJMOfUGg4btZ/J1OJzagbG5uhoMDedBXn4Xqxgj1hDOR0rN7PWvyOXT0idOmOLu7uxtzgZ6cbKdQKMRhNCi63PAZaz+JjfEk3WccPTji8OGEPQPhPbjYfU72iJPFpnBMPA8Ik5/d3t7q8HDZ8spblpDtIQaA4oS7Jxg5xQRIwU5AfDwTaNw5dtAwn8EZ5qWt2DN1qe3tbY1Go1AQ5Q+w8fcGYKDo4RkBBdVqNbTpnimjyKGhI2cOs5EKsAI1i+OWsnU2ngOH6u1SnCKiF3Uw3QAAIABJREFU9fjl5aX29vbijAkfS9Y0doNt847OAvB7gg97eejqSV2v1WpFv6bxeBwZt/ckYz270m9lZUWDwUDz+TxADfss8G00r3SwmF+D3+96rwMACxPEcnFxEY3C+DlqjPl8Hu0X6OH+5s2b2HDiOno3dintGe/OnEVEsQzkDmfrDpl/o8RgE0qpVNI3vvGNTLHUdw5zHy/ywdtCdbgO3ikWKT0YptfraX9/P/4Grh8azPXUFEFfvXqlWq2m2WyWOZeVtJuiM2k7VBRG6kVxAgsZmKtUcAwEEO6FWuT8/DxaA1D8Oj8/13e/+1399m//tnq9nq6vr/XNb34zvsPH3ZEq/PHV1VUcr+m2RBEcOauPv1MS8MMejKSlo8W22BHqPXNoCQAI8WLm4eGhms1mRr/NXI/H4/gOV6tgD96J0iXH7IjmHlABTvmwOcgDOfUWH0u3SYqcPDtOl4CVV/WQWYKIvS4EV+4BE4dHMCBAAbqoPREA2IvB+tvZ2YnOujxbo9HQeLzc7IUt8E7YPmIMBAcouLBr/xzZfr7A6vSQ251nttyP8ZtOpxlJttfJCHT032ITHco/xphW99QR+e686s2L2I+53usAQBTFUFgAjmpAXVKquqCgwmCRXqKakNIui0RrdrNy+URjEBhBqVSKpk1S9uSvbrcbhdT7+/vMQeR+P54P9O2OhDoA6h2M1B0ohsn4UFQDzTmXC3pxHTaIC3oNY8RRsGj5brhjnD/cv/fF8aAKRYAzhSYizWbhurIItLVYLNTv9zUajfSd73wnaDHPgHyPhpQqsRAFeIbi2RAolOcETbGIUeywz8BrGThA793Ds7hmHKUMi1paLtTBYJDJ7OB5He27U4HOoBbkbQ7gfuHEWQdOyzEe2JOrTFy+7FnibDbT8fFx2CS8Pp8DzAB0PMg7LUpmjtNvtVrRzZLPedb2eevM6S+AxurqaqiSUAZRZKd2wK5wfILv6XB070IBVwo5n07AowboaJ014gDL1WncbzAYaGtrK9aTvzOfZdz4d/5n1LbYJ4QtM75kVS63fsz1XgcAjAtETUAYDofhPKXlJHnbXORvUtqHhclmL8DDw0PsTjw7O4s00Ist0BIsdO6HkfA5nAOFORpdnZ2dxffCyeKc2HhEr3wmEGkbDhpHgfGjkIBTBKGR0uNQCGq+wYbf47C8rbOUPbyFbIafOz9O1054cO7t3CmOgnnwdg6k3sXisncQyM/v5c7F9d9c3K9arardbqtQKETHRA983IP3IJvyjNALkMzxZDLR5uam5vN55lhQai3MvdeHmA8yA1Q8CAa8kAtVgiPzIIqTmM/n0QrAgxljhNoJlEthkGeFz6ZNN7Qewcb3HDjNdH19HbbhlAzrq1AoREdP5Mae1XA/slIfU9YC7+trzcUIjCsUCij49vZW+/v7MY+sz2azGecjcA9shtpPubxsf0GG69SNz4vTMvP5PFNk5v9p2+E1Jf4b/+Dj0e/3IyiTobG/huDEM0GhkS36OGH7tNaoVCpRm/JaxGOv9zoA4MAWi4X29/ej8IKjGY1G2t7e1nS6PJxlPF42WHr16lXowHF6Ulos4dhAdPZEVrT6OEfSKhwPaBeHBBInGsPdX19fR4dS39Thzk9K++T0+/2M3I0GZCwWb/WAUXsPF4p5i8UiNpJJCkN3RQgIkft6Gw03/Ol0mhlrpKdwti4RxPAcuUC1sOhBLRg944qzx8mwD6FerwfvK6VFeXrUg1ZBx3D+LHQ6rcILk2Z7KwaeB8eJVA80x4E/njVAsTHejBXjyXvzHXyfOyYunAk/g6cn46UYyMJnTZAFO2XB2Q6clcEF6CHoAQBc+prvBeVBCLt3xw7lSi8gty9H8Tj9/Du7PRMgfPc4n6NJXrPZjE1qZD7YHWuf9y6Xy+r1epLSnldeJHYpNff2XcesS39+5pd/O73kxXkfO99EyPt50ZcgCChk7UHbEqg9+5Gkdrut6XSqzc3NOCAHX4cS0Cm6L7re6wBQKpXU7XaDcsAp1+t1ffDBB6EMgtN0aoUGSxh7tVqNnZek9SsrK3r16lUYRN7BU0z0hlikpDhhKV3IoBI/+AVlEIvCi1eSMsfZOafOpjCcoG/99kXGsxMMut2uvvzlL6vf7+v8/Fynp6exqNh5y8I7PDwMBzSbLbet49xcUuYLuFqtxs5rKc2AoCIkRcGLYEXTq7yEE2UJ78CmPwy7UEg7qjJutFOez+caDAaZjIgAjvqJ/k6OnMjE8j3TXV68vr4e2SaBBoRXq9XU7XYziigyvtlspv39/XAg1E08JWeOQdd8L/Ql95IU3VFxDO4kyQABLPDF+Z5Nng2BMtld69kCYgfQNuiaDIn3uLu7C9rRm475RjjWIPNPPQREjw6flg3Qe/5ZSZl59uDg6J0i/sXFRSjvKpWKvvSlL0laHlrvRXlABzUV/z5AhKTYc+TjxXPSspye/lyAVYInVKHX0QAHtOagPTVjzVr3TZu+rwIbJMDQrBHakbrPY6/3OgCABBuNhk5OTsLpsFFpd3dX/X4/uNBOp6Nnz55pPB7rs88+08uXL4O/pl/N8+fPo2kTOv67u7uYeBajlOqJnfckwmJUrizxE5jyhWLQlRfxvO0A93fOv9PpxMKljkFBjAuE4vsFzs7Ooi8M74Phgvy4B89CSt9oNHR/fx8ZlRdaMXCcFmgQx0pdxGsz/OPG7JSMlCqFyJBwcGx5J3ODy+be7XZbkuIcg36/r2q1qvPz81CNOSLje6HZnId3GsApFNCdpNhTgBSZTGt9fV21Wk3z+TyOs4QmkJayTN8jwjtLqdgAio8Tqyh4MgfYkAMRnL+fscBFUzMPOI4k86AG++O9UE3RN4n6wYsXL6LFiBebCZCOsvPBAdnteDyOjV98xpvaIT0GGHBOMs4Wp4xtcHYzAXs8Huu73/1u3Gt7ezsCNB1hcZYcESktARIO1E+EY90RAMbjcWQWrnrycfa2DAT7tbU1tdvtTK0IoQEgCb/n2TtjRAY3Ho+j7xb7FwBWUFU/FBvBUE+gk19fX1er1YqFfXV1pf39/ejz72oVFrcXdqbTZX8QqBRHAq6fd8TCwkKvXigUIhPBgEnnJGXQp1fmQQJOf2BkHEIPzQCnd3Jyop/6qZ8Kw+aZNzY24gBwvxcFJw6WIAtCTYHMkgwIyqJcXvZFkpYtlDE8HC+Ly9E4z1ooFEKKliRJOC8yJG+5QBBwjjdfPJtM0h3CIFw2oFF4ns/TfjrdbjdAgAdTip9QSi6Ng2eFosvLGXlWR7SgXwqw5XI5erNjO8ybS0vp8eTO1umhvL1Xq1UNh8NY+DhjKaUcQN4UQT9PleNFWt7XaSvshs9iQwRK7P/i4iKzac/3HBC88t+PM3ckLCky1dlseRQo6jsHWMw5VJrbd57aKJfLcegSdi4pTqgbj8fa2toKvf/JyUmm3sF4sN7ZWQ24AYgwluVyOTYGkiUCrpgrz7qklHosFAqqVqu6vr5Wp9PR9vZ27EHChwD+EBCwBpkXxgM5tK8dBwU/yPVeBwAUCwQAnIy0XMR7e3sZNIziZm9vT/1+P4Ny+v2+rq+vYwcrtAsqB6Ra3BtkcXx8LCnttX95eanj4+NI9XD2OCwWHQuXaOx9QnBmUCfb29va2trKNOYim/jmN7+ZkVFCwbDApJTaIIX04pMvJBAMi9uNDhoFyornLhSWuzBrtVocQIFTxbjb7XZQMcPhUJ1OR9fX1+GAHdnnJXQgKuYP2ofn4sg8dlmCgEjLq9Wqfvqnf1rD4VDf+ta34veMMeisWq3GhjDsimfhLAhvyub1EtDeZDLR4eFhKGg4LwKpI6iV/768vAwFmBc//cI5Q7t410zp3VOynCPHRvgdwYdWJQRYioz5bNQpC1RlvI9vZoMKGQwGYScED+6Jk2S94RClNHiyxlxI4VkydSBsmqD1vThtwFOxWNTW1pYODg5UKpVCjMH4kc3ynHTZ9OwWMQY/IyiRHVSrVfV6vWgdc3t7Gwf8+HuQWTCWZCDD4TCyGdRg0GBQX7w3dkdWWqvVItug7uj10M+bj8de73UAwKlCYyCl4yg1ikKkkzc3Nzo/P9fx8XFsJPKGbhgLaT+SUHfIDC5Oi6gO74dx39zcRGsB9MRIMQkwGBEpMKiZoMNnQdjj8XJzGIsHR8f7o12WFI28WPzQXNA+btyk0DQma7Va6vf7gSQp7LKDlPuCOCVFwezy8jK46m63G1wxtBM0AkEQrthlmFw4RN/wNJ1OMxTI6upqOPFSqRROD2dyfX0d7XRdcw6Nx2YbePH5fJ5x3KTfBCsCkiNlAiy/cxWRlAIGrzdIynwGW/agzeLmuXHYHLvpNSd+7/MK4nPU2el0lCSJer2ebm9vQxkFVePPwtjOZrMIVNTC6MDpNQmnMKH/XP5L3cPfn6AP0gVRf6/1znojQ3LVEzbgWQfv9PLlS11dXYVN8pycwet1GBc9cA+Ct9ObrHV+hvqGwDaZTGL/AffkpD+yKDqEjsfL3dtknZwOxjnn2Ob5+bmGw2HMPwECySeZmNNr2AfP+ENTBC4Wi5mt2CA+5+Xb7XY4rPPzc11eXgaSd5oC3pHiMYXafDETxycpEEGlUondoPf397EpA8SK+kLKHnqCU3B5IEUfjGs+Tw+FuLi40HA41GQyCcMAXfA8LCSP9hgAzhEjgOaAjoL7ppcQ741DxcmhAZfSHa9wklKqcz8+Pla1Wg31gRfqnKsvFArBazIXkjJqGebJ2y3P58u9CRzZiAMm2C4WCx0eHkbrbOoNBHTUMcjlaATIBSVBDYhAfXBwEO8LCuZi3tw+fOOba9t9DPK7VRl7z6hQijBmZL29Xi+cAO/P/gXoPSntG8QZz9AbBDD+liIugQMQwBizNuDyccw0JMRepOWOd8agWCyq1+vp8vIyaCvUWAAJLzrzfcw/8wTy97Xo5254NkTLd352dHQUTjvPg39eTQSBCGPgNKLbidfBGBPAjztc1gZzcXd3p+Pj40xNjXUym81Cbk0t4erqKigs5oTaEBQyz8jGV2xfSmtKPxQ1AC+wEhEnk0n0eMF50/1vNBqFLlhSLCx46k6no9XV1ejlIWXTYb6TRePtA0ajkY6Pj0ORUCgUMqkcvGWpVIrunSx8+DqoFtrDzmazaLF7f38fCJJ+//wehQ+F6ru7u6C+HJVQECyVSsHDQhXBzXJsHggE2oPAhVNmkxVO1dsls0+hUqlEj3pHe4xrnvcGZVOkZVFDW0FVMH/FYjECIgtha2srxonARtYD8mMBMLdra2vRZI0gSEDmGWjY5QvJ31vKNraTFLUhTqHj4KL5fHl6FPUCeG4/R8HpEcbVFSSgZegSuo+ywRA7yaNV6EPWA4XcyWQSSJRAgm07F+5ZLk4RQEGNLd93ngyNXjXYLHbCGiVQuHPjYn498yQoUMPx4IudMT+ummH+GUuOSWVfBuuaFhOVSkXtdjsaN3qRmACEGov3AlzxTNQeva6CaATFmQMeXzMrKyvq9Xra29uTlLY+98Iz9uLvJimOt/Ts84cmAGA0nIGJU6KfDxQNztr7m0Dl8Hdw58gjQUFIDzc2NqKzIhfGC+LxBQod5SiQs08xQgwBagYHtLGxEVQOi5gFhwPvdDoheaU3D4bGhVMl3axWq6F4gEZhcTrSPD09jTMVTk9PM8FESncou9QUhw6lhKP14pOrplhEvpA4shLaAcfCGEppwY/6Ag5+Pp/r2bNnkRVSB4F2YiF5C18pu0M4X5gnkMNLk215QdFrFTgdHCWcNYiVugjPwWcYL5AhmQE6dwCOy/1WV1cjoLx+/TqcZqGw3IT15MkT3dzcZOpL0KAEN6geHN1isYiOslzMNYELKbCkjPOaTqchTeZ9aMtCjx3aY8CzU7R3yTRFXgIm683nH6RcqaQN/cbjcUbazbz6OmM+vHBeKpVCiOBnLvvcAlDIHMiKAEXUnvg97+D0JfdhzfB3Ps7S0mGTwfGuAIPFYqHhcKhWq5UBAQQuDveRlmKNlZWVqEfN5+n+Ct9r80XXex0AJMVOUTbswMezNwCKxQtJTACTniRJqFguLi6C68aZ0n2ThYOzw5m4E5TSE62kNEsBxRNUiNJMyNOnT3V0dBQUCwtWSp2zI4STkxPV6/VAA8g7SftJG0HP0DZ0YXx4eIhzBjDoZrMZ74FCBycExYATZ48F0ktaSp+ensYC8uKnIzQCEpkI40PghmeW0lYQeXTN+EHjjcdj7e3t6dmzZ9Ewz2W3FOTG43HQN3ClOCtJgdz4vqurq3Bsl5eXmTnAAbCwcT5IiunFQy3l6uoqqLudnZ3IaHgXz8aoQzitRdDg/5ljHIbvaeFIyXq9HidfOY3nQgfeATUJFBoST96d+f/www9VqVR0fHys7373u1Fnw7bZAexcepIk8Qzr6+sx9k6xYh+uLru4uMjsc3C74n0IQvzehSCOhqlf8TnGj+/3RoIAOrIh/sYpOi9AY+MUzn1DnW/KdOUga9yBArUXbJVxoU45Ho/jqFPAJoFbWlJuPDtBzltsQPU99nqvAwAREiQ5m820tbUVP5dSeqhWq4WDYSAwWi50sixedtWxUNDTQlWAUkBSBAaQGrSM1x9A+F7AI4tZX1/PUCYYE+9B2ohh4zS73a7m83nIDJvNZiw2ngeqBv6VBUQPJRwNBg1y4O9wEhTDcDi8Nz2OcHQg9E6no+FwGONEURtpKFkPY0Aq7fMLnYHD9KyKQjvBfm9vLxYFaB7UhlMfj8fqdruByukNw3ux6KARQZggTkmhFvJ6EygLO4Cjn06ncfY0+y9A9PCzznkTlLFXzz6cu8eWcXBknlCaZAPQh9wHECSlHSahIPxe3r6EMw+m06nevHkTtBN/e3l5maFosG+OlQSNMr8o8vKcOhnR3d1dyDNHo1G0aKAtOM97c3MTGwOhn5w+89YNXhvgu/g3NTFH5YyH03D8rVPCzIMfCu+N78h+2aVOQZ2A6Q6ZYENd4erqKnbz8x4ofHgfsj8oSVdQeW3Bx/ix13sdAHgpnJOkQL2SAtVDbXBMH+iCApovCpQLBAFSRHZwgqZxrGtrazo+Pg6ukAVJnYBg4NI7UjfSUTdIetf753hXPotTZqE1m81AyrPZLLMTF/6Z8SBtJ7BJCtQhpY3R+L68msXfn3/u7pa98OkeinpmfX0904IBqqbZbIZSi+9j56Jr/71uAP0FXUFAPj8/j344pM3lcjlaRVxcXETAIBskcOMcCSxuSzxDkiQ6Pz+PWg79f46Pj+NvfEGR2hNkCTLb29uSFHYEreZZngcpqCLfn4A8152S2z7I7+rqSqury5PGQJyeQTGP3BMhAIiVz5ydnQXIAH16zcbf3YGC24ArkyaTiVqtlra3t/UjP/Ij+oM/+IOgOmnDIaUKKHoU4ewBPYAgz5bm8+X+l0ajodFolJF/OwPA2LJWoGjymR/zQoYFwq9U0g1ntKDg+wg+XhgnKLvIwnt7udII55+nh9zPMT7Pnz8PYQCAwmXQLs5AvICde5uWL7re6wBAGiQpdLvI2jxtpmDCBPtJXShqQLy+cQenSPEFZ+6yS98EAmrkODyKjsViMSr3Uiqzw9ChsEib/fg32hIQMFiwNPqq1WrRL50F6CoeUkHGieDCc1CPAD15hoEzdakdAY4gB1o9Pz+PhY8clO8jGODkoJc8oDjy9GIe4+RzTiCZz+fR+C8vvWSxENChxmh34TuhmcO8tBKgQDdUMgIoB4KH1zncOXsm6p0/afvsSHYymWQOeZey59FCXzBGjA3ZgPPW0Dvsy2DHNE6A9wMUISsdj8fROgA0yRGroFv2LzgVAnAC6bp94fz6/b6SJNGzZ8/0Mz/zM7Ej34/eZD16sMK23SF6BsPYk03SBoFsx9cxc0Pm6naNPeM0mXtsgjnodrsaDAbhKyRl6o/MC7SOMwh8p2djrEHfOQ36z68Jxpyf1+t17ezshLKJTNMzXy9++9/+UBSBpeUmnXa7HZswoFnyOyC9lwzogF4xFMwwIKI2vD3nmFar1eDxoSDo0TGZTOL3IF6cLegAZQvIWEq7kYI04A9xyvCCqAv4NwEOYwJ9OL+Jc/XjKaVsC1lJscfA2+mihHAHjnOh+Mjzz+fzcGa+0xe05qiS9tIEF3f+jiy9OMxC9Ja80D5s1SeFl9IWHS6HZW4bjYZqtVqmpTHj2263I0tAPeFgwlNqT9vdofr7cO/RaBQb31B+5GtGvBeBCkkxtsYce0Gdvkxkf+12O35erVaD+314eMicHewCiN3dXU2n00CzFOHfvHmjly9fhnNfWVmJ7wMswXmTKbdarUwgHQ6H74gB+Dz1Lp6L+SaIesaIQ8Zp+br2U/rokcXaYx2xR4d9QPTS4bnI3HHQZE04ZGicarUagWixWGhvby+A32KxiCCAzYHCee7ZbBZqLYI9dkUG7OvSgwDvx/1ub2/jDGuC82effRabwVAzeTB1yftfSABIkuQ/lvTvS1pI+rqkvyHpqaTfktSW9M8k/buLxeIhSZKKpN+U9DOSziT99cVi8fr73b9YLGpnZ0df/vKXo1vn4eFhoEs4SVpEN5vNkMoRiTlBrFAoRAX+7OxMg8EgnDvGz1Z/SYG0MUAWHs7cBxgHhQOkvQAOFofqXB0oDucwn6eFPhYw98VZO42D84TeQQ/sUkinn/ILFMeFASVJop2dnVj8ZAv8LUGQsfQMh9+xuOFW/f0cxRFsKdiRGYGAUAy5SgNUTVaI4wZRSYoW294OnOwwT8kxH67soFWGd5t0xQl2wKIGUZMt8iwEEIIu6J7597nAIfFMnNfLc/G9FMM5rIW5IGgz79zHm4whnsDWOVgJrp7xdaCAXbM2mEOoOd4POpVnvbm50R/+4R+qWCzq008/jeIywRi7pCANhQn3n2+P4UCKnfIXFxcRiKkp1Ot1ra2tZVRH0D+sB6cKafLo/aVc9cSFHUFTYhOMRf5ZfR8QGb0HQNaWXx4Y8S9XV1chg0b1Vi6X429x8jw7doWNPvb6MweAJEl2JP1Hkn58sVjcJUnyDyT9oqS/Kum/XSwWv5UkyX8v6W9K+rtv/32xWCw+TpLkFyX915L++hd8hy4uLvT1r389JuD4+DjDcYLu2cpPkdUr/OPxOPYAgB4c4bG5rNls6vr6OnhWkMLq6qo2NzejC6S0lG8eHx/HhPnh5qR+TnVg2Hl0PhgMMsiWTINFh1JHWkrILi8vI+VfW1tTr9dTr9fTcDgMh8CF8RUKhXB+cJSgJBw4jc+8JfHq6mrs6uW5vQUGSpvV1dUIyjgu6hv+PL5Qy+VyPLPvHWBccNiMGfp0AozTTWQbqDxQB8EzM6Y4fe9RBK1Giu1j4HUUlx+itKBpGP2foPl4b3fujvoI7vSS4e8YX2gi5gZECW3BfSaT9FxZiq+VSkW9Xi+Q92AwCIqn0Wjo4OAg5NDIjMkA2XTJvQnqvDO75+fzeWRoZKGz2bLD59nZmYbDYaYwzQUNJCkoxMlkEns7UJ7h2BkPvgPBh6v1CITYJE6XNeZonc6g1DHIflFDjcdjnZycxHr1zMbvA93m9iil2YrThswL6xngg+QcQEG7G+pa2OhoNFK73c7Mg1NbkjL1Nuolj73+vBRQSdJqkiQTSWuSjiT9vKR/5+3vf0PSf65lAPiFt/8tSf9Q0t9JkiRZONmYuxaLhU5PT6NBGdHbkSIqDmgQqATSJAxud3dXpVJJR0dHmfNJ6diIUcMDl8vlzBm7nCEAekE7juNApeToACRMlOZ5cejw0D6hjhTceVJkIlWFWwUNSanWHXSJc3GHNp/PM50O3VhBr5Ki0yYnqYHQQaMsBM6MlZRZKI4KSUsJljwbDoSaCAEPJ8zv6VI6Hi9bZTiNxoKHbpIUtBELCp7fNxNCZfhmOYIl1A7Byd8L595qtcLJeRBj/kBizKUrsPzf0CtOgdBaBEoQh4YAAucL4MDWVlZWtLW1pR/90R/N7JBGogmdASJHXYNSan19PZq/8b7YGIECULS7u6vRaBSbp7g39kOwwAbYeAjSZ+8AQgtUe4eHh3EWggcZxtfrbtjjw8NDSLsJ1Hl7dJTN2AMGd3Z2tLm5GTtxv/Od72hvby/WG+/ghdbvdU8uL+hubGxod3dXi8VCR0dHkhRzxn3zhXzPMDg2FVk2NT9YgOl0Gn3LABaPlYL+mQPAYrE4SJLkv5G0J+lO0v8u6Z9KulwsFozEvqSdt/+9I+nN27+dJkkylNSRNPD7Jknyy5J+WUrlfQwik4yxlUolnZycBEoiEvK7RqMRxjCdLk/loR8HaTzOESeGJhwDgS6h5XSpVAqppTs7NjehRCJIOVqRFEgD/s57yU+ny1YR9A2/vb3NnMx0f3+f2XUM+vGzb/lsu92OFs/wyI76oamcRkJxwX1BlGQ3fiA3G9BQHsE/8gzuDBy5UmBn/KB7eA7uxa5c5kFSZjMd9sH7etrLpjzekbEncPGMUlpA5PMEVjhmVEXws3mKjeejXgGgALAwTi5TzHPTHkC9wPp2PQTNQdAGRPBZAhgURK1W09bWlsrlctTM2ETl30EQ9Z5YOFTPVG9vbwNUAVrG43FQLmSWFIWhpbwwzm51gjRO3DccOkfuWadTgdA6OGacMI4ZO2C+3CacDpXSViDUSPx4UG+vjr3e3d1lAiFyUL7fLy9CE/j8wCgp7YWFHWH7PCvv8vDwkKlN+HtQiwMY52mpL7r+PBRQS0tU/6GkS0m/LemvfM5HmYXP0ya9g/4Xi8WvSfo1SSqXy4vF2w56b3+XoRVI6zAUmsI56kBaeHp6GumdOwLX1IKO/KAMJmgymURqRuM0HBuG32q14mQmnAiGTB0gj+pJv+lOubm5GTSWyzFxIr6Zx4uRaM1B/6SQ8PM4Nz/OkA077XY7etxj6CxIOPRSqRSN9fi7vPMFhfb7/aAMSLOfPn0aqhCcI1TK+fm5tra2QuI3nU70WW8bAAAgAElEQVSD8qG9x5s3b95JwXl3SZFOc+FU4XUJ0lBdTrOQJQIioBRA5JeXl/roo49UKBR0dHQUPLG3TWAuyCLcvhhvnDeOi/lCHYPjxXkxPtgn98HmsEt2sQMsKGRja1BgbiPsX7m+vs4ok/z+ZJpSKj8G8LjUEbXM2tpaFLY9my6VSlFbwqa8qRqZhtcAeF+XNLLOGdPZbBZnZvhuY/6WbB2+3IuyvD9KqE8//VQ/8RM/odFoFCxBpVIJypJ1A5WMYODk5CRoTwI7ABUQw1GWOHzfrOVryLMm3pUAynuNx+PwMUhUCeJus4+9/jwU0L8q6dVisehLUpIk/7Okf0VSM0mS0tssYFfS4dvP70v6QNJ+kiQlSQ1J59/vC9gQsbKyklHhcI3H41CvTCbLPijb29vhIA8ODoI6YWGura2pVqvFTkzvtQGFc3l5GcUkegCBBCi4lUrpLtf5fB50E0Unetq7HIxJL5fL8XnQhTuwRqMRNAAoEufgEtbxeBx6eOSkfA+pMKk+dBVqKS86gTB5dhyLFxjZaOfSPt6djCNJEm1ubqpQWG6Mc322b56h9a5z2OPxWEdHR0FP4bidmiFjQY3BQioWizE+jLEHcJwaNRJH3/P5PGgM7skiBekjc+S+SIy9ECopHJ7z/Th03gEECTVF9gbNCI2HzNBrIl4893cjq0JN9Sd/8iexGdHrEahUCHgAGNAzP5vP56rVakHTkIWSjWCXZOPYCUeFJkmibrerXq+ns7OzzJGNjDvBB2DlmUI+s0HR5BQJ2WmhUNDW1lbG2Q+Hw/ALDu64l3Pp8/k8zhSZz9PznxFLcIIZ402mdX19nVExeR0Luy8UCpmCPSq1SqUSG+98syu1Oa+zLRaLTIEb8Fqv13V3dxfUENkez/D/OwWkJfXzLydJsqYlBfSXJf2/kv4vSf+mlkqgX5L0j95+/nfe/v/vvf39//n9+H9pOclf+cpX9Pz5c11dXanf72tvby+zm5eXdakXVA3pq5TSBSAFqB0cI8Z1cHAQBUg2CuH8vSjJJKFuIAB5JPZUzSM6DsDbJONIjo+PM84ZLh4ERxM25x0pIhEwJQV/DJoHObuyBITiG9q8MAoPT+YCPUThk5QepI/ShOAImmdsHCGR3UipIyfoVCqV2HfgC79UKoW8rlarhX4fmR30AM9O8JCU4U3JGlicvBfjAg2CA3KFEgGZHk5IMHk3R+t8nnu3Wi31er1wFkdHRzEOnLjl1Bn/7/ZBoIIuoF5SKqX95a+vr3V5eRnAqdVq6fT0NN6DjW8EIYAIh8bTzoLv4AAk3gsAg+puNpvF+Rugej+XF8knqN/bJrAmCUasKd4bB8u7YgvQN9Bi1PwobnsLCK+BMd5OtbEO6fhLQJUU1BnffXZ2prOzs/At+Bwp3dGNjfR6PVWr1fALPHe+iItwwOksbAnnj90cHBxoMpnEgVDeZZd1/xcSABaLxe8nSfIPtZR6TiX9oZbUzf8i6beSJPnbb3/2997+yd+T9D8mSfKplsj/F7/oO9gR5wgYY3fnurGxEX1YxuNxoCSQOXp+Ij5R1e8BF4jz8lSY72Unnv+dFxW9VTOac98MQpbBBGPAq6urkd1cXl7GzzY2NvSlL31J9Xpd1WpV3/72t3VycvKOxrzZbKrVasWxiJ9XTPKA5Kk3CxQlD45mfX09kDaLj3djTCSFHtnrCwSGPKfLwvD/l9LCKcV0FhRqLueW2YfBdzP+/G2eZ+dv+S4u53J5H9JwEKc/hz8ziJl5cITJ5VkAdSGAQ61W08uXL8MmaR/ghXbu4YVGz5b4N++JfQFAcPCABnolEWAI/JNJurcDihEqjPHNUyz1el3b29vRaReHA712f3+vFy9eSFIEV7IpOoYWCgXt7u4GrYbE9fj4OEN3cTFPDqZ4HpRy9IiiiSDOlvek2O70HEXT2WwWfYkcMOGsyRqgxPAtThl7sB6Px6Hf93oT9oOfwW7YKMbz8Hzci75enycl9nXmQfgx159LBbRYLH5F0q/kfvxS0r/0OZ+9l/TXfsD767PPPpOUasN7vV44yuvr61A3FAqFqIKDShhwFjQpFtveQbjS0pi8nQMDC+rs9Xo6ODiI58Kxc3lg2NjYiIMhQAtE8uFwmOn70Wq1AoVJ6aKWlpvgvvrVr2p7ezs2YqFcwTGQUUhSt9sNJRQKBhCpS/4+T4ZG6kuwc4Mmw8GhML6OCDFUVxe5s/cxw0GB3nHSkuJwFhYIGQvFVwq7IFk6PEqKTCBJkncCtZTdeEONxQvKLnf0eZYUmQf2sb+/n3GyBBFP/31BLhaLoB1RgoAg2f3sKJsxYQ7L5bK63a5KpWWfpaurq7Al1EDeKsM5eu+u6rp6nBHUATZ1c3Oj/f39sHvGGzFBrVZTqbTsWIu4AJnqZDKJg3qYC2yE7IQs0IUR0+myuy49pXDW1EO83QHrE2d7cnKSCQ4U78lAuaBwsTMuEDRU3feyGcQojB92IaWFalR69/f3evnypXq9XgRAPsfeC3fkAEPskGcpFos6PDwMW8CWkJzip8ggAGKPvd7rncCz2Ux//Md/HGgYPS3GiBHjRHBaTBJZA/UDT9dOTk5C+cLg4gxAwxQIR6ORDg4OYhLzfVAwNA8ILDhvP+Cbn/gZz4GTZDcxCgraNbOw2u22bm5u4qSh4+NjnZ2dxWLCQaM2wok5h8y+B9JhMh0WDQbvdAPppiNgnhXkiVNHIeIIG2fH8/nCBKHjPEn7d3d3M5QMrQ+gANmn4PUIl0RCa/F+IHyK4lLq9NrtdjS2o5DKOBCM6EmEiiOv/CCbwkk72mPMvFe+S4CRs7IhUVJIi3F60+lUu7u7qtfr2tzc1HA4VL/fjzEART958iQkjXt7e7GBCtt2SaWrqshyoQ6pdeHEAQzsUj05OVGpVIoutRR8sW0oprW1tQi20HSc3sUh7U7luX24vNZtJU9xMI+ocpwG5LOMIfdxYYAHG3btc8/xeBznSayvr2fOqGDcuZ48eaKnT5+qVCrpG9/4RtTlCL5OQXlWjO/Cx7ic1t+xUEjPgeBvOJPCzwm+uLjQY673OgAsFouMTp9UDtQkLfuuICVD+ikppFGkshSISA9dHupRnoUKyoALzlfX2T4vpagd44JLBHljKNQcKDBihPmggHOYz+d69epVFAZRhlAIv7m5iQNqSB2hAqAe/LAVSbGApXQ3shd9/bMYnC8aR+9ra2vRVkJSRuZHgZf6DO+bV8Xg7J36wJBRPJBqV6tVvX79WlKKvLANglMesYHqfVfrYDDI8PpQeyBm5sppM8aLi4DphVDGB+WZywWxkdlsFtw5mQvIjr0O7Jhm3JFygsy3t7fjXtyDDJOdxBsbG7H5jUIr3TmZVwqhIGyyBzKKPNXoxWLGnKyAug4UCnYMBcs4Uk8ajUZ68eJFtCehnuP7XVDOMBe+69uDJ89HoAIIkD1i1/gNpxAZY+zW1Tz4D9SF02l6prFTfvwtUnCXlBOAUFtJCrqPteQ2y8V7Or/P+PDf2DD2gvP/Qa73OgCsrKzoa1/7mk5OTnR6eho0EMbCACIz6/V6arfbwQe2Wq1QwLDAQSo4ddAVTtMdKI5rY2NDzWYzClkUtUBs7MT1YHJ1daVOpxMonMM78qkfCMONgMXIGNzf3wdfTKdPd9oU0Hzhgiyk7FbzvOzPgw3GlufoJWWQnbQs8rFZilYO/nsoFimr487LYHnGPLXE35P6U7TntLUnT56E83GU7dQGkrputxuyVdp7wHnzjhSJeR5QGQ7PG/j5hihP7XlHKSubdCqN55jP56EYcW6Y9tcg983NTZVKpcyxm2QgBHACEeAHRdjNzY263a5qtZrOz881mUwisyEQ+y5WngWE6YEL23Y7Y0c6wRr5J1kDTpkCKzUcBxQUbnHmZKkAAi+qMp7r6+vqdrvhJJE456W3ZLQANb6XQOc1nzzFwvPzXDh1F0tQF+Maj8caDAaB8vMqMbIf7NxPOiNjz4+fZ6FJkkRxH+fP2PI7D4SPud7rAMDivbi4ULFYVKPRUK/X0/7+vlqtliQF2oLOYRMQ3DsRllO4nI9zB+fR1X/XaDSiARX/II3DUUHX4IRAZ+jqcbDu5DzjgO8DxXsbCi8w4Wj5XvTMn3zyiSqV5aEeNzc3cToasju+n2MPCYBIyPg92QK7f1n8UAvIId1J4yi8tbFTH1L23GEWW7G4bHKF4VM0BtHirO/v7zUajaLlx3Q61bNnz7S5uamrqyudnZ3F8Zm+MLkHVAjPhQ0wR2SDIGGQvXckldKDa7Avxpu5gV8GQZOtQm1xX69N5IvP3tuKz0HZHB0dxe+5vCCIvXs7h4ODAx0cHKjRaMRueeeIocoYG/6OnkrYgMswsRU/V0FKC5asI97LwZpvssJ+Qfk8A0Vcf0/PPAikFNY98PohO/nxdUcN1eKnkfn3kdH5c/MZqCjWMFkmQYP16/ctFApR64NdYM7zdJYLNHgP36iJzeb9F7TiD8L/S+95AHh4eNDv//7vazQaxeJEbkh0lxRpJqgnSZY96m9vb3VychIbVYju+QmX0rQRdZBLHAlADD4FTlAe2YBfjh496vMekoJ7xtk5mmKzkdc2yuVyHLpNNtHr9bS6uqpWqxUpqKfOFNtYiCxqNrmUSstWGmw+I/th674bYq1Wi2I0iJm9E2RO8/nyNDHSa+8y6vJP0AvtpZ88eaLDw8N4ziRJoq+/tyumod/p6Wm0AGCRMY9sSHJniONnbhlX5oe/xUl5hslFsbter4fED/Tq9Y16vR4OlIyLhe+2x5zyPThk37DE+/kYE+xwyJPJJDb+jcfjTNEXCaJr6iWFDPPzngnbdAkov4OK9M/mC/ysNZfxci+CdL7gzfczjmQdOFZvTvjw8KCTk5M4d9kbvknpwegUtz3AODomCwQkTafpoTFOifL7u7u7oNA8q4OZYOz5TgIEGy23trbU7/c1GAxCcQSt62MJMEP4AI1HAELRxdnmHBhPBuz04hdd73UA8GiKQZ6enkbrXYIBaQ/qDFJYKe2PXygUMiiOvyHNo6gJ7+mSRueUidAUdUD6OBWXgnK5M/FUs1KpRCaTJEmciiSlvCVIncAFT03AoWBHduI7fQuF5cYj5HpQAyB4kB1pOUgJHpZ3cv11nh7w9/MshzHyLIx7OnJFk97pdKKeQCbCIpvNZjo4OFCtVlOhUAgqjw1pzJGjMOyBMXdOnXf05/a02/lZuHWv57AL/P7+PsaWeZnP52o0GpGVoM65vb2NTrFuF1J6XGa32w07azabYbtJkrxz+Dc25rUqr0v4IS8EBgIM+xawQzI4alJQbujrkYB6li0pc0AKjok5xpm6PJU1yztgs3l0zr+duuFdAXpSuqGQ5+dyObDfDz+S/y7sfGtrKwAkGQqb/vLSSsYfQJCXBq+treni4iIAVr1ejzOU3dn7GR3MPTVB/AIND1kTUNJsRiNQQCHlwe33u97rACApqJaHh4d3DlJ35QuVe9JTJgeEjWYYLllKi2uSor0B6RwDvbm5qWKxGLuDmWQWrU8IjgHnC/+HEmJ9fT100aT2nGjlh2Lki7GgRC9cskCQ8dVqtSgI55Ubi8UiHAhSVxQd/AO/jkyPugWoXUp3OVKUI6Ul6ECjSGmQZWGAvEH+zA9/PxwO1Wg0Mry6Zx+edeD4eU6AgKfSLBj+YbzytAHPiDNzWSfZHpkhDqzf72eoESgJrwew47bVaoVUFfUM44wjxMFgt6D3TqcTP2cd4FidHmDBVyqV0OcfHh6q0Wio0+nE2PFsqJloQcEhMYAtBBNeECVAra6uhvy0UCjEsY71el0ffvih1tbWdHp6qoODgxBD4KCbzWZkYq7WwuFyke3g1Mk6eB7eF+DGBjOKztgctlupVALZ4yjJRGazWeYYUPwJc0nAcHtyqs9BGeo36oQ478FgEGPKd3MvnouMnczPaSzskWBEywiezzewMUZ50cr3ut7rAICTgMZAjw4146hbUqTvpMSc3oVkDSORFEbIfWkR4b1DoJb4u0KhEN8hKZrTsZCI/u12OzIDCleoPCQFf4r6xOkJKXtsIehisVhE0CDgPTw8hAyTTEBKC7tkPNBhzWZTzWZTZ2dnsdj97F5QI03XmANSWRAiqg+cCQvOOVf+7Q7cU34Qo7REwNQsMOLPo2BAq6BXDxBS2jqAxUp6DpJmYZGRSFkpJ4sIp+fgAOSPQsU3Fu3u7qpSqejw8FDn5+e6vr4OZwItSS2DRe6omMNavMEbDoYARN2J+XdK0tEh80exl0NcyEAcqd7d3Wlzc1PtdjtsEadKtghYQpXD2sMeOawJIcJoNAq7dyQLCKKfFHPhjj9PjbEHwZEtwYvg71kr9gWomc+XGzLxByB8Bx5OFfGu3J/A5LvW3ebchgBHTkW53NYBC4CLrMZrC9wP6snXO+DFG/sVi8X4HfJxST8cMlAp3XaOHBQjRQEBTQBicEoIFQXokMmp1+vR/hb0VavVou20pCj8npycxESxIDqdTvQTgtcElW5sbKjT6Wg0GsU/8/k8tNpkFyxujCtPGfHuBL/r62v1er0MBUIwKhQK0YOdcSgUCnr69GnsF7i8vIyAIaWH0IPkb29vdXZ2lqHJGAtoAMYw7/AxVueu+W9/N0feT5480U/+5E/q/PxcZ2dn0WSN+7lKxQuV6OQpojFO/l2urKHegHPkM9yLhYdT8ntJqWzRC9T0h0mSJByMOyEyQc9IPcAznp1OJw5EoYkewMUlpNg8Y8hmI2o4OACej81ZHAjjdB60Jc9ye3sbhXgcLEXjy8vLCEA8C9k4wIe1dXl5GYj75OQkDjTx92ZcaTMBAOO7GVN25pLZPn36NE4fo2sr8+NgoVgsxsH06Pr5PZkUwRs7xK59B64XfbFZ/t8Dgds2z1AoZOt5yJV9UxrBgsvnwwGP05GsWW/34rUNPuNj85jrvQ8AFDW5VlZWonBCygUnCi/vWn44PQyChby7u5vpF0IjL4wEhEsPm1arFd8zGo3UarWCMyaNBcHRdwUUCsohGGA4vnEmr5jh8qIphu20iqQMCkDe1mq19NFHH4WT+KM/+iNJqUJHUtQMUPe4sROgPPW+vLzMKJ4uLy8zdRGCA8iPwIwDxmnAcX/00UeZ9tYc54fah9RcSmk+skACDXy0b58HVQ8Gg6ANCYRSivRwQD4OW1tb8f7eZpvPePpfLpcDIIDuoJLIFgle8OqFQrqRjP0GAA/qR/6dXqjFPlwl4zWFYrGYUX85d58kSfSL4plx3oeHhxmnROO/p0+f6vT0VMfHx0GfOLfPNRgM1O/3IwAxN5PJJNYnSBp6kuBULpdjV7qUSmyxZwJlqbTcoczY0XW0UChEpg7q9Z3glUpFT548iZ3jZL6TySSk3WR1AAQ2ZErKOFvWjq9V7kXwYt1jH+PxOCOm8Mweu8b2kXM6te3ZjoMYB0jYTF6W+pjrvQ4ADBbF4E6nk9l6jdwRamNzczO23HO8H5VyDNC18c1mU5988on+9E//NBAGhovThiKq1WpBEdEhlMsDCVJMkKvz32Qx+R23TiXd3t7GjmeeA3RJ62sMY2NjQ/V6Xbu7u5IUygGcIIb3ne98R/1+P5ync9+S4ju5vAcMhUQWm6RQDTnqJf11jbyUKi9wgBR76/W6Dg4O4jwDaDAyHrKy2WwWwYl3zwc//u2LbHV1VR988EFw7b4rFDuBy2auAQDYFwsYxOsZB9TEdLrc2l+r1bS5uanT09PghV1aig15ewuex3efSulGQj+DmLF3BIr0098Zvh5bBAUXCgU9f/48WqJj26B6Do7BeRUKywZ1KF98TYJK2VhGoZOL7JKNaPP5PDIZxpNsGvmi17uwoZubm6AymRuCmhf1mY9Op/POqXjD4TCCIZkYa+fDDz/U8fGxjo6Ookju7St8nLzmw8U4eJYqKVpB+JxCofLfOPFGoxHZmgMbn1eeQVImQEjpuQoECfc7j7ne6wAgKRAE18rKSvT5J+2lR3ev1wv0eHR0pGazGdvbUbnQooDF/Pr1a93d3QUvDtKRUhqoUChE/5NGoxE9h0C6eeRGSgkvJynkk+xM5vMgAEmBbjBu36gkpYdqoIRwNELRFiMrlUra39/X9fW1Tk9PdXl5mWkmBrr3IpmU8q+gEkmBVkAjLDLnPGlVS1rN730jHlnb1dVVNLfieTwFphvl5uZmFN89w2ORQPcxDiwaVFFkbnye90RDDuIiQLg6iXvz/8xXqbQ8HB2Kolwux2arr371q/rWt74VNQ2CN3NGT3zGEjTtmayDBxyFjz3/dg6YYInDldJNVjxDuVzW/v6+JMX/u63hFKEvUK0AlAhEZLvM8WQyCYqWMUSdg4PP7zznffjH+XHsCGpzNBpFmwMcI3bMGEITQ/31+/3oEcY+EB9HuP2Tk5N4x3w90W2xUlm2bwZ9O3jyz1HDcqqTd3YBB0XjUqmkwWAQY8O5IJ5RsiYJzjAODw8PUVNy+ozPP/Z6rwMAGlpXyHBc3Orqqp48eaI3b97o/PxcH3/8ceyYvbi4iIWC3BFO1mVYw+FQ5+fnkTFQzGGCoIMeHh50eHgYrZlbrVZkFOh04YqdzuF7kIWBCtingJrIq/9cIBWMYGVlJfqM3N/f6+joSA8PD2o2myEz4/tms5lOT0+jpQJGTYCjeOmSzWq1mpG/YYSgcbIHHFReseAOs1gsBpqqVqvqdDpxutnJyUlmLwafY7xms1m0vmUBM56gNMbFaw5SSu2wkYtiJgfUgJCREeOwqAn5+EMtAAgoGEJp+RxRhMfZ40QlBfDIF5fdiYF6ff7K5XJ06SR4eo9/pMfdblfNZlOLxSJktOPxckcqsmJQPQGP7wAwkD1AfUwmE+3t7anT6WSC+HS6PPSIJnAUmnFKXgvgms/nAVzIJEGt1HOg1MgUJb0jQ2XusTWeG0rJayEUWZkvam/YOhkqPfm5J2vX0TcqL+bHwagHFYKPZ208C/PK89dqNUmKjIhsCWDq+x/4W98v4EVxf3YXWTz2eq8DgJSe3Skp+PfpdKqPP/5Y9Xpd+/v7QclQ/AT9sHGJwcJIR6NRICNJ7zgRR4P+vaSkyPO4R6PR0ObmZhS/uKeU9rxhYiVFWws/k4BCrEf0QiFtIAfNsL29LUlxiAYbgM7Pz4PjhSbx7IJxATXgELl8cTjaJXhRdyBjAJ36xrbJZBJZk5S2c8aJkIY7r0pB0FP68/NzVSoVDQaDKNqtrq5mNuFIeiclZ/7m87kGg8E7TpfgBahgLKD+cI4gLehG32Qzm800GAwCAZdKpehBz2eQ+uIwyPzcAVMgBfESJKDUnP7DDj766KOoS/FO8N7T6VTD4TDuQ2sS3gfb8D0dkmJXs2eVTvOwn4E6U6lUirXGO1J3wHZA5GQGnU5HJycnYe9kyDhOABfIf2NjQ9vb20HfEJz9H6ith4cHHR0daTAYZNqK+LyzHsmc8ucNY7veLZS/wQ5Zm1CBOGTs4/z8XDs7O1GLIHvOZwsAKufueY7ZbBaSYdYu4+R27y1W8Hn0O/Ma32Ou9zoAoHGHDyUVLxaLOjo6UqvV0vr6eqBwKXVCngozYEx2vV6ProxS2usbp+ldQrngJcfjcZwQhgE7ZZPXNEvKRHLQibTkeh2JglDREaPQIei0Wi2dnJzo4OAgdqDi1KS0xa0rAZwq8EIXO2txOvQw4QJZLBYLXVxcZLTRjjp4L5wlhT8c6+XlZaAeHBnOBYcJt0/R9/OCKGjPUVieEmEsSZ/Rkzuvi8Km3W5H3QHnRfB3HhoEmaf4vBBHnens7CwTVH0s8+c0QKcwByBsKT33FTqB96pWq3r69GkELlD96elpoFSCNfPO2JDNUotC+8+aAlg5fUB/faduOAIxn7nlpbZ8vlgsBrVJBg7gcVWZ13IIMvV6XUdHRxkqju8lsIKWkbFK2V24/uzeWI214gACYOIUI0G11+tlTpSTFNJu35joR0jiB/KgBUC0srISYAKHj4TV99yQCfu68c/TugVQ+tg9ANJ7HgBQvviCByXgaCiYefGOOkG73Y7DtP0wCxAKC5yo7qkUE8Aksjhd4iilPVDo2Z13/p6qra+v6/nz52q1WhoMBtEDngDhqg+KPbu7u0EZISV98+ZNbO9HeQGKy7dvkNJzRzFqghCL1g8lJ7A5FcQ7+QH2XsRmTuicythRl6B3PZup/PsIeFBYtC9wOsTHMU+V8N7MM2cmszD8GYfDYSC/09PTGGuoImoE5XI5aJy8GspVXTgZ+G94/EKhoMPD5Umo8OFOl2HPUBcU9XCU2IPv6qQt+be+9a3giznzmQIzkmcoIi4QM8+GagZdP+tgsVhE8OH9BoNBZBUecPmH58ch8+zzebpjut/vR/ZDkPAM25+TPROogzwbYVc3P/OsDWfIfUDUXE59eSAGuLiPcDkqwQmgArgol8tRq9nZ2Yl6AjJewIzTSVCe+UaD+b0o2BG2Ds1FvcQ3W9Iev9Fo6PT0NPOMj7ne+wAgpdJFUNnt7a0eHh70+vXrkEY6ksC5vXr1SoPBICZgNBqp2+1qfX09ZIzOdeOAcXqOakEVfI+kTIsGUDeozp0wf4s0k46PaPNdzsjuQXj36XSqWq2m+Xx5dilowxE+C8NpCn6Gc3Hp4M3NTUj7pKXqZ3d3V7e3t6rVatF50lUL3W5Xm5ubwa2TFfC9oC03VpwRm9a4Hyl4Xq8PwgPRrK+vBy+KM2B+QIFQGz4PzA1BBQqOzIsAw3dWKpXYzERdyCWP2B126Ok7AWBrayuCIIXHPGVF5oRzQqkFNeeflZRx2FADzD/3wgGTWUEHAmxwnmSBgByK62QY2BLX+vq6Op2OkiTJZAEEC+aNAJrnnXl27MLVOZ6xUecjo5EUgcmL3JJibN0umWPGNK8Q43l5HmzeETNrlEwRua6LLKS0R783UfSzBABOZJP+3X5Rk8tTVNgchW/mxf2L+x/oXoQkLbUAACAASURBVIQM2I/vdfii670OAM7FMiE4ykKhEJwlxSUQB7tbDw8PMzwv6TzIzQ0SY3BpGouVwXWnCwJhwJ0ygpcD0YJmnNd1SScTjJwOJ4ZR7O3thYyOLfXF4vK0MVQp8/k8pKwEM54RB+aOzOmV8Xgch8p4qwpHz7SSQJkzny83t/EZMgaCws7OjtbX1yNFXllZiazFN6tRJPM0GhSOY/MzHq6urjQajWKMKIbO58tGccwXCMsXpRfyPCUHFVJcA+31er1oSIeqhznx+UFBVqlU9OzZM11fXwdqlpRZjCxaSYEivZjo8+JBm4NqsFXPFDn3gT7zedWLZ2eMA9kRB/k4cierYr6wa1A0GRu2hIiCtQkaJ7P2XkQ8DwgXagtk32w2NZ1Ow7awYc9iuSqVira2tmIH+9nZWWQ+BA5AA//tVJIfn8jcY3tSyrWzl4KfM0dQZ+wVgqqhTTmfA0jwPS4SwKl7ARdgmQc+riRifTgl5nsoHnu91wGAFIzCI2m4ZwJ0w3N+jOIoih6nNtDcg0ygWvJqAOgAKA8mmEAwnaaN15gUTxuldDKRkm1sbOjg4EDf/va3M07MG6zhFJ3SQD0E6tjc3MwcJA0qmE6najabgRZBgDhl31PAOPLebHryrAUDk6T9/f04MYvvLRQKoYjCGUlLDh80RTovpQvK0T7z4+MvpSiJ0614fp8jHDDo/uzsLN6BDVagdbKJPEXnAUhKA1mhsCxwMzek2t4cDVGBZ417e3uRhbnjdzQMIEHfToGbd+c5QaAENH9+CtMEfgcRgBiXIDKnjUZD6+vrOj8/jwKv0zl8f61WU7fb1eHhYWRqjC/zB9XhnD9jiu2xya1SqcQ+F76DZ8Yh0hrEQZMfys7cev8cnoUWFLyLF/cBYi4B93tKaQtoWmG7ZJp3dvDk9TeytHq9nln/ns0BPHzN8f/4N6g57uOSUt6J51lbW4t1cXNzEx1BG42G+v2+Hnu91wGgUEgbVrGoqtVqhvum6Eo2MJ8vN6igauA+8NR8DsQDqnBulmhdqVR0dHQUn6dwiiNDGulqAgzbZZwEE4yUbMCLPCw+nA9ZSp435DMg/4uLi0ivQVCtVkuj0Sg2WRGwyCBY0N4/HVTuaTZ/w2fo3IkckQtlQ6FQCH7f5bbScoERmHA2GHk+W2IO7u7uYs8FB+J4bYLgh/OFapNS1M24gJjG43FsyCuVSlEAZpczjpq/ZZMcCJbv6Xa7mk6nGRTJYmSOPMtgAfMdTnd4sOl2uxHMrq+vY7zoeunZG/dgHwN24Tww4+SadgILDsbnCYk1NQHsLk8lUWcbDofxOd/Xga0iBYbmkVJenB2+TsWen59ra2srAi6B3+sYgLbpdKrz83O9fPkyPuvImnVINlatVmNvRKlUygRp/zfsgmerXgME6NTrdTUajQA7iFEIFO7HCP4EwUolbdFeq9WCcl5fXw/A56oqbB1bxt7wH2THjNtjr/c6AFQqy23cg8EgEOpisQhUiRG4o3flCRNN7xh2O3oaTSEZzg6joPsodEin09HGxoZOT08zi5vNSS65dIqAxQAdArLHWFls1BtQHbi2HMfGIqMNMXsXuBfGsL6+rmazGQVfHzsvonuLBoIrhfNKpRIUE7JXvttbWniW4AbqxWgQV6fTUbPZzJyv4DWQzyuKzefzULlI2YZt7uhA+r4r05EvzwedxM/K5bIuLy+jWyfBjMwClRRjj2PEcTPXoOH8TlSvCeWDO+PoqI4gPhwOI1Pl8wCQi4uLjAACBQxOnXFzHt67meJQvWCOXfh64hnG43E4K8AMwfT29jZULw6iWB/ValVbW1sx/gSfTqejZ8+eaWNjQ4PBQKPRSN/+9rejXtNqtbS2thao3Z01810oFNTv9yMr2N3djRoVc+mo2U9ow3nm5wXnz7tub2/H7n7osJWVlejhxEZTdipTv3D7JfthQyN2zPcBsmA1eE4oOAc6zCkZJGAGP0Kx/YeiCIwMFDWESyhZiI68y+VyqBpAzSxG590wYhbFzc1NaI3pvolD5fxVR0Ku2iF4EKVdbcSk7e/va2dnJxysc8CgW9JXECLb3XGu7PS8v78PGSopLkbBTspms6nt7W1tbGxob28vxhPaCSTNM7hjgPpxtVCn09Hm5mYczoIEtVwu6/r6OlAnKhaep9lsRrZDkHE6imKalBYGCSBra2vhAEejUciB8zyslHLT+YtUPkmSzA5X3h0HT50EFCcp9l+wuYf7sXC9743TVoAS7IxAjl14QzUfK2goslTanOCwaHcCD+xtKXCqvJurhxinq6urcOygXDb0Md/UYVzyzLsCFPi5S3UBTlLaXdabn3EoE3NPxsQmyE8++URv3rwJO6JG9vDwEEV+n2feF2fKrmns22mbcrkcG+QYz1KppF6vF457dXVV+/v7mQyCLgL4B4CkS4sRN2DX/r2MDRkVYI7P8HOneDyjY35hDqD8XKVFBsT+A9Y4R+I+5nqvAwBOgYFhoJ2uwBFJy+MbPbUlhcPguSfOzblWroeHB62vr2tlZUXtdls7Ozt68+ZNOFeQCLwfyEdSFKwkBWeLiuLk5CT4bAxzY2NDlUol2kRg4B7BeW6KeIyDn/LkvOLt7W0cAwjfCu3hDgLHUq1WY4MOjh2qhuDCJjXOV3VVA4aNQ8NA0UHzWfTgfJ5AiiPyOff7UpTGcbChyikmnGhe7w1qJyWnNTM24eNLkRuKELR6dnYWh/Z44MAJra+vR63D6yf+DgQC5gjHwNyB8J1u8xoADrpWq+nh4UFv3rzJ1ENwVOxoxp4dZfpceJYDwvRjSKlrkJHwGezv6uoqc2qVO852ux2fZ+6c5nEqFsknwYkjK8kG+/1+7IYGeeMT8jz7bDaLnclcBLdGoxEZJyDFd4N7rym3pdXVVZ2cnMTGLOaD7FBSnAPBWNMpNq/K8Xqh72jmuSj4Yju+6xe5MMifeYDeur29DTALrfnY670OACBhJhW5U6lUytA2TB6S0EqlEs5GUmy1xhHgQFnkLA6q+Gtra/roo48kKVr0YiSeRYD2QOIYPgiMgh+Ge39/n3FUfC91Da8JjMfjoGxANRjP90pdC4VCOOhvfOMb4exJ7SXF2cgYc6FQiG33Una3NcFsb28v6hQeLJEugkwIqjhel6sSNBlnnp959st5W56LwiQbyliQ+THxjAK0jQ3gfPnHawMctIE6hr+jVQhojW60zBsInwDg6hPsgMyFjKJararb7arf70ewJ6ABcCSFNBWp6eXlpQaDQSxw31+AZBOnRmaWD5RkdFtbWyE5RPbrXDXIn3mHmoH2m81mEeyhTAqFQgAiEDF0EWsUDb20lONyprMDBtY1qBiaz+sQfvlc5i8yPNYVPyN7p0cWwclti/XjGQg2sLKyEnTPxsZGSEfJDqhBospiPQHapPQcAVRYAEFJIQ/O1xN8P4dTr0iE3XYfc73XAYDBznOAoCIGkJeG9/ZeQDieWq0W/CYT4c5/a2tL5+fnsUeAM2XRVTu1BOpjYkkLoW8cFaEs8ChPdkDLXSggDqWRUkfsvcVns1mc1evGyYSDsilsemC4vb1Vt9vNNKLignJgzHFWOEqK7N56G8fpi15SqJ3gyKV0OzyZm2uk88/57NkzSUujHgwGgZzJplD8YPweMHFOrpYhS4N2yO/qJQiS4eDwkH8yv7wPdsUzY18OMPgMAdr77eNYT05OYhxYuCh4pGWgRoZK0OWgFbIbHz9aXBB4CBj5Qr5nA5ubm3r9+nVmc5SjYOoqOC2cLHQnn+ffjBPPRFvujY0NnZ2dBa2DXFtSIH1vZMb7ulSY9QRl48GB4I8qi3sRlF+/fh02JWXPgIZigkrLq5m63W40eQNsYBP58WTumB9qdP5MPIMDqXK5rJ2dnWhfDuDDprg31GFevcQ4oiSDwnvM9V4HAOndgxhAXxgcTunu7i5aF+OgfKs9CNs7ZpI+k2JDfcCfgXpwmu4AnfZwKsULxI46yFQoRK6tremTTz5Ru93Wq1evtLW1pbu7u4jwvV5Pe3t7wVsTQO7u7qLzIajKKQ1H1Y5oeBckeqDR2WwWrYt9UxFpL/d0B+qZA+fL8jnQTL1ej340GCWo3vvJExzm8+XpTXRxJKjwvGjbHWUxJ6Cou7u7QOVSepgMTh8ahQXG2BDMccCk1fC0UhowXSpJ/caBBrbo2QV9cTjDtVqtBhiAcnOUidKKuVlZWcmIExgzaIderxcnc62trenq6kovXrzI1HW4QP1o15vNZtA/vqu21WqFsgQbZ58KbTY8yyPAuGZ+dXU10PHd3V1IsPk8Yyilsl+np7APsr75fK6tra0I+GSqzAGbCz1DyAd87sN/UzTNy1nX19eDskU2y4Y4D5hcrG/kpr1eL2olrGkURMw1iH9jYyP8kmdZTk97exqekWyNrJP6DfL3x1xfGACSJPl1Sf+GpNPFYvEvvP1ZW9L/JOlLkl5L+rcWi8VFsrSg/07SX5U0kvTvLRaLf/b2b35J0n/29rZ/e7FY/MYjvjt4fKRRkmKypbTbIp0FkVNJqbOaTqfRhZKswbXsHEqyvr6ecXwYT34jmJQiRy6QXLPZzPD1OFbkYihkoDNoF42T5nm8uV2tVlOxuDy0hXciyrOb1FNopJwET6gp/h/lABkEGUu321Wj0VClUgljp7BWqVSC72RjD7wzCHo8HsdhJO7k82oMnAkGzTNzStvP/uzPqlar6Xd/93fDSbrTYKGyKY5jLllw3vufsaE2hG2AvgkCtVotnMf9/X3sT2DBEmQJViB8qAMpVUGxGHlPECxIGoBRLi9bSbNRi3uura2FcobipSNg0CfURqFQiI1gw+FQg8Eg5ghKDjt2+nF/fz9QvrddJ8ASOAhmBBwXXPg6QBILSueoS07pIlPCflutlsrlcvShYvwQJfAzKD5sF5nzfD6PzZ6ABQIPO4xReJFJQ3di8wQrH9+1tTW12+3YX4QP4j3JUpynn8+XhXpazLDRM+/P8veQFM/HmJPROND14Awl5nSYU629Xk+np6df5F6X93vEZ/4HSX9H0m/az/6WpP9jsVj8apIkf+vt//8nkv6KpB99+8/XJP1dSV97GzB+RdK/KGkh6Z8mSfI7i8XiCw+udB4YTlxSRgVDRR4DoWe5pNhkIylaDEjLASPlL5fLUeBtNpu6vr6ODSgYIJyyOwXuw2L0DTvO/ZL28zzIS0FLR0dH0SXz9vY2HDSf5+QiqARXHHh67tkHQYA0GUP11FVKD7VA6eLSUvhtUmXQPguInxcKhQgEHmC9KyYoFuki41ir1TJ7OW5vb7W3t5fR/XNCFVI6aCDn1r2wjSNhoxl1HRwP3C01BNRM2I0XdHF2vm8BW+T9mUt+h1PEcaDKyOvUGS+Ckwd3xAhJkoRCrFKpqNlsxk5RDla5urpSv9+P/kOefWxsbKhYLMY9eA8UNrPZTK1WK54PLTt7ELgY0+l0GjvR3bawJ8aAv6G4jcIO0FMsLk+t85bSnjGzlhgbqNHFYqHBYKCNjY3Y8MQaJ0tqNBr6+OOPdXh4qK2tLb148SJTNCaYYAMOMOm4i80dHh5GPyfqCbyz1zZ43+vr6wBJkgKYzufz2OjFd/lhOQAHpL7UVgAHoHzeIc/1r6ysRGD0Ofii6wsDwGKx+L+TJPlS7se/IOkvvf3v35D0T7QMAL8g6TcXS+/4/yRJ0kyS5Onbz/7jxWJxLklJkvxjSf+6pL///b4bB1GtVrW/v5/pj8HiJjpOJhNtbW3F3gE2qNCWFbTXaDQitcbRkWpBD6DzJX2T0p2AOH/+7Q7XUS0BAjRKunZ4eKgkSaJHPUYEGve0EMd4dHQU6FNKd1qCDtiYBUpxdILB8xy++xjEwSIAyfCeBBoKWvCgjNfd3Z1ev36dCazIAEHbXlvgHXg29Om1Wk1nZ2fBhX/66afhqEGKbBqC/0cCRwZDMMCRkNFBX+Gs2CENcHBJL07OJZqe/Tl3zGdoXcHvWKTSUrrLxh5oJTICSUH5wZ17nWBzczNoE2yTvv/QAzwDzomxpmBdr9cj8BLMmU/6J93f36vf74eqrlAoZOSn2AdAptvt6vnz55pO03YNjHmn0wkn6WAI+yP4cH9qdQAFQJ1LoqFm2OyG08fhk1WQdU2nU71580ZHR0chm5aW6iTsAdUO/oT/J+MBDB4dHUV7DT/xi3km8GOXeRk089bpdDIFYMQnrVYrAhwsBrWnu7v0lDAk6tDBt7e30ZoeRoFMkjrLY68/aw1ga7FYHEnSYrE4SpJk8+3PdyS9sc/tv/3Z9/r5O1eSJL8s6ZelNK1hpyGXy+ny/8DBod4hpWQAcfqFQtoVEQMEdd3f32c2UjhvyIXzyDtaeGG+Yz6fx+Yjiorci0WPQ3dUARUgKTh6/g4ngiG5oofoT7rJ7+jJg5Mh7XftMptb+H4WMe9JEHWV03Q6jRSe4MFZBTw/aJ4gwXv4oqImQdBh7HwTFxcLG+fhGQxj4xrxxWIRGZ3z/DwLz0OAZe75fp8j7I/Le7y4RNZRGvJKn2NXObHAeef5fB5O2QML7+zcMO+DismROmceMH9e+5LS3dqeZTuf72PCODoFxxjyfPV6PbI47B9H6cGUZmcAKGwsX1xlnngWwAvPWq1WIwuj5QQ0EIGGpnYAiKurqziwHgROzQq7Gw6H6vf7Yd+MM4HC6UwunomgS3bGs9fr9TiycjQaZc4cmU6XkmjOsACUci9JkUUyD/ydy3GfPn0afasee/3zLgJ/3o6cxff5+bs/XCx+TdKvSVKpVFpAwXgRzY0KZwaNwwER9C0BufiGEOSiz58/jwXJcXnScvGimnGeDqN2zbBL1gqFQuZcAgwK/tML1HyWn8GbSooeI8gFj4+PAwmyOB2xsxM07zQdjd7f36vdbodTIoA43yil+xfoGU+rCRaX1xNQ6oAwfeF522eCFIsB2oYaT7VajYZmcMteFMz3W9/c3MycFMYY+B4Q3oXfO/311rZiDwY24PtFQPwseoq5xWIxUKEXzcmOcIq+mQtKDFqMOomU1qmoExBYT09Pg75xHbnvLcEhOp/MWL9dS+FAQebYAnMGaHKA4RvJsHOOTuScYepD2AUZgdOTHjx9dyz0FGPuxUye2ak26DVH1og+kGMy70mSRGfWwWAQR7DicJ3L51kRHjDnPhYeED0oMk8EHK//eDaF7aDOI2CzdsfjcaZVtvcuI0uRlhvTxuNxxg+gVqTNOfWfv4hWECdJkjx9i/6fSqLisC/pA/vcrqTDtz//S7mf/5PHfJFvHioUCvHfUnp4OUgBpIfDBVWw2Fg0cMj39/fqdrvR6AoHjEHQO4Vj7uDumJw8784z+sYm7sVi4wKx4Xw9zQa94+QajUYgCgyIJmzI65yrdgfoxoZO3PXGrrNm4VGQpTmXF5hYDN4sq1arqd1uh5rh/Pw8uF3qITgfFjNoeTZbHvrOM7qjqFQq+uCDD/TZZ58FbXB2dqb7+/uYG4qcOEHewREo1IOrvpIkiSZqOPJms5k5fhTRAPQG8wF1Aapk9/jDw4M2Nzc1n8/14sWLeOa1tTV95StfifQcnhbnIqUKKs9QsVO4eNJ9giRZnKtiXCfOvba2tmKeyQz8HGunvMimPFuSFA4Km4POw3mTbUjKZLS8nwMNd667u7vR80nKyiOxL6gh/53vhIbmYs6cMuEcZpAxlJAr6KiF+El1PCMB0ulXaCR6EvG3XrD1LBLQx/ph/gkegCMApUvfCW6fd0YAQJA9AJ75Pvb6swaA35H0S5J+9e2//5H9/D9MkuS3tCwCD98Gif9N0n+VJEnr7ef+NUn/6Rd9CQ6BSQAh+gYukL2UniSFYmWxWISGFyNxCuTy8jKoEVAQk7uxsREysGq1qjdv3oQaxqO+lNIORHSMhyIeDsp/782moAlISX3xXF9fq9/vx+KqVqva3t7WysqKTk5OJCn47Mlkok6nk2lTgKGzkHFY3nOEz85mswyaRZ8Nt+rKHpwszpNzFmjdwXuwKDw7cdUMJ0zlaRsC2unp6TuSNha/U2XIaJlbLi/awbNCBbiqjLl32gbqRFqeAw214ZQELT7Oz8/jXADQMu+L2uXHf/zHJUmvX7/+3IKwOyAOePceO6hLsL1KZXmyGYAEZ+IXP/OsgPs50paWdSFkoU6zOtDBoeMUXQrL5QGfYEtAwxkC0kC8Pp+AH2yCNesX6NvVc3wGoIRjR/JK0GI9OEDADvJrGFv3NcL7sL65WNdSGlQJ2J5tS4oNhzwzPoSiL4HP620cPMR98GfsH0IsQruYx1yPkYH+fS3RezdJkn0t1Ty/KukfJEnyNyXtSfprbz/+v2opAf1USxno35CkxWJxniTJfynpD95+7r+gIPz9LudTQUNMAIjG9d1MDGkfhkmxjSo/Efrh4UEvXrzIoBI2/FA36Ha7Ia3i/i4fdEeH8XA9PDyo3W6H88DYQZbowd2pupRtOp2Go8ZwJ5NJFJucF8cBEMwILKS5OEp2MWKsnuLiyNmMgiOUsjp4npO5kZbtolE/kJoTTHh29lmw+Fi8OEMCCvzwdDoNjl9KlV8oJQhOFKkbjUbQE95hEpuRshQJ44cduSNyGywWi3GOM6gbFEcDMGomr169CsoDB9NoNMIOP/jgA52cnGSyKL7T7d0VWDyHZybcO0mSTGbH79yZgYLz9IYjchoItlot1Wq1kG5SN/Lg7VJL+Hyv77hgwZ0p4gjklz5PHEYEwvX6GICPdQkdxsW7Am7K5XI0hjs/Pw86DjDC3hEPCvmamztntwWeAXqWltXUBKlnuN96eHhQvV6P1uIOxnwueA7/Wblczhxi4/SQlNJp1Wo104fsn1sAWCwW//b3+NVf/pzPLiT9B9/jPr8u6dcf9VRvL5wGC9Xlid6F0+VX9H0vFAoZKSH3o1+QtNzmzwYgNr5IigV1d3en09PTjORPUix2d55MLKkehuybZdzJSIqGdKBPTyNxphTeuC/fDQr2sfHaAM4XCdl0ujw0fGNjIxAGi8aLonDp6+vrcXIWihJHTnwvVAOOHyoFuSvjw9+4fBMqg/liYRCgHOHhWBgLnDBzzFg8f/48VF6np6fhdDhXwTtCSmljQOf7Jb3DFXughx4E1RYKhXAw+QLh3d2d9vb2Ipj7O8zn80zTNObi7u5Ow+EwbBWBAuPNBrdisajhcBh/Q1B0u2AXOgEXdE1gnM+X7YjZeUx2hITYpY7MtZSqyGq1Wjyj2yb0nKToOgq1xL24t9O6fownqDifqbr9cU/P8n7+538+FHW/93u/F5vvsEXPGCiuki1wGpwXuD0IoXKj6wDPyPpkDTDmT548CTtdLJZnlyCjvby8VLG4PG8YW8i35PBsFjDF3JMpFwrLwjVU9ebmph57vdc7gZkk5/egg0BEbtgY1HQ6jcXuNQAWNAVH1DU4Xf4elD0ej0NGSp9tl9s5r8kCZFNZPo3M/zdUkp8pgNqJgELA2draihYW6LQLhUKmP5EHFjIcCkiSooYAGnYuFAN+eHjQ4eFhhgdeXV1Vq9WKAizj6NmHd1lkYRQKyw1sOEbfoejoq1AoRIGLoIvummyJ78TR+Dm7OD/aAm9tben58+dByb169Uq3t7c6PT2NYILdzOfpLmsKkmSZXiR3JDqfz6OtNUW5s7OzCMie0js4OD09DSeFvPH6+jrjiJHzstDJYHkmdwZQL1J6ljDOGfrKVVbOVzvfDNVAQPW2J06nAZomk0kcFs98t1qtQKUcX8qGK8aAoABSptcNQddpUoJyuVyO9YdjZJzJxglw0tJBrq+va39/X/V6PQ7n2dzcjHdnRy9+gYxze3s7NPvsuclTQqz/yWSSUZZBkTL/jJlvUMRf4WNcxgpYxLETSD1LBBw0m83MumczpqTIPA8ODvTY670OAHDxPvCgF1JQKXWu7BjE+YOEWQhEWZQqLHQcGhOLsZCe8hx+6AZ0BYZJ64PJZBI9wpGkMqFS9qASP5DF0ZsjAByzL0CKQxgBhsyiJoWGL8QZsqhw+i7n9OIn2ZXv9IVfZMwJGu74+D5233rR1efIKYI8XcEmM1epSKnu2hciC0JKd8yenZ2p0WhEa4TFYqHPPvssFmq1Wg3JHTJXgIVztHyfUzM4y9FopKdPn2ZoDEkZ3poshbMVeF8cDGMMagWZUhfieT1boSaBs6QVMZ/xdhJ5Z+8FXewe2wFVgkDzMmb+ISNnLCi4Xl9fq9vtZvYPjEajkBl7RsT5xs7hY4tskoIagd4gA8DR+74WggXKKoLt8fFxiCMQTOTPN2BuGo2G6vV6rDHUaS6gIHDhR7wOhYN3Socx4nB47jMYDN7ZL4QSjItaAAGSd3bRAYCOtcJGzTxQ+KLrvQ4Ai8VCw+FQ9Xo9ZJFETRqeSWl0pBh6d3cXBuGOA0P0LfHsEpVSGgU6QMruZmSivTjovYigplqtVgZhIhuUUoTIRDl/6QUzfs4kk2re3d1ljr6TlJEoYmi+KYpiHegZNQvUB1kUWm4cG9wi6bS3gCCDITvw+WLx08zs6OhIxWIx/j6v6Dg5OXkHOTNPOCeopcvLy1BzEQAqlXR3L/2TPvzwQx0eHmZqEmRcFNqkZUBFtgpH63ULghzPXCwWo/MjHDBZBDYkpQXDJ0+eSFIAEpzy9fV1OB3ny71Q7TYD4HAeHz7dHT9UC9kWTpLMFCoEEIFdv379Oiif/EYiAAnOB0UUjRLZjUzAwr5Zb97GABsHDdOX3ykegBd2MZvNMvuAyuWyer1eBAvfHAetyxr1c6ihlwjS1HOon5D9YIN8xrM5/wc78oyW52OuyM74rFPSXHwP69NpUzI57s+88V2+MZM1D3h8zPVeBwDf8YmBoJ0nQkPvgOg9tcKxOcqbTCZqt9vRErler2s+T1s1cxH9fRMNTsHPl6VraKGwPLyejKJcLkdbAym7mWw6ncaGK5CENzVzh0DQcSoAZEBAHI/HEQRRQJD5jfbqCgAAIABJREFUcA/ehWyEtJ/vwaF4tgW3z+e5WACcG7uzs6PXr1/HGbzUDTBg5o95gANnjur1egR0V5UwDtXq/9feucdIlp5n/fmqurqrb9Xd1ffp2bmYnYlkdld4sY0RJEIK+CaSQEDIESJWEhRFSoAIIcWWJcg/kTARSCAiIoOtxCQkAUGEZSWyDULkHzu219f1Xjw7s3Pp6ft9+jLVlzr8UfV76znl2dmZDdtTs1uf1Jqe01XnfOe7vJfnfd73K2tyclK7u7txLjHzTECVOZMaJbyZv8XFxdyRfgjE/v5+nTlzJmALDIFisRhBPYKbrB1iM3fv3tWtW7diXsfHx0NRu1JHiRYKhVB+LtQxLhAyNLxK9yjY2IxLO9cbj415duOoUGiVSq/VWmdP8yzWFt93YUdfpVa9K+BJCBKsM9azW8usKZRvpVIJgXzu3LkQyi+++KI2NzdD2UL/RiFyzoCkIC/MzMyoXq9HFrnDTXgTlFfBQ8U4493xYoDxgGT4DNnCGApu4fMu9Xo9dyyre14I4oGBgaB+OwzZvv94B+bXaabEJ3wd8zePbXgfX691tAKQWqwTqXX+LwsIq5i6Jf7yWMRuvWG1AulgAWH1rq6uBrbJvbCI/ESjYrFxPB8RfjYVXHN3Wd3FR4sDlUitc4WxsrHUESRgh8A3Q0NDudowjA/f4Zke+/D38E3trB+Cf3hOfqKQx1AQSCjPwcHBKFIHVMUipcwAn3fOPGWCZ2dnJTW8gJs3bwa04wLIM6F5D7eKyYbkO3t7e/FcFwx8p1AoqFqtanZ2Nqx42FZYmyj07e3tUFisw9u3b2toaCgsUBRWlmURY/HAq5dI9iJ9vB/Kv1arBRGhWGydK8B4uGvPOkZIcrgQsJnnDkxMTER/mCunPw4ODury5csaHR3VlStXIi/Dx417lUolbW9va3NzM2IYzItDVXzXaZJQWqenp3Xx4sVYTzMzM7p69WoE73kexgRC3PcQigiDBmXL/oPlh5HB+uX+wHPAaOwH96RTapwDfvHiRa2treXWEgYNQt2pouwZ1oV72HzfobBarRZJYlILSmQO3MNBWU9OTsa7OqLB99u9jNeUrw/0qUfUYMJgLQI9IPTYfGCnUosl4clXWPcIJhK/WExY9+0p8wgVYgjgfL64j46OQnBIrcxOhDACkbwEJhU81fm+HisA84PCSr/R8sA4WDR4QAR4XeBIyrEawKcHBwd18eLFKCHswT/ghGKxGIqXe+KJ1Go13bhxQ0tLS7kF58LSvQF+5z7UyIF2SCVVPBMS0gh+ey103s0TdPCMvBwIQp/vAEMcHh7q9u3bwavf3d2Ns4rBl1HIbDzmU1KMF+N7fHwcODbz4FxvfvAWgVvwKOfm5nTz5s0QUpKCZkrj2axDnsvfCLIimKXW+QzQf/v6+nT16tXYRygahOfk5GQE1HkWexFDoK+vUXdnfX09vjs8PJzD7xlr3w94OuVyOYyZLMsiac6f5w1YF8FGMJd++T6jP0AzGGWjo6OqVCpReBErnD6NjIzkPGUvLQIEvbi4GM+VWiWsWesEtlkvrnjwwlj/7Ef3wlnHjOfh4WHu9Dv3DhD+Hsh3WPNBW0crAAS5U/LY3EA44MRZlgXzAMGMoPGaPVJDsOA+UhuEe9+9ezesAFgnkkJBIGjwHphUhOLAwIDGxsaiHCsbUGpVC2SBwDRwDwKrg0XHooSh4DgjQpQ4BBCL1KIxOq3OmUlAOIwfitbHCW8Cjwmhyzs4dg+e7TAIgg4FhqBFYZVKJT3//PM57PLs2bOSGlb//v6+zp07FxgzbBMMADw/LD6eMzY2pmq1GoKUswQGBwc1MDAQMBJzVC6XgyHFxvLcDI8Z4JH5+Lh1znoDx0cQMhduhMCy6ulplHogY5dSILy3u/1u4LjL7xY7Fm2lUtHY2JhmZmZi7F566aX4Lucd9PT0aHl5Waurq/E85hWhT9+ZW3IxiJHUajWdOXNGe3t7kYMjKY4RpaAjcTaCsBQ+o6FA3RDDA3YjwxPasN7x+BGSjFN/f3+UOefd6TseBlnh/HCyGlAq+2V9fT2MSxhreDVPPvmkjo+PdeXKlVwJb5c/GAe1Wu0Hzuj2BDPG3fc07fj4OAxYvDm8/3vBg/drHa0AgFo461RS1GqnHopzeglQohg8EAIMQzYxte/53ObmZg6agW3hFjmbArYJVhhlCaj7Al+YRXP+/HktLy/H34Gx2DhuIYPlA4UcHBxEoNNZSuC1Ozs7Wltbk6TA0J2r7VYq/WeB7O7uam1tLZe4hDXlVMJisXEyEt9FKDKunp1IP4jfEKuRFJY8G7dYLEZ1x0KhEKUYUHpY8XhpWJMpJU1MTITnAnbM+/m5y9SEQgBPT0+HEseqR9mXSqUQLK4onTbKRuWe/KAAJiYmIuGQ3BSpIfAnJia0uLiYg+lYv2xogrU+JjCHJIXSkPKsNwQNyqhSqejs2bN6+umnw0L0ks8O6/T29mp1dTVq0vhaAbfv6+vT6upqMMEItLIeqXUzNzenWq0WHsczzzwTQmx9fT32Dmfy9vT05IqmYZEDN9EXIBGsX/qHYhoZGVG5XNbNmzejj+xf4gSey8Ied3gZpV+tVlWpVCLAff369SBfuFwisdED2ljuL730UuwTZBPzgzLY29uLnBmUIgqLKsgYSh77caYPdcDaGWxvCQhIks6fPx/VJZlYXC8EAuVWKUPggTusVoQe1u7q6mqu1r5DCSxqzzPwIBnBGocEsIodOpEUmYcXL17U4uJi9N09C/raXpOfeMH09LQGBgZ048YN7e3taXZ2Ntx3kp3cavcNw3PAtbFmsJwdG5daB5kjFLFm6R/MCWcWIbBxq7F43ItiAaNU3M1GMRBka+e7Y+l40P3k5ETVajUsw62trSjChdXZ7vGcnJxEVizK0gPrvC+N7zoU6PdrpyFjhSIEuC+UZeI4vCOWKs9mvcKMYY2z/hCOZM0yXx7rog9kCJPhu76+rsXFxchHKBQahd041Y259TFD+WM8eZ88aO2WM+VDMMZGR0e1srIS8wJUc3x8HOwwYC/WAX3yeJxDccwd3oIrdJhrrBn+RXkTG+E6nsLR0VFAOMT1arWalpaWtLm5mcs3YN+iyKGVE0tCBrHmmF+XF7zj8fGxhoaGokIpHib1lpw4wH4AZvK6T6xT/+yDtI5XAF4HZ3h4OOpewOPGquvt7dWNGze0vr4eE+NCCGycwVtdXdXo6GhYWWtrazEZMBz8QBOplYrtHHqp4aYdHh7q8PAwF3wdGhpSuVyOev5MaJZlsRGYNPjMLOR6vZF5PDs7q0uXLungoFEwq1QqBSV2b29Pk5OTwTABBiD2wf/xMNjMlFBAEABxsNm4BiQEA6Fer0c28ezsbCiUGzduxKbEtcZLKRZb1TPZbASQpTyuDeUUWqcHF4F+gEgkBR3RK49K0uLiotbW1uJ7eHEEqplH7ol36YLMBRxU1PZ4BmPOeyAIWCt8FoNhZWUlMmdJmPKDavz0KpQwTA/uhRBGADguT3+wbPf393Xz5s0QXljwLhwpDDg6Oqq5uTmtrKxodXU1lBvFFRk/LGvWCdAfiXYISe6NZ4NiJUO9Xq+HIsG4Ih7DOB4cHIRHjxeM9YtH6H8HgmUuySFgPtwiRzjznsCz/A1rnL0NkwhlARSE4t7Z2dF3vvMdTU9P69atWyHs/TueCU0AeWpqKmJ2rmCA4hx6dAOF+/T392t8fFxHR43aZnh7D9o6WgHU6w0uMFb0zMxMaFqsRzbX3NxcCBkSQGjOQMFdu3v3blhAZGYySb29vRELQLi6peYNoU9jc2GBEsQtl8taX18PdoIHMBGWLqwRKIxDoVCImkIIy/Hx8TjWT1IEdvv6+qIMA8KLhebCBOYIAV2UnTMQwBgZA1LZOayFQDQYqtRiizBPWHAIjePj46hc6QF7h7ag8ZE5jLL0dufOnYB5mG+vDIo3hDuNB4H3gqJhXvv6+nT27NnI3nQrz/FmlCLvyxxhwTF+KA2C2axjYkJjY2PBZ4eDLrVKj+N1YNW7Z+RYNeUvEAAoON4Xj3d+fj7m1e8B4WBubi53xvPx8XGwbVirGCvMPVBQO/zneLt7Sg6BAm85VAn0B/2T+1KyRWoRGvAcgBkHBwfDOGDMEPqMHf3zADiC3ll0fMfjL6wB/u8UT8YYmBfvyb/DvmNuNjc3c7ENxhEjAkgOpeSlYriGQUdV2KWlpbdOEBgOsXP9Cb5y1B8uW3tlR+euY52OjIzEAMIf9yAL+D0TMDExEZi30/t840utZDEPRmFBYDGxMMEfPTDU09MTrr1PKodRIwjg+O/u7sZpQoxTpVIJqGh3dzesSYQsbAJn0qB0GB8EB8HQWq0WVnmh0KBO0k+oqIw54+dsB7wc3yyeJ+DBLqCSlFLQ44aHh3P8eTYvm4ggHAIBXPbkpHFOATQ/IAEStoBnYBgVi0WdP38+gqVsQqzovr6+yBeRFBuYAJ5j+SQWEbT3bF7eMcsynT17Vj09jWS8hYUFLSws/ICAZ5PD2gIrbw8KDw0NRRE0krPq9RbJAM/M166vYT+A/uTkJPIygFd5LjATWcPM8eHhYXh37rV4YBxrnNpFxHqolSO1GDEwpNgL3nevrukHzzgMCWzG/nDFw/5zC519wNwynzSIGZAXUIKuWPDkWZtjY2Ph9bPWUeocbQqRgrkYHBwMmjTFB0dHR3V8fBxruVBo1DNbXV1VlmURTOc0sZ2dnfBoH6R1tAJAGLBgqE7IQA4PD6tQaHCbCWIhRCWFEO7p6QkL3yEHSSEQCHThguOyOwvEo+tYtGxsnokV53xsMG8EAcoC4YvScVydhehsG4d3Njc3tbW1FclX4+PjmpmZCeHvAVj3ZFwAEFuR7n1oy/j4eOCs3JPAJsLHrRxgHeYIxdxeBIyx93H0wBWbhPHgGShLlABWMRsYuiMCbXt7O8aQE5+kVnIUgoZ8iGq1qmvXruWEB32kSubOzo7K5bIWFhZULBZzlTbBg4lHuCVPOzg40Llz57SxsaFqtarr16+HNcqzEGKMFeOJIOf9HX4gnoMXXCqVwiKlxDPv7jAWCp96Sl5pE8iH/hPbgCXlit8FJvvIISvWOWuNeV9ZWQlhicHhQWDWip8ZcebMGS0tLalarer27dsxRh74JB7EPBKbcjhKamVf42nhIYG1817MBfEGYmV8H4o2Sqivr1WpFQXl+477MCasWw8Yu3HmCgwP4/DwUKVSSeVyWU888UScisacPkjreAXAAvea8CwQqRXUbXftWZxsBkm5E7ewPNGqxWLjZCqsNLSo1/V2S8SDwO0CzmuGcB+Or2vnDDPJLhzpA5PId4BIeJ/t7e0QHHt7e1paWsolJbmQYGMjbBznRykRjMaLYczwphAi9AvLGGijt7c3KhKyedx15f09UCkplAruPzESt7IR8Iw/DDCC7qVSKQcXDg8PB2sDlpcHC72VSiVtbW1pfn4+eN6cMVGvNxgkm5ubmpycjBr9CDQ2K4mCnrXuDTjo4OBACwsLeuqpp/Tqq69qbW0tShGAhQNjoQjoB+uP9So1hPT8/HwoMdYa2D6xBYdAnFrNegPu2tzcjMRHp0z62vPESleUPAPYEy9uZGQklyOAJ4vwW19fj1gdGdrsKQ/KLi8vx/gNDg7G6VeQC0hM9KqrvJcrA9Yga4lqnZxPzZri6NFisagLFy7o4OBAL7/8cpAdsiyL4149voXccCqnexjMJfsRpV6v12MO/VArDB2MMdY196IshydSviUUANaUByTr9Qbn1jP46vW65ubmYtOwCVnsUuuQEcdi79y5kzuoe3t7W729vRoZGYmFg7XogUmfPBcobAgWAb/jwgH1HB4e5g6QZsJ4F3ctmWAWOC4rfGuef3R0FNmKLFDHK/nXaX4EoSgstb29HSwM/o5rzfj7GOCCQ10kpwIFROKeM57YdL45POsYix7oAqsPOiKeCKwh2EQoOIQsXpxbUcRPBgcHA8M/PDwM78sDhYwrtLuTk5NQMG79okBRksyhkwdYg7zfzs6OnnvuOZXL5chkR6CydrDavdgX2cdQKBm/QqEQDCOuQ09E8PX19UXdJtZaSkmTk5MBFeJF0EcgOfIqarVaWOy1Wi0o1YwzsE/7uKPcGQcgGgStQ1NHR0c6f/68JiYm9N3vfjc8Wph9kABY5ygaPAaUMrLC4Vv3Ip0l6IYQFj3xMeI15FTQF5QIMT0PfvN7O63WjUS8CALYtVotss7x3jECHWbyOWefLC0tBRMMJfGgraMVgNQSCFJLkLEByBCknnl/f7+uXr2aExoebec+eAoEjXCBPWAD/t6eAekuIgqCheQYsS8uhKj/nfdBSLbXiu/p6QklUSqVAguErtbf3x+HPjgG284mQAAj1Ai8ScpBKxsbG4G1Hx8fa2pqKurt0C+vJ4MQZ0MSK/GFODAwoGq1Glx8hKozOOr1epx9ixfHBkBooYx4D5g7bFrHy6VWsT8Pyp6cnITC9LFhrLzmPJYvilTKxy4kReaoxwMQRO7ZQYn009SwamGdsCbY9PTTPQCC2Qj6g4ODyKjl8JTd3d3IHuU7TjuUFOw2vAmvYUQZEDdSnLFE0qHnXdRqtajIilAHy2cuEMDsWxeSQB3sA5hjvDdGhSeLedE5n3fieexnn2f32pljxpHvt0M+GBojIyNRLsXvi2HgZA6HdXt7e3Xp0qWgdbJWvWwNnjoxLfIVMPZAEFAWxKzoJ14tMoA19qCB4I5WAD6xbEqwXc5lha/PASBQ6IAL2MhSazEi+AkCAiO5AsBawZUrl8va3NyMzYGAcUtMaqVyS60F5clZ3ui/pGA1EdDDAsMSJqDorBSe69YT0AowCoKFH8fbnfbJu7IwNzc3c0f9sfDZYCMjIyGoUHK44kAFnmncriSxvicmJnJjRz4FwcbR0VFtb29HcTDG1TFsF6JeydK9DQ+YI6g8o9MVNoINocT/8Rx7enqCvUNJbyALx6GZW/d4nKzg/9JfBKqXHPCkOiACZyHB7lleXs5ZgBgSKAe8DIcXmB8/FAfPgP2Dwt3b29Pa2lrOigXSSSnFu2VZprGxxumvS0tLuTmB+gnk4/V62OdXrlyJBLd24c8749Gj8DDGoARzX2iS5BHB0mFN4FUiuGEjeaVUp3xiFDEHvb29unjxYuwp+PtUE8BzI6ER45E1y3M8LlUoFDQ9PR2VkDFSMTaZW/ZaO3kAT/FBWkcrAPAvpyg65ggFk1rwWLSc5esc3ps3b2p6elpbW1tRB9xZOFL+ODueiSLAugWSYQM6JY37gcEisLFwoUp6/ADFgKvoWDiWnSe01Gq1XGEs/vVAoqRQWhw8giKgbAQByo2NjfAeuN/JyUlg0rBPvOQEiq1YbJRuIAiHkGHTesIQCgLrD+tneXk5rB2phZWjIK5cufIDrvO9oC2vk4TQRnA4FAWePDg4GJ4UlFmnUKIYXMEyVxTiwuIHCoEBBBxFVjAxqnK5nPM6GENX4Jubm7lYC313C5+zDihg56wSt2C5J16VKzbOswUqm5yc1MjIiE5OToJxAgw1Ojqay0tgfqgZ5GPk9Efud3BwEEKW07C4TqkFPCXe37PLia84IYQ94zg5QWoYdqyXUqkUHiRsHg9Is1ZQkKxXYCLkAQKahmwYHBzUpUuX9M1vfjO3TovFol599dVYS4VCgx1E7srh4WG8r6/pWq0WeD7XMOq4v8se1gfv0n6G9v1aRysASeESunWGQEPoYeX39TVqxnO0HYcvILDgWrsr7y4T3gBCFU3NguUzaF6ueZAHbBoGkm9E3GOK0wF7YCESwNrY2NDw8HAum9jhJz4/PT0dmwGvhIUGxIXQr9UaZY/prysyvKZ2gVqpVOIEIrwlL3hVq9XCc/IjCr0+CX12BYn7zQInDoPydGgJDJuEH6w+h9kQbNwbmAvMH5YHa8Rhu52dnaCj+hGYrA/ezTfc2tpaLtsXSq5nPtdqtRyk4tmmThJgXPyZ/n7uPVIWYHNzM6dcpFYsya1lhBXPo4/EbBjP4eFhTU1NqVKpaGFhIbJZCc5iCHEA/fLycngGCCdXzCgy1heGQLlcDpptT09PJAgCgW5vb0cOAX2Hfst6v337do7WenR0FJn+KC3yeNjLS0tLWlhYiDEi5uEwjENKCHCPyUgtAwAFgxFH+Qmn/dIvDFTyZcbHxyUp58ltbGzkWIbEKR1awlsC1saQAJJz9pafBPd6reMVgGs5d8U9+IhFTN0cpzyy2Nw6JoPYTxKqVCoRYMMiZlHhVrn77IvdFRELjGdjKSI8PbCJhUf/iWOsra3lgrhsLnj1ZAi/613vUkpJ169f1/z8fM49Hx8fj41JwGxvby/ql4BFYnFILSaDKzaHNJgPr8fCe2xtbUV+BsdCAg84xERg0S0pFCtjBs7tafser5BaJS/YGFiKWHB4HghkYAgUq7OLgBEcWkJ4FQqFSCLDumKuUcx4okBgzBnJS1hnxHUwalzQeWyl3RtijKRWpdVr167lGF2OJ3M/vkvNHaCv7e1tDQwMhHfgJU5Qim4IsYeYc+fNA4M4xRoBCDsJrw+h796swz9QQEdHRyP/hP3qZxX4vDPWnLzFuHlznJ/1xHi5t0DfuRfz7yQNxpG15fvLoUyweYwCMpxZBwcHB6pWq5qamopjKlGSbozhLXK8KzKlUqkENZ51zPrwPr5e62gFAH+/Xq9Htp3UgluwrJyaBjWM5Cf/OwFdrEswQCigCHzwMxYYVhMwUKlUymGmfMYZLZ6E4wt1eHg48hew0p2pwcEXft4ok9vT0yhbOzU1pWeffVbPPPOMLl++rK9//ev6/Oc/H9Y3cEilUgn+tKScdVgsFkPA0lcEgrM12Jx4QX7KFIdl7O7uBnbPOxG09sQrqYWLU86ad6f2vpRPLMMjwFPy4KF7WOSMDA0N5awuhDMBbJS4pNhobF6EgSfpAZehNFAofJdERcbEqYeMG3NHc8zXm78P8CWtt7dXY2NjMadSKx7jVGfWbX9/v5544okooYB1v729HTWpUCqMx/b2dk4JoXDZOysrK8GMGRwc1NTUlLa3t8Mz6e3tjWRD+kxMCg+cftOAfur1RoXRnp4eTU1NBbwG5VFSQKIIQKBWBOzW1lYuHuEMPubZmUnuxTibCU+iXC7H/unp6Ym4IoiCn7nNHmP91+v1gOhYA7VaLQ4runz5sq5duyZJUfn35OREc3Nz2traCi8A5elwNOPQvt54/lsmEYzBrlar4bJJLZeWxYBmRVj5d1EWWEfOn8bqpAw0XGogJiABuLdobxpwDtcQjuCS7a4qCwZoxlke5XI52BNsWJQZeClKZ3t7W7du3VKxWNTt27d169atOIoRFpEL9HaanUNbTodzhgT9pn8sOFzjUqkULCUCYyxCBC/lIoCnyIVgXlAqeDaU6vCAPMwQhJwX02PDesIbODhwD2UGENhYrP6+h4eHubIAeEvtsQbm2a1iqaHYweFXV1dzzBAXQPwfIYN1jKVJf6HUev7H0NBQlGDmHu4VOM69tbUVzDhJesc73iGpATssLS1FrR2yw6nkifXN/DtOTt/Ze3hpfX19UbrhXnx33xN4LBhixJTAwMnPIcmLGlruafr+Zk6p38V+8v56oiJjNTk5GeOEocQaZ7wxflD4xWIxUAIUBwYmHlE7/Mb9/EhHDJKrV69Gsbx6vR4GDp4d9/KCiR6fZPz29/dzWees27dMHkCtVgtoA6GN2+sbl4VJIgcsIbjRLGoWLYlNWIvAM1irDuOwGXp6eu5ZNREXkM9gGbJBPYAGFbNYLGp5eTm0+v7+vlZWVoKD7wLAYQU8DJJiFhcXA4t3wV8oFLS3t/cDAd5CocWDh6JJ30l+4XO+oKUWzoyglZQ7mxl3l6Qrh5D6+voiYUVq1MEhgOrWEx6aQyNcY3xdKPDv0dFRKEyExblz56La67Vr12LeYFexxngvSkWglKTWITLkGwAn4LWguFiTwFkeZ/D4BH32GjAunIaHh0NA8h54qCha5tVhRgK7+/v7Ghoa0uHhoV588UUVi0UtLCxoaGhI09PTcW9qXhHTgULocSb/F0ML2APYrZ2h4xAea5a9ChTFWHEwE/AX8CRQop+S5VROxsAJA1mWqVqt5s6uBjlwGK5SqaharYZA3djY0P7+fqx7jD2gFNYKnH+P1aDMMER9PBxiYo7biR6FQiEK9NFXktJI1pNayWLME/dAeXsMg789aOtoBSDlNSkBvoGBgYigu0tYrVbjvF/gGCwnBlZSYHwsMAQIE3Ev/IzFgKsGzofV4YICT8Td8nq9UUmzXC6H5Yzy4f7cywvQOZddUgTtxsbGwsugFEStVgsYCEjDmQQO7QDFOLPCKw+6EOQawo1+SC0aKhY+cI1X52Ss+GylUtGFCxckKYr3OUOIuUYReH13vAM8g8HBwRCO5IUQ47l8+bLe85736Nvf/rZWVla0vb0dwgBBVa/XQ3G5smKcEDDFYjFX+I/NDp5PqRGMEYc5uAeKi83vx0pKrU3NXMGqQknyfcpSULqBe+/v7wcjzjH89fV19ff3xznGzAnzh1AGU3b2DWuVrNejo0YlTGJhLviwjGFEMR47OzsxN729vZqdndX+/n4k9TGOMNPwZF0JozB4N56Dt0QpBTx5V7oIX6zpg4ODqJ3k8QA32vAq2ddg7cwTwhyjDuXIPLCGCSgTp2D+2+Nek5OTcYgRa31raytnCLYH2v3oS29kMD9I63gFILVKP0xOTkaJZer+EGQ8OjoK/rELp6mpKZ05c0Z3797V97///YjOg7lDmWIiCDY5bEJjUx0fHwfzg0WOQAErxk2Ha01jcThfG0F0586dSNLhncErPdHr7Nmzeuqpp3RwcKDBwcFQLFAx3ep0Ic7CwxrClUTAVavV6CtuKN9BiFOACiql0zxxS/EsUmqcauVURjJLz58/H9RG4jUOuzjOzuaB/TrQAAAOkklEQVRhUSPw+vv7gxI5PDysvb093bp1S8vLy0qpcRj91772taDd4RVK+QNPcPnBdtmoxDFYX7DM3MLCICgUCgEDsVZQDFJD6DilGAPF1xgCH7wZaALMF8U3MTERCgRlMj4+nmM4AavgnQBXYGSgqFFWbvQw1xxkTg4AeDxrk745HMW7Y+XiudHA0avVagjujY2NgGLYF7BlKABJn0jIYzwp5U4RNIwyjAkopTCFOJiGYnTsEQL4juv7ITyOArhH3e7pOBw5NDQUkC3P4aAZEIYsywKqw0PhnsCCHnRmvWCMAFMhJ5w88iDtdRVASukzkv6mpJUsy55qXvt1ST8m6VDSVUk/k2XZVvNvH5f0c5JOJP3jLMu+0Lz+QUn/VlJR0n/KsuxfPkgH3V0sFos5nJVyDkzQyMiINjc3I3CDUBsbG4tTs0gEmZ2djcAyASeq8ZEF7NxatxQQGh5MdAvdNwPYtbuDuJ/c16EbXD+48Vi8jtcvLi6Gkrtz5452d3c1NTUV+DzWrN+7PYfBT4eCYonSIwDW19cqK827Y5lj0XEeQb3eYBXhMk9OTmp5eTkwbc9r2N/f1+3btzUwMKByuRwUOJJipNbiJyCLpYulJSmog729vapWqzpz5ozq9XoIhDt37kTxMuaImAosDSxQaLooSDahJyrBMkNh4YWyNo+OjqK6I/ONh8JGxro7OjqKctbkiuzt7YWSK5VKOnfunCYnJ7WxsaHV1VUtLCxEfAE2EGy4p59+WqOjo3rhhRci8xr4zOEunocg49lcx1pHeY+NjWliYiKUJErJPWUUIOPlXpa33t5ejY+Pa3R0VJcuXVKt1jjI56tf/WqUZcG69twMDDb3QF0AV6vVnCJyogAMNY/neMYswhNevlvl7kE7k9CFskNCzBv0aWcrsjfYZyg6DETgH+qeseZgafFsUA3+v76+HsqmXq8Hy+pB24N4AL8l6d9L+qxd+5Kkj2dZdpxS+qSkj0v6lZTSOyV9RNKfl3RG0v9KKV1ufuc3JP0NSfOSvpZS+lyWZS/c78FO0QIacYvQrSQXaAhtsG6vcyM1LDACTKOjo1HauFgsBlUSAcB1hDNBH8qvcjAN/UVwtQsyLBLfGLi2jm9jzVWr1XifO3fuRAB4d3c3d0oRmDaBV7fg4VTDiOnvb5ynzCKBZSMph7kiuHp6euKQDvqM4ETBsLlY7LwjWK5bqoxHvd7gZmMFgel6UJM595OhPADNRifJ6NVXX1W5XNba2pr29/d1cnKi69evhxD0Dcu/7sozZh5TQLABk6SU4sQrz0puFxau7IFQEP4QACYnJzU/Px9jSj+91gwZuUAqFP/Dy9jb21OpVAqv9+bNm7px40buhDvObmDvoHS9OB1KAi/Iab77+/saGBhQX19fGBH8jmCmT4wXCsoT/hiPnZ2dWA/spUqlEt4m+wIDh7iQe2jsM+aAbF/KVwATAQvhFSMXMK6Ojo6igizGFd6/H9NI3/18Dlem7GMMVdYlaALrnMQ5F9A8l7hDO/wMzEUAularBRsMmJhEOIwch55fr72uAsiy7E9SShfarn3R/vsVSX+3+ftPSPr9LMtqkl5NKb0i6b3Nv72SZdk1SUop/X7zs/dVAM6bZWAYVIQSqdIEcSTpwoULYZ1zEAvYGhPvATaSbSjj287ndeuDM4rL5bJmZ2d1/vz5HIzBgQxYEWDVTDyCEw3uAZyUks6dOxfZtQsLC7E5EX7cQ1Ku3LHUsspwDz3YWa/Xw0oA252eng62yM7OTgSWeYYnl7DQeTfcUQJWHD5/fHwcNWoQPlhYfrgLh64wD4wJ+RmMO5g4lqUzjer1VkE6BNn6+nquEmOWZTlFw3OAAAmWI5j5v8NNeDCwLNyyBXZ88skn9cILL0Qgmblw7J7nEgAHJ8f7pBotuO/KykpATysrK6H4/JxjNv6Xv/zloEEioAmM+9rAA/F4D0qcBCkSB1kH0FYxKBA87BG8KuaFNckeRWGyx4C/KDcBndhZaBx7enh4GF4Vwthhx1qtpmq1GnE+DBT2JIlnnh0LKYQ1QOIYVjr39bwO1gbyA6UNVo8hAPTmJS/YN+4pMC7+fyc+8H4E7fEagbCA8IDCCLRD1X7Q9v8jBvCzkv6g+fucGgqBNt+8Jkm32q7/pde7seOrBHOx0jc3N+NlPXh39+5dzczM6MyZMyHMrl69GgueTc8PjU2LSwhuioCG50wFR4TX3bt39cQTT6inp0eLi4vBsYYJwUIjuOVwD5im4/xg+cA0njBDbRwgE7wiSWE5sugqlUpYP+DabOLt7e24NjMzE1bmSy+9pPn5+ah94pYhi5JchlKplKNXAtNgGZ07dy7GlLGfm5sLK8Z5zVKeWglND/zZ8z94ns8l1DypsZHoH4IMGAAlDIx3eNg4vJ0yz4VCIbjujPnIyIhmZ2dzHHneEcv07t27eu6558ITc+Xv2LBDcgSN8cZmZmYifoK1vrGxkatTg1D39ydnxPNXiGUdHR1FPRmUJ6esUcNKUqwlLPL+/v5IfEQZsQcpp4IQnp+fz2WxtufJEHgF3mHPcI5FX18jAx4Fi/Cl2B/xCZQX68CTCZeWlrS3txfP6+3tDSsflhfzxlpgnjiVDa8FCJe5RQDjMaLMUSIoOhSAk0pQBM4A4jMw6VgrhUIhFzinRAneBMId5fbCCy/k1gAEgIdtydkKr/mhhgfweWIAdv0Tkt4t6SezLMtSSr8h6ctZlv1O8++flvRHkgqSPpBl2T9sXv8Hkt6bZdk/usezfl7Szzf/+0OS1iWtPfSbPZo2ocenr9Lj1d/Hqa9St79vZnuc+io9mv6ez7Js8vU+9IY9gJTSR9UIDv9o1tIi85KesI+dlbTQ/P21rudalmWfkvQpe87Xsyx79xvt52m2x6mv0uPV38epr1K3v29me5z6KnV2fx88XGytyej5FUk/nmXZvv3pc5I+klLqSyldlHRJ0lclfU3SpZTSxZRSrxqB4s/92brebd3Wbd3WbX+W9iA00N+T9NckTaSU5iX9CzVYP32SvtTEtr6SZdkvZFn2vZTSf1UjuHss6RezLDtp3ueXJH1BDRroZ7Is+96b8D7d1m3d1m3d9oDtQVhAP3WPy5++z+d/TdKv3eP6H6kRD3jY9qnX/0jHtMepr9Lj1d/Hqa9St79vZnuc+ip1cH8fKAjcbd3Wbd3WbW+99oZiAN3Wbd3Wbd32+LeOVQAppQ+mlF5OKb2SUvpYB/TniZTS/0kpvZhS+l5K6Z80r/9qSul2SulbzZ8P23c+3uz/yymlDzyCPl9PKX232a+vN69VU0pfSildaf471ryeUkr/rtnf76SUnj3lvv6QjeG3Uko7KaVf7pTxTSl9JqW0klJ63q499FimlD7a/PyVJpPuNPv76ymll5p9+sOU0mjz+oWU0oGN8W/ad/5icw290nyndK/nvUn9fei5Pw258Rp9/QPr5/WU0rea1x/52N63USCpk37UCBRflfQOSb2Svi3pnY+4T7OSnm3+Pizp+5LeKelXJf2ze3z+nc1+90m62Hyf4in3+bqkibZr/0rSx5q/f0zSJ5u/f1jSH0tKkt4n6U8f8fwvSTrfKeMr6UckPSvp+Tc6lpKqkq41/x1r/j52iv19v6Se5u+ftP5e8M+13eerkv5y813+WNKHTrG/DzX3pyU37tXXtr//a0n/vFPG9n4/neoBvFfN0hFZlh1KonTEI2tZli1mWfaN5u93JL2oVpbzvVqUxciy7FVJXhbjUbafkPTbzd9/W9LfsuufzRrtK5JGU0qzj6KDkn5U0tUsy27c5zOnOr5Zlv2JpI179OFhxvIDkr6UZdlGlmWbatTU+uBp9TfLsi9mWUY9gq+okY/zmq3Z50qWZV/OGhLrs2q945ve3/u015r7U5Eb9+tr04r/e5J+7373OM2xvV/rVAUwpx8sHXE/YXuqLTUyo98l6U+bl36p6VZ/BhhAnfEOmaQvppSeS40Ma0mazrJsUWooNUlTzeud0F/aR5TfQJ06vg87lp3QZ9rPqmF10i6mlL6ZUvq/KaUfbl6bU6OPtEfR34eZ+04Y3x+WtJxl2RW71qlj27EK4F5YWEfQlVJKQ5L+u6RfzrJsR9J/kPTnJP0FSYtquH9SZ7zDX8my7FlJH5L0iymlH7nPZzuhv0qNRMEfl/Tfmpc6eXxfq71W3zqiz6lRwuVY0u82Ly1KOpdl2bsk/VNJ/yWlVNGj7+/Dzv2j7q8k/ZTyxkunjq2kzlUA9ysp8chaSqmkhvD/3SzL/ockZVm2nGXZSZZldUn/US0Y4pG/Q5ZlC81/VyT9YbNvy0A7zX9Xmh9/5P1ttg9J+kaWZctSZ4+vHn4sH3mfU6uEy99vQg9qQinrzd+fUwNHv9zsr8NEp9rfNzD3j3R8U0o9kn5SreKYHTu2tE5VAB1XOqKJ7X1a0otZlv0bu+44+d+WBDPgtcpinFZ/B1NKw/yuRgDw+Wa/YJ98VNL/tP7+dJPB8j5J28Abp9xyFlSnjq/14WHG8guS3p9SGmvCGe9vXjuVll6jhEtKaTKlVGz+/g41xvJas893Ukrva67/n7Z3PI3+PuzcP2q58dclvZRlWUA7nTq20U476vygP2owKb6vhsb8RAf056+q4aJ9R9K3mj8flvSfJX23ef1zkmbtO59o9v9lnXKEXw0mxLebP99jDCWNS/rfkq40/602ryc1Du252nyfdz+CMR5Qo/rriF3riPFVQyktSjpSw3r7uTcylmpg7680f37mlPv7ihoYOev3N5uf/TvNNfJtSd+Q9GN2n3erIXivqnEwVDrF/j703J+G3LhXX5vXf0vSL7R99pGP7f1+upnA3dZt3dZtb9PWqRBQt3Vbt3Vbt73JrasAuq3buq3b3qatqwC6rdu6rdvepq2rALqt27qt296mrasAuq3buq3b3qatqwC6rdu6rdvepq2rALqt27qt296mrasAuq3buq3b3qbt/wGsoLATcKSW+gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "full = tf.imread(filenames[-1])\n", + "print(full.shape)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "ch = 0\n", + "for ch in range(full.shape[0]):\n", + " img = full[ch, 0, 0, 0, :, :]\n", + " img.shape\n", + " plt.imshow(img, cmap=\"gray\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\21-Mar-2022_13-22PM\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2.tif\n", + "(1, 4, 1, 1200, 1920)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ch_img = tf.imread(filenames[-2])\n", + "print(filenames[-2])\n", + "print(ch_img.shape)\n", + "img = ch_img[0, 0, 0, :, :]\n", + "img.shape\n", + "plt.imshow(img)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "4568d59ad21c389a2a9cb944bb46da796561918dbb67dbbce32732a4330b1011" + }, + "kernelspec": { + "display_name": "Python 3.7.11 ('piescope')", + "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.7.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/piescope/utils.py b/piescope/utils.py index e1e3e12..22e6705 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -114,12 +114,15 @@ def save_image( # if saving a volume: if image.ndim == 6: # (CAZPYX) --> (AZPYX) - volume_split = np.zeros(image.shape) + tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) + temp_destination = destination + print(f'Image shape when saving: {image.shape}') + # volume_split = np.zeros(image.shape) for i in range(image.shape[0]): - volume_split[:, i] = image[:, i] + # volume_split[:, i] = image[:, i] metadata.update({"axes": "AZPYX"}) - destination = (destination.replace(".tif", "") + "_channel_" + str(i) + ".tif") - tifffile.imwrite(destination, volume_split[:, i], bigtiff=True, metadata=metadata) + temp_destination = (destination.replace(".tiff", "") + "_channel_" + str(i) + ".tiff") + tifffile.imwrite(temp_destination, image[i], bigtiff=True, metadata=metadata) return # otherwise save regular image From a49dd0b8732b7419a8876ea4d3a168dc95749160 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 23 Mar 2022 16:34:40 +1100 Subject: [PATCH 65/82] integrate the guis Co-authored-by: DavidDierickx --- piescope/utils.py | 12 +++++++++--- requirements.txt | 2 +- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/piescope/utils.py b/piescope/utils.py index 22e6705..e7bb5d9 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -269,12 +269,18 @@ class Crosshair: rectangle_vertical: plt.Rectangle -def create_crosshair(image: np.ndarray or AdornedImage, settings: dict): +def create_crosshair(image: np.ndarray or AdornedImage, settings: dict, x=None, y=None): if type(image) == AdornedImage: image = image.data - midx = int(image.shape[1] / 2) - midy = int(image.shape[0] / 2) + if x is None: + midx = int(image.shape[1] / 2) + else: + midx = x + if y is None: + midy = int(image.shape[0] / 2) + else: + midy = y cross_width = int( settings["imaging"]["crosshairs"]["thickness"] / 100 * image.shape[1] diff --git a/requirements.txt b/requirements.txt index 95cdb60..886a9ee 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,7 +6,7 @@ pyserial PyYAML nidaqmx pypylon -pipython +pipython==2.6.0.1 opencv-python # dev flake8 From dd4490ba28c89daf2da2a9753a2c3a31f0528c04 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Wed, 23 Mar 2022 17:46:21 +1100 Subject: [PATCH 66/82] fixed last fib image type issue --- piescope/correlation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/piescope/correlation.py b/piescope/correlation.py index 99971f1..129dc61 100644 --- a/piescope/correlation.py +++ b/piescope/correlation.py @@ -142,7 +142,6 @@ def correlate_images(fluorescence_image_rgb, fibsem_image, output_path, matched_ Expecting .data attribute of shape (cols, rows, channels) output : str Path to save location - matched_points_dict : dict Dictionary of points selected in the correlation window """ From 8bfb04234039ef8f74a2b3e6f22aa34a47f287a9 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Fri, 25 Mar 2022 17:04:08 +1100 Subject: [PATCH 67/82] conf update --- piescope/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 9abdd6a..3537169 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -52,7 +52,7 @@ lm: - 143 - 51 power: 10.0 - exposure_time: 100.0 + exposure_time: 1000.0 volume_enabled: false - name: laser640 wavelength: 640 @@ -62,7 +62,7 @@ lm: - 148 - 43 - 35 - power: 21.0 + power: 10.0 exposure_time: 1000.0 volume_enabled: true imaging: From 2990f18fe07d3553615abad3bcd5fdf1c73b3b6c Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 7 Apr 2022 17:14:39 +1000 Subject: [PATCH 68/82] Fixed volume saving notes --- piescope/lm/volume.py | 25 ++++++++++++++----------- piescope/utils.py | 17 ++++++++++------- 2 files changed, 24 insertions(+), 18 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index b53a489..d2fa038 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -38,14 +38,14 @@ def acquire_volume( mirror_controller (PIController): Mirror Controller objective_stage (StageController): Objective Stage Controller detector (Basler): Basler Detector - arduino (Arduino): Arduino + arduino (Arduino): Arduino settings (dict): configuration settings of the user interface Returns: np.ndarray: volume stack of images, always 6 dimensional (CAZPYX) """ time_delay = settings["imaging"]["volume"]["time_delay"] - if imaging_type != ImagingType.WIDEFIELD: + if imaging_type != ImagingType.WIDEFIELD: angles = settings["imaging"]["SIM"]["angles"] phases = settings["imaging"]["SIM"]["phases"] else: @@ -111,26 +111,28 @@ def acquire_volume( arduino=arduino, ) + # CPAYX slice_reshaped = np.array(slice).reshape( volume_enabled_laser_count, - angles, phases, + angles, array_shape[0], array_shape[1], ) + # CPAYX img_index = list(range(len(slice))) for channel in range(volume_enabled_laser_count): - for angle in range(angles): - for phase in range(phases): + for phase in range(phases): + for angle in range(angles): # get the index for each parameters image in the slice # see notebook for details idx = img_index[channel::volume_enabled_laser_count][ - angle::angles - ][phase::phases][0] + phase::phases + ][angle::angles][0] # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] - slice_reshaped[channel, angle, phase] = slice[idx] - volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) + slice_reshaped[channel, phase, angle] = slice[idx] + volume[:, :, z_slice, :, :, :] = slice_reshaped # (CPZAYX) # Move objective lens stage target_position = ( @@ -156,7 +158,7 @@ def acquire_volume( logger.debug("Difference is: {}".format(str(difference))) count = count + 1 piescope.lm.structured.single_line_pulse(100000, settings["imaging"]["volume"]["slice_interrupt_pin"]) - + # Finally, return the objective lens stage too original position objective_stage.move_absolute(original_center_position) @@ -213,6 +215,7 @@ def grab_slice( ) grabResult.Release() detector.camera.Close() + # CPAYX return images @@ -330,7 +333,7 @@ def grab_slice( # if mode != "widefield": # angles = 3 # phases = 3 - + # # Create volume array to put the results into # array_shape = np.shape(detector.camera_grab()) # no lasers on diff --git a/piescope/utils.py b/piescope/utils.py index e7bb5d9..16f610a 100644 --- a/piescope/utils.py +++ b/piescope/utils.py @@ -90,15 +90,15 @@ def save_image( # Make sure the output file format is acceptable if not destination.endswith(".tiff"): destination += ".tiff" - + # Append timestamp string to filename, if needed if timestamp: timestamp_string = datetime.now().strftime("_%Y-%m-%dT%H%M%S%f") base, ext = os.path.splitext(destination) destination = base + timestamp_string + ext - + os.makedirs(os.path.dirname(destination), exist_ok=True) - + if isinstance(image, AdornedImage): image.save(destination) logging.debug("Saved: {}".format(destination)) @@ -113,14 +113,15 @@ def save_image( image = skimage.util.img_as_uint(image) # 16 bit unsigned int # if saving a volume: - if image.ndim == 6: # (CAZPYX) --> (AZPYX) + if image.ndim == 6: # (CPZAYX) --> (PZAYX) + metadata.update({"axes": "CPZAYX"}) tifffile.imwrite(destination, image, bigtiff=True, metadata=metadata) temp_destination = destination print(f'Image shape when saving: {image.shape}') # volume_split = np.zeros(image.shape) for i in range(image.shape[0]): # volume_split[:, i] = image[:, i] - metadata.update({"axes": "AZPYX"}) + metadata.update({"axes": "PZAYX"}) temp_destination = (destination.replace(".tiff", "") + "_channel_" + str(i) + ".tiff") tifffile.imwrite(temp_destination, image[i], bigtiff=True, metadata=metadata) return @@ -131,7 +132,7 @@ def save_image( metadata.update({"axes": "CYX"}) skimage.io.imsave(destination, image, imagej=True, metadata=metadata) - + logging.debug("Saved: {}".format(destination)) @@ -150,6 +151,7 @@ def max_intensity_projection(image: np.ndarray) -> np.ndarray: """ results = [] + #CPZAYX if image.ndim == 6: for channel_image in image: # collapse angles, phases and planes, keeping cols, rows and channels @@ -158,6 +160,7 @@ def max_intensity_projection(image: np.ndarray) -> np.ndarray: # put channels on last axis projected_max_intensity = np.stack(results, axis=-1) + #YXC return projected_max_intensity else: @@ -207,7 +210,7 @@ def read_config(config_filename): def write_config(config_filename, config): - config['imaging']['lm']['trigger_mode'] = config['imaging']['lm']['trigger_mode'].name + config['imaging']['lm']['trigger_mode'] = config['imaging']['lm']['trigger_mode'].name with open(config_filename, "w") as file: yaml.safe_dump(config, file, sort_keys=False) From eee65541841e17b3ea9d0c650c2fd2e58d018255 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 11 Apr 2022 17:27:39 +1000 Subject: [PATCH 69/82] updates --- piescope/lm/mirror.py | 6 +- piescope/lm/volume.py | 2 +- piescope/notebook.ipynb | 203 ++++++++++++++++++++++++++++++++-------- 3 files changed, 166 insertions(+), 45 deletions(-) diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index fa9fc95..3478203 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -3,10 +3,10 @@ import logging class StagePosition(Enum): - WIDEFIELD = [2, -3] - HORIZONTAL = [-3, -3] + WIDEFIELD = [3, -2] + HORIZONTAL = [-2, -2] SIXTY = [3, 3] - ONETWENTY = [-2, 2] + ONETWENTY = [-2, 3] diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index b53a489..9f59028 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -68,7 +68,7 @@ def acquire_volume( ) # no lasers on laser_controller.set_laser_power(laser_controller.current_laser, temp_power) - logging.info(f"Lasers: {laser_controller.lasers.values()}") + # logging.info(f"Lasers: {laser_controller.lasers.values()}") volume_enabled_laser_count = 0 for laser in laser_controller.lasers.values(): diff --git a/piescope/notebook.ipynb b/piescope/notebook.ipynb index a74918e..9801802 100644 --- a/piescope/notebook.ipynb +++ b/piescope/notebook.ipynb @@ -2,39 +2,91 @@ "cells": [ { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "['C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2.tif', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\21-Mar-2022_13-22PM\\\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2_channel_3.tif']\n" + "['C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\28-Mar-2022_15-41PM\\\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_0.tiff', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\28-Mar-2022_15-41PM\\\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_1.tiff', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\28-Mar-2022_15-41PM\\\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_2.tiff', 'C:\\\\Users\\\\Admin\\\\Github\\\\piescope_gui\\\\piescope_gui\\\\log\\\\28-Mar-2022_15-41PM\\\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_3.tiff']\n" ] } ], "source": [ "import tifffile as tf\n", "import glob \n", - "filenames = sorted(glob.glob(r\"C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\21-Mar-2022_13-22PM/*.tif\") )\n", + "filenames = sorted(glob.glob(r\"C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\28-Mar-2022_15-41PM/*Volume*93_channel_*.tiff\") )\n", "print(filenames)\n" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(4, 1, 4, 1, 1200, 1920)\n" + "(4, 3, 5, 3, 1200, 1920)\n" ] }, + { + "ename": "AttributeError", + "evalue": "'numpy.ndarray' object has no attribute 'metadata'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_16112\\2764541655.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mfull\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'metadata'" + ] + } + ], + "source": [ + "full = tf.imread(filenames[-1])\n", + "print(full.shape)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "ch = 0\n", + "for ch in range(full.shape[0]):\n", + " img = full[ch, 0, 0, 0, :, :]\n", + " img.shape\n", + " plt.imshow(img, cmap=\"gray\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\28-Mar-2022_15-41PM\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_0.tiff\n", + "(3, 5, 3, 1200, 1920)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -46,7 +98,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD0CAYAAACSA/HcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAEblJREFUeJzt3X2sZHddx/H3Z7u2CFq65Sl1d7VF1odq1NYNVkViLJa2Ilsf0BJMN7VmQwIKotEiiaCGRHxCCVqy2srWIA9WTDcGxU0h4h+2drctpe0Ce1ugvXZpgZYWxYjLfv1jfpdOd+/ep7l3Zu7+3q9kMuf85ndmvnNm7nzm/M6Zc1NVSJL6s2HSBUiSJsMAkKROGQCS1CkDQJI6ZQBIUqcMAEnq1NgDIMnFST6RZCbJ1eN+fEnSQMb5O4AkpwCfBH4cmAVuBV5eVfeMrQhJEjD+LYDnAzNVdV9VfQV4D7BjzDVIkhh/AGwGHhian21tkqQx2zjmx8s8bU8ag0qyC9jVZr9/zSuSpJPP56vqWYt1GncAzAJbh+a3AA8Od6iq3cBugCSeqEiSlu8zS+k07iGgW4FtSc5JcipwObB3zDVIkhjzFkBVHUnyauCDwCnAdVV19zhrkCQNjPUw0OVyCEiSVuRAVW1frJO/BJakThkAktQpA0CSOmUASFKnDABJ6pQBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUKQNAkjplAEhSpwwASeqUASBJnTIAJKlTBoAkdcoAkKROGQCS1CkDQJLWkQ0bVu9j2wCQpHXk6NGjq3ZfBoAkdcoAkE5yqzlkoJOL7wzpJLeaQwY6uRgAktQpA0CSOmUASFKnVhwASbYm+XCSg0nuTvKa1n5mkn1JDrXrTa09Sd6WZCbJnUnOX60nIUlavlG2AI4Av1ZV3wlcALwqybnA1cBNVbUNuKnNA1wCbGuXXcA1Izy2JGlEKw6AqjpcVbe16S8BB4HNwA5gT+u2B7isTe8Arq+Bm4Ezkpy14solSSNZlX0ASc4GzgNuAZ5TVYdhEBLAs1u3zcADQ4vNtjZJ0gRsHPUOknwD8PfAa6vq8SQn7DpPW81zf7sYDBFJktbQSFsASb6OwYf/u6rq/a35obmhnXb9cGufBbYOLb4FePDY+6yq3VW1vaq2j1KbJGlhoxwFFOBa4GBV/cnQTXuBnW16J3DjUPsV7WigC4DH5oaKJEnjl6rjRmGWtmDyAuDfgI8Bc781/y0G+wHeB3wzcD/wsqp6pAXG24GLgS8DV1bV/kUeY2XFSVLfDixlFGXFATAOBoAkrciSAsBfAktryDNxapr57pTWkGfi1DQzACSpUwaApLFzaGw6+CpIGjuHxqaDASBJnTIAJKlTBoAkdcoAkKROGQCS1CkDQJI6ZQBIUqcMAEnqlAEgSZ0yACSpUwaAJHXKAJCkThkAktQpA0CSOmUASFKnDABJ6pQBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUqZEDIMkpSW5P8o9t/pwktyQ5lOS9SU5t7ae1+Zl2+9mjPrYkaeVWYwvgNcDBofm3AG+tqm3Ao8BVrf0q4NGqeh7w1tZPkjQhIwVAki3ATwB/1eYD/BhwQ+uyB7isTe9o87TbL2z9JU2JDRtWZ1R4te5Ha2vUV+lPgd8Ajrb5ZwBfrKojbX4W2NymNwMPALTbH2v9nyTJriT7k+wfsTZJy3T06NHFO43xfrS2VhwASV4CPFxVB4ab5+laS7jtiYaq3VW1vaq2r7Q2SdLiNo6w7A8DL01yKfAU4HQGWwRnJNnYvuVvAR5s/WeBrcBsko3A04FHRnh8SdIIVrwFUFWvr6otVXU2cDnwoap6BfBh4Gdbt53AjW16b5un3f6hqjpuC0CSNB5rsafmN4HXJZlhMMZ/bWu/FnhGa38dcPUaPLYkaYkyzV/Ck0xvcZI0vQ4sZT+qx2pJUqcMAEnqlAEgSZ0yACSpUwaAJHXKAJCkThkAktQpA0CSOmUASFKnDABJ6pQBIEmdMgAkqVMGgCR1ygCQdNLxfxIvjWtJ0knH/0m8NAaAJHXKAJCkThkAktQpA0CSOmUASFKnDABJ6pQBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUqZECIMkZSW5I8vEkB5P8YJIzk+xLcqhdb2p9k+RtSWaS3Jnk/NV5CpKklRh1C+DPgH+uqu8Avhc4CFwN3FRV24Cb2jzAJcC2dtkFXDPiY0uSRrDiAEhyOvBC4FqAqvpKVX0R2AHsad32AJe16R3A9TVwM3BGkrNWXLkkaSSjbAE8F/gc8NdJbk/yV0meBjynqg4DtOtnt/6bgQeGlp9tbU+SZFeS/Un2j1CbJGkRowTARuB84JqqOg/4b54Y7plP5mmr4xqqdlfV9qraPkJtkqRFjBIAs8BsVd3S5m9gEAgPzQ3ttOuHh/pvHVp+C/DgCI8vSRrBigOgqj4LPJDk21vThcA9wF5gZ2vbCdzYpvcCV7SjgS4AHpsbKpIkjd/GEZf/ZeBdSU4F7gOuZBAq70tyFXA/8LLW9wPApcAM8OXWV5I0Iak6bhh+aiSZ3uIkaXodWMp+VH8JLEmdMgAkqVMGgCR1ygCQpE4ZANIU2rDBP02tPd9l0hQ6evTopEtQBwwASeqUASBJnTIAJKlTBoAkdcoAkKROGQCS1CkDQJI6ZQBIUqcMAEnqlAEgSZ0yADQVPPeNNH7+1WkqeO4bafwMAEnqlAEgSZ0yACSpUwaAJHXKAJCkThkAktQpA0CSOmUASFKnRgqAJL+a5O4kdyV5d5KnJDknyS1JDiV5b5JTW9/T2vxMu/3s1XgCkqSVWXEAJNkM/Aqwvaq+GzgFuBx4C/DWqtoGPApc1Ra5Cni0qp4HvLX1kyQt0caNG1f1/kYdAtoIfH2SjcBTgcPAjwE3tNv3AJe16R1tnnb7hUky4uNLUjeOHDmyqve34gCoqv8E/gi4n8EH/2PAAeCLVTVX5SywuU1vBh5oyx5p/Z9x7P0m2ZVkf5L9K61NkrS4UYaANjH4Vn8O8E3A04BL5ulac4sscNsTDVW7q2p7VW1faW2SpMWNMgT0IuBTVfW5qvo/4P3ADwFntCEhgC3Ag216FtgK0G5/OvDICI8vSRrBKAFwP3BBkqe2sfwLgXuADwM/2/rsBG5s03vbPO32D1XVcVsAkqTxyCifwUl+B/h54AhwO/BLDMb63wOc2dp+oar+N8lTgL8BzmPwzf/yqrpvkfs3ICRp+Q4sZRh9pABYawaAJK3IkgLAXwJLUqcMAEnq1EkbAP6TcUla2En7Kek/GZekhZ20ASBJWpgBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUKQNAXfB3IdLx/KtQF/xdiHQ8A0CSOmUASFKnDABJ6pQBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUKQNAkjplAGhiTj/99EmXcEKeOkI98F2uiXn88ccnXcIJeeoI9cAAkKROGQCS1CkDQJI6tWgAJLkuycNJ7hpqOzPJviSH2vWm1p4kb0syk+TOJOcPLbOz9T+UZOfaPB1J0lItZQvgncDFx7RdDdxUVduAm9o8wCXAtnbZBVwDg8AA3gj8APB84I1zoSFJmoxFA6CqPgI8ckzzDmBPm94DXDbUfn0N3AyckeQs4MXAvqp6pKoeBfZxfKhIksZo4wqXe05VHQaoqsNJnt3aNwMPDPWbbW0naj9Okl0Mth4kSWtotXcCZ562WqD9+Maq3VW1vaq2r2plkladP5hb31b66j3UhnZo1w+39llg61C/LcCDC7RLWsf8wdz6ttIA2AvMHcmzE7hxqP2KdjTQBcBjbajog8BFSTa1nb8XtTZJ0oQsug8gybuBHwWemWSWwdE8vw+8L8lVwP3Ay1r3DwCXAjPAl4ErAarqkSS/B9za+v1uVR27Y/mktWHDBr8pSZo6qZp3KH4qJJne4iRpeh1Yyn5U9+BIUqe6DQCPXpDUu24/BR2Tl9S7bgNAknpnAEhSpwwASeqUASBJnTIAJKlTBoCkr/Hw6L74akv6Gg+P7osBIEmdMgAkqVMGgCR1ygCQpE4ZAJLUKQNAkjplAEhSpwwASeqUASBJnTIAJKlTBoAkdcoAkKROGQCS1CkDQJI6ZQBIUqcWDYAk1yV5OMldQ21/mOTjSe5M8g9Jzhi67fVJZpJ8IsmLh9ovbm0zSa5e/aciSVqOpWwBvBO4+Ji2fcB3V9X3AJ8EXg+Q5FzgcuC72jJ/keSUJKcAfw5cApwLvLz1lSRNyKIBUFUfAR45pu1fqupIm70Z2NKmdwDvqar/rapPATPA89tlpqruq6qvAO9pfSVJE7Ia+wB+EfinNr0ZeGDottnWdqJ2SdKEbBxl4SRvAI4A75prmqdbMX/Q1Anucxewq83+F/AF4POj1DlGz2T91Arrq971VCtY71paT7XCZOr9lqV0WnEAJNkJvAS4sKrmPsxnga1D3bYAD7bpE7U/SVXtBnYPPc7+qtq+0jrHaT3VCuur3vVUK1jvWlpPtcJ017uiIaAkFwO/Cby0qr48dNNe4PIkpyU5B9gG/AdwK7AtyTlJTmWwo3jvaKVLkkax6BZAkncDPwo8M8ks8EYGR/2cBuxLAnBzVb2yqu5O8j7gHgZDQ6+qqq+2+3k18EHgFOC6qrp7DZ6PJGmJFg2Aqnr5PM3XLtD/zcCb52n/APCBZVU3sHvxLlNjPdUK66ve9VQrWO9aWk+1whTXmyeG7yVJPfFUEJLUqakNgGk7dUSSrUk+nORgkruTvKa1vynJfya5o10uHVpm3tNijLHmTyf5WKtrf2s7M8m+JIfa9abWniRva/XemeT8Mdf67UPr8I4kjyd57bSs3xOcEmXZ6zLJztb/UDuSbpz1znsKlyRnJ/mfoXX8jqFlvr+9h2bac5rvUO+1qnfZr/04PjdOUOt7h+r8dJI7WvvE1+2CqmrqLgx2FN8LPBc4FfgocO6EazoLOL9NfyODU2CcC7wJ+PV5+p/b6j4NOKc9n1PGXPOngWce0/YHwNVt+mrgLW36UgY/6AtwAXDLhF//zzI4lnkq1i/wQuB84K6VrkvgTOC+dr2pTW8aY70XARvb9FuG6j17uN8x9/MfwA+25/JPwCVjrHdZr/24Pjfmq/WY2/8Y+O1pWbcLXaZ1C2DqTh1RVYer6rY2/SXgIAv/mvlEp8WYtB3Anja9B7hsqP36GrgZOCPJWZMoELgQuLeqPrNAn7Gu35rnlCgsf12+GNhXVY9U1aMMzql17Hm21qzeOvEpXObVaj69qv69Bp9Y1/PEc1zzehcw0VPOLFRr+xb/c8C7F7qPca7bhUxrAEz1qSOSnA2cB9zSml7dNquvmxsGYDqeQwH/kuRABr+wBnhOVR2GQagBz27t01DvnMt58h/QtK7f5a7Laah5zvApXADOSXJ7kn9N8iOtbTODGudMot7lvPbTsH5/BHioqg4NtU3rup3aADjRKSUmLsk3AH8PvLaqHgeuAb4V+D7gMIPNP5iO5/DDVXU+g7OwvirJCxfoOw31ksEPBV8K/F1rmub1eyInqm0qas7xp3A5DHxzVZ0HvA742ySnM/l6l/vaT7pegJfz5C8v07pugekNgIVOKTExSb6OwYf/u6rq/QBV9VBVfbWqjgJ/yRPDEBN/DlX1YLt+GPiHVttDc0M77frh1n3i9TaXALdV1UMw3euX5a/LidecJ07h8oo29EAbSvlCmz7AYBz921q9w8NEY613Ba/9RNdvko3ATwPvnWub1nU7Z1oDYOpOHdHG9q4FDlbVnwy1D4+T/xQwd2TAiU6LMa56n5bkG+emGewAvKvVNXf0yU7gxqF6r2hHsFwAPDY3vDFmT/oGNa3rd6iG5azLDwIXJdnUhjMuam1jkROcwiXJszL4nx0keS6DdXlfq/lLSS5o7/8rhp7jOOpd7ms/6c+NFwEfr6qvDe1M67r9mnHvdV7qhcGRFJ9kkJhvmIJ6XsBgE+1O4I52uRT4G+BjrX0vcNbQMm9o9X+CMe/hZ3AkxEfb5e65dQg8A7gJONSuz2ztYfBPe+5tz2f7BNbxUxmc/fXpQ21TsX4ZhNJh4P8YfHu7aiXrksHY+0y7XDnmemcYjJHPvX/f0fr+THuPfBS4DfjJofvZzuCD917g7bQfj46p3mW/9uP43Jiv1tb+TuCVx/Sd+Lpd6OIvgSWpU9M6BCRJWmMGgCR1ygCQpE4ZAJLUKQNAkjplAEhSpwwASeqUASBJnfp/s2gbHFHtx1IAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD0CAYAAACSA/HcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvUmTJVl6nvec47PfOW7MGZlZWVmVNXUDPYDdDQKEAFCEOEgmM+2kH8CVfoD+irjQmjTJTDuZ0YQFrI0UCTSIHqu6a67KzMjMmO48+HiOFp+73xuRWQVg02xrxDErq8h7fbrux7/h/d7vPcpay+24HbfjdtyOf3hD/9e+gNtxO27H7bgd/3XGrQO4HbfjdtyOf6Dj1gHcjttxO27HP9Bx6wBux+24HbfjH+i4dQC343bcjtvxD3TcOoDbcTtux+34Bzp+7Q5AKfXPlVIfKqU+UUr9b7/u89+O23E7bsftkKF+nX0ASikH+Aj4Z8BT4EfA/2yt/eDXdhG343bcjttxO4BffwbwPeATa+1n1toM+LfA//hrvobbcTtux+24Hfz6HcAd4MnWv59Wn92O23E7bsft+DUP99d8PvWKz65hUEqpfw38awAH57sx3RtH2D6ERaFAKzmKtVhrQSGfK7X1mUI5uvkMY7HWbM6uFKq6GKWU7PMKeEwpJdtoBao6nlZgrOxd71NdT3Oltv7+FTdF63qjze+rr7u6a/I7t/x19b0COb/S4DrX9pf/bt47Wx+wur76+s1mX6UoA0e+yg2qMHI+R4NWWKWwjsJqUEa2ATDe5lnozKDSHMqyukda/lNAabBlCdbKb9caG3gYT2NcUBZ0YdGrXK7RqbZxFKq0cszSgOtQtDyMByao5kOhcFJwVyUUpWzb3CMln2kF2sEGLsbTlF51zhJUaeUcxsrvNqU8W2ur61dgjfztupSBXJep3iQnA52WqKyQc9e/meoeuy7Wc7Cuwmq537a67bq0qNygjIW82DwjC9YauVeeh/EdykBhPFAl6EKu20kNZBnWVPe1vmZrsMagXBcT+xhH9jUeuGtkPwMqy6r3wqKUAseROVXfR0djPbeaB2AcJfetniPGYt3NHFUW2c8i+7qaItQYT67ZXZnNfbIWwgDja4wrz1ln8r0ty+rd1XIPq7lt6/dJVe+QUs021pTN3FfN/FOysa2u1Zjmfb72ritQSlevkWk+rN8ett7LV73PzXeol23I137+Ncf7+2yrFHM7urTW7v1th/p1O4CnwN2tf58Az7Y3sNb+G+DfAHTVjv2+82cAaN+TCVmWmCwXA+w46DjGZhm2KJpjKNcFazFJivJddBTKxAAoS2whk0omtSP7OA62LLF5dZwbrkr7Hqrdgvo8xmKLQs7lODKpADwf5WhsmmHX6802WstEVkrOb+TpKa2wxsrvg63vDMqV34fvQZbL9RUFNi9QjkL5PqraT3U62MBDGYt1q9+UF9jQx1a/Ua+SxujgOKhVgm1HYmwAAp/0sI3ODO4sQSU5arHC9jus73axCvKOg9XgpBZvXlC0HBbHDsHEEo5Lgss1zosx5vIK61r0Thdzbx/rOTjzFHU1wUymqJYPd48wsU/W89GFxZ2nOOdTzGgs13s0ANfBdCK5lryQF6comf2jExbHDpNvFKhSoQpF/wPF3n+Z4VzNISqwWQ55Vj1Pjep3yY/6LO5GLE7EEIWXFieF6LIgfLHCuZhgxhOU50DLA6Wx87kYRddFtVuUDw65+FaL9aFCp2L0O08M7ccr3KdXmGwM4dYEKktUFFG+dZes51PEDtYBqxW6sHizgvCLEVxNQFfzqOvLeYsCPRhQPjxi9E6LvKPIuuDPILowtJ8keOdzOL/E2AQVuaijfdRiRTmeoJRC9bqY4z0uv9ulDMRBx5eGzsdznIsJRBa7XIJnsVmGCgOZ4usEhULv9ijv7LK838YqWO1pvCW0TzP88yWqLMn32yRDH39SEJxO4fk5RCH2YIfFwx7zu444rAI6pyXdn19hF09RsQ+He+T7HbKBj7sqCZ7N4Pk51qbovR520MU6Dnq6kHuSpPK+V/ageQdrh1vbAN+DfhcCXz6bzDFXI3mHlEW3AjAGk6Zi9H1fbEU1X8xqhc0ymTuemEqbF5t3XenN3zeGqt45a+y17Wu7VR/3pXFzWxBb1RxYb7ZrHIHdOL9q/Hn577585YXdvM5fcxHYRYrA/xQ4RYrA/4u19v1XbV87AB3Kg6qNvApkgto0FUPmOPK9tU3EJ1GQQnc64jTSdGPwt26oct1mP2vs9QcN6DCQyRSFYoSzyqA00Z1CRaFEpI5GBYFMsPmi2Vb5/rXfdc3RwOZBb02W7clo82Jj+LcMuI5CbJKC1pWTUah2GwDT72A9BzTopIC8QGW57FuUUP1OrMW0Y1RekO930HmJezaFdYIddFm+MSDpi9GPRiXushQHkBuSoc9yX6MM7P1ohn7yArtYosJArsN1JNrvtlDLNSTyvMxuj3wQkQw94mcJ3osJ9mosDtJzZV+lZL91KpfpuZg44Nmf9Nj/m4SL3w3JemJ8g5Fl54M1/rOJRIa+h8py7Hgi0fvRPou3d5jdd0mGYAKLs1YMPjS0v1zL+eeL6rmaJkjAmI1BabUoHx6xOop4/ocKE1hajx0GHxa0P5nC5RjSVAKDKrionb86OaLc7bC4F2McCCYlTmbwRgnO+VgcTquFaokztsulXPf+kMl3D0h2FOsDRTACJ7F0Hxf4kxTn8xdy3cagogjV72I9FzVbUF5e4Zwcs35jj/GjgMnvFAyOp6T/acidv1jiPR9j14lEx56HXSwlYLEW5Tjobgfbjknv7ZAOXJYHDvGlITrP8MZrVGEwkWQjReziTzP0bA1X4rzt8R7jb/ZJdjTGB2cNBz+aoz9+jM0L9MEe+WGPvOuTdR38aUH0+Rh7+gLlOKjdHcphB+NpnFmKvhxjV+vm/VGOI9lo9U7W747yfXSnjQpD8D1sPc+vxpSjSWOAlSufm9WqMfC625VsabWWY5bldUO8bcxvjpvO4Jqh1q807M0x6+1uHO+as3jV+a7987qz+HPzf/4Xa+3vvfpiN+PXmgFYawul1P8K/HvAAf6PrzL+9VBaNQZTaYUKAonW61TXqY69FVU3+7quePHK2NbGHTYOonEajoP2q4MZg6Uy/nEERYGdzpqoQzmO/D8KxRlpLQ9pnVSGw4rxqEdtSKrPmuvRN9KMarLU2Y5ZJ/J59VB1GFyLBsxiKddhNtkHvieZQF6grIU0QxUVZJLn2F4HAiT6j8SRlt0AZ6nwPztrjl2e7LG6EwMQn+cEo5QycMi7HssDF12AvzDs/WSJezqSqN33USdHmEEbleaotIDJDM7WAn0M+6SHbbKeiyot7S+X6E9PMeu1vLh7QzH81YuuJgZ8j7LfZvGwzXpHkw4sT/8kJH5uOfzLnOiLiTi2ypHZwMEZLzFnF+hBn+StI6YPfWYPoWiXuAtNdKbof1LQ+mgEoylmudwYFZBryDK5t0qhB31m3zth/MhhdVIClv4vNLs/rQzpci2ZodKYdCVRdxSh4wjbbVEMYpK9AKuh/SzFO1/A5QS7XGI7bXj9njyP8VTOv7/L5Dt7LI80yY6l9Qzajy2dxxnuqsB7McWOp5jVCh3HqF5Hps9iBWmK1YriD3+HyzcDJm9bnLXFnTjov97hzgdLvLOpBA2eh+3EqHXaZKtyvC6z37tDHivSnqYMoftlSfw8wXsxJbszYH3gU4SK1vOc6LMr7HiKCnzs3g7ZQYfZ/QDjS7TferzEeT6S6PutB6zudljtO/gLi84t8bME/9kEO1+iTo5Yv9YHwJ9meE+uMBeXGK1RnTbK81DWSnaXpmIbtoy/cl3J2pYr7Djb2IqiQEchynMlaKqCQuU4YlM8F+VozGSOqQKlOnBTSkkA+apRGXexU5vPNoGafy3YwxpsuRUUmjqoc+R3mLKBGa3RUL7a+CutNsFr89JuOayv8FMvHeo3WQ66q3bs9/V/u3lIjtNE8tsPvXEO1Q3ZNrDNdpXR3t632kgefhURNFmG6zaTpTH8FbRUR/3KdeW7OjOoj78FRzVZxY3MZHtsO65625e2q4xR7Wzq75XrysTvtOW7JBW81PPE4FvbZCg2CjY1C5DouijFeHkettuCoiS900NnJe5EHFAxiChaLlnXIWsr4ouS+PEcdXqOXa0Fhjrax7RDsp6Pkxu88wVqscYGHrYVYiKPIvZw1gXuaIlarjHjCXrQx4Y+qiixiyVkOQQB7PRI7/RYHnmsdzXWBXdpcdcQzA2dn50LPNXrUA5ijKvxn46wkykEAeWDQ66+0WL+ALJhibPQBCNNdGHZ/fEc/cVzOR+gogibZQJ5VEGC7vfI377D+bciVscW9/UFySik9bnH8Q+XeF9ebJx9mjZRmj7cpzjsszqK0LmliDWm8iu9j+boL1/I/d7dwXRi9DLBnr6Q6zg54vyP9rj6Tgna0nvfY/h+in+5QiU5TGabiD8MYH9X7ttsjl0s0Xu7ZK/vcf6diMU9md+dzzT9T3O8eYGzyNDLhNXDHcKLLaiuKHB2h6y+dY/pAxcnBevA9A0YfAC7/+kctUoku+p3ML5L2fJw0hL9+TOZW/cOufpWn+Wx1AXaTw2Dn0xQT5+j2m3Kox2S3ZC076AMhFc54fMFpBl4LmUvYvowJusqWi8M3Z+8wJxfyj0d9CkP+pSRh3exgPMrbG3888qwx3EDz9osE3QAMbQNYlB93qADcQzVe4zW8r4kySawqt/vsrwOwzQv6/XIvrY5OA46CJo5IRDTVkZQ774FEykt0PD1GueNc2yd51pmURn9bVj5/83/7d8pA/iNdwA/CP9lU5CqHwZspWO1Aa9hoDoTuInTvQJTU9VDVr7fpPzb+Gd9LhUEqCjErhNsmor3riCnGtMHrmGSyvc3k8baaxPI5sUG869S7m2Iq9luy8g329YTpIYmfA+q7ykq3FspVLsl28aR1ASUEhhmuzBdFCjPw/Q7lN0AqxXeiymqKDHdmGy3VWH+Cp1bvEWBfzaX6HU+R3U6sL9D2QlQaYleJqjZAtuOWb25i3VUUyAOLtc4ZzW+7qIGfUwrElx/NMWuVuh+j/Joh9WdmCLSrHck+nQS6H+aEX16BdOFvOi+B50Wpt9CJQV6MgffIzvuM38tZHmswUB8JrWJ+MkcPVvBOsFMpk1NxuZFk1kpx5EI9MGAi2/7LN/IUImDN9Uc/FXZQD0qCrG+Jxnd1URw8zimeOOYi++0WO9D0TYEl5r+p4bW0zXekysxCDs9kjtdghdL1GMpf5m37nP2vQ7Td0ustnQ+cQVa+smpGPe6SAqoOJL5EAbi7CqI6/yf7JH2FVnP4q4UreeW7hcpwccvsO0Y0wmxriZve7jLAvdXj7FZhj7Y4+KfHHHx++Ik/Ymm/7Gh/5NLyd7KEhWGZK/tkfV9Wp+OJWNYrkEr8kd3mD4Mmb4hc8pdKQYflnR/NcEqxepBl9WeQIi9zzKC0ykqzbCug22FFP2Q0tNSCxmt0OMF5mqEarUw9/YxgYuzSKU4v1xjp3Pset3MYeX7As8aC3nWGO+6dqaUEqO+TuT3xjG635O6QJ05F6VsM5lujhsEjROp58Z2lngTbdC+t4nGt6Dma7W++jlq51qg91Xwz9dBTq+8jq1tfyMhoL/3qIydLariX2VcG0NZV+rz4trN3uy/5T2tQVAnNhBOzfapC1/V9jX0ojsdeWmtFVywdj41Juc4knHUhrrOVOIIm2bVeTR2G8pxHKlpQFMUVr4nE/RG1N9ggNu1DWiyoea3J+nGOWgt2YnvYwOBktRyLSmxNVIs7rawrkYVhnSvhU5L3KulRNTtmNXDIXnHIe1qvKUluswJvhxtjJ3nog/3Mb0W2TDGv1yir2bYLMccDFnf65AMHMJxibsqq8h8Jtd+7xjTkt/vvBhjkwQVBJiT15jfa7EeOiS7iujc0n1SED1boqcrOL+SmxKFUox3NKxT9HyJikKKkyHThzGLuxpvDr3PSlpP17gvJmKs8qwiBfibmkk1v5TrisF57ZCnf9Ih/fYSx03xP2xz/B8K4p8/2dSb4qpoPp3LZ0qhdwbkJ0PGb8dMvpPRGqwpPusw+Kik/dkC52KCjUOKu0P5CZ9cSHT74C4X39vh6rsGOgnhRyEHf50Rf3SKHU8EijCS5QojR+o8ZjZHpRns7nD5B4eM35Fbs/djg/9BiT/OBJqazrHDPiaW++2ejtCjscylXpfVH7zJ5E2X2VsFeq0JLzV3/mKB86svQWmKt+8xfy2i9TzDG63wv7yUWsHhLmbQYf5mh9lrmqxjaT2F9vOS9vsXqKIkPxowfifGSS3xeeWAr2bYXpvscEja96Se5GqiJzPsF0/FKO4MsO89pIhdjKPx5pkQAJZr7Hwh99/3UJ4nAU9RyDVVz0f3ezI/ALtcY5YLTJKiwwC9uysBk+cKGWK+xq5W1+prKggaW9MEbUo30G9jf0xVI6wM/7XAU2mBdjwXxQ27VM+5hn1kGpu0bfCvGf9tdmA9akRgC/G4Zvf+juM3OwPQQ/uD4F9c+6ypwm//yJv/vrbDjSwB5GZuMwaCQLDzxVKi4sqQYw1msbxumOtjwEvFZBUGgsPXtNCiaI5Rb9Nc1qse3Fekk/V1N5OvzjpunB+QyN91BQIyRqKasmyi9aIXknc8ifbnOd7Vsim05scDlicRxgE3tQSjHG+8Rp+NBOqJI4GKgop5VNEVs/u7LE9CikBhHQimhvYXCzHw8wUEAfZgyOpBF2dd4l8lOJdTzKDN+qTD7J5LOlCYADpfWNpPM6JPLrDTucB3rZbAV/OlvDhpJg6gxptfC1gdKoKRpf28JP58hjq7wq5W8vJsZ1dbpAEcB70zIHttj/m9gPWuZv6opP2Zw/EP5zjPBB6h0xLnaK3ARmWJPtxn9dY+i2MPJ7cUkWJ5pMi7hu6niv2/mqHnCTb0KAYRKjeC3V+OsK8dc/H9ActjRXKc48xc7vywpP2jL6/VpKhhjHZb5lLNgtsfMH23z/yeZvFagTd1uPvnGd4oQa9SyapWa2xZZbSug70aY9IU3e2S/O49Ru8GQsfMYPhBSvBkIpF9t8X6bpe076BzS+/HZ4Lv9zqUez2ynk/Wd8naGm8l1NPW5zP0aJOBrY5DSk+YVfEHLyRb7Pcohx0WD9ooA9GLBO/xpdSOlIKHdxl/s0/eUvhzS//nE/RU4C7KEuIIE4fCJpsusfMldrVqYDvn+JByt4ta5+jxDHM1wmQ52vfQe7tCerC2gmtzqb9sF1frgHCrlqjDAOV7DQmjzgK23/2bRVzl+xtHUZEB/rb6wc13ftvxvFQw/io46MYx/64ZwG+8A/j98F8CSDRUYf7A9fTphjPYxvuBhiYmkZSWyCHfeqCVkUDrxvDbLcbPdtZx04hvjxqeUWGwgWJqhhBco6tuM3oaB/MKhpJEu46wS+abAhVIvaDBGuvfB9fopzUFMBuGwqhIhWfujVaoVUq528EqRd4Vo65zi3++RE/mDR0TpVBxLL8rDiWFXyfQ67B+MGB+z6P05MVtn2aEHz7HLpeodpvk0SHpjouTWKLnS/QixXRClvdanH1PU3QM3kTT+QK6n2dEn11hzi7EYXc68uLmBXY+b2oD+W6bZNfHeIo8Fniq9TwneDqBi1GTtW16PkwDtakggGEfGwfkOzHT1wOSXUV4aWm9KAjPVjgvxgIRxSFqlch9sBble2LIdrtcfrvD1bdLCAzeuUfriVA6hz9f4V4tML2YdCfAm+W4nzyDNEX1ulz90Qnjd5WwkD4y+NOC8PkClZeY0EeVJXq2wi7Xcg+DANXrUBz2SfZCjKdY7mucDLDgrSyt0wRvvIa8wPRinKs55uxicw/KUuC1kz2Wd1ugQJWW+HSFfnKOikJm3z5ieaDpPC3lOU1XcDVBBT7L79xjeeCSDBXtU0N0kYsTPx+D55Kd7LC4G7I80oRXlmhU0v7FGeb5mdQl7u+S7FdZ39oQXqzRX55JNnO8x+L1NmlX4+SWzpMU/9Nz7HIlAYeq+jfyXKjVaSqZnBYatB70Mbs9ksMW/jTD+fAJ5XTWGG8O9jDtAL3KULMlZjKVd6PKlk2SNnajJmAoX8gUYsRNkyUopTbv3zb2vgUNbTP+/s5Moppm+iqn8nX7vsoBVOO3xAHs2B+4/90GR/PcjZeub+xNLE3plz13jYnXkbGjm4KjSdNNo0idUjXQjOD49oYHr4vNDQyzFUnUjIIGl6+Mf9N/UFPW6u3rguzWxGkona2WOIw0bWCpOnpVUSRQ03IpzgYaTNtpt+S7QZf1/T7GU7irEneZoxdZxfrJSPdinAqjd1YFzsUUOxKYp54XOgjEATm6iZLM/oDR7w5Y3FX4Exh+IAZIX80E0ul2KActkn1hEXmrAu9yBcD8UZ/L33EoYos/VXS+NPQ/mKOfXQiF1Pfl3lX8fdVqUR4Pufpmm9WBNDCFV+CuLf2PE/ynI4nqlssqO9xy5r4n96aGUe4eke21SAceywON8RSDj3OCixXOWUUhbUVy3nXaQAu62xEe/L02eSzPK28pkl2FKmH4QUHrk7EYmGGXsh1gHY3/2Rm2KCgeHrE+CJnfdVjvW+Jniv2/WeCMVxKdK4WNPFRWoK9mmLFci97fJbs/ZHEcUEQKZaT/Ij7L8caJ9PEbQCO9D0UpRrKKblUQiPE/OiA/7AvsVxqc5cZBFt2Q5Z0AqyAcFUR/8yXK0WRvHjN5IyTZk98YXlo6TzOBAi9HqEGf5Tv7jN6RRjxnDcP3003mtrfD6uEOo3c80h1L/FzR/bKg9dEVKsspDvssTyLSjtR5+h9nRL96IdBpK8L0WqisQK1TzPml/J6K7KCikOKwL/0juZW+g7MLyQZqGDbwIZZnWRfJmzkdx5vsvmbYxfHGRpQltjSQZy/RTKuX9iWMfrtG8JX1SWtfpnRu0T0bO/H3MPSvHErz5+W/+y1wAFUfwDZLp8Hnfa+BcK7xgKtIuHYAWNsUzpqUGITds1pd4/03UX7dBVk9sFcZ7AaDq8c2PTTwm8hh2yBt9ypsR/06CBoOvOCNumn8qvnOKC0RQsVoUK0IkrQpXNmiQAUButPepMuBgwlc8q44l+ByTRm6mMBBlRbjKomaXoylwabKWgBhVdSOLwhQ7Rgb+k30vdoTCKD/4RL9+AzWiRTjOi0IfKxSQkOtfnvRC5k9iFgdalQB0aVh8NOJQDXLpUR7deFsnaD3hmT3h5x9N2J1bCiHOcqxeI8Dup/B4JcrvM9fbBrtADOby7XXz56q0L/Tpxx2mD/skPYUOpOehtpo1zCP6cU446UYjApaUP0eNgpYPBowP3FxMkvreYk/zbGOwj+bo8YzaVbyXTFai7Xcz3tHPP/jHfI2GBeiC0v/44zgxRK9XAtH3dGY0EfPV8LyWSxRUcT6ew8Zve1TxNL01f2ywF2XeNNUMhTAxqHMldJITWIh9RCGA2zoYbWm6AW4i4qhNE9Qq4Ryt0d6EOMkpVx/mmPnS7CG/L17nH8rItm1WBeCsWL485z440sx/J0Oy28csbjjMr8PncfQ/zjFfzqW79ttysMBo/c6LO4q3DWEV5bh34zR4wU28Ejv7bDe99CFJRgXBC8WqKsJhAHlXo+84+OsC7wnl5jxRFhKgz7l0S42EIcJoPMSPVlKsTrLJeipAy4rEF/dj6N8X+xAGGLzXCipVRDptFuobmeD/Vd9ADXqsI0wvATJ1LTNG2yda5lADfW+Aqpp/lk7ju3ttgPc7XrE1xSN6///1jiA34/+VcPSaaCOio653VD1VZRJ5Xvy0EsjDqJ2BI4WY1yxA2rDvE0HvebJt24wbJhBNfWsxmltUQg8UkVY15g9NzqPG2NbT5b63FXnqQ4CVLcjUMQ6lTS4NOIQslwyEyOFXXptbBygVqm80FGA6cUkeyFFJHIEwbjAP1uiFytsK0JdTRpHpRxHDH0YCMZfv1S9Lqt3Dxm965O3YPCRNAMFj0eCDbdibK+NiTwoLc7lVKiovke5P2B9p8V616EIIb6oII/TGVxI5K52+ljXQSUZFAVmd8DlPxow/obFu7fkwe4V68Lj+f93R9gp70v3qk3rDCESGmKFzQNyf1xXDGHgMn/UY7WnCccWf1rS+vAC8+JcILJuB5vnzbNRrRgbBVhXY32XZDfEXVdQYmFwlrmcP0nkZdzfIT1o41+tUKfnAJj7h1x+u8vyWKELiM4tvc8zws+vBNqIQkyvRdEJcOcpaplgn5+j4pj1d19j/Mhj+naByjXDnyr6Hye4swRKiypL1Hwl12ysNEMtlpIxHOyxerRH3nYoQkUwM7jLkuB0ig2k6G21RuWlHGc8w8wXqHaL4vUjkv2A+R2XZBfCS+h9nhN/MZFeieM95m92WB5WWHWBZDGfv5B3KgpI7+9QxE4jp1FDWwCmHVLGLmnfI2tr4rN8ky24rtSnutL4WDcGohUqDCmPdskHIe4qxxktYTqX97Ys5R3sdxtKLS8upLmrGioI0HtDmWNFiZ3OKSeTDVa/3YC3Wgv8W5EqrhFLvoaKebNLuA4Et+uVNWT1SqZifcxXRfh/W/R/Mxv5baoB9PTQfj/4F9favV8yqNSQycv8+KZTt92SppckaSI7gkCglbrIuw0v3aBWNcXjrXMJm8CXKHkbCqqvyfcxafpS965yN8XouqDbdDVuNaypVkuojiCTM0mayES5Lnq403CyAXSSbbpmA5/8sINxNGUguH9wtkBNFxtjpzSqHQvv3vc23bOhL+eLA7LdFut9j6SvML4iujD0fjVHf/pE7l+vLVS+ToCzzNHzFWqxwhzssLrXYbUrkgfxRYk/LfCfjrHPxUg2NYUKg7UHQy7/0YDpn6343v0v6XtrPlsMmfzv98jaiuEvltKhbEXqQpWVdtFq3fRi4HsiubDbw4Qu6yMxKKq0BJNcsOUqSyAKG8hJ9bskD3YZP/JZ3oXex9B6UVBEGiepMOtPT+XeOw6q08YMuuAo9HyNHY1Rgz7T7xwyfSiUx/YTQ3wmXHc1mUt3L8D+LtlxDwDvcoWezLFphrl/wPnvdQRWMjD4sCQ6S3HSkjJ0ydsuTmYIngrcgbHCiPJn6PKiAAAgAElEQVSE1bJ8Z5/ZPRc3kSJ86/FC9HlKS9kJQIEzS1GnZ5su5U6b9bfvszxwyVviMLqfCWUVwAzaZHstZvd8sr5oPw0+LITRM11CXpDf32P2egQWOk9T3PEaPV6AtZR7fcbf6DJ7XeHNYfh+RvT5WKjCSYIKQ8z+QDrWlcIZLST7Wq2lr2V3QNELKSMXd5njfP5CZEQqNpZyXWw7FsM+mTZzSQ935N0pSsyg3VBL69qBHgxgp7exIdOFZOv1v7co59u2oX6nG1tQ9+XUnd+vgIkauLhmNG4zjG5kFi/R17fH13Ug3/heOc7fuQ/gN5oGahGmjPI2vPpXSihUVM5XNVk1hj1JJOJ0HLlp60QMdP0gyhJzo/jSXMd2kRYq4bSNx94uOtYO1W4b/61+A2ohqi1Ka9OR6LqoTlsiUKfS6pnPm54E5fs4B/uURzvkvoPOKvxynqDyAtONKVuBCLUphc5KgqeT5oWzSjfFLcIA04mwXhvnbIICTCvChi7rwwF5S7M81ugUdj5MRZ/lxaW8IFEo6Taglgn+1Uyw28CnvLNLsh9jPEX7WS7O55Mz7EKkFvSgL0a8KDBXI/TOgOU3jzn9Y5f93z3jT3ae84vREc+e7jD8S4/hF0vcJ5cCT/meXL+xwi4qCokeHQe12yG7M8D4mrTv4i1K3JWR/oPnI+x8gSmKBh5SAA/ukvdDxm9HzO+DtxR4CCw6N3Q/qgqp1mL3dqTjWmsoStTFSJz/oM/kn7/D1TcVZWjxR3Dnh2vB/6v6jK1rEPtDimFb+O5z6cnI7+0yejdmeawIJrD3k4LodIkyhuSwxfidiNJX+DPL8K8u4Pm5OKDdHqu7HcpQkQw0RaRwV5beJ2v80zGmG5MPIvKOi7MuCS5WqIsRdr1G9brYkz3mr7WZnzg4qWXnw5Tw0wvIC8r9AfM3O0wfaKwDrVPLzgeZwEBpJt3Zgw5FL6AMHaKLguB8LUXhsqQ82WP0Xoe8rTA+xM8tO79M8H7+mdz7Thu1M6g61ktUWghzyRjod7F3D1nea5F2HaLLgujZAnV6jpkvROah0xZacZk1z1XHMereHUwnpPAEJnJnCXpUkRmMwem2sfeOSHdbeNNE4L7livJqdD1orO2MNXLcOJassu4N2goIG2p4bTsqu9FA1Eqh6vrfjah/u/Db2J3tv7eN+029n6+pB7xEh/+a8RudATSNYFsR9s1U5yZVqh5NW3iNK9dsn21myKtSMWjSupsp3HbvQG2wgU0GULFvmrG1TVMkqo/bwBVVNhEEGygozxt+cyM50W5R7vWEybNIUWkhFMNuHeUarCNFPvdqKUJwy9UGHuh2JOr1XGli0ogRWifYYZ/kqM3q0CPriFiYLmDwYYJ/OhaJgjobqTOcSmulHLTIeyFWg3UUblLiLKSuYMYTUArd70m2ErrCULm4QnfaZG8dc/mNiPnrBuOCkyiic8Xgo6qoOp6JgXcdifoXK3FkeYFqtzB391ncb7HaFwPozyydJznR0zlqupDzU9Uz8kz2832Kd+4xez1ifk+jMyhDwamjKyuCblWmYdqxqF7GPiov0fNEoCvXJXvvLuNHAelAsTo2eHPF4FeWwc8mqCdnTbaAVtL124tRhWkKm9nJDhffiVkdy/t38JeG7l+fCkZ+f4fxmz55V+HNLP1PMqJPpSs2O9lh8kZI3lbkHfDmUhje/dkSZ7rGeg7ZXov1roeTWaFbPrnELhYChfY65Psdkl2fpK+FsfP+BWqdkr55yOkfhaRDgz/R9D6xDH61kG5fx8Gc7JH3QoyvpZlsuhbjneVYR5Pf6bM8DJjf13gzS+/znPB0IZDjOsHu7WAjD71IpPZSUYvNoEt62KKMHIwrmUYwLgjOFnB2Kdu5Lmo4EGdc92AYI/PgwTHJboiyEJytJBNdp41chNrdwXQigdCsNJSZ88vrzZxbUXrduet029I3U9ULG2hpO7p/BVTcvPs3EYVtqugNMsvfqcB7Qy34JYdQqxT8PTKA32gH0NND+4PwX74k8vbK5oltI11H205VJK4x+RuCcddwOqCmgQEbnv6WJ260hLZqBcr3X1IjbXjEUXgtpdxOGZVSm+azer8qI9FBIGJYvRYmdNF5KQZoJhMwO9kh3fFIBg5uYmmdpjirTKh7FXbfdDZXlDaUxh4NJepKc1SSYyOfxetdpg8c0qElvFS0nhtaT5OmI7gpXtcsJNel3B9gQlfkfWOHMtS4yxJvIWm6nc7E6FfGBi1wh5ouwHOZfveQ2X2HvAX+FIKpJT4vCC8SgQ8ckWq2wZaxSFMoClS/R348IB0GjN5yKQORcd77SU70SdW9qrSwQDy30cchCikeHrG4GzG/q0l2LW6iaD+2DH86wzm9lLqC68KgS7HbJt2RgnvrVxdCiWzFrN8+5OI7AVlHiqQAez+29N4fN8aq7jFQJ0cUOy2so3ASmR/rw5jVvsPiROGuYPh+TnQ6p2wFJPsBiyOR4XYSGP5shnM2wbYiZt8YMn3okA5kbvU+hu4XGbo0qMyQDXyyjoMuLU5iaX0+lcKq42CGXRYPe+QtMR7BxOAk1fOqnMbpP9th/laOO3Y5+JGh+/MrGE1R7ZjsZIf1gY/Vivh5KoZ/laJKQ7nb5eobbYpYov3owtD5IpGmsfW6EVIsd0TgT8/WqJlkg8VrByS7IcnAoQwgnBi8hSF6MpNrB2y3jemETTOgWa0EAt3bJT8Zkg4DgRmfVdDT5WgjkFjBtHW9r+nzcd1NN3CWY8aTje5W9d4qxxFSQ5XJm3Xy1Zj9tnBbjVhsoQVNMXlr24bgsd3QeTPqf9W5xDhtHMH2Nlvjt6MIrIf2B+6fNf++Vgmn/vMGK6d+8Ns3spJubiSg633d6wjY1xV+6qLR9o1v6KE3KVxwjaO/3dzTGH7P39DMtmoZemdAfnfI+iDESQzR6Rx1NkIpRXlnl8nbHbKOQpcQXRlaj5fChDi/ul5TqEd1L5SjBfZpx5TdgMW9iOnrmrxrCS4r/ZVP17gXMykitys6ZJKJUUvTBr9Od4T3r4tK0G2eyPnXaylI7/QodlqYwMF/PoPJDNWKWby3z+gtl6xvic4UrTNDeJVLA9MywbRCTOSisxLnSrDght3Rjknv9Eh2PSZv6EpPxrLz/kp0edIUhgNMO6CMffwnV1JgdDT5e/dYHgakPYWTgZtIMdib53gfPxOHtTukPNohHYZigKYLgfSSFPPaIRffbpMOFCjJGOJnlvazktbHI7gai3RAFEgxu1JBzV7fwzia9b7H7L5mdWxEB38hcguDn00aqeR0AKqsCsafZfiTlDJ0Gb8TMX0Din5B+NwjOrP0PsvxpxnpTsDijkvaU0QXlp0PFjiXM+x4gup0yO7vMno3Yr0vbJxgZGk/y4keTyEvKPa7zF6PWB5rnASCcQUznV3AnUPmj/qUfu00CoJRinM1p+y1KLs+k9dDlncUOpd9d36Z4P3ysTjqMMQOuvI+ThfY5UrUcqOI/O6Qxb2I2X2Nu4bBhxnR07k40DrQqFVhfQ87m0ux2nXRnTZ20KUYxJShiy4N7iRBPbvcBILtWCixWYa5GgEV9XN/SH7Ux3gab5qISu6zc8rprGEa6kG/NgbCIKrsxrVAcXvUaEGtBRXH1+xDwxSC60Zb6UacbpuO+sqh9OYYzWfqJSe0fX2/HVIQ2AaXM0l6nRb1Crwfx9lALHDt71r3o6EMZjkKqk5JV4rDZblZY+FmMUep6w9pKwsArqV6zfYVK0i0yf2N1pDrNs0l9TXpQR8z7JLHPmXkEr1IcK8Wkq4eDlkftsh6cr7OaYk/yXFWmRTOJrPNsbYYCariO0Pl3FyHbL/Fek948E4C0TkMPlzjnc1AKcxA5KT1IhG2yWKBzXL0cIfV6ztgLc7aEIxKaSY7G2GnM6Gz7g4xwy7ZMJai8yrBtCKmf/w6qwNN6UMwsQw+LolPVzijhWQroS/RmEa6ZedLifSqYrhtx6xeH5B1JTo+/MsUd5njPr2S2k6njR0KDdN5MUYvFljXxbxxwuJ+zGpXGqf6n2b4lyv0dIm5uJJ55DjY9x4yu9/GXRni959L01mnQ353yORRzMXvF2BKBj9zcNdSII4+udx0Bx/vUVS1F//pSHRuujHLw4Cz34fWa1PW85DujyL6n+TEn1yAMSze22P8loNVgpO3n5UEVyk6KZg96jB+W5O8luKf+uz+Z5fhL4Syub7T4eLbLZZ3BDYbflDS/fELkb9utzEPTlhW+D5KOPyDjzMpIE9m2L0dLv5gl8VdeX86X1r6H63xPn4mOPfdI+aP+iQDTe+zVBhfroPpxVz80RGjb1hMZPEvxbEM3y9o/eoC++wMXFeYXa1IYJh5lb3tDzH9FvPX28zuSW0hPhO9Iv+XTxsasYpjqZ0kacPrxxiRat7tYxwHHIU7XuEaKzpSy6Vkbr4nwZ+12PUaM5mi+z3M3UOyXkAZiOaQf7lCn40ws7nIREShwKxhKPtW2ea29PtXqX1aUyEFdf9RBTeWVZYjTukGVFNnAUXRZP0vMYfqwFw7m2NsjyaTeNle/X3Gb3QG0NND+4PW/7Axbo7TVPK3xZZusn5q7n8jjlal5PXY7gBWdbNIJeW83e3XFGm2sP9GM6QWe7uhQXTNAW1rj29DULCBqYZ98FzyYQtVWtzJSrBvz8PsdFjd7ZC3NP6slIaq00mz6IuqePt2vhAH5vvXi1SuC7228PIdxfqkQxkIJdSfFnjTFJWXWN8VFc+klIVgnl9JFBdHAqO4Dqbfomj7OEkhRdl6vQOthUoX+E1xV7ku5eGAydsdrr6pKHZz2r/yGX6QE386Rk3nImYWiGyGUFwrGp7roloR1vcodttYrUiHPllHE7/IZeGU+RLVisnuDHCSQhqozkYSJcYx+bsnJEOf+YmDN7f0P0lwx2vU6Zk4lor+x06vqi/IalXO1Zxyr8fFt9uMvlvQ2luRrH28DyOO/0OKN5ZMZXuhnbIrTV8Azkrux/jtNvP7iuydNUpZun8RCUY/XgnZoBOT7kcULaFM+tMCd5nL6mShy3rPY3FHS5PZ+yn+JIXSMnm3w/yepmhZ2o9h+IsV3rNK178VVxRQLRTQqUHnQsXUl9IrUh4OOPt+j+VdSxla3IXi8C9L2j9+KvMmDCiHHcq2v9HhWees73aYvSa8/+HvXOBow4tf7nP0HyzdX1w16pzX+m0CXwKKXpv13Q6rA1dWezPSvdz9cI5zKbUWikLerfniWpeviiNUt0N+KBIU3qoQ3arK8dfZgh705Tmuk0a2XccxajggP+xTxq6o0F4u4FwIBY06QGtLRbQSjWvk1+NYcP8apqm1nyLpUL6mIbQlKnmTrPKqjt6XlIphUw/Y7i3YPkZjZL5GLK7a57cCAurpof1B/N83N3ub9rltjIENv15t9HO2IZH6wegoFApjWcsgCzPHVg/+lYqcFaa3rQPy0toDf4usQ319Oo5Rg54Yy9Cn6MfowkjEvViD51LsdynDTXahUzHMN7X9qYXJ8nxTZ4gjOXYUkA9bZANfFnBJjDR9TdfCmw891nc6GF/hzUu8WSrdsI4WXf0K408HAcE4RS+yhvli1gnO3q7IOBu7kSPu91h/44TxWwHJHqQ7Jd5Ms/cTQ/vTBc7zS7nGMJSo33Ob9vxaIdSGPulxlyJyKGKNPy3QhRUO/WwunO9+i3QYElwlIilQFKhBj9WjPYyryFsab2mITpeiG1NdHyAMmL0dVEUZVIsVdtjn/Pd3mD0E9fqSPHUJPwrxZwJPxB9fNgvS1Fo7ph1ifRe9zjG+y+S9DuO3FNmdHLV2ULmi86lm7ydrdF6yPhAZB2Ugep7gLFOs75J3A8nIDjVOJnLX3soSP0/xzmYs3xpy/m2X5EGKe+7T/lK6iN0nlxI4HA1IdwN0bnHXBc4sa1Y1A1DtFvnbdxi9FcqaCP2C1mceR/9xJRr8riOw3sDDSQ3h8xVly8O6mtWBz9U3FdmOzGP/yqHzGDqPc+KPLrCTqkhvTbOQDkGA6rQo9rusjiOSviYdKOkU/iCRhrGrCQz75Ic9dGFwvziTJr6aMNBtSdYfuuS9kKLloDNDcJVI02KeNzW+ei2GxrGfHJGe9El2pdGs9eVC6iiLBWadoLtd7MFQ1hRQSlbJuxw1lO1aCkLFkTDVJtNr0LPT68pvTlPK+bz5/Jod2grCmhXFtPp6mKc6zlf2ArzK0N+Ugv6tg4C0um7866h/C255JRRURaKANIrUEX1NAa0fRD156wauLdpm/XddFN5e4OXmco7b11HTTgFZFrha7rGWbjCDLsZzpGkl32jjg6ziVQzEgLvLXFZY0mqzmIznyvKOZbVGal5I01awoZyV3Yj1YUQeCzMmmBnCi0ww8ckU1emQvHnAes/DTQzxs7Xgxp5LfneIdTTJriz2EZ/l+JMM93yGeXGOqWAv3ZfIGa2xVyN5Ju885OJ3u1x+24JT0n9fc/CXhvjjcynMFoXAa54vvQjLlURUFfxlQ598r0vRkinpJAKH1AwW64kMgGmF6NmaaLKUnoIoxN49IN1rYVyFk5TEX8yk0/ZqTFnVaXS/JzLOiyXq9ExS77cecPGnh4y+n/On7/0cg+IvfvEWw//ssfP+UuohpcHGIcZ3hQY6mW0iOM8hH0Q8/acxve+fc+QWnP7NEcNfWHqfrHDGK0w3YnUcUUSa+IWspkVpKQYR632f8SOHdGiIXkDnqZGaSuUcHv9PB0R/eMmD1oJP/+N97v8/K7zHl+A65Pf3WB+G5LEsyhJ+Louy2CzDei56b0g56JDthA10OPgAel8UeOcTTOwz/t4hyUAow90nBf4ko2x5rI5DFnc0yxOD3U9Qo4DdHyuGfz1GXUg9Shrt+k1zlc0ygVE6Lcpei8W9mLSnRLLjk5L2L6+g0vfnziHru128qcwtHAf71gNM5JJXizKp0oqceFYSjRP0swt5jyulT/Icu8gaZo5z54jVoz2mD0Tp059ZBp/O0Z8+FfhYa5y9XUy/g14lsFpDklDMFlKvi+NGbbWWg6iNf83aqVUErsFDtSJxFb1rV+7NNc2u+pjOV6zutXWcm59tJOxvfFcTYf4W2ei/bfxmZwDOrv1B9K+uNXhdGzVmxgZuAa5TNSup5XqVpsboV4VRM5tfE22qx7UVd14R8d/sFXhV00ctO6ziSNgMvVgw9NFCJqDjSJEr9DGx37AkMEYanYpSUts4lL+tFcpdK8K6mjL20VlB0REt/2TXkwXGFfizkuhU0n9b0drMyT64GuNpdFai1zlWKYphxPJQ9GZKvyoun4qUsjm/lMyp05b1VUGKxFmG8jyW3zzm6j2P5d1KU2it2Puxpf+LcdNp3MhvZNkmEm+3sAc7rO7JOrXKilCYuy7xn01Rs4VAOpUcAyDRXo2Z+j5q0BN2SWnRSSZ9CpWQX82AUnF0TcUTrbHvvs7zf9Jl/b0lx8MpT84G6GchvY9h70cTUbZ0NOVuVyi0NbuqKFDtNmanw+Jhj9E7Dv73R/zZvV/xwxcPyf7vffb+ywyAbBBSRg7eXNZQUPMVyVuHnH83oAiFZlu0LFjofAG7P5njXM5YvnvA1bsei3cy1Noheuaw9+Oc1s+fYXttFm/0WO05hOPqGZ2ONosAxZFkfoOIrO9TBgp3bQgvqsi5kmFYHcgiO6qEaGTofrJAT5asHu1y9j2P5CRDpQ7BhcPwFyXd90dwOUF1WpL5OI6I1s3X2MUK1Y7Jj/rSsNZxyDqaYGKIztboL140kiuq3xPYryylPrBao3od6Yqu1gVwV0VDc1ZTKf4C6P1daVZcrAR+rOZkebRLchSTdaX7ORyXRGcJ7tlUekVqRlj9HtcLvoA0hNUd9Ll0WNfSE7V8RK2FVRvuRhX0pj4QXBeqrOfolmrBV+r/3xxVPeHaOW4yf14FD21lCr8VncC1GBxcj7rrcVN0qR7XMDVoVDWbxVsazC+9ru4nJ7h+ETcopi9JONfnrOoFtRPQQdA0TDUPrtEEsU0EbdqhwFS15nmSbBhNteFcJ2Bs85KXgxZl7GM8TTpwMa6iiJQoQz4RJg/zJXRazWpcqjBCwVsl2NAnOxmwuONT+ooilkgtHBspPv/qsSw3WMNlvY78hopiah7eYfReh4t/XECp0J2c7n+KGHyUEn14JkVUEJydig1R0SNrCGb1oEvW1gTTkvBsJYyM81HTWV3rvtv5QiCrivethzvYKKDc7aDXufDqxzNx5FUxTQVBIyhXY7q606F45x6jd2Ou/iCDTNP63KPzpZFlGuvaiid9BxSlRIO1XILvY+8eMPrdAfP7ivW9HBxL/KlP/xND/Cwh73qUgZaFza8SyawWS8yDY57/4w7ZH87Z6y548sUu4anH8IOS9ucLWcKyHTJ5r8/F70HZL9j7ocfOz2YirRF45Hf6zE8CdAmt0xT/83MRfjsYkh62SIbC+9eFxV2V6MLgrAr0IsH6LmXsk/V9ilhXTXKlaOmsc4puyPM/iFi+lULqMPiJw+5PV3iPq1XPdnqUvQiVlo0Mhuq0sY7G9FvM3hCRvGAmNE53WchC9aPpZnW6qpbEeCZZbTU3redQVvPTWabo0Vwyvhqi833U7g6kwuhRYSBF7gdtSl+RR4pwWmey84b/X9OAAXEYq7UUfH0PPdzBDLtCiV7n0qewWDZrBivfl7qW70kmUBWL6/e8ti8mSa9TyKuFhWrYx2m3Xqkp9HVw0DVq6Ha28KoM4SYdvv7MWv7c/l+/BQ6gWhLy5o9/Sfti6/Om6Fob/zrqL4pmJaF6icdtatd2Y9c16edXiLjJRtcdRr2Ob9P844kgXbP/fCGfV/K0JnBlsevJXCCR+jfU2YvnyefrpMkgimEbXRjK0CXreRhfmrbctZFi32guL06vTX7UJ++4FLGm9XSNM15hPZf0sMXqwGN+T6iU3S8N8YtMsNmKSqoP91k92pMu2qdiBFQUkbx5wNM/9Wn9zoj99oKPfnlC7wOHg7+aox+fifNrRQLTVMVSc3bRSBrnRwPWhyG1HLG3KAleLGRB9VpMrl7YPEkF4tmSYa7XMG5E18YzyvFkswpbGAiTw/OkeWe5FAjx7dcYfbPL6BsWVSqCsWLnlwXxM+nGNZ6DTgq55iwXWeVKNlhHIcU7rzF5FDN9BOrNBeazNuGFove5dBtnXYc8VvhzQ++vToUVFQTkb91h8iji8h/nHJ+MOB916fwwYvh+gv+xrAZWSzTnsUSvwUjqLWgouiFF2yPtOTi5JbyQhVkoSkw7YPxul6yryHpC8ew+Lgifr6Tu4TrY0CPbbaGMrRb9WWwWVul2SN465OJbAes9i7tWtE4tuz+eoT9+gup2MP2OCPqB7LdOYHdAethmeeRJh/LCYhXo0tL+fIH++MlGUyn0xSCnKZQGNeiR3RmQ7nioElGoXeU445Ww3S6vZO5vyaXUar3K9ym+8YDFvYi0K+wjb22EufXJaAMv1e8dYvjLxVIgnk4bDnZJD9uNCKL75FJE4WqmnuPIdvVyqnVRuH436+vSShZwqjj/2wtVXUMSthVBa8VhbjgObhjw7XFD/l4+erkP6lrTajV+OzKA2gHAyynPTZ1stlg70CiCYux1Hf6vaJOuM4hthc9GfmJLF+SlUSuQ1iqdtQOohLqamkNVB7DtCBP76KQQfnSSSEZSrSQGSLRciV3pThuzPyDdr6JpV1MGco3usiR8MpUaguuIBtBem6zvVxGeRAPGdygDzeJEfmPpSbbQ+zzB//S8WZRDH+yRvDYk2fUEQvpsBNM562/d4+z3fMrfWfDHDz7mp5d3WP/7ffZ/ssb/5EykK+Kg6ZitF2WnLFH3T7j8gSxXCLD304QyFOpjdDpHPTlr+OGm1xZJgKvxRho6CmF3INmTo6UprKIJXlu/ud3arP1aQV752yfM7wVMHomz8xZCiex9usZZ5yLGNk1xxnOppxSFGG8QnaKTI178NztM/n/u3jTGsjTN7/q9Z73n3H2LPSIjl8rKWrqW7tq6p2c84xHuoRmPAMmWRgLJ+IMREiAQkm3xHTwSAjHIH4BvIMB4AWRpwJ7Npts9vVVXV1fXlllZucW+3n0928uH55wTNyKz2v6AG1RXKlVmROS9N+49933e93n+/9//awFqaOEdGXhnGu8soXAWoKKEyZo4sf3DGfbDI/RsRvTCNidvFum/HLK80aXoBDx5f52tP5SgG2ZzwusrTFdkMGyEmvLdTq7+ipeqRGWXed2+iOI8HKDGU8LNFv1bPsMthbbkd3L6mvJehP/ZqaAagHipjsrULCMZdALg2CTXVujdKdO7bTBfiqh9ZLH8wz7Ggz3Bby/VxSk+SflScULcqtJ7UTwo2lCEFbAmUPs8lBNc1ibLdPhaS1LdZCqnyKUG040yQdUiKCkKvYTyx+c510hnqXwpXyv7uyqVSGplJtsVhpsm/mmCdzQX7X8cQ6cvp0bbEQpvKlvOcNjGcptoqcKsXWBeNSh0YvzPzuDknHg0ziWg+S2dBer5/CKPA2TIrZOcMJyfCBZaz1lBWITC5ddker+/aJibrSdXi8az2k2G616KNV1sExmuyx9N/6cvUQF4xvHnWfTPfPeQtYMSnYfIP+X6vbijp+7vEsp18QVO36zFaLgcRJf2+LKike1aBPGQculTGqn0FMPcnKXTmLosapDpTApGoYD2C8SNItpQYnwJYsxZlLdzkmaF6XqJadMS1cNhgDUKULOIsOUz3HQZXpOkruqD1OzVm8DRWT64S66tENYkMAatxSgUJ4xeaHLyVYtf+dbPabkj/v5336HxkaL9o66cNooek5t1EluURIVHqRO2VmFyoy6zgesxKlAUdw1K+wmVz1L5X4q7UOWStFtMIwd6qVJRTm5JInz+JBFD2jzISamXZjqQt/WwLMIXNxhsFRhcV5hzwTCXd1KcQhDK8d82MbuCycjCx+Xo7zO7vcLROy5hWTTXbxAAACAASURBVGPOFSoUzbp/GuPvjImqsjhbkxjvcQ/Vl+cU3lnn9BWP/msBbnnOfOTiPXRYei+kcDTBPOkSXmsz2vQEGLc3xz4byftuGExuNUQpFCPo595MFlYgWqrQvSPMoKiocXqK2ucxxf0pZmcs6rAgzJPDcnCgbcFSi+n1OrOGJdwgHzGG9RJqn40xHh8JjHC5IUU8SlCziLjsEtQchpsWo2sQX5+SnBYo7ht4x5rGzwcYu0digst0/xlmPXXS6uUGUVWYRONlC3sqCGj/kyOS0zOMZkOKVZJInsRohCoWGb+yTuIokS2nN3sYUziaYOyd5I+hKmVRlPWkVUccY5SK6GtrjLfLTNomiQX+WSInlJ0Tkm73IjoyXewzl7BOdKrn93LciR6mm44FeeelHJKF9eNS3ngaL3mpfbQAhbtKIZBvXIZPPkUkvmqG/QKMzR/P/ucvQQEwGvpt48IJnOdvLgx+875vtgu0LLH0ZwaoFO2aqXqeOqLJHT01xH3WiSG3iC8cATPoU7bo50UoNYTkt0TLol4WSzxBCLZFUvYEn9sbXmSe+p70orVOlT+iODH6E+lTGwpch9lqibBiEXoKa64p3x+gxjOidoX+LZ9pWxEXpD1QfRTif3xIcnYOhoFRrxEv1YlLDrFr4J5ORC9uGPTfWmf/Wwl/+c13+fHZNXY+WmXzj2NBIiRi/583C4L83U8hcYBeX2b/Ww3MX+uwWhlwNCwzuF9n409j/Ec91PAC05v3Z1NUg45jUQMVPeK6jzEKRK2hNXo0kXZOyn5Rnif921mQh8zrrVVGN6uM1kzmNTDn0P7ZXCBoB2cXvgbHlgJLetJKTxjzlRLDDYfJirBo7LG4W/2TEHsQgoKg6hB7BvYgwj0Zi1/CUEy+eo3jt22SF0a0qiMO9hrU37NZ+uEAsz8mXKkSVhzCkoG/LxJQdXCKKpeY3WgxbdsEJSlWZiAJX87jU4gi4tUWg9tl+jcNIl/jdhTtn80p3DuUloJlkhQ94oqLfdgTU2AWYrO5xOiaT+d5k9lqjHtqUvssobQ3x3mcBvD4HrpWJi67IvUNUkTIzQrDdZPEgbAMiaUxIkX9bkL1ExmU6/EEVa+m+bqpnFcpjHaL2e1l5jXZlJhzjTYQKefRGHV8DjohubZC7Iu3xNg5luvg2honb9eYLkkudKF3wWfSvYHwtrLPWKkop4f02jDaLYLtNvOGzbRhoi0odBNKTyYYO8d5XoLy0pN2EOR5Gobr5tGl2jYxgkjmZWmU5tV0QeL46fnhwm2xrWM49sVJAiAIiUfjXyz5XJB3Zu3l3Fl8pX2Ut64X1sYvhQ8gD4S5orF9VkZvbqyCC6VPluazkKd6afhydUe/yAlK73Px9cl6gFdTwvIoxoUhZB7LmCkBUn104heExZ6Zn/Jdm5HjBHRRHIkkSEtE6/z/Scknqnui5InTQd8kyFVBYdVhVhdFhD3VwvU5HcHxqZw6ikVxVJbSx9BaUA7A5FaDg1+zaL56QhSbDH7WZPndmNLdTqrxTtVKSSKqkvk8HQpvcva1CufvhPzKi5/Tmft8/qNrND/QVD8fC9Zh8ajsWqjJXFoGWb/YtSUsPlPdDMeyIGS7pzS0Q1tpyP0klc5urzG+XqL7nCmYhYmm+ZEkhSXHpzmLJgsRB3LDmF5rMV0rEVRMpi2DUEzQtH4eUrwr2OrZjRZBxRIvRaDxd4YYx9JOGb++xfHbNrNrcxw/JBg6GEMrN0gFqxUmKw5GpFEJlD7riwQ1CFDbG4xuScHShsI7S7DHSR6entTKBEvi/p42xbznn8QUHw9FfeO5xGVXtOwpqE7NA3TRI2gX6bzgMmsoYk/jDGQxLe8EFD7ZE3Kr74marCC8JT0cg6GIbq5y/GaRyaomcTXesZEuxAmlz/uow3MZ8i8m6GWI8jR5bLpaYLRi4vYTQUT3ZgIeDEKZa9UqzNergmNIAXuqXmX04hKTJZN5XZ6vdxbhP+zm4oNsYcxAe9nn0CgVmb79HKN1m8SS040zTig+GsnQejC8NJfT4zHJaJxLmuONNoljCi47jkXlNp7kprKszw5c9OIzlU/2PJ6V752yxfKT6nye+w1+YdG40gbKeGOL0tLFOcDiuvjlUgGphn7H/hYq1dUqQ8kimfbkcxRDdjHG8cWLvaAAyY1h/xya6CVXcfpvFpn+iwUhbwFlR7orBjKjVBSWiW1JiyMd9OqSLxdYLktUsNQiqaTsnSASRVAUCz8ljvMjdsbK0UaKuh3NRNq3WmHWsgk9hTtM8h0qD3alv5mqapKih3ZNUQSdD8AyiVsVjr5ewfv2MVFs0ukWKf3EY/XPBESWNMqMt8toQ1G638c468qHYn2J/gtVRusGw1sRzz+/j2PGfPSzbda/oynfk5DxuFEiccz8OavJXHg5ShG3qkzX0yFltjs8On06vq9Zy7NudUcMTsnNTU7frDC8DomtKT0xWPleH+PxgbxmzboMk7NM3/T0oNeXCOse5y9K3zcqgTEXfXzpbkd60rbD5M1terdsnIFkBXsPO9AdoEo+05stjt90CWqaqBbh7dq4Xag+DPF2h4Qtn8myQ+grag9necYtloVebTK5VmHaEACaO9CUdqZY3QlJ0WW8WRRMRyBcf2sieQTm2UD60LYlxTvhYrGyLcKVMr2bBcarqUIJIFZs/SMofia/lw4jmSktNyR3uDcQtVe5RHhnk86LHt2XNNQCGNo0PjCoPArEfd0bXPTBU/Wcsi2MSoVkY4nx9RKTliAejFDkpcWdsaC453OJCW2WSSxDroPBWNqAlRKTmw36N2yCChQPNLX7kxwJokxDTmlTycNY/DwatWr+vBNL4Z0n+MeByIgnMyk2WeFIdO4ZMGpVaDeYr1UIqhZGIPA89o8uyAEZUyybIV6BQxqOjapW8gS7vMcvC0n+M1my4GIbKLtdbQFdFbdcIo4utn6urF/ZY+bqxy9TItg79rcuXLSuK73KbACYySUh5wBdHfrm31tYqJ86BcDlN22hoOSsfkd0+vmiv0D4XOwdZgHqVEvyuGEEaU4rmWks2z1Uy8T1MolnYY7mF7ukdIipiqLrjmo+KEQfHcaErRJhySL2DBJLpS7QRLJtz4eilw8D9NaqYB5qruB7BxIJqG2Lyc0Gx2/b2K91ebF9zI8fbFP/nkv7vYFw0tPCEpZN3E6I/dk+SinC6yvs/0YR951zvr31CS97e/yX9/8Veh83aX6oqX06RM1jguXUmDVPZIA5maErRebLJcEJTyMSyyDyTAkh3zu90Hd7BWEA1cqycE/nYmIrFAhurTK47hEWIfYUjU8CvMc9ODyRFlt21E7jMjMZ4fj5NrOGyWhTMmiNAFQM9fsxlR/tSivJ9/J5SFgypef82RFEEcHza5y85jF8LsaYK/x9CUC35hrvNMQIEqKiRe+GTVyAypOY6nuHgr5u1Bm8sU73tknkS9qW8JwitAEqgXld2iWzmok91djDGO8g9XFEEXqlyXS9hIo13qMudHrolTbTzTKdF22GLwWsrXU4Oq3iPPDwjrVIOZ+cSpsj27g4dprYJvkE4zttBlsWw+salMYeCKiu8c9286KFTlEqQZgXDNoNgmUZ6kaeQeinMuT9OfZhDzWSxVZXyyTlAmoWYXQHOZ9n/Oo6k7acrIKKEkbUvTHmg8OL1mm2Y5/PRaK5oOYZPl+T1tZyQvtdaPzoGM46Ipf2ZROoU7NhMptjlorgFXKEeOwoYkdRfTzD/mSPZDCQzUYq/cyGwVeNp2Z2fXkFWWtSptdVyaaxoADMNq9GqZivN3o6vUDOXJGYG14hP1k9S+14VZp+iZCQPtcvRwFIfQD5jjydsGe9sEuD28VhLFzq4wOXiZ1XNbgLkLlF6SeQw9uIk4vCstgPzEIfvILcj2Nf/MxCPmkeWJ4mlCVby0RFW1KhzroytIvTiLt2Q1KSss1BaluP6h6zlpMrR5x+hHM2lqzVfqqvTnX7SdUnKtooLRLAxDWZthz6N03GGzG6HOUZu80PxbiVOBZxxSGoyIDTfdIR275OSG5tsvebFYyvd/lbL/8fvD/Z5qe9TX7+45vc+N+mWJ0x840q/RsO1lTjncUU9oYYowlxq8J4s0jvOZPYFulp8SDE3etBd3DR3y+X86JHomXXmcpDp69tMW1ZRJ6idBCJ9O/oND/d6FpZnKNDYb0r2yK5tcnR1ysMbyaYy1Oi8wLl+ybF44Ta+2fovUNpAaw16d0uUujEeLvDvEfNcovOa3W6vzNBKU24X2TlB+AfzDCihMQyUImYuQBG1zyKezOczw/zVKtos8XZK0XCsmAg2u/PcA766ILNfKnIZMVGK0XxMMCcJ1KkZ6G8l6FschLfJS45WP2pIMHjhMlLqxx/zSZ5VTwX84FL9QOH6qMoR0ELCsWQwXmUZkYvtQhXaow3PYYbBrErBcg70dTuT8VfMB7LguPY8jlKQ2CUVyDYaOTY6tJhjD0QVIc1DmW3PxjKQrvWxsjafNOZtJde2ObkjSKjLU3iaBofKeqfTuU0e9LN8wEyGWZm0lSWBbe2Gd2uMq8YzKuKyJfBfO1+GjSTtjezgpEMR3LiKYgSKNho5JsmaxxjD0LsR0fE3Z7g18spM2s8yTlXi1iXfKi7gJhfXIeUZV1OC1tozSyuPdktm0VeSiJcmGcu3le2Rj2l+38WCfSXxQJSSm0C/yOwgixV/73W+veVUg3g7wLbwGPgL2utu0q24L8PfBuYAH9Fa/3TX/QYeQFwnAs51ULllC9cbuMAl3brV2cGVxf/bHefq3hcN2cHqWJRPohZ3y57yEz9kz1WhouAvG+dK1WyuYRp5nJHXSkSl12Bg3X66MkEo1GXgW+qdVfTuQzZHId4uUZYdRluOBixxj8KZbh5dJ4u/AZGpZzvtuKCRVixcTtztFKEVYejd2zi58dstrscD8rod6usfX+KdS699PlKkcF1B61g+c86sH8klvbtVc5eL9N5NeGt1+9zze+wP63x/Z88z9Y/Tih+eEhwo03vZgG0hK2XPutCognbJU7e9Bm+PkOPLQrHFs0PYwGIdfoX2ce+j6qW0a4j/f3RSJARay3OX68xWZH3rrQnkYXWg0N5r8qlvKgShFJEUyT16BvXOX7TJLo2Y3v1nJ331qndhda7XdTeIbiu7Aa3i8S2ovJogvnoCOZzohe22fmtItFzE6rlCf1BEfuex/p3U5aNnRJqHYvpehFtgtsJ8xQw1agTrNc5ecMjqEDhVEikuWIoxRn3b/o44wTvcIZ93JdNRxihS768j0UbFaYBP/0h8XqL6VqR3i2L8Zom8RKMuaJyX9G4O5fWR6YGyhLqsjZis878WpPxqsNkRcis2WtauzcSv0c6FBchxTzfBRvtJsFmk9GGy2TJQFtQ2pcFp3J/iLEnmAZV9ElqZbl+T4USqzwPvbXC+es1zl/TqKUZxo7H0rsJ1Z8eSfavY0OjJtz/SXDJfKdqFUYvL3P6qkVU0th9Rf1+TOnBCONATo3Z2oBji/FuOhNmT7vBfKPGdMlGJVDcnYrf4/HBhcwzTeBTUUxyev60tFgpcbOnhYU4eWoNygm8V04BVxf3q9/LXcbzOUnqUbq60GdrxyXPUgZ9XFzPrhSBX0YBWAVWtdY/VUqVgfeAfx34K0BHa/17Sqm/CdS11n9DKfVt4D9ACsDbwO9rrd/+RY+RzwCuFICnXlC4VAQuZQR/Qbsnq9CLsqzLut84f7MvKXuygpNJOyN5Y7LeYVYcciSEmSZ6ZfLPKMpbQRgqp1qqKBES6EjMSbrsE1c9EtsksQ1pFWgk1D09MWAoVKmE9gvogi2DVMsg9iyMMCEsWXRv2wxeCVB2gh5ZVO9aND+aU3h8TtwsM13xmLRMnLGmcq+P2pew9Mmrm5y/5BC8M+T28ikGmp8/Xsd9WGDppxH+kwHzJRk2zuvQ/iCi/OEJ2rXpvtbk9A2wt8YYRsL8UZnGR4rWu1JY9Cxz+/o5NVJPp6LSuLbBya+2mS4pwrLG6Sv8Q03rJx04OJHX33VlqLv47xwHVpcY3Wlw+A2TeHWOYWq89z1qD2IqP9kn6XSFkdOqEFZd0EiY+84RrC3Re7nO0a9qlm+ecbTboHzPprSfUPvgXHrWtkWw0WCyVsDthJizWPDPGQtne4PBHcEozxuKxBJUsr83Rs1jtGsyWxZevDYV/qMBRncgu9eCK++jbZGUHFSsReqbklO7b69x/opIQN0zg8KZpnicUHo4kHzeKCVIysUsu3ZDoVeajLfLdO5YaBMZkk5EGpvJOAnCXK6MYeRObloNgo16+h6n6qgh1D9Loz5/cj8VOqT52Kn/RY/HGMtthq8s07ljMW9ojAi8I0XtcxmwJ8enYvArl4mXqsLqybIMGnXmWw1OXy0Q1CGoJRRODBqfxpQ/OZd2n+uiSj7aNMQwmHkeVpcJthqERYuwJCdO7ywSafPhibS/PE82Y2WZ+mezEAmaEYYSBqh5nKeZEYQXiIcFuOTVvv8iH+yZap10JpC3iudzUQQlC+/flftZlH9eNaxmAVI6bRllt1/6EFgp9Q+Bv53+9+ta68O0SPzfWuvnlVL/Xfrnv5P+/L3s577oPrMCYPh+jm9+iqmx2AuDy2/IU0/SyKWk+ZfSKb7h+7L4a6FbZr3/XHpYLuW7zKylo0zzEi52EQWRHf2MdJHTs9lFaPXqMuFqLX8ORphgnsuHThuKcLXGrOVghBr3fC7AuDASqmWKfVZFXxhBGSTONglaRRLHQEUJw02H/vMQrc4xTh3qnyia7w8weyPiRom45BD6ciT2D6aYn+9Do0b3a206LynCzTm1+pgwNpk+qNB6H2p3h5DA4PkynRcMnD6sfXeAedRldnuF4zddeLtPqzRm77SOfc+j/UEkILBOT56776PKRRnQhhG60wVlEN3Z4vT1IsObCSpUlHYU7Z+NsXdFdZIFjKipaLaT4UhOWKUiLLeYbpQ5/IbDfD3A9GKcTz02/2SEeW9Xju2NGnGjSGIZAmRLi0n46g0e/XaB5a8ck2jF8f0W5Qcmq382ENIooJebzDbKaIU4SPszOEvNatsbTDcrDDcshtchdjWlHYPyXkzhRELd580C1ijEnMcQJaJ5T+c98UqduHhxgrTPJnDWRaU48KBVZLgl8tTEknze2sMZ5iAAy5Ad83nvkmvVKJdItleZrPscv2ESlTTFPQO3q3EHIos0d08uWi5eQZzqqWrOaDYIr7XpPefTvwVGKOll9fsRxQcDocIG4YXDPhDBhVkpwXKb8XMNzl6xxHw3TP0Gd4ciKuj2ZBFL4x1RSuSdQYBRLjF7aYOjt1zCqkYD3omi8WmI/9MncqIouPkGQI8nFwt3vUa00aT3XJHEFqKq20vNjAsIaNWs53iRrL9vNOrE7RrzZV9cwr1AlHOHJ5cNammsaC4BvTKsBX6h4jBb1C8ZWBcHuosxj1lBWPhajqFQKs8RuITBWVgXf6kFQCm1DXwXeBnY0VrXFr7X1VrXlVJ/APye1vp76df/FPgbWuuffNH95jLQ7Cj1LBzDwsAl79stTtrTqpjv+NNFPevzK89LgyQEL5sHhSzA5HDd/FicKVQWMa/AZRDdoqHEsi6qt++TbCwxX/IuNPRhlOf5JmWfpGDlREznfCYyttEov/CyYqQLjvzOSqFmc8KVKoPrHtO2YrqsiYsJhUOT0p6m+nCG1Z/mJwRtCmXV2ZOwdFUqMrmzzPHXbIyv9TGMhNFehco96ZeX7w9JPIvebZ/JisI71jR/NsB4fEBya4OH/2aJr/7aPX6l9oA/OPoKn91fo/0Dk9aPz9IPUSjPOTUFmaMA86wvbJeNVfZ+e5nh7QichMYPbdo/HWLsnggGI+3NEqTW/OEIZZoYjbrkJWxVOH/JYrKWoJ0EFSvW/ilU3z8W9+tKm6TiyW56Os+dvsnz19j5VpniO2f87vZP+G8//FXMu0VW/2yOd1cGv8lyg7joYEwjwUAHYZ69oF+8QfdOidGG7IwLHY3bE9+AczYhaPlMlmysmcY7nmHMI8ESh2Eue42rHkFVdvsqQWYinR6qVGS+3WK46Uo+7jDBnCWYc5H9aseAWEts5ywg6XRzqTGNKuPnGnRvW4xem6EnFrUPLer35rgn6bxoOs3jNUnVZslwKAvktQ2GLzXpb5vMGxprrHC7MlC2Pj+AMBCDVGo2i/sDuc6vrTN8oUHvlkR9lvY0zQ/Hwu5P08CymZhypf+U9fiNZoNkrc3gdpnRhgQVlQ5i/MMp1t55/vupViP3hSSDgVwHzQbBdpvpssN42cQea8q7Ae6TTh7Yk9NLU+pvbhir10k2lhjdlJOAOdN4RxOMz3dFJuoIgTajyGZzhUWZpuG60sKKogu22BeYTS99PWUHZWvUM9lAC4PfDFP9hWyhK5SCX9oQWClVAr4D/Gda6/9dKdX7ggLwfwJ/60oB+Ota6/eu3N9fA/4aQAH/a980/+Kzd/jZzy/02bIdN0AymVxM1Rd2/YukUJTKe+9MpsIkv/xkLoXRXE0EuxTscOVmeIW0deVIT7dWlEoeyUVgzAKSgiP/L7pEJQelNeYokKNnLzXauI6wbUbjnFCoSkV0yWN8s05cUEQFxaxuMHg+RjsJzqlF6wNN5ZNUMlly8nwB53QsO8Z5gKpXGT/f5vgtm/nNGXc2j/j07gbtH5k03++hZiHzjSrnL7oEFag+TKj/TPr3g29eZ/9fjfn1l+9RNAO+s3eTyeMKSz+G+s+7cCC7p2yhTjxbYGKHZ6IEaTWZvLTK0dsOUVHjHyjW/rSD2jkQvX9VHMJqMkMPh0J0tSyM5TZxsyyhK1uK+Z0pSWjif+6w+UcDjM93pcW2uUpULWB1J3DayYey4e11Hv1OAXNrzL/38nf5o5MXOfwH26z+yYkoV2yL4FqTyLNwz6YCnBuMiU9OMSoVwufXOXnTZ3AnBEvjHNlU74N/HGEPJaBnsuqSmOCdhngPz3ONPYnOvSCYCm0YmL1RvvtWzTqz6y3igoE2FPYoQsWayDfzIpHYSp5XX4LPMQx0pUjiO8wbLmHJZLRuEjuSlVx5ElP52XE6W0jduln2RTrIxDQxV5cZvbxC/7pF7CGojhNN8Tii+OkJujeQ685zoT+U4u046Bdv0LtTYl41SCwoHSaUdiaYd59c5OMWi5ezNiLJ2DXKJZJrK3RerhC7yOK9M8e+uyezlFSGietKrm8UiXzaMNAv3czT3mYthTOA6qOI0kfHIgJIlXgq0bmTN5nNJei9ViVuVZis+0ybJmagqd0bYzw6kGvT90XiaZn5qT/JAIeuKxvMbHG2LHluk6m0cuDiRJCyf7LWcL6sZC3tVJ4aD4dfzAOCp9a/RUn6F3U8fiknAKWUDfwB8Ida6/8q/Vre2vl/owWUs4Ce+QQWjlUZ01snOf75klllcchrp7ulheHuJQDcFekXkCuQnnXcIs33zD0HXgEakvQVl10S15Rd77kwZ5JmBXV4zuTNbZxegDGPZNEfpzLQQFQgmXbf6A2FGZRKQ4ONBr3bHqMtRVhKSGywJorGx5ry45m0OJKE2XqFxDGwh5FEPp52YKXFZLvGrGly9jq420M26z0++3CTpXehdneEeT5k/MIS5y/bWGOoPIkofXSEdmxOf2WJ4u8eMo9NbCNh/6RG7Z8VqH8mQ0j6Q3nt0xZG4tmCLO4PUI0a599c4/jXIwrVOfODIss/hPq7xzAco5cbBO0i5iQSt+zhOclAduxmu8Xs9gr9mw6z5sXA35pIT9r70ecy2CuX5DSXAviS+RxzbYXB6ysc/6UZv3L9If9W+/v8uz/6t2n9XwWa3zuAOCGpl8RZXTKxx2n4yGEHPRoRvbjN4IbHaMOAt/rYZszspw3KjzXWTOMfBxjzmMFNj9hR+Kcx3uEE48lxTnBN/AJxxb04TYynsjNeaZEUXWZtj8RRmDN5bGJN2CgwWbLRBjijBH9/IrjwrqCpk+01aVvYKpcDZ2HvxiiQ/nWnl6uRzLPhBQOnID1/1agTbNY5ec1jvJlgThX1e5rKgyn2UU8Kp53GLKYLoVEqordWOfjNBpNlmdO0Pooo3juHo9MLV3fBEYTHTHrombLFqFSYfvUa3dsO0xVN+TG0f5AO5y0rR6Co6ZykI4ZD5TiCjVipc/p6icmKOKf9I/ENWJ/tSUuu4KLqNZKKjzGYEB8cQRxjbq4zvrPEeNViXldEHjQ/jil0Apx7svCrUlGKnGOnhXJ6kSVSrQiuJFtbkLlhLgXNKLbmRW74ojfgmeiaBXjcvzDX/wtaPldlov/SC0Cq6vkfkIHvf7Tw9f8COF8YAje01n9dKfWvAf8+F0Pg/0Zr/dYveoysBXSpTwZP/TlDuObSzVRvq8dSkTOa5yInKJOTAk+ld11a2DOy4EIFX4xyyymCGa3SdUgKliBuY33ZpWmZREsVwrKNez4jKjm4O+Iq1d1+rtZIymIKM0YSXKHjJB/o9e9U6d4xmDfkd/UPRY/e/HCMddwnWq4yaxfS+cFMfAGDIcrzCLbb2J/tk2y0efCf2NxYPuOznWXW/8CifL8PSjFbLTGvmUwbBtXHIf5nZ4SrNZ58u8Bbf+5Tfnfph/znn3+b44+XaP5M0fh5D7V/kr/u2jJFTqeUhLL0BoQvXePJb3v8G9/6AbcLR/zXd/885j+psfrdLurgjOlXrzFtW1gzTeXTHuwe5pJYVS4R10qMbpTo3ZK2hHechqB/0EXtyP5B1WuCz+j0cpewWltmerPJwa/arL4lRev4fou170D1h7ugFPFKnbPXymROW39fWgCqVmVyZ5nubZv+63P8yozJuU/tA5vSofT37e6U2WqJWdMmKCsBsn18KAYnrSU/IY2cjH0HbRkSzNPp5diBqFYgcSS7N7vNaxahb+QKISOMMfdOpf3lFWC5xeRaRTKSNXhnIXYnjauMYjlxwAX+IpNyRpGcSOsVwlaJHc36rgAAIABJREFUWVvS4karJkEF3B5Cdr2/I69frQqzOfHZuXxMWk2C59c4fdVjvC6D3coDaL4/wHi0d+EvMC+iFjP+vuH7sL5M/ytNOi8azDYCvMfCSfJ/8lieW9HPB/t5e8N1CLdaeXh95EHiaApniqV3J9h3d+Xzs9JGuybGSIprfHScM4HOXxMlmTYhsYWJVft0iHnUJen2MCplmYMUHKGWjqdSdEpFScdzhRbL8dlFiuCC+CPDwAAXbeorQ9urQ9rFtevqmvNF88undP/ZRucqtuaXVAC+Cfwz4ENyxTr/KfAj4O8BW8AO8Je01p20YPxt4LcQGei/84v6//ALCkD+JNKLZEHDn6l4MnfeohM4KxBXkQ/wtDwULuYGwFM/j2mKfjhj97g2SamAmi/Iw8JYdkC+MPkT28SIEvkZpQR+NZvJRZd+MMXlmQioLAjRZZ/EdwjqBUbrDtO2IizLcK1xN8pjD+N6kXlLcmadXiSFpT/KefGdF10Gt2P+w9/4Q/7hwavs/myNxkdQeTLHOR0zviFBI9ZUU9qdSVyg53L6VoNrf/U+//H6H/HxfIP/ZfctRn9/laXvnaG6g3yhS0ouah4LRbIzJDk7x2i3OPztTb7xV3/K31z+U37v+Df5zt/9Gqt/NsZOIw3HLywxq5sUOjHFn+/LTKJZJ66VCBsFIs9kXjNAgxmCPUrzAx4eiOywUSYuuli9CfrJPiDhIZM7y/Ru2AxvJqDBPzBYfm+KfXcfZdvE7Rqnb1aYNRXFQ03jA5lp0KwxeHWJ09cMguWI1lqf8yd1ik9Mmh+F+YktKrsMrkkP1z+J8PaHomWfB6IwSfv4kWcKViJKZXuVIlG1QORbouo6m8jrVS8xvl5Bm4rIFV+A3ZlgnHRJBkNUsUiyvcLwepHxipEu/Anlx1Ph9gchqixwMyzpz2dDXUg3Ra06ie8waxUYrcuQFg3OWFN+NBa8R39w4a1Id/zm1oakbW1bTFcUYTnB7hssvxtS/FRaLvlcLcvkdmwx8wUhtGp0X2ty8hYklQg1slj5AdR/fERyfCrOXMMQkUQYyCmgVCTYbDJed5nVFGFFYY3BGWhK+wHuhzuiNmo2mD23LJm/nTF69wBlWczfeI7pkk3vpkFQ0/iHispOjHcc4Nw/kGJaKqJTz41KEkF8mGbeVouqBYxQcjQ4Ps3xEXlrB/LfO+vjZ7JylaaLATmdNA9/X1hDrp4E8nZ1VkQWiQVpuztJT0SX1EBfShx0CoO7xLt+xkkgY3Io37vg/2QAONu6iHhLHXlXb1dNFYunhEX/gOG6UnUzw1WtciF9y3DSWstgdzwFpUhqZZKSgzmcS6ZvnFy0edJdj/YLaE8GY2o8k6JRLTG5VmHStkgcULGwaLyzGPdYmO8kibCBmh6zhoN3PBMLfbdPsr1G59UK/ZsQtGJwEsyeReHUoPVBiP+wS1IuMG8WSByDoGRQeTTB2jsnbtc4e0PYPr/71R/jmwF/5/7XqPyDMrUPe6jZnKTsE5ccgqqNdzQRhcd5B2VZTL/xPPu/bnHjrR3+0up7/L2DN9j57habfzzGmEZM14vEBcEKl3bkMZNuT1QgL27Qv+lInOBE1BylvYDCTk9aWJYFjSpRswiaPPxGD0eozTWC1Qq9Wy7jdVkwag9iSg/6Al8rFIg2mgyu+6IL3xdOkt47RG2tMbzT4OwrJrONkPrKgPEHDer3NMWDECNMmKy6dF40sCZQPEjwTiPpxz88kGSrko+KY7QjIL/Ed7COenIdFD3GNyvM6tKf988SSg8GqCghrHuM1wu4vQi3M8c87aN7/RwgSK3C+E6bs1csIk9T3oHqw4DCo3Pp7afekaw1lOVeKM+T66vsE9V9wrLk/saugRFqjDjBPpTWYE4Ohdxpb26s0Xtrje5zRo6e9o8T/KNQBAz7x5fNltni77okN9aYbBSZ1UxmTcVkVVPcUyz9dIp9d0+GyeWyaPCn81zpRUGwJ5NrFSlSEbiDRF6bJx304UnuYtYFGzUL5f1LyaDjV9bo3bQJyxBUpD21+gMx311qT2UcpP5YXsPxGFWv5Qo5rRTWcC700MHgKfDjU6YuwPA8aTFnm9DRWGaRi7nAVwQsXwh2e5bUffHn0jmCTtHZl+YHv2wV0L+sW0U19DuFb18MYDNX3ZUjlpG94CnTPbNEP2vXng2BnwIyLZwmcp53mgWatY+Mek0GQ6maQbt26gTVubRMCIXpbiiFrekgzC3jhldA1aokFV+i9cIYpbUUDMMgWK8zXXYEEmYKybO0H4iCozOUD3icoEq+3IdhoEIZGqM18+dWOH21wPitKYaRwGOf8iOoPAmxh6EMRcOI8Qtt4aOfx/gPOqjJTKScb7l43zzjZv2M955sYd31ZaeXwtGi5SqjLR8Va9xeROHRueziGnWGX11j93cSXrhxgGPEfHBvi/U/NCg9HhF7NsNrBUYbBv5xuuPePcrVKPPtFmdfKTC4E6OthOrHNs2P5xTuHaWYBh+93ARTCrJx3CEZjnLpYO+mFFB3oHEGckowT/piDCsViZtl5i2B6Pk7A9TjA3k/ltsMXluhd9NkvB2jDU3tY4vKToR7PmeyVuDsKyZRSeSpjY+hvLtgugKCdZE0hmUbI0xkcQSiuk9cENzBYNshqCpBYt8bYkzmzDarefZCxqgXRLcHKy3iqsd4wyO2FWFJgHHFxyPMsz7xUpXZso82FP7uEPVoX+YdrSbBjWUi3yQuSOyjSjRON8AczlGzeR43qkfjHFKmoyhPzMpct70bJlExHQYfpZ6D84EEzqefCUzzouBUKySbS/SeLzG4LkWjcAqlw5jyR2dwdCq99KyHHaYIhTTtLlluELTk2opdQzAip2OR3A5HuRIoKRXk1JQ+j/i15zh9vch0STZK1gy8Y1EDFT7Zu2idtRvC+BmIoCI570hraqVNuFohtg3CskVxV05DSacrzy897WevkXz4L8xaWRgRmc4/0SJcCEKZtZRLUsyvwuAWJZ5XhS6pDDR3IGdD9My7lJ62crNrttal9/nlKABGQ7/jfvtisJK5364cmS6hG9Id+iKwKi8Ez9DnXrJsp7dsqJzleWa5vqSBLTl3feGmZ7N8B0MUSysgDGSnD/Jm2pbwTcpFwUAHUY5IDrbbjDcKDLZFTeF2kZ7yzlj4+SBSujCS18Kxpf83nqIcm3itycnXSvS+PmdjpcvBeZXaP/FovS9QN10tkXg2YdWVQPhpgr8nF3q82uDgz1VY/fYO32g95PG0yff/5GXWvhfh3xO9uG43GN+skFhKAGUn6QI7mxO+uMHer3ss/8oBLW/ET9+/yeYfa4oP+ylT3iUsGsJeuTuUhd80SbaWGW/4zGoG87q0tgTjHOJ9LgsiXiFHWxj9CXQHuQSQW1t0X6nRfUFhDyXRqrIj8DUsUzhK6SJshAn2YQ/Oe1IUrm8yvlVnuGEy2gIUlB7D0nsjjNGMwYsNTt40MG6MCE58mu8ZND4dY54NJds5AfOsz+z2MoltkNgKcxpTOBxBkjBfq9B9zmHeUDh9KB6n7tW9E2lzLLcJl8qSB9Dpo0djwVIs1QnrBbrPO0LFPNU4Q41/FOB+fiwL3mqDWdvDHoY4+12Sw2NUwSW+c43pcoFhGvzjDLRk5KZtQjL8Nch1pPVFIpbrojZW6b3eon/dEKDbWXr6OhzJopnuaHN5NOQqnejWGt0XfIbXFG5HcqXLu3MZsKb0VVX0crd3JsnMaK1xq8Joy8ftRdj9ubSjBsPcaKbK5fTxEpLzjizkG6ucfX2J7osQFxPcE1NiNlOfQzIY5g75qFHEGsxg95BkPhf55kqb6Y0Gww2ZPxU6Md7OELVzkPt7MlUhpiG/f7qm5Lv1lE+WGcWy9SkHyqVt4oxA+tQ69EVzALgUP5nPD67Qj5Ph8Jmm2C8JC6ip37H+wqWYx6tUvkUVTgaDy/jdz0I8X1L2XDVwwKUXOPtarvVNv69sWxb4+VwugPTYnQ3AcmdwWsFx3XSHIFmz2a4HgEaV3usthhsGGFA41ZQOQpx+gDEJhPhpXXgX1EBSxHQY5bvi7qs1zr4K5Vs9BgOP+ncKebi5rhSZrZYIahbmTON25nIKiBOGL7c4/LrBW9+4y++0fsYfd1/in/7kJVrvGrT+7Eg4Lu0G02s16YVGCfbJCPaPc9ft2VcsghemWHZE/LDE+ncjvL0ho5tV6VUjlMzC/gh1fI4q+XTfXuXka4q4FGPMDfwDg9JuQvWzYV5UVMElaZQh1nk8pI4ijFqVZKPN2esVxhsS1iIEyano4uchSbWELljMWx4qSijs9vPesL6+ztnXaoxXFUEjwTs0WP3+GHvnDByb019b5fSdmOLSmMnIZekPHZrf2RWyZLUsrbq0vaOVEvf2LEDbFsOXW4xWTCbrmrigcToGtc8Tqh/3UPvH4jcpyq6d/kjaHqUiNGoEa3IamNUMnKHGiCU4xR4E4mGYByQVn7jkYp2N0Dv7cr1trjLZqjDYtjBCiF2FPZJTY2G3L0VUJzJDaFZk7pSKI3QQYlTKhDdW6N+U/AgjhEInofpgkmvwFyNRF132ZqtJvNFmeKNE547kFbR/pqW3f5QKA4pFkWNGcS4/zYJWEr9AVPeYLjlEBckULn56mkeTqnIJqmUxDJ53BURXqxI9t0HnZZ/hFoTVhPIjk+aHc/l9z7ui1FldIqmXIEqESZReP+r6Jp3X68zqgtjWJhQPEyGyfrYnaiDLEi5Vyv1JBsOcVUU19aWEUW5KzFWD+QzAvgDJLUg18/SxFKr3rGySZ0ZALnw/X7sc51I4jVLqUj7Bl+MEkA2B4Wlr9FWlzgKdE8gHNbnJ4opp65KxLL5gey9e7NktP+JldMI0bQm44HK4br7jz9OErLR6p+7dLBg7KRckTnCrzLwiu0dnlOCdBthHC14ErS/SsDK0LeSMk+GWQ1BRzBuCNG5+ElH6+BQVJ0yeXyLyDAnkSHemajwlbpY5ebPC9DdHfOvGpyRa8YOj60y+32L5x3O8B2fo0QRVLhIuVwkrNvYgxLq/B8ogem6No3eKjDcTkkqEMbSofaLEvDWeE7ZKnH3Fk2CT45ji510460G9Qv+1NucvGQTNGG1qik8s2u8H+B8dSJtsrUXQ8qXQnE3g+Cx3/BprK8yuNxmviuLGmkD18QzrfCrRgHEiu7Q0AB0F9kFXNOGba/Reb9F5wSBxNVE5wd8x2fzHkmwWt6rs/laVya0ANTWpfGay9JMx9sMjiWhcqV+6LlUQCaVzMkVVy/TeWuPsFUWwGmKd2lQfQGk/wn/QFR9DJif0CnLdzWaocpngWouwYhN5BvOKgX8a4/QCnIMehBHxUjVXk2lTYR+lCzowf+M5zl51mS7JZ8LtKso7CW43kmKbSiqpVcCVbF6S5GJh3lpn/HyTacPEiDX2WOMfSroYKXJbT2dPzQWUZWE0G0SbLU6+WmKyKnnCpV1N80cn0uYpCwZdj6eClch61vVqirpwmS35TJYsgqrCP0mofJ7yiOIkD5LPXjcdBBhrK4xeWmLSNgnKaQ5yD6oPI0ofHMj8yXXlMTzJSch4REatyuS1Lc5etpkua6yJnBZLh3EuXU3mc0kJy8KYUue6jgShTaPGbKuGNY4wJ4G0IFPaLClqPv/YLg5lU8OXUSlffG80fhr2JgvbJexDLi9fJIPCJcw0kBNHL57Al6kALPgAFnnX+W2xF+e6eYVdrMi5DDSzUWe7/YVj2KUXemG+ALLI54u61nmK0KWJfnpCUIUCulrKHbpqlHLg00HvdL3EvGoKKjnQeGch7p7k+uqCQ9wqy1xggUOiR2N5rKUm0VKFedNlXhUliNtP8B8PMPojsMw8wCSxFcXdqejpw5iwWeT4LZ/w60NeXdvn45MVxrtlGj83aL/bEx6OacByi6hSEFNadyILjmNz8hdv0n1Jo5sBOjAof+pIP/vzkTBcXIeoWSSoOZizhMJD4frTrDP4SpPBNZPRVkLh1KD8RFN5NMW+t48qF5k812K0ZmNE4J9Ktm28f4hRqRC8tMlo3ZFFfwrlvUCC5KMY7Vpox8KYhiSOlaqu5hcBIktNxi+0OX7DItieYZw6FM4MNv50iHnYIamV6b5aY7RpYM5lsFv7+Tmc9VBFj7heJmgWCGoWbjfCOR7nO3lqFabX6/SvW0zbCmsG5R3p75uHZ0K0TNKT4Hyes+jN5SWSZoXx9QqTtknsCMe+9lEXdg+Fm9+uMVuR1oO/M4DjM3ktTRO1tUbv1Sa9m9Jjd3pQ2RW0dEaGxTJFeeY78veTc9k9NxskW8uMrvnMywZBRUkOwuf93ByYQdLyz0j62TG8AvraGrOVIlHRZLxkYMRQPIolb6DTl3lOtSyfsdEk/3vczhLR0qB3WzGrGXjnCcXdMcaD/csn6PgiQzu41mK67BIVxOugDTBDGcwXHp5KQTMM1OYaScnFGM3Re4d5HnXnjRZnr0PcDFFDi/pHBu2fphLQNB0vC0kijFCjicheTRNzqU28XCP2bMKShf84FSKk0k8jYwlNprKjX4yHzAii5ZK0j6M49zQ8i/Fz9ZbPNlO/UjIaX2xUr2xenwLPfWlw0FdC4Z/lus1CYi7p+6+2bjKtrm2hg/BSoPPVNy2f2C/gJLK4OIx0DpEatbLnlR2xASESOrbs/DxXAjwKFipK0LbJdNUnKBn4xxc4ZOXYEs9YtCUebzgTamQmKUzVK8NrPkaUtgaGgXy4zzpCzkx5NUaQYA8DVBAxb/sEVYvxislkRVN67ZxZYDN/VGbpXai/eyRuY9smaVaYt33MedorPzlH+R7Dt69x8E0TtT4lmloUnjjUP0uoftrH6I9lBlH0SEqyYBnjqQC9SiUmL69x/qLNvK6xR4rSXkLjJ2dwfCrff2mV/nUhNVaehHiPuuj9I5RtEb24zfGbRYKqxDPW70UUH3Tz/NykWCApWNKCGYxzRpMqFolXG3ReKjNZUYy3I9BQfGKx/JM5hQen6KLHdKNMXDAwZwnWJMbZT1sdroMu2ERll7BiYwSCYLA/E4np6J1tZnXR36NEoVLcGWP0xrLLdh2055IULFlk0h47gLm1weC1ZYYbMuC3h5ryboi300fvHKC2N+i8JhnLpT0JkI/3DkTPvrHK5HqFadMkqCgJMTlJKO5OMLojGewqdREWE4SowYj47FxwCS9sMF51mNVl4TViLb3y0774EowUl6CMC417GiATb7QJai7zhk1iQqErJ0rjrC8FIwM1jsfS7vQKEu1ZdpnXXVAwWbJILCj0EsyZpvigi945uAhximPi0RhlKIxmA73c4Pz1OvOawppqyrsRKtH5e5Ucn+bxrItJX3o2h+ev0325SvcFOZWZPQt7ILJV/70nOTxQ+Z68XwuRliB+h6RZYbZawu3MQWvMswHx4fGFl2gBEZ9MZxe+IMfJ4XhZCynf9QehIB0Kbn6i+qLNrOH7+Xp0iftzJdZ2sdgsDoX/OPxfv6QFYOF4pGxLdu6WddGWyaby2ZsURRcckCxIBi5jHK6ogRYn8pAWAMjln/kMQCd5viiQSuns/DQQ14vMlnzMIMHuzdC2iVYKe+9cdjyeJ33KBDktTNMQk2xYXHAJN5rMllxi1yAxkSHq4wN57FqVuFmWDNNpiHEsi0303AZnr/oMt6XHacSQmFDaVbTfF+Z7ZoKatQooDdYoHSienMGtLXZ/q874Zkh5acTwvEjreza1hzPss0muolicheSnrdUlxrcbHL9hERUTyg8NQSE/OIfzHsmtDToviZPTHkDjruTbJr0+RrnE9OUNerccxuvibm59KEd8tJbdWMlBhQnmYC4O6dTgRLvB+PkmR2+ZBEsRJAqnY9L8UFP9qIcxnhKs14lKNrO62P8zx6/RnxA3iszrLkHFxO2nUtveSHay1RL9ry7Tu2UwXU4o7hu0PghkQD4ao1faxBVXks2mofD80x2xDgLU6hK6WCBo+cyacm2UHwhGWY/GGPUawXYaSziLsM7HcN4Vf0XVJyq74g/wTVSksSeRzGI6qVS0WkIXCxIV2e1fJF9VKiTbK4w3ZdBefTjHfXKe786xLFk4ix7acy4kyOM0u3mlxfCFBqGvMAPJQXD2u3nusMo2WHGcSpqLhNfaGGHCvFlg2jSJPAm5L/QSinsTjEcHF6eZTL2XRi+ay0vEa02myx7TpsmspSicCcvK2T2X0/BwJB/TYjGHLCbDkXxGl5qMXmpz9hVBR7sdReVxQvlRGnyfJpMljTLaseTk2unlQ2G9tcbkeiXHbmQpcHmewoL2Ptvx5wTibBNqpz18nUiBSFHPhutiNBvSGhuNiTu9SwPf/N9weQ7wrNB55TjyfDNlUKaOhC9nJvCl2xX+fxYXCWlaTwZmSmmd+a4+7adf4mcs3N/V22IRyFHQhsoxB/JvUxlXetRXBVcGkG5aPAwDNQ0xRpNU7qVgHggiolVBWwbWyQB91pGL0CugymWSeom45DJvuGgTvOMZZn+af+CVYwtfyHcxhhPoy4cifHGDo7c95nUJ4fYPFMVjyZotPuwLAdOx0csNhrerWJMEb38k7R+dEN+5xsE3S4xemlMoBYSPS1TvI0fmMwHXyQui5DWeTPNhXbK5xOBmif4Ng7AixpuV7w8wHuyjij6Tl9c4e8Vm2tb4Rynh8d3HoBOS7VVO3igzuiYuz+o9RePTmRQqrfPQciBHHBDF6LJP2CzSfcFjtKGIXU1Ujal+YtH6cIb7+Azt2HS/1saIEVlhP8IIZBNhdSckBQcsg3mzIMiFXiDFpT9C+wVmm1W6z7vELmgDmh+H+D/8HFWrMH5hicE1C2coahl3pyMnqkw67Dg5p2ey5smisjeWAu7YRDdWma4WsAfRhdKm5NH5apPYlaGoNZZIyIwjZcyCtACL8Ut7ojrL2zy1KtQqRM0isWehFZIdsXN04XxPKaqLpqa8h12rkJQLohZr2RixpvxZXzKch+P8BJzJVVWpKC0nxyapeIyu+YzW0uSzcy0tok9P0QfHuVJvUbWX49IrZWbbTcZrNqGvcAeSZ20NZqiD04tF3rHl85pKKg3XJbm9xWTdT7Owwe1rqnelFafnQc4wSioeiWNinQxEDRYE6DvbjK6XiFKmVmk/wjuQz0SSzi9ANoFZIJRO9IXoZAEUmS34mTM4/9ls179gCJN0w/S1v4qVztaghU3o1axg4Ol1LP+z5k/0P/gXKgDWP+8H/r++PWUCY6EaJqKxz45fgLwJ2eJvqLQSx9I2uELqEwDT5QqcV9+Fn1G+f5H0BRdqntns4sRR8knKXk7cNGYR5kn3YqaQDilZbhG0i9jdqfShzzt5vzFplJmulohdSY9yugHOkzNRYqRDNJIEZnPo9DEORYWk11qcfbVG51WNCjVOT4kc7kFfsl9HY9nxLbeZb1QJKpZIEtOFKHxlm7OXPZZ/PGSynlB44lK/a1N+PBYjU9oyy049OaCrUiZZqdN7riQhI+lBaeWHMaXvP4L5nPCVG5y+7hOWxEi0/t2Y0odHwtBfX+bwzzeIf6NHwT6HD5ts/aMQ71PBOyStKlGtgDGPL9g2/SHasQlvr3Pwqx6T5+YYPY1KNOWHBtXvaIof7aA9l9FXVgiLBoWu7OgxlSwAqRdCRTHmLCBargqueRqKCsm1GbyxznjZIPJVKk2d4368i3Icun/heYabkn9b+1yiH3V/SJItoikLavBSi6ig8I9DSh+fSrvOsqBZI2pXCOoOxUcjjN0jKabPXWO8XSax5P33D2aiToI880FN57KAp+lVDIboyRRjZYnpN5/LmUBuZ37hMu50xT26CDJLFyqdIqTV1hrTrSqjNSGYgrR6vCc9kSqnRM1sMJpFmuqiR+LZRCWHoGrRfc5EJZKDUPz0VNRbcSwLYIpfUY4jhcr3SMoeke8QVmyJH+0lVB7OsXdFgZRJVM16TTZvaVqX4fsY25v0X20xryrMmZgGa59JYJAejdG+j6pXCVeqmGNRUxmdXj4f6nx9hfGaAoVkTrw3yGGFSWpoyzaOGejNKLgCsdtoY5xI1KYuOFKQhsN8wddai4zUEQ9T0h/I7+37F2KAKJLX8ws8SZd29Qvfv5pB8NQmVgHPHi08dfv/9wkg9QFc0u7/glkAkJs2sgSubCCcTKcXU/MF88Ui1wcut4YWU3vkvg3ZNf0/3L1JrKxJmqb1mv3z5LP7mc+d743MiBwisobMRoUaCWhRdLcEi+5egNiVWrBrIdZs2LMC1DsakFogWLBAPVAsqqqpzq4hK3KI6UbEHc98/Pjs/2zG4jMz//3ck9kFTRUiXArFveeeyd3/3+yz73vf59WtJcuiI526CfiKqgBWlEavL9uxSXrSSVJstoS4HlP7aNRHuZug8i3wUpr+Pb+eUVuk20G926WFa0xWd1nXW2TKMqLQjPgVR+dLcvnqpDHUNRl09oeoWy7cV2PKqd0ZYvpru7j8AYM8zGC99MELhu7nNNjlaQlpE3aYT8l0wwLfDLnznRjz+4SmKLoSydegqv35KclUD/dw82EXRcLgLiS6ny3BX5wCjGP5Vx5g+ohwxVGSIf2qhd1/LtH+E1oIxdGITFs2mZz4xQ0NKA92sHivjasPOdiTJd7bucTHXx+i+2OX8m/PJhCtEOlBgvXIRjCuEZyvwbIKMnDId7FSm7ZiMzEh6f8qSSt7tovLH3ioHdqwdn+8hPXlCerHBxh/ECEdElOm/0lNi/cLUkcxz4VsxagGMWaPaMOLLpTbV52wqm/dBy9ren/ntJlBCmDQQ36vh9WuwkdfF3C/vDC8fhlQe0knfck8NyEucq+PxdM2ViMLVkm98vCzC8jpzEgRwTmZGPWmkWaGc896XWQP+pg9cCFsILwSiF9tZhqyqVbROOcwICmoItKuRxYkpzD46LxE8NV449hVLRPNIRKjLkWb9ijvAgDsdQ1nntP9o0Nb4oiosI4Ntko3SOgwQPFkH5NXn5UcAAAgAElEQVT3fJQxoaqT1wXcyxWF6zTmENqMKSdTkrx2O1h/sI/ZAwerQwAS6H0i0f2zMc0jpKRZXlUZ8JvOWNAUURGHkIEDaTHUvg3vs5Ot9jNPYsJG62GvWpwt9XzgOpvfqYmPvh0CfxcYrrHI3x76/n9CA/2LfrR5X/7Q/23zJG8T9e7K9+VhSBeezuEF9evM4s8byp27jlS3dlMT9K778toOHnibvqnG8mY5tYlsG7KTQLg2YHMImxOyYLYk74BS9IjER9miIZl7vQYfzzdOX4ujPhyi9m06BisypjXoozoaYHkcbgw7VxKd5wSD0z1SAFvOZI2eqN47xtlvRVi+VwAlg7W0EL/k6D6nxYXVEkwCPK/hjFdgWUEKhl6CKvFQxQ5WuzbSEb0XySuB9qdTsDcUnoJRH+uHXRQtC9FpThtCXgD7I9x82MX4A4b+d69wNU4Qfhxg95+v4b68gpwvUL3/AOsDH/ZawJ0UcF6cEwhv0MHNR31cfwQ8/eg1uYy/PMLw9x0M/ugGbLZEcX+IbOjBvy7gXKgQ+igAbItQ1FllspVZWVE1fXJJGOZex+QhZCMBZ85w/L9ncH7xGuJoF+PvtzB7BkACnc+A/k8m9F7VtTEZSZejSByVj1vRe/biBKzXQd1PUMcuSXzHE3qddgYoeyGsrIK0GFhFzBlWlHRiY3wjNFDFjlyp2YvngR3sYvW0j6xrQThA99M17K/PNj1ynaOtNhDpe3SC0ogJzwPaMcqDDsrIhrOqSHp7eUMLYF1v6J1huIHK+S5EO0TZ9pEOiVTqzWoEbxdgFwQ2pIXfMu1R7cLOOzYVBEtJg/nznFAUl9cmLIklCcThyITmiNNzMjw9OsLkgxbSEVMZxmKT9HV+bVRELInpXpzNN4avoz1MvtvF1UcMYicH5g6GP+YY/LMz8/1hWbSJq8VcY2Os3R2aGTgW5TJPM3Of6oWehyFtOp4LMZluzHKqxWaiZXX7TBek6rUyRle1Roksf8dp3Aya0UNfWdeb1t2tYJp/kv73///fAFq8L3+T/1vGzWsGIrcXbMAs2rcTv4ytWj+49c4ifyejQ/0crtQ/mmkOxzEZohCCblbAaJ1hW3STRNQPscYLyOUack35vuh3UI1aqAMbzk1GLt+SZhiyqiDu71HlDZj5gKwq8G4H5fEQRcdFmRAf3k4F/LO1CY0h74ENQ1TUzy+JsfjuDk7+Kgcb5QjCHOuXLbQ/Z2i/INOZ5Ax1YKMKLLiLEs7JlMJGegmqboDVngfJqA/upHQDx1/NwF6egrVbqA56yLsenGVFg8LrG7AwwPr7xzj9LRviQQoJoJ672Pl9vsmhjUPMPtpB+2dj5PstWOuKgkeqCuUH93Hx6wEWz0rAFUBuIf7aRu+TCtFnV5C+h8WzNgAQluLzcxpuj9qoY2rlWcsCfNkI684LY0hCp4X0UR/X33GVKgdovygR/fQE8Fysng2Rd0h33vmyIGlrmgGdFsrdBGVkU7iOBIKLlBbwNVXXcrePxZMWnEWN8BdnhnVUPNlHNnRROyQDdufK+Tpe0AAeoE07iejEeD1VIe2Mqtp+F6IVoEyI5GnlgtzEJxebBVuHnKtrSudUsyAA+h3I0IN0bROL6b0leaNM083iol26rkOtEM9FudPGet9HGVJEafK2gP/1NeX6AmDtFmQcUHstLyF6CUpl9Ep7DNJi8GYC/o1CdZxPNi1chYAGY2CzxQaAdzjC6n6MdMAhGTmqo69I9iyXq+3IVr0oKiRGdX8HF78RY/FAQHKg9RVHfFKj9fGlUbnJODSFmU4XY3FklHd5zwMvBAX2vL6BPL3Y8gAZfX9eUDiO69Cwtwm3Y5yGwXphby7Wah7SVAQ116N35gd3fI4+DWhvgCyKb4gKSMHguO9tdrtmCk6jLaQ/1lTvMNumI1xzA1Du3LtaSLclodzzTL8OjkNVjX69NBNEt4G0U3i2IEplEoClBck8tbElDiAib7sFYNtAtwW2zgDGkD8awT2b01G4rsF3hsju95EOHTopzGoiTy4zOs7rI7rmkADGnciSBNn3jjF56mH6gwKWX4O99dF+TjAxAKRcUUNRnlcUMTinrxejLrL9BNNHDlVslzW8SQXvdE4k0LyAPNpBepCQMuVsboxAsx8d4fIHHPzREp04RVFZkP+4j90/mIDPVqj7dKJY77pYjzgO/te3tLimGcTTY5z+6y2sf22No+EEb666aP1egN3fp2q/PB7g6vsR0h2g84VA8iqD++oa5VEf6a4PXkiK9btcgM2X9N6p0B/YNkQnwfp+C6s9C3lboaU/WcI6HZNM+HCE9DBC3uYUUvKzS2A8BfNcZN8+xOLYRRky8EoivBaGcyPrGtWHT1BFNhmG8hrW+QQoS9SHQ6yOI1QeQ+1Rnz46L2kBnc6Nqku0QvI2TFfAdG4Y9/JwD8VORNRLPcPICkqLy3LS6utKXT1knm8iRLttuo5GhAHxbsoNhmI23yTgNV3vmoXfaaHaaSPd8VEFHO6shn+VkjAgy2nmUWyKGOY4KI8GqCKbXquIIR1JeBMicsYvV7T5S0mLsMUpFW882RQ794bIe+R34TU2QobLmy3+vnloIFuSQB7tYPbtDub3OPKuRHDJMPwzysEGQLJPwGQVCHVqsoYDyHaMshei6DgoIw5nKWhzf3G6GUQDGwik2nB0qI4MPEjLMrndzcFxc3a5hX9QD9Nt0PLPRr74L50T3H6oz/lGtICaNNAtPCpwxzBXGk+ADoBhjHICdOgy87x38KsAzG6s1URbrA/FTmG2bSBWcragG811TI9SxiFp97MMLFbVl+9CJCFgMdL2lxXkRAHKfA+s06Y2RVUTv8iywF6f0sW1M8T8gz7WQw5nRYEg8VczsLPxJrTbst7RJGsqavlgF7PHIabvARBAdAq0XlZwpwWYlBA2VyA7wB4vgdmC2iFxBNFLsHzYQtahQWcwFrBTQQPBNId0HVT9GHVIpxj+9pIkdoMeJr9Bc4XHP3iNjpfix58/xM7v2uj98TXYOkNxb4D5g4BC7gXQ/nIN58U56skU+M4TvPrtFto/vETHT/HFzw+x/3tA688uwfISk79ySMHooURwwXH0v92Az9co7vWx2vVQBQy9XyyJGTRbmMAf5lDISHV/B+v9AMtd4u+3X5QIX83BxlPA91AP22T0c2lhcb4+p/ex30F6mGD20MF6l2SNwZVE/2cpnMsF6l6EdMeHNy7AKwH75YXBZF//aIh0wMBrwL+WCK8qI7mVS7WBBz6y75DhLRjXRiPPXBfi/j7KLmGJneulaXds5U532kCvTXLgZUbZEq5jXK3lKIG0KSvayirwN5ekedftBFU9G029720wx3GAfK+FMrFgr2q4k2xzorItOvHoDcz3SZ2WhMhH1PKZ3+couhLtL4BgXCP501O6/m2biiJdJTsuqsf7WNwPUCRk+orPa/BCInw5B3t9SgVgE8Xc4IPpOdfqfoysQ5gHdymRPF+An16BuS7Kwz45qq+W1IorSjq1hL4h44Kxd7AnYr0GjyOwbofmJyr9y3iQwhDi3g6EY8E5m2zHR2J7Prn1MdXSYa5LMxpOvCEtHb2t+/+XhsY01JHfjBOA9gHc1sqqvv1d6qAm26fpDDZfrvtvt5J16FurY5d2BWu5FrCBaNW1ORLroRw8l266xpBYRgEhH4rKMN1NBvGoD9GiSk0Htsg0IwPNwQjzZ22UAYOdS8SvU4N41i5NcEY3W5YZ2BxzHWBvhPReB4sjG7VLrYnO1yW8qzWsyYrgaG16HlvB5kq/nx21kfccLA84WAUkJzWCswzOxQzIC8hWhHyPUsbcaQ77fApxNUb9vcc4/2GExdMK3f0ZJidtJM9ttF/UiJ/PjAZ/8q0AZcjg30h0P5mDvzqHeLAPvszw2d/tY+/ZJfrBGp/8iwc4/D8qRD89QXU0wNWHEbIeg7MGWi9rgyyYf3eA5b4FZykRjGvEn93QJtz0hIQhqsf7WN4LUCl1Ve+nU7DTa7p2eh1U/Ri8EiZm0WTmRhHmv3GE8fsW8r4ALxhaX5Esls9TLL/Vx9X3bTiLjUoIaYbye4+wOvAweUYLESuB1iuBzmdLcr3mpOThwz7qYZvkvpzBv0pNipiMQ5QHHbBCwJ6ugevpFpa4iSXXmBHkVDWinRjcCKQkh/ScjE5NF/xttj1vJRADGtKySlB7y2KQjJE/4XJO94XFqcVzQ60fPhpARAFgMZTdAEWbAm3KmIEX2t19DXl6sdHv65zgfheL9/soIoIgMglE5xX8twuwizFQFibhzxA3a2H67Hx3hNWzIdY7BHTzJhUFIakTBgCg1yZX9GxNp6p1Ct7rong0QtYj5zoYKKf7bGmKLCkleBIbr4+4uoYoShro6hwQx6YiUEqw8RT1ZLqhCTf693rh5poLxvg2TqY5dFZqxKbM850BMbC9IdxSSH7jNoAtxY62Q98VqaYejDPjptOB1MZV1xwoN3Zl/XV6E9HSNVNlFyUdjy1rs6lY3KhA9MP0MvOCXJaWBQx7kAGlQoFzarWsUsjpDMz3UT7YRdFxkfUtFSRewH1xSeobVcHC9wihm+fG2Ka12PVOB+leiOUeKTKiS4Ho1ZJaEKp/ywsVTJ4XkOs1cdHbFIW43nEgHIbaBfypRPQ2hfP6mkLMXRfVQQ9FxwMvBby3M+DiChj0cPrv7KHzVYmb31licZqg83Mbg5+l5KwtK2RPdrDad5C3OYV5nBbwf/EWsCy8/Vv3cfCPrvDlfzTA/kdnePOLXez9M4nWn10CnovxRz0s7tH71Hku0PqSTj516GLyno/FfRrKxqeF+Z30YsGHA+SPRkhHLrIOQ3AjkDyfg52P6bTS69Jw1rNMq6gJ2RPHI4y/28L4+xLoFvC+9rHzL0pEn10hfdjH+DseapfyBto/PqEF43AP+W6E5YGL5SGDP5ZovSJducZXQ0rwXhfSdyF9D6yswGYLYg6N2oAAsj3KK9C5D+L8cgs0ZlRHtSClF0DvZeij3GnR3GOxNgA2uVhuJUcZtEkSU/Ve12C9DorDHlYHPoLrElZaUXxlUYFNaVOFyug1P3PYRz1ooeh4qAML9ro23CJe0GnDOrsxoUdwHXKdT6bgwz4mv7mPdMBhpxLtr3MKwLlZQC6Xm1hXfcp1FOV3uaLXcDRA9nCIm2/RHKP1uiIs9vnYmOvgEM1XrtKt16k8GmB94GP20IK9omCd8KKA92oMcXZBg1vtNwDIIzNfgjm2aRMJ3wbPFBBOZQ7rzG4AG6YYYE7mPElovqOovrpFB2CzLilza9MzsNX1aGIfmiljt7IFvhktoLtOAPpx1yD3llRUKyGa0CTD0LiLsncbw9qIkgRgJHUQAqzdotOFziDQMwKAlBZQioZ2jDrxIF1O4LKiNMEmzHUgWxHm3+5hPeSIz1Qk4csz02/UWaRgjPKEVTwf77QhdnpY3U9Qe9TOsTKJ4HxN/ePrGzDfR30wQB04lPB1fUOsmd0uVscRlnsW0hHgzon5Hp8qzs71hC6wdgIRepTytdwwdli3jfXTIYXVOEB4VUM4DMlPL6mXG/ooeyHyngPJGdxZBWeSke/A4lj98BF4JbEe2rj8rQrhCwf7f5DCOZsiv9fD5Yce8r5E9IZh8NM1nMsF4NhYPOtA2AzrIYeVS7RfFJu8ANX6EqMuVg9amB/bYDWQnFQ0NJzMUe92USUemJSofAvedUqDyNVqs4kHPuYf7mL60ELRJTfp7h+u4JxOUO12MHkWIesztF/UaP3kDCgr5E92UfsWao/ByiV4KWClFZw3Y0rYUoNUjQZBWZnBI0tipN/aw/y+i9pjiE9rRK+XdGK7vtkMJhWJklW1gaxJKcFbLaBLXCI7qylP+c3lthRRPTSbvqlBZ3EEudNDtp+gCjmceUVAQLUxmMFyEhuKJe92gVEPZS9EFdI1b+UC7sUCbLGGXK2pTaXorSyOIFcpxJzAbOXTA0wfkwO98/ka9penlP2sTiXM9zZpYuo+1wRT9uAI8/c6SPt0r3ozidbXK/Av35rsBwMGVKH3OuQ9e7qDom1jPeBgAigThu5nJcI/fbWVN4CiJDVPmtFQt9OGGHUhPQd8XdAGd0PtXjGdmYKShyFJVxsfb77u6FHymc43MEPdhlRUr2HvcP4bIhcWBJBp+o6vqfl53wwnMO/J32QbFMSW4ueWdv+dhfwOh2/TTv3Oo7n4N2BLBn/bmClo9QCrVahDsyovSqoeRgOIdkja80JVXpO5kTWK2EetHMNVZBOS4M2lieTjSQzZTuj7Nxj4Ou5wtWujaBEnJbgWiF4vwV9fUmXfU/RKi9Ogua7BBj0s3x9h+tBGHZBmm1X0/9brCvEvLqhStCygnSA77sBZlrBPyKzGwgByf4hiECEbOHAWNSl+np+SXl1pnIv9DiENUpJCmjCPMED15BAn/0aE9BlVPfHHPg5+dwJWCRTDCLOHHoo2Q3AlNuH2ANLDBHnHJtXMrKJ++M0a8sUbeq13hij2Wsh7DtYDDm9GrTP7ag7pexj/oIvlEYOzAjrPK0TPKQCHcMwxivtD1L6FsmXTwiKV2kQNHetHe8h7HskP38yB00uwTgvrp0Ms9x24K4ngsqDhfdN/kSSq/eDRHGieAudXZsaTH7Sx3nFQ+QzOWpJs9mQCeTMxWnj0OhCJD77IgNmC3iPGiNGzNwBsFTxUyw26QsPndHgIQFVtg1+vhQpFP6QNK6sIjTCemES9rRwN9eBhSEjrdkxIbIuRWk0hKMw90tJQuE2GgPz2Q2TDAGAALwSCL68grgj9rNV2sqyosLIsM6fgYYj62/cxeRZBOIS8Hny8kQ/LujaGLZMEyBn17fXpuuticWiDV4A/ofvFOrnehMG3Elr4byYQWQ6r14E8GBH8LqRTdfx6Ta+R2hxMYqB+nVWxKbKcFn01UGeBD+m5hLlWC/dt0cnWsLf5aJIPLItOB2VlWkW32+N6HvrN2AAUCuKuXtddf37n837VsKQxWG5GsQHYLP7aOamrKM8Di0PqgaY5VSgqDEIWBVVJWnGi08CUTJQlMWToIz1qAVJSlKC6qXVFpnXbqOiClhkNnHRlUhx1sTj0kI44IIDOV7SY4eJq87zaCfVIbyZgjg3x+AhXHyXIuwx1AEACySsyz3hnc7AlLbIyDlC3AwqyV8ErcrUiKd69HawPiGNvZQLh80Z6le/RZtcKzEnLuphSf5gx8F4Xy+/t4/IHNvJhDWfKsfd/UmYAqyUWTztYHJKWffDTHP5L0pJXwxbW+z6EQ317/7qEO16TKUwhKPDwGOkRVa72WlDS14zaLMsPD3H1PRvSAspEov0cGPx0RQPavADrtJA9GGB+T0VxCsDOJaxCIjxNiYXfSyj1LS3B3p7RzfngCLMPOlgccjAJJG8EWp9NwU6vzBwHALmkY98MZfX1IQZdLJ61yUjkAP5NTQqq8wVwcWUWfnFvF8K1YY+XYPMlLVQ64tFX1EylRGluOvp+trod0zIUU3Ks6s1ShB5gc5KtLtfvhJXcxhiYOYGSojKfYG/gzKiINNJBt0cNjyjwab500EIdWHDnJWnpL24g5gvTNnknpAkAO9zD4v0BFkcUWh+dSnQ/W8P+lELrYdt0jxflBiQXRyY8RoY+ylGCMrbBhIRwON0vNzPS7PfpXuTjOTnyAfD9XayfDADGUAUc/k0BVgrY10vg8tq0gkyH4FZPnnnkFEbg02YsBXkGNM1TKa2aBrvbz735etwldTfEglusoGaG8DemBfRD/7fpL81B7R3HnrtmAAbrfOvF0l4Bo5rR0XbNGEmtjjDDX0FtG4tTFd8gJrLAp2OubZG0TCMTGCdei22h3KHAb57XdFOvUtMD1NW+CL1NeEWhMlNVqHvZslE7JD10ZxXccQZrsqB2E+OmP4s8pz8Pe5h8v4/pEzWIrIDwUiI+qUiDPV5QheY6EIkP4VhUsV/eQC4WlE51MMDiUYLVDrWnWj8b0yJVlNRKcJzNQgCA5SXkzYSOzp020u8f4+pDF+ujGnzN0foK2PnDKaRjYXUUYfLMgpUC8ZlQ1dUC+b0ebp55EB5gZZSGFVzRYI9/+QYyywl78HiI5YELO5NofaGUHmGA9dMhpo9crI4lqkAiPOWEJfjsirKDhz2kR+QUzvqEefBvBLp/eg2mqq+6G0G41OPlb85pQXtyhPnjBLOHHHZGJM/ookb8R69MwLgOjOFzctuK6WxjBGrHqAcJig6JCryLNfXXZ0uqYtVCyJIYshWRIuxiTP4R5QuQoZIJZiWlailXsB56NzXssqSEKrFYmiqa9bsodzvgZb3xp6jowtuVppk36HtKm8r0PaIMTUbYoO5Rked0Uu33UB30IBx1epASsBgt/jeLzclAnRh05Ku+5lePWoopRJiH7uc5/D97SffLzpDaaGUJsaB5gdXr0MLaiiB8F9KzUMYkZ3UnGbXUJjMSaOz0USceRWSq9C9rdwfr9/ew2nXgpBL+dQnvZAa2XJuTiB4Kw7Lo99cYDZUeaPhKikCsh+63TwpNWWhzATczSyV5lyo1DfoUp9Y6rlRat9+35kbyzdgAmiiIu8KU70rT0Z/bDItR+Zn6mKgfRimkFn9t1DAh883Yu4Yr05hkLIuOeOoNkrmObeObqLs+pVrxdU6LviYt6s/xPeMhYOuM+tlxBLE/xPJRjLxFbl93RehfMs+on5NEBOhKM1Is9bpYfbCH5aGN9Q4zLuH4pIR/vjIORoQBDUBDGzyvYV0vqCetqJrlKMH8QYAyAi3A1xXCj9+QOSeJzUUuLU4bnlrAZFWBxxHEo0Ncf9jCeoc4+YOPcwRfj1G3I1z9egurAwoQiU8qRJ9eQEYBimGE9a6LImYQDuBNJeK3OexZSr+356Luxcj7PvKODWdFFT+/WUAmIabf7WP2kCPdq2GvOLqf0HDYmZK/AoyRrrxjo4xUy+Ush/uGogexM0CdeJSv/PqSXgvXgdgfYvxhC6t9Bm9CA0N/TLwiuVrRnKeXoOr4NHx9dU4IjzCEPN5H1Q1ITQNQMLmSpxp3b1WB745Q7rRh36yMigmuA7k7RDGKAAY40wx8XdDCt1iZwS5AsyaWRBChT5vYdE5ttyiC3OlDxC6KjkcmvnkJ52pJP0cPkZUUEZZFJwx9HXNlPqsFyTXVfSbXqal+jepOShOzmB92AAZAAs6MFl8IYbIt9L2qCzBZ1+CdNrL3aAGGutWis5JmUhfXNCx9dEQa+3VOA//lylTc2jWvM6OtdUUtt+kcSDPy82iPhN6cAbDjA6QPe1jt0jwrOlchMYoZZGYwWrmjDF1Nk6jBUSu3vZ5/3C5AzbrTNHDpIlO32fJ8g6y/1cnQxWoz+WvL0/SNawHxnvyh/de2J+HAO9U+ALPQizTdCnIxWmG9s0q56dcB271DnQXQII02P19LTw14Tsnw9JvGooguFCmpCtBVypzUK1oCB8BY5eU6NdpfHkeQx3vIRxFq36JetwpyZ4s1KXICf8OwWazodxh0sXrQxuyBjYKMsQjPCW5lMmgdl7j97Qh16FJQzNnY5NOunvQwfWKDF6C5wrhG/OnYJCOxOKJBt5SGu96ck/BOG/XRCOMPCPUcXkgM/mRKTKNBGzff7WB1wODdSIx+PAU7H4NFIYqjLsrIRtYjxn54QbJVrrACCAOsng1x9SHlBuz8UQ7/xRiQEvm9PhZHHnglkbcJ6pW8rWGva1SBBWdZofY4ap9S1+JXa0NnbTp6i5YDXkr4pwuw0ytg2MPyaRfzezZqF5A2IS86n8xIPlrS6awetMFqUr7g8oaGnGEIDHuoBjHWez6Ci5wW3HVGr9mKFkPme5DHe1g+Jiqr/5ayaLUap/YtQnI01TTLJS0yQlC4S7cFcBjjmDy7pEVi0DPJWwBIDgoYMByAje4f2MSXhiH9XqEP6dngE4qtlFm+Sb5qaNS5ryTSQpg+evagT4PoRU5snnVqKlrm0pCdOY5pb/LRAOV+F3mPkCjBGbGb+ITaMsz3gEEPMqTNmU3mm8U7CIDdAbKDFrK+Azsj2qv32YlJ62JhQH6DojCbJh8OUB30sDymfA3JQKfqaU4qOYWR0ApAHvibRDTPIxVXHIDlJdF963oTCvNLAl5MMapbZbUwa4FWnwHYipe87QOgTxaGcmxiIO/wRH0zNgClArorCUy/ME3mht6ZdZg7gK2KH4AJZdh63mqDaPbbmq0h+uGbjaKJaTXMlXZCKg8hN1p0LbtTXgLmKTiWlFtJUTyOUL93D3nXg7QZGW4uVwZ7DMbIbczZJlu1KIF+B+snA6x2bSyPGPwx4CylseiLy2s6soYBREitLL7OgHVKN+bRHtb3Wpg8cVBFAC9UT/urJfjLM5o/uA7NPqKQnv90ZhYEFgZA4KPc62D2KETWYwAHktc1Wp9NIRnD4r02Ko8Rt+XtAri8AYtDFAddZCMPzryCldVUudWS5KNSou4mmD9NsDgiI5GzYDj8pzNYJ9eoDwaYP05Qu+SVcJaEFpCOBZbXKPo+Zg/p5gqvBMIz6unr17EatVC0XeRdwiUnL1M4b0ldVdwfYvyBj6zHUPvkIu1/ksP/xVsy+Sm5JQCClKkhpjXoQwzaqCMXed8jIuc4oypUDf+0asdEXxYCzsWcVGFSQN7bNzTQ4LKAc71UvgSqnGVVEYa420G52wGTkiip1xM6dXTaqA+HyIYB3FkBe5ZR0peq9LekhtrxW1V0zSYxRLcFEbuULaHkp8z3yABV1ZCzOerligacrrMJkAGoAg48agMWBbWI8nxLSccC36Da+bCP9bMRlvsOovOKft/np+ZEAssCH/Yh4pA09vq1VlRTPuyj3Otive8jb3FEFxX8qwz881cQeQ5rNNwogZTixhr0IXZ6WB8lyNscVkkLv3+2JNz1eEoIaGBz32uHcRgCR3uoWj6ZySapcSXrwe9dC7F+cNfZtIh8z5yqjPpJyQTDJEsAACAASURBVEe3lEGbxc783cAp6/pdFVBjw/hmtIB+mRFMPxo9y6ZBRsOc6FO2J+xbFuxfEchgAE3AVriz6dUBmyOz1v2rFo/m8OgcYZTqSO15QJrRTaSYIeW9IdJdH5XHEJ0VcC8WlKHLGfV9VZXFstwwzPlogPXTIdKBOn5zRujekxUx0NepMYshoN9NUyBZu4V61MbsaYLlASGc47cSnedrMpzNF8YEJaPAUDK12oJZFli/C9EKUQxCpAMHRYuIn/51CXeaQ7gWbr5NWvbeJytYn78B81zUBwOs7sUoQ2KvOyuJ1os1hagUFVAL5Icd3LznYb0v4Y8ZWq8UdfP0Chh0sXhK7QV3WtFQeJFC2jSQE90Y630KE/Fmajg7W0L6LsVOHlD7JxgLBNc1BX44NrK9GEWbzHN5h2F1CERvAX8i0fnTK4KVHe6hHISoAgv++Rrsi5c0WE1iVI/2sDwKwCTgj0sC6V3RnEdLVLE3wupJj5RTVytq951d0DWyN8LiWz0UEUd8UsB7O4U8OYfOmzAn2jCgxYNzej+WK4OAwP4IVZscw3yZUXZEmm2QBRotoI1jAM20fI8QJbEPVGLLd2AUP2VJi2hdwxr0qaWq+VVS0s8BNiYzYIv3bxL6khjiaBeLJwmWe9TaHPwihfv5KerJlAbG6qSKLKdZG0BDVDUv4J02yoe7WO/7qB2G+JSAcvLkfCP5bCWQqzXEYkHPd2+E8qCzBesDiBNlXU0h5wsaIjcIAPoEYLViyMM9LJ+0SQn0NV2LQtNWm49bWSVN3xIPfLBel4q4NKfYSS00sSyS2+o5p1Y16fWn0fI2BlhRb//7rd/jm7UBNB93WaK1OUIHMwCbls9dev/G93rnQ00ZKGCm/SZ2zXU2NvaQHMMszU0bx1TMmuCXZu9I8nQg93powV1KxK/XsN9cm+pGRgHFStY1tX7U4st7XWRPdjC/74LV5LAMXi8MJ99kqSYxpMVNUAxLIoP8zTsMZQLK130lkLxKYT8/NcNj5nmQcQjp2ZRUpjJQYXHSH7ciVG0fRdsFE8SdZ2kJluWoBwmygQ/hMvhXBZzP3gKcIfvOEdY7FOZeBwzBpSCX8yuKMwTnqPoxZo9DLI4Vm0ehpRH4KI57WO1Sq8cfl7BXJS1yQkL6DoHNEhe1x8FLQUO/k2tU93cw/k6E9YhmEdEpPV/njELXq8M+xh9EWO/SvITVoE3pZUXa8OWKBrCd1mZAr8xmOih88f4AwmGwcgF7VcM7X4GdqwCTMET13jHSXR/OooL/ZrZhPPW6KO4PsTz04C4FgjNi7lunY4jJdCM7ThJaEKsaYjI1LQIeR2CdNsq9LvK+Z8LkteIIwJZvRV/PPIlpxtSOkO7HKBML7py4/7i6oeccBAalroOKMBqgHCWwVqXJL9C4CD1f04Ncff/pgSfvtJH+4AGuv+eidgB3AbRfVIh/fkEAvFrFQkphWlwANu1Xzs3rle7S6So8JQ+HuLrezB/UZifWa/Akgbi/jzpyUCYO7LSmjflCMfx1qplCTMO2aXCuCzTfAzvaRzmMUXRdWGkN//UU8vXJVnH5DpW42bPX/H8pqBBU8wEtA9XYmtunh1/6uAuFf8csFIx/s1pA78ifgK3J+m2UwxY76PbjLqyEOiUwVW3rXGGmkpMAUFXs+6ai0eoguUqpwtfYCd3XV8dO/eBhSGhgFZDNCwFe1rAvZnRzd2NU3cDgZs1JgnPwnSHKvQ7SXR9lQElR3nUO+8tT0rLrik63ojwXrKxQjVq4+n6E+WMJ+3iFfOoj/tIhmubzG2A8oYuQczou66G3YxMQTt/gtkVhN46aW9icFBQqiF7EIbJDkt4Fb+Ym3Lw67GPyXoTKB+wMqHzK9zXDWc6RDXysd2xUypsw+Mkc/OtTmg88GGH2kF7n9tcZrLQkZjznkLb6z7FQhQ6Ey2EvS+MdWDztYPLMQu0Bg5/VSD6fAhfXYEmMup9geT/C7KGFoi3hjRnaL2sE55nZDNmgp1p6gjAKqh8tj/cgQleltTG48xIQMH16cTMB3x0hu99H0bYRnGdwXl/R17suqg8eYHVIw0g7FQjOU1Lk6IVbL9SthE5vZUXO2OUKvNOG3B0SnsHmqAMH0uYU03l+RS07jS6p641woYGGLg57ZN5ibGOEmy8UUoIGmU2TmTgeIRuRV4AJwH9xbaBtGksiVeZ284TNbBvscA/rJwPM79koY1Jc9T7N4b+mLGw9m9KRi7o9xWybTuGeC9ltoexHyIa08FtZjeCzc9RXRE7VqJamCEEe7wGMoQ5d8IIypLXktclA4t0O0XuVU1hvVtWjPbrXQobkVU5tuvMr448wLelbdM6tIk9jKwAjE9cbx5aKp/G1t4kEW/4C3YVozCm31rdbJ4a/tA2AMWYB+GMAJ1LKv84YewDgHwLoAfhTAP+hlLJgjHkA/gGAHwAYA/jbUsqXv+p7N30AAHBbCXQ7yB3ANiMIuHN3vL1xmB69iniDoEEn8zzaAMqSjqNK8w+ViqVvAmN6KQojvZNltemVeh6QRASG41CwsiU0i6buRZCcEY3z69ONPK7dItnicYIisWBngiqfq5lJ+WJJQtWaHlK1EpS7bawOA1x/h6E4pE3If+Wh+6lA508uiGwZBpCdBJIR74Vl5GmQjgWWlSQPjV3KMljkNEgsleyvFnTC8FwI14b0LIqsPKdqTjw9xvJ+hPWAErXiU1o8eCnhTUrwosZ6z0fW5ZT7OpZof1XAf34BSIn0vV1kfTJIBTc1gtMVsWlsrmSQFaRvo2x5cOb51sUvbY7pkwh5lyG8EGQIGy8pe6HjU8sqoVYPEzQz6X2awfn5S2qv7QzNINN5O4a4uqZr5fExlo9aSpUlEZ8UsFclWF6SB0BRO6tv30fZcmmg+IIUQcy2gQdHuP71Lpi6DFuvcngvr2nx0YNhNSTVqjM9tGRxBHF/D3VAG51wOJxZQaqhdbZJzmouFjq1KwwMQloqrg/PKtP6kKrd11Sv8E4b6HeRH7YpH6KWYLUAT+nrzCBZnXJFlm8VUdpctzqkRTS8rOHd5HDOpuQwBkx/Xp9STHtRIypC3ySNMSmpMFIhSTrkCEW5lcKlB9HlTtsg1XlZw7pZkZdisaRBt8VNxW+Mdb0uRDdGepCgisgMGJ5mlN+d0clerlNTlDU3PMMc04gY2wbKYkso0SxOmwyzdzoO6sRjWn8W4etvh8fQUsZ+6cnjn2b/w1/aBvD3APwagJbaAP5HAP+LlPIfMsb+GwAfSyn/a8bYfwzgu1LKv8sY+zsA/j0p5d/+Vd/7zhYQ8G4b6K7F/46+mPna5qBYv9BcpYSpybxYLOmGdJ2Nyke3dQBzdDRvsOrHGqSuFHRjeS6pdlZq8GpxMzsQsW/CqTULnrcSsp1bFurIMbI2Vgo4r5QGPw5Rd2LSka9SUunYNsp7Q1z8ZoTlsQCrGMJzSkzqfzyHdULfX8tOTYspVylTrmMMQnVoI+84pqXBJ+q4HEc0bA99Ik8WFQ3CFK9eD/YWRw6KNoNkQHhBMlJvQq259V6AxSFlxna+rKmn+uYczPOw/mAfqz0HlQ+E1wLR2xQsrwEO1IGDKrLhzgqwsobwbPC8ourZtlAPEuQ9D1XIYWWSJKLzNephG6ujELWjqyPAyslL4X99BXkzJZPdfgew2EbKqVo4WmWSDh3ULqPEq9czavupxZuFgdl47eul6d/z0cCQSrMeg7MEWq8zuG8mEBdX2yHigKlCde9Zq7PAAHtVE7abMYquVNeMyZ9V7RL9fxZHkPtDVN0AZWgTvnmsJKYm1tHZPu0mCUWbRnTak54FnpYkY76ebMMHbdugkLUGHsMeROSh9m0Iz4K9KmG9ON/MIhoANC2qYEGwccuq67LYiYiqOk7Bzq82GcS+R8UUsNkINNdIDbXrTow6pnagf7Y0ATcsCiGTEGyxphabUt2Jx0dYHUWQnE5kzqoiCujNzNBxARgVkV74ueuAHR+g7kU0w1plJMlWXpx6uXpnsd5awvRJDZvZifZEgKv4zUabzbxumiDaFL40vrf++D9Z/YO/+A2AMXYI4L8F8F8A+HsA/gaAKwC7UsqKMfYjAP+5lPKvMcb+sfrzHzLGbADnAIbyV/wCWxtAcxBylzMYeLfqx93HKy0Z1VUHtH29kQjUDGw2MlJgwyuJI2hGiaxr6pMqtYy0LVogsnzbMBaGQJuMJCwvKEd2vaav3RlCtALUoU2ZwnkNe54RSXSh3IedNoqjPmqPU+rUdA2Wl6i7EabfIsVMrdos3c8rRC83cYrU943BpASqGiwvyNwmBES3haofAAJk7VeVLR/PjSZ9S0OtzEVmg+x1sH7Ug7QZhEMLvzeloBMAqGIXtW9B2AzCZRSC/noKXF4Dto368QFWBwHKkF7z1gvCLANA1Y8hLYYqpvSp4GRJRqglqUXETg/ZboS8S6iI6PUKfJ5C+g6y/QSLIxt2Kgmwd56b4SwAyChA+qCL1a6N9osMzmcn1AP+9n2kOz6KmH6fYFzDmRfE4dczEYAkjREJArbwDcMeyn6EsuXAygSYoCpaYx6Y7xNJUg0E5WJJBirGwPs91KMu6paLKrBhpxW1mBTgDYuVAaKZ67ehyWdBQAPhlg/pqvbQeEpAtkbvWA8deRzRcDLwjMLFSkuCFS7TjXwSatHSyhplCDOnhYM2ao/Dm+SwblYkH1anIg1SlHW9FebEwhAYdLB+0MHi0IY/lQgvcuOK1u5k464Ng60ZB9NUTg1diwJKfKtrwmYr97Xstmjhvx6DxRHK948x/raPdIfBndFsqPXFgjK81+lmXVFeHVkLckunKXgQgB3uIT/qIO/aCE8ySvu7vtm0whodidvKIGOyUxtoE10Pzuk1VoY6A6LUX2u+kfYd5YZYzFx3Ix+t6z83DfRfNRT+vwTwnwFI1N/7AKZSSr3avgVwoP58AOANAKjNYaY+/7r5DRljvwPgdwDAh1LbmJ4X/dVoZG+xgPQLfBeOlb7NRv+/1b/TsirNFQGoqm/0NJtGDkCZYZTBiCcxtYEAQsPmhcoBLjb+AAV/gw6hWK4AzmENB6j3esgG1Ot2pwWcZUGYiKsbSNsG2xtBtEPkgwDOooT/ek7RgVGg1C2OyqmtEL5dwbpZ0g0XeJAtlUlc1WBFSaoeVfGDMWRHxKOxcyKAWhcrWuQsDsk4LWiOTcRD3RsOQ6DfMc7W2mMoQ64yC+a06UgJsT9EvhOiaFmUjKVojdqYg50h6m6IbOjDKiTsNZEzWSUAx0a+Q0NKXkhYhaKQXpJ6QgY+xP4Q2W6IKuRw5yQFBeco91pYHHooEgZvJhFclfBP5oTIaIfIHnXBagkrF/DGGcKf39DM5WAH17/RRTagoXD76wrh6xVYXZuNGIAJREdVmwWJhSHk4yMsjyPwQsK/zuCfrcFXmel3S8cFRgPUiU+Gs5uFUWzx+0eouyEqh3gyPK9h1+SedS4XdNJrGO4AVe2pxUDPB4TKq9XtIblcQQIbv4pqJfDAB9/fpWrfoiGuPVbPryhpkW+cFFiS0M+eUQvHGvRRPNxBFtuwCoLfeScrkrwqMQQLAtMS1b1xkefgnTZ4t4P8Xh+zBx7SEYOzAJLncxowL1fGiU9kTjX3m5D+nyexSb4DYyTGKCsgL8Cubwwll+8M6eteU442nj3Aq3+3i/VhBWst0foK6H+SUf7yagWpAl4A1Q5mNp16VCvH3hmhfLBrECXJyzXs8ynkdEaoh8Z6cld3wkjLPY+8JLA2BaZ+jtpEpp3CDX9Aswi9DYnT84l3lEn/ksf/4w2AMfbXAVxKKf+EMfZX9Yfv+FT55/i3zQek/PsA/j5AJwD6oKDF/5edAvQP0MYtziAFtVqklO+Yxt5J6NHW69tJPVIAsLZgWEaFoQiDOiVMLlZgFqejrEq2guuAqyhJMV9tZHueB3Z8QH1pl2IF/evMJIUZWd2wh3Kvhcq3YOUCwYsJJYxFAcr9LoqOC+EwdL7KTNg7C3wgiVGPuhCBTUjfrCAYVV5Q+8a3IVwLtW+jaNvkuDyZUWXsOpD7I9SJR1XgIqXFXyEJuO8TTfQognAo2cq/KRB/SSx9ACge72F14EPYxNdpfT4De3VKz+l4D1U3oLZCJSAc4sNY64peR8dC0Q9RdGysRhzRpYB/uSJwl0YuJB2Sx3LAWVZwlgA4UHbIJQyQNLb9sqLXDEDdDbE6DJB1OfwbgeQ5xVnKooB4fB/jf/OY0BApMPi4QPjFFbVKcoUQDwPDeEFVQ1wpKmu3A/FwH/NHCUUWnmSwVuUGzAbQyXLQQTmIKZBlXUC+fAv0ukh/4xHWIwfBdUVtmpLaPKyoYC+VZyPLIHQPWF/rXKljkhj5ewdYHHlwVwL+uIDz2QmlfDUryunaVPz2/q56TSKwslZzHzXf0YwrVV0y2yZn6uUVnVSfPUB6EGM9JP5+8kop2FarDRbF8zYoA1VESahK/sERlk+7KBKOImbwpxKDfzQFO7mkhd91De1S5zkw16FNT7vuG9wuCGFyLcwpqN0iKef5JX3O42NMvtvB7BH19g9+lyH5ckYOc3VPsziGXC6BitrCIs2A5Yru8+MDFIcdTPcdRGclki/nYK/PIRYL1GrdYZ4HprT5xrilBSZqcWdhYNYoaodtFEEQgk5ld8hIaY2i31Mv+Hr4LZRSS10Ufz41UePxr3IC+NcA/E3G2G8D8AG0QCeCDmPMVqeAQwCn6vPfAjgC8Fa1gNoAbv7cP+1Wq0fW2//GOHt3YW9W8PpLGzukrGtzLOaucrneMoPdJv3BtumijEP6/HVqYhkl98C0SUsNjEXzwnRd8F4HxVEf2cBVTJ81RUfOFiZ1TLZiqmx8B871Gs7pJclbwwDYGSDdo7aIyVVdUZXHRwOIVgjBOVhdwx7nlELm2Mj3Y6RDGoDaqYQ/rhF9dgnvp0vo8Ph6r4fat80ipZ2gsG0ijDo2REzcoPirGWnwNfCq38X6yQDrkQNhA+5Kov3VGvbbMeUVx7GJCbSyGvYip1hMxwarahRHXaRDF3mLw5sJMAn0f57CPZ2S29JxwI73UbdV60RI06bRG1EZEfc/uCjQul4SCE0FmAOAN6nQ+nQJvDmja+XxMZaP25jdt+DOJYY/oVAXuVhC6kyIkAJ8WF4AWY769Jzey/uHyHdirPboNY0uBIXfzFREo2Yy9TqQ6hjv3KyB00vAdZD/6D1cfeTBSoHu8xLh55d0fWmU8XT2zqKvr1MWBGDtBOnjIRbHLtIhQ+uVQOvHb6i/3eDriAVdV1a3Q/LeyEeZeBtkwrIgs9rVjTKKbZDpAGhBTmLIwyHmD2LUDkN4UWLwxzdg0wXEdAah5aaAIeIKHfKuTGds0MPq2RCT9xxEZwKdXyzA316Sik21iZjrblphnfYm31q1Upnn0gxLt1h1boCauzHXBaQwg3e+O8Ly/RHmxza8qcD+H+TwXt1QoeK5G0PfmuJVdQuH2Tb4vUPkhx2kQxIjuEuB3k8mkC/eUIvH80hxpGYo2uDWRNCY9ldTqbhOqb2j1TxKsSjyfCvnZJNX4m7CcPS6leXGlU3Dd8/MA/7vbgL/r8hA1QngP1VD4P8JwP/cGAL/VEr5XzHG/hMA32kMgf99KeXf+lXf9y4Z6K8yhd0GI2nOiP53rmSOepre7Kvddhmb04Rtq+MgN8EyAAzHBDrhB9jkAYwnNASCumGVllt6NOARsU899kVqQmZEEqDshTQ4U7LA2/OBou1SCPjlgoZUVUULlHYKh76pwqVtEeTNs5Hu+igiTuHmX5dkgLq6AUZ9pPc7AGNw5gWsVUFtiTQ1Cg0jMW0yTxpZs/JoB+vjFvI2h7AZ2l9ncN9QKIdhHdkW4LmoWj4hAlYptU9CH1U/QhXaEC5HFXDEr1Zkx1cVoNzpEf8lKyBCF3Xo0ueGFrIOYXolB/ypQPSWfAWsqrcH3fOVIV5agz6Wv34P86MNFju8FOj8bEKLc10DBzvk1AxcIkVej40sMvveMda7DqqA0q7cFW047surrRBwFkeqoCAoG6oK8ngP0/c7WNzjKCOJzhegZLTXl2TcUz4WzbE3PX5LYYDv7SM9iJH1LKR9ykRwVqCN9ucvTH61BqQxTjMFDLqkALIsQkc4Fil70pI2rMXCFEa6aueuA763g+Kwh3TkogoYVfxfbE5OW4ytxv9NqHwSQxwOkY1Cw0MK3yzAXpyYVhASEhZAiSBYohz1oFYUyspgylkYmBO4bivpjULOF8ZVj0EP2f2eCalxZjllZACQkU+nz1VKbSOFrJZpCpYkqJ7sY/xBqFDrFBsanCzBXp2adq4x161WW0NYrQZicQQRh5C+re7l6bZUtiFCMQoqzSRrDnv16xmGdH2ozUEoifk7wVh6/bKsv9xEsFsbwENsZKA/AfAfSClzxpgP4L8D8CGo8v87Usqvf9X31ZnAtyvyLeAb8M7Q93Z/DNhUInr3Za67ueGa/oHmQ7khoVQ92hhjGCGdNvFx9OlBKSwMCjdJqGpRDB1Iud2/rWsCxg0UlnaRAePJpoIZ9FEeD8h0JQFnVsB5cw25Wm87kNcZpOdAhh6kY0G4Nhb3A/AaEBYoXWpWwz9b0rHXtowN3yoktYBe35A0tSyMc7SJATYPjRUe9FDutpHuEic/PE1hn9yYvNd6b4A6cqh/XVYm+Jt8BBZEK4BwLGQjD5XP4awE4k8uIefqJKTi9szN5jso+iHKxELlc5ShwkRPa3g3JUHjJktIz4FIQjJt3cwgJuR10PLO6w88rPck7DVDdCbReZ7D++qS8NkKwseEIFnsWA3gbRvVR0+xOPaQd+g1ic9q2Ksa4RdXm2xfgE4LQlI8owqaqd47xs0HIeaPgLJbIXjtYOdPSoQ/PyW8hH6+84W5ufX1zsMQGPWR3e9h9pBCY+xUwptTa02TNXV7RM+xeKcNDLqG2c9qBUIUoNdGhfuYQadaWFDXsHZ3UNwfIhsRQM5eC3g3mwhQqMJoi8OvcObUGk1Q7XZQtF1UIbUvw1dzQ5oF5+RzCAN6nRQviLUS0uUHHiGbtQ+iEa5ulD+qsIKUxhNgjYYo7g2QDT248wrOvCAZ85RmQ1ryzK9vRWMGAcrDPuaPAiyOONw5LfzRp5ebhLAwAHodwqSrWZjJVLYs8FYC2YpR9yKUsQN7VZH/YzLdxJM26QLaAAbA0kojRVelf96Y4Jpf09wg7mIB6QL4mxEJqUPhG/GNtxf/LULeHRuCwUOoN9zcXOqIfzsIvmnegmWBe54Z1DTNKjwMqbdbqQtUT/KbO3fg0yBMYWshJe30alOQHmUHsGVKenMAfNBHvdOhhVzp3p2btYnlY3FE0YGqT8zWOVgtUPdiCNfG6ijAeshRBUD/FyXFEY7nVIn22ljf72B+z4adAvFJQe5Upc02G6J6PkZuph46yL446mO9R1VaeJrBfXtDJ4IoRH7cQ9514E3IsWtdzcijICVBwJIQq0ddFbwtYa9KkzWLoqSsZdV3Z56HereLOnaR9VyAkZdAKLVReEYxghCCqKSuSmUrK0IDVBX40T6W7w+xOGhU/Mof4JyTLp3FEUQ3hvScjbxSzXmwO8DsO32kPaoIw6tq03rLc9OyMYwXVbHKuob81gOMv5tgtc9QexLJa9CG8/oGcjKjQTJX8YBFsW1SarUg9/rI9mIsjhyUEUPrdY3kiymF2FvWRrEi5EbV0+9BHI3oWitrSNeGtDmEZ9Fs4uxGZQsoI6M6bTDXBdvfweq9IUWDegzR24xOm1fUqTVOd93WUFWwBqyVh30UHdpwtDs6+vSSKmDVtqDErho615fr/IQkISRF5MEaL1APWrCuZvRe6PmcYxsns5wtzMDUOtxHtdtBNvBRRhzuoiajZSVhz3JY17PNPS2EAcWJx4e4/l6M+WP6J/+KofWyRuv3viYzYBhAthMC4y0zyJsJ6jkNyq04MvykOvFQthzYWU0KppsZMX7UPaVPRNC5H/o91u7lW5TRJjJ6yy+gRS0NIcAvK4S/OU5g698meFuDkKcfulVzu08KNKbuUbQVlnG76tcP8zOaMwHVZ9MXn/neaqGXeb55Iy3L4BIghNFLNw0hBsClbh5UlVnoMOyh7kUEhLMYgguqaJlSDTHfRz3soI5dGn5er2loyznqdoT0MELepiEXr0EtjcsboB0bBVHWo+fgzWqEX03o623LtKZwdknHaTWsBrCRvCYRZES+BWFzMhNNl0SdbIcQDodwLfC8JkjZmvT6LC+pBcSYafdIm8OZF6Tjn6yUuU6djoqSwjpGXSyetI0U00kpdctWCik2I5mobCe0UeXkYNUzHa3tz/suypDDWQuEJ+tNWA1gJIKoxYbbY9sQT49Jy+5aSEcOIIHoVG02Gk2sN/MwoE1L8ZJ0xOPNtz1IC/CvJVovUtokpzM6TSoGDBzbeAk0ewfDHtIHXaQDgv+5S0ECgLcLsDcXW2wevRgAoOuu30E1bBkNvrQYhM1J1rnMCVKoc491myYMIHeHWD5to4g4rEKi9eWCXmPdG1ch9rqgkanytABgSYzsO0eYPXRRdBhaL8VGynkzo/cEMK1EM7Csa4qW7LaQH3Ww3HchHCLRxm9zuF9foL643KiBmmY/7VtotyB3eqgjD0XHRe1z9ZqXcN9OKBY1jk0Mp1wuwXwfxbN9XL8fYP6jFMyS8H8aYvTHuUko4502vacA5GJlgG16Y2ZxiOzBAExIQ511zqaQb8/oeSpXtcljUOuRLDeLv55XANjMEepbUMrGjMAEwqs1kAf+5hRxRyv8m8UCumMG0Bzu6sHvFr4Z2Eg+1UWn+2xNk8Y74fC3HHoAtrhA5jSg3YdBQCcBjUb2VWWlJXtSmipH6ujIxu9mjYbInuwg71GGrX+Vw5mkRqsOziGSAHXkQlp0M1vjBSlU2gnKYYwyIemfOyuJc7Ogfmf1kCztRcwRXhF1071agU3pGC56CaRrEwTsqN1sLgAAIABJREFUaor66nrLTATOwZIY5ZN9AIBzPiMX8GIJ5nkQgzbKbkBOzUlKM42yok3FdVD3IghVffJKGH+DezIhpVODiqh75+L+PsqeT8M3TwXgLAW8m5Is+ZqnrxffqjZURWbbYMf7WD3qIu1bcFKSevqXudFqA6DAlG6Lnt94akiaetPJWxzBTU2GsWkOa5HTZqqHd1Yj/aomOiuzLGB3iOlHQ8wecDLg/SKD+4LaWuCMFqOqMsoizejR/f1sL0bapxAUZ0mgPPtiZgbt+vrWLUKjEU8SFA+HKCMbta8iLd+uwWfrzSKuAIUASD8fRyj3upg/DJAOOKJzgeg8JxPU9XQjbFCVq9HvK0Mka7dQ73SQ7oZYjyyUEamuok+vKI9AyZwBbGVx6/uQjwbI7/UxfeJhdcDgTtQw/ItryLdnW9hkqdu2DS4/dgcUq+rbZr6gQX38Lal/5F6fbiGt7z/Ywc1HfVz+SEJGFdwTF/2fS3Q+HgPXUwVvtE1bqplqxuIYot9C2Q2MpyV8s9iolzgH7/eoLVvXBG5U73EzUrbJFEMtaJNYr99llt1y+5p5pfp6sw415el6wwD+8pzAf5GPrQ3gLuzpba2tJnVyZvjdADYvOrAJfdHzBOCdEJlfho1objS3d3odosE819zgLAyoYioKkyCkKaCyFUFEHsqWB+FyWmhuVqTBVsPquhdBOBZYTWYi+3wKuUrBkgj/F3dv8mtZlp33/fZp7rl9//r3Il40GRHZVFZVZnUiKZGSIcmiYdgje2p4oJngoQ3/BZ5qaECwoYFhGPDAgEekYEoiKZLFIquyMiszI5vI6F//bt+ebnuw9t733peZlAxDHOSZVMar1957zt57rfV9vy/drrNsRRLGfT1z+nrVqJMeiJpHewp/nroEKNJM0qYCT/TiSsnCaAJGHMhOKRneliKJiUxzpxQhCKDbJG2V0aEHmZaNYTKToJlWhWW3xLIZoD0oTHKRir4ay8BxbfO17BtVCFHtlYpIe9Jq8eKc6EKCbKwZiVLRsOkl7zi3LKS7txh8r8ls2yMPof1ZSvn5aKVkyvWKDb9YOv6M12mTPDpgdKvIoqsIppr2ZwvCs7FUGb6/kkWuz28QhVB6vEPckNPnsi73U/OLqcxDhqNVjGgYoOJEeuimGhXtvrR5hncC4zTOqb6ci+t7uZQDhVIr3EMQoA52STtVQPKkx0cF4rqidJVTe7GUts1gtArumcw2MiHi2x2mexGLlqJ0bfKMT4YbKXUOJLd2qSgiv39I760qy6bCSyVPuvx0JEjq0XgDPGefLfuaqVIJfbRD0i4zPopYdBUqhc7HK/WV12qSd+qCI3nxegW+q1TQ1bL7fnlL/v6sGMj850KqOsolkh0JxQhGC/SzV6i9bcbvbtN/4JMVoHgFzSexzMT65r4KfLnH7IZj5ij54RaLnTKj2wHFvqYwzCh/1XeIb29323lqnLlzPN6sXGAV3mNyFdD5Kld4rbvgZLNrc0mvVNww09nfb309tOufXce+OxXAzUxge32LMsidtu3DapyS39Qmctc3ZQjfqA7cDmxhT2spP26HtuaXdXbQcrlyNAaB9DotDz7NCQYLkYGCqFdKkUumcgM7G8NYLpE+OGS2X8RfaspPR6jX5w4RnbWrLLslvFQTDpf4Z32RbtZKpI0Si6700YNZvlIC6dyB7PJ6mawSCeJBKWnhGNetKCBK6Epp5RGYLSVrtVpkdqvOdM8nK8jptXSdiants9fyuq05onWausFZ3m2xOKiybAWyUVwnhD1R8+i5UUnZjbYQSuVj2g8c7DB4t8Po2GPZ1gRzRflEU3+eSIKZcVATBKtFDVzs4PxWjfFhQBYpqb76uZy6X8mg0/LtbUtPT837uL/D1W/vMngkA/bGF5JeVf7iSkJ6dO7UYhb9gREPuNjD/S7DNxsSRjLJhTa5ji6wDCojG1RKiSrnVpu4FrJseHgZxFXTrz/LqH9i8m6tMGEpcwXl+3Cww3Kvznx7JQUujIUtZTOgbbvSBchb8m25hI5CFgd1Lt+LyEIcsTX8XDwHzqxlZmXrIUxes4GqVen/dI/+Aw9/uYYBefISooj0jX1ZzGcJ/pNTCddpNkQFFoWCCwd0ISAz8wx8JYqxxRJaddJOVQ47Z33y/gCv1WT2zj6jW5INXb7IqT6b4E1W6GU1X66qcuXJM9uokezUGd+KmO16BDNN46uE0i+fi2zVyHDzelnEAnYwbDhKMudYq2yDwM2KyPIVc8kotLjqu7mR+73MoJsgkKpxnQX0H3B9JzaAhtfRPw3+kfv3zWScjetGNsCG69dI3LxC+M0v4o2ISdt3s/19h4s1KUYbb5S139tBYBCglzH5aLSRKGRvAlUpyyZiJaNhIIYww3L3Z7Hkl5psXeX7kpq01zJD0FwW35HBAdSEKZRbQqfphxMn6GKB+LDFoit97GBuesnnPVlIj/eZ3aqTRYqonwrRcrIU1HKSOg+APc3oUoQuCzIApYgbIfOOj/ZhtitD0tZnCaUXY9T5tbRlDGPGRQ+aEPnlUZNFJ2TW9Shf5QRzUYqo896qxWFktnhqFesXBEzeO2R86DP8rQXl6pLJaZXmxwHdX88Et9AfyCzAznGGI8fdT7arTHcjkoosgnmgqD9bCBu+L1UShdAF6CiLSA4D2O4y/MEW/Qce8+OY6uMCu7+YU3hyISYi+BorxzFvGnUW3zticlAgqSiyIlRPcnGTvrqWNlGpaEJTMnSSuMVbGcTI7J19BndD0ip4S6i9ziS79kVPwlsKobCFlkvZNIIAr9Vk8XCXPBDXrJ29eEPBiOjhaHWaXJNxqnIJ3aoT70io+rzjkxekR9/4UsxfeX8gf+tadvC6SsVrt0gP2qTlkP6DArM9Re2ZpvWZyFZVrcr03QOGd0OhhH7yStpxW12ybkOG/13ZWIqXctgACF9cCdrC+Fd0uSgttonA2vI7+1x/ryrRn1NN46slhVd9macVBWNOnMj3AKOG8lGthnPWxw1F6TKn8eUM/7OXkhu8vYWuV8RVn6TiAreVfrWCLkXkRfl9velqhuIw1+b18Wo12GqjiyHeeE76/NWq5Wzw3bYFZtebm5XBN65ha9d3Ygjc8Lv6p4X/9BsxqRus/7WPW2nUzcBlYEMtdDNLc73vv26p9kpFGRamqcszBVEPuUGzYaQA0uoxqWMuAQhWqo11N6PR/2tr/1+krieN56EO94j3Gyy6EodYfTKSdkitzHK/zviwQLDU+EtN7XFP+pi+J22OeoWkVVoBziyBNIlFyXO7w/WbxtL+KpPUrPOhcNJtepXhG7lM5HaDtFVmtlc0un+Im8L+aX2eUX0yRL08d4Aw2+d0ag/DlJ8eFInriqSqqJysiJ30Bl9DGruQ8Z0t4oMW4+MiV99X5FEOWtH8VLH9i5GocsYTaf+t2+cRZdXy/g5JLWDZ8AjmWsJbLpayYUxm8roZz4IuRgLAM98vv3fI6L6wluZ7OcHEo/thRv0319Kvhg1EMKxkfKpaYfn9Y67eiZgc5+hQU//Mp/vRQuSn1z1ZdKsVeeAHQxfR6NWqZAddkkaRtOwz2/LJQ1EyNb9cEH76Aj2ZOuWYSjLUsxO5r+7sc/X9KtrD4TCi05HzRGhr1LLsf1Ol2DZR1qoxu1UhrslMAQX1J3PCp2fS6rkhDbbPF1GEqlVIdhqMj0uM7nikFU3pTJLVot+8lM18b5v5cZO84FH5UgxW3laX+cMdZjsC3tMB5AE0v5B2jRpOZFAfSiWdN6p40zn6ui/PVbHI4LeOGNz3yAtQf6Lp/NUVqj+SeROIIs08h/bgp0ol4ttd+o9KzHYVxStN59MF4SevXCWS3t3DS3O8Z2crya/vo5p1ydcuhTJsHy+kjTueyGzIASpvKAPzXIbcgH+4L22k/mh1cFxzA38Tz+xbacfm+k5UALYFBCvFjx2o2MtKpr4xmAFc/OPX+EA3P2bCGW4OrDbaP7DS6Rrc7vrHXeKSdQorJVZ+OxMohLCz5aSKwMaQzqqUvJ0tFscdlu1ABpH92OnpJ+/sMLolm0owX51uuOpJTu1OU+YKoZIIRmNuUvUa2V5bQtUb8vdEw4zoXIZmVs5ny//1dCc79EsOOyT1kKTmozIkT9WD6uMe+vkrs4iVXD/VwsCyR7cZH5eJq+am9pA2wBczwhdXTpWzzmECXMD85E6V0S2fpIYJbYHq65zGR9eiXLKnT9uSS1PBNjTr5M0Ky04RlWmisyl4SNkOEvzt+4LqbpRRywyVZegXJ659cPVOyPQox0ug+tyTeMjPz+XkvLbYr7NabNUYP9zn6p0So/s5eSWj9auAzkdzCl+ebtJmDe3SVkiqWiVv1hi+02S6I4avwsScvM8G6J4ExnDniHi7ghdnEgYznpI8OuTs75SY7+T4c8XWBznVZ1MjW41dhKHXaUsFaT7m1apke11mtypkkUc4yQjHqVSkF0Npx1m0g2l/ruvWvWaD+I1955VYNsFP5L3ufphQ+eULWXi3O+TNCmqRSvtyPkfdPqT3oy79R4qspAmmHtHAKKheLAg/fuGMh6pSllO8wXHoNMU7PmL6oM34UIbRLnfgWU9mU+Yk7TY433Po9OnDLS7eD+V+TmD353PZWGdzlLmH8BRqPCM7O5d5RLHoDlnxVgWV5g6gh2nJ2kE7qTEB2nskTVfu5f0dkt2GhOy8uiDv9//mDJN/T0j8eg7Kd2cDsJnA60MVG1Riw9zXBiluUTcuOcDJp9xCn2UbbG3rEL4Zxrxx3dyB2awsVKMursYwkL6iSehy8wEbhl0uGkjXxPXDvShCdVrCQC8GxK0iOpCAE3+eoNKcrFxgfFwiKyjKl6kYcwxmgbAA7YZLx/Jmsdj0+wOZDXTrLLZKpBVBJZfO53gvzp2aRzXrYtQyklNtWEQWepY3KqS1SEpnzSrwe7kU2WatSnrURStF+PJKqIumzz55o8F0xyOtKOmlPk2JLmebba51eV+hgFevke116b9TZ7ajpOURQ+OrnMYnA9S5tGW8WlUeRBtcbgLEk70mSU3uh8IgFo593ximjPMa5Ymr2QzjvZcXMoTc7jJ6b4/Jns/4WONl0P5I0/75uaugXDl/4yCiGnXyWzuM7lboP/JY3IrxBwG7f66pf9yD1+ebbR7D43c02nKJ+P6OG9BmBUFMWOiY4w/VquhOUw4R/REqKrB4uMtsOySpSmsrnMlzXXk5w395Iad2hF0kWcCZk2gm37vL5Q9LTPc1xZ6SwKDPr6UiswonW5UZ6bKjULabxLc7XH6/xORIiznvUtF8kklValtohYILq+f8UrwLbxzRe6fO1fs5nbt9rntVoidFDv6tVEd6OJLftVkXiKHxWNiUMtVqMn1zm8l+QB5IhGfl9ULmaoulfI2tVOLEPI85bLeZ3mlw+f2AtKYp9BVbH8TS45/NJPS9XEQt49UmU69Du0FejVCpGAVzE1TvDSdyiMkyWfR3uuQlmVuo02u36bq1ot0ka9WcWdE6ijcMr6w0/m7DtW3nNVDeukLItorgO9ICWlcBrS+2wMpw9Q3JOjflmzeZQDdfWPdxO2P4pmzP1RdjfthKEVSrQbthzDcp+rrvBneqUZdTy3S2ugnT1LmRvVZTnI9RwcnZVKblv5VisVd1J/byeUzhdCSxgobSyN625LmC9O4ve643mhx2SBqSPqZyvcJM2EFlp2XctuD1xnIT2zK1WiHdbZKWZXP0MhlYe8OpC6Oxw+OsVcNbxHB2JYPqoy6zvRJpUbFoexRGGqU19a/mhCf9VXylVWvZHIVaFbotZrfqkhJWBC+FaKTFcPZMnJUOyhYnztSjD3aYPGgIImEBfqyJBinR1XzV/kpTab1ZQJcZ1uvxGK/bYfbOPhfvhSzbOff+zxmXP6iw82d91Mnl14d4NrkrisCQSYePagzveaRVjUqh/gS6f92XtoxpF+hCKDLJ4WhDOpi1ykxulZl3ZOGvvzAL6NkVLlvCID8wLSICn/iwzeBBiawgrZ5wllO8XEqffxajXwiKS1UrMhw26AN0Dge7DN5p0X/oiZv7XNP9YIL35StXseo4cax9lktRshka7PjdbYbHPsuWvBb1p9D6dEZwvcpEIM8lSW2tLacadaY/PubsZz7ZnQVBmKI/q9L+RNP6xblUs80GWauGynO83pjs4tL5evLDbRa7ZRZtkWP6saZ8nlC4mLpo0jzw5GS9iDeeifh4i8sflpjvaApD2eyqH7wWJ3it6tzH+UD6+16nLQt/uSAIjSSTVq3FmRi5tyoUpLoxoU92EK2iaHXPlYrCMcokXEmPxhu+iA1UdByv/j973YDLuYMw0npcP7x+N5zAa3kAXhRtwN5UoeB299ycWL1SceW6M9XBRhVwM0d4jQa6ft3cge3nr88KvHLZsUlcdJ95Q71SUR5YEBmeaYfkceJSwlS1iq6VJVjFDF0FNidW+LwSsdguuSSwytMRPHkpqordbeG3N0VJ5PUn4ubNcvLjfRa7gmBWGgqjTE7cryU7lW6LvBBImMxsscIY+L4EetRkwJuVQtKyL+5Gy5Q3yhZxMgdOg89yKUPON3a4/EFEXoCopyld57IIn01ccIwyQ+V1jbTXaRPf3WJwt4gOpBQP5lrcui+vRGJrfkbeqqJmS/TpBV6zwfTdA6a7AZNbCn8BtRcm9/dsuNrowEHKXOyhMdeovW16P9thcuihFdRe5tS/mhN8/mrVmrl/jA59Mb5d92WmUS6vhph3QqZHWiB4A8X2rxIqjy8l9GW9bTGZSeunVETvbhFvS45BUpZktNyH1hcp1S+HEqtZE+05IOC92VzkrJUS4+/v0n8YsOhoCgPF1q8TiqczqXQGQxy7ymzy3lUfncliHN/d4uzHJabHGeVXPt0PE8pP+rIxmYSsm5W2NS+pZp3RD3a5fstnfpRSfh6w/SuB2WUnZ6JW2t2W52c6RxVCmWmZtlN8vMX5T0pMbmfoakbxeYGjfzUlfH4JYUC21WDZEUFE8eNXzqOxePuQuBGQlBReBmhQ2ijazsTgp8tFFkcNspJP8XIhFfJiQfrGIcP7ZebbIvONhprGl9NVP9/kOujpbLUx726zuNMhqcpaUBimhP25AAzN8wysUtcs88ok/alalaxZRdL2UkGxJ6lTsTlaqvUTGWyMDajfWKdsTKZZ29y9a/7tqoe1Ne27tQF8Q3g7bA6ELTArt3K/v8kwsfoG8r/fJC+1H1/zHDjjjaVjgmw0xpKvqlV0URZHtRRn6Aam1gyFdZa75DErN9TlSCRuRfkZ/jKDNBeU84sTWfi3umQ7TbJKKKeb6VJON2kKO1uM3+4wuOujcuh8HFN6ci03pJW2bdfII5/opbgWUQqv1XSUThtX6JmF3i78+WAopW27KVJVkw0AoBp15j+8zeBeSFYE7UPjq4zKqznBq2sXZO4Mc8Zgs24GuvpeEZWB0praK4mA9K/HruWhwsClq+Xnl/JL3jvi6v0W821FYagl5P6lxErm171VuWxbAKZctmTKydvbjA985rsSCtL90JAi02wl4cxzeW9MxeXe++0uw/d36T/wmT9awCBk6xcenb+6Qr84cc5ptYil1WcwCPa1XnYjJnuysARzKF2lIpk18YM0qqRbdfzp0vkYVLFIcneXpBYy3wpY1j2U1hT7esWlty2udXCaloQqVauxeGOHix9FzHdyGp8pWp8vKXz6anPRXx/uWr9CqQjdNtM3txgf+sy3Rb+/9WFK5c+fyP0XFqBRRZcj1ItT8/ppB0tMDjtc/KjC6GGGLuQ0fx2y90eXqP6IbK/L8FGNPFBUX8dEH72QdLQ37zA5rtB/wydYQPksx49F9BD1lgTXU3E3a43e7RB3ygSzhOClRJNmh1uc/Vad6YEmHCv2/lzmN/l1z6GZ8f3VUNwcRmZv7bJsBs6ZXLqIxcltoG5uaO/QDuId8FpNsr02813JUI6u5jI/sQt0nLjq395LqlRy71U+GpMvlq4lbe9bVamIksgcIt0z4fsbi79dE1UU8YeTf/kd2AC8jv5Z9E82TVzwtYn3etLON/bEvkUy6tjc5lqXj9p4NuvSc3jX0GATzEDH3eRVc8qbL+WNGgxX1YpF1RZCmQNMDSe+UiZv14i3KnhxDh7iqO1PZMho+8N72yS7DRZbEeE4FXOUAZ/pSpHpcY15RwZgzScJ5acDaR0Y01bSkfZBeDGW9lEc4+3tML/XZXIgG1HpOiO6XuLPYulxGtSv1a2rSkkqjF5fWl13jpjcbzDZ89G+IhrmlM8SYQtdXMsib0p2K+O0ih7u3mL4dpPpvkdch8prTeUso/KkL1I+e7oypFPnZPV99KNjhg9qTA48/BiqrzMqrw2IbjzeOAAATlrn1Wtkh1vMDspMd3ziuqLxVL7WYisAh4XQ9r21DtxqmWS3weSoyOAN6e8H1yE7f5lT/9OnzoSno1Dc0kZNpWo19F6HpF1m0Q0ZHvsEMwhnmsaThTi3rwfyc1pN0ZanOWo4gcAn22qw2CrSfyNk2YbCCKqvcmkHXk7h5MK5fB291vLnqxXydo3LnzSZ7SiSmqZ8ptj5+ZTgyanLrMD3XXvIwdUMqiG/vUPvbeEZKQ3NL4zf4LKHOLd3SeoFIW4+O11FaRZCaDdYHNSZHBa4+lGO9jWdv/bZ/ndXcHbF4v27jG8VUJkIAvwPvkBFEfOf3uflP/TJahmkis4vfRpPY5GwjubSN5/NnKImb1SFHHpxhapWGf7skIv3PfJQU7z02PmrJcXPzgTVYYFzk6k7iVtY4Pxuh8lhgWVD5KPtTzZFCmBa0LadbFPDSiXnila5pngxx3t+7hQ98qmbsY3OEBYEZNc9MbFWK+IW18JYsq5rQFzJN2TtX1sH11ra34kKoOF19M8q/7k7eWejyTcbIdZ3v7UWwzdqZtcWf1jJ9Zxsr2SiD9d69YALiLeBL3oyXeGgo4Ixayy+VoGg1NcVRVEkC/N2FZXkBEMzdB2MV/GAgdBG06MuaTkkK3py6nndI2/XmNytk5SVuH1jTWGcCbb2xZmU/k1pl+SBhxenEqgyGkuc3WGT+bagFgrTnNJlTHg6cmYgp6qxSiCzMFgCY3x3i+s3i8x3FeFITs+lz+RkZXu+7kZe+3vU3jbzex0G9wqkVVGIiHx0JIRGQ89U5ZK0HrR2g1Kv3WL67j69NyUzOFhA+5OEyuMLB2+7mdpmq0IOdpncbzBv+wQLTbGXSuBLnEgry556bdShOUVTCKFRY3nYZHRcYNFWZBGEM2h+kVJ5OkQ/eyVznFpZTvzXZrHY3XJMHxQsWh5pWQxU1ZOU8uNzyYFek4CSySlP2k63uHqvyfRAHLdoKPY01Vcplc8uJYIySfG2OuTVsgzlp1PpnXfrjO5Xmex7zHc0aSOj9nlA+3FC+cueDI6LEXlD3LTebCH4A/Ne+a0myd1d+o/KTupbfyaqK/38tfS1d7syPJ+aQaYxg6l2k/n9LeZbIYuWRJTmBShea7q/HKEeP8Nrtxj96ECUahcxhQ+eoJoNen9nn947ingnwYsyCk9K7P5FIo5dQz11MY+dpmth2s0gfuc2J79dJHl7RnYV0fzEY/dfX4qju1xy2dzZ1bXb4FRUIDnquhaR9iHqm9/106duJgZsMKAIAmjVyeslCa43pk6vP5KMBCMBBVbrgNmgrVTZGtC8Vgu90yGvFvCHc3h97jAUbp2y8LebDuBvWA//1nHQ/7EuuwGs26nd72t9ALlJULJoB9vuudneuckQWmP/qEJhU89v+sWW36EKBTk5rO3MrmS2v5fF4a5xf5zaCPCKkSBjW3UhNK4xeGybBIwue6vN8qgJGsLhYuVc9H3mx01Gt0OyogS+15+KrFAvFi6TOK+VJGz+euyGz/nxPhc/rQtgbKypvRQMslXQbLDdzd9kXydVraB3OwzflCFrMJOM3WiYOWSuKkbmtL+2cBs5XPL2LYbHRbQPWQH8GAoTTe2LMd7Ls1XG7vrlKWl73NlldlBk0fSE0T7TlHqCQubLFw4MZtVglv6q6jXSww5pOSRuBi6m0e8ZuatVa9n0NvMz7WBbV0ok3TLT3YjRsUdhqClf5cLDf3kulVG7aYaqM2nTNOpMfnbM5Q8D4qbIMIOpov1pRvXFTE6vBvftVSuoVlPuldncmdVsSHn/oWALCkMoXeUU+5kcAIxXQ0UFQSOAzENMMtiyHZKUlRi/NJR6mUM1WC28LkWSDQB4k5lTuvjdDotHe1z8MGK+m6NSxc4vpMLR44kEw+x2pEK5HpD1B86jkTWrDB/VWLQ9Rm/kFAYehT60P5P5QH56LnnHe23y0BdMw5PneFtdXvzXt1C/0ycKMq5OGtQ/DmUI/sm1DFvtPWmw6yiFvu7LZtBpM/veAec/Cll2cvylovuBpvmrK9kgykXycoTfH6823MM9ZvdalF6NufpRi7SkWLYg6sH2Lyf4j5/LsNtAHjeQJc2GDPJ9T5RM1Ugw7kPD57Lmv7VDE7CCQ5oDodYaf6uLblSdsYzZXDYPWylzYw5p1zGdr37GN6Fr+A5VAD+N/gmwKuVVIXTyyY3yak2meTNSbZ37c7Ml5AKV7axgfSGxunYT7JFf9zZmAbZlJIHyphLw/a8xwFUQoLpt8pqJQpzO0f3BSg9ck5OYKhTQ9QppvYiXZHK6ynKWh03GR+IgTcsyqKy8XhB+cSILh0ELaM8TlcJM0LVEEendPUb3SqQlRVpSbP9iSvjqWlQPlu5YLop5xaiXvCiC7Q7pVp20EpDUJZ4xrShKF5r2hxLhR5xsBKOTpM5Z6jUb5N0G4/t1prs+/lKGwoVhKmqNs8tVu2Bt07WtmsV2icG9kGVHXK+tLzLKJwtxgVq4Wqsp8YyWk+P7Mmg0TPhgnuObIbY3W4haKkceNgssW1df1GtkW02XY6w9QS0UJpr6Exka6tkMb2dLUN7m5CtD7B2e/WdFsr0lOvX2iGOGAAAgAElEQVRg6dH6yKf1melp25lJMTJoi4KcaJdLVKVCen+fq++XN3j/1edzwvOh/L2wwmIUI7fJ4ikWP7rPy39YQAea5mNF67FgnNVwjF7GqFZDlGYWm234+3oylQ36zVuMjossW4qkAuFEGD+1X57IxlarCYI8R/TqxuHNwzuMHjY4/R2NDjREOeUvC9Sf5TQ/HqBOLtGzOd7OFnmltKE28zptLv/BEZe/m3D78IrnX27T+tCn+WVMdCmySevXyCtFGW73Bi5IJr23x+CNMuNj2egKQ6i/yKh+JRjmtBZJst1gij69kFCVdoPxWx2DS1eMH2TUPvepvcoEEfHFyxWiIc8d+sPON/JaGQJPwpwmCxEZGNzLOkJDlUvOOOoOhoYiai9dCGWDWixF/7/GGQM2ZOrfin9Yh1baRDBZ+L4jPgCvrX8W/GO36G5YpWG1qK9vBus8bVMJOJ3/eqCCuYTJvfbi2Y+bkySekt17XXKVrbHy/TW0qwmVtk5Ym00KGO25cklfYFRLxaIEY5h2hPY9UUM0SqTlkMlBgcmRbGiNJ0JsLHx1KYMsG9ZdF8WRmi1cepLeaTN8q8lsy6N8mRNOcqq/ORMJ5ro6ZDKTlpaFwXXbTB9tkVRFFZOWpCwuXedUnk7wL8wJ1rQ98mpRVEjXAyfxy7oNZrcqqEyGwiqD4tWC4GIkG5PFNCjP8WdUMULf2uPq/RbL9qpfWrzSVM6lZeJSxkqiVCI3LZP5QkLZdzrEOxUEiZ07B7RKM3RUEInudOYeTHvCs6fpdLvO5FbJKUy8VBP1BLWgr3puU7fluBdFcLTH6FGT0W2faKCZ7UpQTeOrnPonA5QJJFelopygTWiQzjIZGu62mB2Umez7TvdffzLFP7nezAdot9xBxFJnFw93efV7BVrvXzKLQ4I/aLL7R5cy4DcnRK9WlSjIciTspkUsvfB2k8W9LV7/vYi4mxH2POpfQfvTKf6TU1HHGFmjt4hXDmLTdopvd3j9OyXmd2LaOyOGjzu0PoHtf/1a7rFCKJVUVCCvFU3vXox3yaMD+m8Uuf5JSliL8T6vsPVBRvWLobxHUeCYVN5kCdd953ieP9ql91bEsg1pSVN5pWh9kQhscDona1bJiwH+LF5Jlne6zA9rzLsBSUUx3xKXce2ZpvPXfXhq1HXdjmMo2ewNXS6S10tk5QAV5wQjg3gYjFZKHivpts75LHPsKa/ZQLfq5vCRi1PYhNysHyi/cW65Dr001zrixvkBfF9mlUmKV5Q85u9EBeASwTB8fs/bTMQxxrCNkBcrlVrL3LTD4Y3T/7f1z+wAbS2UwYXK2Dc8yzaNZjedoAYfS0EGvno8WTmF1wZATkYK0lMMA/JKieVuhdlOyGxHNO3VUznZqBdnMlg0Oa15qy6EzTgWBEa3xfyoxqLjs6x7FMaSyxu+kBQxCqGcTspiROJCeqGq2ybr1Fi2I6a7KzNRcSAn9uLTawnYNvF0qiZxh2gt2bXzhRhluk1md5qkZY9wbBLIRjO3SHu1Knm3JdK4eSxacSB79z6XP6wQN2QuUD7XVF9LSLo3XUqrJiqQVyORsC5S/FOZaVigXNItozIti/54JgC7LMeC2SyAS+favD8VVLlE1q4St4os26HzXxSvE4pPrx3rxbGf7EnO9I3jVoHhceh+78qppvV4Rvj8cgVhs4lmZqDvNRuCFW6XGd2OQCFgv3NBNawbp4giaFRFUWbAYqrZYPrWDoN78nOzSNP6TNP6aIg6uVqpTezvbNKsJG86RJci5ndaXLxXYL6XUTrz6X6UUv3lK/FYtFvSlgB53e3GZwbp8f09rt4ts2xD3NDUv4LOJwvCD58BkN87AK1FlpmshdgrRXa4xeS4wvCuT1qCwgDqLzMqzyeoZQa+Iu6UyQsexZMx6vQaPEV6d4/LH1YY380F6vbao/bKhPqc9GGxhDAkb9dELjsWB7qOQqaPthgf+UwPIZgqyqea6klC6Znh95v7WSScJk+iUSXr1kgroXhoshxvnuKNZ1I53uCB2bVoHdmsD3bI6hF5QeI3/VmM35tI5T+Zfg1hv+FHWl/w7cF3bdHfkLn7/gaFwGYEfDeMYOuRkOtZv9YZt876Mcqd9VP+13g/sDkr+IaddYM7ZEFuynM7LEg/H6VWg2ad4xk51zrHxpIcXYydNdSY/x9AFYvkHZkLZOWAtLiijnpJTnQyEjSB4cLgrZWg/aGEp3RbLA5FCZSWZPGuvZJKQS+WqFqFrF1dOROnU/n+5iQ33Y1ISxI+onIIphnFsynq5Mpp91VD9OhW958vl7KgH+2y2C0z2xbZXO2lPFxc951Kah0jUXw9Qb06lUXx1j6TBw1Gt320ErxD5WRJ4eW1+CJCAejZU5jtoev5Aq/VZHl/h8lhATREo5zoekn4UtpbLsjHqrDCYKXgatYlR6Eesmz4+IlGZQgP6dm5KLis7NP4TawrOtlrETcLDO6HxHUZRpcuNK3fjIRDv1xu4sh9H7/bIT3qMrlVlgxjBSoXj0bxYiZSQaP62qgYLXqhVGTxg2NO/m5EfGdBpbZA/7zJwb+ZSFU1nZkFPljhpo2rWtWq0KiRtSvEzYjJfiAJZSVN+bVi//9+gR6OyO8dkdUL+LNUUsN6giXwSkXyO4fMblUY3A9IS1LRtR9n1D66EP/JTpfJ/QZRL6Hw1MRrBgGqXmN5f4e05BM3fOKaIq4pCiMZhFc+FJPa4sGuLPqnE9R0Id+z0+L8d7cYPtA8eP8Fl9Mqw486HPzblPJnF3JCD4LV3CoqCHZlsUC1W8RHLc5/VGK2q8m3lxSeFdn5q5TqR1IFq3JpRXtNEslZ2N9icq9K7ksORdRPCfuLVQVknO/AppcFXLs4b9dIaxHTwyLhJKd0KpJmqzrakG2uh76srwlWNZhlYgizbLFS6Wv5ATeJBXZI/N1oAf1NPoBvkXauu+G+zfjlLrtjZ2usf5MVDDi07UavvxA69yqslWF2YbcD5BvqIQdUixMIAlStQl4uoosBST3CizNTXpoT72zuSIPsdFnuVll0QolBPB+hCyHzoxqTA7HBexlUzjJKr6b4g4n044sF8qZkClh3ptdskLfqLHcrJPWANJKWRfXlnOBqIrMAAyRbRwLrZbyCxJXLZA+P6L1VYb4lr2nlREvAuemjuq+tVsgbFVFxDEeoeo3ZO/tM9qUcVznUXhnz0/nVSloLq6Gslc4GAfmtbUb3ayzawnypnKaUXkrWQH55teIx2YcqCFxcY14tM3nQYNHwUBqn824+nuA9eb0RxL6uEycqkOw0mO8VyQqKNJK/OVhomr/pOymmlQnbHrl+8x7zw4po57cUfiyS12iUSTrZWX/lvi6XV5LTxUI2znqN2dt7nP5WgdIPJMxm+LzB0R9qKp9fS/B96Itb1obXmyhLfWuf2Z06cdVjtisZCcFUHNK1l6tFND/aZrFdQuUIIvzs0vXBl/e2GbwRMbwHOtBE1x5bH4jySvcH5PePuH63RulaNoP85Mw5qnsPJW86MOTucKZlk7fmvslEgHC3GoIB/0y8A/M399xGV64umb2qUnnls//HE/zPXq6Ml42aa6W4OU4QkO13GDyscPX7C4rFhOmwyNH/5VP9+FKqwlZdXtvpXBLCajWSww7LTsRs26c4yAlHKX6SSybEbCEy2yyXSnvNW+Q22DAg3W2iPYUOJXu4cDpyGPf1ECm3XFmF0I1Og9dpSyu4N9jMFi+XNkJq3DJ4o6X9nXMC/6z4+5uEzpsL/zdMw781PN5e35AEZk+KXq0qi3uckI/Hrkdn8zvtPECVSjL8TM1A2vT83MnL6oWDwPW6rcQxb9WFAOp/nbnvsMmlEuxvk3TLErOY5qAUeeixbEeMj3zyUE77pauc0vlCMAumT66rZXko4sS5ffXxPpN7kniVh1Ac5JRPFiJDXXfqGuyyHYI5LHW9BqUi6U6D4f0yk0OP0rmm89HYLaCuR29bYoaDbzNYe29Vme0pvFhkje2PJ3hPT1YSuzUQnauowoD4doeL94yFv69oPM1p/PIcfXK+OXA3SGRb5Sjzt8T394T2uKOovdCULxKi64UYzkzwt5WwojxxhpaL5LUiaS1idFsiHtFQmGpqT6fCUzJDYDzP+RD8rS7j9w+4fisgLUtOQThBho2fD1GXki6G8pw3xN5HmNyH+OE+/TeKEiTfTgkGAZ0PDU7jfCiCAkBNFyuHse87R/b4loTEhBNNsW/uj7OhnJLrVZLtGovtSHDYjwdi3so1HO1x/V6b+ZZisS2Ltr9Q1J5run89QD0/gW6b4Xs7aAWVsyXBX32OV6sy+Ht3uHhPkW4n+NchxWtF6/OM4mWMynJpjV338LodNz/yr8fSZjre5/T32gy/H+OXUgqflOl8YiTCvbHZYIvitclyl5JGmsoQ/ahL/1GF/iPIDxbks4DKVyGHfzjEmy5ksywG+Gd9sssrvFKR9M1jJrdKLFriLi5fZFSejfFGopyzBrGNZ9pUZqoi+GdlKtSkW155eMZjstFkY5EHNgN21hA2XjESRlNo+D5XPbLxWAQq1crKQGZUidbUuD73vMkp+060gBp+V/+dxn8pcqv12DT41gm58n1RlsAGT2N9U1CFgnsD1tkaqlKRgeBiQT4WWJtXKrr2gZ7NVvC2tpHwTecbCFd34gfHTrFMIBo18kpRSsr5ciMP1spN7ekm2ZOWS9Cfo2ZL0u266b2K6qH2Iqf+dE748trpo+3JFVgRSGtV8qNtzn9SZ7avCaaKzicp1Y8vJdXILraViiCRQYBwtgKIImjVydoVkmqIn+RopVbxe09foReizHADUmv6WotonO6KQ1llYjqrPB0KXsIy2U2f3C7mfrdDcnuL/qMygweQ7S9RvQJ7f6pp/PLczSS8dksexOlcLPpr4D/rzOy9XWO+pYgGpvXw0anzLORxgl+tOFOOKoToZo2kK/dQXBc08bzjEc40tedLwsev0NOpk/Wq/khga2/c5vR3W8x3NLkPlRNF6/OE0vMBajTdGOrajQlwblL2t5ndrjO6FTA9An+uKJ9rWp+bhLI4IdltgkJYP8/PpB3WbDD+0SG9RwFKA7n4DWovY6JXA/TrM3Gqmspgeq8ukYanC4JPX0jl89Zdrn5Y4/rHKXfvnjOYF1n+uy47v1ghnO3X+ouccJwQfPIMlMf47z/g/Mce1bd7zJcF8sdVtn+VozJN9d89EZGBAaqpWsWpxQD0nQNOf7fF8K0UlKZwEUhM468uUbOFtFqtua4QSupWz+QQ1KrE93e4eK/E6GHKzq0eV592Ofx/Mspf9tCFkOVuBX+ZE54OyF+e4G91mT/aZXRsnvlcDkLF65jC82unNFqPfXXxlEjL1rYkVZzKjKsQSqa0mYeBmQMacYirAmBjbuBFkawLoYFczhdkV9duTmXvDatKBDbgl+uqx5ut7u9EC8j5AACHaraGiG8DtBluhsPVYtow1mhjXJOur2a10c5dt9LB29OgRfUCq0XaSL/Wk8bcoNp8rhdFzijmuD/jOXowklLOMj3WmOyqXJIbyuiCkzu7XP6wwmJLBo2155rWpzPCF3KawvPcbEEptVr4KxXyW9tc/KTO6K6U8K2PFd2/HkkKE7h4RV0uopJUFtU8d3C72d0WacXDSzTaU3iJpvxyLJkEazp/Va+hpzMZfCrl+PRJs8iyJW2maJRTOpnivVihp61Kar209fd2GL6/x/jQZ/RuDLFH9WnA3p9MCR6/cI5ZkhRdEYkulz2JhrSqrGoFvdVmeq/ObNsnmGmqr2MKH790iU7YWMc1nbaqlsmaVdJGRFr2ScsCSfMSLb/7q0s58Xc7UqYbty8Pjrn8aYveD3K0p6l9GdD8MqX6eR/Orlymrb1/1qtDVSwSH28xPSgyORRndOlc0skan4/xL4bk7Rrz/Spp2VuF+rw4FXnmbouzn9VYdCEaQOtxQunl2KGWrd4822mSlQsSP3o1Qz0/kb/59gHnf7dL74cZ1d0J83mB5h+V6P5K2nmq22Z5q01SC/DinNKLoZjByiUmv32P3qOAwm9f43uaq5dNWh/6bP+F3GM6juU9VmoVRm+Ub8OfHjK+5TN6kKIyRfNjj8ZXCdHFXFqYa5nRIhPOnIM+P97n4mdyX2ethOKLAlEftj6ci0KuXWN8vy7txY8u0CfiQZh8f5/LH0hUaelCU3+eUnotr6VduNfzxDdS/sJAwpuqohr0ZjFqOEEniZPzuirUPvPLeLV2WJaSRcBYsrGdFdp2j3VRxwnZZLqCYK5J1VUUbcy47O+73vH4TmwArgUUrIYk6zm/N/n/35TfC5tDlcxiBm72+9dcv+tT/XWZ17oN/Obi71jcuZaSziJl42QVR2hY4OvsIkJzEvE9meobiaMuF1nsVbl8LyKua8qnip2fj/Cen4t5S2u3wVili7u2O0wetRncD5jt54RDj92fx5Q+MAEiWx1BDmRabmKTdKbKJfTBNpO7dZb1VblavkwpnhvglgXelcuu0skvrxxAa/ZGl3lXYhalxTR3g0qLePDaLXmgPCV5xMORYwr1HoYkVckLKF5rOh+OZOEdT1CHe+SNsnDXTYweuTHyGVCcDn2mt6rMtjyikabyeukGk16rKZvGcOyUFTpORDFSlWCe+UGNrOihffAXWgbLJgRlY4gfJ6hKmeX9HS7eLzLb1QQzReW1pvPRzPW53fsNKwWYmW3orTbzo5q4m8vCBaqc5DQej/HGM3QxYnFQRfsK7StJTDsRB3Py7l0uflxm9GYCqaL7C5+tv+zBycUqk9YuRrYiDQMxG43GArL78THnPw5Y7iV4U5/2R4qtP5cAFd2oGSezj5dC49MhfPFc4G73Dul9r07/H8158+CMi2mVyR9vc/gHQ7xnJ86JTlSAZSxqM0B1Wkze2WF4J2C+JetO1FfCrXraR40mq+AWzxM55lK8MAQB6Rv7nP2swuLHU9qNKRdfdDn4t5r6r87kXmg3SbZr6MBzPXhyTfrOHXpvl0X+6UHzCyOnftlHX/WcoMHRYu36AjJ/qpWdLBsF0csBajQhN4cg+95axZUL10Eq67xVR5fExObksCDrgVEEuSo0kxAkq2LcuG5KQ9f+be8tu159d2YA4T+Wf6ypfFwW700plblcPsA3SKs2AHLges4308Hs59pyzKtVZaE0fgE76LyZIaCiCG+rIwtNksLZ5cbgxp34TYyeqhjsQZKio5C8WWF6q8K87YES/X31yQj12igfLFsny1bIAoDdLvPbTSZ7AWlZCZlyrKm+Nlm105n0tUuRKBqGI2f6siqdya0SSVk2uGicUzqXIBp6w414R2tEyvsDcZBubzH93h7jQ2lBBHNN87Mp/uVQ3JfrruLDPdJ2hWAwc8Ero58ccvrbirwbU/6kyP4fTwm+eOX0/e7UBPLQDIZysm01ybst4p0K825IUlF4CYSznPpHVw5J7HVMrqwBvdlwExs0npcj8lJAXvBJagGls/nKRW179fb9K5fQ9QqzO02mOwFxU+EvNOEEqq9jik+vNtEUa6V+1m2gI5889JntRUwOPFQqTt/qiSxIaE3WrTPfKYGCwighfD2QRdT3ye8f8vIf1pjvZuBB6bXP7s+XFD87lfmUlb3aw8xazKNlVg3f2+X1f6LxagnB8yJ7f5ZS+fVrUIrFg12m+yFxVdH8Mqb0+Mzl66aHHS7er0rATZSjtKL6lc/+H8nCnx/vE3eKonC6mIraC0jfOmZ4r8yircgjKJ+uDcKvx+j+QO7rcJWdazMp9G6H6XGNk9/xab15zWBUJnhcZu/PlhR//UIW7a02yY60TAuv+xKPWamQ395h8LDKdM8ji0Qo0f114kLd3ZzKLvpJ7Hw52lMQFchqEWk5JK34RFdLgq9O5dkx7WP3TFvktZHeep02s7f3SKoewTSneDnHf3XpgG92HVo/xOnJVNpPawavdUPYTY/Tei6A/CLK4SW+cxvANy3Q8A2STPvxQrixOG9c34B4vjlTUIWCMwq5y1YgZkFbJ/NtmIpsDsF4smKFw6qnnqYCkTL9RG1OlWmnRFwXPXqhH4sL9Kpn+qc1x8C3UYXsbZM2yyT1kN6jgpycEzMfeDLFPxVSaL7dIqtGhGdD8pMzWTz3dlgedxkfRU7JUz7PKfYySicTp9rRWSY3XrG42nyNysnrtInvbLPYisgKwiSqfrXi+rgoPMCakuzfQBiwPO5y+cMiy6YEvmz/KqHy4YkYlRp1dLUkxqXxxHH/VbmEqlWZPdhiciCLfmGsDSohofCq54a6qlySqsM4yNnZktAczwMP8kKA9pVotXNN2Ju5sBmbiUBqrP1hgK6UmNxvMN2ReYaXQukqE6lffyrO3DhxMlBVKJC9dczgjYq8NwsoDnOCWU5S8QinuShvLq5EanzvQGiwviK4nqPOr+X9u7vPye82GD9I6R4OuLqoU/mswO7PF5IGZ/wGajyTCs0eOMwC4bVb5I0q8U6F0e0CcU3UV7Zlku226L1dRSsoX2VUPxCHudWzjx81GB+JM3q2l1M+9ag/z1zIjT7eZ3K/QVZQNH8pRjRvd5vheztc/MgjLUsVuvXrnOqTCd7JpbR4PCPe2GpLyzNOZBNLU9jt0nuvw2zHY3orJ6+mtP8yZPvnA9TJlQvz0YVA2qoG5ayqFfI7+wweVBjf9li2JNSn8kKx9asp4dMzmTspz7RhhOarCiGq3SLr1FwAPSDIljyXjWpoHNnm66zfQpXLG0lr8e0us/0iSUmJifHjU7KLy41cEteu9H058a/3+W8kHFpUzcbg2OZdrzGw1mcW3w0aqI2E/JYAZNvvz+eLr/My3H9uykE3iKHruv8bCiLr6nN2/ShaGcrWTncu9EUpCRcxg2KHrqhUxO2apBvJYDYPOCtLEIw1i7iFN47dDIIgMPJSOdV5O1tMH27RfxCSh2LI8ReKxlc5rQ+uhQRq3L4AKk7IL67kZnt4m9HdimTLpqJJL0xyCoPEkSntKQJYDZVnMjuxJytbpaRlReuzmNKLoQw6+4NNjvz622bSkno/bDHdldzWyomm/mxJ9OW56McLIQSBa5vZ7GV/b4dkr8X4uERSVcy7MtTt/nomA77zyxWOw4ZpjycOLZE0xOSWlhTBQlM+SwgnkrbmcAFh4Pg8JKkYmQxGe3SnRFJByKeDnNqLpch2T65E4RUEDgtMngtP/t4W46MCaVHSqqov5/hTcaiSpKsTe7OOLkbgIZnKcezC3J/+FwFvvP2ah41z/uT1PRa/arP3p0sKgyVJQ1Q81luRT6Zy75qsCl2vML3fYt4Rn0UWQf15SvnZAHpD0rt79N4us+iIMKDy6SVc9eBgl+ndBoP7AUkFoj6kFeh8lOAvc6KPZBajD7aZ71fJC4rqp5KPrB/e4eQfNJi9PyMbFShc+Wx9kFN7bNRP88VqNlAqGvXUdKV+u3XA9GGHix8GxK2c4qVH9aWm85eX0BtKOEutCJnGvxqugmIO95g+6JAVFb1HPjoAtFQb3Q+n+F++XinU5iLy2ECsl0KSWiAkz8EUNV+KutBAHgkL6J2O4CzMHM+aMjEKwfzWDostiR8tnk5QL8+df2i9U7Hu9F1fp24SbG3Ii8tCMZuBVy6v5kprhlhl28G55g+G/8t//A1AKdUE/gXwjrzc/LfAZ8D/ARwDz4D/SmvdVzJd+efA7wMz4L/RWv/yb/r+Gz6AtZM5sDFNd+Xu+hzAXjcMY+shy+vD4vXdc71szmezjRLPDZZND1mVivI7GK7MBhTOzhfsgKlchu02SbuM9hXBcInKMpGCjqarisHyYtbkgdb8lBx1mdwqMbzrkUcQjgWX0PxiRvDk1PFdaNRQs4XEMxYj9O19hm82GNyXm67+NKf5yVhCTvoD9/q5jTTXzvmsCgW8dov4eIvBgxLLlph5womW8JWTvuTUrlVH6/x8C7gbvdtlfOCz2NYULxRbv14QPZOWibw+gsSw6FurtspaNabHVaY78rsXJiKHDL44ETWO6e2r+VLcydOZ47OnR10WW0XmHZ88kNlC9XUsLYrz61UgSMGE3KwF8+T1MsM3m+Qhopq5SEUBM1xIwI7R6zskSRzjtVss3lgFm3uZptgzILdn5xJuY9RWFsOsa2XUZC5zip0t4qMWZz8tMfvenK3OmP64TPSXVXb/bEp42kdHBXQUiHx4vnQsJK9WdXhkHfkst8osmz5eqqk+n+Gf9kR/f7DL8O0WkwOPwkDT+WCE9/QVbHe5+q1thm8g3J9UZhrFwSpXOO8P4N4RSbtMVvQpfdUTR22tSv8f3OXi95c0m1MGX7bZ+Qto/eIM3R+ung1L1/R9OUHbrOztLr2fbHH1fYUONYW+x+7PVwoqogJZS7Dm3jxBP3kuh4y7t7j6SUvMbUWNFysqp+IkLwxigi9OXG9f1SpSIQ2GsojeOWD4ZgOAYJ5T/XLoiLzW/wI4D4nSWvIxjOSWKJIo1iiQxDBP4U+WqNNr8n5/Y8ZoT/lyo3w9+vFm5rndJLwoWp3615VBRvXnhsZmTmJVhf9q8b/9rWwA/xL4E631v1BKFYAy8D8CPa31/6SU+h+Altb6v1dK/T7wz5AN4KfAP9da//Rv+v43ncAO7MY3t4RuYp4dr8de6ywfcBsAsGL6GPed/Zjt6dk3Zf1n2Mvt6qy1g8BR/VSl4vJE88gEvkyWeBd9OYlYTOzNga7OZUhsZJjnP66y6Bop5aWm8VVC+fNLCapIUumXV0pOmurVqizfPeb6nYj5jrxexQuJG6w+GbrTpjKyWTwlfUcz3PJ3tslbdRYHVRbtgGVT8NOVs4z6r8UFasO63WuxXEqoRVEY6/FBi/FxkdFtDy8Tln3z8USG2Qbja0tpq6SwkYPJboP+oxJxXcrm+vOM+uOBBN1jKgqzaOfXYpRS5RKqWiHr1IhbRfKCx3Q3IC0pur+ZU/hSnL4A3nZX2m9ZJuHhRue9vNVm0cVY2mcAACAASURBVA1JSh6FSU6xF4sMcxmLGmUyWRnMfN/MZsqyQb5RYtlW+HMoX+VUXs0JTweiW0dUR1bvr+NYWk1RhK6Wmd1tcfK7AclOjPI0ql+g9bGi9emcwtMLQYsUQtH9m765qpTIGxUXJhQ3Q3Eb+4rCMCU6GcHVwLF95ve7AATzlMIT49q9fcD4UZv+A2nzoATT0HiWUPn0wkWZJnd3zZvMCih4fMjp73UYfD9BxR6Fa5/qS832H1/IxmDhaLP5qjVmczVadZaHTfoPCmSRYnqUE0w99v9kSenxmcytTKaBN567ga1vzGbDOyHTA/AywZIXrzXtTyb4Ly9kozU4bwA1X5KdnonB7e0jpvuCqw6ngu8IPn/lqlyv1RQfjT0Ixsmq9VoI0btbJN0yeaAIZilenDlTn45jh3LHmPpsteFmhZb9Y6XfOnfm0g2m2drhdr16sG1vFQYrzAisWkR/GyogpVQd+DVwV699E6XUZ8Dvaa1PlVJ7wL/RWj9USv3P5r//95uf920/Y6MFdBN7uqa6cT/baGPXX2AXbeffSAizblXfX7lGjeTTkiWBjRf1W3/umhRrI1ugWoFOy2mG1XQh+n/LyDebg4pMvKWVudqeYK3K4q1DhvcKaAWju9D5jaCcCy960tYx0jKb/JQbXXj85iG9NyMmt+VXK50q2o9jcYAOhhsnV3TuqhvlC3gsPewwvF921v3KWULYW+BfDZ2GW/DTJfRwvJK7mbbX8t1bTHdDJoeeqEieZnLCenkuX2uG4BYG5xy8h3ssjhosuiG5KeNL15lzqapySVo8YSAD9rWA8PigRVIz85SyR1KWDb90ZRj6Vz1pvR3tgq/wz/qyULQb5OWIrBIyPSwyvOMRzFacGu/VpVN1WFMbvucW7nivzuB+xKIrQ+jml8bZfNFz854NVclk4jbs/HiXye0y1+/4ZEVBUtSeQuOrmOh0JFWN55G1KtKuuhoKCLAYoVpNsmaVxW6Z6V4g0L1BRul8IdXGbC4AulIkJEtwVE2bSdF7v0PvbYW/lEW0dKlpfDkjPB9CnLB4sIvKNXmgCCfJChR3tMfLf9Jh+r0FeuFTuArY+9NU5kfXI7sYYAF2ejhaSVL32pz/uAYK4jpEA03tpQkEGs+ksmrWBdNgxAYA6viQ4dstxkceSQXyUFM5gcbTFSxQTHxGSm2ro+USr1Zj+d5drt+OpK01WDtAXfelCrTMHdO+1HEiz6JpveR395ncqZIHisrpkvBiAmdXX5dwIgt2ft3bhFKWiq76sYfP3HpX1g6XqlpBzxcuU8CtKfYwmaau1bghilkTvfyHbgDBv+8T/obrLnAJ/K9Kqe8Dfw38d8COXdTNJrBtPv8AeLn29a/MxzY2AKXUPwX+KUCR8mrRXz/pWxzzDSmU+7xMMgIwgxP5uGlpWO1trlGet1rord7f5givD3rX5gs3HXcbk3nDr/GiCHa3yNoVVKZFM2xKy2w2c308VTb6YgNLA+RE2Gygq2X6bzcZ3hVJYmEEt/5wSfGry1XMpHXsLmPJqa1V4Xtv0HtYZdERTXnxUvDRjQ8uZMG00Ci79sexe0D0g2MW2yUm+xLv6C/l4Sq9HInscjIVjvxaCE5+eY1jpW91yDo1pocVF76y9xdzgus53pWpdszA0jqt7eVVK+R3Drl+t87kUJyZ7U9Tqo97cN2XIfTetvTOx1OpcKII9fAOSb1IUg+J6zZmMTeh8DHFr66EHQ+oek1Ok8aIlzdrDtiV1AKWDY+4pqi+Et9A9GogcDY7yLcPmm31PNjh6p2IuCmvlUvLOr2QasKKAtYZP2GAarfQtRKT4xrXbwd4qQzBG19oWh8NUKembVevEN/uEFzPZcjcH5Kb4XveqZOHPstuiUXHJy2aIedpX1AeQYDqtCSiNNcCzxtP0KUi+tY+y90Kk8MC031Z+BtfCVwtuByhFjF5s8bwx7t4mab+cU8OLsMxqtXg8vfvM3wDtK8pflGk+WVO41NBhFuCJnkulcpoLH3sep3Fe7dJaj6TfV/u6YGm8TSl8thszrZt2mmhJjMJbgH8rS7Td/eZ7gQsOoq0ImTc8llC8bVUOLpRhXZTFv7BGH12Qa614zBNt4qMjoRXtfXrRMKTTq7QnpLXyfdgIadta6y0znaL+15sFQjHGaVXY3h95jIDvGZj1U62BzEzRPeMrNWpiwJf6LT94Yo04CmXFU6unQl1nRKqcoMJMTPGDWbZDWLo/5fr/08F8CPgL4Df1lr/XCn1z4ER8M/+X+7e5EmS5Erz+1Rt33xfY8uMXGsvoLobmO4Rzky38EAOj5T5A0aER55HeOSNdwr/AgpPFB54IQ/DIWVIzjTQ6C4ADVQBteQamRl7+O5mbqvy8FTVzSMz0S2kTAul/FJZmbF5mNlT1fe+7/cJIVq1j5sKIdqMsf8FwH8jhPh38u//dwD/Sgjx5fu+Rz0Uvv4AAtsWkDJzKf5O3Rdwe3GoH8F2pKI1WejOn+Xn1KFyO1kD2J46tKnMcQj30KAdF1/EmrOvTgXMlVr/TUptEEOy6McdrA99PVwVBuWgNr9b6p4zC0Na3PKcBp1SzohOE+d/3kfeYOApEFxUWw38dEbvVaJq634EHgbAsI/55z0sD2mBDU4rtH43p4F0LTBGD89rZFM+GiD+YIikayAecgiTTDbNJwnsl9c6QhKoSW6zbMs+aTVRDTtI+z7m92zkIUNwRt+fvbmkdli3RbvQiyuN7RXNEOkoROFT26J0OA3fbnJS80gWvcJJCE8+iEmK9OEI83sOnEUFIxXgWQVhMHKMLjJCPEiPQT2DAkKAjwZYP+5jfs/CpkcL7OjfT0mmqxZxy9TDe2ZblGUcuihDB2nXQeFxxH0agntXFbyrAt7JHHhzoTMJ8rYLa5GCv7rUmb3ig7tI+z7WIxObDiWFmbF0N39zBcQJYFnbXbfCXstMXxUrmgfkJgdIABC8WIK9PAULQyQfjLDpWZRFcEazHYWXmN+3MX9Ai5UzY+j/OqUFdrnSzKfSt2GsZR98sQB7eIzl4yYmHxjIOhXClxzhaYnG72eEH4ljKnStJr1HGY4DAHw8RHbUweSxi6RPyiVrDfR/GcN+SfLiqtckg+UiIW3+bA7meSg+OMLinoe0yWFu6GQVnOdUvC8nO2gWlCWdBOsqP3kS3jwconQ5rEUO62pFkEN1LzcjmsXEKflZ5HXSQfGOTZRRdR+pwh/HbxM+b3UmdH64NIndnmPWCmGtKG+7JP8QJ4DXAF4LIf5K/v//BOC/AnDBGBvXWkCXtY8/rH3+AYDTv883YrK1Ut1S8+i+PbDd6d9OAhMVRFn7e0APWHSvv1bw34oVBOj7YIt7RlnunEiMboeKhOyVijihnnKaopKTej0ULitUcmfDPA9sPEAxaGDTd7A8MLHp0W7fPydFD1vUQktcl7wIsngz2wY7PsT0M0o1yloMrSclSe1enaNarlCZJnFGADImSdSw0e9RQHnTRtoyUMkwd+98A/MJBYFUCiVsi50hFm80UD7Yw+K+h8VdjqxFao3opIJ/kdMpZU6GMa2C2qTkbLRMgluFAbI7PSQjB3GPQ3CGxqsC4a9PpRpItrayhNQlhgF2tIf4uIV4QO0OK65Q2gzeVQ7/NNlyZbIMsG16346tH+iiGyAeu4j7HN5EwNgI2MscPC2JAip7tZBDbwDk5oxjsPEAN386wuIegzMB2t9l8P63KXB+tYXWKcNVlkuZL+3i87YHYVKIu7UsYE8rRM8K8CTfZvraNjAeYH2/Taav5wvgyQvAtiE+PEbWdjF7aCNrMlhLwL+kHbA93YDHGQXUeI7GaxAFNgIbdLB8RLkQlcXg3VSIXmxgn852sqk3XzyA4IA9S+F++QwQFaqDMc7/+QEqCwAnY9zevyvhv1yALynXoOq1UQ2bqCwDxqaA+c0JqWO6Hcz+xY9x8RcF/OYK+GUTx/9zCutvn9ImAKQo4y0awioEg1L0JPe7soVIG6HgTCA6Iacwj1NUzRBF24M1iSkZDgCLQiR//ilmDyys9wXMDUPze3lPnq3I9Lha0XNr2UCe6fYS3dcRZRj4LirPwnrgUQb3mzkwmYMZHNVen0KF1glYJhleCtzoOEC/Q3OlLKc0s0WqvSeVBPXxRkPLT+t0UG5b1EaSM0RRFPTcqZmlah0pGkK9VgnJAFEb3vdkyNx+/X8dAv/fAP4LIcS3jLH/GoB8AnBTGwJ3hBD/ijH2nwH4L7EdAv+3Qoif/KGv/04Z6C3plD5aKzNETSsL4C251e0JPP3V+01g9T/Xd/9aSVTn70hOuNol65hEucPQigeFyj3qYHVgw1oLmEkFnlWwFik5brOM5IEOIW/5xWT79Q/GKLoB0q6DTctA6VLP2L5aE+5Z4g5YM6KWyXpNx1VJ8Uw7DrVLBFC4DI2XKZwX16TkUdKy+lxEZRB028hHLVx/7mP+WKByKxgrA93fAL1/f0ZhL5a9Tayq7UIB0G5/r4/13RDzY/q5vSti3djPrlBdXesTkthQ7jLvdig05SDApm0g9wmA51+VMJMS9sUarJahuuPHaISomj7iPQ/LfXo/zryiecY8payBZYzy6np7OlMEUICQFeMBFh9tB6T9vy0Q/PULzfvnjYiGfa6t4XsQAuAcxUC2aToWFd8rOUyWSV0wOO34mwFgclQWJzDf9ZT67MM+4vttrPZNZA1GQ/Df0xCctRooew2UvkkI5/Mp0VCFoFagdMUmI5KKsgqwliWCr87o9+x5EEcjlAFtoKzzOcRkCtZuYfrTMeb3OIHsYob+r3L4J4sdYCCLQpSDNsrQpgyGV8QlKj97gOsf+Zh9XIF3UoQ/89H/TaLzAphPJkgRJzQDUj122RrbHHdx9SMHhUueFmcq0P3tmtzknKFq+mS0Wm2o9bNeQzw+xsWfNrE+EijCCsaKo/sVzTLM85mm29bzqrWjPQqBfgdF20fWtFEEHPasgLXKYb6Z0EIqUS6Vb4OvUrp+cmAMwyCDZeSjcm3wOCX13c1Eh0ypVo5K/lPS8ncGXSn9vzKn1mofkxvenU6HfEYV2UCdJP5BjGCMsR+BZKA2gGcA/iUADuB/BHAE4ATAvxBCTKQM9L8D8J+AZKD/UgjxN3/o69dbQDsWaGDXzAVsoW6yPaGK9O3eWB0BoY5Wutjtvredr/NWcEP9NKAWAlncNdJYugxVmweeK9VALtYHPoQBmDGxXfjldEuDbDZQjtooHYOi/RYrAEDVa6Noe5jfc7HpkgFKEQzZOSVIKUs48z1qiy2XdDw/HGF1P8TiiKz97k21JUvK1ooKqgGgdcYqCyD/YB+Txy7SDtNQt8aLEo2vbqRLlQw94JwQuvW2V7NBbKHjFlZ7JuYPATNhaP++QvsvX1NBkkNNYXBgvqJTw8EY6ShA2rFQ2uQwtucFzHUB82ZFDCAVnq1dkQwsDFGO2ihCG6t9G0mPI7io4F3mMOMcxjIFmy31kE4duQHQtWMcrBlh9ckIk4+Igd94RlGY+P4lLciDHqrII5xGvCHDmGVCmAaqyEXWdrHpWUgbhIH2Lwr431+TzyLLwMYD5OMWKpuDFxWsyxXYlPrGcGyUnRCzD0Ks9zh4DvR/tYH91UtSXd09QN72AMZgXa90IeTtFs0NhhGyponV2EDpMIRnFaJnK40R4a0mRLdFyVnTNcT1BKzTQnani5uPXCweCHgXHN6lQO+vroGzS+2A563mdghfVcD1hNqpR3s4+/M+Zp/nMKIc/pc+ul9l8L58TieiUX/7cF1ebyMUHQes1cD6gwGWhybW+wxMAM0ndH+a05jmD4GH+E4D9jSD+eSUZkCtJmZ/fg+z+xx5Q9Ac5QnQ+l6G8kxnO4WS+76WSjLTBOu0ED8eIB5YYJU0jL3ewH49gVhLt7hSmtXS5yDEtrXYCFD5NvKmSyeFiyuU8nk1wuBtiabaYLFtwa77bm4j7FXNqtecOhVZS0GNbSoYs8x/GBnof+iXPgG86/WuNK9bEtF39et1oa7ElhRax7XeCp7XKV/KjCH71zscDhUaIh2zMAyNktV8kFYDZS8CK+lrVyaHebWgKEVBALaqE4El2Ta7Nc3AAg9lN6IdcMtAHjIUHnFjhn+1IAxzktCuqK1CyolBYwz6yO70MP3Qw3qfwb0kaZ97EcN4c62RCtqOrt6flGMa7Rby4xFO/0mA5JMEVW4g/J2N0c9jWF89pwzfThvliOIKVTFRua1oRii6IRb3PBQ+QzxgcKZA61kO/7dvqGc6HiC5S4XQO09gXM2J4njQgrVIsbwXUrrYZQw+p0SmajbfykUNTg9KTeud7bWQDB0ULoXc+G9iGNckWUWWa0iazmtuRIBJ17nsNzF/ECBtMlQWQ3hWIvp+QYYvRVftNlA0XJizDfg6oa/ZiiAYQ9lwsLjnYdMmkFzzuXQ3y9YD8z2IwEPRC1F6plZWQQgUB13EYw+lw1C4MtjnZQzzFQXziIMxNvshisAgPMjJOQ3/JWqi2O9g03P1MJtQEpQKZ74irwVsS0ZSVsSf6rZw+acdLB7Qou7cMAx/ERMC5Gqye2qVLCRhcGC5BrMsxJ/s4fwnFtw/mmAQrnD2vx6h/6sUzm9PwAyOzUcHKB0O780SePqKBAdhAPQ6SB70UDoMq7GBrMXgXdCz0f31gphCANBtoWqHyBs23G/OUF7fwBgPMf1He5jd5xAWZSyEryXY7fRKz2J2MBg1lDsfDZDd6WL6yEXuM1J7vYphnN7Q+3VdKvpFSdgHtckwTY1CEY0AwmD0vHGus5K54kVlud4A6doCyJmQQ/LNON4mzu0Usm0bW88Han9fXxAUw6iOrQaAf73+7384C4AOegF2WzTv6tfXX7dUQ3WoXJ2fAUAPKgFs49bqkY/yVXfxaeOY/B714q8CPUTkk3JGvvh8tTXueC5l+jpSOrbJqC8riZf5uIV4z8WmzZH0iCnfepITV+RiRqYvn3aCsEztfmVRiMV/dIzLP6ZcX14Agy8rRN/OIF683jqbpY4YnG1loKZJPdi7LSzuWFgdAjxnMGOg/X2B6Ms3OtS7aodkGJpR0DcAsDv7yIYR5vdo2OhOKyzucPiXAp2vYiJ6AhD7Q6zvNygM5GoDPl2BpTnKURtZ00bWMtH4t09QPtiHMY2ByxtUyyW4GqK75NJGltMD1+8gH4TIpAzUTErYV2sKSlEJX6qXKumwepBnmWBCYPWgidWeAWMDRK8yuG8WYGlOea4AhG2C5SVp0hdLoKzAfA+bx2OsxxTh6V1R1oD3YkZqIMdBdXeEtOuCZxXcFzc0rFUyZQBVK6IY0JGFymAI32TwvpUZyLLVkww9VBZp+93fvabTXhiQ6ibwkPUDxEOJeSiB7lcrGNcL8kh0G5QnIYeuPAqx+fgA83s21vukAgrfVBQKdLPW/W7lgNWbLRmxWT04xPWPItz8pMCnj1/h+aQD89+0MPhyRQuNY2NztwuelbBu1sD1jIpjo4HiwR4W9zys90nKGbwREBzofr2B/YLagAA0URYACSDiBOLuHiaft7G4T6Yv90oOop/SzElvynxP76qZ65IxMEkIGHg0xOxxgHjI4Z9XaH1LYUAQ1fa+WicQcUxtU4UEaUaoIhesqGiek5ckklgsUa7WxAtrt7ayVTX4rfl7tG9EnszfharRMvNbYhadDWAYtIDX8gHqkbSMMVRp+sOhgdZbQPpV7+u/q8d/KxzmLeOWCnhQ8Y01I4ZWudTkovrrqlctxk0jH1T7B9geDUNX7/RVca/v2GCZVMCKYptf22ogHzWxOnSx3qNMYP+qgr0oYc0zYpmUMgijGZGsTC0cBkd1OML0kwamHwFGwtB4LtD+hswxiqejeUS19w7OwfaGiB/2cPOxhawlwHOG4FSg9+sV+JPXejfIwpB6/HGik7DEnT2s7jewuGMAFSBMgBXUtul/uaCHOM2ooHVClKG95d0AQLuB+H4Hlc1grWRvP8v1LlQZ02DRTETMFrQb7Xew2Q+R9EzYqwrmuoQ9z8gMVMPs1rOYARp8wiTN9+ZuF/N7tkZEeL8/08H3+WEPpWfCSApCP6wTiNkcrNVEdqeL2X2X4jQXsuf8TH6u50Lc2UOyF6L0OBXuZ9dbZEUYQDQClJGDrOVAcBBm4dUMuLwGc12UB30kIx9mXFJe8GROC7zvQYz6EC4hAErPQtq1UTocZlxRWtib8y3agjFUp+dgroPkpw9x+YWN0qVTpH9Oii3r2zdaX64G91sEidw5t5pY/ckdnPynwL1H54hzC9NfDHH4b6RRTQiUgzaSgwD+CbUlxXwBFkXIPj5EPLSx2ufIQyB8RXkF9iyFcb0ggJtEi5cdur9ok7MCazWx+PEY158ZYAVJbqNXFbyrHM7JBFjWNgKV2LK2PE/e4wJVK0J83EDSMeAsicfkvZwRNqWe+V3jd/F2C+WAMqwr2wBPC7C01Peloq5yzyWwYJygnC+2i4G8V7W7XAi6l1frXZLwrUjbd6kQebsNFvo0eJdGRv0x9Vr1Q8oDeOcMoJRwLm7sDGdVG6ae06s+7/ZLh7yrr/W+ucE7wmbor7dzAXXk0jZ33wfaDdot5CXYxWR7QVWbwvN2TF9wHFR7fW3oyUMGMxYwE0GhL+dznf8Ly6LCpcBZsl2DUQ+TP+qSlJPRzqrzm4UObNFzAQWqk8gIZtsoB00sHkZYHnBkbQEjZuh8K2FfZ5dQwC7hWuDTleav8G4HyeMhbj52sHhcAIaA+8ZC+9uKAj1kLxS+h2JAu1C+SIA5ZaTyQQ/J/R4WxzZ4ThGLje+XMC5mpJTiHHWInLBMKsChj1IO7dYjC2Yq4J9ncE4mFORey2+gC871oJ6ZJuB7qEKXgtnvOtQGOCkQfn1BIDmATmbjLirfhjGNSdEBQPgukuM2rj+1kfYEwpfA4BcL8KevCS0dBBB7PRSRo3v0bLqgoa9pAs0QInBRNFxsejbsRQEjKWCdTsnYZ5rAeACYBs0Wkg3hm00TGPWR7TWx2rfBS8C7ymHENA9hssiI+VKecGXLA8SOmn8xwnpIg3dnJuDdlPBP1uCnErXtOFT46ulSZUmu6gf7uPwixOzzHNwvYH/vofdViehr4v/wYR9lO0Da84jnf0btRd7tYPN4jKRv4eoLBjOmZLHObxdkwpMmKBV7WjRd8LwCP7kgk9ThCMuHEeIe1z93eFrAudnQDpsxWiQ2KT1bahfvuShbISrPhLA4VnsO0iZD9KaE/3wBPqcirxYNlVdQrdbg7TY9vw0PedOh/GYBOk0q5dNiub0vDcoGrpYrqgfjAYTrEDZC5gUoY2d9uFs3eNV3/GrQq06HOsiqtknlnqtlyXVsRH1O+oNIBNtZAG6/atwfZpp048o+WP2XCewOVphtb3/xwLtjI9/hIVAvffFqpwp93NQhI7VdtnzoWVmRImez2Q2Ol7CxZGAjbVDfODjPCa62SgDTQNkKAYMRpGoVb4tJr4V8ECLp21gPDVQ2EL0q4Z9udPweiyLtNFY3PfM95Ed9LO57WB5ypB0Ba8UQnggE5wWCby63LmNZOCkAZa5DROafdpF0GRlzQoHmd9iipxdL2sH2WyhDGxCCFjEJXMOgh3wQ4eYTD5sugzOjU07zb+XAMctoUNkICeEshA6JL3sNrI58qWopYE83MCYr4gmpY7CSkEqGEvNciL0+VvebAAMEA7KQNgbhmwzOOaGL1aAThkEzDAkDq2QWQXy/jU3bICeovEY4vwZrN1H5Lskf5G3E14lmLLGQcmOrho+s6yNrmjBSGexyMSHduzyBicClOdB0oQuaCDxa8FoO0iapkbyrHO6LCd0P3RaKpkvtm9lCkzx5p43Znx4QN8qk3X70uoD7egm+ikmqG8fgjQYJFWxbO0xZs4HswwNcfe5iMxAoHQEwYO//qhD+/AWB9mTmhXCJYIvLCYkOogjFgz2c/tMA8V4J79xA60mF6Psl+ItTfX3BGMp+C8IxaDC/oCFpddDH5U8aSPoM1prwIfaipB5/WtDiZhhgeaGxGGAMvN1CdjzA8o6DLKLMaCMTMDIgerqEMVlBGJzSxZar3RhXxwEf9JDtt1G6Boy0AisrGOuMrofMkFDPHpMIEZ1otz9COgzBy4pS/KQP5XabWtekW4Wbu47GZii8CAXhkGdHpxPKa6Tlo6reqHpS/hBD4d/3qoUhaB4GoI9Tt8FK75KDvuUbUF9aIlh3QmKUJbu24NSdwmr1ZlFIF8qjPFu2WNPFlIyfqhlCeBZK30ThGrCWuT5e8hlJBJnBiVXf9GFM6YgrVitdPNcHLtIGQzym2YBW5Ch2v7ENNlcmF9aIkN0f4OZDF+sDoAgF7AmnHftXU4gXr+nzum1UgUc/i5LLtZoo7o8xe+hjeYeh9ATsGUPvNzn8pxMKuWAc6DSRHjRJZjlbA/MV9Z1bTWw+GCMeWFgc00LHCqDzTQHvPIbx+ooWx06boF8Ave+8kCgDF3nLReEbcK82JNGTmQbKVMM7bTodJRttkuPtFuJP93H9mUXegaVA8xn19zGZ00nIMHQMoAoP0q7wvSFWH/exPKDFvfk8R/DLE70oJHcpDNw9j2FcTqXSI6fTYBig2usjHfqUrZtJo9kiAW6m2qiGVgNVK4BxsyQ1kdzdisAj8iWA0jXBSkEQwcUGqEBzg6FFUZXfzSCevwJzHJSPD7E+8BD3OJIBI6nttxItsUqkmiWhOMxGuDNA5KMBFj8aYn5soHBpfhS+rtD+ag72/A15HoZ9Oo1lOQUezZd6o5OPW1jcdfU9Mvp5ieBb2ZKybbBWg5zCAC3qBqeBqGUiOYywHtEJuPQA90qg+TyFfbGEsAywtKBTkYT1idUaIk5IiDDuYHkcYD2iBDvvRsCZ5HBfzWmRlLkPfBkDy/WWB+X7YO0myk6ITd9D4XM40wL2TQw+XxM2QxJ8RZppJIiOEI2IO1VZHBCAOVkDN1Pt5gWwlXoaBJqsB9NWywAAIABJREFUGyF1W1IBAuXwmC76lh9khJQDohaDelKY7nz8v0BB/P9/AVAqoNs8IBUGr17vkoO+q4//rgyAW68ddKtM5lErtNLZAthlBNXkpSwKKRCGMbphDY58TMYivinAyhJZL0BlMbjn6y1SGNCQLBicHtYkoYVj0MXmsIn1mAZ9hU8KD3cm4J9tU6+0jl2FaggBFgRIvriD2X0bs08KGAmHd8HRfFai8ZtrgnYFAdBr6aEwJpI5I/k80y96mD0kbTgvgOb3QO9vJhAvXhN76N4QaccCzwT8Z1OI12e6gC4/GyDpcpQWQ+kCPCcjU/ObOdj5De3QPQfpXgOVxeFcScUPgKJPWvesYcKMSz1c1ZRW6XcQpqHD0VGWeuAX73lYDw2SYl4WtOt+daFnF+o+EFm+bYMYBlivg8lPR7j5jNQ0rW+AzldL8KdvwBwb5UEfaY9OR97z6bagOw4VlHaAxYMIaZMRFO5kDf7ygmY36lTFuXYoo6qolw06SYpGsNWVpxl9rGWi8h1sxj42HQOsBPzLHO7Xr1Etlij+5DGuP/ZQukDpEtDNTATCs4IYUNOZdoDfTszjwz6mfzLC/B5H1hKwFgytJxVav7nRMlDWbAARySJZkqK6uqHBZKuB5G4LactE7tM1hgA636Sw/vpbeh77HQjPRhE5MBcbGs53GyiaHrm4KyBrmUgblL0cvKbWJ6oKQgYCaSib8rW0mth8eojlkY3CZfR55wXc0yX5YaTLGMM+Ff84pXtHbhp4r4ty1EbaJWggBOBdkBIN8jRYTmcw2q1tpKWUc7PAR+W7EJ4FluTgqxjYpJQLXAuLAbDb3wd0Upva4euvC2gWWb2Yq42l2vXXPUzqdfuk8YNZAOqJYG9Nx4H3av3fOQeow+RqRq56Ua+/6nJPFdaghze3DBr1VhQAcoYyBnguqsjTN7pzFYNtKDSETbeSRhVAIkyDdM+yty9GXazuN7AecJQeYR7spUB4msGabXRMozLTwHGoTxnHMA72MPnTPcwecqSDEnzDED3n6P0mgfXdGyDZ0NBt1EYZWLsReXKIuXzYwPShgcIXcKaMYhp/PdPxgBgPkO41UHgG/BcL4PkrOh1JyeLyiH5vecjQ/iaHeymjJdMMzLaQ3+kj7TpgJblkresV8kGI+V0XlQ04820xEJPpNnRbSVclV0gX9GGfilHbBM8FrFVJrZrJfAsk63VpviCzZgFo7DbzPCy/2GbHutfA6GcL8CeviAk/7iK+04CRlJpDoxfvXgf5fgvx0EEWUvxg9CqH//UZDTODQMtF+Xylcx/AOQXMN0IKrHEsGrpK0xFcB/m4jdWRByYA9yaH+/SKOExlCfHxfZz/WRPJQMCZMThTAXda6Qxn9vKUFnbb2mkpGGFA12+/iasfOyg8wosPfpnAulhsaZ6NSN7zYtvudByIVoT4TgMXf2yhCASiF0D0mnb8uLwmP8a4g2TowblJaXcsBC0ELRdZw8LiyIQzq+DdkMjBnMUQhkHy2rygQb8jwW4yXY53O5j94yNc/ZiS71rfAr1fy9nRZLo1XckQH1QVqblOz+l33WmjHLaQ9n1kDQPWSuK6X5MgQed3X063hi/bAjotAjsqJZiKNFWZwKpOATu7d7V5VJnfUK2kNNUOe1WP6hr/nfqC7ezxfXno9Q3tD2cGUPcB3MJAAHjnL+z26y2ENLZsbdXm0Sk89a9Zd9i9izNU+/pq96+pls0I4BxVKIfBq2SX9qlcgs0GOQmXa5oZlCUw6KIYNDB76KPwKMrOXgrZB11R4lac0M9QCd03VHJHo93C8qd3cPETA/lhCuPMwf7/WSD4/SWpUHwP1Z0RKscET4st5x1kh49/dIT5sYk8YsgiAe+Kof8rWjQU74QP+2SEKirgzbn2BKw/3UPSMyEMClN3FhW1bF7fkHRSSjbTPYrwY6WA8+Ia2KTIHu/h1V94yBsV8eB/kWsKqKZ+BsG23Zds6Jr1O0judbAeESLCyAQaT5bgJ6TN1tfI92hIqAbhKm9WHsXLXhOreyEKl6H1HSWqiXUM7A10hgMTAtb5kpgwZUU7wW5D45jzyIS1LmCdLYDpglp5zWjbfpgt6JQC2unzQQ9li/j9LC/BN4VOIWPrBKIVIe/5yAMT7tUGxikVfcVPWh7aSIYMggG93xZwrzcwrpeAY4NJybE6lYh1jOpmAh5FwKiH9YM2WCFQ+BzedUaqrJNTnUmhyae1eReLAmyOuygdjtkDC2lbguyeVWj/4gzl6Tm47yP7/BjzY+ItNX95DmQ5sgdDXH/iIW1RgL13XaEygfZXc3K61/03nRbNFja5TkzLPj/GzccuZp8UsOYGnAnD6C9jWF+/3LqqOyFYLp9TIahQS1MibzWRfnyItGMijTiMTCA4y+F+SzxK0YqkvyOmU09egO2PUPRCCINT+22Zwrik1qEyXgHYzgWF0JGPxmiI4qBLz9Uqo+yPFbGOVOD7bU/RbYfv9o+7eee3uxf1zkeV5T+cBUBHQtaK71ta2duv2wVaDX7rzl6Z8KVi6XQP7T2o59vh87dPB8zzqJUgMc5wnW3WrwxD1z+TxlCTokeYBjBfUWth1Ea87yPuG2g9STG/56D1/YYAZwvq3YJxKixpphcBYst7yD4/xuyBg8mnZOPvfC3Q+fkF7ebCAGKvj8qnI7Xx9ExjIzDo0mxh38H0EUdlUxB955sUzm9OtI4bg44kPVKACcoSfG+E+RdDzO8aGgYXnBfwTpbg13IX5blAFKDoN5A3LDiTVHPbiw+PcPWjALM/zgABtP/GwuCvl7TrVi0pywaapLqoK3LWj7ua8mgvBMLTHP5Xpyivb8htqdo8yjBWS2djvkdD+FGEwiVdvrnKYT85Q7VYSgpkH7lvwp5nsE6uNViPhWQIiw8jmEkJc52DrzJNPWW+DzHsklQToFOPwmh7Lpjvoew1EO9RO8i9SimRLcshQp+ctoa89yyD5gNCIHlAKWNpm/T+ABXS6CSF/WZKypbawL8+SGSMQXx4H8uHESYfcEQnMo3t5c1W/eR5WxWRnA2okzLuHWH5uInFHQP2QsDcCHhXFHlYTaZgQYDy/hjrAw+VwdD6agq8OgPzPcz+yTEmH9B95UwYWk8LODcZrGlC+Q5lSbt25c+xTFp8KwEW+jj5z/exepSDJQaiZxzt70hwwFYxyoM+spYDJkAzlnlMbnTFcbJtiMMhZh+3SLK7EnCvc5qJLGOIwCPkCqAjQXmnjeTxEJuuRdGd5zGMyQqIE5J7ymd6R8JZC5bivS7SB0MwIWAsqPjzm4VGwb9343pb3i5bPpT2Jd7ZBuIyz0PPKwH86+R/+OEsAG+pdG6/3pP5q7N46/23+p9Vy0YWfE3duz1veM/3qyeIKQzBW/085ThVCGVD8sZNmTzGOcpmgDKwULoGioCOpNZkA5icbuZ1sj2K1vNIVepWFKK4N8bpPw1Q2kDeqND/Emh/eQVx8oaKYK+jd4VitaIHq9tGeqeLiz+mdgsrZX/+okLjeaJDMninjaoTEWsqy2kxke2f65/2sDpg2AxKWAtOQ7+nU+Bqoo1WZZtuUJaWJBFcLEmJ9OERzv7Mw2ZQofQr9P/KQOdvF+CvJT+w3dDyRhQlSeoqAWZwlIcDLO4HEAwwU4Hg5Uq7mwFsYzplapeiPLIoQnVniE3fQ+lypA3aCYavU9jPLlBe34BHIaq7Y5SuCXO2Abu4IXyAzG6oug0k+yHSJmUDN7+eAc9f6dNX9ngPhWvAuU50WwIA2J19pHsNCAakHQtZwODOaT5gXMxQjtpIRh5KmyF8KTOdyxLVoI3rP2pjdYcMecaGWi3GhvhR7itCEOhgdRk3KZZLLVoQH9zF/FGEeMBR+KAg+WdXGufN2y2aR9zMyCldU8aUnVBTSNdjkggHL1fgz06p1dhuoRp2kHV9FIGB4NkcuCAvw+rH+7j+RC7Qc6D1tKC21Om1ztFV7liVCCfWa8CykfzRXVz8kYXikzWK3EDrLx3akLy8gbBM5OMGNh2bFs+rFViabTdbjIM5ts61SPoczkSg+6sp2OmVbmEJxrRiS+QF2N0DrO81kfscgtOMxVznxBSSQ2fdDbjl2OWtJtBt02IiDZJis3nLqas3mrdMYPX6pbsKtkUfU5Z60YGotpnlwFszAwA/IBTEH1IBYdt+EWWpB7bqF6TbO/WBSj1SUvXt5cftsP9vxUvWYyfpP0zLOW8HM6t/V7GGMIxtUITvEThMyhrzboC8YZGscZHBvFxQLmt91yq/vuoXM9+j6L82ERFn91ysDimMJHxNxi/29VNorTJAuyGZQFU8OsDFTwOwEkg7AMsB/0Kg87sY1rPzrWFsf4jKtXWIiMgy8NEA6d0eFncdrMc08PPPZDbvyRUVyjBE1YlQhg7puuNsy08/3MPy0wHB1Yxa8tQ3V5QNO+yiaLnkIC2rrbqIU5RgdtDBZuCgcBjsZUXa/cvrrbtZxebJBVNde95qojoaklJkSElQ3k0J/00M/uQVDTk9T2KNQ5IYzpeolivwKES534OwDMRjj6SkHDDXFYLfnqK8ugZvNFAdDVCGNqzreEcSiXYD2V4TpcNRBAZyj8GZV7CXOeyXN0BZIbvXR9K34V1kW0fso7uYfN7G/AFD5QjYU4bGC+L2G3FGIUNpTiwfKTxgSbotgt0WwfAkRsRZVDA29DOLPNfBNuperK5uSDnlOPT1GgHScQPrPQtZyGAmQOd38t6qKvB+D8KxUPaokFpnU4h1AmZwZA/GmD30UFmAtaZ8Bfv1lKTAUmkm4oTmZK5DC7xqEbYauP7HI1x/IcBzoPkdQ+tJBvt6jaLpofANsFKQiUw64kWWgfe72Nwj5lBlc2QNA2ZS0WxpmtAshHFgb6A5SNX5JZ2YHt3F6n6I1Z4B/7KCMythrgsYSQ6e5DoKUjP/ldRcpn+VhwOkHQe8EBpQuONHUWmE76hH6vSgZgDMkoliMjBJDe51fVH1TX2e+jqyBV0lyQ9nCFxfADSX/x1F+nbfXtuibwW61Fs4Og8Ab7d4NPwN2GKQZREH8N4kHkBKy2QhQpZrQJkIPOT9EHlkgQkgDzjMpIJ7FsM4I6csgO1JoSx1ZCQYoyLWbSA5iLA8MEknHQPRSQlnVsB9fkM3NGhIV88INQZ9lIMmNkMf04eWzBMWKG2GvX871YNCFoUQrYgMUFdz6Qeg3f780y6mD4ljH70kIqd/sgQ7OdcZvFWviaLhwogzvSNXpqrlwybWI9KxBxek+6fThA0MusjGDQo5fzUHZgv6/cpg+/WjDtYjA+6UXJzuZQL+5BXhrZW5zra0k1P9Dni7hc2jERVeuatzpyX8b2keAsbAjvZQNj3Sot/IbOOiAHNdFHeHWB35yH1acPyzDWUgy5OGuLOHrEcnHGuygXE5pVOE50IcjbE+biCLCOhGbJ4S3skS7GoCZlko+y1UngmeFGTay3KwvSEu/9kIaYe4T+61LKKvM8I/r1I6GSlBgm0BaUaLr+si/tGRlq2CAcF5ieDJVA9S9W4fIN9AnOjTkRh2kY4CLI9syqO4pEVSzYmERBqzMKD7UjJzFPqgHDSRjANUNoMZV3AuYlLfTKSR0TRQNQOgFODThTarMdtCcdhDPPYgOJB0ORovpR9mk6Fq+Kg8C5XJYSQ53VvLFbXjogibh0Osx/R82quKTgWn0x1cCPM8et8TKubccVB+dBeLYx95yJD7DNHrEva8gJFW4HlJGJLJXIfWa0SMYZCR0vdQBR6Ktkf6//MrPePRJcc0d2WadaZPHSSp8jrk6V45kplp7raNbrWJ1JC5jmz/wcwA6k5gbltvF/T66zYsCXh/++gPHb3eQ/5kNdlpPb+z/vl1xZCmHfoeqnYD2TBA4ROG2Z7nYGUFc1obOFnmduAmLfiKWliMWoj3PGyaHIXHwCoBe1WLh1Q9XNX6kEdV5nnA3gDLRy3kAUNpk1zOnpfwn07AFivaifU6KJsBpWWtki0y+HBIjJyxgU2XAjkaL0pETxZgby71g8Q6LVQNUk8Yl3P6/GYDxf0xFsfU1mAV0P52DfPVNRVJ36eB8EGL9P3XUt+fZWCBj+WnAywPaKAcnFda143JfKvHdhyNFNbYaantzg7bmN91UTpSTfRmQ2qi0wu6xsf7yLo+jE2hVUbazTvuIh0ESPoU7h69zrYLLGOa5rnec+DMS8IK1OSSYthBfNTAemygtBmCC4lyfnMOmCbKB/tIhi7MdQnv2Q2q03Pwfg/LL/awOKKWibGhwu9fFrDiAiyrwISAeTHX9FFKSFsS3PD+IWYfRVjeoUXaPxXofLvZqrvimEBsldgJIDF6XZT7PayOQyzuGNj0BFgBDH5ZofHrc5Sv3tC9JflR2udgmUCvQ87XskTZJDpqEVhgRQX7zXRnl181AwKnbTIin0r2/vq4icoiAJ69rEiRc7kg4JySW1oGjLn0hSRE6sSwj7wfImvbSLoGzETstOPUkL0KPLBNCtzMNIoFoz6WH/eQ9OTzVACNE/Kk8CQHipKwz5uNDptS9xZsaxvq5JHjGzdTEmHIGYDGOdfqgq5N9XoiFYBaPZTlO1RPhaap0vStzeuOgrE2IGac/cPgoP9Dv/QCUN/p32rF7BT393gDdl63F4NbH6NNG9jd5W8//R046ndcYO65VJyaEQ205EAPFbZqgIR04zo7NU23OGLfgwh95P0Q630XecCQthjciUB0ksG5WFGYiOKpK3OatJyzZoPwEmMfmzbdXEYORM/XxAVaLDU+uApowMRPLjUuOP7REaaPLBQ+zQUAoPs1qXLEm/MtOM73KQxHcoHAOdjBGNd/NsDyiFKrms+qLaphuaaPb0WoXBOlZ5EufBHTrno8wPk/6yFtM+QRoRaaz3P4vzvXvXTd1lLXR4bK804b+UEXaU/mJDikg28+jWE8p9YWyhLGcIDisKfbFtXlNZ2wpDxwfRQg6VCbqPndEvzZ6faE026Q9jvNSd2lWi6ME0Kg6aOyOArfRBEYsOcF7NM5KVkAiIMxiq4HllWwnp/Tdei0kR/2sLhHwDfBAP+6BCsE3KsEpWuCFxXNUOZrvdsH45RxfNDH6m6IeEDBOjwXaD3N4Lyc7MQy6hMxAKMRgkURll/sYdMykPQZKgswN8Dwr9baSa42MTC4Nilx3we6LaRHHeSRoeM/vaucZM7rDbUxK0FFvt8h2WuSgJmm9lCsxiaESalm7a/mpPhR6irf0ydRvtroRZ+1mqgaPmYftxCPOLyrCsFZTgyl8ysqzlGoQ11YXoKdXmt8dHU4QLzvo3DpNMhLUqLZ80L/7KwoKZN3NtcOXN5uoWpF4LF0/lYVIaOllBPyGVT3pWpH68wSxfuX/64xMqa50+ZRH6vbOUoteJtI8A61UF0i+oM5Afy9hsB/16sGb1PHKD1ZB6jVIs0bdRPZW5P6PzAYfovhoXT9nkNFQvXxbi9ctZUfpgkWeMgOu1jvO4AgSSOrBAqXk/77zYIAaclG7wDUDIL7PsTRHrJBgGRgobQYrLgCLwSCpwsdnMI9Fxj0yNAzX21Dt4/2sPywg+vPDKSdEtFTA62nBbyzNfVLL66oELaa1AIoSpIWLpfgUYTigyNc/TjA8n6FMizR+o2F4V/Owb57QTsZOQivWhHprOMU4tUptR+O9jH5SR/XPwZ4xuCfMtLfS4a9xl07NhUiyQpivgfWiLD6aIB4QL9LKxYI3qTEyr+a6J64jtlTBsHVmnwBgz42j4ZIehYKjzDMjWdr8OenqJYrGHsj5OMWSs+kgeDrG1KoyH51FbkoAwuFa0BwRqqgeUqzE6lYYoG3BfetVrrVs/x0gMqie4YXAjyjlDJzmoDlpSaR8jijXOb5giSaR2MsHzWxHhjIGxLzcJIRV+h8RkHnwFbSWQ9EiSLkh11MPqbWB0/JtGXfULqW8nGwstQkT4CS4FjoY3PcA89KrA9cFA6jE8qqgP39Ke18V2uapwS+DgVSs6fpYx/JgN5v87k81Z3M9KyHeFcmOdHnK7r2jAODLuL7bcoF7jPYM4HO7xJY37wi1c5ogOywi6xp0f16swQ2KWGvHZviVg988IL8JgBgbAriUy03YHlB+cCV0KclYzRE+mCIPCJPSPhkTnnDKqbxFpdfP8+qkBvGNn5WzRIVM0whqiVNQNceYMsmkyA44O028049ekdd+sHMAN5aAG7LMOuv+i/iVp+sfvTScYpB8BYDX2l51UnjLc3tOxYEbQRTiF+Jm1aEUJFstrhohWbgjFo18gYVrg0RuNiMAiR9Wqw6v7hCcq9DTlPOwJax7sMC0AYSlc2bPOhj+thB6VD7oPGqQPDdRKOUleMTQkCsYj2kLO+Pcf1ZgHjMUHg0eGt/K9D6PWnphSRqAtiBU1VyEWJ39rH4qIPFHQN5BHgXAt2vN+QbWK2J66MMOWVFC4fUURv7Yyw+H2J230DaFQheMwx/Pgd/eU6FQyU4pRlJOOVxnFprJLWMjxuY3TNhL4gw6T291q5XLQW1bJKTlrS741FIId2OheSoSbmvy5JOVpcTvWMsj0fImjaF0Cj+f1FChB7yQYjCM8HzilAPaUXE0NPrreNXceXXsQ4ZZ80GksdDrMc28gBwZwLOtIAzSVG6Ji1cnEMwplsf1cUVAID3u8gOu5g9dLG4T/z+6HVFrBuFzlgu6b3LXaZue8jdeHIUYXGHwuiduUDzlyQThmGA97t0rdKM/g4A7/eQ3e2jdDjyyIS9KKiVCcA7T8BfnKOaTqn15nsk+WWMJJNpBrE/xPVP2lgdMBSBQOcroPGCgleQ5RqZAgAsSalwy3B19DrY3O1g+sjBpk8k0M7vd7HkZa+Jzdin/IYnUoEkMdl520MycrBpc/iXpZaeKu4QIFsxknyqnL/pB/tY3HVgpAJmKhB9RfMqjZZRr5okU/Xrd15KGVjLNFfqQO0hqBV/teMHaOYoarXodn2jdtxW+ln/9x/MArATCfm+4n87LQzYrry3YxyB3TARiWFWdD01zHofa1sX35raZwcMV49yqyMi1DFafn8lPWWOjapDBpTSNWiHMk3AkgxV0wd/vo1NFooDLt8X73ZQHQ6QjH3M75rImgCrgOikQuvrJdh3L/TQTr1XBfvi4yEWPxrh6kcG2EdLZBsTjZ95aL7I4b1ZUc5qUezY1tX3Vylf5fEIN58GyCJqTQXnhW4RMdvWihq+iul3ulhuqYkHY1z/oz7mj2jH710IDH8mHcZRCDHskJRuutA7Lh6FRKfsRkjGAVglUDqcclsv1wTgWq2l49LXWGAlw1MBGuV+D8legNJmNIS/HZDTagKdJooWmb+smzUNIiPi7heeATAyuplJAWORUWtG8odYFJIhKS21L4BHIbKHe1jvUU6CMIDCo6GjM6Ege2GRGaxouDDSEny6gji9oCH+3gjxoz5WexbiEYO5oeF/9GRBxkCZJqevb7ezzaduEn8n74dYH7ioDFAa3PkM5ek5nR5bTaDVoEwGSXsVj48RH1EUp72qwEogfLYA2+QkuVwnKG8m5Cj2XKAZ0U56uaJ7vNPE/NMuFkecFufXBfyXiy0ls9WAsExa5GYrCJmjDSmvzj48wPzYQeHRc9v93QbON29QTmfgdw6Q3Oug8LmW0Yok0VGraYcAdep0VVoM0YsE1qtrnYW880wA4IMe5n88xuLIgBkLdH+/gf3kAtV0tlOY6/wxDYCUJysAQC4l2mW1lXveUg/pzSig68zOgqDaSfV6865o3HecALjj/HB8ADsy0PeA227/+1sRjzXN7U44jJrqSymoBovx2lygqn0vlRimpFe13t7tDE8l0wKg1URcaZ0tCyL0qMCYHBCCdpfxhgaRcpCoPl8pgURZ6hCZctjC/GGIxV3qZVorUtY0viXiYhXHekcm4kS3acrHh7j+LMDiHlD0cvCVCeeKY/DLHMGvTki3XMvFVUVElCVJHQ8GWN0PcfORgaxdIXjF0f2aov+q5WobcqNaX3Knr9gr2f0Bpo9czB4LlEGF9t8aGP0flxAnb+jUdGcfeS8kBca3r7S8s7q/Twa5gYHCYzIHuUTjtzfAxZUOu2dRuP2Z1UnBc3UiW+FbyFomjA0Vfv5aUlNtG7zbgQg9Ik2WJfWi4w1gWyi7EUrfxKZjI21y2KsK4dMV+OtLMuW1G0jH5G52zmSbLk7ABz3ke22sDj0kXUJ1O/MKVizgnW3IdVqqdiCB0VCWwCVJMvHgCJsxITV4DhipgBVXcGY57JMJ0S2LkkitUsqKvQH97i0T+ShCFlEmcWUxuDe5NvZpH4zUmev2xNEelh90UFmMMgpmOYwF5f4qibAoSzpFMU6020pQprDMMZh8HCEeM3iXFFsa/uo1YadlDobwHCAvtjA5tclqNUjq27OxPDRgrQRa329g/vI72iV3W3QdAwvWbEPzGRmxmd7pYKHUS1cltT3lTAzz1TYDwzR1755HIcT+AMsHDSzukkCj/+sU7nfnKM8vtGG0XK13T/uqTkjoH6KAfDbKrAloIYc6NShxSN0wplRFb+UA3PYj1cjEb2Fu1L/X3Mg/nEQw/h+/Pdx93+uWMUO9boOVAGw1t+/g/3PH2TkFqD8DeItHpF3J75KnYuvSo4FwCOE7xHpRcXVpDn45JcZ4VdVCLKqdwZBy6y4/6mLT4sgaDHlIlvrWU8mbUU5TSSpEmtJC0Goi++QOrj9zMf+wABhgrDj6XwLNbySiV7Un5PBZDQ+V3ju700MydJB0OdI2BcX4VwX8r05RXd9Qz7fVgHBtrU3Xi1Cvg/hhjxLGjgBnQieG7q9mwLfPtUO5DAgUhotreg9RgHy/hfXIwWqfimf4ukJwLpVPl9d0wolCuvFNk1pkaUoBGpLUuOm52HQNCEYRkeH3c1KKqPeskrVsi1oRaQY4NgRjhHiWsX9Fk5hFRpzBOJ8CjCE7HmDTt0kp9ELGN8YJxP4Qi48o0Uow2u3nPiUV9khNAAAgAElEQVSkNb9fwbiguUvVDiFskwih51e0qwwCFA/3MPnYR9JngAB6XxVwrzYUSJLLUBIFDJR0T97toBx3sOl7WB5KHIcM5QnOJD/o/JJaYo6jTwzVhjAbvN+l9LGxj9znCE5TWJMYuLjWai+M+rrNyZIUCpktGiHycQNJ38bsgQEjpZSx1l+f0feRcESUJUHv0lQD+FgYILvTQ7xHEY1mQgNl9/sLQlc0IhR3h0jbDqxlTuqiFe3iqztDJCMfWcRRmQz2uoJ/msB8JU90qrWr1H3SEMh7XSQfjMhV3WGwljQ4d789R3l1TR8vg3HKxWqn16/ax8zgdPLJi62QYx1vuf8q/7fWGtabRyn5VKrGt3A1tVqiF473zCW1J0l9PfyAhsD6BPB3LQJ/lwLoD80L6h9fldshDWoXRH/Y3yOKUn49blt0NJQhFcIydawcXyYa8awCW+C528xa5cTstFG1Q5Shg3jPRRpxMEHhKc6spAI8ndHQ2ZUmqNVKh1vkj/cxf+BhecRQ2fReohcEz+LfnWwDOeo7frnw8G4H2YMhbj50UXo0eAsuCu1b0IuW+tkB/WAD0CjlLOLIfZKfeleSTDmZ0Vyj3SKZnlRGVZMpeBQiPx5h9shH1mQwNkQ9jZ4uwb9/tUNzhG3R8C5JyQNQlmD7I5SdAFnL0TtfngkiPZ7eoLy43Bb+mplPyRXLfpN+/iQn+SBAnP6iApuTxrvst7AZ+yhdjuBVTCEmaYrq+ACLRxE2HXLtehNpGCoF7aZfz6kvbBnU6klyGJMVMXSiEOWDfSzv+ljtc5QOJWc1n8Ywryn0RRgcVeSDZwW1UmTKnJqlTB8bSFsCwSmhIoJzyocwn1E/n0lvSLXakkdZFCF/vI/KMWAkBZn3Vhu9uFRxDGPQp9NwuWXgs4BSzZI7LSRdA2mLIzyjlpZ9sSQMum0hH7XAN4U2FColkTgcItmPsB7TYuXdVHAvU9hPzqjNI811aY/kpe7ZCrieAlGA9KiD9dhCHhD330oI/6wktfWoVvWsV8kG3PeRfnEPNx85qGzAnhMe3HkzBy5vqCZYtjZfqkS5+iLCopDuO9siqahM6NOzRNCmU5lRmWnqvr+aP2rj6u36c2sTWW8F3W4tq5fubtT8Tz+YFtAfVAH9XS0h9THvywKQ/65bRnUO0Hu+32010W0zmu75+95W4imjH1VhhIw4VEdIADv5Aty2wEcD5HttJEOpAsnp59JZt9OVRkUzx6bdwWpNuu7xEKtPRrj+zEQyrAAmED030Pl9TgPliys6kqrYuoS4KfVWTfzJHiYfWkgGAt4lQ+83KRUvaYrRKoZaMhEALRHc3O1gfo+YNY0XEv2sfAONBqGny4oK93xBO/luB+n9Aeb3HGw6DEwAzeclwu/mWtvN1ULnOjQsrLXjynEPm7GP9dAEE0BwTulRxunNVtKoNNxqGF+/vBLcJlyLXLZJqp2tIvTpd1UJCMekXftsDdzQTh57Aywft1DaDLwQBKVLyXlrzbfmLeE5qDza0Sk+EPM9pB/sUyhQk8GZkyzRXBcwlyltFmR/WHgOoUEkU8bodbH64oBwC18ssVk46P7MQvN5RvfJ5ZQKFKDlhmqGg14blW8j3vMgOIO9oNhKMVvo1puCE7JNpp26xcMDLO+St8NMBYxMwFyXcM9W4JOlVvEwFeQzXxK4TxoiN49GSNsmNm0yyNmrCuGzFfhTWtyNfg9lv4W844IXFaxrycEKPWz2G0j6FuIRByuA5vMC/osFRYvK+QELKU9CyPcKAKKsIIZdTD9vYXXIYSTA8K/XMJ+e0XtUz5HEPqt6oAKGFDCwaoeU8c3l9ZN5w7cjHrdxs2Kne/AW1RjYNbjKGqMwD1Uc72r8pUx9h0qsNps1zMQPZwFw//nbGOjb/a93veo9s1sOvJ0Brezj1w0VO22fWnun3v9TF2CnLwfo1B6l71X9VR3yAGz7h7fmCywISLLXCFD5NvLIpt1rLmBfrkkWt1rr38dOfB8APDjC9JMm5vc5NnsFWMbQ/NZA81lOKV9SScKCgLT4UrIn0hS820H+aB/rfUfvPqOTCo2nCayLOdFKRaUzBtTcQ8vdwgDl8QjTxwFKhwxMViIQ/X4CcXKqvQnMsqBgZYrbY4yHyA46uPnUw3ofaDwjB6rKthVpSgYmy6ZiLEPVFYmz9G2kXQfrETHyw7MC/ndXJFuVaAOo6yKzWcG5TrPS5qRNBuG71NpQWnvTJAxwIKmum5T+HdDRlPEeFUNnWsCeZ6hMDhgMLKtgrFNKywKotSTza5ljI3u4h8VdF0mfwZlJGeeG7lVjU5A8cZ3IrN4tVkAVydWP97E8MLC6AwgA3d8KNJ4lMK8WWx2+8mio+VGnjbITYnUnABNAZdIg3F7QTKE8PddxnypqUfk7VFhM3KN2S3hOizOfLSF8F2UnoOCaotoylJZLjRVZPaJEtSxiaD4v4L1Zg7861xsX7vsQx/soA5uc0RkFwJS9BtYHPhZHBgof8K4FWt+nsK5j8OlC3/5k4vM0N4pZlr7GWZ9MmBrjrcyENePljmrMVKo9A8KxUfkOwCnPA3mhM4Fv6/F18a7B9HSNqe34b3cWbretb88Z9ELyDnIBty399X94iWA1HPRbBb3+qreAbg9M6A+7H/8ek4Za8et00PrX2XHyKZeeyl6VF2JnKIyazKvuLwD00EZn847aKB2DFCCrDe1KspykfdIkpvTc6jjJ222gGerUqsWDCvaMI3pJBcX9/mLLnZfqGGZb2hTFogjV0QA3nzcw/UhIWqOB0c+Jqomi0O0dMVvo9hSAXVhYz8P8noU8YgjeVOj8zTWdNLJcoweUBl4NbHm3g82jIRZHNuIRRUs2ngC9L6dgJ2dbmWkd48wYDWXbAfKmi6xponToWnuXOexLGe+o+suBL8PCpQnHtmjYyjkVZAXzk+5WCEFD2TynnXO7QS3BGnqhakUo2h6KgPThZky6/8o1kbVssEqAlQJmXKCeEqWCfdL9Jub3KdiHCcCZUo/e3JQwYjpR8UUi/R7SR6B2oWGAzb0+fX6DoXSA7tcFwu+m24Qz2fZQ14q326Rq6gRIxi6WB1LCeVUhfLWBdbWiQBs1SJfCAaVFN3pdlIM21ndp2OtepTDnG70rF7YJwTnKwCIxwyresvv7PcQfjzH50EIeAJ1vSj08r6ZT3YJioU/F2uRgmxxVSHO4ZOhhPTZQmYB3I+De5LAmGwIGckabgNAl7LOMeeRRiOLuEJueS2yeWUqmvwvp9labptpGBpCnVzmr0zMgAMI1wTYFQeMkWrqu2NEKw7qMXA5+b2f/1tU/b20uZZ3htkWKIqUAkq0lDY/7A2og9f1+MCeAOgpi5/X3oYPWBjd/qI2kVm3dlgF0bFv9+2kCn3QkM8OQhD9rN/RZGTjUKi5feqFQARGOQ58beMgHEYTJaVczW9Js4DZqomZY41EEcTjE4oMW4j5H1iDHbutpSVK9N5faLAbH2YaWqPc06mP9qIvVnoG0TcEazgx0WvjNGyqgoY+q4RO35Xq62/MfdJHe6WB+bMPcUMuDCaDxdA3+/QnNNaTxCoC21PN2S9I0I8yPLWz6FELi3ghErzNSqEynOpoRpknDNtOkBKmGK522BkqXwVpVRN28WdIJp6qoBaAeRs51kcrbHsxVBr5OdXtHYST0qa0oyIwkZzY6qavVQNn2kbYdsErAmaTUJ09SVM0AyV6I0uNgpSDAnNy9q/lMdbyH138RYX2ngD014F4zeFcV7CXJK4UBWMsS1iKFcTahBVoI8Eb0/3D3Hr+yLWue0C9ieZt+u2Puufbd9+rVg4JBVzFCwql7gpCQqgcghIRaiBn/AcyZMQD1EGipBagFDJAoEEYq0S11d5W6yz1z7THb5k6fK5eLCAZfRKyVefa99egSpeLm5JidO80yX3zx+34GCAOowMf+szG2z8lawqm0Ad/bR7puq4qyhxmDfFxYlo58cQGR+mgTF/sLF+XEWHI0iL/dWGsKOyBtW4jNjmDIy3M0F0McLkNAAeG8hv92QdRNHeribGrwb64tldoUU2c6QfmjS2xe+Vh/BiSvGS5+fwH1i6+7+Y3ZidU1deuD1Kp32zwEExJt7IJJ0A54viQoDiDWkcHBtYMpHw7QfHiB5Y9jsv9YKRq43y7JAdew27QI0N6PWrSJLLEkDVa3YDV1+2xXWCqyHeoCx0FS/XvdsIN0fegbVfYtHPpqYVuOjD4J0Du/6qgW2RnkScPbTyxUVfUDsoLoR0ICxyvgyeCXB8H7wgnzOC3+5nefolc98X9HymGgcwA1+oDTzr6/O+jbuyYJWKaNtADIPAY71ESHO5TH21LNUe5niPLhAPJsRNTAF9Rxu3uFaCGR/8kCeHdnB8jme5shM8tS1B+do5z6KGZ0bJwKiB9aJH9AFFCWZRDTAQV1L/bAYtUpO3X4eTuJUI59NDGD0wDxdUkOlotlx2TyPUom00wbPhpaNaYIGOqU2ZCb+EsKfTGqVRv6UlX0d71Atil5zIjQoVnI3d7mDdhhNkDis8kYapihukhRnHlwGgXpMuS/2HbZvUb7wfQOrZfXwFyXCm8SYf/RAFAghe6qpPN1qADXgRinqEe0KEXXFNZjw3XOptj95gVuf9uB/5M19tsQ+T8MMfpVA/fQohp6kC6Dt+vwczmnVCoTadnkPnZXPpoUdpg9/acF3F++tcXM2IeYa4WPRlCXE+rMXY56GGD1Mc0dkjuB7Odrgk6EIMaXkASX1TWc6QRqMrSQCVlLkD+P87DW9xWzA1Abgei5ZAt9NsLukwEWP3LAG/JwGv7JFvzLNxTYcj4k+49VCfb2hgauZ2PI2IeIXVpQyhqsagiGqxur52BpYgf0zu0ScrGkmdfZDPvfvEQxcyF9GiYnr/dU+Ddb+sxaha42W2ur7OQp8OwCMvLQ5AG4kOCVgHu/seE5FtrVu/t+LKyxerc1qHctscCH3GyftHI4NZ58b1EBjjRMtg6h23H0H6dMROY4P6AFoLcD+E4ISCmAO8dBMd9X/J96nKrsTgVkp1u3vq7ADGj69tE9ywmeJlTUta2xtZINSAGp1ltS6ho8XSeQyUNpt4NGgt8mDkTA0AYMXADJ25JocY/LI5m5oaHxOAYbD22kIJmyKQRrieRXiw6mOZuifjGB9Dj8xwLs22vLmlDPzlF8mGN/Tv73XqGQfnuA+7gD2+w6D34dimOwVD4coP70CrvnAaoBZev6W4XsWwovkbf31GGbxTFNrOAMdQNMhmguh2hSF04t4RxaMgnjHFhubPduFlPjmCoux9h9kKCJia9fpxyjP93AWe6hlmvq5PpyfQ2LmXOLMED9fIx65KPKOcKFQPyrOYX2hAFBFZ5LKV6t1D5GBI+xNIH88Aq7lzG2Lx1UQ0BxheSahExO0aKahKiGDuUQ/HIN9rAgjrzrApdn2H86xvpDFyIAlEuLdHIjMfzDOUFJAF1nWpgnywo8JOdTlURQkY96EpNPz4TOmb+TCOcN/Os1LV6eSzscraHgkzGqn75AGztoI7Id4bUk2+mGIEm1Lyxe37dT57MJaR1eRijOKJTdRkMuVuS9n8aQWUjQlj53bDqGzAztWWl7kPoYygLAxiPINLSduRG+yasZFj/LIQIgWkj4K5rBOG/uj6yb+xkgqmnh5CnU80vU5wkOUwp88Vc1/OsVXR/brb0/rX1IcbALrLWR18NmALSDKUsLE5rEL7Oz+j7xqtEDnGY19x2LDarwfbY49uf4S6KBMsb+YwD/AWgG9UcA/n0AlwD+LoAxgD8A8O8qpWrGWADgvwLwLwJ4BPC7Sqlvvu/1+2ZwwPsD1z+3sH/XkPhk+3T0Wj0x2Xv2q6cv3z85PeGXhWnShDoPz7P+L/QEaZOqrGf4CfTEOBUz9ewMIvHRxi5E6ED6DMGigburiYWgnSDhe7RjOBxIzRqFkB8+t6wY3oL8TN7VNATTfuV9/BWtsOHmfDyCmA3RDgI0mYsm5jpNSZL46nHZHV8tdjE3HI9CYDrG4eMJdlee5Vknd4Kk+m9uaHEaDgDPI7y9qo/wbpZnELMhqjMKbnEqhfgX97Sr2Gx1QpKkeULQFb/6Mkc19uAWFJZiIBUTJA7gyArE2HDAsJo8ByIN0MYunFJQMLkeqBrPfaMVMAIsM6swQ9LdhQMZAPGtRLAWCG8KcstMAiiXogX9m00XJK/ttvcfj7D6mBTdbkGwGFFnG4Rfz0n0tSuooBiNiA5qV2EA5TmoziIcZhSNyQWIkrmqyBunbug603x1o65uP3uO7QcR+U4pIHysoRiDU7bkPFo3HafenB89l6lfzbB/FsJpFNqAIXpoyIqjOBD0NUiosB8agptABV1MMhqWA3C2+nXrhhqKzdbSLVUaQ4UeMaH0IFyNcmx+Y4z9mYN6AGRvJMb/cE7iubq2IU99rB4gqIcPBxBXE+xfxKgTjuyNDph5XFqIxxo5DnMSAipFUJ7xszLNgh6wG6hRPi663XoYHEHD9AEIGrKRpvpafI+kYurR9zAXLfsnCo/4/39pOwDG2DMAvw/gJ0qpA2PsvwXwPwP4GwD+nlLq7zLG/ksA/0Qp9V8wxv4jAD9TSv2HjLG/CeDfUkr97ve9h4GAnsrOBL5jGPxrffjvmSd8H130ZFdgPhMPAmu4ZcRj1pZZyGPHQK0s7NsXH7k0pglYlkKOcogsQDUJ4O1aYoWYXNHNnuT2nFk7ZCMa42kCNhpi9xvn2F05aDItcvlCc53vHggSMvoEx7HpUSbYoriKsPnAhXSB9Foi/3JP239tp4DAJ4vewCELBXPDjoekmE191JmHasjBBKgofPHQuW4OB2TqBhzbQxgcNgxo6Oo6dhDH7h5JvdpjaaBtgbMp2mmKJifGlHMQCG731kLCMLD6W2przWFCenwfcpBC5ITv810N9rCwmcNskEFq7JkXJVk+6KQxRCEwJdijmFG3ndy2ZC9xt4IKiTrYJh7cfUP4/vyRCs3ZFM3lENWYGEx1Tp8vvZZIbiqwWqIZ+GStvKrgzDdQ+wPkZgPnbEbBNfoeqK5yrD/ywQTILfZ2T8dwsaaiEEWAw0k8JwT4J69QnafYfOCDSSBcCfBawdvpIXQr4Xx50/kv6euaX5yhvRhCcYbDeQjpMUT3NVE173SouoafWCPA7xbd7OjlM+x/NAGvCVLimwMtuppWye+XUFVNQ+gogBzEZKex3hGcOh1g8bMhVp8ByTsgeycofUyH7/S7/T4cy/McGA9scwCA9Abvlhb64nFsmWIq8Mizqrd4GANDJqWdDZhAeBvViB6xQ+/C7Q6359R7RBQR4mgADCXfg6dNnbMhV2b3quHuvg7AzNz+Px8C6wXgHwD45wBsAPwPAP5zAH8HwIVSqmWM/Q6A/0Qp9W8wxv4X/fe/zxhzAdwCmKnv+QD9GcB72Nd3LQbfJxh7wjb1aJ7AneMTcPJ6T4nDrPxaF3Qex9S5mEi+npeHiZBUVXUMGZmONEuBQQaZR4BQFAmpB402ElHzqe1h0MZZztUF6pdjNImLNuIW/ojuSng35A7Zv9jAmTUM4+czVC/HWPw4QD2gIWFyLZFcNxQbeD+3lsW8bMn3pm7o8wBAlkAOEzSDAPsLwrXj+xb+qob3+qFjHKWJFatBKSDwKQ4z98EaCWdTQWQBwABetWREpwNtbOHXzB4xSlCex2gjjmDVwjm0cPY1+GJLuyLAFq7+uWO+ZwVMyiP8VnEOXlSkftadLo9jsDyDGqTWroPvSqiliZykRaGdRKiGHpqYI1wKRF9oqCjR4SNSUdeuefs8CMCmY9RXQ2w/CFGOCTIJ1hRL6d2sIAcxNp+Qr0z00CB4vehonRczNGcZ4DDLGDpc0lzFX5GlMb9b2IQpM/RXey380g6kTUIK42Ct1e+aLePerSkesays26rxyxKff4Dl55QkF2wEorsS7jd3ZGioNRRiFNNrGEjM98GmY5SvJpAeg7dpyK10q60ZAjpG9n7OEohxSoP6DUUwsmGO4kdnqIYOBn+8oh1FTwhnuuj+fWVIBGyQ4fDJDPXAhVMrxF9vwN7edClb2heMXEhJCa62vehF7T0lIg9MKmJ1PWygru+O8H3rB6ZZZfbRs4A279exkOR7Rb7fgL7HOOznkWhPMFOD+g/VtL82BOT+eU/4rodS6h1j7D8D8BrAAcDvAfjHAFZKKbN0vgXwTP/9GYA3+ndbxtgawATAvP+6jLG/BeBvAUCI2BZoZZr9EwfOI/EWvUDv79wqe/srpFIKkD14R0l6joWB3i/+9Bm6YsL6jIKKhqwG8lFtC7nZHHednnv0eXnU0RpZHJN17iAFW+/g7KlzNTJzG/4uZNfxGwOr4QDq+QzLTzM0MUP0KBDd10h3Nal1tztI8z5mAdOdh/FHX3ya4jDjcEqF/GuJ/Msd+Dc3ZP7m+2S1+2wEp2zhPKxoWJxnkBcjNHmAJiPfewCI5i3cUtgQElEU2kzO0aZsJTAeojnPsf0ggGKMclcBurFb2Vkf68B65vBOVOd7aC4GEJELEXC4RW82sN3TZ+6pLoEOy1WzMdo8wOE8hL9uwWsBd1vBma8hF8tuYD0c0C4siaACB3xd0GtXFVgYQp6N0Ka0W3CKFsnjwfrdg3FgPCDr5/0BarGyx4C/uCJri8sAdcpod7ZTyN60iN5soBhDczlEcRnA3wrEX6+gXl9Dti2cqwu05wPyMhqQl5FizHLb3YISyfh8TTufICCmy6GEM8iBj16ifJ5Z11Le0HVZDTiGv9xTN/647Ki3/R3sJEf9fITiwkewkYhuSxqU3txDRSEFBwUeWFGCv7mG0NcWm43t8N7dNQi/Wdlrwt6imq4LAJgNIX0PzmJH8aCjHM1H56jGHtqQI3po6BrZFtSh+x7QeJCrojNIPGH0HC6JGRXflPBezyFu7zSzzIGCtn05m5CafEufi6UxdfiuQySNVsI56PyHu0XX0JzSyDWMe2Se2LdvYJzqTr8+KQklcIzv94NfIDqbaFOTZM+B9KkdTxQCx6Fk3/n4Z14AGGMjAP8mgA8BrAD8dwD++hNPNdX5qbb8ve5fKfW3AfxtgHYA73X0ZkGQvSJuP9QTswJbzCUAp8Pfvgv2OXp0CWGybmgx4U6Xv1nXXTCKxqT7QzIe6qKlMTqb9xkG3UlVdCGrpgGu76kImSBok2vbo6dCqw6dPEX741c4TAO0Ed0c+Vrj3UaOXjcwnGTGGGQvJam9GKIY6W5bAKNf9lTCZQU8v0T9s1eUPHa3hf8r8sbHeITm8xdYfxxRXOGKmDy8EnD2FfjjhvjYGp5y8qzbKQxzVM8G2F95oKwDIFjU5AfPGFhRdmlPjINfXdAFb7B714FMQzi7CvzQwlsBfE3FwHDA+7befDqByhOIQQTpcpSzAMoBWS8bOKxuILRpnDOdEP0z9KGEJN737Q5isYJ7dQF5PsbhKoN7aOHdbGiY2dREfzT5D4eSsOjDAVKzRJzzM8hRjmYSYafdQJNbAf9XDXglwIsazTRGGzrw1zWG//cbiIc5kKVgr56jHUU4jHzsLolZk143VMRrAa+VpBZebGk32NTUHGgPKPlbn2L7PNTdvhaSaTYRkwrj3/uadllAx2AZZLTjTCLsPh+DCYovzb+koHrVNIBU4LMJPa+uoR4XgGZ7qSiAmGaQgQNIILzegj9uIO4orrTf1VqNh+sA+wPUu1sgS6GupiheZHBK0dFqTRiLsdguK8oqEILIEoMcajaGDKmsSZ+Op3tH0aZSKUvIUIbg8JKuMb490HkPA8iUYDfWCPBNQXOn7Y4WRwMp6XvdKPdZmhDMpudDars77tI1dGPrzXc4HJu60J9d2MaTdRCmmbnJHuHFJCa+Rx//nsc/8wIA4F8F8LVS6kF/uL8H4F8CMGSMuXoX8ByA8TN+C+AFgLcaAhoAWPy576K7dwDHRfvU9x84SvOyQ5FTwzb75BPjuN7WzK6+5mQYN8847rI3+zoBTVk0tE8nTY6UgHAcKwZjWWptpVVxoO9nIufMzkIqAMLODQDYnQvPc7CXZ9i+TNHEDMFGIv/5CuyOMGupdQkw7AOTK5okwNUUu49yVDm3uG/8eovkcUMmakLQbOD5JdqznLzx7+Y0XL46w+53XpFZV6kQrgScO4IN+KEBX+vuGwAbD0lwBUBJCYQ+mssh2sRFk3ISPZlglaqmQWxV06IxHoK1QitxC/reaQwVBmhHEcVoPu7BVovOd8hY8uoizDyPLAvOcsjAAa8EmFBIv9qAr/eQD490bM1CMRxQETKCsfmKrq8gACYjsA8uUKc+IIHoizl1vkJoaqz+vEod6wqiiM7DIEMzSaF8DtZIDP9oRUKpNEYzjSF0sfJuNvA0FRZXF6j+5d9ENaRoSICYV/lr8unx5wWUy21RVA3ZjEht0eE8u8TuN87QJFzrOyTcg4DwOdyDAF8JuF/dWOtsPhnT+9YN2CCDSiK0gxDbDyKCoG73ZOktJMTFCM0gQPjlg81FRhCAffAMYhChuIzgVBKeVhar4kDXpcGtAYuJI9Dc9aoGUx5BZqMXKM8T8Eog+dWClNC+B+U6RFRQylpLyKKgnfd0AjkdoMlDOKW+h6sG3nxDLqnWej2wWcZm18E2BZEAAKgwgMh1ENOhAeZLiEcqUcz3aScF2EWH+T6cyZjUx5zrLIY9VFF0hAPd0SupukXglHDiumC9ATFjjAbIhhlkkATdiDK9gwfjR8wfiwoEAWEyv8bjL7IAvAbw24yxGPR2/wqAfwTg/wDwb4OYQP8egP9RP/9/0v/++/rn//v34f/m8WQQvBFTmCJsdgVN2203+hFq/Um7fWEzP3COdxP6ZJnXMw+usWNjEnWaL2CGPU6qgx30BcCNL0kvFEL1Qp+Bju5lBkfmd5nnWiwargPle2jOMkjfQXxzgLM+ADf3lqGCQU7+OEVBHU4Ugp/PILMIxXMSXikH8P0EfscAACAASURBVHYK+bea/bBcURczGtpjhV0B5+YeSBOoixm2PxqgHHFylbxtEHy76JwgXQcyjSnoO49pB7BaU3RfGkOFLqTvwClqePMd4qqxOLo0Yjqz7XVdMgvTtEQMMtTnOTmEKgV3TSlZbFfQMTRD6SgES2LUz0aQPqfdSNmCFzXc+9L69KtDCdGH60wT4DjU1WqfeDbI0F4MUQ/oXAaPPV94IeBcnhO7BQD2JdihtB4yzPfBLmZoJylE7JIieFeDP2wsjVQOUrSjiFg27xYQ9w+QAPirF6ifD7C/pGQyXgP+XvZ8oGjnwYqSOk3GyMNps6HCf3WB/Y/PIAJyTvU3dM0XZy7ie4XwoSTB3O09lOwGw6qsqBEaDdCcD6B8DulwDP9kRZ2xw6ECH8pzwbclgm80hv7JSxvU3iYUgenuBYL7A1lH7/bW4gT7/Yl/vlaXGyGljggF5/A2NXhRQ3ku2pdTO5jnqy3UZmt1Ls75GeR0gPWnVJj9VQt33dhhstK+T0pIasA8UoFb+2nfIzoqUrTnAyjG4C4LsG1hTRp5ltkcD7laU8OQ52BZQjBfK+j60vbjR1nAus6YekSIBLedvrGMAPS8yrjTahq4hYv1YtDZyTjgQUDdfm8ADMc/chz9dR5/URrofwrgdwG0AP4QRAl9ho4G+ocA/h2lVMUYCwH81wB+C9T5/02l1Fff9/pPWUEcefD3RV/dk46Gq9/JFHqKCfQUA6hHCz3F2/qfyYhCzA6BaZ9wFoZUXLQgTPUMzGxncmIwZ1hFVhA1HkAmAapJSEO0uzWpXpWioWaaWr8Ym/50eYZmlqLJPLQxDYWZUkiuG/jzLjyF+T51YiFhxmbHgKszbH48RJ3S94/vWiS/eKDirSRYmhIzItLc7MeNDdpgowHqZyO0sQO3FHANRm5e31gV6AUA6GAuPh6hfkWWwyLgxH7RsBZLE+qyTP6wQwlWMo9xeJahHjhwD2TA5u5beI97YsFIdWSExqcTek+dzAZJxxGeCzHNUTyLwSSlXTnXjxDzR/q92RTNiwlE5JLR2uPG4sHWaG40RPHZDG1M4T7R2z349QNdI3lCWQNlBax3HatJe/i3gxD1gKwkmtRBG9JuK1i2ZChXaIGUhgYN152lCeQHF6imEXijoDjgr2uU0xDhfQH1hz8H/+mnYG/ubGAMiyLaeaUxVBJCcY56EpKBXVHbe8w416rtvovmPJuiejUlfUYpyPxOKQrGma+tXxUAe3yF5vXzPO9slAHILAJrBGHunqZTRh6RILT3DjtUNifDRIPKUY7iVY4mpd1sfF3CWx6Auzkp4OMYGA90QM3efg7DarLxmGlqoR++2nZpfa6rIVRJuxhtayEuRvS7lSCmmYF6TDN3Qjp4irfPg4Bmd0JakoO5F/q6gafEY6doxZGGoFfrfjheQD0hmGHR9C0XzM+OHk+EJbynBzD/1xMRmf8/FX71oSF6+Q6v62N7hv4FoAt+ORysGVff0e89SMp0BVlK7BPXgUxCOMstDX89TfvaFeTG6ZGHisHMjb8OPnmJ8irD5qUL3sBCPck3hMPK5aorWFlq7adZGICNR2jPchSXEdk3H3RoyVc35MuuU6MQ+KQZELob1wpi09mWUx+8VQjmFTE+NAxg1LpGQCMftOpVRzs2Uy3z18WEbwvKFjABG4xTPKVhb4xHFM04TYn7vxdwKokmdeGva3iv56QW7Z+fKDwK72aMQeUpqudD2j3UEsHNxhrY8ctziHGKZhCiTZzuOy1X1PGbMBDOqbt0HMjUJ1hM48fQpmSsqgk33u6sbkDGIcBB6VW+C5H6kB6Hc2ghA4c87lcV+L7q8o21+R6LQgvXQIGYMZVAM41xOPMhfLINz//PL6gBsWI3CfXsHO0wRD3y4W8ayyiqphHaiCN5W5CL6mrdsdt0UPv+wwH8VU27rM2BVLqHihbnutGU6NoOoRlncC4vSEAXuGBVC5lHUA4jnL3QxdNz7L3IWgn2uOrS4HTedfk8QxtxssNoFKLbEt6bR/K7EuLI/tmaB2obEnMPWhqw6HnzKAk2HEBMMlpoN3vi/mshphxnZH1RtHAe1gR/SXXc9Z/C0qee/lpJDE6wtjWTO5kDHP1+nxLacy0+evTha11bfpBK4P6jb8EM4L2h7pFt6ncV//4ioJXE/USwfv7nqQjN0j+Bjs0ThRZXVtvdERulD/P0TeHMbIDnGdHQADJO0yZwdktXN93Owqd8W3NR8ygEzmc4fDhCNaRUI6+QiK73gASxgXTcofUrMT5Grgv28gr7T0bYXVKQR/Qo4K8beL98BxxKsPGwE/TsK2C+OsoTXn8coxpyeHuKhQyvt9au2voR6UGZcrVHkrZGbvMQzcCHYkD81ZLEUT0TOGNz3Y/rtJbOYQAxydBmAUn4H3ewhm73884CQ39+GXlw1gfa4pclMBlB5hEO5xGckuwY1NdvAJCNgxwkqKcxnKKFuyo6/6C2PYKJ3EJQFvChJu69UkQRHUVgrSQTsvmiw2izlGw5no0I3mgkpMfBGwkROHA3JfhS0ziMSM7AA9Mx2rMcTeppu+kWfF1A+R5EHkD6DsVYrko4yz0FwGhzN7NDaS6HqIc+vE1Dn1soiCyA9Bw4hwb8zT3kam0pq8p1usGr59K1qf/N6sbmOaBpgdXGXqs8joGLKWToox0EJH5TyqasyZh2AUwIMgr0PbCqBsoKcrsjOm6WAWcT1Jc5mtQFk4p2wY97oonq+ZvSZn59SwWepTZb2ASz9+nihk/PxyOoPDmyrmZZSuaMqQlqB2U1L/TcQ1DqnNTw2VHt6fnyWwisqa3du31qf2ZZVU8uHGZGaYknWvlthWBhYL9vfxfw6+4A/iIzgL+chy3S3UHuG62pJ6bptlgrjZ89IcW2swXGwRx23BWaQmO8/IEj+wcehcfQBUCLRt1AiRJKs36syZwQlgJl1ZSua7sLFuq84LKiwrTdalaGpomZITEA5Tg2pJ0FAZxnl6ivhmhTD8XMRXJTd6KhHfH1hXlPx4EsK1p0OAd/cYXq5RirT3y0EUNyKxHf1QheL6DmC+0kSQpbdqjBvp0TXDLI0fzkOfaXAYoZh/SB+E4ifVsj+GZO3VGSdOEZAFSeQiQhmBCop+Qz06Qc4bwhz/7bJeTD3Ha3ZuEzMEffLwWM0wLmOhARBcI4+wpss6PdBmfA+QxinIA3AiLxUGcevF0LvnPoXExG2H0+huIMyTc78K/fUvf6/BLtNIWqiT7s39EAVB1KwPehrqaQkYc28SB8jmBZgRc1ubcWB7KInmakpC1q8G8JC2dRRDsoAMyjiEnlcrBaoMl8tLFDuonHPS1QGus2wjn5yXMU5xEZ4G0Fwts92L4EkwrtWa6PQQ33y0dLKlDagRaOA55naD68QD3yKQ7z/gC+2kMOE7ShC6ds4X15Q/RlxuCczSCmAxI+lY3N8eUGgm0FVOBRApzxVDLCKH1tyRHNQdzHA4Iv7+lnIOofYwnlBeidJOrGzlKknl+xV8/RTGPUOTVG0fUezj1FXwIAQor77Os9bFNjhF2M6Q6aqNQMjoUbmetSrKWUwP2CFvYkhnh5jmpMhdUe54oYdfA8gon0MSYOvy4BUWRzQFRBw2tjIyF3+655NPXJzCxP3EDtNa7vWaa9qQz5hGpQ1KnhD2VnPWPYheUTtfSJx/9/dgDAMUbW2waZL/1UuLLdJfS2Vu95+JtVtGfDYH1i9LBZmuFh0Ftx9QzCzADsydFQlcX2exYQACy+DyGAOCKPFZ1mZb6ngaROBR/mopVnI9TTBNXYJSGRDhbH/aKDSYyXuOgCqZ3pBGqU4/BygO0LD3VOiUrDL2pKFzMcZ20/bIKt4ThQLy+w/nyA/QWHUyv4G4X0HS0YtP0/ZpIYuwSD76rAR/ligHrowt1LhPddGDsAKvzjIRVyjY/2MxOMC6nBa+F7xD8v684KeDxC+dk59pce3FIhuquJ0QGiBfKqtVADawScuxVFWg5yyKsZROqDN4IgnMWWhu9xaAuRoVAGC22J/LgivvoksXz3I/uI6ZiG0x4nHH9dQMXEaBIezThY2XbB6Cuy7uZZCnk+RvEyQ5PQ8Y5uSvCyBS+oAMo4AK/bzpZit7dwI9NKY5VE2P5oCOlSUI1bEK4PANLjCG8LsF9+Y2EeXJ3RbkCzp9x3C72T8siJUynLejLW2aqs6FwxRgl2gxQiC8hH6PaRZk1GwaoDfVQWdzsGoCuo+hpoLnMoxrrZws2cCq/v0U6bMYJDt9uOihlFZP/tOnT9AeTmWZQ2KpT5fseS08fKmU0hLscoriI0MVGq/RUpldmhgg2P19Gbp9GMzHGO4FG21hneOnntaNZ3Av0eEVr6Nc3onPTDNIBHNaiuj3YUttkV4oczAzCJYKfOeO8NhPvT96ecQ5/wzT59mAIOdCfLvl9P4m1tHUzh74swzGRfdklAzHM7BazrEudZSHo/7ZgJ4CgAwg6WjF11HIMNczSXQxzOQwifwd8IKqLLPQ3JtKjGMghMN6Tpp3KSo7xMsb/wAAZID4jmEtkvV8CbGyuEYlFoCz+LI+s+untGLKJgrZD9amtjIS29TrMlDDtCralIyxdnKM8ilCMHXqGQvN5RGPtqTZBWltFNac7lfk/nwfeA8cBS7GQWUne5LoDlptsJeS7YaGidOZkCvHUFZ7EjOmkSURRno/N0twV54Wy3xNzSNELlch36oheMAdE0pc8hArJ6Du4PVKh3BVgakzgr8eAtSjgPK8KN4xjy1QWqSQjeSMLXAasolr5DIjQN9ZjrAADYdAwxSrDXNF9/J23aFltriEszwlTg0oB2V3SKaccBPnoJFXlYfZagjWiBdxpSsTJF7CB/VcH5xRuKe5xO0HwwowG0ghWlsbKi82hgO5OZYPQl2iCNuS4x1XyPIKL9wSZlsSjqbDv6uHwvRtGcv8PHUzS5izZgGHyxh/PmXpsoMrL09hy70zJOm5aDn2ekKk99YosVldWHkABR32NRBBP1yCdjtB9fYvcywv6cY/hVSwZ2UoLtCur2zb2kNSZHYtC+WVwaWx2LOtAu5qgjB46so40mCMDRYmJe29YkgzqEAc0V9bzv1P7BNsW6Xvyv5d/54S0AtvCbg9oPWPmuYS/wXvEHcJym9T3uelbxC1jc0AY9aAsIg9/1w5sZY53LpbYptoPC3d4ycMwQyTxOuwOTZoVBhuY8txa94W1BtsbbnU3HMmwj43bJswyYjVG+HGJ/6cPfSVo4tgLRux34prBeKCwIaNtsuhqt7pSjFOU0BJOKIgp10lOfwWLD4LcF5PyRoDftRb/4WY7NRwzuAYhvFWb/1zWlTpkgHN3NoWnp8xu4RxuJlRcJBaXsair8j6aT86z/PRwOOUgoSapqyfisFcTvDnzLKunPQngc00wi8CCmGdrEAxMKvBbgjYRyGKTL4exJAcpXW4LnBNElxZgsIvihIesFIa3fTHHuU8d+V8LZVGBCUMLbMITwObxtY0NYjA9S3xdI+gzhQw3/3bITA06G3Q5yd6CCpkVoUJoGrCMeH3+aoh4yJNcS4WODauxB+JQXkVxX8P7sNeRqDWc6wf63XmJ/4SKeC7h7+u7efEfDd9fpbMqlInsL/Xd7z0xGaGYpvIedtYc2hoAsy7r7VH8P000DILhFRz8eZh4UA8JFi+j1Gmy5IdhwnNjzYDOF9VCY5RmF80wiNIkL5TBE13vwtw9HDRp9BtUtktr+pH42Qj30EMwrmvGUNWQeW40Fbh86zF0/nDShxmSYE4ykdRhGl/CeE7GuL332zhF9HHiSEGLrj0E3fI/YVNst7Tji2HoNWXqoLv7/b6wg/sovAH0IqK8BeCp16ynL1e9SCn9vzrA5AZrlA+B9Tw/9ODJq0hDUUQShHuJBSbsrsAHkmtF0uo1jYUA+6SC4SEUBRRc6DnmlLzc2mNt2yqZLaWnYxccjNC+nKC5DFDMO3gLZm4Ywzeu5Nc8yzocsCmnACQDTIWTsQwYuYcuHBs7jFmq9tZa4dvcF2B0LADhXF9j81gU2LxyIkEK3k3uJ5Nsd+LcU/8cGOd1AAOHHBW2rDVVSJgGF0OhIQMN8AtA5MgYU70g3gepofgDU5QTFBzlBYw8F4cbrDdH7sowGfgCk7wIutxi89Bn8dQtvXXUiq+3WmnixMADTOD4A+i5BAHExQj0KiYl0kPBXDRxt3EcEf9CfDt34fHuAWq4pxGQyRvtiinrggzeKsPjrpX1tE4ACISiY5lB27rNJTLubNICIfdRDj6yc5w2YVCinHvbnDkQAXPwDyr+VjwuK//z8GTYvaWHnuv8wixavaLDMyhpysaQGxgw1XRcq9NHOcmvbwYrSev/02VkA7MBdFYcj99XqgzHqnMLgoYD0dUHX2L6AOh+jHUQWqjpSmLct+HiE4qdXOEwcuJWi8/xYd8lmxYF0LVxrHKqOes3zDPJ8DBH7pC+R0kaBNqOIVNWPG4iHeVesHYcG9wHlQ6jQs/bYNjPgpNs/DXw3zaG1e9dQUr/4P2kweTI4NvXB0MmfZA4x/sNcAN7z/+kNT4ATzu33UT97fx4JxoD3k30AO0ijNznWHlhaJ2Cxcz4e6ec11HVolS+ArvBrVouxjma6CLM06d63abuFRzOBLBYYU2FQ+73tUEzARXWRohq5kA6DUysEywbW8rbnd6Pa1jpewvfIPyUJKXXLJyqiO98By82Rt5GRoqumpZCa6QT1qxmWn0dYfwp9QzMMvm6Q/NE1FZEgsDsF65lyqEg7IBVYlkBmkU2ZMvCSxbPHI8KNAVoAi8ORUppnGXB1huoitV22/8UNQVRJAvnyDCLu8H3lckifIhzbmGiF0mUYfFHA/eK6U3saUzETNqPPAxsNUH44wWHqEe9+KynjVvvUKN9DO0momO4qgkVKshTgWQqcT1GdpwADsYw2JZ1vM7NJQrRZQDDR9kC007qxudFiOoDIfQiPwy3aLqIxClA9H+LxpwF2LyVm/xgY//5byMUS/HyG4tMpmtTR2Q4Kru4j/J2Et5OIvloADwvaqZqiHQZQaQQxiMAqQf5IRQ12t7AMLWMBAc+FjH3qoPWOANBxi2cTOwNqQ4booUX0zQpsTeZ9cjpCO4nsd/JuNIW4qmhx1yl0858FaCPKrB58UZCiXNtT6JuS/jRuu0Z0phXlNqweoB1G4NAOY74hywidr8CSBJgOya3UYWCHmuw/2pYonH1mX8/y5RR27s8ElY53/U4LaHSNp9UH+D4dP2jcvyiO2EanDgZQ8oczA+jnAQB4uqj3//+7Cv/J75tBCtBBNv2EHzOYOYV/bJDISeyb3Z5HulD0k7x6VC3z+n3VHzTl0VgkQ0qCMEwwOdCxlPTwuR/KzocDiGdTlOcxREjFjLcK6Td7YgMtVl1KmMOtS6Ta7+l9JyNUzwdQDPAfS/Cy1pS4Xedoqred6F2UOJtg/+MZyqGDJgGUw5C9bZH+yQMwX1hqHh+PbIgKq5suVF3DL9UosDkH3s0K6vquEyvFEeR0oOmDFbDadH5LgIW5qhdDKAYE93uwN3eEbWuGVJMRZTK421EhDnyKdxyTj5JbSIQPByoAD4/dENxxdDg4ieTgusB0iPJZjs0rn2YojwrxDVkLm+8kQx9cG4thRQXDpIzVn15h9WmIasgw+Fog+6N7Ys/MxqjPE5o1SMDbaB3D/NG6chJk5UPmEUToktBu33bv7XtoZinWn0RkCvh2D/zpF3CeXeLxdy7glgrC134yEsi/2AISaMYhsZ2KkthHxuP+2Tn5KHlELfUf9nT81luyYdBiR/nqEtJzLFUWTUt6EynJVE7n9tazBLyVJAzUsacsSSAnOWH72vfJqqq1yhvjAZb//ASHKd3HyZ1EfFfB//bR7pQAaGPGuoOZ9PliZY3227dwX70gSC0MIEYET/F9eTwkdl2wD56jej5AkzqUf/y4B27uj2zFaVZGAUj9brxP7bTXkPlsmkxisXsDARsyihZ1WZGXiY7Vzr2WZBIGx7oisxDUNQyl/Qe5AwBgDx7ZNwjLlnnvcdLlHw2ITw6i8egHcFTMj46NgXp0R2g7cc/toAddnA1P970BUI9VxIKAOkHjCiqkpYLa9zb8Zv3affzQCHPkdITqIsHuGWXzJtcVdY2LLeTjonMp7Duc6u8hP7pCMwwpX9dntA2/WdA2vJd+ZOcQQhAGHkdoXs5Qj3yIkMPbtGTott5SspVmWdD31ouxw8lJc5hBaEdO6TEwoSgS8XYP9u4eYrGiTISxTrdymHaALG2SFL2eA8zGaCcpmtyj3399C7ndwplOcPjpcxTnHg2d3xZgh8ZmDMjQhfRdVNMA/ooWHdyTKA1RSMKuwCcGifGiCX1UVznq3IXwGYK1HqTOt/YUqyQkyuT+YAOAmO+BjUdQUYB6lqCcePDXLQ119wdSMT/PIEKO8LGGd7/rFt/9nrD9LCFzNc9BGzsIHkurx2C+BznKUZ8TtTa63sNZ7CBv7sCiCM1vfEDnyWcIHxsUFz48bS8RPBR2MI75ymLkhgJaT0JajNakKVDzxXGc4uUZZBpCuhzezdIK+wxchvMZ2klCrqnrQxfzaOiWA4Li+LawDYO1/s4yqPMJDi8zbJ+7qEYM6TuKl3QeVlaHAIfbjATVtJSMNhkTlBh5kL5DrKy6IS8hhxMLTAJ8ubH230oqOJMxxMeX2L6KScX9UMP7p99ArDfdvY5uNtjn5DPHoWZEQ73gjNhOSkGtNxbGOZod9nYLfcsbHseWMmyYRDaFzHGenjWcNL0/rB0ATuCfU7oUTuAf+8OTA3TqLNpjA9nYuN6k/r330mIMywTSv2ffoi/htjoFZaEScG67cJal9Hm0ehLanMxCVOa9xXEQPBvmJJ8XCofnmX1va8G8WHbdk+N0trRVdZSctf9sjHLoIH5oEcwPVGDvH20XZDMHzIyhbijn9GyENg/BW5LDO8ttFzJiQlaMn5HBquMI6mKG6iLB8kcBmhRQDjD+uUD2x3OotzdHIeYyctHGLtyCPP5Z2dhgbhMSryZDGtbN14TDtq1m84w6Q68tDWCN77+ItemXw+AtDx12XdeUWXw+pAD1kCwsnE0NJiVk5KEaB/CXNXW5yw3tFn2fRHtN2yl+1xtd4BLgbIz9RwNUA06L89sD3DdzOt/jAba/McH+nCNcKiRvS3g/f2NVwixJoM4naIeE0zv7mvjoZQ3VNFSAkgjV8yHAgOB6Q0rhQ0kpX6/O0SZkHU3DbQWnlth84CNYS0TzGt7tluIXje12HKF9MSVIpCAvJcMOs51vEIDPJmT257nEFjKRlnFE5IE0QnWVQ7oM0dutVfSyscblo4B2Cn0PHWOlEkdgeYbisxm2z13UOUP2ViL7mkKJxDRHPQwsRCTvHsim4eqCfPtDF+Cgc9eIDu5xuB5eK6sXMRCic34GcTVBcRVBcYb0V2vg6zddJOsgp7qg5019+iX3PWr0tObA0nB9v0MBzH3wROE/xe65CaUx5JC+Wll00ZBH9HYcLyA/vEzgPt51Mlx5T9F7mgcAPDnsfTJP4Lueh456+uTQRb9Xn6nUxwctY0UpKwSD5vfbGUYQUGHTpmX25APdbiGOKJR9FFluOytb8tnRw8p+uLnU3RpPE6iXl9h8PrQdt1GRum/mxCSKQjLLAuznVIaaqD3fxcUIymFkQjdf2VwCC2uZ76TjMFmWoX02pnzcFxzSA8K5QvquRfRuC/zyG/p8l+e2w3aKFrwRlsIJwA56WRgQ9FVV9mYEiDqpOCOP+FbQc/IE1VUOKIALCXd5oIXkUFneOstSYu6cZxChQ1j+qoaIXECBzM0KQZTS26UNewfM9p7TddDPivVc4GyK6vkQhzMPTkW0V2exoxzh0MP6x0OK53xTUg6tgV2ShHyfslDnBrtIbiuyH7jWi3MU2e6WH5puSL7f06JxOUE9S6CYXug2De2iXI564GJ/7iC9EUj/8B3Ew5wWzUmOw7MM0meI3xKLRm139pzygIJ4YGCLOKT3DTy7MLPxEGKao5pGkB6j4JXX11ZMKCc5dd37Aw1zDYznUAQjG49QvRzTMN6jeUzy7gBWCcjQhYhd1LkLb9si+uIB4uaOuu7zGeqXYxxmPqAAbycQzA9wlnuCe1xX5wZoKu5ub/O3+XSC+uMzrF+FkB4w/pMCzj/5FTUjJqNDX4NQsmPYAXY3z+LI1p9Tyxer4n1Cu9SvGf254ynq8J547LvIK/3rEviB0ED5RP01/q892dl/L5NHPwfAkyvk0c97z+m/tnXlMye0d5xsZ29VeaEdDpuTzIOA8M8eW0bcP1gr6L7QzHq0aAm9+bwsScDS2ErtWVnTAiel9SIxi5i1hjALZI/fXs1ilFOPTLNuKHUKjyuCoqIQGA+hIp+GXFoKD8chxsYgQztJAAWyDdjsaUur81PN8TAwEx8NobIY7ShGPfSxu3IpS3irMPr5Hs7PvyW3zzQBpmOiaYYUHwgJihU0/PCebw+ArmsDLHUSjJFttOfZIbHJ9RWhC29bE6y12drFiucZ7WQGkcXR3U0J5buopqRXUA4ovP6bB7u4GshOFQfiwpuOzCwGszGkthbm+5J2Bk1L84/IRzMiSItXAv63c2Im+R4wGwOcY//hALxVEAEDbxSpdQ9UwNs8hLPXsaFah2Ctp+OYXEZHKdoBuYyyqkE9JfhFcQYw0IxnWYK/vgfzPdSfnGP7IiCYrMfSAtAFng9zYK1tKTR0A8+1WD0LQ6g8RXNJBd5/t7S2FzzPoa6mUL5Lu4m7ORV+3e3z0RAqjVG+GFiNhL+u4Sz2BCfOxth9NkCVcyS3LeI/voa4vYPz8jmKz2ZkBCdA9hA7AW9Tw5lvbBMAIawGwVhLMN8HP5ui/GiGzSui6w7/bKtDaHaU5hf6wO28a9YAC00BsJnVdnH4DpsHK6A0ep4eFG11RTZ7XB0tENYcTqu537O0+Q5rHHNNwoA92QAAIABJREFU/kCsIE4WJ3MQhegSwr7zV+XJP9+3aH3veT2aqQl+Zg7d3Awg8Za+6VTTWnqXoXUBJAe3wRqGHllR1wkhILW969GAyKgg9TbRFhrfg4hpwMV3BdRiZXMGjCeOGfyYYZKTJqRqHaQozxJimVQS+a+21BUZ2X7g003uuVTMFisdGs4I281pmC0CzRZ52AD3j5C9EBzL5nFdq1WoL3OUEx/SJXw//6ZGeLMDru/pGA1yOOOR9YHh+wP4/NC9ju8BYQAcOHW7WiRl3UKztKPS+R5h9NpzX8Qu/HkBdqjBfRfusgBu58Sd9n3y/Y8jyCRCm4dgQiJ6vSN+9ShGcRlRsbmjhC7Ml7STGw2BOESThwAD3KWeD+wKsCiEmOb2EuLrghbRuoGajVF9OMXhzEP6+kAWG5stwDhUU9uAcek4aCcRUTJrieiLBcUPSkmJVELRQlSW9Lq9RZ8PRpCjFM1AZyWsdcYEY/DWJfkkNZIWfR11KD84x/LHmQ30yf54DvXutsuDyLLOj0oqywiC78FoNgDQ8zQ7yLvZQL27pRAc34NzeU5WHbEP93FnYT6mKZXyaob9RYw6d+AVknYMd4/UNYch1HSE8lkKt5DI/uQR6s01+V399X8Bm5cu2gTwNgrZW4Ho3Z5MEw1f30S0KgW1WFrBmHNxjvrVDOWM7qnhlyX8bx/Je2g6ArIIbLGFuqfibyzDVU16Cz7IiX5s8ni13ubUAppx1sEz/VyRE0W/ZQX1LOY7KCiyoVNPQUb9eYSlxBvGkO8D+++sjEePv+I7gLH6a7yzg/5esddTj6cgoD5shJOtlf53X0BixWBBYE+4weRPO2ArGtP+PUA3vDXc3r6VtX19jXuqwKNYOlfTygycocPNj5LBgG4QrSmkmIwgRlQwROB0/P0eC4glsaViss3OBnbz2RTijHYLTcoRLFr49zoIpKxoe2sLv1Y6a3dPjIeQWWhzU5XDCXIx2LAehNqiv9rqwbfodjAhHRvluaRwXe5op2Foq+MR5DgjKmfddopdTdFVnmvtecEZ4PnWJ1/95CM0eWAtlc2QTvkuROKjGgcEjRUtvHd6IBwEwCBFczGgZCsAvNb2yLWmEEYeCcWk7LKIpYL8+AXqSYjiwkOwluQg+vrBMrrg+VDnE8jUp26XMXLJbASU70JxDpH6cHY9CwQhaMHIEgt1GtqsdLT//7wAhKIMBs8BU4qiGxdLwHXRfP4Cyx9HkC6Qf9si/nJpQ+MxzK0ds2FpoWmPdgQq8DojP87IEgLk6qraFs7ZDO2zMfnqb0ryD9K++myQg/k+FeCpj2rAEawl0q82YF+/o/e7mEEmYSe82xck8ntxgdVPMqw/oe8Z3gPpjUC40EPzxdq6nTKtHJbLlY3DNM6nTe5BOQzBo94FtwLifEh25rsS8vq2C3TSWhO107sfqUjtrHcTRun7Xq2x/+ycCvoWMwA6w0hT+E/mjMY/7Kn36LOM7GsbtbCeM6q6/oHMAPhE/bb7rz+pkjt6nNo8/HmiME2Vov8+wdZ6J/LUfuL0+Ufq5CA4oor2JeNPeYEYla9RM4KDitpyQ/TPXmdvKGeqrrvIQ8bopopCqIDcQWUaWmEO6oasFgzExPSOQXvpUxAH5f3ufnKG/QU5gZqUMOvvb4auZdnxrI3oyvegrmaozhL4awrxwLtbmgPEMTBIiU2jxTZ26J3GUD0rDta0kGlAN/6S8GGx3tBO6YPnEKMY/NCgzQJbcCEU+HxpZyYAusVZd1bOeAh1NUM7iOCuD+DbA8Q0x/5FjCqjway3l4hfbyx1lEch2UoMU4jch3TIpdM5NGB1Cxn7JNpqFbxVaS0teBSi/ckrVOMAImRgAgjnNfyv7+1xNN2tHGaozxJrBwEJ650DoQCH2eNvh/JRCExH1pGzmcbYPfeJS/92axlF7YDmQ8TmIuqq/OAC+w9SKA44lUJ0U3QZC5EJr5fWT8g2QELYmEPr3FlWYLsCQtuK8yyDenGONg9pKF8JeG8fIe5JjcvTBGw8wuGjCaTHoRwG9yAQfvlATqUhZVfIJCBr6TWx13gco/3ph9i9jLD8nJNb7K1CsFIY/HIL5928g2CMAn+3t7CN1R28GqMae+CNQvanj0TLHWQkrPRd8M0B8tu39FlHI5sHbBYfuq6kpXv2h79H9gtGMKaFlU+5hZpAqH49sTXFkEZOLB2syVt/0eg998ipwLgS4AfjBqqOi795nHb2p4uC43Thy4bp04eNDJb31ELR+7sSeG9xof/XRnCKdc/TVDLzukdZAaK2zB4AdtLPAh/w3K7bgQa99CJiqV8mScyYWV2dA46DdpzAXZAQh20PcDZ7oo1p+iG9WRc5qQDLlmk+ukA99CECjjolpXD6rkbwdkUsCaWOt7taDWvtbUc5ZBJCpD7hygY/dnRIi6H4rfeWCmoUuMrlpPKUeotcN3AWDdSq6/jdqwt6rlJw5luwQwWvzcBWW5gkLNW2NuAE+ruZh3t5jvqjcyo4e9IjFJ/NsPyRDxECybVE8q6E/25JTBLfg3M2g4oCyNADr1vwuVYiOxwqCSFj2i1AAcH1GniggHDn8gL1RzMU5wHcQiJ+V5IT6HxNcOAggzEvk8MMMvXhPxZgdYv6PKNg91KCly2cuzkt0pzRcb4gDF25HOVZTDYSj3t4iwKTbx+txYLKEoKK3i5INCYVcHmG3edjVLkDfydJF/K4JQjH96BGOdhaayO2O2L2ME625HVNdtlGu6EUZVZvifZqbJqbiwzC4/B2DdwvbiCWKwhDrR4OoM7HKM8SbdOwA7t9JEjPcch5dUbwmff1LcScaKTGo2f1aYwmZXALIFgojH5RWsquAmxjYyBW1bbgkzHk8xmqAdGMwRixr+43wHZPO2DGiCa9WEKUFZzxkLB/zwUOlfUtUof6COJhnB3ZvQDo2D2GgBIENmPjlOZpa4f5vRMGocn3tbuAurZpeQBsc0Mxmj069AkMRbAQfq3HX+0dgEkE+3Ugn+/xAbJd+yl3FjjWEnyPiOzJncJTw+lectiRhbSxeJCKGDfGjdAM8vqFvrd7kFXVGcwFATDM0ZxlNvKQPa6OnDPfO596x2GyS8uPZ1h/5KMakBAp/WpHPGzPJY5/K2hoCGilLoV6GG94MUjQDgIozihZ7M0dxHoDJ08pXSkOtRioIWgmCtCeadsHwwffFkRl1PYTR6pbo4ZuhaU7gnOoPLEiJDj8SBUNdBRcJ02Aixmayxx17oG1RH+khC1OOQm3B/DXd/SLwxwyj9BkPtyiIeroekeD5SSGOB9i82mGcsQQrBSGf7QCvnp9RD08nEfktLlv4RwaEk65HExI8ENrXT6h4TMWhZBpjMML4v8Hywb+n721FFI+GgGjHCryUU9jCJ+uQcrarcC/fGd3cXw4ODY7CwPID59j/ypFnXIEG4HsD64JhkkJ/lOOA64D1uUtBbXboB4hIUcp+KagOcDuAPkwJ9sQPUMR49TCfe58B9zPbSARSxLrHNrMUpprVC117G0L+eoSIvHIX39RgD2uSC3sdCE3zeUI1SQgF1QT+nK9JEhUqSOLB8PKcS7O0byYYvNRBN4C4aPOMp4vqZmJI7pm9nvKTzaFX0OvynfBap0+diihtrvOOt3cm5oObe/POKb70tBkPbfbJZzUBuuGaiBlU37Mc3s286cun/bnGuLpexP1f97/9w9OB2Af5vOeFu0nfH/MwPjo8T3U0KeKev+EnUa19ReUvp7AnFQ7xWfMhmCbi8UIxvoDYbOqHyVYpUQNFIOIBDcPOzLoMkwU/d2f9BbxXPAohHp+ifo8QTUip8VwKQg2uHkkeCdP0U5TYvo8bKCu72xxNVv48sMJ6tzVXvLFEfTBtPUF+dRIMg1zHagkhIh9KJfDu99aOwTUjVXZAgCa2vokMd+3sBNiMqSDkHRj9mYCfRM+QzuVHz8HayVE7KNNXEiPzo2/rqlQPSw6dsV4iOZyhPIsgFNR8fbfPNKg3XHQ/PQVds8DHKYc8YPE4I9XwNdv6HcnI+KcJx5YLaFcbgNhVOSjzQKyDqgl3FUB3Nx3BoJ6FtJMY4JL3lBqmRXPMQ51PoHIA7hz6sptHsGh7Lretu0WgTShKMofnaGYuXAaipE04jirZo5Ig6IcB+z1tQ1tYcMcMoksDMW3B6KmHsrufGSJhXGid1syEryfE3SUZWBpTOE8qY964CK6K+HerTWdlENdTrD9dGBFcHhzY/OA2WgIFYc2E1iEdF14+pyxMIQapARtKgW1WkPu9nDOz9B8MMPDbyWIHySYpO8d3O7oufp6hJK0sOkZnjU+1LtYFThgrSSqrx4am/vHOgNoppeFXAxtc190WR096/Yna8xpTWIcTppAbLdwzma0oPWcPo9/tas579nfmPcyuxCl8L+p//4HsgA4J0NgoPuivWL+XqDC95nC6f87omWdwkE9ubaZxj9l3mTwN9uN9rm95kTpzvypvAITTWc72PGQCp42+lKBLpKGQ2246Ccr/mngBE8T4GxKlsY6Zaqv+GRBADYa0LZXpzSZ+ERnNISaDNGMIpSzAG3IwAWQfbmFc7eCeJhTRu5w0Fnman8cMcnQ5D68Nfnc8/3BUhat0M2Yt5mPrymWapSjuszJg2hTgq22lvN/lKVs2CTaEVIlEaRmSzFJN4KMfUq4KolDL+7udUBNBowHUIH2rClqChEXEhjlKD4ZY/vcBVPA4Ksa4c9vIO7uCTb78AIicq2vf5+WCyHoWAQeeQHtCuuYyi/O0FyNsPmQutP8y53t4vlkDJXGaMcJeN1C+i5k4MDdajtrjUezRFNcd7vu+vF9yI+uUDxP4FQkcjLpZBCKFg7fg8wjC/3YUHWtOdh9PqbB6EL7RS1X1M0HAfj5DM3FAMrj5Ma6qzrhmM6SVpcTlJcpeKMog6FSiG6JPgsA4nIMEdCOKPjiDuJhbvH5+pJ2hk7ZwtkSlKcch4b5ZmAeBFafIueP9L6XZ9j85gSPP3HAGyB6ILaZu2/h3Szt4NoIEvvuvXw4IHPFJEQ1i+GUgpTC948Qu72FeI48uuKYQuA9l3yLtP2LzfDoi0eBY4sG9OaF+nlOltkdD5oGQseLPlmHTuqVaShVD3I2NaD/3B+MFYSxg/6+gm5dO/t8WcbfXxhOhjFGvcp8/yjY+VSYYY2ZerbTFurpCTxsHnA/J+CUcdRjDh35h+iull+c0fsGOmmp6uyiydGSMHibdWp8SPR34ZMxhZtPMp3cJOFotSxMUL3nwZrVFUXn5Hk2gzgb4HCVoE452pCOQXJHjBH15rqzsRgNoQ8Q4HsQ4xTVLEYbcyom38xt/i2MsCZLu3AcJYlXHoaQ0xEOLzK0MYe3E4i+fLTwk7kx+t0VDwOK0Iz1TsP3AIfZ3YZx4jRe+XKzsQN3lcV27gDtVSQux1j8JEVxyaAYMPhaYvT7b4hzfnEOcTFCMwjIa+h2D77c0E1o7KZ9F7yoKPN3serYWYMc8sUZDhcx3IMg/r+eOfDREOJy3LumdZSlUPazW+/9tj3qZFkSo341gwwcVEMXYED0UJPHznoHOaa0MWoayk7bYeYKvmeH4YoD8bsS3ttHyIc5sWAGOXAxRX2ewd03cG6XxHDSlEg+HkGcDVCexagHDuVHFwrRfYPwqwdi11yOKdt4U9GO9fU78OkEzcspqgnNUZRDwi1vUcJZ72kW07+n48haIfAsQ/OzV1h+GmL/jIE3NBcYfNNSopzm/5tsYGva6DgWulKea6MzoUC7nbsFxHJlfY2UtnXmAdFhMUhtKiCrGqu07ws1bU05YfdZY7/efc6zlHY02vpcrtYdkUSnfpnfP200bU06GT73dxTmdX7v8N/8MBaAUzfQ0w6/z7d/arJ+xK/tfmj/2k8D63ftdmU3NEXzf6cufH3v7h574oj5AxxJ6ftUUhsqYUJYmoZeo24I6+4ngkVhN4jWLqAG5rEZubMBWN1SIbxfQy6W3XGKI8JPNVvC5AmzLEP9aob1x6G9mf2tRHRfw7vfEi1S0VbfRldWNXHqRzlEFkBELriQFOb+9h5yubQXvTMaEosFIAxVu0YawRZvqGvn25IofQYK0xf6e4E7WrWs4tCGtjQZ+cHzWpLPzt3CdmjObAo5yW2mMdsdoNII2x+PsXlBoi9/q5DcCKT/6Fu6KX/6CTafpHAPknz91wc6P1J2MaFS2ZBzVjdQj0sarj47Qz2JIX0SNwX3Bxs5yS/OrA89FBDd7MEqQXRb0b22igKw1dbaXJiOXIwSsrRQCu6qtF0+HN5FNYae9SSSyxU1GNp0rXiZQ3oMImBIXx/gfXVLjB5QVjGGOVQcQMY+nGUBrDY6GtUjq4zEQznxsbsgu+/8W4HsF2vwXQGZxiifUUaDv6rgfPEOcruDc3WB/4e8N4mVJEnTwz4z3z3CY4+3ZmZlVmV1VXdXz0z3zGhAUBgQIMADqat0lQQB1EW6SjoIECDpQEgn6iYeBJCAQEhnQQfyMgcRxPQs5Aynu6u6ttzfHvFi99VMh9/M3NxfvMzsUQ/IKTnQqM54sXh4uP32L9+y+MkR0iGnjH1WwZ+TqTwqCWexgVxtIOZ0r/Jup+7Tj0fY/fZjXH/mIZ1K8ALovgBGP9/BO1/QvElBH425kko44HtgSRfFESUr0iFpc76g7yVWawr8YUAy14qd7Dw8hUgiSiCUMJ7J+C3xNjvBvFPxt8ThWLdDa58xyPUa1XJ9J/7YG4Ed5O1414hhe7gBul39z9b/+Du2AdyD6a8RPpa86jukGmy4qD4awR33tJLah5XZNyoMLTMBNKqExiYB1O5bjANFXuvnqKrEKG+GATSKSGy3pg/JB32ISR9Vh2jwPFeD4eXGcAdYHJGm/O2y9guwZgv5YYK87yJPyNQ9ukjBd6XJaO3BG6QkXLSQ1AcfdVEMQsLQz3fgi80dOV0tVmaus+cgH4dwCkE499fXhuGrdZYMlNaauZhSXLlwCc9BOiUN/eCaBPAkYzT0U76yWkY6fzwltqgSBUu/d4SrHwdIpxLJN8D0T5ZgP/uaNvUffIj5p13wUiK+KBC8mIFlBcSwa9QsUUmSD1aGPNqgRD4+werjPvKEAxKY/PQabL6kzY8x8m7ukMeCtyrgrjKwTQoZBpCRh7zvk6je7LbG3ytiVnU4QBV5NEtRxulwHCDwjXELysr4RMhdStdLXf/0QYKs79Qidl+fGTVY1ktQDTsEw52t6gG97yF7MAAvBIqu2mBLCXdX0m93s6KgeTTF9nEPwmfovNiAP7+A3G7BHp3g5ncmyBOGYCnQOSvg7Ejfic9Wta+E55Lr2PXMrAE+HCL70SNsjj2UMYNwgXAmEV0VCM6WJEWiq3bN1K9qOfZqOgATAsUwIrjtglqK4nZRwyf1PanaKe7BBOJgCFZJ4HJGG1I7894XP1paPWagqyRUjFOeml0AtZijvlf1uTc6DW85bLMYHb/stfPd4AG0h8B7ev/meJtkdPvQPAB7c/Dcps6Qfs/2e6nX7tso9I9iSrkWokeXiZrFq8lURnZaZy7qhtLB3v5hWZKQdr7CZcvIU45JGS0qBSc1g1THaSgKmlZIHCJ7MIDwCefubgo4s00t1RyH1DKweAmyLGmo/MEJ8kkMyQB3Wxqki3YX44M+kWYASNeB6McQHicD89gDrwS8661hB2tss75Obdo9tDlGr4OyF6LoUwYczLJ6w1OBwBCCAjX0VC5sbJdBRgFWn46wm3B4a4nBzxfAVy/oej19ZEhVWj4CrgPRiwHGSFkycOCsc0AAzuUc4mYGkRdwT45QHY9Q9HyUkQN/VcA7X4Gtt8g+PlJyCyTAxgql0+STxDIASAY4hYD/xZuacNfpUN85CiAdhqobUBDbUGtIesoqMXDBzm6MHAGLCM1TPBgr/R/PtOX8RQ7n5SVlvr4P1k9QDZOayJbnBGKYDA2ZbPE0RjivwEsJ/zYjj+DFEnAciI9OUUUetscB4osM3p99Q8Hr6SPc/HgAoZDI/kqi+3xHBjLzNRHI0ozaq50YkjPINxeU8fd7wMkBdg97KLoc/m1JvsmKfMfSwgzzbYkWzazFwQQypA8u+xEREi9ujKy5IU1qa0Uh4fR7RmSRr1OI88vGIBjA3bXcrvbVpmBIZEosDwAh3VRFbNCAjDd9AezPaCWr7c6HMYS3yaG66lCv/87MAO74AdjHe+r60MP36Aa1snjbK9i2jNQ/gm1JaUge9oDG/iHQ2qm1NLMlN60HVBrqafD2QG3UrQZGMg5JlwcAJOC9vDY2kNoVjGlFTgV50zc5j0IagHUiQvwAZFaiA+hmQ2gMLa8gpcludfuI9RIUR30sPiK53O4rGvaJm1lNQz86ILXSlOSXq2EHwnchfV6jYl5fGFlhu2ytlUg5+OGU7Pl8F9k4RBUwQuusC8qClXG8Nv3Q3rIIAsjpCKwoibEaBSgmMTbHAXYjjmApMPjFCuwX31Jb5MEBssMYPFd+AbcrgHOUpyNF6iISUjAv4c3J97e6ujaesBgPIIZdsKwAX24pC+9E2D0eoEgc41blLlOqfpRzGBMSrAJBHF/QNQQA9ugUohchHwRENpttCZK52RluhxwkhOW/mgFS0D2k4LOiGxtTFekwOBlt7vzZudEO4sMBtLewOLsAn4zp9hwlhtAlHVZXdhczavl1Yhrqxi4R1hiDO99BfvkteK+H5e9/iNmnDnkyr4DkdYXOt+ua5FhURoqZFaUZKEspwR+eIH8wRDrx4K0qapu9PG8wfGUljACh9uXQLm3VtG/uEwDo/uKGmO7KorIhpawx/cMh5OGYEFtpQWgtrcJpt3739OLtlrPxJda+3wAJB1pVrO0IZqDf+h7S/h4WQMROKG1fEea6qNYbE9f02jFy0yqOfXc2AOfv3G3zAPUg1tbC+FXbOPYsQP2IRvJV/3iWAUT9ZIXFFRVVA21z5zab2J5FqPOx/YZtLwLdlwdArRZlxwdlgUj0/LWRpWVJQpm65h4o3Rw9Y3CODgHfQ3nQI+leKcEqqSQi5qQgGQV1VrbdGaE3DfHUpiraOcvNJLq/JMlcQ05T5DBtlwchzKIEQAqNZzND9jE3v8ONoYcsS6Cf1G2HxDWcBH9VGAMQg5JSMgONtpa6lsX3TrE5DbCdqmz/mxT+SxrAMt9H+ekj5ENfae9cQfsxVMME2UGE1SPyqPW2EtFVifhnZ8achR9M6uqioP4/ihJi3EPVDQyGvXOWwbtcQ3QCGsoCKGMP6YSsI7v/5pzYsP0exMkUxTBENnTBS4ngtjByzeDMaBjxbdqQUdYVYXnQgwgcsELAWWaEpMkyul6cEzhASYzI+aJWmo0jVMcTyMDB/NMOhAv0v6VKOHizhHz+GmAMPOmiOp2gGIQIns9qMUHfR/6bT3D5k5A2tBuBYCHgbiuSzqgEeF41Mni2XKO8vIbT70E8fYDdYYTVQwfxlUDn1Q7O12cQ87m5L7TCrQEQqASKHx1g93RKnsceEM4qxM9uKZCnNVFKt3h0ksbHI1SHAxS9AOGXZD4kNxu6lyxJ+DaxsyHZoGYHLAxpfpDltSpsS+7lDhhEawE5jkn6Gobz2gdYa4mpyt32J7b5Rg0EkXqP7y4PAGiUSPu0fAw0822m71Z7hzkOwSY932DSARBUUWenqk+3j+BlNoS2FEX7sHuHFpa3zfo1JvJVRUiXzdYE9oaSqLXx6ECstXH4wYRIP76L7cME/m1O0sOzORmVKKMRGQY0SLxd0ONxBJZ0UY3JgKSKCU+vFTPZJgVuFBRV6wJlGZW9nRgiDlH1ArJajDii6xz+8xujF8N7PcOARlmZ/q8ZXO4yyN2udlaLAuqJq542uEJWKI8DfR15HANHExTjDq5+HGNzKhHOGCZ/liP66df0XnkOPHmIchih7LgIz9bgFzMKEt2YZJgnEYRLcgX+9Rb8gti+2qCkmMRw1zmqjkcBGkAx7aLseqgChvjNjiQNNICAM8PhgMOAStJg/fwKbDzE9pMDo5jauagQv07h3qwJ0ZbEpG0/3zTRJyA2OSYjlAc9ZOMA3qokj4O8VJmsMqPpdIiBzTnYYl0jijgD8zzatGKfWOERJzP6L98QufB4TFVNUUIOEhoqn1+CJQnE4yNUoQvhc2wPSGk2WFRqoE8mMpTpV6Rku1ObUV4AUYjie6dYPQpQRgzxVYXOt0uwN1e1H4LvNQxidNuUdbsQowT5tIO87yJLOLqvc0RfXBjCGmOW25aUCtHTpcDsuWRE4zD6nS6vSZtJW7e2YknDbcxyDORJ11QkjXVpVfhts3bzPXTCo9qfdjVgzlujgdRzhZI7aTCRLfhpe5P5tVUAjLH/DcB/AOBSSvmZemwE4P8A8BjAMwD/kZRyzqhx+w8B/F0AWwD/iZTyT9Vr/mMA/6162/9RSvmP33Vye03hW7Kn+nGg1a8Tsmb56mDf9gvQb6tLLQv5o28iuy3TgJgCzYm9jfW1JaXDwCxcAw+0s38NMet0oCUOzCZkcwzs7EMFR7HdNvX3w9Bg0WUcQHpEcGGlMMQbfjCB6Ma0AGZqiJfnpNA4GaIcRoZABYDmA8phTCoZANbpmIAgZ7fUcjqcIDvqQriMdOg3Jdwb6r9qUTbeSyCHPcrglVSyhpHKmLyIvfNbaEikXFEJz3wfLOnSb7RamUzNLJpBD/mDEZaPQ+Q9hioEuq8Fhj89J8hl0oU4HNHANSbNIZobUJCsTsYQLqfqqBQkDXw9M+0v+ckTo0kvXIb4y2vkp0OwSqCKXJSRQxvGhYKIei6qaR9Fj4bzwWuVcd/c0uYWBig+e4LZDyIwASSvSri7Et7lmpi3/S7KAVVO3tUauLhCtVwbb1k+GpL15LCLoufD2ZXwniuxOcU01y5irKgI9XJz22Aiy4juj/S4i+B6p0TgCiPUJ3sdZMc9BC9mRg5azOfgHz1G+rBv7pEq5OCFRBlzsIqIWP6lau8VSkojzQjk8PGKzm+9AAAgAElEQVQjLJ52kCckD+6mxPJ1v3pjWkFm5mWbrijYb/70GIuPIpQR4K8lOmcFwm9vIN6c0+ep4GkTMZ0HJzTHAQwyyvTmLZiyXvP2Z7IgMHLSdotRz5pMO0nBOzVfpcHitQ5D+lSaXDqb51FIA3uHQ9wuGpIPNmFUby4GQdiWiraS2l9bBcAY+30AawD/xNoA/icAMynlP2CM/TcAhlLK/5ox9ncB/JegDeD3APxDKeXvqQ3jjwH8DgAJ4E8A/LaUcv62z27PAPahbfaJuL1zCPw+R3vusA922m45VbUXQFu1s/1c22pRG8XLLDM3ZMNO0jalV5mIsb/rJUAYkCAcYITamBa0spE/4yFELyYdFJUtOZMx5CBBlQTIBwFYKchkfL41kseyJOlrgss51H5Q1H/x+ATZAW0avBDkLrbYkvSwytSNvLXnEnN0va29W6cj7D4YoOhwdJ+tqTefdImrwBjE1TVl39tto1fKky7k0RT5QYdMxgNFVvtmDf78AiioPSJGCUFMlySnbXTqj8fYnSZIxw4qj2Hw5Q6+0rJhuoIKfIiEEDwsV5rtjoP0KIZ0GQX3WQb3mgab0nVQjTrk1xs5COYZQTxfnpMZ/KCP1d98gsUTIjBN/9WO5BB2mWEHlxH9zvGX12Ywqt3gxEen1EfnnBRRdxnkakPfVbXqROCg6DoIbguSW7hYGpN3jIfm+0AIiMAlmQZNEut1IB0lTV0IeG/mkIsVVaRqU8vGoRLHK1GFrkkQWF6SnEJaAK5jJB74oI/Njx/h4vc8RD+5weLrIQ7/EBj88QXk2WVj7qPvdR3QNK8l/eQYi498bA8Z/AUw/lmG8Iszmj1JaQzTjU7RcAiM+kBVoTzowVlnYNuMcPw7gvPqLHufYqfR9+GUPOqKXAspGga6Cvy6O3An8Nsxw1IU0PIVPI5pQymVybyOEdpLQB+thNdOWPcCV/BrrAAAgDH2GMD/ZW0AXwD4W1LKM8bYMYA/kFJ+whj7X9X//6f28/T/pJT/uXq88bz7jsYGsAfx816mMDrzpw9+y5e0kEX3IH3a7R5b3lnkBSCqmire4h9o5qo2bjHyEABJCKtsQlvQGeW/LCNIoyUByzodkltQnrnGh7YsaXPKcuNPYMTbFMxU21PykyNsPyZDFXdXktmIyoD5YkPzgEpQu4YxWiAawjYaojocYHcUo+hweBuB6HxLBvTrTX0t1WwCmniW5ZSZ9RKUBz1sHkQoQ4bkWQr/qzMKkgcTIgR9+IikF+KYyGpa5TFJwLod5B9MkI19hFcZvPOF2exYv4dq0gc4iFewWBE5SLUCdPth+ThEFQBOBgx/vgT+4iuC1Z5MkR7FqJRZvLbLrIYxefJ2XEgOeEsSZWPzJVVdvQ6KUQxeVDRYz+ohJz85wvoHB1g+cpFOgf5XAuN/eQ4IgfJogGwYGIc2780c4vyyodaaPhkjG6jq4yJH8OyaDIGUSmzxcEyzEofB2RTgtwrN5XsGLVSOOsiHPunvbwQ6X9zQ3EcI1YIL6Jrd0OxAq5aWQzLNKboOnEzCXxVw1jmk58C9WNS8DschIpxqJfLDKa5+/wRXf6NCON4h23oY/0GA8Z8vwV9c0qzNVvFsE/3U9857LrZTEiscfr6F9+LaMNb10bCrVIxy6TkU9CtBchQGLFCYTdWevzVUNXU8cd16s9BVgIJ48yg0LSrb8KVx6E6C0gATql3Eg4Cq+KoydpumtWMBSHTfvyElrd63ARXVlZN+fp7/lauBHkopz+iz5Rlj7EA9fgrgpfW8V+qx+x6/czDG/j6Avw8AIWhnb2P56SHZzP7biCAprMfeEvjt1wANnQ0N9WJQQyEpqZyVgujcUQhkGZE6pAC4qkhEuXfDMj1GPUew6Nw8CsEt/oAp5zmjm03T2btdwjhX2kFrpuBgSnzNyjrMzbRaEcOz1wUeTyGSEOujmrXrbJW+/i6noMAYENJgWBaFmT9oJuftBxGcXCK4LRHMMsJ1LzaQmx1lQ6rVxjwXknHyBFAQvXLcxe4oRN4loa/Bz1bgX78Eki6q33iK9VGI5P+h6kOUJaBE7syiOz0kOOamQPdmA7y+gMhzgj9ORqhGZL2pbQ1ZHIEfHZAo3SA22v7Dny+NbaAsS4gffYyb7yfwdgLuRqD79ZI2Lc9BdtpHkThgAgivUvB1TgqucQg57BkXMABkEn95A5FlcIYDFL/7fSw+DLGbMvSfVTj6F0uwN9eQByMsvz+AuxXkNXy1hHx1hkpVN+xwgs2TPrYHDqoA6H9TGNlnuUsbGX/w8haYL6l1yDgNyAcJssMuhMfgL3IwSWYzva+0//M1pOcDoz7xCvICmC8hOYN4coJ0EqKKuJGQjs9SVKELZ5nDuV4okmJFxkJpDrleQxQl8OQhlj8YYPZ9jvS4BCsZvH+Z4MEf7eD9xeeE6PE9UqZtB/4oBB8Nsf3hMTaHLoQPhHOB0S+UCuj1jIKh65rAy3yf5FMGPQr2DqcWI+d0/6qqzx7sNhB7eV5n4iOSRmFXMzOvMENXPUBWKp1CmxQxXm8KWrRRgUj0OrCHyzygzVJst7WjYBg0uwSKA6QrDa6tUPV6boFheEzqwvZ7vu/x65aD3hdp5Vsev/uglP8IwD8CqAKgd60D/L2s3rcw5t4JBbU3D5UVyEpJHyt3Jcrw1Y2qPVJV8KfsI65v5jvcAQFZoZG1AKqU00xBxQSWWQbsdjX+vRsDZQWmfG6F51BfVxGejDuYVjvUmkWoMyMEAdxHByiPBsgHBDsLbjJ0viWLR2NAAxq6kln6oiZTHUxQPBwjnfqQHAhuK4TnWzgLkqJGXlC1UtRG1lJIYAfadJ4+wuqjHnZjjnAukPxyQUzd9QZ8NETx2ROyb1xm6P3RK1TzOeT1NcA4sYgVCqoadSE8B975Lao35xBQQeP4kM5hNgdXdoRSm8iMe1g/TpAOHPgbgfDaUt7s9yAeTLE76VAL6nWO8NtrYJeiejDF7addSMYQXZcILzO4V0vaIMtKDdg9SM+BDBy4l0ti+6YZ+GSM8ulTXPwgRNEDDn+aYfLTJSAk8uMe1p99RJpAX62M17DIc9IFejBF0fWxfBRid8Bw+Mc7+F+8oWugBubVkyOwoiLp58WK5gpJAhxMAM/F7riLKnLAc0FCeC+JbOfo+9K6f+UrMn13jg6BpIPs0QhVSFDO8CYHywWR34SAe7mkYB/6YJUwUEc+6KP8wWNc/0aMzQMgn5ZIvuA4+kOJ6NsZ2HpLgXA8UG2rNenuhIFh7KKfYPXZBFmPo+gwdM6JYcxendEAVMGb5S6tB6JxDHZ6hHKiVEe3ufGTQFVBKCRfvQxVyLG4Jlp5VcNi+e0KYrFswCp5HJvgW603jaretIscx0BytWx6W6bczAtVYNcxS+hq3Q4ZNnHUspq1YyFXKgJyl6K6vaXNQM0H39cR7C+7AVwwxo6tFtClevwVgIfW8x4AeKMe/1utx//gnZ+itw3TxtmT5ev/tqqAO5WC/XygaQqvL64kUS+9M+mbpOEHzGkzYPN5/SNp1u67GHyWdkdDZVQpHGoooyExAZRNpJkhjvHllha9ElUz3q2OA1kqRq2aU/DxCOh3IZIYRUT93vDNqh6GVUrALA5pk9nsgPkC1WpFQm+fPUU6ibCbuuAl0HmdKXP1jFoMjNHgqyxrW0vHAZ+MDd/g4rMYZYfBX0iM/mIL9/MX9LxBH9WPPkIZOPAu1/CWGyJWQbV5OkTA2v7wmNowmwzOqyuw5coEfqOeeUttCz4aUmCeJGRlWQhUoQt3U6E/K4wtInNd4NEpIY+KCp1fzkjky3VRPJpg8VGMbEDyz8PP1wSZXW2ojdBPSAPIUZLKWU7DajVgv/29E6Qj0qqZ/usNvBfXkJ0Im49HWD5y0bmo0PtmB/erNxDLJWQQgB9MsPn+ITbHLngBuJlE/+stJv/8nK5tQlWNlnxwL5eQqw15Bgx6ZHzysI8qcpD1qF3S+2ZjzltK1cpTompyp2Y43Q74aIj08RiXn/gI5xLBbQV3V0I4HEXsItzsqLW3S2vi4vyWKuOTQyx/8wDLxw42DwScFDj4Y4Hu8x2c8zeA70F0QwAxMFvQ3EnNrpwPH6E4HkB4HLsDksWQHOh/q+C6b85pfUYhzZDygnx99exrPILsRiiHMYTvwL/aANdzCCWprddEW5bFEAy7HbAoghh2IR0Hztm1MbnRzwUA2EG/1SngivSFLKNqXjObOb+T7Ekha2SPPbvUsQh1gqrtZgHU8wZbKt6Sjq5mSsaj3Y5+z+MvOwP4nwHcWEPgkZTyv2KM/T0A/wXqIfD/IqX899QQ+E8A/ES95Z+ChsCzt33u22CgAO7v779rINwWc7tHfY/+04SbAmgMY2zIaVsjyGYMtjeHttgTj2OwPkkmyJ2SegYMCsl29gJAdnVpWitlquugzehlHBqbRictwZc7Gr5qlUXVM4TnGk1+jdSpHkyRTiOAgXT/VwUJjWm9GteB5iQYar1DJt/Zx0e4fRqgjBlYCQQLgcEvN6S/r2Cmmqgmbms8uqlixkMUBwl4UcGZbyHigFi3Gg3U7dAgen5LLbIgMPOQsh8i7/vI+w6C2wrRyyUpimqbyNMjVAnZPzpnM+JTBAEwGSI77CIbutQyWVYIz7Zwbtf178CY6VlDiHqgnHQhnpxg8zBGOuCIrypErzbEjE4i5JMO0okHf0mB1f/iDcRyZXgT5aSL+acx0hFDOJOY/HQOdn5F10r9jiwnsxyDVokjyEGCQsFZnUyQfAEHhMMRfnFGUiBS0PVxXarshIRcbcACsmYseh7SoYNgKcxAGwCycVDbJuaFEQ3UTHTx6ADZNMbyEV2v6EaQRMPzGc3IehH4rgCynOQdFGBAb9DVJEHZ8ZANXHgbQqkFlxuws5qxy+O45uJoCW+V8WLUN+08b7YFn69pLqADbIuzY34zNTBmwz6Euq5aKM+WItEkxfu6CUaqRXETRJoZ6QddDesY0YBn2u+n1Qj2fY6KD40E0YopdozR3sF6vqCPX9sMgDH2T0HZ+4Qx9grAfwfgHwD4Pxlj/xmAFwD+Q/X0/xsU/L8CwUD/U/UFZoyx/wHAH6nn/ffvCv71Cezp7wPN/v6diyv2v976uyzKuge17/nqRzM/pL2ha+mIogSqWgYawP1VQLv6MG/FamhYnteCU1a/0MgjQBnVa8RPJUybxlGLC5xTfzUkFI2TliRdvFzXLSOHjN4rCwLnnB5j+/EE2ZBuieiqgDdLwTdpbRLDGAUShdWX2x0ZoyRd4HCCfBRjc+zDX0v0v8kNs1YPNNGJKUPRkhHdDuSTh4DDsDvpQroMkgPhZQbnegX56gwMgFSBnynpaalc0PhwQGJ0XR/C5SQ5PM8QvcyJ/r/ZEPmt26EeKWMkd7Fc08Z9fIDdBwOkQ4W8uSzgX20UPHYNhCHkeEAaOPO10ciHlNReevgEi8eREpMTmP7hDMhyVJMEu48mkA5DeLZG8CIDVhuCHQJgJ4dY/egAmyOOMmaoAmDy5yW6f1G7qrEkQDXpg2/InERmGRGfPhzDWxfI+75C+5TwX81NawUAZBAYDSi23pKgmWpxyMMxykQR0yS5wHmzLVhaQPQisLREZ5FSG1DJeEs1Y5EPD7F62sftUwesAnrPKsRnKbWGsoKSjpisHY0QnevCeXiK/AHJTkvOIDwGd1Oi+01a6ym1ZBGq1cpU13w8os+PCUkmIw+8FMSXWKxQ3S6aS02j3pTImzZx4d0OcV8CH3ybGm4FtFS7ko/et361arAWNdSCisx14YxHlKi15aHtdd+GoTNWB3Q4d2QmbIVikyja+mCOA+ZHhhms/246FundELTv+OtJBGtcyJb4m3mOaLZ52ln+Pk7AHgG5+keyBki2Wt++17UP++/tTcziDNj4ZcP+s24ozSkwEFHNM+h1ICLP6O+jrEwLSRupGLEoS2HTmY4hpyPkB2QWwyTgLUtyttoqwa40M8YZPM3BVlvq/QJGaC0beYo8JRBeEuNXrtY08FP0eLnZGps8HoXg0zHWPzqCP8+xOQ2x+Ihj/LMS3Z9dQb46I/ZqL4HsJzW6RH131okh+12SLPBdkmFY7agVpPqprNshPSIhjHCaDgxi2EN+0IHwGITP4S9pEM4XW2Cxot+3GxunsPDZDarXZ/SdP3yEzdMh1scOdlOG4ZcCyZcrOJdzFB9MkQ98uNuKgrKC0GrPYn4wwfqHh5j9wAUrgeQVvZa/oYxfPjoiuCnnNceCM+BggvTRAHmfCGPdVzmq0CHV001KG2W3A3l6gGIYUUAvKrDVltpWUYj80QjOOkc2jRG+WYGvU0L/RD6q2Id7s6a2nsOJZKfdyZIEODnA9oMe1qd03p2LEtHrNfjNsp4f6YpQQzOjEDicohx3sPwwQuXT5j78orbhbEBArSEn833wXs8MZWVISCa2U3155UsslqtaRwswyYxOnIynL+N10lSWdSKk1pSeKbR1fQxjV5nBwHEM/h9QME7lTletN7WkC1TfXwjTwtk7t7Rihj1PsIe9+xRBdaA3cNkoMr+BHo5/t5nA9x12j86rRdR0e+YOZ+Bt/frWJmOwufbcQD8O3JWqsN9jn2rpPeduaxGZP2nZBEVKgRQGAih7HcLr71QJqLMFhxNTsVDII8tCURtyrH50gCKmIWdwuSNrSMchJISUNBOw2ktyRQxV9ugUm0/G2BySkXx8VSJ6fttwvkKg7C+1dgtgDNfzRyOsHhILNJwrr9qLW1SXRNqSpwcw2H0d+JXWTTVMAJcbXSWtVa9tK0kTSdDmowfrcYjiIIHwSdcHAJy0IjXOUtD8Q0FzZeBBdEi2ly93FFw9F+LjR1g/irH4yEEwl0he0jxFG81nI2othS8XtIFVlZGmkNMRVp/0Mf8eDVe7LwWGf3ZLSKIkhugEKLsUoILPX5NchuPAOT4kRrbvEuEsJunq+PUW/OWlmbvw4QD5Rwc0n1GBX3YisCxHNU6wfdCBvyjhXW/Bcsr0ndnaCAry2xXE/Nag0pxuh/x+TwdIxz6Ey5TF4hq4npO3AGDw8WK1htilxo4zezjAzQ8C8ELC2wDBsiJpi8s15Is39FspUpStvaMZwPD8mrCmoc5bNXeqKpoF6HaPJdFgZNG1R69m7gO1hage0AL36u9wLXte1fGhIdVgeYUYBdLhgJRZr2d3LR2BBoEVsNrIdtau3rstba/PzcwQ7ZmGpaNlJ6TfHS2g+9RA3xK8dQa992K2L2RrcPw2Nx56eStDeNscwT4f/Vp9DtZ7v63FxSOSZiAFw8rc2DqjBWDMPky/V5tV2P3IqjKBvzjqQ/gOytiBty7hny3JQs8j7R0mJA03s8ygLrjvgU8nyB9PMf8kRJEwxOcC/c9X4K8uSQ5C6fSbLMvaDFgcoRp0kR1E2Bx54JVEfF4gfDajIBsGwPEBDQ2FgHO5qLP5pGvaWyJWOim7AnyxRnV51VyEnksD9UEfohtDBg7KJEA69gjXP88IxrlNlZOXoCG7kqeQKtNj6u+yE2HxW1MsH3FIF6pKuQS2O1THE6RHMcAAb1XC//INqusbOJMxEEcQ3RC7Bwkuf+KhiiT6v7Qkoj0P5ekIwnPgLnbg6xTV6zPDVdBS3VVQC7MFswzO1QLV2YXZ7FgY0hDf4cRu7nVQDmLyg9gVhK662RDaizGC9SadmhRlZ7TdDsTTh8gmEYoOh7tTENUb8v3Vzm1wnJoUlRcUzJ88hOiGWH8QY3PokNHMlSDPgedXRjnVHsQaWYskAesnZIKUEx8FaUYERyVOaLR6bNZ9ywGPdcmLQFcxjDFDrLQd+cyMwGL368DP+gndE6tVnTTZJMw2t6fbIQSWlITm0i0kq4KwxR0bniU6KdQzxnbMetv80nGaG1grjn235aDvOe71ytzX2rH+bQYue2RVG6/T+PbWIKZ5EveXe3s9ivd+kXpzYWFAGZEU1MttyUg3YGhWhWBKXCVnwYYDiCSC9Onm57sCuJ7TYgwDYoKqwaGRrihI/pk9foDV9wbI+vRdnEyi/9UGzstLWlCK6EUVTl11wHVpqKu0crRcQPxmB+fNDcTNjFi+x2NI36Vzen1O5vJJTMGeUwAkyeuCZhLb1Cw2M3xjHKxDpbBIIqw+7iPr0VDWSStql9zcmgCgSXPQG6vDSXEzpMF4fjLA7ihAOuRgJdB7niM4W0KEPmTgoOh6xJi+XkO+PjdS2TiYQPQizH6YIBsxCAcYfF2h82xNSJPjCaouCfs5O3Lbqi4ujdxF8b1TgAN54iEbcPS/2hK34LoemRnVSccxonTVqGPUS71lSVaH8x1wQXBaIw2uAred+XLfA3t0iu1HI2wPXfS/TeG9viXpCp1pdxTarOVbwadjFCdDbI9DzD8hzkLntcT0T1fgLy9rlVPfb+j78CAAG5H6LEAzK30PsK3yja4qo5dvn6tR0dXYfLXx6828cY42MVPPoqw1zqOI9K/URqpnFw0EoF252zIvllSMycAtZWBj/mQpkO5rSd+L4HkXwfW+GPOdUgNtaQG9C2bZDtbvdWhRN2B/8P9V3mvfOdnHu2Qq7B1eZwMWQ9LYzGlmqxKs0wNZrS/EuiT5DN8jeeZSUIaorP1YQGbfWpRNrjeUEarymPcSiMkQ+WEHiw99lCFD70WJzrdLo/YpOxF95mxBKB3GSJ0yDCD6XcjAQdX1UWkxuaslcHlDG5fqWUvPAb/dUIBjHPLREbYPEzgpBW5nV9C5b1JgsYZYLk1GpfWPZCXAQhqaysDB6oMYwgOSlxm8syVlr3lBwUAhqVjSgeiG1Au/JkE4HIyx/GyMymcoOgzRTKD7ywX4ZgfRiZA+SJAOHSTPd3C/PjPfGU8fG8ZsNnSxPuVwNxKTP9+SRk+HpBTS464R1ZNfP4cx9Rn3UPYJ0ZMNHDi5hL8o4V9vwV5f1rdGENDv7HBABc/8gAJzNnIhHIbk+ZYYumVF3r0qcMssM71qus2YYRpro5rgcgee5sD5dZ1cBD5l0Wpt2PaeYtzD7kGC7YGLMgJ4AfSekTBbdUn2jloATfeoyZeZXitiH85iR97KahhrIMWqutAH972GtDIfj+i31GZFWW6qBIPht6oNQKFpNPnK90gevRtT+3S7awqwSdEke1lZt9EL8r1ahwd1O0evIQ3maKMFdVKqtZ305kThodWteFesaFVC+v9/NzcAfbzv0BXYf4HuafG8VVZCH7oK8P27FcB98NO3ne+7WHtWOWleoisdYb2fHiKpUhpA01NYawIpUTUtgduQhxj0IXtdiH6M3VGErK8s/K4L+NdboCJmLFxOcgdbQqhAsZBZP0E1TlAmAarQgbsrqS/dgve1qxUcH6A46CId+8pkRsC/zeHONmCLVUMfSQ8JCZLYhRwkxjClCl2SHq4kMWvfXNB10Ju72gSMxLbKMOH52P32Yywek7/u4MucnLmUDo52IIOU8J9f06xCDSnTh33MfhBAeAATwPCLAtGLFYnCARCTPlBJ8A0NqY3Jz4Nj5Mc9uKvMqGZuH/cABsQvViTJsFzVw0xNJkoSFA/GWD2O4GaSzGRyifAqhXt+Sy2TXUazISGAs8um1EgYmJZicTIEzytqQ331hjwhNNQ1CCgQG0VLhZ+PQmDQQ3nQQ9734WSC9IAWO7Bnb5RuFDObhZEKnwxQDmJUkQsmJNxVBr5Km+i0tiZPC0JNUOMhcECIIr5ODTLLJiDe8d62jFuc8YiIX2p9yNW6qUCqiFwaMGB7A9gWjwAaImyN5EzPNPRmYAu2qTVvt38AGGtIoyp8H0x0XxJsPaYBIv88/d//SqUg/u0cNkSz/Tiwd1BCf67dpZgq/xrDXMXU3fd5d2cFNIPYF/z3WU7e6ftbqKW2LPQd+WrFFrQHzQYpYEvd9pI6GyorovZrBdPV2tq0PMI8a09gnU1Nx2CdGMVRH7vDkLRuNgLJs5R8Zzc7KtUlmamzooS4vKZgrAKKHCQkDxy4pGkz24JfzgmpASg5X78eCAcBcDDG9uMJNscuhAu4O6D3LXm9YrGmAbKG9CVdWsgaox2FqI5H2J7GYAJglYR/m8M7u4W8mRNGPwop+Ki5AADj7cqHA8h+Ank4QtkLIVyG0ecZ/FdKn9BxII/GKDs+3EUK55rgipVivhafnmJ9EmB7xFFGwOArhehZbSHDAOXDCVhWGeewqizBh0M4kzGqgyHyUahktjnAJMpehM7Xc7I6zDK63hFR/FEUgOuiOp1gd9LB5siBv5IIr3KyZpyvaGApSQQQvge2INiq1pphngtnTFpH0mGQLjcWmbi6hjTBSvlMaASckgdHWQGug2qcoOgHqHwOJxMIXt1Cvj6nqiwMCOu/pKG8Mx1DnExR9nzspj7yDoe3k+i+2NLwfrOB0O2T9tBTI9asTQujPrWJZitgvYHQbnLAnddrAIiRU/A9OCdHqIYdcnS7uiXugJaCsFjGRrVTr0tLssF0Agz/iBujlsZAW2v164Cu13PrPdueJua5DS0yu7NxP2S9EUPe8/jrWQHcd1g9+oamt+7vqx3a1skxBC4AdyqAX6UyeMfObP5952Ut8xotYd1+H+u5eoil5wNMycua7EPr8Fhm6hrvrDMM5vvGrL087JOZSC4ABrg3mgijtEw8l0y/laa/LErSX5mOILohyo5HKqKrDPx6YbgM5hztikwZyReTGNsjyvj9NQ0bvfOFIQ5pfwaWdEjoraqAsjQaOLtDQhH5K4HOM5UxpykN/xRpjkWR6QlrMxEWBJCnh1h/r0/ImNuU4J+qxy4fHSOfdMi28mwJnF/VWbuaV+TTDnYTD0WHEefhz66JMTpJsDmN0H1OLFxxeU0IoicPUPYD8LyCdDjK2KENa5GjCl34L28gzi+NVjzrJ0CaGetG+egIu5Muyg6HuxHkb7wqCH+vtZvyom7nbUg8T+x24FFkxPsMKXCVUmUAGJtELXesSVssjpRBUkXtmjdlJ98AACAASURBVMiD5AxV5JL89Msbo6ypA5Bmw8Jx4JwcIX0yQd534e6oSvBmKRHkLq/vBH0jd6yqB+3nLJOYKofYRfBqAdzMqV2phrr6O5i2rRUMGWdkT+q65KsReARjntUsfmPcotuKWvahreCrUEq6laUlmlm3Q7MHazMCmigfc9gIIGuWYM7f6i7o57eRi3fmiK0Yo5VH/9nmn3yHWkD/H3vwRnPfUtRsaP/bvb0WNr8xZTc77q82X7hjEPOuOYZ9tAlkNkPQmg/oQy8kLZhlJJQt4wndw5XdmHDcQlAfljFqGXXjOpvcpZDbXY1zVlDO4ngA6XBSD81L0tBXg1ktbw2gNrhhDDKJUfUj8oD1OHhWwVllwJtLI+WrRd+0rr1cbyhbT2JjYF8FHOENGYzzXQn+6pIYznrx2AGpqqhdczBClQQQgYNs4CG4yeF/dWasDmUnokEk53CuF0YumxjaCappH1XsogwdY7PIsgKsksiOuthNie3b+bPXNNwOA+D0CPm0Q9o6pah9Fhixbp3rFeSbi5oUp7JhfR2ckyPkp0OsHpPbVrCoED9fUpWn23tK8A6eRwNXxog0NhwCkwFE7CObxvAWObyLhUF3ad0poyFVVbROlLwG68aQDidTGpdTtXKzAc4u6+pq0KcN4vqGxAbHI4jHR8j7vjGQ51kFJy3hnJGxjv5+bbct7Q6n2eLalxhQqq63SwNDtmcKJqGxkH/67yyOgX6XiIyLFW3kGljBeI1i0hm8ign7IJy29r7ZWNRMRr+PncztjR/71nnr8bZMxN7H9iAHtdewRi59d1BA7G/TP/Zlxe/KyttHazagj31w0DtmC7/q8Zc5v/d4nwbSqZ2h2LpFdpagF4bjKA2UkHrFRUlsz7I0pDJ4bq1vo9sHGmY36EP6HqpRhxQ5lTKktPRXzELS5xqFZgMQcQgmCWLKhKRMVVULBpqnnZ8GfWNasjtNIF1GuPJFDmeTETM3zWgIDtBGpb+zIsToXvv60xG5k10V8JZk+C7mt9TPHg0MA1ZXOVryQJ5MkE9iSAYIj1oe3ioHy0vk4xhF4qAMOYKFQhm9OKdM8LOnWH3YVf1xaczfg5sMTEg48y1xBQDw6RjSdYDrGZm+hASZxXSE7ZMBqpDD2QmE1ykZ1euqbEPQTRb4FGTUb8BcF/jkiTk/JxWIvp3XaqHadSrNCLoLGCABHMdARMWwCxH7YFkFcMC5uCUCoJS1IXlV1Uisxw+wedIHLyUgJcLzDfhqR+iyNCNJ77KZrJhg7Lo1ssl1aIblOgRa0IxzwGTr7b6+vj8RBDUijT6ApNG1kZHv16JtalisjV9M+8bm+GhHMJVEaRIji2N6j/Wm0WK6z57x3nUNvL2/bysO3INmtDscdlL7vjOAf/c3ALsC0IORXxXL/xaSlf2DAWgOj+6Dg77taP9o1ueb93gbWsmCgJo+qHUD2OepnZPa5DT7+5jsSgoa7AGUXRd5rdEyHjUgcNoJyxhv93vAoFdXC8sNBW6r3QTGFQFH0A0ZErRNtswttDSB7ZBmNiiAziUKUB70sD1RPrMXSm5AoTX0tTO+Co5T+ywIQciayRDZUQdFzwUk0Hm2Bv/6JQXJODLSAiwvIJVGklSKnBj0UBwlyAY0EI1fbcDTEtLlyKYxioR8e6OzLfjXr01mKb//Ea5+t4cqZIgvBaLLAmAga8nFBnJ2a64ZALAoNANu3u1APHmAquOBVVKhcjZkAOM4xH5Nc8iioM/qdckqU3kD8yRB8RuPsT0kzR//tqRB9vkVzYhcB9J1SDL5dmnuRZbQ37T5ulTsWZaq36YsSbtIq3FacgfO4QGqgyHKPg39g6stZevqvGx2ajsh4VFYty+jAKIfQ3oOnPmWBv/LVW0H6Tj1+wCNtq32AEAUUkWqzluu1zUUVENQC5J62OfxrdeRBkToNoztw+v0e3QNlFqojfO3lQGMmnArLjQGtVa7tv28Nmm0zfxtPA9otHr1877bKKD7jnt2SFvMzf7htVGDoV23enHmPd8TWtpw/bGgaHulKPacO4/CZjDNsiaGeM+xb7O7g5VWGYLd/zeS1pzR0NGCz5nzENIMeLVaqF5YJnsz11IxMF3HYLuhHMA0o5JtdqYNYBAVesN1XbDRAOXRAKsPYjg52QV657dkECOEmXnobNLevDXJTQy7SCchisSBuxWIny2Br55BliW5nw17RIJSstGm9zvoU+A/HaCMXOOM5r2ZA5VA/niKdOojfrOD++qmNojvJUQIO46RjkgjJ7oqzMbT/WZJkhqK1KZNdXS2zo8OkH8wxm7qw1sLBBdb8G1GLR4hSEZCBWfWiYHtzjBh9euXPz5GOiTEVjiv0Pn8Cri8AeslpJ/je+DXJKgHzo2GEtOsWFWRGflizb5WLSHWSyDndfuGH05RHvaRjej3dzLq7/PV1gzvTUbduk+1pg7rJQSPdR0aMANGrLBhgKRfb1WYZvalHOo0M1mWpRFHpBOje+sOOcvq/dtqAebe19aS6n0dVV3I7baueOK4YbKk78P71vkdcmorsdwnW6P7+UZSQq3vdnxrENXU/fz/DykIuycPNIOzTdpCs+doDNhVsJVZdmcYdEcqWn8evdnbz2cfu9cu4drvYfEQ6NSV9EILM2yXvXdKwn03QwuBZFzJHIfw3csVuSNZlHJzowY+oM3p8wJyvTYZtm28jSAgDP7hgOCOeUms06JoUt+3u0bANZ7I3Q6ZyXdDSHXuPM3B0twMC20yj7k+Go8+HiL9cILFhz7yHkMwk+h/myF4MaONQ4nGESxSkoaM0qvRdpjS5SgHIXYTH/6iRPh6CZzTYFdvKpqdXF1eUW/+0QjCpYGuu6E+Ny8EUApUPR/C4fCvN2BZSUP06zlJPADUnweQ/egRdgcehAsMPl+TvIOQDdgqrMGq4X8kXRSfPsTySYQ8IX5GdLEDf3FBCKfDKbX48sLMcGyYLl9nEHFAZu2ZgmvuMuMEBo2SY4wY2KpiYL0E+ekQVcAhfCL1hecbGvwrxVCjq6NvbZUAMdclmPF4UAd8jf3XDFprJmeLoNESUW1IZXLP0pwQbbpSsJA0uveu1287uDY6Aeoz9dyp7UVMH67mKnFsIMQ6kWkQy/S6bCWQPAyoAkmzu4F8T0ywLWXtYXQjbuypFOzjr9oR7N/usQ8OqjV3zMBVZTM2OgCAFBwMSvNfZUD39erMDWgH16pqwrKaL2j+974NY88w595Zg/psM5ja1wvUhw0/a28S6r86CMtFjT82Egp6EQLkE7DZGtcmU4pzDiZEHfwdDkhZ+8oq5qYpTy0NInOOSnZXyx2XwxjC5SRZsMso8FscB5PZWcM1fnyE9HuHmH0aYP1Qwt0xdF9KjP/NCuwX36IqSzga6gkA17ekGaQ2L+fkCMvfOkLRYXBTCV4oh7M3SxI1+/AEZRKAZxW8sznE5TUEY2CffojV4wRlyOEvK/i3ymfAc41UhbPO4RYVWFEBN3OSjVDtpfz7D1AFNE8AAwb/6pq+5M3cyHMbme0sqzVyPBfsYILlbx1h+dhB0QG6LyVGn2cIf3kOMZuDHUxI7fJ2WbeWBn2w8RD5gxHKjgt3U4KnJUldK9iw3GypfRIqv2DPo6CW0u8oDyco++QFzIuKVE6fXdPGkBcQVtBs+GMzTu2Z8RBwHeTDiDgayxS4uEal9P3NwFRn7NZglwVBQ04EUoKtdyQtoawdTZ9eHQ0wh27laFSa/rfNglYii3alYLtwsSAAHw7BfK8hYc4HfYNIguOAu3qd1utObyLVksh0+4a87fV+RzLCbilZbeCGRLS+5tZaf5/jr3cFANyb6b81S7f/bl/Q9mvVzMFo/ujM/B4j5rd+rn5eu0Kw/nZnMG2/551NSNbqg7r/DbxdysI6V13GMoc3Kx+7bFcZf0M8S2WHPI6pSlDnozMxc6jMyvx/qH6tYl9WwxiSMfBSkJqnYuSaDaqqzXZ0L5hFETAmBNLND0OUMUPnTCBYVOj8/IKglAB5Kndi6nkrNVQ4DnBygLIfogpdVCFH0XUQX2TwX86JDQxAPj5BPukQ1PFiQfo8SgJ49ve+j3BeGRSQZAw8LwGhqpZdVrd4FDlJVxmbD/vI+hzBrUAwy8j79/Kasn1FuoLr0ixCw5M9lTUfjnD+74+QHgCDLwTiiwLutoD7egYxm1OQjSOIiytqUYQB2MMTk+UXoxjCZQiuiMzHF+sawum6tUyE4kiwpEtVV+BDxCHKYdTgG4jZnAKxQhBpmKzB7UchzWGGPWRHHQiPw1sV8C5XBlarOSgm09VtWP24JjZ2YsNx0cY/BoIZRQ2/3sY62iO50G652JuDLe5o99Sd4YCek+UQ261pneo2pGlVOU6z1WSjgJQPMIAGGu9epeJWPLhXmeCeOSjwXWICO3/n3p7avfaQ92H59d9sNFC7jLoPz99+X+vxO0qjb9l8dKvHFqGyb5T2EBdAzWPQhwrKRiFUIRLuVRG0roNp9ShEhI3dtmnspoS1YHEGsqeGqBDCUOjtga45b53txxEFqCRC2QvB1EzAXaTGsMX0i3UrTn22yQAPJigOe9gdkiyFm0okXy7BXpxDrFZGE0ZGAQ06lZY9S7pA4KM47CMf+NgcuwhvBekRfX1G3AJlEAIOUiCd0SDcmYyx/t0PcPljF9GVRHwl6DNzpb7qklWldDn4zdIoarIgAHt0AtEJsPi4C8mB6KZq9PdlFKDshWQzucuo9628AHgUGr7D4qMIeZ+hcy7gL0pELxZg8yW1dTgFAbHdEjej1wUOpyiOErCCsPfC5XCVfwLb7MwQnSVJ3fPPC6DIqQIIA4hujHIYwbtY0nNWZLFoMP/qftLYd33POb0ucHqEYhghH/oQHkPn5ZZ0n5TFKACTuJjgbVV2ui0IIVUriteCdep+4kkXUgm23RGY2we7bGXEeuPZZ+iu9YFsPL5YrWrtH6AGSejPtHSAGuuuteb0ufIgMAi7O+f5Hu3le4Eu1r+/My0g+rJ3s3ZzwRtzgP1tmUbLxvpRhBKcAlBnBPugn/tQRtbjDRbxW8hgpi0i6x+vbRVneopaHtZSLjQsQz2/qKrG/ML0N9sbmvpsG59vvEltLoRGWll6J4yzWnDNklmWrkNDO/X5NjcBgJojBARTHPYguiFYTjo4/EYZruvgocxmGr+F7vuPBxBJjHxMzNnoggxM5LNXCscek/pmRO0LtstqRuXpIfJJF9JhcBcZeOFi+PkW3jfnRLI6mKAadVFFHgmnvSSMO3t4AjHu4PbDCOmIo3Mm0TmvEH+7pL65Cv6sEsQjeD1DuVwTq/qTj7B7kKCMHfBSIr4oEH5JkhQyDiFDD8W0S2zpb88hlivjNKYRLdXDA9x+r4NswOHkEsNfFghfrcCuZnR/eB7g5KgWS9MC4Q9PkH0wgvA4wjcrFKMYPCvhvSRugLiZURtFVW3GdU45qlXDA2SHsdJgKuFdLGuYcKbgtsqBjSS+t6Z94/S6JPN9OsTuiDJdb1Wh84sbyLNLVNptSyPCKiWQZmXdjCnjnjCkwW6aQRYCYrVtzBAA1LwUzuo+/X1yC0CtAqoSHFlVZiiv14dpWcUxVQFpBrFaNSoVrZqq5yMNzoANOLEGzRp8oa8TPJ/mOrrKuNO5sOYHLdDJW0UorTkfHOc7ZAhzTwXwlzpamPl2Fg60MgjrJgKwd7Cq37fRNmrBOu3n7oOI2QQv5jh3kD/m5lRUdCP3DNQZstZ7saFjatEZo2p7QGwHapsIp76bXgjm8HxqFej+sJbnbS0s/X2Y7tn6HvkL5AXkZgepsyelaqrhqLbGOU+6wHSEYtxBPvSpP3+9a6hLOpMxQU2VRLAhM0UhcDhBdtiF8JjZ1MLXa7DXRLpiD45RTLu0Gc1WxuCGPTjG9d+YYvEUiN8wxNcC8ZsUzqaoe+ba7DvNjB2mNk1Z/HCIygOcAui82tFsYJcaUpM27NGaQADgTCcU8DhH/nCIi9+JUHSA8AYYfpEhfDajjSYOwZYbiNnctHl4L4EcDyAitYGkJcBBLeirGd3jtwsS6At077uAuJmBD4cofvAAu6kP4TC4qYC7qeDPU/BXV8bLwXAE8gLgzKBeGCdDdXkyQTkIkQ08FDFH8mwH72IBcX5puBgAGnBmY34SRzWnQOP7K9HwkGjAQLW4mu9TW45xeq2eQVjBv23R2BZWNGu4laW3WcU8CBoidHrNmGrG1vnXccSCvhoipDovsVzWLSFVbWuY6Ts7COo99OfeSfKsePGdqQDuSCPsIUuY454+moF2QlUDooS0nkvllGwEeF3uNXS324G7NVCiB1twzVZvro0qMvBUdYOaLAOoKx9YP25ZB3NT9mqd9NbikHne8AtmGupql9wAhJUN2S5IRo8/ihRkVhhSDwCVSaZ0LdV34XFcaxMpsS253ZHWjD6qCthVd1oAvNsxrY984BPW/s3GSCYLxzLiBghXby0yeTjC9qSL7YGLKgCGvyRtHyMKdziFGHVRBS7859e0mfQSlL/zPWyOAuQJIyTRHOiekYQz36SUCYc+IXS2KUkJlCUc5Y+wmQbIehzRrELv50tyZStKkjE4GsBZZXDO5xDzW1RqsMuDADiaohx1kA0DLJ54KLtAfCYxfU3S0+Cc/lcJ4PU5hPqd3UenpMnju+Cp4mLsCtJp2uxMLx++Bz4Z02B+NqdKrdtB9Td/hNmTEN5WIrwuED67oUCp5zg6uCrvZo3pF6steBzDGQ5QPDnC5jgEzyWYkIhfb+G8uqJWD0DZvIJk7pNeNtpVRUlBv6Q1qSVL7MMOtjpw2uCCBlhDV7pS1rIg9lzMWovGjKUsm+xfK6Zohi/zLGSRdvlSn81QNeUbFLyUDfr0/goYAaCeIWh+QRuo8RYgiP1d77Sc9LloEut3pgJ4Hx7AOy7c28wV3nsY+75ziH2f0T7sqkOXpNYmcl+P746khDps+QfNjG0PcI3KYsspDZoXEMdm4CbnC2oveC49PuhRH1aZejTmGFADZeW3isAnM/DVxiiQNrSJqqrO7jQfQSlMbj8couxweKsK4fkG7NvXRoKioYCq2cKjoZkrpBMfuwl91+RFgfiXVxAXV7SZacw5QG2rvIA8HCM/6Bj4aDiTCJYCnZdb8HVK7lMaBlmUJEWg5iz8o8dY/mgMyRnSAUP/mxzh2dp4GQBAdTQkd65dToPPLDPflUUhNt8/xG7iIhswMEHmKf2fzcFuV1QNfDiFd75qSC+Ijx9hdxiRp+6Wgpm7reC/nhMzWKl3EvOaE4lru6V77eEJynEHtx/HcDOJzusM3vWaXNzygio2PXDd7iAzajHp+5EnCcTjE8jAQTYM4G1J6dUM77dbeg9d4ar2iH5tw/BFaRfJ9boO+Lqy1UvEWg9tmQMATViwPVC2gApt1U7TYrU+a68AI9AIuPcNWvd1B0xlppBrYpfSPaiABChLqnj3IXbaw2p1tAlf7WMfF+C7UwG8z3FfAJYtlc99gxQ0/64v5r3m7vbbW9n8HSjW+5yfen675cSYQvW0bg7zXayb1BjCAMaH1Bw2CsdxwBzUGOtK6wIlFDB0OyXLIXc70/sHQOgS1cdswON0u2Y8hOgRRM+ZrSFnSlHT96jEL3JDNCM9oci0iDQiSHgOvFWB6HUK9uKMBqK+T+xLoKnbEkdgvQQiDrE77SIdOvDXAsnLEtG3c8jnrygL7feAfkLG8BoT342x+fEDFF0O4QLeRiKaCYQ3OUlbnF3TgHHYgww9ahGp7JkP+sg/OcHFDyOUMeAvJcZ/sYX79RlpFiXkSCV7HTjXSxLPU60L5+EpRC/G7rSLzaGLdEybzugXGfxFToJ0novigymcdQbvz58R9nw0BBsQJHXxNMbugLgOIRS7ebVtBGAIJVGgr7WaDZSxg93IQf+bFN5sS/pLWuROo3nU9zSkK6V5g8MJimGEKnQgXY742S0wI9E/oTZkniR0r6iBNPNcONMxMOpDhH5dSSnRQuNNoBKQfagxQAU/zu8QruznO3GNhLujxqmHvJpUpTD9e7W59iEC22tao+j2gDmcXpfMjNLUeCjwKDQtNP19wXhTsFInRy30kL4WbSUA+3VmE3yPeLXv+OtTAezL5vcRwO5rCe3L7N+RYe/1Ad533IcSsv9+34xgz/k1/Ibbn9tGCWnijO6/WwMvA+/U2ZDqpUIP3LTZdUoSC2b2YFHcjfG0NtpWJS7v9UgwLPTBsqI25MiLBrTRqCRqdEunQ9k4YxBJCFQSTIg60EpJEs6c1RWE4h2wfg9i2EXVIVE3VgqwSoKnJfi3r5pKlrq3nOWAwyE+OML6SRfCYXAK0tFnAui8WJM0sULC4GBCzNk1+RGLXQp89hQXv9fH9ljCSRniC0lZ/5cXRoCNdTv1cE9rEalZSPXJQ2weRFgfO5Au4N9KTP70Fvx6AXguRDeG6JI5Cs4uIdYbOIcHyD4+QjrxkA45siEDz4DOhYC/rBC9WpmNkieJgUcChMYRHz3A+nEXYEAZMCTPU3hfvqEqRiGVNJTTtHh0m0Jl3Gw0RDVOUAUOzUGubiGub4yzli04aGfmPAjAxsO6bbahikJut2bN2kq8+lwaXgAaZWP10++QOR2nJlhZJi068BsvbaBJIlTHHXMWvIWPo5efPbRV64J1lVuabQ6v9YI0+YvdJXM2grmVxbe1f/T1MC0jK17s6whAiu8QE5j9bWjMK4D3C7LvGqQAdSDeA90C8G6/33dAQ9vvZ5BKe4L/XrYysP9z7zkasrOoZwoAGsghrY9vJGyVlsy+9pCpMJSLliHT6JZPWUEWhcG+GxkL1eaxF7hm/ELKuvdblvRavSmpTMhkoHqjiiJUk77RnOG5gLMjhzF5dkna870uQRuB2g4zDCC7EYpxB6vHVM1E1xXh4QXANymJpGkERRRBrlaolmsTRG9+s4fVBwxFTyC45jj5FymCry6oX67hs6qqMi0PLZzXiZAed7E99Mi8hTPEFxncm51xGZOeA77aQrx8QxXZ0QGKoz7WjyJUHt0HRQcQHjF+uz+7qu0hhWxcZ2cyRv70GIuPqN3lphLdlzt4L29obqGJZRZ2vSF05ntEzpuOIENl0Xk5o41NV5f6+1py6gDp5BiXOSnNhmp+z6ruk9vDYQBmOGvzWrREi92qsQEc72LK6ozf1iG6k1lroEU78NIibC6wPfDxxuBYVRpOt0ND4u22dlWz5ojtjaydzRvARxQ2Ntb7YOp3QCVqLX13WkAGEvWOwP+WAPu2971XqrlSbGHogOzs321b53JHCE7fOIwDd3Sf6LPb/cV75w5v+342Qgkw5+50O7ViZkB9VKjAaxZmENCpqWxLoxRYFNWwwbIk0tgupdfPbo0pjRGus7xRmWrf2EQeCFFn1TZqQp1/pTNQtcGwTgwRh8gOOwSrzAWCm5SUQN9cQKgF5kzH9P114A98iEFiXpf1ONydRHSRwbtaE4NVqYdqeKvMMlSzWzjdDthPvo/LHyfYHDOwChj9Qpmbv5nT9fdqVzGZ5yYI8ygEHw5QHY+QjWiw668kOuekQsqygqwjByFYL4B3voB4cw5RlnAenCB/OEY28rA5dMBLwF/TgLX3TBm/XN0SYqjTMbh6xhmc6RjZZw+xGnuQHKSjdFUQgmiX0UBYBV2h0DxwHEL5qIDqnh7TJtv1Sb75eglxdmGYsBoXL8uy0crgUUi6/YFCe61I4RUg1rnJxHXFoBVLAUOk4kEAxLFxidP3UEPrSSHgzGZrD1BtqLVFsBItXo1tHqMHuwDuEDttC0egNY9QLVAA9b3uOKatCSlMG4xHtBG3Z3wAGsNqWH/Xg3LNfbjTdbC+p4kdjTduJbXvOP7d3wDuE2bT/7aP9/nytrIocG+w3Tdlv3NohJJ1XncGNXuIXW3Vzr0kEvv171EF7JW01iV6KQ100Wb9kkeuf6csJ82T+I4mjW4RYdv8HCEkIJVQWBTB6SVGnVE6DliWEwRUKW6az0Ut1KV7qPCUib2Sj5aeA3dTwL/YgJ1fobqZQQYBsX2FJEbmak3BQdkskok8A6skvFWJ8KqE++zCYO5ZGAK9BNgoZdKqgjMcoPzdT3DxGxHKDuBugO4rieEvtnC/OSO55SgCG/bNwFV7GPAkAet2UDwY4/ZxhGzAUEYM03+dIXx2A7nZgsUR8gcjoJLwrtaQz19Bak/eD8bYjHysjx2UMeCtJbwN+QJHX5PoHNvsDCpHzG9Jm+jjJ0gf9lGFDvJEyVJfbOuWVpZBqBZNQ4MGhEZh/R7gucgejcCzCtLl8J9dQdzMUKY0eHYGfTPQ1HIGmoXLBj1q82TkjSDUwNqImanAaAK3zpR1m0i3IQvVu7dE5BqtWFvNUwVFqpqdOmPWyDBbBNFC+TRgxr7K+PdUDw2Grg7uSh1U6DabVWU4qv0ji5J4AzYSz2pr1cu5JpjZLS/DfnaUztD/2965xkhyXXX8d6q6p2f6Ma/dnd2d9a53DbbBRDYxwRhBIlDAsS0S8xKyhRQrQYoiJYIIIcWWJciXSJgIJBCIyBCLGIU4RBDBh0S2ExD5gpM4Zm2v1954d/1a73Nm59Uz3T3dVYcP997qWz3dvTMbb0+vtv5SaWpu36o6darq3nPP09HVReK/pI1yC7aA4VcB9fIC6qcS6lQHOfirhE4VUCrwq2PSwVspJEFnbBj8fcNOmpw+Kh0/lYV7sKnfe9gpOl7W1Pk9Y3Yqu6DneZSE7nsvaPJhF8eMQW11NdErbzifR1uS0dNG4xIEEAYbBv3OSmxAUoyjLVFbo1q5ZKJ6qzV0aTmtWw2DRHUV7p6hef0uGtMFolEhtxoTNmLCeovcwhqcnTMh/Da6FtUkQZq2WuhPH2L+1nEa00JrFIrnlKljdeNZs7zSVhtYHsaLSzivk2BygsZP7aMxnScaEaK8UDqzzshiwyR2W2/C7AyaM/mSgvMLRAuLBMUizVsPUt8xQmM8YL0iiVG5mMvB8QAADyhJREFUdDameKZG7vwymguJJ4pGGreG+HBinOjm/VQPFGmMmxVK8YLNALqyaksTNpMqaL6PeZIMcP9eGnvKRCMBrVJA6ZS5Xnz6rFnR2WclxTET3WzfEfesXOCaSyWha2upDK9BsdiONXHSsnONdDWpw8CoAW32T3O+KPkGEndkO3Gk8gPZ9CBuVdOW+NNJ3PxI36R6l3NN7UismJzXc5BI7AdeDIIvXKU8+DrihjZI/M7Wgafy8lRanemkLzXIpzwQu2gG3jUVkIg8DvwGcF5V32PbvgB8GFgHTgAfU9VF+9vDwB8AEfCHqvqUbb8b+GsgBP5RVf/8UtfeSIxvTO0zy3UxlBhJ2/3eReXjXUPCDuPMBjr8rKNePIGnp/NVS53STDqjZ3sS2uCS5tPk1EW+ZOCO6cILjSIzaHnnc/EOri6yr/tPjLy2vOQGaQazEoi71UK27n9JaolavT0geHYENyBJPmek/UIhCQZzxlp3by4dg8stk9u72wwWKytmhTK7m2hmnOqsqeebr8aU31wjWK4Zo2PdDPJSKBDu2mkk1VqDeGGRYLxC/Y4bWT40wnpFEIXS6Zjx19fInV00A5MtQhJXlxIjtku3IJUK0cwE1dkScV5ojgmF5Zipw6fRegMpF4l3TQOY4vAu1cXuXdR+/rak+HywrgSRkfgnj7covrGIVGtEMxM0DkyTW2kgR08SNRoEB/dT+5ldrFcC6tMB+RVlx5FVcqfmrQ+9JsFwsZdkDUgVmVnfXaE2Y4Lryq8tIRcuGvdem6Y5GK+gVSPpR+fOtwd+J6SMjZpJxkrrsecuTCDI6GiSNwdIpP1getJMGGEAIkkwXMr92Q76QaHQdiV1KahtinJdbxLXaimXThdVnuTD99RDiWpmJG+Dxpopu54RigpJcJdZIbTPm0qh7geLeuokaAtB/veYimhXTSeb89JRJEbiQqE9MfX4rlNCXzLOeQLtFnHJFYCIfACoAk94E8BdwH+paktEHrVM+ayI3AJ8FbgDmAW+DdxkT/Uj4NeBU8APgAdU9Wi/aycrgG4GmU50kdq79t8Mo3odv0k1TWol0PHAwVt6bhadq5SOiS0hqfOc/nHeqsD3EEoKxli6/GWrq5aUGHU786ZYSdjVBVA7AHWVbrzgs1SdYCelQTvKFlIun6w3TYqGMDRqntkJGlN5NITCQsvkol9rJAN/vFJtG5DLJWi2iObmzQd2YJYzvzrN2qwyekGYPNGifHwJ5haMxB4GyUDl3CmDkXxSqCauFKntK5lrz6+bNNDLNbhwEUbyxNftQhoRwcKy8RAKAmR2N809E9T2FKjuNSkiwobR8Y/ONU3Q14WLSLlE4+BO8nNrBIsrRGfPEe6eYe09s1Rn8+RrSn41pnRyydzr0op5traMY6Kms0JCODFuAr9mJqjtLYFAVBDGLqwzcux0O020K9lZr5tsl6FXGKVSMRHgowWiqQrh0qoxgDveWLuHM/xG8xeT9y3cMQ1T4ybtc7OFNl16644MsbTVPEASPJa4OI/kU/7zGwyrDr7aplza8N34K6JUMReXsG1sLPEq8pO2ddb4MJ9Wu2qgn3oaSNs8oiiVK8hdNxUZ3VkDuPNb7yxk1a2f+97t/+/aCkBVvysiBzvanvb+fRb4Xbt/H/CkqjaA10XkOGYyADiuqicBRORJ27fvBGAvBoIn+XcZwHt59HTDZgb/Hmql9GBrrxu01R+JKsZfCXhqF/AGf0/10zXVa8rdtYeE7+7XUwMl95B0bJ8jSYVtB2ZxH0mUjsoNRgvGZa3ZShW7TsLXk2IaVhqyRt0Nq6bIXCtwOV7yeaPvrdc3JpDrON699NHFRbNimN1Dc88kGhrdfuntVYLFVZPff6VK7HmaBBUTjKVrNaKLi+T27mbt7ttYvj5HawzyK3Ddd9YZO3IKrddNRkybWM8vWBOM5Al37SA6tIfq7Bi5tZj6VEhhKaJ89AK6soqurKBBYAbRSong1IVEoubmQ9T3lmmWjAPAeimgeD6msNiieOw8uriURDVLLgetiPyzRw2Pd0xTu/t2Fm7K0SzDjqMRlVeXCBZMbVy1qzWiKMk86gbtYGoKKReJdlRYucHwYnSuych5Y0chitFcDvbsQtbq6PKKMexa3geVMkyOE1eKRGM5ckt1okqB3Lmldo2GQoHczIRJG15dTfLmhBPjRoU4WTEBdAvLqOcN5Dx4Ul5rNq9OtFwFjQkrFYI9MyZwrLqWSo0duEHXc3v2AwvDcsmopfy6BL6LqVut2OpmTtAIJsbRprFzJPmV3Iqjo+4weBK/56nj/65RlFKfJhHMUZSsjhI7RrOVznhgV8F+krvOeuXdtARb0f07vBtG4I8DX7P7+zATgsMp2wbwdkf7L2zq7NJxs1196HunX+g+oPaZRHrBBWKl7AvWk6jT88dd208j7XTtrk/QkQTKXaaL8TlVB7jDoAS0B89uEj/p1Yg/CTijsC+xBzljlNaq5xrqVDyBmA/Zc6XrCjvpBZMTCY+0sQ6N1bY05B3bqQZIVgVhSDg9CZPjKJA/s2C8l5x6xp3H+YTbwdTlwg/372Ppjr3M3ypGYp+DHUdblH/wpjlHccwYnVut1MAflkvogVkIIM6HrE8WGJ1fJ2hEFI8toQuLRC7Cs1wyA+pazRRjGRtFbvlJ1g6MU50NaVaE4rmY4tkm5RP1dg1lK10n9XJVkf2zVO+4jdXd5jnmq1B+J2b8+ArhOzZATWPDm8BK/K6gTxgSzuwimplgxcY75Oox+ZWI4omL6FvvJDaYYLxi/PJPnSGq1YzhvlwymVNFiPZYW0kM+bfm0NU1gvV1YiCYniKeKptSlXOLxHNnzXszOYGUS8TjRVhrIPOLSa4kINHnu3d8QzR6GBoabI2IOJ9Dzs0TLS+3q5MBnYZb9W0bYWje8epqSlABzIogP2K+jfUm8bwx4IflEuomH4w7K2GQ2AqcesY3KNPpXupWKp7KKDWA25KTyerEyy+UGku6rNJTA7/z/Oni9ur6pNo2gR9rAhCRR4AW8BXX1KWbYlJUdWvvds5PAJ+w/1a/HX99Hpi7bCJ7aVq6Xf1y7eHta+zEp3ULWp6+6PU8L/Wce10/Asxqtk1vu21z59jMdas/xrFg7u+C3Tp566Mb3QAn7fZkj9+X+rS/1J/MBJ33WAcWgBf60NsLr9ptq3A8WwXeAp7r0a/m9fNh/t/JkqX3bXqjaq/ho4m57wt9juv1jBxiDN97PZP0e5jmrTu2H3rlxuk87uImrt95L73urdu4EPfp74659Pk2g+s30+myJwAReRBjHP6gthVxp4D9XrfrgNN2v1d7Cqr6GPCYd53nNqPLGgZcTbTC1UXv1UQrZPReSVxNtMJw07v5iAEP1qPns8BHVHXN++k/gftFpCAih4Abge9jjL43isghERkB7rd9M2TIkCHDNmEzbqBfBX4F2Ckip4A/Ax4GCsAz1kjxrKp+UlVfFpF/xRh3W8CnVI3zpYh8GngK4wb6uKq+fAXuJ0OGDBkybBKb8QJ6oEvzl/r0/zzw+S7t3wS+uSXqDB67dJehwdVEK1xd9F5NtEJG75XE1UQrDDG9Qx0JnCFDhgwZrhwuywaQIUOGDBmufgztBCAid4vIMRE5LiIPDQE9+0Xkv0XkFRF5WUT+yLZ/TkTeEZHDdrvXO+ZhS/8xEfnQNtD8hoi8ZOl6zrZNi8gzIvKa/Ttl20VE/sbS+6KI3D5gWm/2eHhYRJZF5DPDwl8ReVxEzovIEa9ty7wUkQdt/9esJ90g6f2CiLxqafqGiEza9oMiUvN4/EXvmJ+z79Bxe09bzzdw+fRu+dkPYtzoQevXPDrfEJHDtn3bedsXqjp0G8ZQfAK4ARgBXgBu2Waa9gK32/0KJrXFLcDngD/p0v8WS3cBOGTvJxwwzW8AOzva/gJ4yO4/BDxq9+8FvoWJ5bgT+N42P/+zGF/moeAv8AHgduDI5fISmMZEJkwDU3Z/aoD03gXk7P6jHr0H/X4d5/k+8Iv2Xr4F3DNAerf07Ac1bnSjteP3vwT+dFh4228b1hXAHdjUEaq6jgnluW87CVLVM6r6vN1fAV6hHeXcDUlaDFV9HfDTYmwn7gO+bPe/DPym1/6EGjwLTIrI3u0gEPggcEJV3+zTZ6D8VdXvsjFMaKu8/BDwjKpeVNUF4Bng7kHRq6pPq6oLu34WE4/TE5bmcVX9XzUj1hO07/GK09sHvZ79QMaNfrRaKf73MDnRemKQvO2HYZ0A9rExdUS/wXagEJMb6b3A92zTp+2y+nGnBmA47kGBp0Xkh2IirAF2q+oZMJMaMGPbh4Feh/tJf0DDyt+t8nIYaHb4OEbqdDgkIv8nIv8jIu+3bfswNDpsB71befbDwN/3A+dU9TWvbVh5O7QTQK+UEtsOESkD/wZ8RlWXgb8HfgL4WeAMZvkHw3EPv6SqtwP3AJ8Sk9m1F4aBXsQECn4E+LptGmb+9kIv2oaCZtmYwuUMcEBV3wv8MfAvIjLO9tO71We/3fQCPEBaeBlW3gLDOwH0SymxbRCRPGbw/4qq/juAqp5T1UhVY+AfaKshtv0eVPW0/Xse+Ial7ZxT7di/5233bafX4h7geVU9B8PNX7bOy22nWdopXH7fqh6wqpR5u/9DjB79JkuvryYaKL2X8ey3lb8ikgN+m3ZyzKHlrcOwTgBDlzrC6va+BLyiqn/ltft68t8CnGdAr7QYg6K3JCIVt48xAB6xdDnvkweB//Do/aj1YLkTWHLqjQEjJUENK389GrbCy6eAu0Rkyqoz7rJtA4H0SOEiIrtEJLT7N2B4edLSvCIid9r3/6PePQ6C3q0+++0eN34NeFVVE9XOsPI2waCtzpvdMJ4UP8LMmI8MAT2/jFmivQgcttu9wD9jcke+iHnZ9nrHPGLpP8aALfwYT4gX7Pay4yGwA/gO8Jr9O23bBfg7S+9LwPu2gcdFYB6Y8NqGgr+YSekMJlfjKUzVuy3zEqN7P263jw2Y3uMYHbl7f79o+/6OfUdeAJ4HPuyd532YgfcE8LfY4NEB0bvlZz+IcaMbrbb9n4BPdvTddt7227JI4AwZMmS4RjGsKqAMGTJkyHCFkU0AGTJkyHCNIpsAMmTIkOEaRTYBZMiQIcM1imwCyJAhQ4ZrFNkEkCFDhgzXKLIJIEOGDBmuUWQTQIYMGTJco/h/BpOGun+jQGcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -56,9 +108,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\28-Mar-2022_15-41PM\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_1.tiff\n", + "(3, 5, 3, 1200, 1920)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -70,7 +130,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -79,39 +139,98 @@ "needs_background": "light" }, "output_type": "display_data" - } - ], - "source": [ - "full = tf.imread(filenames[-1])\n", - "print(full.shape)\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "ch = 0\n", - "for ch in range(full.shape[0]):\n", - " img = full[ch, 0, 0, 0, :, :]\n", - " img.shape\n", - " plt.imshow(img, cmap=\"gray\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\28-Mar-2022_15-41PM\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_2.tiff\n", + "(3, 5, 3, 1200, 1920)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD0CAYAAACSA/HcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvdmTHFmW3ve713ePPTIiVyQSa6G27uruql5nxKFxxFXcTNKLpHf+DfoH9K5nPuhZNOlVlGk0RlJDzlDTM91d+wYUgERmIvfYV1/u1cPx8ExUV2kok1lTqsljBgMQ4eHh4X79LN/3nePKWsuN3diN3diN/fUz/R/7AG7sxm7sxm7sP47dBIAbu7Ebu7G/pnYTAG7sxm7sxv6a2k0AuLEbu7Eb+2tqNwHgxm7sxm7sr6ndBIAbu7Ebu7G/pvY7DwBKqb+nlPpCKfVEKfXf/q6//8Zu7MZu7MbE1O+yD0Ap5QBfAn8bOAT+AvivrLWf/s4O4sZu7MZu7MaA330F8BPgibX2qbU2Af5H4J/8jo/hxm7sxm7sxvjdB4Ad4ODa/w+L127sxm7sxm7sd2zu7/j71De89goGpZT6Z8A/A3Bw341VHaXU6k24BllZa+W91fur97SSr7JWvlFpeU29+vXW1eURqDSXfwYuuS/b6cSik0xe9xyso7AKdGblqK3FuhrrKHIPlAFnadGZwWqFdRTGVahiW51ZMLY4vuIn5VaO01hwtPzbXjstq99krp0mrcrfZFwNCvmO3KCMxTryntXFbpT8rVMj+8tzORdKjh2lUKY4jjSTv10H67vl8avMonIjn81NcRy6+KOujjHL5Lp4HtZ3yH2NdQED7tyg0gwyOdc4jnxeFdfWGEgzrDEox8EGHtbTGPfa9Uhz2SbPUVrLPlynOIdGjs1a8D3y0CEPFdYBlYFOwUkMapFgsxzlOOA4mNDFeApnYWC2QCmFqYTkocIU19WdW/QixyaJXDfHAc8lDzRWKyjWhU5MuS6ysPjtyHe7k0w+by0q8MkjD+ODcUBn8kcZi9WKPJDXlQEnASexqHmCzTKU42DigKyiML6sC28EziyVc+u6mEB+Ux7Id3u9uZxX1wHXJa25GB+cObiTpLye1tFynS3ksRy8M1lCbq6uS+STxZo8KM5rDs7CohcZZBkohQ08jK9l7RhQ80Suj9aytjwHjJV1l+XYNJXzqjV4rhyLApXl2GJNro7deo5smxn5bFasWaXkuqzWowWMHDfWyr6v+wBr5T1k/SmlZC2B7Hf13uq4uOZzin+v7s9yLarini3O119pq+8tD+lqn/9vbEz/wlrb/au2+10HgENg99r/bwEvr29grf3nwD8HqOs1+7Pg76N8H+VobG6wi6VsWFxkHYXiDEFuruJCKVd+mooj8D1ZlFphqxEmdMFYnMkStZAb0kYBi+0aJtDopSE4n6EHE7KtFrPtCJ1Y/EGCO1iAq1lsVpivOeS+wkks0WVOcDEHIGkG5KGD8cUJexODN0xAK1RuMK7GmaeoZY6yFo5OMPdvyc1nLM7lGJJUFqOx2CRB+b449cCX3++5WFejFmnpAE3sk9V8stghizTu3BCezNCTJSpJ5RyEPnk9JA/FufuDJXqWwHkfrEFFEWatzmKzQhZrvFFGeDxB9YaYyRQVhqg4xFZjrOeg0hw1X2JOz7FZhl5vkN3bYrERkEZyLWovFngv+5j5OarioVpNbBRgtUaPp9jRBDOZglY4dzYZvrvJsqaxGqovM8KzGc5Jn3x8gfI9LBnO7jo28FHjKXaxJB+OAHB3tpi+vcXFOx5ZBDqB9hc5jV+dYPsDLBmq7sNWl+VWDWeW4Z6PMPtHAKR/+D0O/tAn311g+z7tjzTrf3KOHb9Etapk97ZImj7eLMOZpujxApVmWM8l2a4zuBcweMNiAkv00mHts4zar16SnR3hPLzH5I01Rnsui47FmyiqhwZvJgnD4J7DsmNJNxKcC5+tf2+ofXKJPXiJWSxx924xfmeDsx+6ZBVD/FJT389p/PoEu+Eyu9/GOgqVW4yviI9mOEcXZP1zpv/5e4xvO+glWBeSOqx9mlP7t0+hYbCbXeZ7NZKqQ/3JWNbMYkl28BLluTjdFtMf7TLZdskixaJjiV/Cxr/ro04vUXUPux2TbtbKZMHdP8OMxnJv/uAO070qky2HsGcIexnR+y8wgyHKd1BrVcytrjj13KLOe5jeAJulOM06bG+w2K4B4A+WOOdD8pMzUBbdqUG7Kfd7mmHHE/LLXuEHPHQ9QjXqWM9FzZfY6RQzX4i/cDRO8VmyDIIAO55gsjk4Gh2FKM/FFsmPWSzBimNXnofyXHAcVBgWDsxg5wvMbAZavh+t5D7O8/KzWAvakf8rfRW4jMVmaenTyu1BXrP/N0FFXQE6f5z/i/1v3/DaR37HJLCLkMB/CBwhJPB/ba395Ju2r6u2/Xn1HwNgk1SyPs9FR6FckCKy4zjybygDACDOyi2yzMDH1CKSTowzy/BOhzBfYCsRthJKZpAZ9FSceN6uMt2rkoWKsCfOXaU5WS1gvBfiTwz+KMPrL1CTObYaMd+pkFYckoqicpLhjVN0kqNnKWk3FocxS1HGYLUGR5E1Q/znF2QbTZzBDLVMsEUGpLIc6xa/zffkR2U5DMdXlUSjRtatYZVUNCozOHPJpvQ8RY1n4DqYekxeDUhrHv5giQkcvIsZnF5I1rzVJW3H5KGDdTXeMMF7cY7pD7Bphq5WYH2NvBGRVzwJVJMEfXiOnUxRcQzdFmm3Qlp18XsJ3ssedjjCJikqCGCrK0EjM6jRFHPZwyyWOI06rK8xfdhmdNtl2YLGU0Pz0yE83pfvr0Sw0S2zI+t78OwAM5uh4xi1tc7sUYfJlktaUUQXhuYXE5zjHtnLY3QUobtrEkBdB6s16rxHfnaOe+c2F//JNoOHwGtTrFFU/m2F9b8coz95Clpj3rrL9FaEzizVLwdwfI5q1kl2WmQVl+Fdj2X7KuPufJRR/eSc/OkL3N1t+j/b4eKHkrREp4q1j5Z4k5T5Rkj/kcvse3PubV/w7Ne36Lxvaf+mh/lqH12rQrvJ5I01+o8kcPgDxfafzvGfnmMDj8tfbHL+Y0PtqUPnwyXhp0eSKFlD/voez/5phcbblww/XKPzgaW2P0MVVer0dkwaafIQ/JGl+Ztz7OExNs1w1jvMvrdDHijSWMt57RmCXiprZ/8IjCH9ySMWax46swQXCd7nB+S9Ae7OFrO3trj4vkdaAW8KtX1D8zfnmGcHoBV6dxtbjcgaAd7JGM4uyQcDlO/jdNYg8Mk6tfKedo8uyS8uizURozttWQuugxqMyc8uJGistVFBIPe376GMgcsBZjCUhMr1UGEg69p1seMxZjovnbSOoiu/ojV2scSmiThtQIeB7L+oCG2SiuNe+R7fF6eu1NV7RZXy247xa87+W5y/cpyrILLy29dRkWv7/mPzP/3KWvveN/nVV776dz0NVCn1D4D/HnCA/8Fa+99927Z11bY/C/+B/MdYlOeiCke4KgtxHIElVrb6v+OgAl9OXBhg45CsXUHl5srRhgFZu4I7WqAmMzAW066RdGKWTRd3Zgj6S/QiI6/4LLo+ViucuSE6nqKHU2wcMt+ts2hJ+ecklvBCFsKqtLaulvJ4BRkVJSzGYnwHrz+HZSLlv+vIgnZUCVGp3KKSDDWeyYLLc8nUG1Vs6JKHrgSapZTfejQTWML3sFpjqj5p1UPnUnJ751MJJMZgmhUW3ajMHJ3E4A0W6K8OyYcjcZwbXWwcktcCrFLoJJMMcTIT57hWZ9mJ0LnFHS0lKIwnciz1Gma9Vf4W52KEuehhkxTdqJE9vMV8KyT3FPOuJj4z1J5O0AdnmN4A3WxAt0XWitHLDKc3IT86BmPR7SY062SdKuPbIYu2xh9Z6s/meJ/sl45E1+vQqouTGE7KrBRA3d7m4O+vsXx3ShCmTA9q7P6RpfIXz2G5lPO83iKPfXSa45wPIUlJ720yvBeRNBTO3OKkoFNL7fkc7/kp2ek5uhIz//3XuXzLI2mJ4259mRGeLVHWcvFOhf5bhsrumNkkoPKbiFv/2yX22QG6UWf809vM1hzSqkLn4E4ttYOE8MUAtUxY3uvy8hch8/sJ1c99bv3RAPX8CFWrkdzrcvLjiPkP51QqCyZPG+z9y5Twgxew3qb3gxbLlkZllupxTmV/gnp+hM0Nutkgvd0haXpMNl1qh7KevVGK9/wUW4nk5BVwzfRug/hwgjo6J7/s4TTqpG/tcfLzmKRpyWJL5zeKtT8/xzw/QDkO6tYWebtCHrr4h33UdE52cirX684ueSsmq3i40xSnN0WNp5jhSBKGdhNVq2LjEDWZYXoDzHQG1uCstaHdJG/GqNyghzMYjCQrny+kmmm3xKlHAYyn2IlUBKULqVclKBSfuZ6lK98TGK5AGMxsVn5OR1Hpg5Sjy6R1BfuVGf/XA8E1564c8Q2vVAvFNqWZKwj3tyqCYt//nw0A/09sFQB0HF+9aA02N+UF+LrZLCsDggoCcf4VieZqtpAyLwwwjQrWUZIlLxJMLWLZjVmsefijnOh4iprMybp15lshyljC0yXuaAHLhLxTY3I7ZtbRoCE6N1SOFqjckjb88kK48wxnkpDVA4yjMIHGneU40xRnOBdsMssFnqqE4iiVIq945J4WKKo3xk6m2OUS3ahj2w1M6EpQSTNUlsv3ZXmBr7rYyEelOcl6FRQYR5X7QiuyrRbjvZg0VmQVReNZSvxsCMfnmNkM5bqorXXydhUTubiXc/TlQE6y62LjkNm9Fou2g/EU8XlG5cNjssMjdLWK2t5g+rBNHiqikyX+waWU7ICz3iXbaTO6G5NWFbmvqO9nxM9HqMNjzHyBs7lOsrtWVjXe+eQKCtnZYv5og+mWjzczeFODygzh8QT7/BAzm+E0m+QPb8nhHl1i+gPMfI6OItTuNmm3ynLNZ7zjsmyDs4TG05z6B2eoZcry/jpJ08UfZPiHfczBS1lzD24zeLPB6K5AVK0vDY1fn8LlQAJmGMBrd5jeqTLcc8liaD3OcRaW+GDMYqvK4J7H6KHBBIb6Y5faQU7jL15iLnrw4DbnP2ky2QXjQm0f3BnUDpZ4/TkqM0zvNph3HJYthTexNB8v8X75Obq7Rv9nO5z8Amgl2FzR/FVA80lK9GIIwPRek94bLt7Y0nySEH7wQpx2vUr2xh2Of6+CzsGbWOKznMrzsawZV7LZbL1OWvUwgZb1cnZJftlDV6uwt8PR32mzWLekaxnRvkfrS0P1+RT1my/Q7SbLt3dJGi5JRdP+cABPXsj16nRI37zFbCNg0VJUTnKi47nAc6fnV/dzs46NAlR/hBmNZa36Pnp3m6xbZ7ERoDIILxa4x33M+WVZQapKRZIiRwtsORpjJhPZt1vAOUVGbdMMmyYoTyBXXQQ9m2ZXQQFAFTBRtYJyXfE/y2W53cqhX/mnb6gErjn364HA5jk6DCTZpQgKhQ9cHfMrr12rBL4TAaDhdOzPqv9YMvnciPNPM8HDrwUAFQYlJ2AXS1guIQhQlfiqOkhSifqVqLzIqyogb8XkoUseOgTngjcT+KRbTRZdH3eSE76UrDFrxYxvh6RVBRbCviG8THHHS/LIY7oTktQU8UWOXlqUhUXLQefgj3K8YYIzXpa4sYm9kvjTSS6ZeGZK0kzlBjuby2+GgheQBWCnMzkvjpZyNApQxmLiEBw5HyZwcQYz8FzSTkwWuczWXZKawh9bvKmhcjDDPR9hJzNUNZbjqsuC1/MULvpy/rptku0Gkx2fZUuzbEB4aen+eoL+7DnkObq7xvJel3nXJ7xMCb88JT87l5vj9TvMdissmg7OUgj62rO5QE2DIbpeI72zQdL2Ma4iuEzwn51JWZ/nOA/ucP5766Q1hbO0RJeG+GiB+/SY/PwSAKe7ht3qQGZQSYo9OhEHs94lfX2HeddnuumAAW9m8ceG+ucD7PNDgd02Okze6qJyiE5m6K+OMJOpBKS9Dv1HESjwx5bG50Psp18Jd7G9yfidDYZ3XSa7BidR1L+C9scz3NGC5WaV3qOA+aYlrVlaHys674/gw8eoMCD5yWsc/Y2ApJWDA/6lpvEY6s/mmMBhtu4x3tO4M1A5tL5YEn0h51ZHIbPfe42D/9SBzhIz9tj+N5r6pwPU4TF2b5vDv9sirVqiE0Xnwxnubx5LFdZuMvn5HQ7/UGEDg3/uUnsOax9NxYG2aqStkOmWT/XFAne8RI/n2F6/rBDnf/AWpz/2SB/NqddmTD9qs/4rQ+1PnmCGY3SzQX5/i9HdWHidowT//a/IRxOcB3cY/qDLoqVQGXhzS+3ZHPfpMaY3QPkeqlqBZl14rMWS/KKHzVKB/m5tkXarzDcCWTPDnOhZH07PxfGvd7Bxgc+nGZz3MJMpNkuFH6hE4ktyg80ygXoKKEfH8RX+X/gWmyZXficIJCnQGhVHr1QSynMlifJ9sEY4hzS7yt6/xXQUvRIArgcQm2ZXAURfCyzXq4DvUgVQBgDna2pV1y1VMCtytIR+slwcfSBQkZrOpVT1PfJ2FZUZ9FggF1uJyLo1jKcluyqc7irrVYkRuGOeYmKf2U7MvO2gLIT9nOAywZ0kouYIHKZbvihGFgZ3mosSJNZkgSLsZYQnU9Q8wdQjsqpPVnFQmcUfJmAs7sUYlolk8dOZKGlqFVFFLBMYT8vsYgV/6brgo7Z5hZOWmUCWYyOfvBow2wpIqpr5uiy+6qGh/nSGczFGLVNsFJC3KyzXAtxpjn88Qi2W2NkC5Tqk9zbpvR4x21QEA4jPDfHLBf7BJXY4QrWamEaFZSfCnQrHYoqMX93dZblZpf9QILTKWU58tMB72cOcX0pm1m0xu9sQ8npqiPeHmMfPAXBubTH64SaTLQfjQtizNJ7O8Z6ekBXZodNuwkaH2e26wHafPMNMZ4LV3t3l9PfbLNoKZwmVE0PlZYJ/PJIMdjjC3dog32yR1QOBsV6cSVBq1MjvbTPfjsgCjbswxIdT9P4J+WUPd3uL9HaX4YOYZUuR1EW10/oiIzqeY3yH3lsRk9vgDxTxiaX1qTh+XYlYvPeAk58FtH7/hP4kJn1So3qgqB1lGFeRVDXLlmK2IaRx87Gh9X8ekb88FSdz5xZHf7fDdMeQVw3xvsvmL5cEHzyHdpPlbpPe6wGTXcvaR5a1PzsmPzxG7+2wuNOm/yhgdN9g1xIqH4ds/dkM91SqhWS3xWgvIK0ogoGh/S+/EOeZ5wK1tOrM7rc5+NsOTqLIaoat/0PR/MsTbK+PatTJNprksYczSyWbP7vAzGa421tMf7BD/zWPLITqoaX94QB9MSQ/u7hy/I2aKGVGE/JeH7tcCjew0SFrRqQ1D6wluFyImOHlqQSmOEavdzCNitzXg5FU0UmK8j2BFl1H7pHZHFvcV6usX1ciUcklorwqnfc1x6sjCSw2y14hb3UYCOJQJKk2Sf5KHuDrnAFcy/gpKoNrHMO3EsLfuQAQ/0MpzQA8XyAc170id1dmDEShYN8gTi1JRJ4VhZh6jHUUTn8qzr9RJa+HGFfjThIhcishi82KOLD+XPDFVo3ZrSrzjmStleME/3wq0sHQI2l6zNsuKIhPU5ylwBFZ1fstGMg6mrTul3h7iZmPF6j5UiSUWY5ynZKclmpgie31pfopVE/KdUSWF0cidatEJa5vwwATS6k7uR2hLMzWNc7c4s0swSAnfjFCDcbYKCC51QIgi5xScYMx5DsdZjsxs3WHNFboDOr7GdUPXmIue6g4In+wU6qkgn6C++Ql+fklTneN5du79F4PSIpKoXqUU/nyEs4uMPMFul7HbndYdmN0ZnFmKc7+KquN4N5tLt9rMbqHKGYODK1fX5ROW3mu7GNjjbQT4/Xn6NGM/OUJyvfJ377H8EHM+LZg6O3PM2ofnpEfvJQMMooES95cI68G6EWKPjwvjz99uE3vrQidQHyeU3kqlYLNc3QUYu7fIqsFJA0XZ2lx5xlWKZyF/D18GDPZUbgL8AeW9T/aJzs+xd3oMv7JbQ7/lkZ3ljhuTvYyZu0DRfOLGfOtkEVDs+gqjAMo2PzzJcHHB+Tnl7i722QbzZLAndySa7P2cUp0PMW6msmdCtNNB2duaT5d4n98IAHt7i5nf7DO5bs54bFL9YWlcpYRns5xji7A95i9vsFswyPs5ajcEh2MsY+fyTn9/n2Ofy8uVcpB3xL1DJUXU+FnDl6iqxUW797DeJrgcoHz7IT84gKn0yF5a5fB/YDpjsKbSDBvfzRCff5coL/uGqoSY+IQPZxgk0TUQKug026QbNfJQgdvnOKdT6A3JL+4kPu+4HxUGABgx2Py0QRdiUUU4nvYaix80GyBuegJDKS0rKc4FsFFnmOGY6kUfF8SzWuiE5tI0lZWBEqVih8dhRJMvub0S8jma45bR1eoRJnlX3fw1330t0BHX9/ndyIArGSgpdRzVQk4TqmLV74nF2ylMQaBMlxHnGkYSEbtaNSyiKxRgI0DgYFW+n+tsaErFcJoBtaSbTSYb4aioU8s4blg9stuXEpAg5EhPlmi0rwkd/PQQZlCE4441rTuoozFH4pySLTCFj2eym9aaeN9T4KVq3F6E+xgJAGvViFvVYQQni2hP8IuFqjAR1UEtgGw1Yi0FZIHDlaBu8jRi5yk6QuvMVuWqqK8GmB8B50ZgaV6Q6wx2G6b8aMGvTfk98SnViCBgwvsbA7dNtPX1phuis6+9fmS8P3nkhFvbjB59zbn77hYR/Dr5lMhGfVXh1K9tZvYyCdtR3j9Bfp8UGL0TrNJ+tYe/dcjFh2BBWoHhub7F9jDY7nm1YpwO9VYyPM0w84WmNFIbr5bW/TfaTK6q1EG6s8NrV9dkH/5FU6zCd022VoVnebCAc0W2MEIu1yKg9jbZvygThYqlBEZq/vlkUCQtzZYbFbIQ4U3zgmfXkCSYisRy90my6bLsq4xPmSxov1ZSvzBAflFD33vNhc/7zK6B+ndBVwENL5Q1A8ynIVh3vGY7GisI461+WSJfzzCPJfeSfPeGwzvReQhWC0wlDczOAuLN0xI2j5ZqJl1Nf7Y0n6/j3nyXDLLIpheft/iThWNr6Dzy0vs/hGqWiF9fYc0dpltuEQXRbA7OMYmCU67xeLNHWYbHpffl6BUPVC0P10SfnRQEv7q1hY29ErRg312IKTtGw/o/aBF7y2RRRtfSOHOnx4LoQ9C/DYisppP+PSirBRWIoTlnTWSuovOLP4gFVnx9W0adeGmCq7MzAt+LQhwOmuYbiETTTJBBZKU/KKQioZBeR+R5aIyKtQ9OhLuQPme7LcIClc9R46QwwV/cJ1MxppSbaRc91Uo6JrD/q3AUASjV6Sj15VB36D6kfdsGUj+2P7P350AULLvuRF2fdUYUpC8hIFkvrMCf7sWFFavAdCoSvAAwROLG7c0z5Uo7LuYQl3jzETKaUKX2XbEoiHNPfF5Tnie4PZnWN8ljzySpg8a3GmOO0kwnlO+5k0ykc59Te2jFsuyCaskb6cLgXuSFFWtkO20haMINNHBCM774vwdjapUsJWIvBljfAfraVRqcArVkR6KSkEtU2zgkdxqkVUc3GmOTo2U+xc9VKUiUEaRteoMonNL84sZ7uNDqbw6bZLdFsM7Ae7SCt66PxbN9q0ug9drnL8H1rf4l5rW55b2nx4JnBUE5FttZrdi9NISns3KbFuHAWp3m8kbbS7fdLFamoc6H2ZUf3NIfnaBrlawtzdJWxE6NXjHA8z5JWY6QzmOKILWmiQbVZK6BMPgMsF/OSB7foBTrzL/6UMWbZfKSYJ/NIT+CDMaSYa3tU66XmPwMMJdWsKeYMn28BibpDjbG8wfrjPb8NAZ1PZnEhCXS8ydLRbdiHlXKoHq4QK3PxMZZxyTP7zF5TtVZhtyXoO+pXKSEx/NWK6FTLY9JrtyM1deWtY+nKA/eSoZcbvJ/N27DO96zLYUQQ9qhznhZYpODVnkkDTcMliF/ZzoyYXITze6JPc3OXs3ZtGxuHNF9cCy9qtL7PNDdKvJ8rVNhncCFmtK+Jxf9jBfPhN49eFdzn6vxXQHVCaf9WaW5kc9EQtMpjidNrbdYLlZxb+YoV6cFP0iAeztsP9P2szvJjhxhvskYuOXOfHzkVQUrova2SRdr4Gj5P44OhFIbnOD9M4GiwLbd+cGb5jivxyQHx1LsPZ8dLOBikO5l+dz8sFQXi8UYqYalJyaPT4rMX7leuhGDZp1uT+mc1EZzUUGXjruwMcuk1e4geuZty54xuv9AattlOPId6z4hSQpCd1XIJ1r2X7J9X2T84dvVhFd+87Vfr4zFcDPK/+oJFKkPLo6gSglkIjjCPFbVAkqKALCqmnMdSVjDDzJFhdLIW2uk6uei1lJHR2FO15iPQfjOaR1j8WaNE55M0N4keKfS+aedCssOh5ppAnGOf4wQxlLFjrCLUyyEk/HcbCug6lJ34FaZKgkRS0TIVl9Ty78fF6Sulm3Th67IocbLVDDyVW1E/iYuiikVmoZ4zvoJEdN5tJ16zhS8biarBagM1kgTn+GGk0gDMjXalz8sMb4NlgH6k+h/clMJH9pCmst5neaJA0Xf5TjzjP8J6cip9zb4eQP2gx+KDd5PnNp/aXH5r8+h8s+tJukW3WWTY880PijnPiLM/KXJ3IcO1sM3ttkcF+yZquh/amh/tUEPnqMrlXJH+wwvB/jLiyVoznOkyPy3kB04O0mebdB2ghExrrIcE+HmLMLwXs9V1Q/mzWy0MHvL3G+fCEEZKMOa03mDzosG1LReXND9dkE/fQl+XCE012DtSZpu6jKiv2TpNhGlWS9SlYRJVR0ssD56pj84kLggHde4+hv1kUCOlRUjgytDwao8x6qEjN5c53zd1zhlC4ttRcZlfcPyE5OcZpNsjf3GN0JmXfEAcTnhugsJTifYSKP8V5MHggh7o9yKl+cY07PUb5P8oO7HP8sZL4lpHL715rO+yOcixF2NCF/tMuiEzLdcF4hXvPzS5wHd1juNjl7N2DRsYTnitbjjOjlHOfpS8xwLM5xowOBKN7UcEJ2LLyE3rvF5U/XGT5QJHcW6LOA2r5i619dCK+jFbpTsiA9AAAgAElEQVReJ7+/JZDZLIGnh5jJRNRE93cZPqqT1BXeVI5tJa3F5CjPF46guHevY+xOQ5rG0nYs0ugkR5/2Sv4A7UjCEUeoKJLPzuby93Ip3EGjLus+y0DpV0hj5XtXMNAqKFxzyMot+nW0KgniFVwElHC2LbrZy9dWnf7Xm8Hg22Ge60Fj1WwGZXXxnQgADadjf772X0oEXS6vWPFV9FtxAMbISSw4glVHsHJdwchBLn4RictyD8TxhgGmEpWKHJUZrKNKfNe4imCQSYazSDHVgPlWhUVLSEmdgTc3uFODTk3hKCTD9g5FnWJqFbK1iCx0CC7m6OFMWu6NkQC2GmVgijEMUYD1XWlOmy1k/EEUyPiBin+lHJql0k1cQCErHgDXlf3EIWknhtziDhbo6Rxz0UN32swerdN75Ilsr2lY+0vN2kdj9PPjsjlsttdg3nXRqaXx5Ri9fwJZRv7abc5/VKX//RxCg3PpsfYRNL6a454OyTs1prciphsOWGjsp1Q+Oy8x4uz12/Rfj5luqxIqWvsspfKpBAddrzN/9w7jHZdFV1F7YWj/+2Oy5y9Kief4bqXsxK4/GaM+e1ZKPXWjjllrknZj8sAhPByXjWPurR3GP9qm/5pwN97I0v58if/Z4VVFcneXtBOT1Dz8cYp/0MeOpVs5e7DNdCfEWRrioxn6+TFmPMGmGe7WBsnddfpvRGVAbX8ijV28PEW1Wyxvt5lu+6SxIuwb6p/1MV/tS2/D3g7pTpPFms+ioXEL3sk7l0ou7cQs214J89T2F7if7heKnBAe3Obk91sM3lvinvq0P4XWp2PpX9CarFtncqeCP5L16Z9OS3xfd9eYPuoy2XZZthXBwIqK6fEhdpkIhh4G2FqM9V30aIY5ORPorlEnf32P4f2Yya5Ab7kP67+R625Oz1HVCuZWV/pD5qk0bhVwy0qlNd0MmHe1yEBPlnhfHJFf9iSbXmX7WV42KK74mFUjYtaSZkZnluGdDMgPj0scX9frBc+WSYKYpEL6BoGcuxWiYOxVY9iK2C04BNLkFXx/FRRWaiHlule9AV8nhqGEaH6rYvi6FTDQSgVkVsns1+1689i1/X1nAsDP4n9YsuJqBfUUrPuKqQfE4RXVwer/5eyQ+Ry7LGSVvo+qVq5UQmmGDXxsHAjsE7lgEZhkluOOE1EXKEXaipjcDkkroibRmcUfGfxxKjN5QLL+YYJO84IM9mWejaNk++NROZbB1CJpezdGApHjSKUAEtwWS5knUqtgmhVMIJmCCR2ceYaeJOjLATbLXyXHo1ACiOcUfQam6IHIsfUKk4cNhnsu01sWdw6NJ4WTOLoA12X+aIN515Nq52yJ9+JcAmi7yfjtDmfvapK1HBVlBE9Duu9n1H75ApumpG/d5vKNkCxW+ENL43lSkpe6EpP96AHn70SM7xpUpqg9U6z/eoK7L+U5W12Gb7cZ3dGkVcutf71EJwb17z/CadSZ/ewBoz1xUOGlpfPBFOfJEWY4xlnvYFp1ko0KxtOEh+MrKeh8gfPwLtOHbXpvuOQBxCcFzl44fqfdJL+3TdIKZK7PMsc7G8NZQTAWznuy4xMMDZVnQ/LPnqDDAN1dI721xvB+RB4AVjD65sd9OOuhahXG31tn0XLwx4baF8MyIDmNOst3HzC867PoqKIaSCVRmKdY32V8v0Zakfk7YU+ku/qTp/L5+3dIdlsM7gVc/jhHzzWdXyvWft3DvniJ2t1i9KYQ/ToVHsr/eB8znog89427DB5VSWpCWFcPE4LzGTx5IVLRZkMa6ShUdcZgJlPMZIKz3mXy8zsM96Sfwpsilc7HQ9TRGXlvIMHh0a5k++Ml6vD4ipjd6LC402be9aSf5DSVKu3xYRnU9HpH7vvAh95AcPg8x2nUUc066WaTPHZxFjnONEH3x0LuzmagtHQF1yrSVX92QT6aSLdvHIvSqFaRe85xRPhR8FGlxj+OxfGvGruKLFtHkaANUKqIlOeWzvq6A/8PcvyrkRDwWxLQ6/O2XpGCfp0TKPzhH+f/4v//AWDFAQAlC18GA9+TC5Nl4pyKeRwr8ndVSq0cIyDOEQRqcRysVqVuPm+EMr+nGDwWXC7Q4wXkOXm7ymI9YtnQGE/hj42QuZMUq1R5cVZzfnSSYyKXLJTvcxe5ZN/jOeQ5thJhYr8koFdDrbBWFD8LUQSpOCLfbGF8l7Tu4Q+TonEtveIwkvSqFAwCbKOK9V3UPJFgkhXfV4+Y3Yrpv+aiixhTOZHmNf/lAOu5jL4nxK7VsPbJkuDDF9jpFN1dY/FgneOfBcz3UvAM3rFP6zPo/Okxtj8ke3OPy7cjFmsKfwidj+f4Xx4L+dmokT/Y4fLtCrNNRVa1BJdKJIdPXkrHbaPO+AdbzLpSVVWPc2ofnYmUVCnyHzyk/5rIUHUK1SND68M+nF6goohsq0Va98UJzFNRpLw8wSYJ7vYWo5/uMngg18MbWdY+W+B9fiTKmFoVNjrMd+skdYfq8ynO/qnAip6P3emy2IixrgIDQX+J8+wEO56galXS13cY3ZZmwcpJijtNJTgPJ5BlJK9tMbodkodQf5aUhLmz1ib53h7j3YDRHYXKofFM5Lnu2UgUWusV5l2f3Cv08yvp6mCAu7nB4s0deo8C0ro0jq24k8qfP8OMRvD2A2a3KjKm4VKO2wyG4tRrFeYPOsy6Qq46iaX+WR+7f3Qll2y3pL9kPL3S3xfqKXOrS+97dYb3QWcKbwxb/24sMNF4ImqcWoV0oyGzrw5PBborKqzJgwZJVaqc8CIl+OoM0+tfEbvdNUyrVso4zWB4BdO0mmS7HUxQjGaYZ9Lv0h/JHCAryZ6O4/L+lxlA86tqoFEF35N5YPMFNssxo1E5KqKUmVP0ABROeZXxAzKfLElK0viVuT5wJQVdIRN8QwPX9c8V9nXJ52+NgVipir4uDS3suxEAVNv+vPKPgCtNrHJdKbfSTLLka2MfSuw/y7GzmUTgRl0yB1PIKYuFbaMAGwbYwCmHsJnAlQFxhUPO2hXShs+i5eDNRNvvTQolkVKY0CEPHNxJKgO4AgdlLVYplJUM0unPRGUSBeWETUAWNVw1qmldSkFxXUyjSrYWSS/CSq3SE302rit8xjUIaRXMrFYCBRkr4xtaMUnDZ7bhMe9I5bL2yYLg8QlmNEZ315jfW2N01ycPpCO48ukZ5qJH9s59Lr4fM3wjR7cT1EFI8wvo/rLILB2NvbPDyS+aLLrgzqHzYUr050+Es9nbpvf9Jv03IA8t/kBTe2FpfT690prfbotzDGTiZv35AveLA+Fn7txi8lpTunWbUDuwNL6a4x1K7wHrHWYP2yzrklVXHvfg9Fwkoq6HvrvL5I01hncEZ6+cSO+C98URynVYvr7Noi0jMsLTJe7lRCSq0zm6UcNudpner5PGmmCUEx1N4asD7GKJbjexWx3G92sYVxFdpIRPL0S15XvQaZFXfNK6z7zrEZ/J+/nLE/TeLcZvdxjfcshimfq5mn2kpgsIfJab1UJeagjOF8JbFPp27u6KyumOJm1Y4iNF2Lc0P59IQ99sLlBEq07aiQn2LzGn59JFfWeXwXubpLHMLVo103knA+lEznNUrVpCpLY/lEF71uA0m5j7OwwfVjGuIg9l7lF0kROezUXuedkrezJYJtJxu1J4rbWZv3uXxZrLrKuJz6WLu/bLF2Sn5+Jcw0Dm+3iuNGoulldNfmtt7MYai50q7iLHmSQyUPG8hy0guBLuicLfGuegfB9nvYtZq4tAYjzHjsbY+aLM7uEqcy9x+mtqntKMKSuMclTEtYz/le7dr2H1yvfLgCIbfUNF8E3zgL7JVvzD6ji+S30AddW2P3X+ThlRle+LGmSxvMr640gW6zLBTqXRA8eR7SoRNgwkW6YoX30PU4nIG9LE4QwXr8Auqzk8y25cYvneYEFe8bEKnEVGVvNLHbReXjVrZBUXb5Ki5yn6YliOvs26dayj0YnMsgEke4+KhpFVYxdgfY+sLSWpsrYka60xgr8WstbVyNmyEvhaF3Ae+2QVVwjKgsMITiZlV69qNZi+0SWtSMZdfzKVbl5jsG/c5cXfq7N8JIoIs3To/juP7v++j+kP0JvrjL+3zmjPLaSmltYXS/yP97HLhOxHD9j/uyHmzhyTaoKvQtY+zal/2keNZ5i1OvOdCmc/9KSr9XFO/aNLzPMDwf5/tMd412O2IVrx2pF8lpen0pxze5P5rSppxcFJDNWPz8tpns56h+Vrm0y2fdKqjEqILjKiZ/1y0F5yq8Wi45FUNeEgp/rpJWb/UCbE3toib1fJaoGQ1v2ldMT2+nJN7txivlu/kgGPDY1fnWDOLqT8f7BL0gxwFnnZWa5OLiXr3t3m8hebjG8r8sji9xWdj1NRdp31ysaqecclGF3N58mHI5xmk+QHdxncC5htKhYbOZVDh+aTnNrHF9AboDwPolAaGQMXZ7gQmGm+QL/5kOFbTYb3NGnNUtuHxlcJ0WfHorKqRKhW84qTmi/Ie310rYrZ22SxGTPZdGX20UKCdfPxvMToV5CK7rQxtQr6ckB2coqOY+zrMgn08k0Hlcv46PanGZXPZVie8lyc9W4x4dYRRc5geDXmYe8WkzfXmK05eLOiF+flUKC96fSK2F0NTPR8qRayFVrgF1l/DVNAWbo/KgfHvULc+v5vqXVUGKDrtSsecbkspn065fvXid7r6p1VQFjJRF9pKivH3P8HzAKCV9U/36YE+q4FgJ+F/+CVcdBAOQpBd9rYSiQL5qInEEocoeo1cYjzpXTQFrp3W40LlY8WrHA4vZr2V0gwTXA1b9wZioQ0rwXksTg7nVuceVZe7FXHsLIW97h/RcJGoWD8SpE1AtzhEpVk4nxzI7r9670LReBZjVcmSWXBKY2KQ0yrVgaJVSczIL/Lc8Fzyeohad3DeBplLeHpvKwcbJaj4rBUzBhPo1ND+OyyJGZnv3jA4L7H8M0MHEv1sScZ/ZMLGE4wexvMN2PmHQfjFdMjP+rB2SWsr3H8Nzu88d98xlY45M/O7jL51xts/MWC4POXWGOY/3CP8a7LvCPz86uHlrVf9cg/e1Li+5dvy80YDCyd34zRB2fYyRTdbpHe7pRjOKovM+I/e1IqdeY/3GPwQLpKnQSqL3Nqnw/RfYFS0s0G/UcRi67CmcPmn0/QH31VOhn18C7j1xvkBcQXPx+hTs5llEG7SXZvi9l2yHRTxhlH5ynhiwH2+AwVhtjtDmlLBAerSZkrybJe78iYiAInj86g+VVK/MkxdjxGNeqkt9ZYdH28ccE7ffYcM53h3tll9lqX8a7IY92ZQD3Nx3P8/QvspOgj6bZFQryQvobVpFX3zi7j74naKA8twUDR+bDoTej1Ua6L3uiSdWo40wROL8h7A3FYbz/g9KcN5psW40N4pqjv51T3p+jRnPzJc1YD2JTnyWDAYr6O06gz+YNHnP7EIdlIIdM0P3Lpvj/D/eJA5gfFMbrdIttqoWcpejgRxz+dyUC2YgT0Ys0jjWXCbvy0LzOh5vNylINqicbfjiflKOZXZJ6BL1X5YikdwbN5md079WopLy9JX65koLoqyZiZTK+av1ajIlYNXFrLMLrrQ9ooOoVXAyvh6vPXoKSVwy4Dw8q+LfO/7vi/rUpQ+rsBAZUqIKWxs5lk94WEDK2K+Rsz7KLQ/8eRlGmOI4qNNBFitJBUriAfvcjgoi9dwmFw5YxXC2U1p6fqY1xNVvXwxiluf1aStaYmFYRKZeSDHi9EzlnILrNmJOMdelPZv6Nkdn8uoyqke7doJS/m6uvRDDuRqYYUmcVqfwBkuUg3QSoC38fWK6St6OrhNgr0IseZJegLwUxVFGHaNSb36+V46+jJRZk1q7cecPKLJoO3M1SmCC4d1j7JqX94IQ1nO12md6osmg7+pJi/8+QlZjDEWe/Q+xu3OfkDw7tvPeWLi3Wy95vs/S8j9P4pWEN+b5veW1XGBc7d+Tin9nkf8/g5KgxY/N7rXLztkdYt4YVi61/1ZCjcdI5za4vZa13ySAsU08+JH4vO3Wk3Gf6thwzvaeYbBp0qqvuKzgczvE/2UXFE8mCDi7cjsgq4E6ic5dQ/G2C+fIauVsgf7TK9FZEF8uCb+tMZzlfHJU6ePdhmuhuRxhIYwl5K8ORMOqFrVfK7myxbAVmsqX8+gNMLCRorCOlBneFdF+OJ8259LjN8TK+PrtdI7m+WOHZwLOOQ7WyOqlWZvbfH5ZsexoOgJ8PbgvMZ6uhMOKJWE1skAHq2kL6IyaSEOtLbHXpvRCzbCncKtaOM6sfn2Jenop6pVWGtJUT5TLJuAGdznfEPtxhvu8y2LNaBypES5/3lUbndKmNeTb5c4evq9Xuc/7hJ73sWW8lwLzzan0DnTw7JXhwKMdtdk/Wd5fLZwbB0yGx0Wew2WLY9VG5xZ4boYAz7R/L7XE90/oDSWiDfAt8vFTsbHfJ2VZK9eYruj7HDkRDAUM7qWSVVZrEEkwsxXKvKflcj5pO0hMFW5Ou3wkTFtNCVldg9AguVjl/rVyeGrprDvi2z54o7uF5VlOqgr80D+k40gjXcrv15+78QjC7LJKJ6fkn02pmMI34F/zfmqjMxjstOYAqljF0spWSrV6WzuMjIVw9gWY2IziqujI5YGryLmbSlx6FUCqEsHL3IMJFHHoqDz0IHbyT7U7mRQEPh4BORaFrfk8ASOOV4CGeyRA0nwk8U/Qq2El7NLJrNWT2sZSXvRCnSjQbW1xhX459OUcagpnPsaCL9EPVaOeW0zPhfDKSj1nHIv3+fy7cjRvfBuJbWp4rW53O8zw9QUcTitQ2G93yWLXlwSev9XtkdytsPGD6qcfozS7A1I880+nHM7f9ViF273WGxVaX/mmT07rxQ3Lz/TBp99m4x/NEm/deEdI5PLN2/HGA/fyrDw/Y26L9ZJY1F597+fI7z4VeSXd6/w8XvbzJ8CMlaTnDm0PnAUP/oAs57qDBg+fo2wzsByorypXKS4v/yS8mqd7aYvbnJ8K6HdRXhZYG/778sR1TkdzeZ3KmwrCmaXy2l7+Osh51O5QZ9cJtlNyZpuESnS8nG53PsZpfzn7YYPYQ8sK8EJf+rE+nxaDWZvLUBgD9IyuamVc/D4LUK/TchbWd4Fy6bf55T+8tD8ovLMmNf3m7jLDKc0QKOhfdYqZiGDyuMb0tHce2Fpf3BAPXyQjqli/EbapGiRhMZWx0G6FaTfKvNohuxaDvF2pdxJeXAvTPpMViNUzajcZnVroLp5fcqTLcUWWypvlCsfSp80yvPZJgtsLNZmak76x3SO+sMHkqgzUNwZ5bGc3kYUdkjEMci/GjVUctiRMSKWF1BPN0mJnRJq/LcC+d0QH52/up2tapAOUlSSjZXhLFqNQSGynJsXx6CtHoOwPWO3+sZu3KcV6aFXucTfgsKKrqC7XL5zc67yOp/a/YPr/YYlI1iX/98sY/vTAXws+g/A4rs3vOw87mQOsaiGzV5bSWDXJ3s+lXHL/OFNHXkoo1X1RhTXCx9OcCmqZSvrotp18iakpXreYZeZqLUKRy3DV2BaDLR+qetiLTqYnwhYIOLpNTaAxIwlMJUfZzxEuvqEmJyJktR6hTafdH9e5jYk+aV0QxTkF+6XsNW47KrESSorEhrPZ5j+0VW5miZbxMFZI1IAlGSo/vFU8aikOXtNoOHAWmsMAG0vsyoPJHuTKfdYvb9W4xve1dSxl+dYvaP0JUIu7dN/+0G5++BiQzhsUv7M0Pjkz5qMCa93eXsxxUWaxAMoL6fU/vkEvP0hTzR7J3XOPtxjcmuRQHtjyxrf3KIueyh19rM3tzk/Ic+3gT8YdG1enCMXSwxP3mT0/dixvdzbDUnfuyz82+muE+PIUkx97YZPaiR1OTBJdHxlePScQwP9zh/r8HgdUt0qmk8E5hIFSMm2Nlk/KjJZNPBncuMnMpn56JEchzU9gamFoo6zHXKJ6FhLeruLqM3mvRfc1i2DX5f03xyNcJCVSskb94qRyHXDpf4T07Jjk9x6lXSt+9y+pOYyf0clSjcmaL9saX9Z8Xgt6LxKuvW5bkEpwPMZU+Oa3eL2V6DRdthuq3RCQRDS+PZAu+DpyWpbe5skVc8eardkxfSE/PwLvO9GoP7HnkI0Zml/nxJ8KInv614GApayRA215FGskKiqfZ2SLsVRnsh49sKbypzj9Y+GqO+2C8dt+60yTt1nP5UegcKeGr6RpfeI0/IcN9SOZJJp/4nBzLfR2mRe7YamDiUAYWnF2Wlo3e3SXeaJDV5II07kcm8ejAhPzkrn6a3evznCkpePT+gDGjFHLFVR/D1mTyvyDnhFSlnKQW1pnygzCuKnZVdl3hef3DM154YVjr+bxv38A1D4L5JVfSd4AAaTsf+vPFPr0ZAJClmsZSIW62Inn8hj3izeX4VwaNAlDdjGfJUwkVRIIEgz6+apgJf9MHF80BXCh5pvJJ5NVYrvOGynBuTt6tk9asmMW9i8HsL9KzAD42R/WU5NvRevYjWljitTZKr5xUoJd+dpAK7TKcy5mFjTQa7rXiJyfIKSlr1DRSjrikeF2ld5woPLkpes9Zk+qDOZFOyO4Dur6d4hzKnXzdqJN/bY7rls2hp1j5d4H9aNEZFIeate1y+U2V0FxltMVJ0P0ipfChwidpaZ3G7yWjPJ6vInJjo8RnZi0OZ9f5oh8u3o3IaaeXY/l/cvcmPZFmW3ve7b7B5ns1njzFjyIjKrCGrukrdTbIlNimIlCBIa2rDlQRwJQn6CwQIENACN9JOBCRBAgSIgrRo9kLquaqyMrNyjjk8Inx2t3m2N1wtznvXzCOzigQoEmAaUECWu7lbuNl79557zvf9Puq/7KO/eo5KJQnuX+P497IESci91tR/0TGuUf3wFuc/yjO4HeDU5vjnadp/CaUPo4W/VqT7oMSsLqyZ2udLUn/12Cw+4b1rXL6XY9qS186caiqP5iQOLsGyWO5U6N1IyYBzIY7b4sdnplVib7RY7FXxUzapixn2SZfgsmO4Q933y+Z3J7uawsGS1JsBdHqodBpvq8poX6rb/BuP9MsewbMDcc3e2KP3oEznocIrBWReOxRehpQ/ujDsI6tcIiwXCDMudn9K+OpQTGe7W4weNLn4noO9gNSFJn/okToao46EimkXC+jNJn4phXYtEm960vqLUA+XPywz3lGkOlA48Mk+7aLfHBtNu8pmjbeEIDDhK3axwOL9awz2EoRRYZo/DEh2FivXLsjinUmjcxnU0sN/dQiAs7dN74ctRjsWQQJyR5rqrweok0vxZEQu7bAkoTFOfy6D28g45uxssdivM95MECQU2XNfUugOzsT1G6d+xSDJqGpf1+WrTEb8AVF4Ehc9kYEuFvL9RGKVO7IOaoMVStoVSkHQ7a/aQG+5fb8h4Yz0+/HGdKUFFL3Wb8Q9g9kEvhE3uTZY/m5sAE5d/6Tw981wZp3PQXQEi1N+lG1jlUumQondwFalRJjPorS+simofHallhhLxaDnCyjmJfS6lMLLONjLUDAMvSlhPmUwzqKs8YwULcwlpBWkkLCX8UKGuUpJ5RKKtDQOb9G2IKpZevK8MERHPUyVy6ILWZb1LEHSEkPQ3BcZa5xmpSzDPNK2JeTQeIA8X0iryFLoXIbpXoFJwzHW+srXM5yvXskx9tYOo+t5FgVFcqgljevgRMBuW5t4OzXOfpTBT0GYgOyRljbR6QASLl4lw6yZZFGwSEy0aOhjXMDta5z+XoXJpsbPhWSObeqfLCULttuXRLDb23Tuy4nMmUL1l5IaZdeq9H62w2jXYlbXWIFEKVa+WoqiZzJjcatF/7qoYrQFrV96ZL4+xX99iLOzRfenm8wrkUHPhvITj8zrIRyfo1JJvGstxlsp+jcs7CVUv4oksGcXWM06y82yUFuXPnZvYloCVjaNd3+f3jtpJpsy1yg9FXyFevxKnK2bbRY7FWYN0fAnJiH5T07w3xxjVysMf/ca3Ts2YUKjfEX2SFP5aor9xQtpc5WEbUTClUKl25fhrG2j7l6nd7/ItGkx2Q5RATQ+hPKfHeCfXchQNpI6B5WcDFhj1UuUq9B/Txj87hRS3YDc5ycipCASV0SCCWu8RJ1eyIxgvjCBN/Nmht7tBM5MU34im2lwei4zp9hZ+xZO2UqnYH+b0e0i84rFMq9I9jTlJzPsXz8lnM1xNtuE1QLLaprE2QSrN1yF+eRyqHbD5CqrUIKYil/24cVro8yx0ilBxMSKnTVjlpXPQaMq8MekFH72SVdeYzpdLfzRicHINdcX9+gkgZsws8m4TWSlklfVPPGMIEJJmw3obWMXXNH3w29QAkX3vjzhN0tEvxsbgF3TP1J/AMhE3YQrvLUhAKuBiufLoDifWzG5w9C0gVQmjS7mTHvEuRyZalqnk9LTz7orDX+EYPBLaWbNJH5SkTn3TM89zCRYVIXtY88DkysQL+om2D3pXsn1NYv+ZCIfaLWEzqVZ1NKESQsVQKI7x+5P0SfncmqJfx7MLIR0HEatZXgYhd54rSJ+zmVelh67O9PkH/fh6FROUg9ucPajnDn2Vz+R/juAdWOP0e0Sgz0bbUdQuKfRprFcorbaTG+UxUDkiXbfPewYRn14/zrHv5dnfNPDSvtkPk3T+CQylk2nsL/N5HqB0aaD7UnyVO5pFMpybYfT360w2dJ4LY/EiUvjo5DCL8QbEIe5924mmDVk4ax+KaRS//gEp9Wk+/t7TFsW84omd4i4hR8LUZN2nf67FUn0UnISKT2OFt7JFKfdZPK9TcYbDsmBbIiCmJgbfXvvYZlFQaEt4fab/rxto/a2mFwr4WUtsqcL3KO+aVk4O1uc/cEW/Tsaa3NGeJih+aGm+OmlED9Djd2oEbQrQqUdTES/P5uZU1TvTprJhsJaQmIA2TMJhfcPXmPXavg3Nowr1unPrvHC9YEAACAASURBVCSkeQ/26NxJoXREaX06wXl1Lma9XHalJIranlx0pdUTZe/G8thFxSVwRVqc+eoU//Bo1UMvFa6ocax0GqvVYHqzxmjHZVFeDaTzn5xISlyosTeaLLerKI2okZ6/MWogvbvBvJU10mDtgDuCxidzEr9+GSWKVQlrRbl++2MTOwrRwDdSBxqi7tKXeNDY9QvCIQIxa661gOIZCcmEzOQWCzOXvGIAW6v834a4mSzzeI2CK47eeOP4xoYAVzsIb7eAote98prfFRbQugwUkCNo7OTLZMC2hNS3psG1smlUPgpJmc3Qs/kK/5BJrdo887VUrgizoLxAeuZR3u06VsBeBCL/RExgKpKkxvA1uz9FjSZXXcaeyD51Pmukq2oyWzH//QCVyxBUcnilFF7OJkhaZN/McM8G6Eh7DhhOiZ4vouAbX46f66E4oUYXsviltJEUun1xNMdyxeB6m879LMuCoBpqn44EupbJMPvgBv0bLtO2xloo6p/5ZN5MUE9ey+Bqs0lQTDFty6abvljifPhYAsRbDUbvb3D6gY1XCXD7NoXniJTz1Rkq4bK41ZIWU5zd+2pO4smJbM6lAv3vNwUZbEt4Su1zj/SvZFOa/vCahIdkREdefuyT//hYqs6oqp3erNC75Yqx6mVA4eseXPQEw/CgwfFPbYKST/LEofgMSo8kySyu2JcbJWbNpBA9vzwTnMBkin1zn+G7VfykxFemBiH5x33062PZNHa38JtFgpQjBsCZj/PmAv/0DGdr0wSjT1sh9sYUv5Om8Nhm44/PCV+8lsW3XccvZ3D6M1R/hH98Im2GW/v075e5fKjwcyEoqPzaovr52EhF4zbPopUlSNlk3ozg6Sv5XLY3uPxpm9GuwsvJSarxUUj+L19Kq6WQQ2+1zZyK867R0DutJsFGlcluTmZcPTnxWqO5OZEABrVAEBgEQwx1O/ndErOmhhAyZ4rar0WhFQyGhlbqFV0WRdukw/nHJ9iNOrP3dlkWbBaR98DyNekLj+TpxCiCnFaTsFkhyCZw+jO47EUJdDJc1qW8KOQCjfJ86QKMJ1eGu1Y6ZRbvcDY3cwMrn5P+viOnATx/xQjylr+9Wl939lpqFfYSh8fEp4Q178GVxX/t95jHW67h+DQSm0ljJdN3xgcQy0CNmw9WbA5W1m75utjTVSJqD8VY12wWXYx29qjdopeeLMCFHF4rj1YKZ7wUk1Z0ggjzWbxaxoS3xAyfoJrHKyaxpz7OYCYL+nwhH2I+g7asK5JPFWqTVGbMa5F8M0y7aEsRZFxCR2F7odxgr05l40qnUIX8SvMPRhFk/rZseoWxjgbDWBFzZTyV2EjbhmqJ4d0yk4YE21Q/H2N98Vwumh/d4/h3c4yv+VhTi8Izi+YvBqhHB2jfx95oMb9WEyzvxMfpz6XH3O/jbG3S/dkW/VsW86YPrib32KX9lxOcp4eoQp7FboVJK4G2EIbO0y50eujFEqtSov/BJr2bFkFGXK21z1aKmfD6FpfvFxjtgT1V1L7wyX3dIXh2IHK/doPpzQoXD1wSw5XUkU4flUnjb1a5eD/H4LYGDZlTi8ZHCxI/fyQth+0NJndbLEo2tqdJ9H1Svz4QttBGk/G7bUZbkgKXvowYPF8fmDaN/84Oo/00aCh9PUS9OiHoC/9m+tNbHP/Uwbk1YjFzCScutV/YlB9NsT97ZoawsfAgVgMRaqz9bYbv1rh8YLOoS+GRvLRp/bVP5sMXwtiplKBRxatnZdM568uG6Pmi/3/QoHPHYdYKxbF7atH6cCabdhBgbW8wvl8XNtCbHvr4zDh2w702k52snB7HIYm+GOKC47OrgDO1WsCMqmd7g/HdBqMtm8kmJEaK6uce2Ufn6F4fahVGDxosCpaELJ0uST47xz86kWr95j4XPynj5RSpS03h9Rz3ZHgF52zlcliFPEGrjDUWfb8JjqlXCbfqBGkX7Vo4oyX2xeAKH2hdSqkS7hX1jpVOYVXKq/jVUAuiYjY3C2wcAH+lmoerw97YWRyjIaIF3jiC1573DZRE/LDU6nvxIx5MJxKr08pbG9B3ZgP4wPnbJhxZJVzpK0ZyzvhNVJloEp9MoHsDubEyaXS7Jhxw1xFD0HRmTgI6JYEoygtMjxTHJsxnV9XQYhmlA0krR41lMQ3KWazX5zKojRKl/JKoCOyZLz8bPWIzmvk3RU7fZSkhYS3LEKc3NTJQdCgBLzG+YiGc81i2FlNP4x4vQFjKRv3/pbHPK8tCF3L4tZwolVwLd+KTOB4SvniNSrj4792key/NZBPsuZLh44dnclrIZZm/u82sIW7d/Ksp9uM3piWgb+9y+TDP8LpgHjInFtUvPDKvJCicSonhgxqduzapTmR8+vxIVC+RXHF4I8tw1yJ0IdXBmIRQFuFuk/7tHMM9CyuA9l9ElWO/j7PRZnGzxWA/ybIkfeTisxnu08ibsNlmfLfBpG0zqykSI2j8aiwcnG5fWoTXd5ntFFkWbJypgN3WK/rLn20w3hauUfXLOclXHYOwtvI5dKuOTtqECQenM14B5+7c4OJHFUb74KdB25rMqSWGuk9eGUVS+O71lVSxM5KYxoiZdP79HIuyqGKspSJzoik9X+B++HhVXe9ugmNJwE+Er1AJl/DeNc5/mGe0J3nUyofqF5rSZ32pmiMZbFgtMG9lcQdLnEevZdOq1dCbdUY38kxaNvk3PtnnQ7PZG419Jr1KzAoC87Vwq24ouUECMp1ANuPLrjBzbu0wuJVnUVTkDyUXgBevzWbU/aDJeNtiXgtJdixav1yQenSCfyzDcLtUQkX8/hj3rkdjmQ9kMqjNFsuNIn7axpkHuN2ZtIOiwbWVSkpwjGWJjLXbM4t+PB9Q+Zx0CvxATGPR70dZ4lGI42i9pYHKXanI4VtbPG8HwMBqg4g3lW/DOq//zDecwvFjfXj8XRoCF1RF/yT392SnW2/3wKrHHxs2Qi38n0RChmeWJW9Gf7h6TqmAX8tFbZ6lyDXDUCSWKUdSjJTCGk0k5zadJqyWBBsRyjDQOrwQZ2qpiLfXYFlwsZehzAxmnhyPlZLqfxExxVNJwkJGqnOQjcsLpNU0jIbPcbB7KW8MX3o2M4hZEq5sDBHzJw6QIVYOzRer35PN4DdLLCspucEvhuizS/R8gb3VZvSwyfn7NkEKMV795RT7s+fCuNndZHajRv+GizvW5N8sSX11hH92gbO9YSriRUURpDT5l1D9bIj14lgWgXqJ7oOixBQuMb3/sD/AurbD+J0K/esOfhqSA5F6Vj7pwcso9ereNbr3cnh5RfoipPLzE8Io4FvdvsbodpHhrlTk2eOQ4qMBvDiUU9bNXUY3C8yqMmAsP/PJfd1FH56Yan+5XcXPudiLgMTZGDp9Y/qav7tN73aSMAHWElI98T6Ez1+JyKBeJagVUItAXKudrkkxi0Nfut8L0W5I+pVL++cLUs/O8d8co2xb9O47dcKkLbOio3Nh50Qo5e6dLP074h/IHlqUn/jkP5cISwBrd5OgkhPHeRgalIHTajL53jbdOy7TjRB7oUifKQqvfPKfncnmkk2jKmVxp4NZGPV8gd2oMX+nzXgjIe23USimtuNzs+Eb0GIYSgsl6u+r7Q3G71RY5iz8lCJ36uMOPNmMu31Rymw0WTZzLMoumeMZzklPBvVRetzR71tkbwwIQovZqzyND6Hy54f4h0dmhqCjanydLRQb3hY3Goy2kqAg3Ymku1FYULxAmz5+vHH4vgQq5fOCoIjvKzBYmdg0ZqWSJhUsFmsYomgsA7WtK9wh4Js9/LdjHiOlz3qraH3hv6L7Z2Ukg9WJ41uVRN81I9jbeQAqI+0e/OAq6jmdEi5Q7LSNXX+lglmArYUvkY9LD5IJUQK5tizeHQmORoeoShmdShAUZPF3TnryvXqF+U6JMGnhpy0SfR93uJQZgOcbj4Hy/DVHcZIg7QoR0Q9Rk7lJ6IrnBPHsIB7mhv2BfLiZNNTKxulrMBBrGAnD/wfxE6QTwjE6Hxi6orPRZvzeFhcPHeatAHtmUftEU/mLQ/yjE5zNNoMPNpk0bKxAkz0LyH8kPXYrl8W/u8vFwwx+Duw5ZM5C8i9F8aOyGWY3Gwz3E0wbisy54IzTB3308RmqWWP4sEH/ps10MyD30qbytUf28QX+wRtZHLfaTO42mDQcLB+KL0QZgtaE968z2ckw2rZF494PyZx5Ekc4nkgb6HaNScPBy8vCl3u0kjNa13aY7ZeZVW1SXXES65NzMRdGpq/uvRyjfUAr8gciQ+X4TH6+Uias5OWUNRiv1DTFgoGjzeoWQQr8FBQONNVfiYzVyqahUcOv5giTNslXHYkynM1x2k2m724yaTnMK4pFWeNOFOkzTe3DnlTHno/dqOFv11hUk6SPJliDCf7Ba5y9HWbXa5z9MMmiIvdx5kTJcPTzVyvy5lYbv57HuYzycyO+vr29wfB7TZZZC5SogZKdBc7TQ0E15HJYtYpcX0tP5JVRdWtXSvg3txjtp6V9udAUv+yjzjrys1FYT1iWHrw1XQrFtNPFSqdXQoE7S1L5BfOLNNv/DPKfnslAu1gguLVDmHawx0vs056RgKpEArvVwG+XGe5n8LKStJY7XJL6XNDjBvecTkmWQYTliAfDVi6LKhUIqoJYsXsTwovOFQ6Qlc1I8RVLQX3fhMMYzHSURhaOJ1c2HMKoQv8NA9xYUbSOf1hXG8k/QJlF/8ps4G038vrwOFrPvxsbgNuQPID5YjXJj/nbkwnhZGaSd1Qms+qzTaeyw68BoFQYonpDqZIT7uo04AXS++8PV4PVehltWXJCmC/ELFbIGyVDkJBFJn06xRrODEModv9q1yZMRLt7EGLNPDlSRkxwFff04yCYiPsTKwsAwV2UC+i0DMDV3BPn8nlnZXIDwVmA0WkD6MHQZI867Sbzd9oM9hN4ecEZ5w8DCn/x0gDKprdrzKoO7jQkfbHE/UoWAGezzfRem3HbYVlSJPqa4sGC5LNz9GgEG03O/q0qo33QQOkxq0AZZRntf+9BgAoUmSOb1i/mJD55bjAPi90qo50kaMgfyu8Ouz3QmsXv3KH3TpL+XR9naFP7TAuq4dmRaRONdyUUxp2GAk87uZQ2SyQZXGyXmDZdoU5+dobuD1GlAou9KpNWgvGWMPZzh5rkUH4HXzyTWVO5ZHACzkmP4PRcrsOtNtPrFeYVm0XJItUNSfYD0sdjrMsB/smZSB5v7uLnEkbDHn9dbbUZ3avSvy5MJXsu4ejFlzIUj6MJ7VIJvdMiyCRQQbgKVy+VmP3oOr3bCeY1jZ+GwnNo/nwATw7EZLW9gbdRQdsKtzcz7S0rmyG8t8/5D3LMq2AvoPQ0MBjocDLBymZRmy10Jokaz8xsIHbyBvUiy1KSZcnBmYRkXvQEYbFYmOJMu464abs9U0nb9Sq6VWWylxeQoA3p85Di8ynqo0emLTneTjGvWKQvQ3KvZ9ifPpW/abNNWMwx284zrwiML3MRiHfh+MxgIkxaWFSVxw77+CRNMS8FY0TP5bK7MnFFwfCxujAcCy/MzCBTSZk1Oo60nCdTKdjG4/iG/I26/fi/DSNIqZVreE01dEXV81ba2Do/CFg5kt8ikv6zyT/5N38DMKHwkeIHkGo/Ou6oKNoNiNj4y1VkZCIhfgGIUsK81QYSA9QGIgFVyciMFeUFqPlScmwzaQhDFvt1MX25CsvTpM/mWHPfEEK1Y4n7cOaJYSvQYCvCpGPwvMa4FcXExVgKvVyu9L+JhLiVE65A7mKX8Gwmz49krGbQ7QfCO1qfi4CR9M13SiwqrsEplD++NAHj8QBwWrdJd0TVEj47kO/d2GO2lcfL23gZi+xxZGw6u4BkknC7QefdPIuywstLjm3jT8/RR6eodoPhwwbDXRsvD14+pPylovKlqFZUKsX84Q69W0mCVHSSeDXHffRGKrV2g+G7NSYtm3kVVCDGrVj1YtUqTO42GOy52EstULiXA/TBoVEjhdUCXknyHVKnE9SB8O25tcfoRp7OPRs/rSk+Fxxy7BgO+wO51hpVI4fUr48N3EzvbtB9WGK0owhdyB+siJh6MjHVelgrEuSSOBcj9Mm5CU6Zv7tN71aSRQXQsvgWXocUvuqjH79YsXDiaNM4sjDqQ8enuP51YfRkzmRIWv2oQ/DouXHm9h5WBF99GGEUorlGvNmONxVeXpM9lIG78/ETCW+vV9H1inhWosxfw//faDK9WWNRsgmSisyZL56Ks0v0bI5VyEs2t1IGXyJtohQ068z2Ssxqcg8ZfPSrM9Mm8u7v072XJrQVyUFI+cuhKJmWnrQtHzQZbUlYU7oTkjlfknzVlXxgz5foznxWFvXhiHA0hlAboJvOpiPTpyWn497EbE7xQNVsEKEGb2mKKDMfSKdXxNLR5GqGcNyKWR/Ifktso8k3j0ytV6ig8SM+QazNBWJfAiDrX1zsrQ+I17II/mT+P/2bvwHETmCUtUrcSbirHOAggCAU/vu6LCpc7cAxQ0il01Ilr1+cURCIdiw53k9moppRFhRzhKUs83paMltPJ1gXfbAsgkZRcNEKCTeP4h3DQgbt2uIYHk8N6AqQ00kQmItCT+MLxzV9yDCTkozg2QId0QfD2XwVQhFVNeYRh93Em16xQFArMN3KCq89oVbo3Ij/E97bZ7yTYV5W5I4C0icTqXgzGZYP95nXXCYNm+x5QP7ZCHVyKeqpQo7FtTr961KtW4EEkOc/PpZe+P3rnP4kz6ytRe3TVdR/LYNPPZ2hdja4/GGFWU3hZyIn8IcDeP4GlUrh39jg4r0ssyagNOlTRfnJgvTXJya3oPfDFoPrFpYfyUA/O8N/dWhC5b1WnkkriTsJyRyOV+z+W/uc/6RC5305iWRf2TKb+PgFQb9/hUoZJqQ/z9mlnIKi/nrnvsuiqkl2hYuUPV6SfHy8YulUK3hbVbCUBNafXYiCqlGn/5Mtxpty0sgeaZyFpvBkiDq6MBA0p92UAsSy0OOpCSaJMQrLvRrdd6I0unmk///kTBhCmQx6p8VkT1LD8i9XVbN95wbnP6lI6Hz0vhZfiYM7ZuTYjbrMzQA1mho1jt1qEJbzzFtZpnWp2DMXPpnHQofVk4lUpLWKtDsn05U0tFJCt+p49QyTlrjLU/2Q0lfyd8e5AbpVv5rgdtaRU06xIGa7O2kmbWnxZI8FUxFjIpTjSrBNoyJiiyCQNo7nY2808dtlFtUk9lxmdG5PZKJ6PDEVvV3IGTdvXCjGD4OfyYpniPlCNsX54orxSyWTpvAMJ9OrKp743o/Xo7jlsy7p/JaK33icwtC4kIFvOH6/FTHxr2MGoJTaBv4J0AJC4H/QWv+RUqoC/K/AHnAA/Mda655SSgF/BPxdYAr8A631x7/tNdYjIc3xLCKBEgQG62roem9BlmIqYNxqiTnjaC2Zsc2K9Cf7ExhE84J8ljCflmO31tL/vxwJXbRSZLlRYFF20QoKX3RkyJxIGJaP0vrK4q9SydUQZzKVEwys8lVj0ieI0mgwjo6UE/M3X8Fhx/nHTrTZ5bPobArt2mjHYlFNQiiQMfe4K3MQHV4hLAYulL8YrCL/djcZPWgw3rBJ9kKKTydYX76Q96lcYv5Om2XRYVa1UD5UvhxjPz0kHE+wWw06v7vFxfchLPmkDhLUvggofHgkrJprO1z8pMxoByxfUXgpCGj9Wgab4Z09Tn+aZ1aX6zDZV9Q/FoyEHgxhs0X/fpnBNSuaDQQUPr9coRSu7zLbLrAoOZLb3FvgHHXwT85wNtssbjS4eJBiXtNoF1p/HZD7q5cEl5eyuDbrLHYrUnleTLHOexJO4jpY2xtc/qxF974mTGrSxzbtvxa4WXB+KXLbRt1AAq3e0HDsnY020/sbnL+fYFnUuGNF4yOPzNNLwjfHZnFXmQwqF8maR2PJFo773JttvHaJeT2Bn7QIHUh3hOSqj8+i61WSuRb1DO5gaXT0zs4Wgx9scPz7kGxNWZxmqP/SEqf1i9dyf1RK0g6JH5Hxy9neYPRem1nZJkxA6Cryb3xyz1ZKqRiAprLZSI4t1bJdKaG3mszaWby85DVoS5HqLEm87hJedsVFu9nCL6TkPRwv4NlrM6ifvtNktOMy2ZDchOyhovxoservI+2keDZmXQ7MfCDezBfXG0w2EiSGocw1LkRGamSg8X2VSqHn80jK7a5O4flsRPG1RAV43hEiaCgdg/ieNAVdXNGD8RWImcz/5skAriiHjAw07u3H/oC3h7tvhc/IDbSWQbCGo/5XDoNTSrWBttb6Y6VUHvgI+PeBfwB0tdb/tVLqvwTKWuv/Qin1d4H/DNkAPgD+SGv9wW97jYKq6A+sPzCBDuuLoNkpo8Gvns7lg1wuVxVzPsoFWCzRU9nxKeZW2IS44vd9SCahVCCIHMJ2byKnhaWHymXwWiWWpQTuNNbBnxuTiE4lTf9def5qmGtHfB7Pl3ZTqFf4hoSLTrkykI4wEeFwRJx5rBy5QOPht/b8Vf8xk0bbFmEpy6yVwfI1Wsmi71wMpTqbz7EqJYJa3A6xcMc+iYNLUUjMFzjtJt5eg3k9gbXQq16u70uO7J2yJDddhiR7PslD4dvo6Yzg4U2G19IMblgsagHZ17bIQH91IJVhpA7p3HOwPKh9tiTzxbEszHvbDN5vMtq2Ge0HWAuL3BtF+0978OJQjuLtOhcfVJnXFdYCKo+WpD9+ZWYTixsN+teTLCoikyy+mEmS2GyO2mwxuVVl0rZZ5gV/Uft0Ivz/2dww8kNXOE5x5aknE1QySXh9k97dPPOqwstC5kQwDe7BGf7pmSzOtSphvQR+aGSSsSqm80GdwQ1YlkLckUXlC03xyQg+ewqwghhm0zCaiM58ODR8n6CSY9bOssxbuNOQZN+TjIFYlZNOodoNwYkrZcCBer7A3mhy8Te26P7bc97ZPOXrNy1Kf5Gi9Scn+AdvRONeqxjXrXvSJ3hzjPY97FKJ6Y9v0LvlMm9oEn1F5mxFEw0uL43+fh3hDFHFv9lgup1nGen7Ux2PxGEPBmNREFWK+KU0y5JIi9Mve3B2gV56BA9v0r2XYbQLWJDoKapfemSed1cS22oFKkXCfEqc0sMpOpJyxgVd3JbFVtgTD+vV2ZVwmFi1E1fserk0HQJdLgi5dzJfKe0iQYYxhxUK8rd43ipJ7FvyAdYr9281ibnOavFe8xCYp0SbwHqM5Lp3AFhtDt8iI/3X3gJSSv1T4B9H//t9rfVJtEn8v1rr20qp/z767/8lev7j+Hm/6XcWrKr+Sf7vG8wDYFAP8e4d5/xqP5qgu+5KFjqfyy4N5gP2i2mcwQw6fRN/dyVlJ8rZVY6NzmfRmZjFH4o8dDKV35V0CSrikLRmUdvGUpJAFnN/PF+4PHFIe8zsD7S0ekYTia1bLlfBHvHnEXNIYsVBIYcql6TN5FioQLOopbG90JiA9CRC2xby+LU8fj4hR+vTieSxRgoMq1zC36wSph352ahijsPNx++2mZdFDZQcBGR+9YrgooPTrBNs1hhez9G/aWEvBH5WeTTDfXEKqSSz6zUmbUFIpzoh+cMF7pevpeV1c5ejv1VmvBegHU3y0qbwAmq/7MB5B5XPsdwsM7yWZplTZC5DcgcTnKOOoBZu7tN9v8xoR9g/MVDOYJxv7HH5w4qgEjwovBJKqY4kpt6P3mGwnxT8dCcg91QqWuU46J0W85ZUrYu8eA/cSUj2aIb9+I2cdho1/M0q2rZwj7uRU3iCXSoSvLPL+fs5Jjua5KUkkeVOAnJfSlqZDgKczbZozG0L1RtKeEokp+TmLsPbRRZFReAqUv1QnLEHZyI7HAzls6tWCKsFKWDGU4P+nn1/n/6NhFBWd6d44wSlT13af3JO8OS5RCFu1eWkaFu4xz3JTI6q9uX9XQb7ScbbCmcmXKTMwRCOTlev3axLUdMRbk78s8G1DRb11Fqe9hL3dCB+knQK3aoz284TJhTpk5kZqINIW8/+VoveXQ1Kk39p0/7zoeA3plNZ9KO8Zm2D8rVRlxEEqK02s2sVlgUbrSBzvhR578mFCfsxj7h3HmojHrFKRcJyweSEqP4o2jBWoU9WLisybMeRWdt0ZuZtMZ4lPpXHJ3yjCLqySL7l6n1rwLv+iO/7t3HSVzaLb5kTxH/fnyz/53+hDcD55z3hX+ShlNoD3gN+ATTjRT3aBBrR0zaBN2s/dhh97TduACqedMd9OXsFU1K2JUEwyQQGjBYPfUcTYewg6hSrVBQWTxDinvZXzJxqiTDhoMYzUzVDhF8u5qQamC2hOxCGTUFCPmZbeWkXTD1pEwE6lcAvprFnHowX8m+IBsxhQXwGyg+xpkvUaCqLPsgGESmW5G+N4FlrDmerWCCsluSCCTTWbA6uQ+qgK5sMRH36vAHcaUdJxX52QTiZEQYBzkYbb6fOIutgeyHuoyP0eIIf3WjeO9ssS5INXHo6wX4uULjQdbDv3KD7sMx4w8IdaxqfeGSeSQWn0mlm9zYZ7ieYVyVxq/TcJ3MwFOR2qYD37i7Hv5PCK2rSJ7Zk4H4RtYKaNWY/uMZoUy7H/JFP9VcD9KsjqaKyWfTDW/Ru51jmFflXkTv0swPQIcGtHS7ezzG8oaVX/EbMW4lfS8XP/RuM93KMtmyc+eo0oC0LfWuH8x8UGG/J25g5U1S+Fv1+eNGRIV+1Ag9vMa2K2S/z9BL/zbFUjj+4T+dOnuG+YlEPKH9hUf1iahbYIFJihbUiy1IK92IC5x38OBHr4R36dwsMrllm4F15Ia8fnJ7jRzJAu1iQOVYYok6iJLDI8zJ82GC0YzPeCUFD9Y8zwnb66jnadbDv3mK6U8CZBSQOe8ImCkPsSpnFOxtMyy6zqsWirKg8Cin+WkikYSS0sKsVKXrWZxO5HOrmPpO9Asu8ZCZnjqbYFwP0dC7ZA5FhzqtncEceiZfnBOeXBJbC3JndXwAAIABJREFUrlXwrrXo3kyzLCgKzxWlpx6Zj18SnF9g72yxuPkOk5JA3+IWku71CYZjwUjcajPcSWEFmvS5R+p4BJ2+IdhapaKclkdjkXDGHqJScZULnhAptjWaoIdj/HieGEEnlesaaCNgBB3raWE6ksnGg+cYEyEL1dWq3hi4lIVKOCvaKG8perRGOuvx9946JegQFaNg1sFzb6Mk/jmPf+kNQCmVA/534B9prYfq7Yn22lO/5WvfOH4opf4h8A8BUmSu9uaiHVUH4WqY4vvSh0wnZRA1X0SGMBeVza545uOJ7OrRpF+bTIA17X8qhcplJCS+NxQ1QTxE3t0UOmcUrAJgTWboTMokciXOx9EAd2piHP10FIgymEl/f7GQPzpYqw4cB+XYpiKUNyLioOey4DrCLgpCqR4nMwO30wkZFoWNMn4+iTNe4rwRR2ywXGIXC5JzW82zTDnYc5/00y7B6TlhqLFrFdTelvRjbSVRiJGWm3oV9d47THZzjDdslK8pHgQUPzqV5LJGhdHffIfhtoSbWx7C73k1khsql2H6YItFySF0oPw0pPThCcHxqVRTN3fp/If3mdWk6syeBuQfDwi/eoqO2hzeZolFyQUFlc8HqFcnphof/M1bXD60WGx5qHFI/qVN/ddzEl+8AR3i39tnspliuGuRPQ7Z+j/eCI2zkGP8B/c4/cDGvjkmCCY4n+covgip/EJaJUGUUxtuVlhkXZyJR+arU0EtuA76g/t0bmeYthQqFO1/+sPQLGBBZFLyNyvMIsev+9kBQa+Hlc+jvn+P7p08g5uglSiKql9Gm+7lpfx8xN8HJA9hOJLBcq3K4sfvMGm5TDYtkfa+Cdn8467JTlCVEty+xnRPFv7Mix50eoSjsTkpzRpyUkr2NKWnCxLHA0FNOw5qo4kuZbG6YxnuxsylepVgt8msnmKZs3EnUZjO0TnhYEQQVdbxbEQtPRJfSARkmEqi37vNIvpZZxGSf7Ok/mdRaP10CqUS/PA+k7rgMbKHMwOs05USwa0dFtUUnbhYeCNzFf/gDUEYoNzEyrG79PAjT4ByXKOOCwuCeLfHixUCOmqlyFwmfSVgiuF4FR2aSon2PxKhxGa6K0ldyaQ5Zaz37+PF34qS/pRtGRGHvL5e9frj1VKH39riuaL/D9faTL8lUexbF+V/mRaQUsoF/i/gj7XW/230NdPa+f+lBZT990T181ZmZjysMUoYS8kuraPgl7zwf3Svv1LSJJMSFmNZMtEfjgQZXcib1DC99OQkEAQiA23W8GoZCDRud2oyf3U2JQEvKRd7shRLfqwtjto92pVZgH0+QI9G6CA04dKxqzmuAAy5MOHKYDDuM8aegeg0YR5xQlgkaVWzxSpI23GNxj6+kNyL6crSDzhbm6J6STviYh7OZWOZzlGppCxcrRShrXDm0SDt1Tna8/BvbnHx/SyD2wE6GVL6zJWK+01PWmvtOrMdITM6Mx/3q0PC4VCoj9sbDN5rMq1bLEtKYhKfeKR/EeX7Viss720zr7ooDcmeR/KgY9Q+4YMbdO5n6T4IUeUl1lGKypdQ/bgLx+fyftQrzHbzzEs22VOP5BcyPHT2trn8aZuLH2jyuwMm0ySpzzI0frUg9atn4k3YaOI3S0y2ZTCbPZphPzsy7J3R797g/PuStpU9VJSeLoWIeRThCiJlS5BPGtps3GN3Wk28vSbTjRTDXRt7gbSJngzgxWvp5zdqhMUsYcrB7k3NzEUHAdbeNoutIuffTzKvaawFZI+g/X+/iQBoDmp3U9oljsKehyTfSAKcSiYNCbV/U/AbuUNpofHs9YrcWS6JG11ruOgZpzKNKst2gWkzEdFlQ7IHY5Fqxml90cKnchnjbQk6XVAWzt42w+81mTQs3Alygnt0RHDRMaY0v5YnyLjYU08ouIcnqIRL8M4u/ZtZ5hWFH81kcic+6Zc9M9C2axUjQ9WTqRR1liUqIccWP4drE6Qc3N4M67wnBde6yi5CWK8rglTCNegVQ/MFmdl1uquF37ZRqWidWlPvxd6k2MdEEIIOzdAc3joZRDkBV8Bwa/JOvVya//82SmJ9OPyvfAYQqXr+R2Tg+4/Wvv7fAJ21IXBFa/2fK6X+XeA/ZTUE/u+01j/6ba9RtGv6x7m/F8knZbiiMukovtGR6XvkC7iyo8aT+dncqIPMJhFJR40MtFISB+9l1/weq1QkrBZkoOQoAbQNpqjJbBUun01ICygmDEYUTq3AnnmiMx6O5MgYu5cj/T6OIxyStU0t7vHrdFJaRPPFKnuVaGOI5WLx35RwzZE0nC8MOndRzzCvutieJvd8iHXeMwHgaI3K5/BvbGBPlpKVOpnKhRkhqcOEXGxx3GA4nWKViizvbtG5l2K8pfErPslTh9qnIcWfC6pZlYt4zSLLSoL04Rj1+tSEtodbdYY38vhpJW7ZNyInDN8cS6tgs8HoZoHRto0KoPDaJ//hoTFPxYE0/duSUVt4blH9Yo774WN5g/a3WTazBCmLIGmR/+yc4MVrwVP/4A5nP8owfLCg3hhy8aZM4WuHzT+5NLnE+pZEPPoZC3sRkuguxRHb7Zvgld4th3ldk+gp4dR8dYR/ehYlVq1MY9YywDrryvciTET3Xo5lQXKHU52Q3PFyFbgT4Za9jbIsFloL3vrkTMBsOw367+RZlC0WJQjSmtS5ovHrGe6nL0QYcW1LQukVwsDpSi9bOQ7L7+3Tv5FkEW24gpA+k40pCMzgWbs2dneyYgu5Dmp/m97DMl5WKoncsU/qbIb1/Ai9WGDVq4SlnLQmo7lGPLtSjou90cTbqjJtSWZE6YWA3bjoSqGWSeE3S9JuDUJx3A+Gco/stendzdO7K2iO3CsoP5bIUiM3rVeNKEItZDCtbEvc1/U881oCL2OR6vokO3MJ84mc3BApBZMJQxPAssxgmEjtEzv2pbswM+RO05mIHtr3r8DZDL8sXpNA/AVrNFFY6/+vh7u8zQH6DZTQeCN4e2j8r5wFpJT6GfDnwOesmlX/FTIH+N+AHeA18B9prbvRhvGPgT9EZKD/idb6V7/tNQpWVf/Y/cOrVXE07I2173LE0rLIJhMGmgYYlIL2fYh8BLHCxmrUzGIbL8Z2pSzsn6h6U0EoLmE/IKzkCdOuoBz8UIbCk5lUOsUcYSYhSInpUm6+COWsMhkjU40NXShr1eoBMR9VhTceEzxjn8A6bXHdU2A++MhYpnY2CLIJluUk2lIiA319IbMQx0FvNvDzSbAVBJrESwnvWFdA+RUJznFOeoacaBcL6L1NRjfyDPZssCQ/INUPyLyZYB93IJ3CaxYJUzbWPMAZCIdeJZN4D/aYRjkK6UtffBMRT0klEsw+uEHnrouXE7595iKk9Fkf/fSlqGN+cIfOgwyTTdA2lB4JJsJ5ciRArls7TLYzzGoWyb6m9HlXEAy5LPPvX6NzL8nwnoed8+A4Rf6lRetPu+jHLwTT0KwzulcFINn1xDMR5y/kcwx/ts/lA5tlJSD7xqb5YYRZ6HQNcphkAp1KyMY9GsnQNJMh+N5NLt9NM7itCdMh+ScOxYM1iaxSqHaDsJRdCQm6PQN2U+0G/e83GVy38HLiQUh1NOVHUwNws3I5wjt7cllEmBM9GqPSaYJmicv38obLVHy5em+V46A2WwSVLMtigmRnjtWfEL46EglsucRyv8F4J0WQUGgF5Sczk/uwHjEZzzXiat9Kp8SB3xCZ5rIsffrkiwtTvOlCFr+QkntsvJCh+Hgii/Fmg+6DEsuiYl5BlEiP5rhfvpb3PZHA2t0SgYbWqwInKrRo1lg2JOkrdJQs/N3xVeNXhGdWicSK6x9X6hH3x0i0+0Oj+IkFKFYhvxoUe8srWSRSwYcmlGadYxa3mlR8qtDayEBNtON6Kyf2CaxV/t/2eDuD+DuRCVxQFf3jxN+R3l2sufVXi7g5ksWtn8hBCaywy1EmQIyGUJm0aPNtGz2ayLwgk0FlUuhcZqXemc1NgHzYrBjFjTNYoMYzuVnTSZHiBRprNDHIZ+W6kgGglCzoi4UMiODKURkQFVPClTnF0lv9bdFcQM8XoriILgDAXMAqk4ZSgbCYEdbQ3DcXug5CrHqV+X6VWc1F21B8PMIaTKVNAyYcJ/YQ2F0J0gjHY+xajeB6m3ktxawmF13p6Qz3QCiobDQJMwmmmxmRKV5MTMvASiVZ/uQOl/eThC6UXgRkDqfYL0/lSN8qM93KMtx1THZw+YknJ4JXR3Jj7G/Tf1BiuCuMnfLjkNKXEfgN4NoW4+sFZhVLUs5+fmJCUTp/5wYXPwz5wx9/ytBL8Vcf3WbjT6H4l68EahcxeGZVGQrnDsaoJ68N4nnx/jUu7yeZtiW3OP8Sql9IIE44noiMMx1FjCoF3cEVQ9fwg226t21mLUnrKjyzjHErPD0XVEK7xnQrJxGKhx0xZUUyUL9eYNZOM9p2CF1QAVS/jAbDUeiOVa3gt8uiQhvOZNMC4S59r8Fg3yZISvBL8SAQp/eTl9IiiBzRaMi+meIcdQh7fVQ2S7jTYN7KECQtQkeROVvIZxs5g+NcaD+fxPKlYvcjWJ2zu4W3UWZZcrEWoQglRjPx0ADUy8x2imgbnGlA4nwCscSzVmVxq8VoSxLessfCe0o/v5T5QCRbDtoV/FyCIGmRPhxJwJHno3Y38csZvLwsqumDvhFvxFJNlUjI/ecmTKvGtK+UJaTR2Mm8FJBjbEA1912Uy4HjrCn3ovo3mRQWWXSaCCMz57pbN3YMq4Qrs8xoU7jSLkq4Zr26wvqPf8da+8dwgtZOBMp1vjsoiN8p/QdyxI0kXMpx5CKOF/s47D160+KFFTBtIJVOyTQ/nZJ2x2IhC2QuS1gtiZInMorFCzG2hSrkDT2RQGNN5xIKsVzKBw1CKYzCMWJHaphPoeY+1mQmCOE4wD6dNjJAglACrqNjpTF4JZPfkJuZ9LPoJATSEtK5zJXX0v2hXIyNGl67IANrX6P8kMRxXxafZBKq0q5QQYhaBKuhL+A063jXWsxrCfyURWIcYXuPxURjtxqM320zrdskR6G4hQ/PCAcjiXi8ucXF+1n8LDhjKD2XHrnOZxjeLTPatvGyYC8hexRS+YVk76IU3Nylf7fAcFd67MmeYKTTz2RjsHJZI9cM0hapiyX2Z89l4b6+x+kftBjc0hRv9AhCC/+XZapf+eT+4rn08G/sMblVJUgpUpceyZcXUs1m0/j39rl8N82iolgWNNrR5A8smn89QH/ySJyxUeqU8kNUd2DCw0F60NOH21zed1mWxZdRfgTF5zOcL18SDMdmPuCXUjJPOrkwVby+tcN4L8esJiorZ6GFs/NqAMdnUSJZ2cwQEgOfRG+O9eJYrvvdTbrvlxlvqmiBFSVW/pevJSaykINmHa+eY1FLrN67KAXN22vQv5nGyyoSI03uaEnqydlKrlnMQ7VsEBlqtliFu2+2CZolplsZgoRFYhiQeXJhQuWtXJZgUxz3Wimc7gTOLuQ9qVdZ3tkyWdSJsZagni9fGBmo3mqyqKUJUjbJ3lKc1hcdCEOsRo35tRqj7YRhOVmvz82GHEPpdDYtiJdYIRhlAlPMiXQ7ygGn2zdmPGB13+Wyq2o/EnCoCNdBwjVeoBjffuV3rIfSx7Lv2NwaKY4A4wGyopS/uGPxDWVR/O+KTWSRRygOnNGe/904ARTtmv4g8Yfm/6+/ifGw10hAiQap3vJqzy1O3Em6Is0cT8wxL6wVjZFGjyIlUDYjpwPXkQ90ErViHEd+R/xIuMa1a6r1ShE8PxqmziLaZJ6wVjQDYQBrFA1cF9GuHm1ixjIe0QXXgzdUcsU9MkfRaKOIE8JUPk/QLLGopkgMljJEPO+YdpNdKRM2ygS5JKFrkXx6atC6cQjIdDND6CjSl0uczgxrNBFeSy7L7N4mvVtJbE+Tf+OLI/XkXPg891v0r7tMW5ogpSl/rah+OhYHZibF+GaRwb6DM9XkX/ti8Dk8wapWDHButKcIk5pkJ0oD++ggoqK6pl0RJm2czgx1dCYtg3s3uPhhkeF1sK+PWcxc0o9StP9qjvvRU7PAze600bbCXobEQ2W7WCC8tsHZB0VmTVjUfdy+TePjkPyjgRma29UKerMRfXYzkYdG4DFrd5P5XkVIqE1FsgeVRwuSJyOJY5wvohlBUXIk5j6cd8XQ1qwzfbjNuO0w2VAk+xgAmnvcFXNXEGDlcwTXNpg30gRJ+WwSLy4kner6Fr27Bfq3YFkPyLxyqH69iluM2UbTG2XcsY97OjKuVmezzej9DbyMxaQtJ6ncUUD2Rd+oiaxcVjI08hmTTRzLHWNfxLKSQitI9hY456Ke04ultElKeTMvM7nEvmfYStPtPNO6TWoQwfzik1i1QnBjkyAtQ0174mG/PBWzXiaN3mwwb2VZFh2Z2Qx8kk9PV0lq66c011lh3odj6Rzks3itImHSJnEpJxWJ31wNb5XjXBkM6wgfYVrOmbTck1EGtx5PrlCLTY8/bgXpUKr+taLOSEmjn4vbUN8IioerEtBY+x/N9eJHzBf6TtBAC6qiP7D/HbMAAt+Ap6lUciWJXG+frEk91WIpQfHRgnzl6xGewci7LMuA4uI+tbkBglDY+3EvPnIBh7mkSSUiWtTXF2OARG8hyOjJbLVRuYnoOGkb6Ns6CsBaVyW8NUgCrmQFUC3hVTKoQOOeDVaQrLXFJ24TWcOZ2P5jSeJ2m/HNEtpWOJNAjs/nHaiW8JtF5vUEXlrMUYmBT/q5IDD0VpPugyLTlgx2VQjJLlS/npN8ItnDVIp49Zy0py4GwsaPMAudn7S4fE8T5gOssU39V1B6NIoyeGdm4V3WMpK3fHCOfyIIBOvBbQ7/oMT04YxGbcjpSZnSRwlqX8yw/vwzeY0YapezyRzPsT97ZjDMkwebnL/vsqiFpM4tCgeh4SaFL98YyaMZME5mVyidtOtM94v0rwsWxPLFe7Ae2qKaNYJafrVpnV4QjgQM1/3ZFp2HCj8fYk8sKl9A9a9ODXlzHQUBECYsEkcDOL9EByHhvX1OP8gx/50xO7Uez5632Pk/FdkPDwjOL3A22vjbNbycK63Lzgx1eEI4mWGVinT+8AadBxDkA4pfOdQ+n5tUrjg4RWfTopgbjCTnNwgkB+PmBrNWkmlNFD3lr4ZYh8I1ilucul1jUUvjzALc15eGL2Rtb+C1itKqscCZBCTOx4RPDwBMNrCXd3GnPu5RXwJllh5qo8n4fp3OXdkUEgOofboKCopVTGG9JG3ahSfqu7iFk8uishnm+1VC15KUs/OhORWE88U3uFtGZBI7fEFmjZEM1BB8o+FtPPhV6bQxi4kyL1Lcx5vHmgT0NwbLxKa1+L+/bTOIH2997ztxAohpoPEut+J0pw3ASc/m0r6JwU1hKIjkNWmo9oOVdjdGNIwmK3yD6654+lG+gLItUeUkXDNXMEHvUSpYmHKx5h725XBVWUTD1DAlfXNnuJDvR8gJHYjfgLL0G9V0Hmm8h2YQFFddIPrv2KBm2CO2zEJUOi2VRyYKhj/vGIaQ06zj7TVNX9G5GEps3mBkbP9sNPBqGWb1BPZck305kGMw4DXyzFpJvLRFuusbsqRyHILb25z9KMdkS0cadkXjozHO+ZDwomOCNkyPvBPJCUsllg/36V9PMt5RaEuT7CmqXy5JP+8QvjoS9dFGSzjtIMPR7sCobZbfu87xT1PMNn2wIHluU/5aSKfBk+fYpRLh9U1BZHghycsZ6tEBAOG71zl/P8fgdohVnxNepGj+HEqf91GHJzK8jVAHchyXm05PZwZ6Nr1d4/Jdl2VJlDj5w5DiFxIaoz0fZ3sDv1kiTNirmcxwJNfp/jbDuyV6Ny28vKbwEvKHooYKXrw2TuxYFaMVuBfC8A+HQ+xWg8W1OqcfpJg/mFIuTOn2srT/aYLCn75YIbzvtvDyNpanjRPZyqbx7+xx8b7Id53GDOfzHI2PPTIfvzKnPFXIGeqkHo4IByP5TCL0xWQ3x7RmYwWQf7Mk+dlr9GSymkkEoYSuz5ao8dRs2Pa1HYYPGyzzFunLgMzhWKBwl5eCZ9jfZrpTwPJC3LGH8+ZSIIC5LGGzwvhanuG2zaypyR5H2cKPxF8QJ5n5xaScFC4GoiSK+vpi+HLQtlrds92x5DKsR0SuVf0mYyRK4MNSq0zuGDm/Do6LjWEJd4V1WUvtUtmszPsiTEQ4nhj1ntzb0cK/lhsMfHMo/NseaxvId2YG8GNXWkBxdme8AMbHMRWTPmM8ctxGiU0VQRj178IrN7XZoePhse+vPAQRp0WnkiY8HkBn04RplzAlyFhnOEdFjKGgmme6mUEFCHPneAC9oQyZc1nIZ1eMkIRrDGOxCUW5zopaGl1EseTMIK5jxU8ysYrAnEi4TdDviyqlViFsVphtZrHnIakXl8Y9GYeDhIU0i5oEeSitSfQ9CQsB/EoWywuY19MkewtjTLJLJSY/vcnlA4dFWaMCKD6Hxp9dEB68kRNLvUpQluG33RnJQHk0ksVjr03n3Tx+RuGnIXckBiKevrqCIl42szJc7M8Nyni9VTPZEdpo6lyx8WcjrC+ey5H7nWv07xZBQe5oQeLgUlogpSLDn+1z9kMLtTcBrdCvMtQ+05Q/7V3BPeMmxAi4HsjTbuC1C4y2kkzaFr7sy5SehILXjqSmVqvBYqeCn7alFRKZl+xahemDLfo3EsyaAoXLnEgKWqx0igNfvJyLFWiUF+KeC0pa2RZ6b5N5K8v5+3La8LOa9IVi4//pw5MD4xGY3ijjZW3S50sShz2z8Ae3dujeyzGvC0nUmWpqnwyxnh8KQuP6Lou2bLipl53V6bFaIdhv4ecTBAlLIkzngenha8+PMplrsnAPl9gvjmXTQAo1vdVmcqPApCnY8cJnl8L2mU7FLNauMW9lUb4MjdWrY3H6RlC4/o0Ey4KgszNnIaXH4+iEODduYLUMsbwA+6yPns2EDZbLMG/nWBYd3HGAvQxJHA+lGOn2RTtv2SIDXQuLMVV8PieFZCopJ0DPRw/HhjwcP6xserVmRHj2WEJrvAFrrP+4KDUtXriKq4gD42PYW/RYb/XEEZVXvv9Wqth34wQQq4Diiv/tyb3jXAE7mdZMwjUxkMqypEUUPyfazc2wOFYVxVwhx1kxv2PjWRwbmXZNqpia+6gwRLs2XiXNouyKjPB8DBc9E0+pykX8Wl401uOFzBt6/avVQzK5qviXS5NtIPIvjzhIRp6sTF9ST6crrG2lRLjbEky1jdFqB4OhXNAbTZbbZZYFhyBpkTlbQKBNjGWYTxGkXQMIi52ZViZDeO8al+/lmGwo/IxUYBt/0oWXb+S9u3Od6VZOOPHHc9zDjrQSolCU/p0Cy4LCyypyR9Ljdp4dS1XbqOPt1FiWXOx5SOJyijrtEFx0JBXq9jade1kWZSUtg7G0mBKfCOYh/MEderfSzKuK6teeZAO8OkLlsnT+9nUuPgj5/7h7jx7LzjzN7/eec6471/u44SO9IZl0RZav7qrqVptpYMxitBGg1UDQcqAPoI2gjyAtJa0GgiBAaM30GHWZaXazyGKximSSmUwbmeHd9f6YV4v/Oe+9wWI3tGoIvBsmmYzIyGte8/yf5/e4rSGeZ8OTLIUnUPt1tPgSkRvjWsCIIx/bcidXq/S3E/iuYlrT2BNF+ZGkmZedKfGMR039RSNWlF3oX8syXJe0rnuiKT4ZL/IFrSazGytM6kmSPZ/0yVgwD4OhvK83V+jeLTJctZhVNO6x4BKyX54RRFKa2l6n/UaFIKlMOErvHaKyWeZ3N+jtpBi3FMk+ZI8ihPTeIVgK69o2o50iXtYSvv7uBf7uS5GvNlqMrpTobzoL/v7uheRlwhCrVmG2UydIidEgRlcQamnrWqswXs0wLVo4M23w2UG7g5VJE9zYZLKaAQ3p0xnOg105pGRdgleucPGay7SqQEP5cUD+cV/QFlGgbtmZl3zZJjw9l0WzUWN4pyo49ITCPfVE448or/FrjmWZ4BY6NIUwMUICy1r4/yO0hbmhRxKymUHGoc048xNLRGAs3LHxJB70xlp/LAeZQpr4JhJZSbEsc/OPOz8ucYLMInL5378ZncBWVX+3/C/kRDybLV6krCvX9LhYZfnkD7JzW9YimDGZGueQmRnEOYJ4oh8NWE3DVvRPnc2I39gP0SkZ7ARpB6XBz4h9Uvkh6ZddqRmcz+UNVCsTZJMiBUw8sV92+4SDoZyWc1k5XSQTgoEeTw0OOCaByg+wGBx9HSI2br7y63mRDDoTcexEuASdc/ErWQbbGcKEwj3xSJ1PjH9fO7bMMixLXEkRMjcuMOlvJ/FdRbKvye3PyTw4Ijg9x15vMb1SY7SSQFtKFrZnR4TtrjzHN7fo3BYPeuZck26HFB5ESeG5J06kWh6tFNpWJA864hpRCnY2GF0rcHHbYXx1TuowQe4lNN5vEz56Ls/D7auMtnLMcxbpdkD2i2NZnK5tcvrtEr0fTUgkAqaDFLmHSZofTknef2HcSjSq+GUXuzeF53visokcKRevpBlsyS0nMVAUn4cUHw2xnh7I4DmdwqpVCAuubMgRm0f7UkgzeKPFYM0hSEnbV+XLGan9ninjid0880qS9MkE++Cc4Lwti/LGKqNbdTo3HOw52DMt3+PTrtyWJhPsWg3/xhpnr4sjLNnXVD+QQh6ub3H2VpGL78+xUwFBP0nj72xqP9+TG1Exj15vMtrKEaQsUm2xWvov9uUms7XO+KrA1YKUIncwlzTxwTExHny+02BWTWLN9aLWM5q59G+VmFYsgfWdBGSf9FHHZ1IaE/VoD9fTpHqBUFiPzy4VAfV2bCwPEiMtmIdP903nAlc28eou86IjtuIDkYmU6zJ/ZYPedopZWZHsaYq7c5IXE3nORiOwbAlbZiIjxRIwMu4PiV14Rn4Zjy9JRCqZWGwOsS0zXkeijuEOPlJWAAAgAElEQVRlK2gsAy0Pd+UPUr/Xc25ov7GhxfQGaPPvvzcHWCx4i/8e5Qa+OYUwpX++iFYvMbxNGExZC1JfjHGIX9Ao5GG0PDBvgLjqLf7/DFZCh/IiuhmjrWvHunQKD9wk80oSexpij30JXM09qXB0pf83TIkG7Bx1hBcSYR+sZl3mB0kHa+4bucRkAKKhY1y4YV54uPQi24WcMJByrrDoRxOTZrbKJSa3W4QpAYzZ0wBnMJPe04h1TyIp2YdoCB7zTJyNVca3xdETpOSDWL0vtE/tB1AuMLpRpX3bwZkgnPbfRJa9WpX5ToPTt1zmRWEDlR8FFB520c/3jM88yCUFP9EewVnbNEfprVXO3i7Rvw7hxhS1l6b4ZLHwq2SC8O4VJi1JvKbP5iR2TyEM6X1vi6PvKdztPgDzL4oUnkD9wzZ6d19OUqtNgmKGwE0shr2+h7O5Tvu7a/SuWITRvlt4rsnvzY0komxbBoyxDTQK7AXtrlhE11pSWHPFIsho8s+RwNaTQykviYa6842yYEXOhqbG0K7VmN/d4OJumv61EG1B/pklSd8o/GTlcrC1xmQrz6xog4bC87FITe0O1sYqB3/eYvTumKvNcw77BVL/rkjz372QfoDVFvOdhhTSd6dYg6mxL9v1KrpVo3+jwLhhkTm7fOJXjiMp8Wx60avdHZqye+7dYLLi0t9yUIEm09YU77fh8MSYISYrLkprwVMcD037nL3Wov3uCp1bFihN9gAavxI8hfZ9rK11JlcqpgKycn8giOd+H3t1hdl2lYu7aWYlSAyg/MQj+8Upwf6RtJnlcnLYyqSNhTsuZoozOIBBvIS9/sJzHwbYpaJJBIPMCGPXnm5WBXY4nYltPJWKCn1G0h0ARto1TqIgvBRYNbeBpfKXcFmajh4G+PY1a8FXH8q2/z/TQP9/vwHENlBT2aZDk/6Nr2wqkzFXsHA6MztpjE2I/bhxmMrstF/z5JFMyCIcpwCjwnY1FfeRdtP4pYxcdcdzkXRsSyicEV7ZHs4kFRpB5nAcVCZj0sSEWv6f0WRx2shEbiClUP2R+JijRdk8Ik6IvdKQhT+2tsVvtmyW+bUmo5UUQUpRfDwmcdwlPD2/LJvFGYZ4AbNtw1I5+fEqk4ZIBqWnHpmXPTm1F/NMdsqMmwn8DJSeRD7x0zOsq1t0X60w2LKY1DX2HApPouDYfZFaVLnEbLtKkLRInU+wnh0KJqJYwLu7Rf9KhnFTMa1qnLEi3RZXjfPefTkZb60zvF3F8jXJ9pzE7glhrw/Xt9j/4zJ3/+lDKskx//7BHYofpGn9pxP0wbG4vipFZis5grRlMg1Bt4uzvsbgrVU61x28nASusoeayueLpK1KJrErZfGRRx2yy44gZ3uT0a0GnVsJZmVN+lzR+PVIvr7Xx66UTJ7EK2dwhnOs8VxkKtdlem+T/k6SwbYknfPPIf/Sl5P18xfGLjldyTJuJkj1A7K7Q9TugWjlrSbnP97i7G2NqswIRwmqH9k0fyZQO6dZZ/T6BpO6gzOVhVnv7puOX//NG3RuZ5iVFc4IUt2ojvHpnhwmVhriRAq1YNQPTxYdv7FE90qWWUlR3A1wj2YkXp5LleqNFcaNJJ4byVMve+L2WbrpjFq2IComUPtsYvhAzlqL0WsthitCAy0+n5H68pCw18cqlxi9tsZg05G+h6EmdxwI/uPgSFrOigVUpUxYcGUgHZktlGML9z/poLwAZnNxC01nxgkUL66W64pzKLZbz2biRsrnoFaGw1Pj4dd+YA6feu5dngHEknO8aEeqQ+z2M7f8OCn8ldP874Hllh9fRUVHa9o3agZgghJg6KCxRGM0NbgcEgPiph6VTJgd2S4W5PdWm5cLYZRl2CTApXmCGd7aNjqTIkw7WMMZau7JhlBIi5/4bGQ6UmP7aFgtEGQW+QGnJyliwBTGaKWktH4yQ3clEg9cbguKIvbKdcVBFIZw0ZWFvVbBrxeYV9LMCzbpC4/0oxOx3sVso82GZB5iV02kh9rVCv6NNU7eccmchoQJRfZIZKJ4NjBtyIaR6sywO2P03iEoRfjqVfZ/nMN7dYTXS5E6tSk+hur7x4R7hwatEQ92E2cjKR6Pyj28O+ucvp6hf9ej+qGDl1XUP5maqkVl29irTYJaAW1LUjkOjelb21y8VmDyF33+fOdz/u3zuyR+VqT5fg/16CVWpcT4VpMgLeUkmZeL3mDryibtt2v0rlkEKU2qqyg9kQUk3Ds0nHuVSqFzrrzO3b5JZFuua6Br5/eShDYk+1C7P8H5+Inp4PVWy8wLYndM9DwSpwNod6FSYny9QudawtyUap/55D47wn+5L8P8lQaTm01mlQT2LDQc/fhQEV5d5+Q7RfpXQ8JsgJrYrP88JP9BFPy6dZXOvQqjloXSUPt0RvrhkdwGVpqM723QuZFgvCqzjeZH0cn58HiRMq+WRZ6MEBUx4sKqVQhLOSarOfyshQqRANbEw6u4zKpJBmsO9kyLDPSsS/Dwqdnsu9czeHmFNdeUH89JP5O0r0omoFFjtlFitJIg1QtJdSSwRhCgdjYYXisyrtvMylJWU3g2Ifn02BT1xFwpP58Sy/NgKg19YYguF/AqrthyR55xrRk5J34sdfAuIyKM9z/rymFwOF6khZdLmyKUxHLBE7BIAHtRyjeZuNRsuHzYi8Ngsdz01Z5hg42IHstMoG+OC0hV9LfTf7aoVIsLqpdKlZVti30t0vZjT7+Rc8As/gDOzpZgHvxAroDR1UsnHNP7aXhDQSjfN58lLGQMAwhboXwZAOOH4FjS7DWZCsSqkmfayqFtSHY9Ekdd+TM9OT1IhWBUU+mHqP5IQj2jRU9wvOkYhMWSBdRY1HJZwo0G2rEI0g7Js5FxtcR1h3G9pbYVyRfnhlrpbG8weK3BuG4zWlVkDzSZdkju2QDtWEybGfxo8Ux15jhf7pmO3Isfb3PxqiJ9s0fCDvB/UaX5mwnJR0ciR5SKzF7ZwM/YxhGlj05NY5XfLDFtZOhvOYRJcQQVf/bY9Dvb1Qoq5xIWXKz2QKy54wnKzTC7t037Voruqz6Z2pjZXo7CU4uV97qoF0fozRUG1wqEjiK3P8V5cogeDLFWGkx3qrRvphita7xSQPLCZuWDgNwXp4tWrGIBGjXCQkaqQi+65v0Tu07O72boX5O2r9KjkMrvFqUzar3FfK2I79oGh6BeHpvT3vzeDt3rKaZV4fNUvvTIfryHf3yCs9Jk8M4ms4JgHNzzgNwjCWXFpTWT9Ry9rQTjlsbPaQqPLQovfdxfPpDgVqVE+6dX6O9YpNpQ+3xC4tNdWaRu73D+poTGUBrLVzQ/DCl8sEdwfmFeNxVqnP5MvP3trrENBzc3GK+KhJrs+SR6M7PAept1etddelclzFf5TFN97wD/5T6W6zL+w7ucv+qYlHLzQ/Hv69lMTvSvr9HbTjCtQv6lpvbhBeHTFwDoezfoX8syWrEMFiPz+JTwvG16l8Nqwczj0Bp1eG6GqfHnMXSEkRWn4sPpbHGoWu7pjjJH4XgsKf4IRWOcd0t9I7E0bIKaUSeJ7vQk6KmUkVxjO3cMnfxqa1iMeFn2/8PiZG8YRvD10jCYG8E3QgKKKyGBSyzsZYyqSSpOZyYgRSIpV71sRoaaUfQbkALsKNIda+gAXHQWDPDIzrVMA4wfKtQyOE04wg2KbKA67zJv5PAzAkxzxoHYzto9YzsNK3mCXAprKkNhNYkY73FRRcwpWbKSmVDJUgVdzDUPKlnswQzVHxGcRg6HUhH/2iqzchIVaNwXPVSnL4O0rAtba5x/q8y4JQ4Le4bxsjP30OkUs5UsVqBxBnOsF9IkZt++xul3K7RfDWleP+esXSB1P8PaL0bYnz4RnlI+i9csMl5Lkz73TMAnHgp3b+aYlS3S7ZD0hU9mf2A6ZmPUc5B2RCYZTIVf3xtg1ypM7q5x8KMk87q86au/tql9MsDaPZIN8co67Xsl5gXpr81/eiL6davB6Q8bzMqCSPAzohXXfycds2G7K5JEPif2wWzm8k3MUqjrO3Rfk+HmaF2TOVIU9gLy96Wb2C7kCK9tMKumCRMW9jQgdTyCaFPQt3cYbmWZVsQNlOlEyIIlG+bweoneFQdC2RRi1LFdqzB4Z5PD79uo6KOaPleUH/lG8iDUWNe3GW8VmdQcUv1AEBDHJzirLc5/skX7FUhf7zGZJEl+7rL23sRguq2NVXpvNhmuWaTPNdWP24RPdiXXsNZidrVBbyfFtK4oPgskJb1/JD97dOL2Khl62ymypz7u856c+CslJm/t0L6TFPzHFJq/mZJ6eCjD21aD2VaFwUYSPy3vxcrnQ9QnjyDUBN+9S+dGmllR4Uxl3pR5ei7MpyVERJiwFpDBwVCIvlGp07yZI7SVSIeHPVMvGQPrSKdMCNMQQcEQd1VJbp9xBiieEcSn+dilEzvJ8KIyp4hFRsIR2TAilcY3it97LDkTl6UciCzwS8UxZtP4B8pfvhkuoPgGsMTMN7vhMsMbFvzuyFKpUwnzpIeDATFZz65XjUWUYp5lYFvsEoqdRfFNI8ZIG55Q5JxRk5ncGCpFJut5grSFMwpIHw4EEzH3oJgjLGXxinKqSB0NxCYa6YUqIwE1PZ6YN1J40TZ2MpWVUhyCYJFYTku8ndk8elN52LUKwWqV6YqLl41koOhqjW0La2YnR/eaBIySPeH0ZHa7ckVOJcXVAqhx5AYaSmq18+MrXNxTpG72mIxTpD/LsPKrKckH+6KLRhq1CjSJ/vxS5Z+9scr591v0dxTa1hSfQPmLgbGo2sUC/p0tnPMhs/UiyZORJGZ7A8Po6V3JcPa2vE/zzywavxkbJLCzscrkeoP+VhL3IiD7fGD6modvrDNakRuOdjSlL0UySLw8kxNvZAHVmRTKD9CjsTyfni/+8NUm/VerTKoWXlaROdPkDueXLY+rTca3mowbCSmsGU4I9w7l5Hl7m9N38vSvhKJjP1Y0PujB0z2RkrY36N2rSQ1kUpE7Cij89phg/0g6Ge5d5fjbLsNbc/Atck8c8nshpV88E4x0lOuYXKngZS1SXZ/UXpfg8TOclSadH25z9IchueYQrRXegwIr7wdkP3gum3okww3WU/iuEp/+B3siE+1scf69FvOi1G8m+9FQPPq7x/p4PCvTbgqrPzYZAuvVG5y9U2JSVySGkD2WpjHO2lAtMV8vM2olQUGqI4U14bOXksC+ts3Ftxv0txX2HPIvQsqfdggePDE20cF2BtvTpDo+6S8OCM7bJo8RVHLMqmnsWQgKkqcjc9CwCzlUsYBORcTOycxgWy4BJpFwl06nJPU+GJr5gEnpL/eR2PbCQQimBpbZ3HR1mAEvLJK/S37/hfPn938P+FpUtAmILQfFvilJ4KJd098p/tMFPyPSuIwPFy6XxMc7fyZlGD56OjNeeKtYEBkmLnOPwW/L03llyQk8OiXECeGYK6IzSdk0IgePX8pgD2eEmQR2eyQ9v8kEfquMn00QJEWDTR+PUEfnhtGuXFeKM5BZgAo1uj9YbEIJh9BNC4AuLoVJJtDDMXo6NZ2jcaJ3sp7HnofYEx/noC1/TrPG8JU6p2/a+K4GrSg8FbJl4vGhYCtqFabbFcKEhfusg94/kg1ltcnJT9e5+FaAXZgTnqcoPrSNpIBtQaPKZKNAmLDIPu8tQlWNOuM3tzh7XcBoyof8C6h/JF2vgHDk81nG2wVpITtrC27A87HXW8w3K5zfzTArI6nTFyHFRwPUw93IcVQj3Gww3shKof2LnvQKZ10Gr7foXHeYNOW9XXoEtY8FV6AsC13IoTMiiyk/NDhhEIumv1FnvO4yrlsRFymk9Jm0bQEiMTYq+IU0XjEpSIGDNv7+AXatRv9HV2jfspndnKBOUhQfq0s0UXu9xfhmg3FdTuuZk6npHbZu7BhuUv+Oh531yHzs0np/jP3bR/L8rDTw1qt4xSTzgmAuEl8emEW9++OrHP0oJFmdMh8lKXySZPWvo9zG3MPeWGV0s86kJpJM6XEErOv1se/c4PTbFS6+FaDmitrHFpXP5LnT44kA+SpFgmzSoE3ixS3OLgyvFvBTisQ4JPu0b5wywc0NujdkYOyMNOUnU5KPjmRmUSkx+vZVhms2nTua9KlF5WFAbncI959guS7+nS0GW2k8V1F6OiN52I9KY5LorRbDK3nmWYvkKCR9MSdx0DW25rhPWRckb6PGU9HwIyUgrBXRjiW9wMOxWTv0YChojhgKt2wVjTDQJuUbD4QTjmSIwtA4AM2pfzmDtMT/Xw5ywSL4ZWaAX1ng5Q+KNoKv/N43RgKKXUDLuNR40Ks9/7I1NJrUL4cm4kJ4Ekmh/p2cy4cXFk/+EmYhdg0tR8CVmybMCydfjadSB5hMgGMtFpDBBN0fSP9vrcis7hKmLBmoPh+gji/khJ9KQqNK6Cax+pPIBRQ5AqIsg3IzhDGrKOoaBYxcFEPIVDol/v9qTlKQUfw9TmcO79bpXHcYbYTYM0X6TLH+n8RLDogdtZJjsuIajV+PJ6j1FhfvNjh/Q1O42qV7kaP2NwnKjyS8pRyH2Y0VZuUE6dMZidMB4QtBRHBtk7O3S7TvhehMiN11KD2Exntn6Hi4GqVeQ0eKU5yjjmmzsmoVRndW6NxK4LmgNFQ/98k+7cOzlxK82lglzGcJc0ms4Rx1ElX+FfJcfGeFzh2Flw9RgaL8haL8QIaEAMFqlSCTwJoHUgd4dCb47mwWvVZnVsswaSSYVmT2ke6EFH53CufCuadeYXy9gp+2sAItr+3hucxGtta5+G6Lzh0FIThjRWFX0sLBY8EwW1e3mK7mUVqsuYn9C3NTUrevcvLtIr0bmrDgY3cd8s8sWv/xyKCeJz+8w7Ri46cVlYcTSW+fXsiQ8eoG+z8tMbzmk22MmLzIU3hs0frFuXQzREPd6UYRP2uTOZninPRMoM26c53pep72bbH/pjrabFqX2FoJ5/ctsKsreCslvEICy9cyG9gTIqeVzxFurdC7kWe4YZFqawq7c9KfvDRBwN47a/Su2IzWQ9wjS/qi/2aXsNdH5XOEGw0GV3JoxaW5jnIz6JU6wxtFJlWhqBaejnAOLhbQuVIJGlWZnSUdrJO2wbzHaX+dlkOeWGMjhPRyKXw2g6qU0SNh+pgeDVi0oMUhUt9fyLXx8HcJ6xwv9peAcUtrcNwpYG4Dy21fS8jov1f++aa5gN61fioOmMi6uMzPABaguKWaNSuTNilaM1BZLmqInUJxx/By6bzjmO6BuGjepILnnswIKkX8QhprHrFeun2Bsa0JuMseeVjjubh0hiOxkkXDqDDlCBnxoitJ5WSUTLZttKUEP+H5Ap0DkZgmE9MiZLmu4clrW8mbttMXHktkjxuuOcwqEvsvvPTJHE6wHuwa2WG2XkQFWlg15wP04QkqmWDy7RucvJUQzk4mIP9ZisZvBRKmUwl0Nm1IosmjvriBojlM9wfbnL6t0OsTgrFD4bMkK+8PUJ/IqdVp1gnWavi5pOCp96RYZJlb1L3p0rsK9lQcHtVPh1j3n4plMQq8xdIXF1052UVQuYvXgLUJwShB6bcJ6p+McU560BsK3sFNE8Yf9BfHqEQCf6vBcNNlFqWUvZyUspeezUjtXhj7rL3WkhNz3SG0IXfk436yR3DexioVGX5vR07s133SJw6tv52R+VzawqxcDq6sRwltRWZ/gGr3TEObvrVN526B9h3wSwHJM5vqfU3x866ZIVjNOqc/ajGtKdLnmvrfnhI+3zOYh/7VLKd/NuPu5hH7vSLef66y9vMefPpYbpNRfsCehqSfX5hilFjmmq0X6e0kmdQVxWchhadDrL1TGZ5XK4TVAmHSxjkfGDcQyopgfXUma1m5KZ1McV6cXlq4h9tZpmWL0BZwm/Pk0NxUZq9tcvpGinlZY80UuT1N7eMu6sUhKpNhemeN0UoC24PcyzH2kwORBisl/GurjFspSRpPF9Je2OnKGpDLysIfdSozm4vrzw/QzSpezSVI2yQGHonDjsF/mPUjQshrzxPXT4RmkQUjvCT7xIYSPZ0taKBxf/BXq11BSm/Gk8WpPTrpm4X9a4JdJgC61C0Qf+3yBhFvDN+cGUDyTy8Pf5cCEpd6MaNHXLgMXLp6Lafw4id8ma9xqfsTDLMHP5DbRASY06lFN6iayovh1/JiUxzMsHpDaQPTWkrp64Jftma+9JBGATSrVhEvf9QdrC0liInJ3BBDjdQT/fxWqRgFRvSleLlVyONtN+hdzTDPKey5pCgzv3spG5DrQqXI6HoFpbVgInaPDEhrfneD42+nmZc0oQ2Fp9D8VQ91dA6lAt5KntCxJFJ/3iM4PZeinLs7vPjTHNrRzOs+dt8m99Ki9Z+j1GrMc1+pg2OJbHbRXUg9EUO/ey0hvJepDEDdL8/RJ+eGA6RyWSkYH44XM49Gjd53Njh52yJ3u0P3oEDpC4f6b8fiQ7eU3Nw8X+iugNXpg2Uxudnk8IdJZqsediYgbCepf2hReC7SWBjXDUb6/rzooBVkD0RqAfDurNO+lTZ4jGRPUf0ioPCbQymer1cZfWubUUuSrcUnE5IvzgnbHaxKmcGbq1zcdZg0Q6y5wj1SVB54ZO9HGOdKidkrG3SvSRLbPQkp/0ZuE3a9yuk/uUr3tiao+BAoUkcOxcdQe+8Q/8W+DG+vNfCyDomRT/J0ZFLU1vYG4ytlBpsOflqR6mnck0VbG6GGcgG/LnwgeziTm04UaLO2N/BrYnjwszapi7npN1DpFGGjzGRdOrmtWUjm2cWiO2BrnflameGGDHcTI2l4S+xfEJ5dYBULjO9tSKgshMLzOenf7YoZYKXB+M6KPCeZuPNgTuZ3L6VbOKKNztfLwvcPNMm9CwE1AiqXZXa1YXqN3VPP1HoCcsiIkTDxcDheQ2J+mJuWeWAQmk1D1otoHUmnFmThqGMc318QCEAUijiwqrWwfaL/vryumTXrq9r/37P+iVtSegO+MRvAu/YfY2h4VsTX+EqJMrAoSFi6QqmEI1yX+GoWJe+WoWryxdbCehn1AMTeYNO9a1tiE2Wh8WnbkhP73EMNRhJMUgqrUiYs5sQuOvXERx6fTGoVkTBckSLU3Bc30UgGUbHkEzcRmfh5dJJZLpCxKmW8zRrjlRRBUjTXzFF02p/OsGsVvCsrgtbtzXHO+oQvDkzit/3dNbrXLaarPtbEovaxovJpF+u8B8kEk6s1vIIjnJooVxB7uU+/JR27BAr3aZLGx3PcR2eSwAyCRQDKTZuuWELZrKZ31piVHY7/+Qx9kibRtyg8X1j/Yh96DNjSo5HZsK1GjfGNOuevygBRBSJXlB9FaWXPI9xaER94VC5Opw+WYvrqBkffTeG80WWlMOC4nyf1b4vUP+qhdg8ElZzNwGqTWUsw0qmuR/LJieAvahVGr29w8k6C4FaU1Xjm0vx1FELaO8S6vs3pd6rMyhJQar4fpVqjuUr33TXGDQsvB0EKsvuRFh7xbKxGjdGtBsM1R4Jppz7Z+8f4L/exr25z/v0V2n80pZAf09kvkn/isPbXHfTDZ1iui95q0blbwM9IsUvpvlhUY7x29yfXGTelWzh7JL0O7udH6MEAVSzgrVcJ0jYq1CTaE4Gz9fpYmQz6zhXGay6eK97/9IVnDA84NjrnMlnPo62ohvH5sWwaTgJ7Y5XhnQZe1sKZhaQ6HolPZZ6jkkn0jU0mrSyjli2dEfsz6TuOJM3Ot5oMNyyCpJTZx4ng4PxcFu7NVeaNLH7aljrU465ImmnJcnjljGj8Xojdm2L1hsYSbVdKEu6C31/0s5K01+kUoZuQfovxxBy+YkSL5boisyUTEcsrQr5H1m2Vz6GHY0nfRxuSaRtbWq++bj6wvMZ9HQ7m92YC35QhcEFV9LvqJ+aK8/dxMEwhcoyLzqS/tsHHfEkc5ojyAAAqn5Ve1yjxa7T5RLRZeL4MjWIsbFr6SNVkZmxf5LOmIlJNZ4JziMpYVKtBUMsTZBysaUDiuGvi53ruGd0x3pwMCCqVFHxF9P+hQygVCGp5ZuUUQcbCPZyYgFY4neFsbzC6XcfPWGT3J9hPFgPC2b1t2rdTjFY1XiUg0bUpfgn1vztDH55g5bLMbq5GJ7sF1dIq5hn88Bqnb1gU3zyn23cJjjOs/SIk+7MHYuVcvjqHIcxmZvFQ6y0mO2W615NMGprQgeyhIr8v5e/BqZza7UZdTvuevwgfRXCy8U6R4YqD7QkjJ9ULcB8cywdKh+jtNcK0Q+hYJI57MvOxLcJrG5y8U6D79pyt9XNO+zkSf1Ng9Rcd1ItDeQ+Vi+h0ktBNEmQTUoZz0TV2xf7rDc5ftQlvjEilPUZ7eaq/tWj8P3uE7Q5qe92ElBIj0aLtx/viJX/lGp07BfpXFPNiiHtosfLriQTjdvfFVLC2YkrMrbkWaeJzGRrz2nX2/6jI9p88p54e8osHN6j/Mkntr54K+z/KD3RuOng5TeEZ1P7uVGYzto2+c4XRZpb+hs28BOkzqH06ltNxr29S2jq6acfusZg7NHttk+GqSESZc03+5YzkvnCdVDpFsFrFz6cIHSX8//0L/L1DYzuebOXx0xbONCSzP0QdnEovQsRNGldtJk1F9lBTejzB/u0j+aDe2Obi9SKDLfm5Cs81lU+FIKsSDtQqplvA8kKS3Zlgns8usGoV5mtlJs0U9kzjTALBekR5jzjhHVZL4FigNVZ3KM9HJiMunnRSEsPDiXwmz9oLiSeaOVr5nGweSsnBcO4t8gSRvKujEBndvilvimeYIKrFJe//kuJhZp9RMC3OBsXdwvIHfUNdQLEEtDw4WS5OuIR+BtP0RTGHzqaxznvSdZpMXEK2Gu4GRCTQqCPYsY38oiJIGwgyAVjMCFJJ8fZGiFhVyBGW8wJ+G86M9o9lidul4DKrZVBabKCqN1wMiCzLyEIq4RjXUfSb8tSqCWQAACAASURBVHOEoaGUxuXrQcom0ZvL1fmiLUjlKNU7XkmRGIW4D46lQzadwnvrOnt/lMLfnJLKeExPsqz+HApfdMypmxvbjNdzqECLFHEqaVz/zRucvOMyvDelWBozGKXJv+fS+uWFkRXsWlVCMFobznpcmj5+ZZX+dkKKYzKa4lPIv/RwH5/j7+6JQ6tcImhVpG7wWDpyrUwGbmwzWcvS33DQjqKw65MY+aQeHi6qDhu1RVVhzFCae6j1Fp2363RuWvjZkKDkk3mepPmR9A9w3pbOh4gXD2B1BujxVK7tbgZvs87ZG1lGm4vwWO0TTemjY3S7g6qUOf9eS1AKE0391xHiejLFvr7D6Q/rXLwVgKVJHTu0/lYAZ2F/IItOvUpQLzKrpsWrfjFBHZ3Lwr69ydmPVrm4p9m4e8xhuwDPslz7X07F6rm+xuxqg+7VFJNmhJl+MEL95iFWMc/8lS1O30wzbgmGOv9CU3gxI7nXkb97NkuwUibIJVHzEKc3Qe8dGTy23l6j/VqR4ZoiSMvJu/ZxH/VwV96rayvM6+Kqsaf+paGyXa9KcUwzheVr3IOxBOt6Q5Rj411ZoX0rQ5BWOGNN6dmUxCfPpKlsfY3+t9Zo35JAXOZUUtaJT56JW6/VYHi7yqQitaTZ/QnOSQ/d6UrgarWGV8kwWkmSGIfknvQM/sMuFgivbeAVU9jTQKTZyJCh554EEItZma9NvEWN5DRCScSyTEz9bNYkCzT3FnSChBMt+ks9ItMo8xMPj5dP97F+H6Gol/t+5Rd/z6zgq4+lm8A3QwKK+gDMExID3eJcQCTrGExCLrtocIoyAMpxUIWcRPq7g8UgJ+7zhEWAIyZuRpP+eHCjUknJACyRQnWk26lMhrBakA/zaUcGYFGkfb5WlIV64OGcDaTNyfPFAhonkEcj009svn9cHLG0s8s1NEGYSWBNPKz+eHFKi6yg87q4lZK75wSHJ9jrLU5+vErvOlg7IwrZKRfPyjR/paj87QH+3iHOWgtvvcq0mcKaaTJHI/SDpyjbZvKHdzl5O8G0KeUr6UOHwq6m+sEZ4bOXsvCvNIwMdqlQfmeF0abLuGahLZlL5A58MnsDeHEgOmrkvtHxCezlqbmp6LU6x98r4eXBmkPhZUD25fgSb96uVaSGU2txw0TlQPrOFbo3c/SuWfgZYQtVHoYUvuhiRQXlYT6LTtmC6e5PpQJxPsfK50BZ+NdWmTZTzLMWs5JF9jgg/2UPnr3EKhbwrqww2Ezj5ZS4hb7ooF8cyJ9/e4f2qwXOvuuTrY3Rvy5S+TKg8P4L8atHg1mv7gr7/2wIJ2dGggpubNK5k+PinsZujQmOXBofQuW9fdkYI0DaYE2IoYWXU8PQsQs5hn9wk9M3bWYtH7tnU3qohP//7FCSt8UC/laD0LHAViSOB3J7jIbt+uYWnTt5xg1FqqvJHgdi890VYmh4bSPq6FVkDieL18RSpnZ0vJFHBZpk38PpTtCOhZ9PMS8lmVZsQhsy7UAcXktY8e7tApO6xbwApcdRPeb+hdBWt1oMruWZ5S3SvZD85xcStPR9qJYIiy7TFRc/bZFue2ITjYB78S10ulnCz9rSqXwk/QDL/R9BPiXmjs4I3ekJ/TXhGEnSSDxRTgjHlgU5yh1pN73ICGkt8654zYlbxcLQnP7jRX651nYZC/0PLfZm6Ps1FtFvzA3gXeunl/svlx7mCpV1ZfCSTEioI45gR6XPKgjFPz8em1O2SkRPeARximmdwt+REnrzomfScr0bSguQSqeiU2MCbCVXx7jWbbWJX3YlJDTxBDh1cm5Y4SanEIQyF4jyB+bNFfGGdCJ6Y8QzgsnMBNTCfl+sZ1FXrk4m0GkH+6hNcHqOVSrS/uOrnPxgIX3lnjg0P1rqyd1YZfB6Cy9rSSr36YVppfK/dZODH2Tg9T5aK9K/zFO9PyX5yXPxqpeKqHx28TqcXZiBrd5qmZpIy4PsYUj++Qj7+TFhvy/uiI0WXsVFJyycwVx+7vML7FqVzvc36V21mLQClC9WzupnIymmuYjCPoWCOHui6s5Yj40dLRd3U/SvBThDi9IjqP/ykPDkzLRtzcsp7FlI6mVbhpOTiUhP9QqTjTzzgo22Zb5Q+u0Zev/IWFAn1xtMGgmxibY9nMEc9YVo1eHbt9n/SZbJpgeWJvcwSfVzj+wXYkPFtgVO5gWSGzk4v1QzOXnnKu1bScE8lESeW/u5h3v/kLDTJbh3nf6VDL6ryB3KbCAeWKvVJoO7VS5u20xvTqGXoPilTetn5yaNbVVKhOU8Z28VIx99z5SzxLTQ0Zr47J2ZpvBEZKzYKhvsrDBed/EyinQ3IPtAegkAyW6slZnVkqAhfT7HOenh1wt4hQSD9QRhAjJtTWIUkP3dgZgJEg5qZ4OLtyqMm0qKhnYD8l924bSNyrnMNyv0N9NoG1L9kPx9KZVRrsv87gaDzRTzvCDL8/szUi/ai4R0RArw1yqEjoUzmGGddgzBk2qZoBwFIL0A+7xvEBPKtsXjn04ZKUfNomCoH8iNNwgW/z0MTUlTPKcDTFg1PlCasvhl3hB8vQsI/l7Fwyz+1qKgBkRS+sawgN61fmpQrMuunXh4EneQMvcMuyOWgpRjL4aInm8m9IbhPZst0n3LQ2Qwi5xOOLLLn7bR06lc+yqlheYXaf0qmSBYKROmE9ijuTho4vRupOPrQlYW8+FYWCIxP8QPTGRc5zKESTsqnfHE+dKXE68pk04mF5ILwGRqBtD69g5nb+VpvxFgTSxyLy1W/naA9fkzwUhsrTG5VmNasUm3hcmuv3yGVcwzfX2bk3dSzO5OuLF6woMna6z8zKbyi12p56tVpO4w45A4H8OpBM6sYp7g2hrdG1nGKwrlRzz3fV84NydnEr2vVQjqcmK3Jp5YObs9rFKRyeubnHwryfz2hGDkkDxxhNPz232x9gWBLPxx2GYwWDQ4bawyfKXOqGnjZWURyZyHVN8/luKUZAK1vY5fyhAmLVIvlhb+qN93uppnXnJAQ2IUknkmpfXa843tcLApi2O6G1L88OCSRHb+ukvvdoC2NaX7DrnDQJj1ozlezcXLyeElnqv4xycSTmrWmW1V6dxMMVwHLMRR9LmH++EuYbeHvd7i7EerDNckGdt6b4T18UPBflxp0b+SoXszciN1rEsWWu35WDsbjK9WAHBf9qWD4ctnpvc4/h4AyVFI7nHPHFqsepXZlTrzgoPla+EbHY+kQrM/FKnn1hrjZkossntTEqcDlB8QVHL0rucYrls4E8jv+eQeXBC+2JfPba1C780ms7yU/aTbIdmDCfZTSULPt2r0dzJ4WXDPQ/IPe+b2yI1t2q/KfMCeQ+1TD/dB1AkBWI2aHKSi+R1aL0JrkTQblOUQY03lkMXJmTR+RfOBS30dSyf6mAmE1lIIn07JfBAW+YCoklZQ87YgKqKQabxexbDKZVv712GelzNQRvX4iv3TBMyif34jgmDGBrr8WP6LEluf4sBFQoa/0ZMb5wJMWCwlrWKxp94UM8DlOYKbgVLBvMhqMBb9LwKUGR78dLbgfWRSRgs0b7JcFp3PGsxz7F/Xvo9q1iIaYDSLyCTFEmop7N4kSiqOZFNj6aqYzaKbVckJtLvSYFUo4N9Yo3Mjw3hFESYhc6JZ+dkpwZNdscZe36J7t0hiFEoD0+N9CTCttjj5ky06fzDlD64/5myW4/7uKvW/TlH9qycm5DS5WmNeciR6/+hEUq+NOpM3tri4I+EhEB999bOFQ8Pgq9Mpkd1GEyEwBoEMAV9vcXHHYdoIsVcmZH6VFSLo8zNh+cSJaaVgMiVod0SqyWRQG6sMb1UY12yCjBSBuKce7qMzoUtGw36/WUKFGvuojX90YvDXs1ureFmHMKlwxiGZvb4p0wHk9dtqMWllCVMKZxiQ/mxP9PnNdSbXG2InXfGxhja13yqxkp4OIOHQv12iv2mjLTnVmnlLMglba7TfLDPYVIQJpFvhkaAgwpMzkT1fvU7nTp7BpsLyYeWDKckv9tHDEeM/vEv7jsOspLF8yL2A6ucj7C/3jNbN2grTlrhbEv05zt7ZgrK63mJytcaolWSeV7jnIdm9Cc6zI/RwJNbiKytMmin8lCJz5pH58kQsqtkMrK0wuFliUpaFKnfo4z7ryGcg4TC5UqV7TT5b7llI4ZNTuWFm0maoHucDqg+mJPc6Jkw5fmWVUUtuWSpEUtgvxH4b9yp3r1omIV7+8Ijg8Bgrk8Z7ZYfRWppUVxrWrLPuIqmcTKDKJYJKjiCTwBmIvTXs9szByioUoFGRpPNwtsDAjwXdrtw0OpVEzeaXScKwoAY4tvQPgCzUsSvIUpIbyGZELop7A76m7N1KpxZhsK9hoBnJKLqpxLJRfKD9ZswAlm2gSw/lxH/5ha82rnkzrhrfM/VtsQsoHA7NlSkuarhEFS3mxa4VoSSMf9jNCDTOseWkoLX8eu7JJjGbw2AknvvInUAygU7Y0hfQ7S+Ab4U8YbVk2sXU1AfHklP/PMA6aZvCaNNZEPUgCF888idHN4hgZ4XBlsukbpHsa2nHenQhC3/WRd/cErJnxqL4wQHB8Skq4eC9c4uXf5zile8/4V80P+aDwRX+8qM3WP2ZRen9fbPAe7fWmOcTJIa+YJqPT4SBf6dB51qC/l2P9H6C/MvImrfE+FGF3OI16Q8Jul2x5e5sMLhVpLdjM14NccaK1IWi9d4A68Gu/N0j5roajqWSr9sT+2qrib9R4/Qtoa0qH7E7fjnEfnEiN4pMWgbDyajS7/DE2GLnV1fo3MowKylQIlFVPjoXmWc8NqXwupiTxPbEM8lXbBv/SovOLZfOHQjyAelDh9r9gNzTPtZgwmyrwsWdNONVTZDSlL5UVD8ZmiCe/527nL2RZnAlAA3FRzbF50IEjTuE/Y06/WtZPFeR6muyexMB7mXSeHc3efnTNNwYEey55F4KG8n+3WPTSDZ6ZUVKYwD3RNDgYbuDcl38G2v0t9OMm5bYUI+0ZBQiv7wqF/GaRbxikiClSF3MST4/RY9Gxi3UvZbCc2Xjqj4QjLTu9lHlIrPNCsO1JF5OkTsIyP1GoHTLNFEdrZf5JwPUwZkcyq6s0ruZJ0jKMD3/Yoz99CjqZk6gb+9w8WqewbawhcqPfSGlRiln79YG3esZ/KySkqK9ngQcY75WtWAWdas/Rg+GpgvDqpQgnyUsZcUB1p3K7TsCPYoJI/rsR4UvZk1KpWTDLBXl36OZQPxrPZ7I+znuLc9nZW0ZT4xi8XVY50tmF7g0B41R0cu3h0vzAMv+Zs0A/r6HmQ3EvZuRhhYv/CqbRY8npsjZSEBgeD+E+tLCHxey4PsLTT5yA6mBOHtkcY92++jF1L5IBWFJLGHWWdekElU6JYtKNmMwEmHaWaBrAy1a/9HZonIwl11gqcG8gQC5crpppq0c42ZCOldju2e7K+nojVW8es4M+eIAUf8HOxz+CL771pf8sPyIn7Vv8bu/vsnmf5ig3v/MnA6Dap5ZNS1UyhcRR//OdY5/VKH7xhwrFaC7SUqfW+J1f/xCTvWrK/j1AtbYk4rJwxNZWLNZuLbJ4HqBizs2gatJdhW1zzzcx22RBfI5giurEoyL6i3DJ7JwOtubDF5rmttC4bFF9kTaxjg8Na1i8YddjWdyQ4pooqM3Nzj8gYMG7Dm4h9B8r7MAzxXzUCkJ6ynQWKOJaWmjVmZws0R/w2bc0jgTRelRSH5XBpQkHAavNjh73WG6NSe1nyBzolj52y768ydYuSzTt65w9maK8YpgKkqPoPR4RuI3j02L2+DtdSYVoX6muwG5+2emV6H3vS2Ovqtw1sb4By7lLxSNv7sgePhUTou3d5jVXYK0EjbSsw6cCiYjuLHJ6Tt5hutadPSOYCpyL6ckHke47HKJsFzAq7mSn+hNTPG71awzuVKlv5XEzyrSFyH5F9HXjiewtUbvbolxU/IB+T2f/O+k28BZX2N8t0X3SoJZBQrPQ4pPJdWrUimCVoX2K3lmZUXmVErfrSd7BN0edrNBuNGgczvPPC8bdn7fJ//RvmwM0UC6ezOHtqT/1/3iWAwavg+rTeaNnOBa5oE5IMT2SrtWQZcL+MUMYcpG+aHMCNoD0wuOErcfszlhpyuHxYRjSoIAWSMSDkpr6faYe4ua1ejXKIVq94Q6GkmX5oRPFGBVyiAovjoIvqR4LGcAvgqD+8dmASmlbOAj4EBr/U+UUjvAvwEqwMfAf6W1niulUsD/BrwFXAD/Umu9+w9972UUhHksB7+i8NalTs2ojCH2zMcLohXZ/QDjz1fJpOBekwmRJ6bzBe8jm0Fnkljd4SINHMtFy9jXIJQZQj5vKiQ5vTCF6qpUkBKZTEKko2jRB+QNojWcR0UfsAh9+YEMs8GEUUiKC8jPp5hWEzjTUDplz3qmns9ebZoCe/ukKyf+dIr5Ozd48SdJbrz9gldLhzwe1Pny319n7eeiJyvHQW2t4VWiiPzQw/pMitetV29Iz+4Pp9QrfS66OdQTl9bf+WTee2iGyt56FS+fINmeYj96aQpEuLZJ+7USg03FrBriTBS5l9B8r41+KXwhWnUmGwWCjEWy55N6dmYStdNXN2jfSdG/GWCPLNwDxcr7A+xHL8VuGX8YLUuu5v2hDKuLecLtFkffKzDcCnGPLdJnmvLDMYndE4n5LzW1aaWksGcQFYgUc4y3ivS3HKZVhdIirVUeLrhI41dWzeA2cyrE0PIXfdSjl5LifvsOhz/MM3p1SrYwZfagyMqHAbkHbeHOrNaYrOYYrkpjV35/RuLhgWj/jTqDt1a5uOMwvjYneZQguwcrfyO4Zst1Ca+syvuhliB94ZHavcB/sY+VdQnv7tC76tLfsfAKmlRbUb3vk314JpC0yVSkotXGop9iNJXZzHAkNNbb2wy2M3g5CbYVH8sCHY4mJtx18i2HxAhy+5JWjh1i4Zu3OPl2lmlNNp6VX0lgjsmU+Y0Ww7UUwzWL3EFIYrwos7EyaYLXrtG77spwd6BxT33JfPT64Dj419cZbWQIEktziwMZtsc2z1lJks7V948NpdQu5KQpLP6sgnwG4zzQeCrYkHwaaywkT93pmtN2XBqvizn5TAdaOkEAnXZQU182jCBY5HmIDoqTCUF/+PtB1phuvBRkNfPO5d6Ar+AiLjWBsTgQa8//x7sBKKX+NfA2UIg2gP8d+D+11v9GKfU/A59orf8npdR/C7ymtf5vlFL/JfDPtNb/8h/63kYCgstsjOjJgoUuZmUzC37/dLZw9iSTgl1w0zCbo0+krk61GoSlrLh0Am3SqmZgm3flxY/44srNXD71x6Gt+BH1COjRSNw+9Speq0SQtqWTtzu5NDcwtrHJUglFXF8590wBhS7m0JYFjoVfTOFnBEuQPlvgHJSTkGtsrSzfK2r8ik/8Bz/V/MXbvwXgL393j9LHSVb//aFUDlYr+NfXmTZTsvDuXhAcygdp+tPXOH4ngbozoJofcdbLkfhtjtVfjrA/eWycMeNbTeEDdUUu8A8lMRzc2qJ9WwbDKGnNyu8Lxz48OZNCm/U6/Wt5nJl8iA1RtFjAe2WHwx+6jNd9VKDIP7FZ+WCI/eRAfPr5vOlYcDpjU1doZV3URov+7TKjlnxIcofC7+f0XDa1qPw8yFhkjqYkTnqXgH69W0UGGyKT5Pc02cM5mafnRuoYvNagc91hXpJGrdLjkPLf7eMfHBkMw8nbaYa35zC3cF84tH41JXkg6ID5apHu1RRYkolInU/g/hO5kV7Z5PQHddqvanQmIH2QoPmhh/vRrvD7r27Rv1PGcy0sTy/0+dMz7JUG7e+tcfGKwqsLVK7wFOofD00wzSoVoVaW0Fw6gTXzsY/aBrMR903MV4tyGIhS5DpiN1nbG0w3ivS3k2gbCi983EdSDm/Xq8zvrHP8bppZReMMo+fmN2fQ6TO9t8mskqB9W8p0lnEMMeG1dzPPaEU2BvdkTvLBvtxSmnW81TLjlswlbA8KX3Th2Uu5dTfrtN9dwcuJESF35JP54IlYX1ca+I0CYcqWtHBPXEp6OF7Qdwuu8KJCLX/fwVCsxdEjvsWHpawpn7EPzgUbodQiSBr3CkQKArP5IuUfVdrGYa54LVvuAV6+DSzfEi6tu9Fck+g2cCkrxT+SDVQptQ78r8D/APxr4C+AM2BFa+0rpb4D/Pda6/9CKfUfol+/r5RygGOgrv+BHyDOAQC/N+WOdzork5aTvCtp2XA4koXf9AVkTMFLOBKcLdWSWfzVwekiuRdbvhxbdHtfoFI6m/n9gfDSMMho8hE9NKgV8AspKVSJK+kgstMt+niXG8d0MrGQHSL92c8lscce1jja4T1fZJX+UGSthINdq8rNxrKg05ercTrF9Hu3ePGnNn/47n1CFL/43W22/i9N+mefikV1vcX4Rj3CHfik7stw067VOP/za1z8RIbCAL98ep3cBxmaHw6xPnsqJ+3NVWYrwoPJHI1Mx6/TrDO+t8Fgw2HclGtr8VlI9nBO6vGxcPhdFxpV/FoO7SiSex1jJ+S165y/UWBSV0xaAZljm8yJpvGrNpycy1C3VWZeSmHPAhJnY6xOX+yv2Qx6a5XRdp5p2Y7cQD7uyz7ho+fy2q828Gou83yC5MAjudcRi2itwmynTvdqKgp1QfYkILc7wnqyJx/WrTXGW0XGTYdJQ5HqaGHVRMUy9nqL/hsrnLwtCPBkT5E51ZQfjrCGc3TKZriTY9SwSQ40xWdC2wx6fZy1Fhc/XOfinsKvedgXCSqfQ+WzKHjlukze3KJ9K4mXh/yL6Os/F7x2cGOT/Z/mWf3JHhaaR89alH/jsPI30gGsclmolZmsC98nMZTglj46lfe566LKRYKKDI2NGWE4Jux0iREns6sNprUEziQk2fWwP30qQ/kIynf+pibMhKSPHNm0Pn4h7+nNFfo3i4xrFulOSP7lFPvTp+b2OHy1xXDNJkgJ9yh94ZF5cCQOvq1VJus5JlUHy9Nkj+bSD9wfyHtxtcnoeoVp2cbyNdnjOckv9s372bu5xrQh1t/0yQTrxYkk9C1L6lKLOUJX5op2dwzt7lKaNyHh0uXyeH9BDcayjPWTqFPEVMv6gZGL4xpY/Eg5UNFhL6p8BC6d7L8uJHYJGb3cE7z80CFWJvOPYwNVSv0fwP8I5IH/DvivgV9pra9Fv78B/JXW+hWl1H3gT7TW+9HvPQXe1Vqff+V7/ivgXwGkcd/6QfqfLUqZl7Swr7J+zIk/QqzGco2ez2XYEtELKReIS2DCTldY31GXKMoyHZ9EwyFTHBFqQUeEobgBoo3CPO/xC25bYvWMPb9RmYspjgB5USOngCmXGU3Q6RTeSp5ZOYGfsnBP51LN1xvLbWE+F754EGBlpZsVkJRhJCGxtcbF22Uu7mlUc0rYSVH52KLxfz8lbHelOWqnyLjukD0SzdQ/OMJp1jn5sx0uvuPxF69/Qs6e8Ze7r2D/vETrlx30F08BAaTNrtSZlROk2p7p741LvM/uJRiv+yQvbNwjRePjoWQAIjSwXm8SZBLYEw/rom8kquC1q5y94dK/EqJtyBxbFHZDSp91UWdtqVPcqjFpppgVLCoPRtgPX4gVsZAjvLpO70Yez5X3h3sRkH3SRx2cyAJVKeOvVaSHGYQA2emislnmOw0GW2l8V8pPMhchhQfdqDx9irPWYn6lznA1xbRskT/0RXKIZw+lIrpV4+L1IpOawgpkuJzbj5DLpSyzapru9SSEyNe/vytuovU1hvdWOX3LYXZ1ivYt0rtJ1n85wfnoEVatwuR6g9O3U8wLmlRHUb0vC2t8Kj7//qpZeAmh9IVD6z+eCCvfzaDXm0xXsviuJZz8oz6cnl8igvqVLF4xIrV2puKHj91alTLBapV5OU2YshY4h94AO1r4Ywx3bteW/uHfPJM0+PUdpms5hqsyqyr9v9y9R5BkWZae992n3J9r7aEjUlZWluyu7mkBDAdixgYgYBwaaEZl4IIrmoF7rrjnkhsad1yQNK5IkCuQkAMOMKp7uqpLV2VVqsjQyrV86nJx3rvukdXEihgzlm/KKlS6eO/ec8/5/+//coQ6uRJ12WaX2TvbTDalxVY6SecqrwTTrXe6BE2fsCT3mb3UFJ5cEh+fieksxVAP7xewYo07TSh9cSVqo2IB7u0aZ7szj/GO+ySZb6FRRzeqaNcWAONiafj/KpczuGgsy9znajwz5lI8N/UHWDIDzDaM7Htr6kCieEX3TVlD2c9na5Zp76wv/GkSWKb0gdUweH3hv7VhpOvLv/UTgFLq7wL/rtb6Hyil/hqyAfznwJ+9tgH8n1rrd5RSXwC//9oG8Fta65v/t3+jarf0T0v/3oqDA7dgSK9Pw01YjOOQpMTJTONvNWpmWJxFs2X5wrgeejYzwREZO137HtbNSNQ9+Zws4FlkXIqJRilhjbu25AKMpyvD0zrHJ2WIZ65fXSkZdoiKYqJOhflGnignsCx3HBv6ZkYUNIaRNK4uO04q1yF+tE//UZHRXfkRd6zofLQk99FzkQU+uMvkcZOgaIky5FdPJU/hzXs8/w+qvPU7T/mvdv4x53GV//qzPyD/jypm07C3uiTlInE1L8PZ3kzC3Wcz7If3OPu9DsMHCboilWv5hcXGH/VQx2fyehs1dKlAVMkLbiD73WaD+Y/ucvrbDuHOEhS4Rzk2/zii+LkoQKx2k+V+g8mWh9JQfjFfIYXvHzB92KT/0CHyITeEysuI0hdpHKRtSRZEu07YKEjU5NXADHYHb9elP17WFM4UxfOY6ofnqwWm05a5RsVFO0qC3VNaqMrnJDHs7SZh0UJbMrjNXwW4r65l2LfRZvxGlcEDuXlr38ZU/ugpcW+AfXePy7++wc0HaeDOVZ6NP4XqFwPUyQU0a4ze7zC8a7OsaarfQvNTmS3oIEC9eY/T36kx3dHEzZDS156JgIS3KAAAIABJREFUiUzOL7GaDRYPu1z+IIezkNZb4WiKdXiOni/E07FZZ/CwSFBS5IYJpZMA73RIcngMSHxqtFmXey5KsK+GxKcXhig6ervJeMeWXOdj2az1ty8kM+Jnjxjte8S+8J5KX/VIXspJytnsMvgre0w2LaIiVF4mVL+R2QKuR3xng95bJRIvJX4+mWB98dyotLi3y3yzCBaQpO3QwwsDDbR2twi3a0R5yaR2T/skl9fGGJrUinLC6U1gPBWSaKoCpFEjapdJvLRQ6C9kgwgj9DhV/8TJSpmXzQD9dLOwLGkfL4LV+hDHUkAiJysVJ8YXoNO4WtPueQ1umX1vvaAFfmM3RL4e/+WogJRS/w3wnwERkAcqwP8B/D7/H7WAqnZL/9T/OysO9lpM2us4iGwofOuNzPppGURpLVLSKhZQjiMto5TBYVUrorDJErrSlCiZCRTlJJA5ARO9yvsMI4kTHIts1KpUxCmb9v70bJ72/l2TQ5rxZ7IKJ85ZuOMYZxHjHfUlLMZz09CapTlBGO54enxUmx0mj5uMdxyCMjSeiCSRbw+/A4bzrwKcXwloK/ytN3j2n9r8g5/9IT8pPONfjh/zP/2Lf4fNP9VU/oX8THJvm/HdlA10NDOVPJYi/uljTn/uM3u45P7eJc++2KLxmSXJW8+ORaK632W+6WMFmvzVHPXkkGQywdnbYfp4g7OfO4SNBF2IKD7J0fnVktwvvpGFu9Vg8labZdVGxZrKy7RlMJng7GzT++0d+o8UiQOFc0X1uSz8mR6cTou4ViAuuLiDBer4AmzbPKfphi2D3QRan4UUPz4hOj2TVsj2BvO7DaYbDvZSU/8wdQPP52a2cfNWUWSSQ1G1OBdDoXlWysTbLWY7BeZ18QA0P5tgP5dNK4tavP6hRnua8jc27U8XeJ8fQRgQvXnA4I0C0y3R/lefx1Q/ujD99ej+FsN7PuNdee6lY0316Qznq5egLJK7W0z3SwwPbLyRpvZMsg2y90UfbNN7p0pQkUzownVC5ZsR6ux6laebtkV0zsbuTw3KOeP7LFseYUE4/PnLJe7XRwbu1vsr2wzvWCxbCc1PFI3Px/DJN2agfPWDIouWLOzFs1T1cyi8quX9Djdv5qUQmIo81f3ikHgwwDnYY3nQZFl3CX2Ffx3hvxyIUikIxfNRLpkWllrGAvNLJZpxp0pYy2NFCd43Z8aBbfm+zOu2GmhPfDhosMIE53piKnft54w4wOR4p50AVfChXDRtIRUnUunnXKMQwrGIfRcVJzhn/RUGJjWpmRmAWWCt1Rrm51fCkbQVpAo+ehkYAYx8c0UG/UuVgWYngHQI/L8C/3BtCPyp1vq/V0r9l8A7a0Pgv6e1/g//TX/39SGw8rxbxq91qdR6YILl+zJUBZLZbHUS8DxTmev5wqBoM86+znmSDZvCn6yS9P500ZcWTQaFUxZZTjCIxTurNlVB/AhG+59G5WFbMkwuFojrRZK8S1hO+4pai2llNJMBUna6cGwDN0NZ8qGn/f6k4rNo+4Rlm8SRXNXip7KIKcfFurvH/E4dFSUyYHx2hMrn6f/ePS7+VsB/8YN/zd8uf8Z/e/57/Op/e4e9//2U+OjUxBUODxysECqHgQk3cfZ2GH2wxflPLQoPBwShQ3BUpPMrqP/qCi6vDUp5WXeIXUX124lBJVj72/R/3GXw0CKoJtiBovVrTe3DC/TZJValTLTfYbxfkIq6H8uR//RcbrbH9xg8rjLet1g0NcVjRefDGd6hVNyqUibYrbOsiYnIHQY4vSkMRqhigeEPuky7NlasqRxG+M97phXibHZJWlWmB2XCooU3Sig+Hxi+j1WtGOpl5NvYQWLyi/VsjtrqMr/fYtZ2sGKNfxlKMHyWZLa/Q+9nm1z+GLSnKb602fqjMfbhBcpxGP1kl8FdGzsQvHXjM4HK6SDEurPL1V/pMHwDtAWll0ponofXJt1q+vYmwzsudqjJ9xLKT0eow1OZezVqgnHY8llWLHlfj9PTwGxuFs+k6AvCfB4YCS1IrnOwW6f/MI+9hOqzOe4rAdZZhQLhW/v03/SZt6WFlr/WtD6bY/3qK6xyidmP79J702Wyn1A8kuFu7bMBVn+E9nMs9xsM73g4c403TcwpJlkscTa7BHc6LFsCYPTPFrinPZKrGzOX0GVRvaGUBNlMpmaYndzbZtFOQYxXM9RXL2ThLxRQBzssNkssmvK+FV9NjSgEQC2WUghaSgQh2RA3ZU6pQrrOpHwgA23MCKBp+0hbwlwCRGU1nkpRuF7Nrz2yds56DOWtwXHWGsoCr9bX4jQ85i8VBfHaBnCXlQz018Df11ovlVJ54H8GfgD0gP9Ya/383/R3X8dBZ7zsTOsPrI4/6e5pFQqG93NrkU+REXo8Mf02E/WWungzcFM2+ElaYu6wemOj1gHkRJGFxIOoALLWUBSv0AVpcLZhhPg5yZGtuGhL4Q0C7Flg2CQZVZQowZot0H1RjGQh99kFNd+rsqhLNGDxMqLwtL+KXNzoEOy3sKIEe7xEvzpFBwHxTx/z/A9y/LWff87Pq0/5R1fv8MW/vs/e/zXH+tPPsO8fMPhBm8m2hb2E5hcLcs8ujapl/MMtjn9XoWoBfjEg/qRK+VDT+uNziats1wjreaabnvRinw5XQdwP7jB6p0n/oU1QEzli8VTT+KgPhydYrQbhVp3xvrSYSqcB3smQ+OlLmfMc7NL/oMXgvoV2RHXT/vS2AWn2oMW85eAs06DwF6vOos57TO/WGO055AcJtS9H8OxIBpDdNuHdDZOpkO9FFL69Xg31cjmSnbb0iqNEpIH9kREb2J024V6LoOKyrNsr49VgiF4sse7s0v+gzfV7Cm1D+aWi+YVwlVSpyOzxBr3HHnEuTSN7MsP+/Lk8t4Ndej/ZYLJrsWiJb6L5RUT50wspMPY2SHyX4b0CzkLLAPRwgv4qndekuOXxjoOKNLmRpnQiNNDk/FLan9024UYZYmFXZUA+ALvdRG+2jBN6XSVmVSrMPzig96aE+bjjlOHzdR99dIZVKkrYz12XoJYqwI4iSt8OxJ/QrBNXfSYHRckPnidU/+zIhA2pvS0WmyXivAyGy8/GglcJQllwaxW077Fs+biTEPuZDIwzKi6NKlGrxKLl4U5WKGgsJS2iFCMdFSz8iyVub4bqj0RqXStJS3cemnWBKFoJStJ1JxOegMz61knBBiHvubJWrHUOMpWiLOLByse0Fg6z3gIy2cDhd2cB66Ex5nn9ZW8A/7Ye6zjoW8EHcGszAFY5uWm2b9YasqsVVL1GFtCckQGtZoOkURZt/mBsjCWqKOgGnfNSGehY3ng/f4vLb+ze2Q4chAb3qjxPMNCFPDrvrPTEaZ5wUnBFbaAUajSRwXKzJr6AJIGrvvgU/DzUKpJwFCWCirAVkW8T55WYv54crQiPu22wFM5Jj/jyCoDo529x/Nfy1H/rgnvVG/706V0a/zpH519dEX/7Amd/h6vf2aL/CEqvFO1PZli/+kps5e/e5/KHJUY/m/PW3hmffbNL/UOHzl+MJFaxWGB5t814NycMnXlC9cNzo0Pn3i5XP6py85OIUmvK8qsqrU809T89JrnpYW10mL7RJipa0o44X5o2j91pG/2/iiEqQvEkof6FtCtYLmGry/RujbAoqpvyszH2pdAhw4Mu4wMfKwaVaPyrAO/lNcnVjbQK92WBmXXkBqp9M8U5ujafrS760k6wFNYkkGp1Ol0pydoNkopP4toC/Zst4apH3O9j16qw1WW+V2XetGVjGSaUno9Rxxco32f21iazjkPsSbuj/kmP+KtvTUJb/40ckz1wpoJ5rn89w3l+Bsslyb0d5ptF5i2b3Cih9Eyq/Xg0MYE9ozs+cWpbsQNoftQTntVsJkVJmvRGrAVdkZ6ElG1jb3SIuzXioos1jwRxfnkjbZ5Wk8kPdhjcc1g2NbkbRefjOe4XrwRLcm+f0Zt1bt62iXxN+9ea3CCi8PUFerYgerhNUHNZ1GzsENxxTOFZj/jpS/Pck5zNsu5gL/QtCqk+2GZ8r4wVaRJHUTyamfxfLCXy1moZ7blETR8VaZz+TDIX4BZ62x2FhjKK40iSWbVEXM6JF2QRoEdjkuH4O3gY7dqo2RKVbQbZGpBoU+yR8f2jaBUuVausAuNTNZGOYlEkrS/+WafjtYyArPvxm0Lkzb+fPr4fLKAMB72GfLj1yHpkaT9fp292dkIwC3qWBpaSPA3HezITpUMYGedwJsvSi4XYyDMJmFJi/lrL5FTW2vNJB0BYauUQBJF6ZjLQKJKFC6RdVCqYeYPRCi+XwitplglqOeMjsBexhIkPF3I6SNtUyrbkZNNuoC5uiG96xgR0/NdLzB8tyBcDoqdldv9ZgPdnX0k18d5DBm+UWLREfVH7k1dEp2c4O9tc/u4u178d8s69YxwV8+nRDuU/8dn4kz7q9Bo6DYZv1ZlsSh+4dBJT+uTUqIkGv33AxY8VbC3I+wHTm4JIEv/lFVxcwVaX2X6VeduhcBnhv+gLeC0I4d0HnP5OldmmlhbUcyidrIbCKp8n2e8yfFBCJZAbRMLwubyBRo2wU2ayl2dRtwxn3nt+JTe655LstAlrecKyjb3Q5M+nWBc9EQ40K0QlD+1atzHNc6nWrFoV7eeIW2W0UreUTAB2p0W41yZoeCSOwgo0hWfSZiKXg2aNyYOayBVDTfE8JP/1mWRWlEvMfrRP7w2XoCrxmK3PIoovhnLdeS6zgwpBWRg4/pWckvTJuSiVUj/GrOsSe5AbaQoXS7ynF+ZEam90iDbrJI4lJ8TrMdwMBN1RKUG3TdQqEVRcvFGIPVzIQBpZvCZvdVk0ZK7hzjSVLwcCEiz6hG/f4eqHBUk6y2tKR1D/ao73Qt6bxaNN0+Zxlpry07GJDc0GuxnqufbtHO90QHxyhlWpkOx3Gd0rEZSVbJaf9iF93Va5JKeBFKJoT9NiazQ2rRqrWkFXSszv1HEmId7pQOZ76T2YVIvERQ9nMIeL69WiXy7JPZ65/+30v5Ylkm2l5KSY+nZugeBs2xB7s9O/dm1pMYWRGBbT3InM8GmWtXSRX4dUZrjnTAyzPiAGbg2D/1KdwP82HxWrqX+a+9u32j6vy53sisg3TbwarAJf1txz2QBWl4sSEZi+8euLv+FzpI8MDEWYuvsyap/nCicoM2uliAeVuf7SAAiDnI3WtLqpWc2whJLEZIUq10XXKyw3yySuRZxXEp13PpZj5Hx5KzYyC5wgTowvQD24w9VP6/TeS0CD17dpfxJT/sOvRfb37huM75eZbti4E03z4yHJp0+wH93j6idNGn//iKK7pL8s8OqzTSrPLcnZfXlJvNlg8EaJ8b5FrqcpH8eUPkst/2kq1elftcnfGxEsHTgsSJ/+l2Oc6zEsA8KDDouWhzONyb8aGOKmvbvF6P0uJ38QUq3NGB5Waf/Kovnnl9AfoRybaL/DdMdnUbckx/Z0gfNROrB+9z6DB0XiPKBl0yh8dChKokrFGIy0wqAznIuhyPGqZeZ36ixrjgTpHE9MRGQWdqNLBfEtKHAG6Sbc6xsncnBvg2XLY9ayqb4IZPD8zSv5XNM0s6Aki2fpaIH37Jy418cql0gONum9Xab3tmQX1J5oGh/3pUCplRi8VWWyY1E4Ew28/+xalEpIm2fxsMtkW8JP7IVkOlivLg1Hx2rU0YW8wRWo2cKY/axCATbbMreppfGfL3swnJCMRtjbm4TdKotODisQvr/76prkpofyXJL7u5IdkFJgK4cx+ZsQ74sjlOcS7bYY3S2Q2DK4LTzvCx4kbb8l3QbTA0E5WIEmfznH+uI5qlQkfLTNoukxuG/jX6bMoheXsmHubJKU8yw2xFfjn0yNYs9Qgddee1wvYE0C1FXPzD2S3Q7asbCvx5IfkgUrtZvQqos7OkrEfzOarGTbmbJnvjRRp9mQFqVWyPnMwZ+BHMNohZeYzGT9mS9MDoiyLQOwNDPLNCEwKzwz4sG68etWWyg9BXwvNgCjAsp2RNY0r2CGIdkU3TiE0x59Nlm3CgVR31gWyWB4O0dgnRCaqoGyBDGadTnKDUZSyWeZn1lfrpA3TB8Vxqj+SE4PWZ6v66yMJMnahN+yTAyk8rzvALi8UYQ9j3AuRytXYfp7Bq6WbgQSuZiHB/v03q0yeACxrykeWXQ+nuP8xROxsL/zUAacBUuMNIeCDHAOdnnxn2zx6Pe/5e+0P+PDyQH//J/9gO0/CvE/fCED7r0tBm/XmW7Jhdr+9QLv42eyoTx+wPiNKlfvW4S1BJ1PyJ05bPwiovjlpZiAamXCVoFl3cUbRCtDWLnE8r0Dbt7KMd3RJJsLdC/H1r/SVH91Klz1nS7zzSJBxSYsKPyeDDCzxTV+9x69x74oemKoPYupfHwh5q5alXijznS/hL1MpA9+Pccappt8ziMuekRlD5VovIuJSFTnC4Ov1kVfBoyANV5IqE8QimmwkCfarBMV5fvONMTuTaE3QLmu2bBC3xJcwTdDkUnaNmp3i+F7LSbbFipmxdc5H4rgoF7h8mdNJnsyL6m8DPF/8e1Ku7/ZYblbI6g6qESTv1ji3EwktjBzqTeFfGkP56gUj5FMZ3KNp7C9uCh9ImsZiYx5NJaCxfUkWS+fk2HofEl8fSNcpq1Nlg82GNzPsWwonAnUv1mKU3o8Qbkus/d2iQoWKtYUjqfYpzcGgc3dPab3Koz2HXIDjbPQVD++Qo2n6HqFxVaZsOIw3kmVTE9E5ZRM59g7m4QbNWZbecKiRekkIP/0UjDQKfEzE0wYMUU60FauI0PbdgNSc5YejW9B4fRmi0W3gIq1zBaux/J5hCHUKmYYrBzbGNFgpf+HtDOQuYDDyOSMY1nGh5K1gTKVILBS9Kwv/lrfWktwZb3KimATdxvHqzmB6/DPFv/L92MD+ImXOoHTI876gr/+MD0xuEXFy2zVwEoGCuYNXk/gUfmc0deTqoiI4xWF07IMM0TnXMn/BazBRNKw5ovV38mqc9dbyUajSE4Nrgv5HEnRJym4BI08UUF+vng4wb4erSLmHNtcSJmBJJOgWY0awZs79B7lGD7U2AtF9Vuovlji/sUTUUI8vMPkfpU4Z4mrNaVS8s4Djn6vgv5gxO8ePOEPXz3E+uMqG382xfn6FbQbzO41WNZs7EALZ+bwhvhYWO2z33mTwQOH8X1h4BdfOpSOEuqfD2UhsRTBbh0VJkz28hQuQnKfp47ZTovZO9uc/5bLYjdEzWzckWLrTyL8Xx+iHIfJD3aMvt+ZQ+ejhTGdWX6e6EcPuX7bZ7KrhZ//VUTx5UTokvUKs3sNJlsOVgzVFwu8p9LKyDajyHckqa0/g6u+mQFZ9ZoM/5VCBZHgq3uDFVakUjZ/QyuFtYxxbiZy6rMUSa3EbLdsXK3lY+HfJEfCDop+9JDRXp6gIlGI9a9ngqFIWxLJfpfpXpHJho291BL88vGRoBLuHTB7o0WUt4jyEsriH09EpDAey7VWr4iO3ZXwE/t6JLGg6Qk43mqy2Cig0ra1MwnxTvrG+a4KPrrdWCVjpQt3lkER7baMX8UbxfinYgrDtonubzHbELNc4Vped3wiSWt2rUbw3h3mHY/RnkX+RlM+CsifTeC6D7UKk0cNEkcR5dUtNVB2QoxaZYKGSCL9o5F8bqPRqj2XnsSt/sgAGrP+e0YA0Pmcwb4kqarP2d8hbpZZtH2wIHe1MJumns+lmvf9lYFrrSDL5Oiq4K+IoZkaKJVuZwwyFcXovCfGsDSCcr0Tsd7qNgHxae9/XUkoeOng1nD4FlPIc/mnk//x+7EB/LTwd79zvMqqdeD28SczUawx/m/JpLJB8tp/jdTK84yxCjDzA/PhrfXps7BnbHuV/gNCGrXUyhKu0wshTuTDU5aEzFjK8ETivIMVygnCHs7lmJi6B3FsUSFkklLLkn+jUSVsl5ht5Zl1LIKy6MEbn6ZUzuyG6VRYNnPkL0SDT5Kw/Nkjjv+GR+29a4pewMtvu3T/xKLxz59Lu+TePoN3Goz3LKrPY4oncwOFsx/dY/h2g8sfKqJaDE6C/9Jj51+KDl6FEcu7baabHoP7Fnv/dIJ9PUZfXMtg994Bwx926T+0WHRjnKlF9Qm0PhrIbCEMCN6/x9V7ecISFC41jc/XVDEpcO7obxZAycaw8Ys57tcnZji62CiY4PjyqyW5Z5dy4240mW+VmLcdckOJIlQXNybQRoaiwr7xBkvsq+FqPlQqGrS16eXOA9kcUjcx7TrDtxuMd6SiLx/HVD6Rhd8qlwje3me8J6Ep+WFC8dUU69mJXIP1Gou7LaYbog7LjWPhIr08Nmldy4cbTDc9Eluol/6zNf9kKgvOcm7taSCzicsrKRT2t1kcNMyP565Sg+F0aha3uFtDOxZJzsa9nglP6vxCcp23ugQHLcGCTyNyhz1RqKXPPakUGD+oEJQsCheReD5S6a96fE/yeTc9lhWF39OUXs1wzlLlW8En3KqzaMk9ay81ha/Ob8ENg4NWmuYV4Jz1JYgnlW9Hm3XCiofXX8jJ7rp3C9xm4lcRpU4yGhlPkbO7JQlxjXw6Z4uwn53d5o6lmdx6PpeWYLY2ZPJPVrNAoxTMgp7S0CjTvl2XkYKp7s3y9NqalnUzVM4zXQ2ZZ4bf3TDWw+Ph+6ECqtot/bPa37vlgAX5IL+zsKeP9WQvY/rKLoC1N80MiXOpwzdMe2xZRKMvO7r2XLGJZ+EP6eBIjBwrX4AqFYxczJwqnBTY5LlQLa80wY616i0ulivkdJKkwSlKhkVphQNIm2d7g/luhUXDBo1ovm9C4eHcDKTa2eqY5Cu3Nxct+HyBdbDLi/+ow87vHLFX7PNHzx5Q+8M87Q9lBuB028ze3WG86+LONOXDFavFvn9A78dtrt9XsD0niSwKX+ZpfSLB7gDjdzuM9m0JN5lC80sJ+UiOTrEqFWY/OuDixy5xQWMtlWxYn89wrkaoRBO1ysLA91W6QM7E/TlfYLebzH60LxV9CJNtRecjiVpMegNUtyVa8gNZRLKqORmNhV9zv8Pgbg6/n+DMEgmMOb8Uy3+9SrhZY1n3BGZ3OpBAlijlTFUrJPUyapJuzrOFbPIZsK9YINxqsOjmiD2LwukC7+jGVN3qYIfRmzUWVamKiy/H8FxUKWp3k8VWmXnbJc4p7GVK23x2Iu7tWo3o8T7Lusd4xyY31ILGOL9CuS7xdou46JrFUSUa+2ZMfHpuqu7o0R7jAx870PjXAe7JQFqaIPOrmgy0DcnyqmdiJjM1UFT2sBaxnAh6E6lwbZv53SbLhkuUl+de+7wv4esp22j2eINZ10VbUP9ygj2YGeWMthTLfdmUgqpD/ibAe35FfH4pA+s0XjQuemKeOrw0ecpqd5OgW2K64eGNE/KXc0E99wboKBTlX1mYR7iOoJwHw5UkvFCAZo2oXSHJ27LpnslAnDhO14S0sBxNjJdIuXLSyOYLmagkW5MIZWMxp/wM/WIp9Gxh+EMqLQaz+WAWQfsd1U/a/wdutXiA2wv+evcjPfF8v2YArw061pU4tzjYrxFCzUwg69mvV/frR6rlcuUmzLT9Wfhzkhh9L3BL3pV9wDoI5AOaL8wJIVPnqGJhZf+2pYefmc3MxVMukBQkEczuTeGqJxer4xhIWZyzCKqOVJA9STtSxxcmkUhvd1lsl7AiLQalkwuwLcK39rh6z2f28wn77T5Pn23Q+jOHzj9P4W/bAoXLIiL9IwGnKc9l8vtv03tkM7sjm6Z36Yjs76MF3ueHYNsEj3foP8wx3VJ4Q+j+cob7xSHJZIq91eXqr+8wugvBwRIGLo1PLNq/GqDmAWGnzGwrz7KscGcy4PS+Oia+ujFhNuO7JWZti6AK/qUEyxee9WA4Rm+2GLxZASVGuMLh0GQqZIlfg7vyHldfBuSOh+g0IpJOi/ndBkHFFifs4ZnJjbBbDfDzJGV/NdvJqru0zZKU88QlyQ5wBgtpK6RsKbtWg3aD5W5NYHnns1Vec7VMsr9xm1t0HUtU4osjs/jFb+wy7+ZJXIUzT6Qt8eJcFoy9DZbtlH/Tm6Nena+SpZSFs71JuNdivJ8nsRV2kC7OJ+dyoqlViXZbAgWcLI2vwYSnb3WJGyWZjcQaZxJgXw3RswXKc1k+2GDRcgkLFrmRRF+aIKBmQ1pB23lUAsVXU9k0lgFJq0pUyxOUXcKiJRDC6znW4fktqq3ebKEdS+TTqRFSVSvE7SpBLce87ZLvpU7gyxvhYGUy0FoFnXfFcAVw3ZPP1XGNsZNqWVz8SkkBNp5CEIpMs5A31N6Mu6Vs22QLG1T7egt6LWI2W6MMkywdCGc+ArO2ZIv2fJEqF6OVsXStuF33OH2HhJy1rtOTiElA/N6ogNacwLcn3bHp62fS0FvD4TUmkJ7NV9V4obA60qVhKzodsqpSGnKeMTsWcgGpgi8XTBr0kCFiVaEgevEwvBX4nlFDtevIQp/liUaRDJJsewWKSk8Y6xW/XizEit+sMN8sMt1wyI0TWQRultj9mVygab82KfronC25ptd94Zq4Drx9n7O/WmV8L0aXI3JHHt1fxhT+8HN5Px7dpfdujaCsKJ3HlL+4IXn+Cqvos/zgPmc/zbF4uEAHNpXPXbq/nOKeDwR3UKsSbTeZ7hYICxaFq8hAupTroB/fFQb/QYKKJBy+8gzqTxe41zOCdpFZ1yOoKOwl1L8YrWiim12m724z6zqEJYUVpgPQlwNUEJJUi0zulpk3LWJP+D3lJ0N4cUSW9Rpu1hje9UGJvt9+dibva6NG3KpIcEpOUTiZGedoNozXfo64LJuGc9YX/nw6EE1qRZYtH3sZYwUJ7tkA3R8anIjdqKE32kS1vLQT0jYSgFWviSLmjqS3qUgGp/lPXq2iM1tNknaNqJpDBQlKa3kOs4UMHTt14lKORcsjNwjxvjmTiMcMirjVIWgXWTTyrtG1AAAgAElEQVRlgbWXmsrTMdbzUyHReq4xPmrXxuqPTZtL5XNYrQZJtUhYz6PCNBxlJH6VpJAn6BaxliJHdq4nMBituFqlEqrbQudzxNU8ztVYhrppJOr4UZ0oL/ds5elUWjlr1T7tBnGjKKeZSYDVH0Oiibs1Fm0fbSsST0nO8otz4utrUQFWK6hahaRSMJkGdm9CkmK/TYJWhorPfD2us2oD+77hfGWD7uxv05Q4UaPfXwYrZ34+tyINp+FSZlFOC0+jCHJdQxXI5gQGGREEpghdPwWsr2emHbTmczLV//oA+Ps0A/hOHkDWV4dV3wu+Mzy5JZ3KHL/F4grbmlXwOpGbO3uE4hXAtles/2w+AKukoex7cSIXf6tBUi+jHUt0xym905hAsuec9ltxnVVvMANDgVGOLJs5orxFnFMSUH4hVEk9GMmQruijCzkSz8a5HqP7Q4lbLJXQb+wzfFAS3EItwetbdD6KKP7ihQDU3rzP6FGNRd3C76W96JciKUz2NxjfKzO8Kxz8/A20Pp7hfCLIX3trg7hRIqjnifM2ub6Az6KTM+xmg/jeJoMHRUZ3UyTADRQuEsovpmjbIqh5zNsSLm4vV3yh+Ppaqt6He0wOiiyrMiAtnofkDnuo6Zx4q2kYN2EZcn1ofLmUjN6rG5zNLotHm4Rlmyhn4V+vHLlWo0Zw0GLe8gTTcL7AOemJN8C20DtdomrODHXd057A5EpFlGURPNwkysu15kwj3PMhDEbEvQHoBLvVMooZQE4DWQ7tnV2md8S5Hecw7TXnYkiS5txmp4Kgnpde9jxctSMqZeJ6kcVGYeUtOByiD08kArLTJtpuEBVd7EVMWHIE9Xw1huHY0CszCbSKYpgvDD1WwIc14kqe2Hewp6Gw8CczkXFuNwnqObSlcMeheCNu+vLaESVdRs1NKr65lrJchfH9CvOWRW6gKZ4scJ9I2A2kLaZOldluEWup8QaC7lCTGXguy4MmsWexaDgG8ZxV5Xa7KdW+66BztrB/Mn/MNH1tmQIvQy5bSt6PrDr38yK9Tk2iWU64VSpJul+5KEbOeQjLQIi8Y8Fj4HoGBrde+QOGUJx9XxXWKn8wQhITGRmEt+Tn61TQbO3JnnOWLSyvL1UK2ZZwyL53RrD1DSB93NK+ZuoabnOBAPN1q+jLouu50tuMY/PhZ/jn9ZAGoyZ6bfc2raA0E1RHkQxk6xWiZgkVJ9i9SRoWE8sJItUHm9ZSBnWK4lu5oqpcJthvMd3Oi9krSPCGkfT2x1O5eNOLHceS08J1f3UzNGqEj3a5+mGB8UGCFYgaqPXxyLBP7If3GLzfYlFXVA4jil9fSjXfaTH8YIPxtrxudyaMe//JhSzs1Yr0ke/4JlDePe0Z85O1u8Xwh11mbYt5B3I9cCdpatbVGF3IMXpYof/Qwg6E/Fj5cgCHJ5LTu7vFcq/BeC8nksGLUIaUA7mgo+0Gw3sFxvuWGIxeQfVFIJTT4Qj7/gHL3RqTbWlXZOYqPZ1Cq8H0UZvRnoN2ZMPwvzoTHXipaNyuYcHBnUXY0xBrkGK1U8OPShLGj+ryutPFS0ehtErKJXS7AbYS5VOvTzJNUSL72/TfazDdtHCnmvKriOKTK3RfKmZVKspgeqcECQIBvJyKIiaOjct61slC22OKL8YSYp7q8yePO0y74qgtHy1vXy9BaHIvRGMf3zKtZeTLpOKvkAcDaSOpRh3tOsRVn7jgSkTkYCZAvCwSsdVM3dJF0den5FeA8IMHjA5yBBVF7VlI7mYp7vTzS4NiyLhJ+X6MNw5xr6YCW0uDWeKiR+RLMp394nx1radVeVItSNZG9npBnnuxuFos0rzuZDRerR8ZRTdOUPm8uLtnM1Quh1WpoLtNsFXajp2IUTNl+esgNEWi0eFnbeU0nVDwENpAG18vMpVjo6N4lVqY5pQYTMRr+v6MBZQJX9ZbPvJBrmYE2Qah4/h7kgmcOoGV6/zm4OR0kf9NFFBgFfz+G0BKJkryNcro+t9Ufl5mBZm1O9XtAmI59z0Jj85MX4k2u372wassM8CyvpNpoIoFolaZsOKhbQVK4R+NJDt0sZTErEaZuOChtJb5wOW19DQ9D3t7k+mbbRY1m0VTqvb6NxGFk5moMFI07nK/sTI5fXJEMhyhdrc4+5sdxnc0ST5ZpW09ORJ35sEu47eaLKoWUVHR/nCK8+2xnCKaDcJHu4zu+sw2FIktHJvSWUT+bIKaB0TtMrONHNNNm8iHwoWm+eeXJC+ORLLXbTK9J8oRpZH+/+UUwsj87qxtEZYUdpCqaj4WKqaVz8HDA4ZvVAgL6dD4cCJws2UAd3fovVtj1k1jDF+uWlRW0YdOi3CzQuQ7eL2FnKJ6fRN63n+YI6gqljXN3X84gs+fGuKsVS1Dp0lcyUtyVBq7SaIFPnZ3i9lukXldMA3+dYD79YkEh6ek0KCWQzsWziSUVtHFQCrLVoNgp86i6TJrWzgL8CbJKu/5pifzhU6T6YMGiadwpjH+iz5cyYlFlwsE3RJxTq47r7cQXMK1tHqyynm5U8WKEtyrKZxeyAwsl4PNNknBk4HwYikKrlTsYFcrsjG2ZXhrTefSGhlPpYreafPqb1XxrzUqgfo3C2lTpfp/tbvFcqdKUJV7rXg4wZosRW7ZqBK0i0RFCfLxBku5FtP2mtNtoyslklJO1D6DEcl4Iq3dUlFonJ67Utxd9VPUQiSt2TShKwtTAowKMEN76EKq+AsiQUGkLK6smtfLYLXZZANYpQQzDaYlnK0/pghMB786TovIrIMQBquv6cS0kYDvtJLki2sRkdn/r/3sOjX5e7EBVO2W/ln13we4NSk36hqdfFcSBbd0tOvtIRO1FoTmuLf+82bSX6mspvCOvVq0U2mmznnoQk6kgKOJXBRrE3+jJGAN/5DLyd9pSOZvpiPXtiJ32JOLZDyV6qCQJ6mXBV+7jOVInkkpWy2ih9v0H/pMtxS5YWoiejnHeZ4y9AsF9P4my5ZQEA21chmgdjfp/aDB5U80xd0x06Mye/8kofAn34ha6N4+Nx80WTQU+Z6kThk+z4O7zO416D90STxIHCi/Svk8kzlxo8R0r8CiKi5mdypa79wnLwWFvNFl9t4u1++6qAj8K03llaAacB3CzRrT7TyTbbmB8jea+pdjwUhPZ9iNGvMP7jDZcol8hTfR1L6WqENsi+CdfW4e55lui6O28+uQ4ldXYgpr1EmqJcJ2gSgvKWbq5Ao9m2G1Gkwfb8jcoagoXCWUn0+wz3pEZxfYjRrUKkTtCkFNTGP+iz6kbRBVKRuNepxXOJOY3Lm850QRqlEn2K0TFkTy605CaQFd9yBJsCplgoebzLo5JptWummJwSk+vUBHIc5Gl3i7RVQWKWjufIo1nJgsaTbbLLbKaFuhYi2tpFeXxNfXBnlsIGfjhTGGZUC7TE4JkH/Zk8zgLB+jXBIxg59DDcT5qhfLFQWz0yRsl1i2PLxhJKa651dExydiwuy0iJtlwmoOK0qExT+VUwXAYq9GVLRxpjHONMJ5fmYY/fZWl6ReNqgGNRhLQhlgNRvoShGtFKScLGs4Q5/JKUcVCtCoyiaVJCYyFDD54VRL6FI67J/M0KPJSnKdLdpp311uaG0WfZXPSRBU2splsVxV97P56qSR/v76QNh0FrJ20BoSIjO1AkYoYtLHMqz9bzDGwsoc+72YAVSdtv5Z5Q9Wi38WmGxccokcjV5nBek1a7Zlm9bQdwIX0pNDtsBbfn7F/lmTeapy6fYunG4ERLHIzNKv69l8xfp5zUhGuYjO5yR6Lg3YUGGMNZighyNUQ1zHuiTHXyyFPVqgj87EvVksYLWbTB53mGzbBBVF4VywwRkcTdVrhFt1goorg7p5hPvlscjTOi1uftJhvKcI6glJTtP41KL9ywHJp1/jbHRZPtpieJDDiqHyfI3FvrfD8MdbDO/YhCVwp1B9FlP5/AZu+iQHm9y8U2beVWglbZ7SqXBootMznI0u0/d3ufixy7IlMY/NLyJKX1xJr7tZI9it03tD4hiz04T/60NJzdroEjzc5PotH+1A8Tyh9HJqVDHxgx2uflhi8E6C9mNKX3l0/2IhZrgowtrfkTad1liLaBXyU/AJ99osOjkmmzZWCOXjEP+jQ7Nwqt0t5gc1UcNMI5zRAjWaossFtOcQ1vJEvk1UtHAnibSvjq9WCIr9LlFZCJG584n87pppK+yUiUoucV5hzxNyNwvsiwHJTU9aHulgOPZdtGcJFuSmL5t5zkNvtFluFInzNs48Jnc0QJ+cGxnrOt9HJcI+ytK8sBR2oy7D5YInbKOrweq00GxIrkUciyIuFTwYR2q9QrBVBYW0z5YRPD8mmc6MszbZaUtffRZIXq7WJJU0FtW1ifMO9iLCmgXCJbq6AZ3g7GwTbdZT5ZzCPVuT59aq6HZDgG9BYuBtSZYN4LlY3TZRpyKf99VAWj0ZASDDv+dzJKUcdn8qs4PZzPTYTbb4OnLecWQRT3X+caMk8wGQ/I50uJt5BjKygHmsJRWqgv+dnGDl3jamZr9jHpnxKzUlkuhbiiBZ18Qo+/3wAbht/RPn979LxHs9Pg1Wi3+qEMoyAfRyeTtwOQXHAaswmSxTONXqq/lS+qEp6yfrJRpSZJKgLEsUDq4jdu+ML5R9OJ4LzVpqBpEPMyp5K45MOozOqoiktHIs272JuZjtrS7zBx3mHZfEFmyuFWqKL8eo8xt5HkWfYKfOvCMVmP/sBm4GUlE8PGB8v8zVDyycqcIbQOVVROnDV8L439o0kYj+dUT+fGpuYvvN+/Ter9N/pIiKmtoTRfVZYNLErPsHXP6sQf+xuJCLJ4r2xzPsXwufR2116f1E+P9WCCqG5pcRpa97qCAkaleYb/nMmraEi/RiYcUcnRoW/PT9bcY7DomtaDxZGtu/VSmzfLTFzVt5ljXQFuQGUP8mxP/wJYSBGPlqZRLflT53bygVWrnI9I02QcXGnSbYi1XFHt/0sFst4jsbzDdFfVI4nQuWY74gadaYHYgXIyiJxLLyUhyt+tWpIKAbNfSGZAc44+XKqassk4U83c4Tu5AbCnvIGk6Nft8qCOoh3KiSpK2c/PNrk4tgVcvQbbHcKBHnLZxpjHc2Qh+dyiKTzheisrSarDCReczZpXyu1QqqXiUp5KUyDkLD/jGKnpxnJNHJZLo61aZqHRKNti2DM0+Go5X5Ks0f1kphDSem4o07VYJ6Hm0rvP5SwG2zBUmG18g0/p2SmCPjBLs3RZ9dyj3baRI1ikRFB6XBHS4lzD7Dr5dLMtco57FSgqleLs08T/m+CXzCto2aLhkMV6jl1wvFlMypcjkjA82ovmqxFGVQtjmmikKziKfB7VnbRxXygtYIo9WmmqoRs7ZxJkIxLLOM/pk5g+E2FgJWHqYsJyUIv0dDYOt3b5m5fmNyDtzaCAzjJ05WiV9+fpXGNZuv0o8aNSPNUtP5iswXp9LQ1PSjw9BEwZkhTLrbZ8e8TOery0W078mCnrH90+QwEi0XkZ8z/UoTJ9kfmjxi1W0xe6PFvCnaf78fU/pmILro5RJVKbO402RZSwNITsUMk2nokzcPuHmnxGxTkqUaX6exfM9fSU91d4v5gw5BTYK2S0+HcHENtk2y2+H6vTLDB4IS9gaKzT8eY33+DJQi+tFDLj7wmXc0iacpHVl0/3yK/flzkdK9/4Cbt2U+oG1N+YXEGdqnN+hykfndBuNtR6r9C03tW5FqZoH2+uEe0/0Si6plJLD58xn25ZBou8HN20VG9yHOCfOocphKQQ9PsBo1qRyVkspwOCEZjQ3iQOcdglqOJGfh9QIZaJ8KJiKbTYTtAipJ9f3jOYQRwX6Lya44rxMXcgNZ+P0nF8TnlzJb2N5gsVmSk8JwbvrQqlQk2m6YQBZ7qfHGCcVvewaMZuVzUrW2KySeLUPIRSQGqF4/jSyssHy0RexZ2MuE3OENuj8wuch028R1IcxGvi3ZvpdDAzmz/DxWp0XUrmBPA7jsyaK/XBpsiolIXYg+PXtd2pH7LPFd7N5UiqT53CihlOOK4KJekw0lG4ImGlUuSlBP3cVeaJxJKAP10cgUQValTLTdNAEs9mQJV31UPke0WRcEBJLU5V1MUcdnBsSXNGtENRFQWIvQSIrtSglVLovstZCTNs98adz7yXR2a/b3Ok3AqlSk4KuUxFsQxqjhxLw2g5JJ88izTeRW6mA+L20c1yGuF+XEEISyFmQqxrTToCdTafO8Juu8VfjCrQ6I2QTWkBLfLxlougEAv1kC+tqHJkejFJSUqnoycNf6EY20oggbhZWRZzReGbjyOTkCpuwdq1xa9fWXS9nt06oo43ybh+sQVfLY46XQB9MP1gysUmR0Rg1NRgKqyo7Vo3dbBCWLxBFWfOXFDOekJ22FWpXgbpt5yyNI0bnuq2tZhKpl4rtb3LxbYtaVyMDCuab+zdww/q12k8X9DtMNF28iElP7xTnKcZi9s83NY5fZpiauRpS+cWl+EVL4i+eSsfzeQ0b3igzvCpLYmUH3lxPsrw/lZtzaoPfTTUYHFlaU5sR+Jfx+VSwwv9vk5p0cUR68IbQ+FYlpMpmI9K7dZPxOh7Agf79wusA7HUAYEXdrTPaL9B7Zxk28+aeio09GI+xOm+nbm0RFS4JRno7g8EQ+o62u9OCLQsP0BiHu83OiC8lMcLY3jePVnoZijsri/1Ip43RT8NHeWFN+McX+9ti4ddnqEFUEA+IM5tLmCQKollnu1hjelTB4b6Lxr0Nyx0OTj2s3apJktlUzl4+9iLBPrlfXRTocnndE6ZTvhXhfHgvqQVk4B7vm97N2ihpOUhqoJ1V7rWCUJtYshMMTkvEY5Xpyokilz3o2X3kGfJ/woIv2LBLHkor75Jr4upfeX0LotVsNORUXfEOq1VEENTHMRWUPK0iwluKNiM8vVyedUlH+3WpJBq9+zmRnRK0SkS+boTOPZGB9diWziUIB2g2CLeFc5c+nWNdD4usbuc+2N2TRLefEIxMlopCazgyBU9mWqdYzc6lyXGkRpfRUch5J3hEQ4HBNTZSuM1kbx8g4X6vSs5ayti1pE6UgSHQiHYq0Ba1nK2S80fNnYMs1srGRp6/9v4hkErOhfW9mAGYDyB6Zzv/1WMj0a+sxkOt5nVniTgZyyiiR2rbEnj6eijLGc82wVi8Wppdpcj8zFscaLiJplI0BxRovjMHDhD5nuQK+v4qWzGSisQyMVLks4eNVz2AeciMBfanTa8Hu1itmgOksYiFXvjyWVkm3zfDn+wzv2sw7Gv9S0fxSErMy5Uv8cI/hg6Jhzfinc5yjK3TRZ/xuh5s3bRYbMTqXUHrq0vlQAuV1EKAOdrj5oMGyJptK8/MF3lfHJIOhoJAfbjLZzrGsiOmr+dlE/vZ8Dt02s/t1hnfk1FS4TKh+dEFydAqAvbUhVa/vELsyyPNfDlCLJXGrwuROibBgsazJfKF0lhjnbqZW6n/QYlG3yPcTSq8WuF8fyWf98ICrH1UFs7DQ1J4vyX1zLqlTngt3do3pywoi6QWPxtCosdytMeu4zDoylC2fSIRk8uJI5kX39gkbBZZNTyr6gUgdSRLizQbjuyUm25ZsduM0rP7Xx0RnF0ZGmdQrxOWcBMpM5oIXHgxNEFDcKjPZKxDlJE2scBFJ7OfZBXalRHJvR9zIIIvj5c0tU2LSqhK0CsxbLv51iDtYYB1fySkxzcA2WdfTuZxmwwir0yLYrhOVXKwwIf/ixnhNstO4KhZX7dA1p7z2cyS+MI2sWSgmx+nitpqoUkJVK3LyDkKp+v0ci82SYNB9C3ue4CxinNFy1RKNY4NoD1syR3Bu5qiTC8n+TVtvYcOXxL2LtUG5ba2iW1MMg57NJYQlA0cWC6i9LVlrtDbPjTBaOcFTqavK5yTIKQiNMtD87Wz4m9ED1tYBcjlp26aBMNnPAsa3lM0j18mft6ifxsimzIkhWwuzx/eCBroeCZn14kwIwhodVHle+rVk9WF4nuj0w+CWxl+VS8aYkVz3TFh7pioyPG6QaLmU4Jn16JTvoyslolYJaxnJsTBKREc9md36eZVPOUOZ4SOOZYiW9hOTaomolpdsYAtIIH81F9v9cISq15jfaxHUHNDgXwd435wJE8V1UAc79N9vMNm2mHcTgas91TR/eYU+vcCqVVnekzZPWLAov5hLCtJiid5qMXqjyvU7iqikcSaK2rfQ/LCHfnksPdm37jN4LEYeb6Spfz3F+uIFynEI3r/DeDfHeFeR60P1RSgGpZfHqILP4v0DplseYQGcBZSOA/yvJPzE2ugwe9Ai9iUJzJ3E5mZNBkO4u8P0oMzgnvR6c31N9cUC98tjoT96HvqNfSb7RQknX2oq34wEhBdFqEd3ufqtGuMDcCaK5pcSo7ge2r7o+rjDUFynF+l1UK8yedzh6n2HsJJGMH4ZUfqTF8ata90/YL5bYVm1JYzmeAzXfZTnEe61uPhRgahAGpoC9a9Dip+frUJjtrrErQqx72IFsUhQx1NzbQX7LZYtj0XNltD3kwB7EeO+vDQVffzGroQF5ZSc4NI4RKteI96oG9pnWLLIX4fkXkmGbjKRosTptqUYSbRUxJOpKGaqJeJW2QxmM7NcPBiYSh/PNYx77TqCUrAscbSDhJ8XvZURLVNKpbJqOk35OaWknXQzJtyqE5YcgSRm0ZPPr1aE3YzB06oT1Xw5oZ1cyqk0jIwJcFl3iHKK8vES98vjW4awdeOWyQmHlYu6WZPFNMVD6MUy9eqsQJRGc5/lfmQ+oZQbZpAz6fzQQN8y/k8Ghkxzg29lAWcqoPQkpvI5aTtnUZRptsh6fgBwe/Ffm5V+bzaAn3p/+xbPx0ikMjVQzpNjayoFtXzf9Oh1GK0m/xkDPQhX4TGWksERkAzH6DAQQ0ihIG0d24LBSCqHgm+C47Uv3B5rHkqrAG7z/mHlRM5UQBlAquiTVHziokvkO3JzDxYSMTcVhK0qFkjKPsu2VDlef1W52dUKyb1trt8vM+9IxV0419S/HGEdX4kKqdNi8IM2i7oi3185MPViAXd3uP5hjf5jiFsBzoVH91cJlf/7KXFvYBg8kwNZXK1IU/tyhHp5gioWGf9oh8sPbIJmQvHQpvVpiP/rQ8E8txoE9zYYPPBZ1kVGWvt2jvPNiRxxH+wzeLPCoi598MbXc9zn5+gwRJVLBHsNphs5plsWYQFqTxNqn8mGlMzn2M0GeqfL9KBE7Fnkb0LyX55Ij9xxiN+9T++tAvOOwp1A7duQ4pMr4pMzyUo+aBEWHOwgMWoZtMbqtpk9bHPzlsf4YYQ1s9j+VwnlX8ig3G61SPY6RJUccc4WR+yZpEop3zfS1mVNhuG5AdSfBPgfivvaKpWwSkXpJadIARVGMF+An2e512DW9Zi3LRIbcsM0/OTwekX0zLTqfqoimS6EfBlGWN020zfajPccrEDmRf556ja+uJIQ9EzOmbUuMoJt6h2Iqj72LIBYS9tyPJG5QbEgTveij9UX/fyt2MxWmSRnE7sW7ijAuRhI9Gp6esZS0kvPFHdgaLradWQeMQ/RtpIT2HRmcCaZKs8k7PVHMrNIW2c068zv1FnUZbMsv5jiHF2tTvNpf9y0V1IcvPI8MzDWvrdSQA2n6MnMABjNY827cytcql5J53wxaibrjF4sjRjE6PbB5P9mX1M5T9ajrC29XJrTRfYwuQ6ZaCXD06SoeZ2SCNY3kgxF/0/6/8P//zeA9TwAE5TguLdJeVnwC5ipe3ZMWo+GvBUSA6sB0XxueEFZXxFYRbZlnO1y6jDM9MDrvoCM0zGZ3RoMr/c5406VxHNIcjbe1ZTET4dK8wCGY0HK5nOGxQLcavPYjRrB2/sM7uekv6/Bv9C0f9EXjf9sjtrqsjhosGhm7ZaA3NNLgb5tdBj8ZJv+A4tFJ8FeKhqfQfMXl8TfPsfutAke7zBvewRFJbF9hwvcV9fgOiz3G5z9NM+ymWBFiu4vhdceP3+Fc7DL6P0u8+ZqASudSvi4ns5QBZ/po460gRQUL2Iqn16THB4bM9tkwyH2FWj5funFZOVibrWgXSfolojyNu4swj0ZiDrE80jubtF7p8I0HXhXn8dUvupDOtyNH+0zulNAWwhe4qPnAozrtAgPOvQe+cw70mbJX2u6fy6EVCufI37vAbOtPM4sIddfyqJ6eS1V3d4Wvffr9N5S2AsxrDU/TxVWF1fSZqnX0KXUKDSaGKOQKhWYPWwzuOexbEBQ1RSPFY0nIYVvrlYB5pUKtOsmhjBboLLKN7jfZXgnz7Ku8Abiu/CfXRtFkWHaeO6KN5MirmnWCHak+nana1V3Rs0sl1CVstH/Z71rmnVwbOKiR+I7qCAx2QFxr2+UcHarufIKZBA1P4cu+cS+y6KTIzcIsScB9nkfPZ3Kv5EqmUzoehAaV62qVohbFYJ6nmXDxQ4S8lcB7vNz4/i1um3TwjHcf53IJljwUZUySaVgfDZWEGFfj9DD0S35plEbpvkiyvVk0N2ok5QlKMgeL2XxXyxXLaG1iMdMgJKZvJTnmrmH+Zn1qFhYRUqCtIuSRD67dXT0WhSkGWSnrCDl+/zj0//ue7IBOL9/C+G8PhF/PQjB2KmzhT+1Z6/jo81kvlw03BCrWkE3qiYCLhsWAXL8KhdMSLSeL8QhXCmjLTkWZuk+yWBojmTZEE3XK4SNgpwYsvCQrNL3PJJqyVjPrUUkiqCbkdGBW7tbzB60mGw7xJ7IDksnkQRxvDoXhclmnelegdAXMFv+LA3piCJUtcLszQ0G910zH2h9PMN9ckJ8fS0a/R/uMtpN2y0DAYjZ1yP0/8Pde8RImqXrec/5TXjv0ldm2a7qqu6ume6Znrkj3ksrkJR2grQWBYErEdpRhFbaSRsBIqENIQKEBEiCtKdAJ4nXcu4d02a6qk359C4iw5vfHS2+/5yIrJ47JEN32fsAACAASURBVCDdC6Fj0z09lRmVkRHHvN/7Pq/vMbvd5OJ7GeathOKRQ+1ZRPGnL4h7fby9Ha5+sM7gduqMuYK1n47SobKLrlcY36sxbUsxeu1FSOFXR3aYPfpom8GeR5KB4nFC9cUU78050emZLFztJuH9LcKSh4o0mUEgTKTRWE5/ezW6DzMs6prcpaL5ZCEhpjMB1s3vrTHayQh/56VsKDqKcNc7TB6tM9zxCCuKzEBTeRMJJjodDKvdLWY7FRLfITMKyTw/EypluczsnTWGexnCcpqCPtPUvxzJhjWdinTYqFmrIJe9JSJie4PFdpXRTobBbQirCZkrl8bThNoXV8RfPpcZweY60VpVsiLjBZxdEPcHckPd3WZ6u8G84UoxzCBNC399IA1xuayl3VorZ2rTVL6Hu7UhHnnjYT/tWqibQSnrfNYGE/V8jtNuoh0lYbiGDLX9UShcpNFE/PuIbKo815YZGea/9r2lfdR3hSV1MpJh9VV/Wc2aWjVRSkCKi8D2MASdEnFO5m2rTCZD4TV4CpLkmq3VrdWsxGPcedpVEohLbZzy84fX8TIrOHmnXkNXS4Jzd5XclOYL4QMFgZ0F6PQ1fhvqZmaJTqW8dEiZmWIYLYe6xpJeFoaRmsyslGWk7NWiGEsVTZKlkSQMvhs3gIrTTGcAbzH93/b/v2ULdfI5VD5no9vmBuDUquLbn82XTqBGzYaEvPOhtWKqYlFO/WEkBMHULWCus/aXaE5F6a69WgenfQ+d85dcEXPtNmURK0XRqj+y/aIqn4NmndHDJuMNaeQqnsTkTya454KJoF0n6JSYbGSkZ/ZYTvtJt4cqFolvrjO4W2TWkXL0zFDKtPWrAzlhbW8wftBg2pI3UPkgLRkZTaBcZL7X4PL9LLN10cI3/mi+bBm7uUP34w6ztiLJQPVlQvFojvfNkVArmzVmu2UW1fR7v5KUsh6NUdsbDB63GW+JzFM+0DQ+H6BeHxEPx3i720TtCgBxQYaQJBr/TOBq4Wad4V6OSTpgrbzWlA8WAgrrD3BbTYKbHcKqjzeNyRwNBD9RzBM9vMngVl6ssQsZKJf2p7hfvSEejpdac61i+3/9rw4s9vrsoxyT7QQnhOozRfkwovAsHQwjcDNdkaIfpz+2UojbbpLsdJitF5isu3bj8GZQex6Qf9ElOTi2p/p4XfpovbMB8eGJ2HZTSup4y5PbShq4q7yc4b8+k37hSgXqFQG+hZHtxzWzL+PKAVBRYtlAOgqX3n8TYPRc23vNWosk7xNWs6hES3I9jIjPL5YolfTzpcrFZWLYcdBZn6Qq1lTtOjhhjNsdWfuqwW/ruvzObRPeyiOp5El8F3caoKLE2lfN6de6/BItIazUrePUqlAtQcYnLmVxB+nA17h5fg2BE95yNxXzaWAsI69ZfyK9EMNxOldM/66et9T8YWUw7NqKWev6gWWC237BijSUzS6ZY6lsZKourz1WGsJWu8d1GH3HXEDpor5a6QhcW/xts1e6CxpvLoDbqF8jIerZTL623SCpiGPAO7ki6V3Ji21KYrRopcl8YU9VJpptwjGAvAEzvu0L1vmsXAuTZPkhMm1guYxAxoJQZKaVN5KqVgi3m0y2ckzb0qeaHWrB5571IdEkjTJhI09Q8VAxZLsL/MPuEtz27i79u3mCipAjKwcRhedX6MMTVKFA8GiH0U6WoCwlHvleQunFEGc0s8Uow12PoCoLVP2bkOLnJ0RHJ3i728xut7h6J0tUFJtn/bMryQ8ANGoEm1WCtFw8czSwHbrOWpvB99fp3xW9NtvTNJ4su16dYp7w0U3mHYHC5c/m0sc6W0A2Q9QqM7hbZLLlQCI3lcaTqc0eOLUq8UaDRTNnaZjJqwPR3m+sc/HDGlcPNNrT1J84tH8+RH2zLzJdWvyis5llV2zvCtOzcPzXGsx+OCFJHJyDHBt/EFP8piuF9uZQkDa9qTgRGWU8tjOL4b0K87qS9PaZJjNOpADl9SXRwbHIE6USamdDNOVFIBtC2r9r8NiztiLxoPZCUBXO8wPpCM5l5YSey1pkeTIYiVad+v7jgi8D71m4BAmmC51TLQvqYTJdOmX8jMw9ylnceUSSdXHHgcVLWDeQmSuYkpyMLwtx1rcbeZJ1ye73lpvSeCILd2rIMMlgpzdKGVhSpp6Uc6hYC3IljNCT6RI/nQY9VSFvqxWNFdNd76BLBVt044zmYtKYzWyCWvm+MP/Hk2+tKcallNTLxGkftDsNcHojkt6V1eYtUjp1FK3aMq2DJ+MvZRyzyawGt1K8w+q8wITJVk/5VjIy/v+0B8SsLWbxN4rIP+v9D9+dDUB5/vUegLdO/U6hIKfmOLHFCnbIa8IcqY4GWCeP9j2c0cRSQg21MxmO7GZjdcP0DWPcRvaXbIqzk0Si7rO5tXjZlHEKdUMpnIu+ZZmogryJDQN+1s4wrwkGOtdLKO/PJcGZzxDW80RFl0XFlVL3Vxf2hOltrDF9tMn5hxniLBROtLhyPj8kvuzhthrM393i8v0sUR78MbR/OSVz0AXXZXGjQe9+lrCi8KaQGchQWX31WtLIqQzVezcjkse5Fob/m1PrYZ+tZwXzPEsofHVGdHAsC8TeNsN360IbdaDyJqb0zUA4OQCdJkneZ94pEOcdct1AcAdxTFItMNsoMtz1iIqSO6i+Cim8Hkq5SZwQv3+boCYf0kwvwN+/IDo5wykWmP0797m65zP6/hwGPsUDl/V/LdkD4hhnvUO4ViXJuWTOJ6jewLZOxY9ucf6DIoP7ESpWlF65rP/xVAbaabeAMGa0PVSYykB3e4P5rRaDm9J5oD3ZLIvHAdk3XWHVT6cWRLZqKbTwMzNXqTtoD5xAqjOt1z3NdJgBqZotZDahtQTG3tkkyrssaq5Yit+Mlt7/bFZO6wZzvnLSdNY7JOU8k5sicWYGEZnuTBAR55fymSgUcNJeAZJEXgOtSYp5cBVxKUtQ83EWiciRvYHMBhaL67kDMwyeTOUznaIxjCsudzaTMpnZXCSs1IrpFAoS2gtCGfCaQ9tGm7BRIKzKc2cvpqjTrtXPLb/HdGvPF3bxN0NymjVJjs+F/Q+CeUgGw2soGmDpOjSW82xGfg5HLWsik8S6/+zDOBlhucCn3CGjWHwr6Wv+PWWN2eRwuolYXlH6798NCejtDcA8VgphzAJtuNzf4gWZ3TlNyJkiFxzHDoiU74krIIosW8jeKFaw0eaE4Rg4lu9dmwHY0peVq5qRi4hiG1k38C3tu8zbGdy5RkUJ3iyWJONYIuZxXQpIwpILCsrPRzhXI6kbTG2g/fcaTNccFnXIXUL7lxORW6Yz2N1icrvCaMeDBAqXCZWvB6ijc1S5xNUPNxjccohKIvO0fhWS3x+QPHtti12mWwXGGy5hSVE6Tqi8TPtcsxnBMG9mJHh1Iotb9ObQIqSnWzkBw+UVuW5C/ZeXEr/PZwl26gQVOdXkLgNx1YwmqEKOcLPBdDPHvCE0UGcBrSczscD2rnDKJcL7O/Tv5tEuksj98kT88dUK8w9v0Xs3y+BRyM7/oYgzDtVPL0jeHOIUCiS3NonKWVSUiPtj/1wQEJUS4aObnH9YYLYhn4vCsWLtpyOcJy/lF3pzh8V6ESfWZI6HNslr3FnjvSLjTZewCNoV4F3rM0k6x93eMldiFosoWqbVc1m4u8tsu8S07YnMsx+Qe9WV2YTWEizqNJad0eOplNZ4Hnq9zeh+lWnLISwrsldaZKrPDmzozW02pNIU0OlBBM+znQiLmgzq3VliJUGr7xvjRGqk0NOpzMOKBcLtJkHFJ847aIUgSV52bSm8UyiI1bResbo7IC1h5SzjnRxBRRGUFeWDhOrXQysLriaN8eTUbSQgM5Rd3JBC+STrSNDvsCuwPceRgXd60raHO9P0VcyjymUBBbYKaFfhTULcy5EQRweja1mjVTOJxTWbgTXIz2VgeSsU0dVD6bdqHU2DYPq7MBKQeW8YWdjYQc2mJ78UA43LYfqGle99dzaAH2X+hsguK84eYOnu4boH1u6eIJ7+FONr5CGLhl757/CWRcyEMOBb1zVpFstf7wVwHekgTVu+lMHGrrguzG0kurfF4JbpaA3xBwvLoFeLUE5VaZJ4upmTXoBhgHdwQXR2IZV797ZEqtnzWFRl+Nr+bIr3tejV4d1NRrs5FjVHnqebUPpmID77ZoXBOxW67yuCZozfc9n63dBaFt1mg+juNlf3CyQZyIw02UEaSpuHxPUC4xsFFhVx7NS/XkLj3GrFOm6C9DaR74kERW8AjSrTO3XG6x6Fy5jc+QLv5YmA7Mploq0Gw1sFGygrdGOKr8eowzMZOq+1CW+tM29lCEoOlZczvK/2LbBu+OEmwx2XqCgSU/PLOVopKYafL4hvbxDnPCl92b+QE22KxRg93qD70GO2lpDtOjS+kt4CdXgiC+RWh7CRJ84411hLznqHyYM2g5s+UQFxMR0nOJHYEt2Xx0vw2npnmRhfLZSp1WCjzfRmlUVFNtv6lzMyr87tbcaUrqgoFjNCGvhSay2md1v07/poF+Is1J4JGkMdnVn0sVspyXvaUdeAhfHNdYJqhqjo4gQabxaTe3lp7aMWge26ViaSD5cm2V1jtl4gKDtk+zGZYShJ6On8Wy4kk4nR40k6e6syudtguOsRZ8GbakonMaXnA/SrA3lu81mEXy/rNqqErQKLmo83icmdjOHskmQ0XraAmUT/eHL9M25kuzS4FpXl8545E5NGkpbLq4xvF1vrLEy/3pJEg0hyP6m117gArbTDchBsHYtm4Tb1tKuPt7qCcV1Z4B117SZhcRDGJrpYVuX+8+E//rPfAJRSNeAfAY8ADfwnwNfA/wbsAa+B/0hrfaWUUsDfB/4mMAX+Y631L3/T9684Tf3jwr8PXGcA2eL3VScQfCssZhgnbqUkp4aVcmebHF7hcDvF/HLhT3duuzOrdLibTu6BZSI4m7Vxb1xXnAnpG075smGYE5ZxtOROJ6JtztKmorR9KKxmcacR2lXWYaGnM9vcZBeJguCQS4dze3qOb2/Qv1dk2lGCUv5qKsPTMEJXigwf1Li6K9TLJCNDxMYfHhEdHFvw2mBXrt+ZoRbJ4kI+8It2gdFOBu3Jb7p0ElH88oLo1Ru8zQ2mjzaZbPhEOXBiKB9E5A5HYl0s5JjeqBBUXBY1AcrlX3ZJTs9xmg2CW22ma1mmLckHlA9DcmdTeHEgpTGtBkmnLpydFAmg3xwJfuLOHoPHbfq3HRZNsbdWn0HrZz2Sb15Jvebumg03uReDpXS2u830nQ7HP/EItkLUzKX+uUPnjweoowtbAxkX5ZDgX0yW6eu9HXo/WufsxxrtawpvPOrfpAvv6cWyocnIkAYtkP4+k/HYQt9mt5vMWhKEqryakTnoSlVjCjhTlbJ8bX9oi1GM7Ne/nWFRh6ioqX/FEp9tvn+peD0JjwxHk2qJqJknLHnEWYfsVUjm4IrkzdH103G1Ij9Hki5o+Zy9mU7XfIKKonQcS7Pc8wObuzHZBVXIW6S6DgJ0u8Fsp8zohsd4GzIjRfVlTOFkgfvpMyuNuesd+5x6NhNNHJFNk70NglqWoOaR64a2F9kiIjxPbjlJsrR2mnlHo2bnDtpzCOo5/GGAMw2t+y8xDX1vgSdtN3ClRFKTEKc7DuTGPp0vcz/pze7tprC3C99NONUiHoxsFATLDcLMI1cSwXbhtwuxY5PO8jUZ/tnFP/xz2QD+R+D3tdb/SCmVAQrAfwn0tNb/jVLq7wF1rfV/oZT6m8DfQTaAj4G/r7X++Dd9f7MBGO3vbRTEtzDQcO2FMRvC6i9x1SFk+wUyGdEUs779gMoNIc0VeJ4NYZjrrx04m0FMvNyJCVNnRC4L+RxRS3AR7kRSp8lwZK2kcUOCaM5ovuSKg2wmqSMn3KqhgsQWbedP5ni9CfQGVjIZ3cyzqCj8KUtGvuexeP8Gs5bP6IYUxrS+iKTE+/UJyWiMu95h9HiD3gMZKucvNJXXCzLn8iEIGwUu3y+wqEvgrHAZU/qqR/zsFW61wvi370pytqQpHSipadzvCx3VUcS7awSNHFHBITOILOPeqZaZP96jf0fKcNyFpv6VLH7x6bk4YvZ2mN5ry0zkMsDrz9CvDlAZn/jeDbrvleh+HEGkqH7lyXMfDKB7BbUK07stwrJrHUq2R/bWDc7/0jrdD+WD6fdc6l9B9dlU4HCtCpPdEmFekb+MKHx1JsA4R6Ee3Ob4L9WYfDSjXJrR75Zo/55P62c9a+F0yiWxMxpbcjp8NLWEBsEc1vPMOiKhZXsh2Wen1o7oNGqiI3seejSSYW+xALtbXH1QY950CNO5SPkwheG93JeQ1OYaSU3eV2oWoE+EveM26sSbTeadAkkmNQHsD6RyM+0dMFKNKhUs354wQNVrJMU8YavAvOUTlBz8qab65Aq9f0wyHi9vCyvsLpXNipMmnyFs5BlvZljUhHNVfy7zHAn6zW2/r85nLfRQLwJ7647X60I4NZ0HJ0O5SV10BXTXati5jLkl2cxDxhdrZVZCnCqMLYxRTWZ2/mKbtd5i8qhiEdp1W52pHYU7vQ79M/Tgt22bppTKJoLTAbEtgk9DrqarxKgSVuEwNbUpSmLV9aPy+SVRNB0Mq1z2zz4HoJSqAJ8Bt/TKN1FKfQ38Ra31iVJqA/hXWut3lFL/MP33//XtP/enPUfVbekfqr/6bzz5f+vvZqSdFKcKLPX8dHiSzObLW0BK+NRRZJENdvKuDacjtD5qo9mt+nedcmk5API8dK2MVsoOh/VwJFfTckmwtlXRDK27oD+wcXHl++h6hWCtxGgnK6jkbkjmcoqazMUbnKYwp5t5Yl+6g0tPz+VUXa8xebxF94FPnBWJqPompPjpEfFlF6dSsbeFoKJY1GRw3Pp0KG1LGZ9grcRgL8u8KXJM+zPh/8QXXby1NvN3txjtZJhsSuq2/k1I4ctT9HAsQ+9mhaiUQfuO2FP7A5LxGG97i8XtDqMbWeIMuAuovJpZOqTKZHBaDYIbDcKCJ3z8wQx9fIbKZgjv73D1IE/vcYL2Eypf+nR+OcP//LV8AIsFgr0WUc6Vrz3pEZ9fWlDe4G6R4Z6E4XIXDs2nMeXPz0V+K+RYbFeZtXwyYxmc6mevcAoFhn/5HoPbLovvj1EKgqsc9U9d1n9fFn5D2owbJZx5JMGpycQOH6mWiNaqBDX/Wt9z8c0YZzgVBpHryok5PWQkw5Etq5/fbHL5fpbphhZ57EjR+nxK5tW5pZ3GN9dJsi7OIsYdLeDolHgwxLuxTbDTZN7JEvsKN9QyiD/rEnd71oW0ijiwn49CHr3VkTL6tvQa5M8WshmnC7+9aRQLdnCaDEc4jRrT+2skvsOs5eJPNf4olt/LN/siT6V5D9uwN5kv5bWUVRQ1S8SFVLrrTVEpuDGZzWUukc8L0whQowlx72qZnt7syOfXd6XpazRNF994iW0x7ps0xHXN9Wc6uDM+pERUFUSyQa3085o2QJNJMCf61cEwcWzrZVd7yQ1N2B4gVxWGdMOwRpYV2J7K5WzjoMFG4GdkA9j/7/6tNgDv3/QHfsPjFnAB/GOl1AfAL4D/HFgzi3q6CXTSP78FHKx8/WH6365tAEqpvw38bYAcBXBW/P6O+vWLf+pDtok4sFdGC1YykLdgLsO0lSsXkA6Hlt0AeiF1kZbWZ8IcnpS5J6vgpvSaLk+sxf9vThnnXZJUrzXo2ricXXLUhyNxI9Wq4iH3XYJaDidMUuyvJn8ekLmYWOZM0qkT1XJopSi9GEpPbH+ArlWZ/uVHTDZcxtuycHc+CSl+cUp0cIxuNgj+wiOu7mWtTu6PNe1fTGVoVi0RbtWYrmWJffAWmrVfCEAtOj6BWg394/c4/l6BoCJEz/YnIfnjsXT4AvHdbWs59E8HJAfHREGA22yQfPAB3d0cUUFRuIgpHKS5hrQgxdnbISlliVwH/3KKf96TRVQp27E77TjEeSi+dln7eUjmi9f2hGrsju40JP9U6it1tQLv36V3v8xkKz01z2Dz9zTVT45l4a1VCG+0CFItufbJBcmrAzSgHt7h5Ldq9N+PUIU57n6R1i80tS/k5KuTBPfuTYLNCt4oEInpoksSx7jrHaLtJtP1LGHRwZtryRZMEvxxTO5sitMdikRSq9hWqWQ4kmDT5jqj99e4esdj0dBoNPlTxdqfTPGfHRNfdNGNGvreDeZtKY33xxHewSXRiaSg3dt7DB53mFfl+UtHAdkX50RH8rEzCGhzmEnmC1TkWet02CnjBDFaQeFwitsdkZxfEk+nS33fzL96V7LhlYoibaVNX1ohSJCLEVwNibs94nT2oepVsc9GMeyfCtStVoXdDaZrBeKcgztPyF7OBG3duyJOm8qcYsEGx9RoQjIcEc/mshk36iRNQWs7iwg1XcDVEL0ylFXZbCrVBMvBru/htpsyOyjmSTKe1LWS3tJ7fZHwwkhuO8lK/SOgCgWcFUiekYHsbc5sGo5K2T7B0lFoboxhZOVjshnJOABM51ZtcEpFdJLIpmDWR7OBvI2l+Q2P/zc3gI+AnwI/0Vr/sVLq7wND4O9orWsrf+5Ka11XSv0T4L/WWv9B+t//T+Dvaq1/8ac9xyoMzizy1zy7aTzbJH6NLcte3VZyAddgS+nEXKya4TUNTmUz6EVg4+PyQyw3GNvIk95GTAhFF/Ny0k+94MwXtiTCqVWlOi51bRjIlVutoHc3bNsTsSbJygfGDeW53XEgCWHPIS5lWdQz+OOIzOGVFHzM5ngba4y/t83pxy7eLNX/v16Q/fpYuCiba0zfaTHY9Qkr4A+lFKb4TVdCMa06g4d1FhWFikXfN+RLHYW4zQbBe7u2sUtpaH0m8Dc1mpJUS8x2yySeItsP8Z/si+PF822hzXg7Q+JBvpdQ/rovm1n6midN8YubE5pNpaaSxeCdMtO2SA75bkLp5Ug0ekCVi8T1IknGwxvO4fhchsLbW/R/vE33oUNUTMhcORTONdWXAdmDvvzczZp0+4IUm5tCmGaD+eM9Lr6XZfJojpeNSA6KtD7VNP/oRKB/1RJJtcCilZdU6vnI5gLUg9sM71UY3nBkkN6H4nksad3exJYOGSebdpTIMJc9Oyy++tEWg9sOcU7jjxT1bwRoFx/Kwu3ubFr7LUDhaC6dzb2+yFA7mwQ7dSbrGRJfUTiPxBb5zf4Sv10py802RUsoXxb+eKvFopkjKro2r5D0+lb+dEpFe3I2RgiTpYg26sR5j2knQ3YQ485jea8en1m2EElipVXADnfdTpvpu+ssah6TdYfclabyZo7/1ZHNLUBq+04LXsxmCdjOhKQjUpFxeNkTdRBYdDJw7TNucwW1CrqQI6znSbKubOr9qWwexnJayC8PpGbWlxNrrS4X5PcaRtfw0cCSHJrWO1qZ2UjJqa3Ttrml5FAy/rJbwXNtpwlxvGyGS/9pZKA/8xyAUmod+KnWei/9338B+HvAHf4/koC+1QcASwvoKsI1Hah8qzM43S0tm8NUsqXXLlv5tlIen8xS/o/p/sxkrjE4rB1spd7tGv2TlTlBqShzBbgeTW82SPY2mK0XhD9zvhAtUSmiWh6tQMXaQrK07xIVfdE9jwckbw7l+9zeY/i4w2jLJclIOKrzRz04OhWy5O110e8bkO1B+SiicDgRb3WSkJSL9N+rMV138Eea2vMF2f0e0as3EkzaXLPYgkVdkT9PhKVzMgKliIsZJimuODtIKByM0E9fyOnpnV2Gt0vo9FdXOA9tNzGuC9UySTlHkvNxB3PUWVdshZkMbLTRvstsu0RQctEOlF/P8M8G6KsBqlQkuNVeyjzpqTSZzXEf3OHyBw0GdyGsyIe78blD65MRzuv0rdaoETeKNtlp+m/dZoPh79zh+C/C7v1TAA4/2WTjD2PKn57I+yWtIiTWOEEsJTznFzj5PPrBTc5/UKH/boLOaLJnHs0ngq82tYT4GQk6pdz7a5mAu3v032swvOkQ1DTeSLH2C5HWooNj3EaNZHed3nsVEleYSYXDMer1EclkhruzyWK3wXA3y+iGSHOlo4TK8xHOi8NlH26xgHIda35wWw1buZn44M01xbOY4vMh6qJHfH4hbJ9OW97f48myfMT3UDd3mG2XGW/6ZIfJsqCoN7ZWSgNQM7fu1RYvVSkTbtQYb+csebZwEVH41ZHNHhhH0DUcgvk8lkvQqhMXMwT1rNwWUraQQXCseuWTlcSugd3FTaGgmoc7jyS9PxzJGrLa9Je6+8yGpnI59FoTzK1/Ecj8DpalMakcaP7Obxe9m81A/lKpdJSmfE1OxPYDp2wk0128SgQ1a9+fSxBMKfX7wH+qtf5aKfVfASkxje7KELihtf67Sql/D/jPWA6B/4HW+oe/6fv/qYUwwCrywfj3Aev1Nyne1a5Mo22uMoTs461qSdvJ+ZZvdxUsByzzBauFz8pBVUryi01xuzqKxKGw2WGxLtxzbxyKpjmaEm43SbKu5AFGC1SUWEwEWqNGU+LTc3nDb28wu9VgsOcRFYRl03wywfnVC0ncfm+N/l2XRU2T6ylanwUUvjgWrXhzjemtOvOG8Hn8qbB/1Df74ozZ2iC41Wa8mSXKCVzNDaQExbscoXMZhu/WibKKWcuh+mbZNKYyPsnDW1x+r0RUUPjDZbm5Dfs0qoTtkhSXDGfowxOhVRYKqK11Zrca8vPG8r7M7ffltBzJEM10+HqTmPyXJ8SXXTkZvXOL85/UGd6GqBSTvfCoPk8Dbd/sy+9vc002nawnUDeDX9jboffxOhcfQuXeFQDjpw3qT6D1hyewCAjurMlM4mqBd3JFdHAsJ857Nxk8rNO/4zC9FeCXAtSzIuXX0P7FAF4cyIk3nQOQzcgtsNeXk3g+j7q5w+UPGravOXPl0PoipvKzI6LDI9xmg/D+DrP1LCqB4v4E9+hSbMGVEvG9G/QeMLeFyQAAIABJREFUlhjegrCicWeK4rGy9Zg2uVssiHSQJuFVrUK4WefkJwVmbcmC+GNY+5MJ3vPjJQI7nW8pzyW+FEaVt9Ym3Fvj4ntFEh+R5Y61GBBeyTDbeNydkiwLhitkCpaS3XXmnQKztix85YMF7iTEO7iQQF5GylnM4S5O0dJOPiefg2qFuF1lvpYn8cQo4B9foa/6y5v9yrxuVR0wMLy4VSaoyq3a4N2d4dSC5Axt09rIU1u34froYn6J11jEOFfSsLZaHpWMxtf6SmyAC64hplfXEOt6KpeuL/xRLDeRleYwC4Qz2PxCnn96+A/+XDaAx4gNNAO8BP4WQrb/34EbwD7wH2qte6kN9L8H/jpiA/1bWuuf/6bv/5s2AOX5Fn36tt/fXK/sCcVcNQ1KYmWRN/YwG7v+NSXM17jdb3O80xmD9f2mWQEyvuWJrzoItFJSLN5Pr67NGouNMmHJFTLiJMS9GCwHU7P5spN1c41hqudqD/yxpvb1GOfNGcpzmX6ww+kPfZENxorym4TGzy/h7ALVqDP43hqTdWm2Kp1GZLsL3K8PrO4avrvN8EaOoKwonsV404T8wQin2wfPI9htMd3MMWso/AnUnsmmo6MIdfcmw3drzBqKOKsoH8WUXos1UOXz9lquNHiXY+heidySNmrNtsuEZdO6FeKfDNFHpzZopIt5wkZBaKqXU3i+Lyf+dlM4PR/mCCsChSsfxpSfdKUjF6FDhus1mbsMp/bU7TYbhA9vcPpxnvGDBY6X4L3O0fxCU/tVTwZ91RKLDZG3ckdj67Thg3tcPShz+T1N4eaQ8VUB79Kn+Zmm/sUAXh5K2rjdJFqrSb/t1UT89cbquLnG+L0Nxlsu03VFlNdUX0DjiynuZ8/EwXJzh7hWIKxkpLf4oieD+NQGevl+hrCsiXPgD9Ry4P/LA0mvxjFuo77kU6U3qPBGi8GtPKNdyWu4ARRPY6o/OybaP1xaMU2IMQUdqmKR8N1txltZRjcc3Jm8DxtfzSx+Q8fxcjibnlwtN8t1oFZh+LjDZN0l8eWWUn4xsshzC05r1Kx91IbRGjX0epukILZrnXGkGP5iiFoI1M0spsZHv8oPMylmY1JwAnHeqVgLkn00sbZTk99ZxUGLI6lgMwBECUrrJS115WEDW2knsekDWOaQvGtSGI4S0CEs6cRpV4lxktnZxYpcpDxPPidmg8n4/NOX/+13Iwj2sfvvLq2cK35/+zC4Vvj2RrFaHflWgMzkCmzY5G0vbVoXB1yzkb5NHxWnkP7WTcPs8E6rQVIrkWQ9qyWSLvzRWpXpehZ/kpDpzfEuhtddSOngKNqoE9SzjG74LKppUvJJH94coXI5kt01uu+VmWwq8pea5hczvK8PZJbxYI/JToH+XRcngPZnC7KfvSYZiEsj2W4zul1mvOUQlKG8n7LoD7qCck5RFZPdEk6k8QehWDXTNHLy/h3OflgiLJFKDjGVr/pwdmndTFFVytX9q5lo9Glfa/joJsObeRJPBs61JwPUaRc9GqPjmMF/8D3Kr2a2McuGpwBvrc30/W2u3slI9eV5Qun1RIBf511ZaBo14pqAyEzwC6SUZXp/jcFNn3lLERU0xWNF7VlA4RuZLcSNElElixMkUrmZcvn54B6nv1Vh+E5MtjMljhz8z4vkepq1f3VhufBJs0JczECi8S5Su+JK4fyinWO84RHnFN5EU7iIKf3qxNpN3fWOYB6UkuL0tIbR2EB7DxXxzpxk4lN67tF8It0HydmFpF9TPdpiDS6vRE6olJi8u85w10N7aonWSH8vTi4rOIh08OgMxiS9K5xKmekHO5x96BOWNe5C0XySUP2iR/LstcyKqhVxsaWcezPcN90BUbtCVPSYbAgiwzS4mcCbndsVCvbjbaQTd71DtCWodp0e0rzuWLT5yRKsZnhdyXhiUQ/2sJjLWfnN3q5BXEfpLd0u9qve/2Je9PiUaorvSeF9iue2bq8VCqhJdhtKAZ5ny6mM7OOUissTv3HxGKjkygDZrkm53NKtaMpqlJLXK8VP6FDWrD+XHMCf9cMkgVcXXsegYg3FD67LN6YzAK5tDE4ua6Ubm8w1id90mAMs28XAnuhJkmXnJ9gbw7Vghzmxm93evGFSJLAepmXu5ZLU1tXzoCBzPoHznlTGpU1AAGR8klqJyc0yi7KLE2sKZ9InS38otr9mmdGtkhSYTxIKL6/En99sMP/gBmc/kBO3iqH2Iqb8+y/Fann/FvONEr13fJJMiiw40zR/NRLdFog6FRb1LN4slr/nwdVSMtndZvD9da7uudZOWf8mpvxchrOqkCNaqxHUszbwxvmlQN9KRaL7N5js5AmKiuwoka97LcEup1yCZl1AYPPIXqmT0Ri307bVmXFOMW25lI4iCvvCBsIYArIZ21alp3P0dIrTajC722FwWxafsAT+ROyvtkwnpaAuGj7uIqH4ejnTsGygdyNwNYSK5icuzc+k/tJUEkZrtZR8qcgcXS1nE40awXu7HP9keVOpfx1RetZHH8h8walV0ZstglaB7JsedPvE/T5OqUTyYI+rd0uMtxXztZjshUv1hSC03RcnJMOhSCPlsu2e8IZz6SeezVD5PNFWg/GNAkFRCWLi+bnt53VrNQtHdIYzKV/pD3A7LYYf79C/5TJ+N0CNXSrPXTZ+9wqevVkuQPWKgPT64r+PB0Nb2hK2S0RFj6DqCejvMsAbLFBHF0s5A5bWavM5S7Et4d4ai2Y2ZWSFguBIS+HN584upiAmgnRu4Dbqy/YzR6EWstDqtBTHzOuA5TqTLqy2RCeXReeyxFX5Pm5vLBWZg+FyvTGY+lUUjbGApnL0tZuAsYamNGEdS6eysg2Cc7thqELB1sI6o4l9T5uUsaUZmOSwUt8dGuiPMn/jeh8AXDvBX3usMnhMwm5lB2exkDfNypXpW7upOb0bOt9bziJg6fU3xD5zlVvx9EoQyLFhFtsIlRNiqDOYCLVxNF7G0nMZOZnMQ7FDlrMEVQ8n0CLFjCboXJZwvcy8KRjoTD+yBSDK84i+d5fuozz9hwmFI5fN353gn/alpq7doP+9NpcfiEbszoU2WtqXRcRUAo5vFPCmyTUpJplO8ba3mL2zxtkPs8zWYzJXLrVvEho/u4BeXySGdHOLsw75V1fL1q16jXCvYy2R2WEsgbQ3Z7J4VSrQqBLXC8Q5D/9yKj0JT1/IG/zuLlcPK0R5ReOJbMbG9YNOhOfSrKTW257kKnJZ1M4G43s1BrseQQ3CckL+3KH6Mqb81QB10UM5DvFmk9lGkaAi1ZnuFy9Fo3/4Dqe/3WDy22OK+YD+SYXa5x6dn4/wjrqyqVfKRJ0KiecsC92N/NJpM3l/g/5tXzYPIHvusvW7wfImlvJswg2RPPzTPvHxKU4+R/Rgj8HdAv13ZKP2B4r6s5jK0yv060N5rxeL1pWkogTnciCn4vQ0HrUrjPeKTNYdSsfytZx3iXt96S6olpZa9GC0PA0/usPFRxV6H0Z4fY/SvmLtp8Nl70G1Aptrsoj1h7ZjV2UyuFsbhBs1ZmtZnECTu5wLe2nltXkb15D0B2kvgMDewu0m4xvCe8oMxWSgJnPilzLTcYqFJdlzNrsmBTvVMjTr8nkz7P7Zwh4mVjHW1xZ+x7VZH6dSFik340uPQJRIW9qvuS1cK2VJW7xUxpeD6nxuZSkb3DKtYUYyNlRPRDoy39/ePtI097WksRkC2zVvaQX9ztwAbCm8WdxXQHBm0f5WIYwpf8nn7AtsU3dpYbbhnYseez0TYHgjbxc6XAt9rMwMnDQDsBrwuPZ86XVc+66lOeowSj9AHSkmTzQq0bKAKSWdsWGMMw0k+JXLMt+pMm/6UoV4MJCSkOEYt1JC725y9ajKrCM/R/VVROlfv5bh2a1NTv6dMtMNTdwKyL3OsvtPhqiv38jr1GowebfDpOMt6wSPetItkPFJ7uwwuFtivOOwaGiyl4rOJws5pV72YK3N7GadOKvIdgMyr84tsZJbN7j4uM68LRbT6itp+3JeHstgvN20SWkVxoLl7vakBa1Sgs01rh43CAsyW2g+neONApyDc3l9O02iegFnES0dPbM56vsPOP2tCvMmoGTAmetpclexPXWbRWbeyeIuNLnDEerwBB2ExB/cpfeoQPfDmNLamPFJaZk2ft0TPHExT1QviIYcxjgvj8WCurlBcLPD+Q8KjPYSqAWgwDvMsvn7ka2pdPI5WGujc74M/dNglVutEH5wi+6DHIN7KWriyKXxVUTpC+l7VsUierNFWM+njpWJbNSzOd7WBtOHG0QFh6AkvQvF89Q+m3KVTEcBWou/3rzmzQbRnU0mO3mGew5hSVN9DvUnQ/QnX8miu7OBzng43SF6NlvKcmlD2awtrCYn1GQmCcVXI9SbY5GY8nkpV6mVl+aGtFfAOM9mezW0o1jUpAsj24/IPT2yIDenmIeWyEFc9q4B49xOi6RVJS5lcRYRbne0rIFNk8Grn2PT9oXjyg2qVISq5BoACCPZOAxKw3jsV2Vf4wpcOd0rz10ygeLYdgLo2Xx5ck8RMoDwmfyMvRGZOaLyvPQQuiyRtzeItOPYkghAnmM6/e7cAOwGANc1frP4s9T1zbDHaolm11wdxKRJOT1f2O5PM8RdxcPa51txCynfW9rPVp0/6Z81O70pcJCy6FTjS9njyvdQm2voYo7IVNLNQtQ8tLcD7TkkvpsOpxKSjHctCZm8eCOng1s3mNxtEFQc8eAPxbrndPvgOIx+sM35910SD5xQUX2uaXwiFZJEkYDbbhWYrDtoBzb/IHVw9Pq42xtc/XCDyabDZEtqIOtPofpCenxxHOKNBsPbJeKMFHFnX14Qn57jNuoMfmuX8ZbLrK1RiaJwomn/coz7jQxRnU6LuFkmKmfInI3h+Mw6uZzdLYKduuQOGgp3Do0vQwovenKSihPiRkkKRhYRTn8s2jnij+99vE7vkZIB476i8jqi+KwniIg4kYKQFFHhhAnZw4FFWyy+f4uj38lQ/n4Xz405PanT+Vc+9acjnGlA2CgwvpGTgN5lgH/UX0pjWxv0f7zNye9oKIV4mZjoPE/9qbK5DD2b2cYtkkTAYynxkTs3uPioRv8+rL93xiLymP9ei7Wfzcl+JS4uU2ofVrM4UYJ/OZWNYzLF29lk8INNLt9zQWm8qaLxZUT5l8c2+OU2G0IT1Rp1JQu4DiO4ucPkdoX+7dQw4ULz6TJEqHxPdPiNOiqMcc8H0kHRqBHf2WK2lmOw5+HEoCJN4SIRPMWrA2H05PPWDEEU28SuaSFjc43JrZpNDGeGMfmXPej1JdtgNHOwTC4L06tWoNMiaorU5I9D3N5EFu63O3rBAtnMpmE9/GmZD4Cah8L3GY1sMGt1EGwbvFJ3j4HdGXmJxWJZAp8qA0ZNMAU9pidAT2f2FmAL5qNYlIm0X0E+GCuy81uy9+rGAvDPJ//Td2sDsLr+28PgleuXRTW8PZhdKVUw6d636yTf1v/kC1dmB2bnNzwPuDbVX50tABZKZZGuKQMm3moR1ETnz/QXuBeDtDksK+lezwEFTpCIP95kCmYL4vNLGXA92GO8V2TadnDnmkI3pvTFBfSHUKswftSm+67HvJ3gDx3W/yR1hQxHkqh93KB/x8GbgTeB2ouA/J+8kA/q7V0Gjxpc3XVwF+DNofY8FDnn8ASn1WBxq800ZdjkzxZkXpwSnV3gbazR+50bnP1Ik9ucsNgvUXnp0P7FBH//wlZBJvWK9Uwnz1/bRSC5s8PoVomgqAjLCm+mqbwKxAo6mqDLRRY7NeKcI2G452dCy8zn7OJpun1Lh5rGr4Y4++fLAE9a3KNLBbk9XPZEq67VmP7WHU4/9sh/cEU1P+fgrE7p53k2/nCI2xszvduysLvyYUzp6bmUxnge8a1NhreL9O85LG7PcbwE90WejT+KKD49JbnsiWUwlQBVlNgGOKdSJrjZofcwz3hboG5JPaTyaZatf9klef5a9OSdDcK2lM5kzicW86A8H/XOLa4+qDG447BoxpRfuILu+OKNlNKnFtuknEMtYgurM3Tasx+KDVRpKL+C1idDnJfHMtcoFaHTtOG15KJry24WH+zRu59l3gInFBto6TAgdzBAHxwvnSydpi100aPxNdtv2Ckz2cqxqMnnJnelqXwzRL05kc8NMrTXvoc+u5R53Gwuw+pmg3itRpL1iPIubpjgn44EkZ1WrsrCkFzrBr42FM5liddqxDkPrz+XmdN0Zusd7Q1hRWmwlssUdqd90e2lvnEqi7FZJ5RjNx9jSzVBOLNuONXKstfBVEyausg4sSRQEi1ZGX/l0BkES8toSkJW5fK/NQri//8bgPorosu97eZJef+2Ys2kf1N0tNnlTehlFQO9ulOu3iK+9f1XBrvmv8kfSpYcoLdCYjZVvHpCSPsDkkIOnZP/z+2NpSIxn5f0ZEGe3wkTubpeDNBpCYWxeolUs87gpo8Ta/mwfD3AORfv+uTxDsNdj+kmkh59FlH+433iyx7OrRsMHzXp3XcJy5rCiWLt51P81+ckV33U3jYXHzcZ7SkSX1N5IT5256JvaaSzBxvMmz7eIpGbxmgixS/FArPfvs/Zhz68N2I+zlB6kqXzyYLc0yOR17IZ4eTM5GRlrJhOqYS+d4PpdpHRlkeun5DrxXgzWeANU8b4vb2JJEuTN0e2E2F2oyqdx21xInV+uSD7+b4MvF1XTp5gh256sZBFqFSCW9uc/6jG6CbEW3OSuUflC5/mk4UQS8t5ZtslZk0Pb54uTq+PUPWaFN3flq7lKA9KQ+mNovXZlMyLU5LB0CZTk6wnDqXulcUVh49uikx0M8ZZOMS1iOZPPdq/GNgBqdrdYnajilaQPxjJ4p06uIIH2/RvZ+nfB70+xz3K0fpEU//pkQD3inn03hZxMSPW27MLuWU5CnX3JqP7VQZ7LuP7AbVPMzS/mJN5ciBupUYNOk3CRkFyKadd4osubrXC7Ie36d/JMNnSOBHkzxTtT6f4x1dEb2Qu4VZKqHraixyEFi/tNhvQrDO9U7dUW4DScURmGOKf9JfdBwUZwmrXkSTxdAqOi7e1QdypskjxF06YLPuir/p20VQ5uWUl/UEaeotxikXr38d1xfmXzt3oD8WBtlo7+5bSYD7nqliERlU29DCWxX84XsrHb5M9V+eLYKUsVRfTgC0WWsU4GLUhRUtYh2D6vUyQz/6d0uIq4LtRCr9aCAMsS5rNop56dc1/Nzq9HdiuuHMsURSuSUmrzPFV76/ZqVeLop10lzZhsmvPYRxGK8U1TqEgrJNcRq6CcfpGCUMZBhVyEiLRGmcwtUMqW+/mZ6BeIankCatZFjVPnBDdiOzlDGe8ICnnWLTycv0OkYLw/alILUEI9/Y4/7jKrC1SSu1lOnx98hKnUmb+7hZnP8iyaAhkrPwa2n/Sh5eHOK0GUbvCop1j1vTI9SR5qr98IQnS9Q7jDza5+MBjthXhzB0qLxw2/u9L6PaFZLpeRfsO7izCO7laSjVpa1ZYcpnX5dpfPJrjHwoN1Hz/8EYL7SlBYrw5tdmB4PFNqbYsCdwsM5RAm7N/LuXtqb6qckJPNHKDUyigdreYb5bp38kQpr0GpaNEXFYHfTmt5rPElRyzNelkMOgNZ63N5U82OP9JTK45YzH1KT7JUf9aUA3GrqnWWgQ7dbSjyJ6O4ehUXFC7W8z3Glx8P0tQ1QTtiPy+T+1ZQu3TS9H3XQe21gk6RbGhpouiyufQWx0uPqox2VLM9wKUl+AeZ2l/oqn/0eFSlrm1aV1YPHsjslutSnxznat3S6gYQXNcxaLRr3J4Oo100xgtT/zpDe3wr1YIapoor2l8oWj+SrIgiWHwVMqiQ6el8qZJy2nUWDzaoXc/S1QQZ1rj61Bucq8vly45gz9OH3oivcZOuYza6BA3ikRFH63AibRQay+u7ODUGDLsTT9dkE2SOamWliyunvQ06MHQDpCXT2xkF3epKjiOLLLFgnymlbI3udUmr2tdACt1jnqxsIu3aSUkjuVmNRwt4W65rGwKcSJSUBBYa/S1eaUJj5n1LLWxf7cawd7KARhmhw6CZaT7rRSvebzNDjIbidXyTErQRL3fkopsXyfY074dMBdTr7KRfsxzpDZOO8Qp5Jc7d5zYesigVRCcbOoR19OZnRvochFdyKI9B+0ogkZOWpaGId7lGO17BGtFph3JBSgN1Rdy9U5eH+AUCoTv73H5Xp7JpibbT9PAX51Book26nQ/KFmipjvwWP9pQvWXpyTnl6itdYbvt1iUHZwIiicBudc94pf7OMUC4Ud3uXicY3QzRkUKb6Zof5JQ/ko0X27uMNspExUcCqcLvK8PrNuFrXUGD+siXy3E/144nOCeXglwTjnSpbvVJqzn8K/m8OJAFqHbe1z8hXVma4o4IzC66puI0tOudSGpgmysRDH0BhIMArFo3tlkuJdjUXXAAXeupU0s7SZQGR8215Z8oHmEenMiA8QHNzn9SZXxxzPubZ5xNc/T+2WHzd8Lyf/yjQXSmbmGSjRedyavh+PA7R0uPqrSe0+Dp8lcujIX+XSyHLhns7DZIarkBA2SOnW8tbYN+c13QlQmRnUzVJ471F6GFJ6cSGI4LZaJKzlhG6VWSWd3m8HjNr37Ii+W9jX1b2b4+5fSg522ZulyUYicYQwnF7Kg3tjk6v06wz2HqKDJXyhKRzHFAzlkxMOxvS1IYjsWR056kva2Noi2Glw8LhKWFP5Yk+9pKds5OksX95KcXFck02Q8XuIfdjeZbZZIsmqJmEjRKoZYanIz5mvN59spl2S9qJVJ8kIIdmYhajBe3gzM423SQLEgG5qxgzupdTOKLTnYYl9W8Q5wHecQx7apC38F7hbFtu/AUIDJZS0N1nj6DRLbdoun7qJr6JmV/gGV8b9bGwAg7p+U/UMcXz/R/7rHygDXdgishLXsLyhd/C1TY3UDWClqFq1NTghOPm/53Javks9Z37IZAn3L05zLEneqy+Hl5coC1WoQrdVIMvJ87lxcLWRT2SmKbU3kvFMgqLh480Q4+Zdj4mev5CZzc4fBwxpBZXm1Ln56RNIfEL9/h/2/XmTRjvDrC/RBgfpTaP/eCfpqIK1Uu1UGt3yy/YTymzn+s2OSXh+nWiZ8eIOTH+eZbiTofEzmwqP2FTT/9amcXAt5Fh/sMWv5ZAcxhW8uiF4f2Baz7qM8i7oiyqf46V/N8F+f24XfW2tf08k5u5QTf6fN9KNdzh/7LFoy16i+0DR/0bM2UDot4fukA8qk27OR/eThTXoPikw3FE6QJk/35baRXKSOrFaDZK0h9MhpKGC41CY5/O1bHP0VTetGH8+NOf+yzeYfaCqfnEqtYqtBsF0XHTpIrDtKhxFqb5vjv9JkeDcmuz5l3s1Tfeqx8Xt9m30w5E2d8VFJIv7/c2l/m358i4sPfGbvzGHskz1zaT6NqXzZl+as+ULee9sbRI0iThDhvDklGYxwWw0GP9nl+LdBlyO8iwydn2tqPztZQuU6LXS1JIt3IoX2TqOOLuQYPWwy2nYZ76S3wzdIyPDpG3HPpbMJ8968xjVq1IhubTC4U2BRlzL75tOQ/PNLy15ySiXUWksOSpOZ7YFAJ3jrayRNYUpGzTzzZob8yVxmSVf91C4qdY7W15/OFwyh1NB1tatk9mGSuhc92dRXUv6rmSFTCg9IC9sisIlk87k2G8fq2mL/aSykXqoMLGR90fOFXbyBpT00n7MbmF4ZUF/DRJtgKFjSqPy9oyUUbuXm9N0phU83AKvHw/XBzFuP1f5g5XsyhFrR7Fd1MuvHtTRBZxkfX2nxeTuIpjK+tAylv3TXWNJS3z9c37VVNiuuj7Q/WF/1iYdj66zQpQJBRwZ8/mAhQRxTBqEUSmsBwpUyxDkXbyI3h+TNkTxtrUrwaIfxZoawJBiH/PEM9+UxKIf45jrd90oMb0PYiii89tn+v8Y4T15BkhA/vkvv3TzTNUEJtD+d4n76TF6vmzt0P2zQexeiWowzdWh+rmh8McJ5cyYBto0O07sNFhUpIC9+cUq0f4i3vcXow01Of+QSrgU4fZ/igcPGH4xwnx2KLTA9ZSX1CioIUyqmLMqmpezqjs/wQUT2zKP+VSJguNciJUU7bbHPziN7oiTRuJ0W8/sbTNd8pm2HJAu154KI4Lxr7XQmrawdB6fbl/LxtPFr8qDN+WOf+TtzGPkU37h0frEg+8UBqlggapWZbYgsmDtf2EG3KhSIb29w+UGR3kcRmcqCYJCl8/serT84lvJ2x0HtbNheCK83IXl9gA4CvPU1Zg+36D4U/r83VVRfJDQ+vbLlKd7GGvG69EqD0EzN399Za3P2lzfpPU6gGpL7Okf7s4jS03Pig+Nlj22xAGFkN0sDhevdzzFvKFCCDC8fxhSf9WSwmxbO6FKBuJzFO+pZG6dhFg1v5qUT2VMUzhPyFwHZlxckKc7BlK8DqJGwsuLBEG9n0wIKnRgWFYW7gOrzFFfe7dnZjTm8oRNrA3VKJZx2k2CzRlATvo9/NZOhexqIMziF1WJ2e7BLv17nMpKaTjQsAls+b0GRbx8qV8qmnFZDXptiBneSHiKDUIa784UNd60SP4233yKlTSbA8+S24Di2nEd57vKf88WypXAlG6CDkH8R/C/fgQ3Aaeof+X/9T3XofKsWjZWNYiWNpxfBsuzCWMneDlTAdZnnbe7Q2/3DK99f+f4S0mRShKadKE6HN8aLbOBxpSLUKssrdxSnLT+xRM19l7CWAwVocKehvKEurywvxdndYvywzbTtolM6ZOnLnrggSgWG7zXpveMSFTVOKNH92s9PSS66ov/f32D/r2XEwXGEtWmiHOYf3uL8oyzTDfGx557laP0qEirmYCje/70a86aUlxfOQilmPz7Bvb3H8d/cYPhOjNeYE13kqD9xaH0yxvnyNSSJnDLdo5I9AAAgAElEQVTzWZJKHrc7Qo/G1u6n3r3N+HaF0bbLvCVws/anIYWXV7KB+h5xNU+S92Q2cHghJ+ZqBb23xaKVZ7KZYdpRuIGgr0tfXKBPUpheuSwyUSwnVz2dSzEK4O3tWJheUNNke4JiLj0VdLYq5JndbjHr+HhzLWjro1P5vaYOq+Gew2xD5LHchcPGH83JvjgXmSdd/IzM5J1cCeTPdVGba/Q+XmOy5ZC4klRuPF2Qf3ZOtH+IW6uhb6wz2SsTZx2ZmZz0SdKTs9n0zn6QJahpigeK2vOAwueHxJc9ueWYhTctg3FyWdTeNtObVcabnn3N8hea+lNpljNpZKdURDeqJCk1U335Sp53e4PFXpPRdpbpmkIlcssqHc7xvj4g7vXt8+iMZ9n85jV3KyWSOzuM94r077jkuhpvqqk/EYpqfJluHCmHR0+nNplvbhu63SCu5gjLcnvMXs6kcjWM0KOJtPT5GYttWD3UudWKkHtTZLvJJwjqObAD5Gvo+XhZDG9qP/VaE53z0qHwXDqCTfEL0jkia5NjT/ar6BlbR5uuX+Zn1lFke5wNcgKwmA2DizYDbBzFv5j/z9+BDeDX5ACMF//XcXnsY4XeBysv2sqwZLV02TD+7WPF9mXQE3bqDt+uijQ3DhPqSGvZDP0wmUytndSplAVVkM8KT+RqKHqe55KsNVi08sQ5FydMpNyjP7NF16ue6WCtxGRdODj+JBGfe3+I3mjRf1Bh2nFYNCDXlbau/CdvxN+/s8novQ7ddz2URhAOn5+TvDnCbTUY/fAGpz92iQoJ3tQhe6lY+/mc7LNT2cC21+g+rjJdV5T3EyrPJzhfvJDX+OEd9v9GjdmDObe3Lnj+9QbNT1zW/uVxKi3UCHaEeupNQrzzoQwZ09dH7WzSf9xidMPBCaBwkVB5OcV9fiQfok4LPJe4ksMdzlFXwyUR8/4u0808YV6hHUX5YGFLdPR0JgO2Qo6kXpYFaDBaJk9zWbh1g7BV4OyjHFEB8udy8i09OROZp9NisVMjqHq4s4TCmwH/D3fv9StZlqX3/fYx4b253qavzPLVZdqxZ4ajGQ4NIANoKEh6ECAQhPQk6A+Q9KQXvQmQ9CQKEghQJEhIgDSkiDGcnu6u6qru6nKZlZX+Zl5vwvtjth7WOTtO3KpujkSIgOo8VWXGjbgZEWfvtdf6vt+n9w5QhTzDt3do3XIY3JqBb2H3bVFRxRsqwPqKqQrVaCJqFc/HqlXxV6t0bhbob8tA2h1ECWx3XxCcn4tS6ua2kQ9njgYmON0ulwivbtC9UWSwaWFNIy7S4ZTUoxNJQ9vdZLpZQYUa92wET19IBbq9Qfs7TTrXLYKsJnOqqDz2KdxvyWnE8808Jsi6OK2hBL6fni2c0C7uuPgRDbT2xUi4S9GibVXK6GYNr5nDbY3h4R7heIyztoq/2WC4kWVSkdmEn5X5QqrrG9JrUmCBUqYKt3I5rOUmOptmtpQ3t24cyqNHE+mRW0qwChGOIW4dx76EOMsj9t9YvZH5bEQUMptLQBOBU7HXCMeRzOZshHDxA1RvMJ8NRDPAZA6A6TTEzxUxfuIiVYfhnOuTQFGb54h8Rsl84KRaEPiWGcEuLfJJDb+VSX+N2Gnkl4mqPdkzMwqfpB8gcRnWT3wlcKuAiZaMtcJJFGsyZH5BtbTckH5+fCT0fDNMirk+YdoxrlK7NTAcGUCqlGoZb7mMn3ewvVCq37En6qGUy+haVW7GDBReaGpfDheMXcNbS3Suu4QO5I9Cqr88E23/cpPBnWVO3rGZrkjG7tL7NrXPuyJ5zGYJ1ht0bxTw8vIeNH4l4eN6MiV49zbPfz/L2nuHDKZp2r0c+Y9yLH8wxHm4j0qnme0u4ZVdQkeRfxY5Q6MBYrizymg9x6hp4+cUlcdRVmzC4BRWCozXCuSeRBiDqH2kb2wx2C0walhkW5GB6JGoaXQQGMxGUM2bqMbg/GJBEdS/VWWwZkugvYdIQL88knZOIU+wu8KsHGX3HvXRewdYpSLTW2scfj9D8MqAnUaLB8+XqfwizfIHXaw9yROIpZTatXDPRqjjM2kPLjcYX2vQvuEyaWj5TA4V9bsT0o8ksSs+5QWNItq2DMJa2TZc3+bs7QqdW5qg4uOeu5QeQe5MsgtiQ553ZUUChsaeZAJ0e9iNBr0fXaG7Y+PnxXuw8SceuYfnBC8ODSdL1aqCJ0k5WGedOcM/yh04fSNNkIFUT7wRpU9OjMNZZaMoxXxGshPaPfzDIyO97V8r0d8Sk2LuRONMJF84btXIfZaV+3Q0JhyN5DPLZqXNExUSKtRYk2BO2I0zdR07gXT25mEyMd8nkmXHfhQ1mpjHL4RBJdcELsktU67ZPGLHsKGmxiywxOKflJEDsnmk02Y+YNR/MHf3xpGVUZ8/FquYFLfLQpVo7ft2GcHihf5SeyYZ+r4QtpDAQQBf+zAvX5fnBvEJImmwAOaI5siMEptKrHKEghiN5/6DOFM0CoY3fcXxVL6cliXmllxasLR+iHPaQ7faXxsss1RjtpRHeSFOZ4I6a8F0KgvzWp3RRp5Rw0Y7kOppqp+1CR88lde+usl4PU9/w0GFUHzhk30kMk3vzjbtW1lar2iK210GT8tUv1AsvX8h1e36CpOtCr3tFNqB0p78bLh3gJXPMn3rGnt/4PLqO4+5VTzhH375Js3/I0PtpwfSZqrXCOslJit53O4M96QrckbXgaUGwxt1ejvy3jpDTeHQI/fgTJRIqcixHfXnlecvVKXjt3boRj+b6muKexNSLy4IWx1pMS010LmMOWWFvb4JLrdXlpheWxIqZVEQFe5QUzic4t59jh6NxWS0VCbMyI3vPDgwzKLB93c5edtGXxmRzc7oH5Qo37VZ/fML9PNDCQiJVExByiK735dhteMwfnOb1u0U/WsBOh2QPkhReKGp3h/jfvFUNrZ4OBoJAOJNy6qUGb25zf7vODRfPmW90OVikufgozW2/vkU98P7wh9aWSKsFo3+P4zYOfbasnEK+zlBhi9/6JH7eE9aaBGa26tmpXc+nhq6qHIcgpubTOtpTt5yCV1Nqqeof+GRvzd3C1vbGzLMjhDJwem5bChXtxlcr3D2miMZExPInmvKD0dmnmVCY7IZmM4WFmO7XjN012k9gzMOcDsTrJPWPDs5F/G3ZjOR/nZ7C/eRKuTmwS+2whr72J2RuLHbHTkdxKf/pPkr6verdFpat65jPC34AVy057MFWJSCRu+dymXns8ZUKmrzOnNQZNSBME7hdFrmh1GG8ILiKO40JK84YSxao749G4D9e/NF/RIUboEGmsREJOcD8X9/09A4OTdIsH2SXG+VScscYTyZS8YiHtHl8Pl4ELTA5k6npAcJc4hcIUdQzcmwsjMyg+F4sGzXKqhigbAkUtMwK2YT+/BCUALVCt5aldGqBITY05DswRC1dyQVXrOOd2udwVqaWUmkd+XHI+yvXsgJ5domJ++V6N4IwIbMoU3tK2HB694Avb7M6ferTOqKVA9qX0bGqk5X2kTvbrH/2xbXX94n7fg8+PNd1v98RuqD+2BZhC/tGOlq9miIenYgC1sux+y9W5y/mmYahYaWH2tqH7eN6sZZbuJvNkWNM5uzgeLh4+ilFbo7YnbLHSIyyqO2KJUSAR3W2IPDE3HLRnCyyW6dacVhWpI8BVmEfNPOCccTnOUmwXpDPq7OcH6S2Fxj8HKTo+/ZOLsDJmdZio8cwWt//ERuvvUVZmtlgoyN2/eMysiq1+i/tcbBjyxee+sxk8Dly682WPqpTf3DMzg5Qweh4LmrReldjybzf/dSg+Hr6xz+0KFwu8Wt+ikfPNql9pM0zffbhPceyilzdYmwlGVaz5Dd76OfSgR38MYNDv5KjvGtCXRSFJ9YrP6ka3wVzsoyulbGr2SxJp5xAWMprGs7DK6VGS3ZECJZD4c+uRfDhdkL6yuCnu4MDcVUpVJY13bo3qnS37CYNAS7nT8OyB1NcZ+dimgiImHGJ2Q9GksKWeTY1Te2TDav5Ydi+BqNTc/bymfn8ZLRfRqbQtVyA29FPhN7EqA0xmGvxlP0cGiGyF/Dy2TSZvEmnTJ+ntjVrCxL/CVx7khU4ZsqPSFP1Z4ni3k+i86k0RlHzKCt9oIU1bSW4nmAN1uIrU22tZNUghijEq8z35oZwHupPwBYXPxjW/RvUAPJg399PsAC2I2Ejjfp7o15/9ERLRkmY2Uz5shlwmgyaRPWHOd/xkhYVchJRRrHxgWhcR4mXctWpUxYLsgX5EKiF2N5KoDfKIoxq+bI4hW3RDodY9YZbuWZliyy5wHZI9HY6+mU4MoarTsFRquKICMB4/V78/5+uL3CYKdA94pNkIb6PZkPBE+e46wu0397g/Y1h+F2gC74pA5TrP7MJ/fTBwDMXr9K52oa24PcqS9Rhs/3scslglvbnL5ZoHszRAWQObOofRUhqmNy59YafimDTkkovFG8bK7Rfm9dMgvK0iPPnWgaPzlaOFGEpSzWaAZn7bm8dnud/qtLDJcstBNLYwOyJ1Ock66BidnlEtQr6ExaqrKTc9N+6r++ysUdh/FKgAoUuSOL1Z+OzIDT2d4gqBfxymnczgT7uE1weo7dqHHxOzucfD/k2s0j7lSO+OO9m+iPymz90w48fiEu50ZJ4H+zQKrh85b4HhoNgqurnL5ZoPOqT2W1R+eiQP1nLst/coj/7Ln06DeWGa/n8TMW+YOxCemxrm5z8sM6re/4oDSpE5fmxyGlP39kso/96xuEaRt74uMctMRPUC6ht9dovVahcx1SPQmNKT/xyN8/Jdg/QvuetNBWl/CbEmjvvDjDPz6Rwer1XSabZdo34xSsKKjmC2lJAoa2KV8ezxiqTLbAchO/lkenLOzBDLs9NMHzcVtHVH56nu8RnchVscBsvcqsIqdXexxKdnNrNOf/x3LMhAQ0bh0blleMn48iPHWvb1AP4XC0kAuykEceZQEoxxERiG1FBrI02nUkS6A/mDN8YtyMXmxlxzMqlc9jmP/+vPCN20KmaxH9Dn8c/K///98AynZDv5f9GwsfroG+xYs/zDeAxLHNXJfaRfHjk0HSyTd/YZ6QiIM0JrR8Xswqo5GZH1i5nGF2m/zPWA9cKcuXxw/QES/EHG1h7p7MpE12ADDXJ6ddEz7uFW3cQUiqM8U57eE/kwovTknymjlmZYd02yP15Azd76OqFcZXGxJwvhGSblmUnmrqv7hAvzgSVcvrWyYcJd2GyqMZ2V8+FfPW9R3O36nTvg1BJiR9YdP4PNHvrZQZvLdD94qogep35WeDVgdnfZXe2+t0rkk8pT1RZM6RTefpmcm51etLhGlH+txRFCHKwlldpvvdTc5fsfGKIbkji8JBSPWTlvndqVfQlgW2Qh2emyhC69oO/ZsVRk0LLy9BOfnDGZnDvvD3Y+lfqTQfFg5HoljJZlDb6/ReqtJ6yWa85pM9cCi+kNOKfvhU3velJmGtKKfB0RR9JGx9Xr7G+Zslen91yDtbz2mkB/zRw9vk/6LA2h8dEJ6cYTXrDF5ZZVKzsafaBPzoydTIMdvXMgy2BM2RbikJffnsQNpB13a4eLMW9eA1lU/OxQuSzxG8epWj7+UYvjxBjx2sscX6n4cUP9qXofD2OqPrDYKshTMKyX36Qobp5RKTt67Qup1muKEhREig98ek9s7x9w+kPbW6JNGaKQdr5mOf9+YBQS9fpXdNOFWWL8q04sMe6vAcPRwK9yYynFmdAXo0Mfz+uPUVVvJMlrP4WYvMhSfso8PTeS4vLKhzYn+QVSoSrArozi+m8QqOydyO0+CSi26SIhC3bEEGtzi2tGhCLf33SUQTjZIGY3FIcs2INw6UNYe4RTJzlU7NZxqzRPgLzEPrI5VgkmFmUPaJlrZKpw1mXk+mc3JBnH7me/xx+I++HRvAu87vL7whXwuBSV6XF/5ExW9cc7E1PE7uio6f8Yf7jfOD5Bck4VY0qT9Rvy52PyrXkRi+aLen259X+vFGEnNOsmlRDoynQh6Mj8PFPKRTeNUss4oMIDPHQ9TB2XyBXF/F22rgFV3hoZwMsfpDIXXWi3RvFOhcs/BKsXkqpP6TAxkQrq0wvLXEcMVh0lCU9kJK9zrGuTp99wbH76WZvTTGskKcL/Ks/2SM+9kzsexvrjG6VqW74+KMZOBs3X0q7+Er1zn6fonxqsarie+g+iCg9Pk8plGlXFS1QpjPiv5/PJVw9UqZ2UsbzCoOk4rNuCGywtqXngS/HJ6iMmmj/7dPOgZJbOVzBC9foXMzx7ipSLc1hSNf2mNRG8oYfWIuO/MAEbvRYPLaFq3baQZbIWFKkz2yqTwOKX9yRri3LzflcpOgLjhjs/hFrYqD3ykTvNtjs9rhoFsm+KTM8i8FxhectwwCY9xwSfUCOcG1ulLNrTTp3ywzaloM1yHdVuROQkpPxjhfPpOv48YqrTeqjFbkMyt/fELw5Dl2rcLg+1c5+C0LZ21EKuUz3C+y/L6i9mfPBPPQqDG8tYSft8geT3GPu/KzpQKz169y9kaG8bImSGuq9xTN99vw5LlgohNFhjUJcLpj9IsjwuHIYM17L1UY1y1CW1E4Dig87kk0ZhiK1yOSoOJY0q6M2kR2o07YrNC/KrM0ZxRieSGZF11Ub0DY7RmXt/m8plOwbHEhLzeYNUUJpPwQZxBt7r1Ilh25k5PCjSTzy6qU5X4DI86Ir7DXXwiGAhbUQHErxvCFQO7lwXDuP4ofO/MWTxfZDHi+8QcsrGMxcFJZ87+LvAGx6/drGBzmbfFvxQmgZNUFBneZ2Hn5uhz9eDmyEeYVf/T/ppKIfQCXVETyHzK5N7trwhyWVP7EmwFEap2ogghbHeNaVo4rzsUoKMa4BD3fbChWIW/639qxTEC81erPTTCRCiIs5glzrjiK+4KaCKtFJss5xg2HWVEJQ2eqKRz65H72yNA+h1cqDNZtVAjZi5Di3QvCZy+wl5r03l7n8AeK7E6fycTFfppl659PsD+4J+/d7iaDG2W8rCI1CCncPZOhcLnI6N0rPP99i8bVFufnRbL3M9Tv+RQ/fE7Qasv7eGVDAjo838DJ4gzZ2RtXOXk7g7bAz0LtXkjuZEbqbIjqSU/aW6sR5BzS+110xO63KmX8G+ucvZFjvKSxZorqg5DKXzwjaLWF41QuivEJjGY6psfaayv0X1vm4iWHaT0UjPSeJZvOR0/EEVwqQKNGWMnLfCHyY1jZDLP3brH/Wyn09SGOEzI5KLD0IdQ+kk3DymbQG6t4zRzTqkv2ZCrh5Z0eLNUZXq/RvuEwK8vXK3sq7Zbcw/MF1c9wt0iQskh1fXIPz8VlXS7R/ms3OXkP8ls9phMX60Ge1fclEB5vht5eY7JaIEgrcvtDUQP1BpIbcHuFzvUU0zKEKSTg51cS86hSLmp9BZ1NGZidPjyR9y+aVc1e2cbP2UxLNiiRJBe+vCDc25cZ18Yq/nKZMG3jHvXg9Jyg08UqFuHqpoT8ZOQEn+4LDyrOjI4r3KSaLw5yMa7xbIow4+DnXZz+TGJVByNZNBMVtnHvxgVddPIO6xWCYloc1N0R9IfG7RsPZL+W5KXDeW8/+h3i1q513p3jHWJUcxwwBfMoyHgNiNedCAFtDKDD0bxNFacXpoVrldwE4vbxt3MDuOwDAOLwhssJPskMTzOYTbp546NeFBIDLByZ4tlC3NaJaaPmZeP+njvfQOKpvPZmYhKJZgDAHD6WzcqNVC6ZD0/3+/N/T5xPkHYJGkVZrGYBVrsvgTWDoel1xihlnbZR0wCrO5ChcD7HbLNO+6Uss6JA36oPpmSed+ZRjNvrdN5apnvFItWF4oHEEXJ6gXJdBm9tcfqWw/TqBD2xyT9xWfpFJIfs9Qnv7NK5nhe54qlP/t4p/t4+Vj7H5Hs3OfyBy+q7R9QyQz755Aobf6opfHFmFjBVLECjKp/Z6QVhV96DOMCjf71Eb0uUTKVnoZicDtvCRclmCKpi67cmPtZJS/DT2xtMt+sM1lMM1y2jRW9+2EHffwJECpBqZa7TPmuLtj6bxVpuMt2u09tJM1hXBDnRwjc/nZD6cl8W+HwOrmyIMiZSnfjR3MFeWaL1vXXatyxmOxOssxRLH0H1x8/wT85MeMrwSgVtI2E5j48JWm2z6Zy95jCthbg9RaqvWP5QTGNBxCaylhqEpSjbd+xJ9sHxKVY2Q+93b9G+bjO64qEmFqWHNvW74lTWgyFWrcro9gpe0SbV8YXn9PgZ9lKTwXs7HP7QQtsImO0LReXhGPuzxzL7WF3G21nCK7qkz8fYB+f4xydzqFqtiFfLMqm7uP1AJLLHc3+CVSigNlcJCmmRar44JWx15F6I2muTikWQkaFw/mCMc9RGD0eEcTB6PFy17YUMb3upSbBUxi+mcfpTGaaOxrKYerN5NGL0HHHhqBwXq5BHVUqE5TxhRrJ97f4Uazg2c4gk2t14fsxCEKLyecJmhTDjEDqWSHxbY6zOwKjQYtRMDGdbwDoEYdR2lFaRjtlAICbOZDparGBKKH/iFlK8AcRzi3i907PZt6MF9I0bwKXrGzHOcRDMpcD4hdSwZPBL9PfyRInsYeZfoGTITLL/b/TB0Qdk5KHRBmI1aqYXGHZ70je0LKxaRXb86AugHUu+QOetBc6IycgtpLEGU9ErRx4GGlWmKwW6u5Jzm+pqKo+npr9uZdLol3YZbhfoXLOxPCjtBeJePW2hl+u0X6tw8YpCb40JeinK9xxWftpF3X8Gu5uMdkq0XhLpXu1Lj9znB+L2vX6Fi3eXuHhNE9R8mFlkjhzWfjIPnY+RAfgBajI1+bMxC350vcZgxcH2pOKPncycXsiNslTDL2UIMzapwx60uqJaWV+l/b0NLl5V+FlN7tii8CKk+vE5OmLcqPUVYbRPZjCeLKRJ6e01OnfKDFcswpQMlTOtkMpnHRNg4qwso4t5wlLWYCb0dGqiLbtXhGs0rYjZrvzMk03x2XPsRkPiLSO3snvQMWwgrm/TuV1isGExK2uyJ4rs+XyuIUVDxrTHcCys7pDg8NjA1UZ3VultO0zqUjmXns1/d0BgfNtxOyUgdW/fsIUmr+9w9kaawc0ZauhQ/0RR/yyKeRyPze+usynpmff6BBcto+iZLeUZN1OkeoEonY46RslijIrpNJSL0goZjwm7fbPwj7bLdHddMu2QTDuQtub+CWF/MF9oY9ZXQpJp5fMGs6DdyK0bZ01HvhuTjXupWIuzknUpz6yZNyoteyCnaxP6EncDEsNg035OpYTL36wyWy4QpCwZKh93oTtATybzYWzcHYjMp0kxSNyv17kMfi1vBvDWYIY1mkjlHyWPqVQKVSrIv2k0mbuDLctQVk0W8SV0zbfrBBC3gJKD38sZAXHqVxQSs9AuuqwG+g1IiaTKyPD942NgtLEkF3krm1nAUsdVhunhRU6+mN5n1SryJXYsad2ALFDdnrRocjnhkbhOlEcq1vlYKoqbItxawi+lGa7IDeNMNYUHXdT+kdGRc2WD7q0y44YltvqI/ohjM92uc3EnQ383JMxqsvs2S7+SxT1sd1Bry5z9cIX+jiLdgcZnU9K/fCQ3+Rs3OfxhwfS5HzxcM3LG8NkLqZh2NhjtlFABxjcAktbVf3WJ/pqDn5fKM38UUngRafjPLqR9VikR1ApgKZF4nrdk8d7d5Oz7S3RuQrA6xTlKs/RRSPFRD7V3COk0/pVVZpUUqc5snuubzaI2Vhldr9HbdPAKwrnJHWtRUj3vET54auYAermOCkNDjATQt3bo3izSuW4ROprciaJwKJtp+EjmInalLG2ick7aRNFJx8pnCa9ucPFqidYrMgzP7ysan41wvzoQJEM2Iye8hvSB4moy6ZIeXanSvepKoP0Alj/oYT2W2YZdLuHf2iLM2NhDT4iZUTFhN+qMXlmnc8VlWgN7CqW9kOLjPurBc9l0djYlMMYPsdp9QXIDVrGAf3OT0WqaadEi3QspPBtgH17gn5wtFDuqkJe2yHi8IGkOrqwx2MkzrinSXS0sp+OOMJEiBYxVKpocXDMUzorJKo5pjFVeqjswvChTmLmS0W2cvrmcyLFLRWZrFfyCmBBTnRluK9L+tzqLoS/RuhIXfwbdXK0QlnIEhTSha5kITs5aBoqXxD8Di4qeCByp8jLX065DWEjLRhZq7O5YWqJRO5iUKyrCWE0YZwcbMKQ/b0eBJBsmW9jfliFwUgYK8/4+sDgTSKqBkgt6sl0UX79unpC0eidUQIYvHoOWEpW/yqTnRNDEvEDlsiaA3hzj4qzRqCrV/aFUDQl5aez2DYtZ6ZOHIao/Ml8Knc8SlDKM1iQYxZ6FpJ9dGMewXSrA+gqjnRLTsuSpZs9mpF60wfMZ3Vnl9A2X8ZpwatLnFvUvA0rv75m0sOGVCqOmyEDzpyGl9/cIzlvw2g0OfrvE+PUxbspnMkhR/2mKpR+fEj59Ie2KqOWgHUWq44l5qtPFurIlA+Ntl/EyaEuTO45crw+PCdsdUApruUmYy8i/O6JDEmrsRo3BW1ucv+IwfXlM2ElR/tKWBXDvRFp3qw0jhSw8G8BnD02YfPdmiUlV4eeEc5M/EhlonF0c5zOrUoGwmMfqDsSJ6zpYV7dpvVHj/A0I0zIUrt/zKXwpcLRwMsVZbhIu1/AqGZyB5BUHZxfyfXr5Gu07Jfqb0mLKnijyxyGVnz6XNLPYJW5ZUnWftg3S2CoUCO/s0r2ao3NDvvelp5rSs6mkfUWzCb2xSlDOEAfKxwurVa8xubHMxZ00s5JsuJXHIeW7bTgUIqe91CSslwgzjkFzxClV3pUVejsZtK1wRyHZY3nP/KMTYviasi2p+BOUTGXb4mnYXKJzs8C4Ia2m6gPfoDXC4djo95Xroj1vIbPXKpVMdCWxIXMoZqig21s8qScREXHmcLlAUEjjlVJYgeRtO92pGMcixmt9flAAACAASURBVM8C/uWSBDTm7OhqCS8aMFvTAPu8vxjjaVlyMvBmC3p+YN5GjjoHuA7asU2sKUoJKTRSHEE0hJ4JOM7wjmJjWAL8FjOJdL+/gKiJN9FvDwwu/QeL/f34WHa5yk9eyQo/DmB2U6ayBxb6gpc9AHH1YdzA8RcsYQD7mkQ0lzOzhYVFvVSQG6ReQfVHwiCPeeXRa6t8XuYAOfEW0O3Pw6DzWcJyjlk1g+VrWWD6E9RghH8k0rtkTza+7LGP3R6hMy6T1QLnL7uMV0KsmSJ/qFh+X9o8euahbl7h7N0qs7Ii1dfUPx1g3X2Cch0m37nGs7/lUtmVqMRnD5fZ+GNF8cePpLqNODN+1sYd+tKqiYa79uYa5z9YpXMdVKgo7Avkq/xwiL13IuatQh6aNTFvDaYSdB+Zt6ydTbqvNejtWMyKGiwoP4T6r6LAmkoZf7VqbvLU6VAc0K7D5Ie3ubiTws+BtmQ2UH04IfWiTXBwNNdXp1ypzMJQFt6hRO7pN27y/PcKTFZ8yAbkHqTllBSx9wX5K4tUmHVNmyjodHBWlpncXuf85TT9qwHOwCJ/qAR//emT+Sltex2dcdCWwn4qpixl21i7m3TeaHL2hkIB9liRP4iyC+4e4B+f4KwsE6w3mCxnSV9McfZOzdzBe+s6p29mmNY1oQ2ZlhIS6hfncBYF1iSCitRgZEBlamuN1uvC/89cCLu/+GSAtXdifr84TjFe9OJ2i5XNwFKD2VqZ8VKK4YqFNdOke5ryV33Ul0+NOz5WzNDpEXb7clpo1gXfXczjVzKSRDbxJNeh11sId1G2PW/Puo5hDk02iuaedyaB+AdaA3SnlwDIOXMPQHzCt1Qk584avIMJa5r4qN5Q/CoxqVOHYtaKGEML88eYAACyJijhU6kglJmW48haZFnS5gN02l4cQkdqwDg3+HI6mPEZJeYLMV9Iz2bfEiNYggaazOJMsj3M9Q3a/+Sfx5VC/LNJF2/sAzA7acIZHA+fkiA6s/hHhMD4pJCsAOxyST6g6EbRQWgW/tg3YDwKrmv4JygLVSqgCzL4myxnUb7GGfqk9s4NiCuWmob1CmEhJYC1i7GYmDJpJusFursugy3wKgH55w6NTz3yn4jmO87R7V8rMVy2yXRCqr8QNpAqFuj81hWOfhSyduUcL7Bpf95g4888cp/tS7vq5atMlrIMl22ZO3x1aJ43eP26hNGsI/m8z4Ujn3p8bHrxKuViNWpScUemmJj9791a5/yVLKNVjVcJyR7Y1O4HlD6KThSlIt7OEtNqCnfok95riSKmWaf3g11O37IINifodoryA5ulXwyw7+8RDsdzlks2O+e7R62DGLp28m6Jzmvy/So8dFn/sx7q3hORQzbrUMyjC1ms7lAWlkgFZr90jdP3arRe1VCZQc+l+oXF8l9coJ/ty2PWVqS9BVj9ibDxBwPsSkVCfO5kmTTAK8p9WXoMjU9H2J8+lE2rXESvNAmKaYPWQGuslSUuvrsiJNJNH7tvk24r1n4sbSY9Gsl3rioE2jDriqO200NVy0y3a3SupencFPx04bno/927e4YGGpNvw9686rSyGRlUl/N41QyjpRTTiiDJM2cziRztdKVSXlteoG0Gx6fynpRL0KzhN4tMGincQUD6qC8FU6ttFu74HkyywOx6jWB3hfFalnHVxploMu2A7IsenLYWNo7kcywYQG3bREjGGQLKC2RjPLv4Gt4lDmbRQ3H4xwUcjo2OqnQVhIYAPF8UbCjmhRDsOtGJQDYIqzuU3j8iWdcFQXULrXY83wiicJnLLaHYLQx8e4xgXwuFT6h0vtbHT15J52+C2214QYkqRg+H5gOO2zjAwkkhufkYKVn0/DGMLn7uuKrEcYwvYMFLkMuarICF0JlIK63zWfzlskjKpr7MCp4cGhiWCbvIZVAzT3hCKRdshVfL0ttOM25K6EqQ0WTOFbWvPHIfPiM4P8fZ2cJbqTBeFeWB2/PniVi7mxz/sEbnTsj2rWNenFVx7+fY/qMe1otTlOPgr9eZLGUJU4rs0QTn/nNhuW9vMLizzOFfsfEL8kWs3HNY+rC/iBSulOdQv4TawS6XmL55hYs7aXrX5Odzhza1+77QSs8uUGvLBOUss2qaVHeG/fRY1C6NGhc/WOf092fc3jriyXkd52clNv7ZuSy8EYLbcGbGk4Vq315bYbpTZ9xM0blqYU8jvtBzj8xf3JOFd3eT2VpZKK37whyKoxKDG1sMt3KcvGOh1ye4D7KUnmjqPz81G6p3a51Z0SXdlkUxOD2XynW5yeRKg+5uit4VAbOlWxbNT3yKHx+a00YMdrOHM2ljRNr44OUrHPx2Hu+VIbYTMtvPU3posfovzuHwRCrdK1sE5QzaUVjTQBzQgM5lGFwr0990mNTA8mWgXNwTjHPYH0iiViliXQ1HcxR5JL31ii6zki2n01FIqjXB7ozQB8ey0Ofz0KwKUK43WmBd2c06ulnDr2cJXAt7Eogb+uBiAQD3tSsyCQarQs+dlWwCF9LdkNyLvjEEJlvGCz+eUPIBhhRr7vnx2Lx+jICeS1FDoxIyM710SrDuEX46qSYyKX8x00pryfiYTMVk5klrWUWJY2G1JD6JCJlt5KzxbGHmLZ4+xpOFXPT4+teyASil/jPgPwY08DnwHwGrwD8AasDHwH+otZ4ppdLA/wy8BVwAf6i1fvabnv9rKqDLzt/494hhbkkmEN9cyX+t5ZNEQSf6gMBiYlAy8Sd6TCzBMieKqJow8tI4PjKTFhlk/FzD4RxxG/VLdT5LmEsJS8W2odOTL1KSgrjcFOVQRDrUERAurJcYbRTo7TiMm5DuQP4w4rHfkwouVoAMNlKkBiG5A0lX0sMhqlqh9d1Vjn/H55Xr+zw6axB8WWT9z2dkH5+jcxnGG0W6uy7pnqbwfCKVYbeHs75K6wcbtG4rvFqIVprKPUfaHbFpLM5RdR3DUYk3x3hIePFKgcG2nBgy54r65yJjVZGxzdtZonU7S/4ooPDpoahaVpbovbXG2esWzss9GoUhz+8vs/ZjKP90T7wVEao3zl2NFSbxYHi8W6W34zIrK9yeJncekt8fY9/fE0REs064uYR2LOzeBI6kRWXXKoTbK5y/XmKwpZhVQtIXFvkjzfKfHMmGmk4ze32XcVMWmsIzQWejFOxucvZuFa+gmFXA7UPuJJTc5YdCM42DafxGpOg5uDAzC+uVGxz+TpX+GxPyxQmDixzLf+ZQuS+tFh0EWDubeCvFeZrWccdguUe3lhktu/Q3ZSBefiyqnOwvnpj4QlUuzT+zbs8gM/xbWwy2sowbFvZElGep/bYgFqKkrTiKMWyUUcOJafXELc9wa4nJSg4/a+EMQzJnY+yLvmQqJ1z5SVpvfGq3GjW8jTpeUQa79iSQjOzeyODFk/dxUitv5bMYQxXMB6oxViHyOKhYr59yTctID4dzdU8s386Kg9/qD+VnB8MFoJvKZdGVoqn08UMxPvrBPKcgbhlF3QX8wDCSTHBRNjtPC4P5zCEOo4mpyNH1/3kLSCm1DvwEuK21Hiul/iHwR8BfB/6J1vofKKX+B+BTrfV/r5T6T4BXtdZ/Vyn1t4F/S2v9h7/pNUqqFhnBfg3rx/wyl8Jhoj9bUAklHxtfiZNEvIkkvzgm+SspMY16j8kZgOn9wYI93Zw0oqNa0rptryyZHqAKQ0mk6g+N4sV8CctFQc/G7KFOT754UYTg8GqJcc0WyNVMkz+aLeCE1e2rTFYLjJoOVqApPRJENEC4vUzr5SKdWxBujQmmNrkHadZ+Nib16AR/vU7vap7OdYvCCy1ywfvPJGf29nU6r1S4eE3h1X3Shy61eyGVX57AecuolbRtYQ+m88i/2cwkL023a/Q30kwaCnusKRxLQDmPnstRf3uNaVPMW7YXknreItg/wl5bpv3eOmdvKcLVCaFnU3/fpfJoSvrRKWGrjVpfwW8WUUEo/fXTM4MxGO9WmdQcJlWLWUWgcM1Pp2SenOPv7YtTuFrBb5aYVdPkHpxJhKKlsNdXGd1o0rnqgkaGixMovpiRuR8F4kQMn/FKBuVDbn8Aj1+gbIvJd65x8YokfQGk2pGj98FApJixEqxSNl/TGB0SL76tOzlRQpV97J5N82Oo/uKM4OET7EoF/9YW03qaIKPIXHik91pygspkGL+5Ted6iuGGxpoqqvdDyg8HqHtPpL2xVI8klosSTqtSJlitMV7JMW4IviJ/NCN12CXc2zfyyRiGGEsew07XnFyDW9uMVzKMGjZokf1aviZ398hU3cnZ3ULRlkljNesE1TxqGqDTNtq1cV6ci4ggul+NB8C2vw5lS0U5HLm0SEijLO4k/jk2bMaLcryoq0LeuPMBwoxjsoWxLPPvXCAMZDJSgEZzjfg+x7FQs6haV8pEaupewh+USEBUkV+AmSfD8sRGBRGXDMxJ4F/LEDjaAD4AXgN6wP8G/LfA3wdWtNa+Uuq7wH+ptf59pdT/Ff33+0opBzgGmvo3/ALxCWBh6PObFvOv/ZLfsDEk5KLJIa75kW94LTPNj37VZB5xsmX0TY83A+uYR14oyJGzmJfnm0xNDGGSaxIfS7XryM04nZoe4uh6g1lJviBBSlE4nJF5dGpkg3a5BKtNxltlJjWbdDcgu9fH6g4IlsoMtwv0Nm3Gq5ogpUlfiBqo+MU5tDrojWW6N0t4OYU9E5Ko9dkjmaHc2qF9p8RwTaEtCWav35XwErwZrK8wW8ozWkqRGgTGMAbgrK8yvbpEfzONl5fEq9QwJL83wNo7NpWn3llnvJrHGQekTgcCu7to4exscfgH6wx2NH4hwOnZND7VVH95Rvj0hWC5axX8egHLC7CPWqK0yWbw3r7Jxe0Mgy2NColQxr4E6cQwvagPP1pO4/YDkYc+eibznVeu0rmRZ7AuiIncWUjucIL77EQ+v/FYcMrNmngH/HBuWFtu0vvuNvu/K7nCvWGGzAcF1v60DY+eS487FgxEFMg4gjBuUXXeXuXoR5q1q2dc9PNYHxdZ+XBK5qm076zlpkkqS7cDcntdOGuDDgm3Vzh5t8xoXTOrRvOgzz0yJ2OsRy9EYtusEzRKBrgWdHsCmltpMrhRxs8oobteBGSOBqjjC4KzC5mDpdML8YZx8EoMZtMby/SvFenu2lgzcAea5i+7BuWcxCwYLT7zxVhVBSGhXcfk+RruVpywl82YXrjp6ecyhJWC6ekHuZRgquO8jQi6ZzI74hB3mCcGVktMtiQIKHQU+eMp9tDD6kenmk53HkAVrwVR4BSOYwBwQTlLmLJRQTRDjNpxkucxQ8U0T2fe6tFexAxKrGMmSCaRASB/PhfGKNv+S28Azr/sAb/u0lofKKX+G+A5MAb+OfBLoKO1jptR+8B69N/rwIvoZ32lVBeoA+fJ51VK/R3g7wBkyC3INs0R5zL74pv0/loDXz8VoKKK3RYNbjLxJ3mMStJHzWsl2jrm94q0yDqWZ8XPnURExw5hxzGZnrHhI64+kkM2HSY2pCisW7kuupjHrxfw8yKrkwqsh94/wo9Ctq1Xb+KV0xBoUp0puQc9GE/QtTLnv7Upxq1SgHtukTuUuMPclwfo3gCaNcZv7TJuSFpY82dnBrfAzSvs/7Ua04ZGeYJpKLyQ0HiCAGoVBrfrTEs2qUFI5Ys2+ukLAs/H2d6g++YKwxWbWQlSfSg/9cg97RpkM0tN1OqShJ8oRe55D/1sn2AkG9rs997i4d+w0cUpmWdpln+uKH7VlnQrQN2+yqyaxelPJV/3yXNC18F65Qan71XobyObxsii9ATqn/Wx7j6R569UsF69xayWJUjb5E6mpB4cEbTa+N+7g7YUrVtphuua0hPN0l8IwjnoDQii3Gk7n0fFg7t7T2QBrNfo/PvvcPr9gNJKj538iMMP1lj9wCf3i0fGaezsbM3bVNGiZOVy5pTVvmXhXRnjOCEnny2z+tOAwgePRH2Sy8KNHSb1rCS8/eIMTs9lodhe5+zdKt2bkL7WxdsvyFzmFwOszx/LPZJyUWvLcgLdP8OP8M727Rv0blWY1CzQkO5p2fAi3wJIlCMg7vbRWPrRkboqnjUN1jIoDaOGRf4wpLg/JfXsXIoVkMG0NyOMJdaJDUUVi4TlgpxIWl0YjNC+L63XZP4HyELpprDyglkI6yUmDXlPrGmA5Uj/3W4NpaCaTA3F1yrkpcJ3bMFIwEJrdbhsE6QVlSeeSEm70Uk9yeePcwgsC3zkfs9mCHMZ/EpGaKuDmcRpeiHWVIunYTxF25b4Ayy1IAPV06k5EcVhU/GpglBLBC3zxR9LobiUjvgvuf5VTgBV4B8Dfwh0gH8U/f9/obW+Fj1mE/gjrfUrSqm7wO9rrfejv3sMvKO1vvh1rxHLQJOD1K+BmC5B3xZMHfJC0YMjT0DySvzsgrw0UckD840ifr5LxjIj50wEQcR6XDN8jI5w8fBxYTBcLJjjZjzkUdEXGZBgklTUlgpCYxwJT84W9P9BUaRn1sTHuuhJP3J7lc5LJdovKWY7U+i7lL6yWf3TFjx5jkq5BDe26F3NYwVg+ZriZ6foo1OsSpnp9RXO3sgwWtaEKU3pkcXSx6KqUfk8/nqd4Za0aZxxSO5pl+D+YwNmO3sjT+96SJgNyT13qH4VUP6VkEQJtbQ6dMjs5W1Sh11odUzbgd1NWQBfUoQ3hgSezfo/dim8/0wGbMUC/nKZaT2NPQnJPDiR2cBSk+Grq5y96jLa9sEJyT5NLQSj6yDAWV0mbJQJcinssYcajAkjWB0vX2Pvb5ap3g+pfN6i9UaN0pMx9qcPjRpI5XPmpo1Josq2sa5scfzbTSa/2+c/v/PH/O+nr3Pvw102/8Qn+8EDU3HrQk42+OlMbP3dvglPOX+nTvc6hDZoR1O5r1h6vyVDbd/HXmrir1alLdUeGemtVaswenObox84zJY97JxPeJGm9plF41d9+PyhONQrZXQ+i+oPDdM+5jF1dyRHwplo6l+Mcc4HMpOINqZvavEA2I0G4fYyg5083R0bd6Bxh1B6PiH1vCXsI5BCKOXOB73RQmflcpIVXRJMQ1BISWjL3okRC4As+gv45QjLETTLeOU0XsEW70LPxx14suhPZ5J1kYhVXBAHOE7E5gnRhRxeI8doOY09C0GDNdPkPt6bUwYi34OsOb6Z71n57Nx1nAxxCkPx/zi2vE6UK4DWCx4APRqb/F8DhYuBlqnUHGoXbw7JAJvE9ZcNhPl/fQIAfhd4qrU+A1BK/RPge0BFKeVEp4ANILqj2Ac2gf2oBVQGWr/pBZRKsHmSMY2XUA5fM3Z908xAqa+1g5KtGiP3hAWpmNlQLPtrm4+ZG8RD44S2WJ7fnTODxmNjlzfOyQgwpSzLuBKtfBYaNfxGkTBtY01lU3K6YyOLC6Kd3yoUDIteO5YJylCZNP56jfHyGr1th1kJ8gea1Z/Z5D7dE5ZNs87snVsM1lOEriLTDij+Yl/6qbkskx/e5vgdl2kjIH0Oq+8HFD8/Rff6qFKR4XdvMK3ahI6icCD97+D0HAp5vN95naPvpZnWQ9yBpvDMon7XI/vwiODwhDDlYi810cWcUUakPnks3oGlBsO/dY3Bms1gK+qTdxTlP8rT+MmRRBbe2GW0VQILUq0Z+S/P8J/uoa9fofXvvcn5WyFOYwLMsPdzrL6vKL3/BP/4hLBQwNpeJyznCKcBajzDfrIvrbN6jeHfeJ2j7ymad87YSnV5sL6K5Vep/MOPRbXTrEOlgA7EoBT3v1UqhX1th9MfLdF6NeTq7X3qmSH/9f/5b7L1zzxu3n0KmTTj71wzbZrsiz602rIhVCuE72zSvZoVLlFGAm/yx9GG+eJQ2oFry0x3argDD+egJZDAIMC6tkP7rRpnb2ms5oTQC8jdz1Dac6h+0iK4/1j66Gsr+M0S1lEbvX9EGATYtSr9d7YiA6DCGWmWfjkypq8wGog6G+voYg7V7hGct9CeYD2sqztMt2tc7Kbwc4rQkVD43KlH5t6BzBI8X6psQOWyUryMRqh0GufKDt5qhVnGJnQtnLGPe9TDPryQ+UdcTMX3pDfvddvNOuFGk1Ezh5e3CB2FM5W2ot0eykm7PyCIoHJJ/4Co8nKS2BctzH41J+ExI5/Sgx5Wuz/X8hfzBOUc9nlP7nuzDohZVBXyhOUCs2YOFYovBT9ARV4inUmJiCMOnPJ8cB0xuE2nc2BlNHwHFqJjY2RFvLYk16Ik4j6pBvqXXf8qJ4B3gf8ReBtpAf1PwC+AvwL848QQ+DOt9X+nlPpPgVcSQ+B/W2v97/6m11hAQSSTcMK4DXNJBvpr+v3f9P/fFCc5f9xif+0ycM48Jj49XILPGeeeDueYiGijmG86sWnDm0Ovcln0xjLasUR10hqK67DTXRgMx2ojq1Gbo2ujiDmvWaB3Jcu4ocieaVLDkMLjHuHnD6QVVa8xur3CpO7gDkNyByOs3lgkZ80q460ynWsuwzVN9kyRPwypfniEHowIt5fp3CwwKyosH+pfDLEfHZgkr+Hrmxx/12G66oOnaHxk0/hVF7V3JJt4MZIT5jLiV4h4JiqbgeUG3TtVWrcs/Jxo0SuPhHGjTi5E/18u4l/fYFZJzZPGegOc7Q0O//o6/u92uLN0zN3TFawfV1h5f4D91QuCdhurWDRDxBjTELQ6xu3bfr3GxauK7K0Ow1Ea96scKz/3yPz4riwW2xtMNytCnHxxZjwPameD9qtVJlWL/q4mzIWkLizyB9D41QD16QPBheys07tRwu3Lwh/ee4hdKuC/tEP3Wo7uNUWQlvlE/lAwE6VPTvCf7hnF0mxNBsPu+Qj98KmcUK9ucvZ2mdbL4j3QY4fyPYfmx6L/D3s98YssVfGqWVJHPUFUjEbYK0t0316jfV04Uem2pvFJz9BC7XoNygV0PoMaTuTUGeni7WYd/9oag40Ms4IiSCtsT1N+MiO93zW5zXatItVuIS/u2/5A2mMR1M3bajBaSaM0ZC5mxq0bnLfmkEYSQo64Xx+hJ/z1Gn7eRQWa0FFS8Z/3RUXn+3NvT4IPZsJa8jnCYha/mEa7Fk5/JvLr/lj4RrFbOQobUhNf5Jtxvz7lyrDZdQiLGYl29UIRPXiBDHxhLusMQxki++Ix0H5U8UdyUdyUzAYT65UejNCTydx1bFtyH8W5At5s4SQSn8b+taAglFL/FdIC8oFfIZLQdeYy0F8B/4HWeqqUygD/C/AGUvn/ba31k9/0/MkNAPjmQe9f5rrcEroMhvt1jmIwr21YRMnnjFpKsfbfhDQnVAhxb87KZgwJMN4YYjCcSqdMNoB2bVEodPsLAyZ5Icsw0UEqKSZTSLlMd5uEjmK07OJnFcV9ye/VJ+eEgwHO7jZ+o4h2bfysTeawD6cX4knYWuP4hzUGO6LnzbQUhf2EMWxzDW+lyPnLWcFLH/jkvxBHrLOxTusHG/S3LYZXPQgUuecOKz+XGEl0KGyfRlH4Ke2eYZdYtQrhRpP2nRK9HcnmVRqqXwWU7ncIH0jwSjzcDWp5kWJGRE+70WD0nR2O33O59qOnDL0UBx+tsfknEk+pZ5787HJDcL0RPCyOp9S3duhfLXJxR2ie2rMoPEix8vMxzseP5H3b2mC628TP2mSPhvDgGSiF/8Z1zt7M0X3Fwy3MQGmsB3lqdzXVDw4IDgVRoa7vMrhRRgWa/N6A8LOvULbN6K+/TveKQ+/V6LjvWZS+dFn6aCSGv4jFYzdq6FqkCDo5X2iPnfygynATZvWA1IVN5T6Uns6zhe1KRXr8mTSznQapF20JoykV6X13m8GajZ+D7Kmm/HRC6tm5hPSUS6hKiaBexOqNTRESjidG/jrYLTBcsZnUofREkzv1yD6+kDjIbm+eiZHNoNtd6d0PBsZBHW4ticJLa+xZiD30cE5EporWZpNYGAiXi1CvojMu2rUJ8i5Od2oUNWo4Rg8FnaIjBheISsbkbJSL6FxaXiPropWSoaxCeFTnrbmMM27NplOo6WxeuWdFnIHW6GxKiKdegDXyhCrqB+hsmqCWJ8g6OH1x78dB78rzZS4XKXpULisyUNuWlmKEvEjmCcTS01hVpCP8TFw86pk39zPxbcJB27/3jRLPy+2abzwZXL7+sicF+EaoXFyNwLzNA4lBVIIhFLePYqQEjjOXgUY/Y75gcfLQdGbCqY0cLWaS+BG6wnUNS1yyRV1mjRxBxiLVEcKhOr4wmar2UgNvZ4lZySV7ODApTFRLTDcrDNZTnL+uCUs+uScplj72yD5pofePsKoVxi+t0ttNUbs3lufeOxT9/8Y6g9fWOHvdwSto7Kkif6hp/GqAc9JBjybo9SZ+NJB2zwaSWJVJw/Vt2i+X8bOKaUXaHfkDTeNjQTzEzljWRH9PoLGGY1kcggBrZYnhzSbtWy6TmiZ0ofKVDK3DJyIh5fo2XjWL0hr3oBOldXlS9b6zzvmrNtM1j2x1zOxpkeJTxdLHA9SvvpKP8Oo2k7UiYdoi96xnNqPwnducfCfH8J0xpeKI9nGJ3FOX5meeaUXFMldvtULoWqT3LggOj7GyGU7+8DbDdfi7/84/5e8/fYfWgxrNX0L10w764VPjjWCpHhULGlod4f6US3iv7nD8TpbBdQ/ckMyzNPW7gQTDRLMNu1mXhS7loiI3qZGBvrXD+asuk4bG7SpWP5iKfDVSS1mVMsFKVRasdm+esFYpo1fqjDaL0TBf1FC1L4fYj48EkxDTN6sVqUYHwzmjJzIBeht1ZrUU9iTE6UeYhpNz8WdMpiLESCjwrGwWq14jLBeYruSZ1F2cSUiqJ9gRQ8cdymslK/2YKaQijpa3VMTPO6hAY3shahZKoll7aPwDznJTJNcwT+HyA6nAM2mCehHlRzME1zZwOpPylXKhUTXEUgJtUv50PiNxsHEXYjyVxyQCZ+INzKxXMTYCDBguzgiIuw9x3sC33wlMQvWT0gpYcgAAIABJREFU6MtfRjaY67I6KPln33RdMpFdVhh9DSediKBMGsJgvikktcnJVo/KZiX8YTqTL2/kN4jNLiqbEeWPH8gXIhoM60JOKiAnTgySAZB93jMo6ZhDH5QyUoH0phIo73n4NzdpvZSlvwvKV9HRH5Z+OcC6+1QcyctNZptVelsZUsOQ3OHYLIz2+iqtd1fo7VrMKprCnqL58RDnrCeKhkqRoJhmVknjjH3D3lG2jb59hfM3irRelg2j/ADh23x1slDx+ttL+HmX9FEfDk/MUdx/aYfWyzkmdTktpDua2hcj3OdnC/r7WTmF2/Nwn50YPg7b6xz/qEb3Rkhlt01vkMW9n6P5mW9yCwg11vY63noFP2OTORhIq8W28d+8wfF3c4xeHWM7IepJjsp9aPx4n+DwxEQaWrUoV3g0IYz6+/ZSg+Gr6zz/mxZ/892P+eX5JicXZbb+nkX6/fvSjokkpEEtLxLS3ljmC56PXa/h3Vzn9K0c/WsBTl+UTM2POqiDU7M5qEpJFpNQS784lkSuLdN7pc5wyab77gT7KM3Gv4gym6NYTlUqElTzpu+uZx52o4a3s8xoLUOQVkwqFvmTQGIkn7QXuU3FAnF6lfHOKMsMy/2lEkHGIUhHGOXTvpxyW5055jhxH1u5nOQ1bNWYVRzxXATgDnzctrD3TR7HSCrmOBPXiAvKBZn1ZFy8gkOqO5P2X1RQMPPmjl/bljlMoyyL9syLWFwRqn3iExTTBFkHaxZiTTyZMUSnG5VOQa0iprDRZMHhq6slk4sQph3sQTTA9UNBQPf66Gl00kkLnynOSlaOY+IfY/FI3L5emANEa0z8/n1raKDvWr9rFsXLvG6DFEj08L9GCU2YvBY2hG/YCL7Wb7z0d98YRxm3iOIFP3YLJ8JksCz5f9uCSmk+2ImqllhKahXywv+OUbDTKXG+qMqkCRolowayIi2z7g+j55EEIme5ib/ZxC+mpF990iE8u8Cq1+i9vc7JOxZ+PiTVtqh8pU3cYDgcG9zBpOGiLUXh2RD7yaEMlnc3uXizxqysmNTAGSEZtV+dyU2wvsx4s0iYUmROp8KpOT4VWeD1Hdqv1RhsWkwaGmsKjc81lZ/PWyV2rTq3y8co5nYHa2WJ6XaNk7cyTBoaZ6zI72vqd4fS3+/2ZIG/usl4PU/oKgpftsxJwH/zhmnV4IQwtck9d1j62CP3lXgUlOtgbW+gc2mCrIvTm8DBsSxub95m/98oM7o9oVwe0TkpUv+5w/KfHeE/e2HmKrooSigVnVTC8QRnfZXBa2sc/sDGLwWQDXDOUrg9xe7fe2aC42dXV/DKLm7XI3XQNlJQZ22V/nc2aN9wmNRl03SH0Ph0RvbDx6KHLxaEMgsLbUMrn4X1Fbp3qpy/opite1gdh8KexdInY+yf3QXA3liVmUyrK9GavYFp8/SvFpmWFUFKkeppii8kayI8uzAtGitiWqli0aTWxSdPf71OkJd7alJzBT89npkZhOHxxIYr35PZwMqSnBRKkbkyrQxXKL7CXt/gVJLJXVgWVqMmwohofbBmgUhJhxOBrUVqPDNTi2cCUbsHpcC2zEBYK1HHWV4orZ44sCmKGFWlgrSJYgnnzBMPQgS1U1rUe/HJQU0Ds8Go4XjOAYuRD7EKyE19Pfnr8hwxyhsA5rRivkUtoPdSf/B1S/elaX5yIHt58f9/ND/4dc8RX5ee83IMW/y7xX9nTCpxsEOEcdDd3uLwN8JEmNzifn8uAauUCCt51MQ3DkLVl7i4OC0sZsXoUgGdcVF+iOqJNT1u9XR3UwzXFM4Yqg99ip+eEBwem6p3dLOBNQ1RGtIvJEkMx2H28jaHP8gwuT5BDx0qdx0aX4xx7+2D7//f3L1JjCTJmh72mfnusW8ZGblnbV1V3dX9enn9lqHI4Yw0okYaSNBBFx2oE3WhzqIAHQWB0I0nQhQggQIIiSeBHEnQDCVoNHyv37xtXu9d3bUvuUfGHuHh4e5mOvxmFh6ZWd1vBjoIFUCjqqMi3SMj3M3+//u/BaxWwexWC4uyRRm335yZqML07i669wIMb9Fws/o1Q/VBDO/B8dLJtNkgu4C58s+fTA2Ec/b9KnrvCLAqVUfO4wB7fzwiKqNlmc1h3nBgT4Xx9We+h+SDmzj6oY/43gycC8inBbR/KVD+rAvx5AXBA6UizRaqIdFrlce9Nso7/WEVs39zgkZpioPnDTR+YRsqJnNdoNOCCByqBEfjZXTkRhujOzUc/Q6DbCyAoYPyQwvrH+nglTlt1LtrpluxHx8t1co7G+i/U8PwGkd0PQYfOKh9wUh/oD4jXq0gvbFB7/vBS/rcXAdsq4P5dgXTjov+HdCmMQaCrgq0/1olpV3bIfvpk56JzbS2Ooj3GhjtekiKDJkLVB+n8PoJ3MdnZESoGE88DGnhyVWdzHbMMZKCDWkDViTgH0zAx1NSgmvPrJx61RxzbxvRHsFm0gbcQUpD68HIhCrBdZZxnur+49WKglktyGJI+cAMJqVLzmPDmzcmdoVw6bYZRZCZML4+YAwycBF1CnDGCXgqYI3mBNnMY6PTMTkAwBLCKYbIaiGEZ1FaGAOc0QLWUA179cBWU74VJZb0A6kRf5kEMSimkdIBmKVI0c31Z7hiYW9ZvzUN9P/fG4ByAwVy1Eq1Axr3zleFvnzHY6Xaf5WZHLC6CbxKh5A/P5YblAmoAS6HUes8AXURZr3+MsC+VASqZeUTblGrqBwzZTQ34dL6+KxWgSiHFIKdZSRKcWxk9QJG+yFSnzjdpedzWB8/oGGecrWMd+uIqzbl1N5/QRbPxQIW39vH0Y98xHUKRy89stD8nPBimaZIb2xg1vHAU4nCwxHw7IBorNUKovf3cPRjG8n+HCLlKH7lofFFgvDnlK+rsWZ4rknrgpRge1sY364RBXRLIgsk3AFHcAI0v4hg/+ob4sBvrGN2q0VVWZzBPegTxl6tYH5vG8//bReFmwOMegUU77tofKZcUI9PYFWryN7YRlpw4Azmpo3XnYR4cx+n7xcxvCUgSyksP0Xh5yE2/49TyBeHpM9QaV9Wb0JhN5zBajYwv91B77aHuAYkZdr0Gp9IVL8cAg+eGTZR0ilDcgb3ZALx6JlZfMdvt3H2PRvzrQRgEnbPQf0zoPGXPWRfPTSfm6xQl8imEf1OlTLSO3sY7weYVzncsYRQl2n9C7L2FrOZqcxFrUwzlZMzetGtPfTuVTCvM/h9CZ6QzYMzmAOPXhjbAeNppbBoEc1NhkXSriDqUJ5z5jJSIz/uE9FAL/JaZaspizmdjGjXMXyjDHsuYE8zeGczsOfHxk2TuQ7AuPHGMirheg2iFCArkpeOFSWX7pc8V14fh4UBXX9ZRoWZ5yKrF5EWXaQFC/5JBOFYsM9GlPg1mxnvfxb6Js/bzPRKBYKrKjakxcAyieBkTkrf6ZzcQYElzq9iIaUQSw1QTlvAAjqHyTSfRRdU0raZfeqZALAsSl+bDeAH7PcvYe0AcJGOeQmWuaqCzz3y7qIrVT/jxvd/9QdWBWN5A7l8glDe/uGig6hOEMtvVjpAwyzm5SJErUQBHS+6kNPp8ksGlillWkugFn9ISeHx9RKirSKSggUrFmSt+6y3NBfb7GB+q424asMbpLCnydIWuFxEslHH2bsFzDYlwiOG2v0YwQNqvaVjI2uWEK37EDZDeBTD/oIGl9jfxvR6GZOOhVmHQdoS4SHD2q+JiikXC/B2C0m7AitKwEcz4vRzBnbnOo5/XMXwTgbeiCH6HgpPLDQ/TxB+dUwwEVR+cKtKg7Ru34iD7E4bg9/ZweHvCexeO8XpqAj7ozI2/nwE9vUzGiqrpK+s4hN+e9w3gSy81cDsVgujXRtRk4FnRIksP1M4+fOXsNfbSPbayEIb/pNzI2Rjb97Ai79TRVyVSOspIBgav7Ioe+DhCdLDI/reqxXITpNshgdjcgN1HYh713H6XhHD2xlkKQUbOah8zVF9nCD41WMTx2g1GxC1MvnJvDiigaUKdR/vOMg8Bv9cwBtkRkWtCwUWBuTomWWQs7nx9dd5DbN14u5XHglUvhiAnfVIl5JlVClbnOAIZWsuFwtY9RrS3TX0bxcwrzNYMRB0BcqPJrCOehD9wcp1CmAlTY8HgdlMpe/QfeJahI+fni8tj7XgKz/YrVaAJtFapc0NNGMNKOlLLhJimgEKL1ee+Z67DFZRg1edt2zgmUzBUgdnYMUQcjxZLS5zVhHMcSDLRaT1ApKKi8wjYz2vu4BzNqH1x7FJ/Quy/2bTaLn5aVeAGVFCzWdl27TJAGazyNtKm8HvhYcWxgGvEQT0XZnAK49vWfAvPfJwz6XjXNFVXPQi14fJRUgCwEXWUJ67zwqFKwMdWKFAqsz8lzqPqSvQodS59yRmM+Kg5wQjsCyIko/ZZohFkSM4zxA86VNqlfKpkTvriFuEawZHU1hdaq1luUC2wJs20iLAE6D0PEPlo2cUYL6+hni/hczj4KmEex6ZZCW23UH3wwYmmwxMkjdQeEZxg9ZxH2I0NphsWnLh9OfE3x+OYO/vovs7HZx9X8DfmCLqhghe2Nj8SQTn/oFJ1bI21mmTA8B7YxOYrjn4k22OyZ0YzJKwDj1s/usU4U+/McKybL1GH12cgR2fGagmu72L0bUQkw0O4QA8AyqPiIIqn740xmxsq4O0XiC18DOK3bSu7WD4XhsnHwLB9RGiyEXwmxBrfxnD/Yv7NIwPfPB6bakwHU3IFjsg+4aD36ti+m6Eem2K7vMqqp/bWPvVGNbjQxUTGRBTTIUD6aQwq1HH7AfXMFDxkDwFdTl6HqMsCXhxqSbXWhKAcP/B9ztEf60KlB5zsgz/5AXx77NsafPgKZfKRMWaeh6wsYbJzQr6t+ja8/oSxcMUhU+PCOZRsCSzLFrk1c+S5xEzzB5ZCinyNFoQL346XUIfOsApjinHwXVMnkFWL2BRcSFtBntKflGsPzJQDrP4Siawqfg5h/QcyIJvNhwR0Gvs8wh8ODFKW0O3Vow7MLZ079THcx1kjRIWVQ/S5pRvvEgNe0u6DhUccUoaAiGIKDGZmc+E3h8j0kcQEMzFuYHXTNhMzmQOAP2bRkVyYlZdIL8eiWB5GugrrKDpuasdPi95A/0VNoeLi7h56O7gYjeS7xr0z+swmoIaEKoLU6ZKPRiGQIVuNG1XrAc5OuWIFULTpurACFicbAi0lYCUEBWSz/N5StX1wZFx3mTbHSzWioYSCSXJl+stRNsljHdspL7Ka32xgP/NCdKDI9idNpK9NczWPYpQPOhD9gc0v7izj9PvlzHZIQ/76leM/H2+PDaOp7JVpyFYRkpmLb6yd7fQ/7CD7rsMYnuObGYTvv5Rj7J5s8wEfYjApqCbsx7ZPCj//fN7RcR1hkVVwopI9Nb+vymeEoBJKhMOR/BiBPnkBTFq1poY/nAb529ZmHdS2AML4QlD9UGKwjfnkAfHBmYym844Mili1u3rOP1xA+cfZCivj5GkFuyPyuh8NAH/9CG9Zn2NhsIqbSs77ZL1hKrYu++4mNxM4FfnyB4UUf2GUs7kl4/ofEUVMMI55CyiYbRlwVpfw+zuOk4+cBFdX8B76aDyEGh8dIzs8XOTN8EKIW3s89hoLjS7qvtOAZMtIAsknBFH9aFA/WdH5HYKYmFRhUxMIgBmAebtFqZvtDDZoFzl8JTUvt6nz012Mi8E5hq/qKS36lWCNpUtCotipXCdmOGxDlfSehqZZeDlMuRGE1noQrocaWDDjlJatHMOusyxaYPS97wiUKBaBgBEe1V43QhZkXx3Ms+CO4hhH/VJMRwvTJcgAw9SdfZMSoKJdNALYxChD1iMOpBJvKSjFkPIwDVDZ1PUacGmEMYAT8dFokQbNYsXRNHODXWNrkgNuPXzeSfifIa5zhb508k/fU02gHwHcHFIexGWuVCdv3ID+Ot0CpoZlPcUunAuHviGkSCU9FwzMvJpYcx1CUtUzKa8n4oesLEwgKwUqbLRroCeR4wPJUJh8wVliqrKBkNK1YIUVPFvtiFCmnXYR30aMgY+WL2G6RstRE2qfoJeivDJkKreeWwW/qRInOng8TlkfwgWBkh2WhhdCzDa50iLEqUnpHjlXz2l999ZQ1ZXGarzdKnqVN4789sddN/2ENdo4c7HLOrNKq0EEL4FexSDP1a6g3YL87ubOHvHQxqShXN4IlH7cgT+/JSEYdUqxPVNLKo0m3Bf9iGPTqkau7OPsw/KGN6UyIoCPOKofcFQepEg+Pg5MZ2UulRUaLNkvSHS4xPqwO7dRPfdEs5/vECtMUG/W0L4wMX2nw4hf3PfQElJuwJrtjBumZqh1H23gt7bErK+AAYuCi851n82g/2bB0QDrZSBtSbRCM8Hy8HsRhtZq4LzeyXMOgxRW8CeMtS/kGh8RAs38z2wzhp9/sYjSrF0drcwudvA+V0b85aAO+Dwz4Ha/Rj+ryme0ioXweo1SNsiFlOuEDEQ2c0m0oJlsG2WZGqgHS2zgW2b4h11B6ADV2x7yZRRi5yBNnMzsZXbTpMjGlVkRQ9xw0dSssje+uUQOO8TdVJcUdxprL5UgPRdk6s9/PEu/F4CK0oNNo/hhKp6xwVqZZPSxZKMKnmLQ4SuiXRkqbjM/1eblqwUicW2SMDGU5PgpX2TzCBbQTyGOZQSpKyvQU0B1bniF/VFKwJW/VldmAm8Ph2A3gCugGzyVNCrIJhLi7f5wd9iYPxtg+ELFb4ZbuWgICCH12srabU7G7EK58TthXJWzFNH9UUTxyZTOCuqikRI8BenRkauZw9aSMMbdcjAWwbQ94f0fpt1RDfISpoJCf88ITfRwxPywlHhJ3HDXwmcZ66L7I1tdN8pYN5gSAOJ8mOg9k0E5zHFPPK1JtJ2BYuqR+EcT49o4FsIwTbaiPZrmHRsLKoMzlgi6AmUf3mA9OCIKldldWDNU5Lyd3u0ODWbSO5u4fjDAPOGJJjmAVC7P6XQFqXqZXtbWLQK1OUcjyGevqDiYKuD7o/X0H1XQhZSIOUoPrax/nOCmeR4QgtNs7bcVKP5Egq5cwPn79XRuwek5QwsYSg/sND58wHw6AVh8btbJsXN6k2QHR7TNXFzF6M3KgZqsaeUx9z4nOyzs/Me7HYLshBAFnwKNDnt0obQbCJ+ewf9my6SMsOiRNYcpZeZ+dx0+Hp6rQOeZMt5R7UKudtB1Cmgf9sx2QPBMUP7F7MVpTCrliEqBbBJRJ/5aLIMQ2nVkTaKmLc9ZC6HFQsUHw5NNwXAsNzEbGaes8rF5WY2m5PqNc2oK8yJw4BVmFQfj9drSLYaEL6FRdlGEnI4kUBwPCf//8FwyXxRrBdDAS2XaKBbo2jHtODAezGgjbEckgbgfKAIGdSJo9NCVvaJPZcKg9mzJIN0LHLrzA2YWZKCjYhdxHwPUHGzkBLS4iTqBKiLYIy4/pzR83nztjQjw0Y96Nbdm6KpmmCpPHFEx+Lmhuh5LzL9Hbw+G4D1B6+0fr6kBbhK+AVcxuz10xdSxPKJX5fOB1yClvTwd2UonPcbsh0j7sqbxgFYcUBkYUhMgPF4xe+bOTaw1kRWL1Dm72C+tDMYTQyVTp/XXECWZRwmwThYMcRis4bZBsEx4eEczmFvOVxV8EDm2+BxBueQhoDM9yHbDZz9oIbBbQBMovyQof2zAfDgGWGXnTVa/DJBVdVh1/jPxG9s4OwdH1GHwkcoVGZCAS3drgloSRtFGgwr//y8B37/Jke0mcLrWqrbIEaNrppZvUYhIZkEOyKbYV6vYvr9PfTu2IjWJLJKiuCZg+pDgcr9IdjBKWS8oMWzXYW0uMnX1e6q2a0dDG8WcP4OQ1pN4b90UH0gUP/z50vVbLNOA3vXgn0yIEFYlsG6uY+T322h/5aAf2LBngH1rxMUPj2ijFtlqYB2k6rJswEZ6QHgt/axWCvg5e/6EI4Ek2rD+3JC0ZqqYkezTrnEoxk5kZ6cwmq1sHhzG+d3fURt+r6CUxoO1z7tQz4/hJzHsNbXIBplZAWX4i0Vr58Xi2AbbYiSj7jhI/M57GkGO8pgDyLqEKO5yddmrkscdaVBsSpl488jLQ77jMReEHIZvXrFfM2IHzfXkVVDTPYKmNcYWEqhMeHLCfhJz9gj5JOwACq0eLkM1CtI6wVIiwEWg7DJ34fHKcExcUJQVZbRPE51CGklgLQYrCiBdCwsKsQEsmcCznCxZBap1K/8Q2f1mkF3IYAoB8gKDthC0H0xS0gNrFIANfffZFR7HnUFvkedwGS6QiZZSRzUUJCmouq5gHYgBnVcrw8EZP3B6pOvUvd+F6yT2zBWAl++hdO/MnsAVjD+FQVybi6gj3VlcE1enKZZPGEIOZ8vW+7AX7omqiQhAOCzOcTJ2bLl1O11fmAGqHkBsQF4uQTRqCIreRCeBfdotLT1VQZjaaMI4VvkXHhwTIPTZh2LWx2MtzzEFQ7hAeGxMHRGMAbc2CGrhVTAnixMNawjHoc3C5huUG5B+QmxQ/DZAwAw5mTzThH+y7EZzNrtFuLbGzi/62NRAeZNAb/L0fgyRenXh1T1Kv99tOoUq6fcHkUUwbq+h94P2jj52ynKzSnGzyooPeZY+/XMhJtDBYmjUgQTEnI8JVaM2nQmb7Yx2rWRFoCkKOGMGNZ+E8P75CmF1jfqEHsdLKoerETAORgge/SU4Jbru3j27zcR35shmzoInzjY+ClpJrJuF1ajDlYqQlTUd6rgsby3z2SHvkZ7ytD8IkX4Ygp8/pCgROWJBMcGm83p9x6OzffVu+1jeFOCLxgqD4DKExJupS8OqTOsVZGt12hxVgJBMY9h725hdosgQeEwhGcp/BMV0XjaXeXO64UuTZfdq/YOqhdpI9ZalXlsGC4rrJVcUWVVyuR+2ypTipnHMGtxhF2B4pMJMWf0wqt58YraaYajxQLEVguLGomurHlGm48WWmluvR4Mb7SR1kLj3wOLIQtd03GwDGQXsVB2FdMF2IgC4OHYVJnrjWCR0EyuVETaKkMENoTNae41jk1XwSYzRfzIyNwty5YLv22tVPz5WYYeBufXn/xw23QxymcIUkBmAn86+h9ekw3gIgvoKgz+4oD4Crx/xU4aWFEUX6X8XTnOhU3gUkA9lu2ZEaflh8L54+gBct7dVEnfDRMAIDaCumiNE6hWAeYiJldSjEBtpAmYUOfXPjo6xBzNupHI24MIODylinqzg3i3jt4bHiRn8IYUEO4+60L0+uDlErKNBtKyBz7PYJ9PINXwkO1vI2mGmGx6WJSITx6cLuA9oohGAGC7m5hvkGqVpxLe14fEY282sXhzG6fv+YTvx5RpHJxnCD95YcRZvFmHLIbU3Zx0TfqZ3FnH+btV9P6tOf6N6w9xv7+G8f/Txs4fn0M8fEpU0c0OpOeAxYmJOpRpQud+axu9NzwkZbLGcAcS1cdzOEcjyKPT5Xk22xBFl0ztznrE6AlDJB++gem6i9MPAVlfoPILH+VnKQo/fwIxGoGXy8j217GoeWRl8LyL9ODIdBqnH5Yw2ZJIyxnClzZteL98ifTwyFgiSMcm4ZYKI9GQXfTuLgY3HIz3BJwRhzsEOj8dgT86QDYYGNdNM9cYjA39FbubOPtRDVGTwR0D/rlA+ckM1sMDymyOY3JRLZdMDrXOs9AwkWaWWYmANVkYSxKzQOe8efL+PqxUhOw0sWgEEDaDcDgyj8GZCjPg1dm5iBckAJvMiEWnN4N6ldTbBfLtyqvjjUumlCabF7YFUSpA+jY5d8Y5ODkTEIENyZmxeuDzdOnXwxhEiQoeFsWQYxLeycCDqISQFjeMImuakOWEsmlmKmRGpqkJf9f/r3O/DdtPC8OEoI0rE8tNwLKo4NMiUf3eFXtIRpFhFr0eOoBX0UBfYeWw8hIFv+jX5w3bXun+eXHjAC51FVdBSGbxv2oQfdWxLswzTAur4SzlbWLgKE5QEbCsCHQuMa9W6OIWxFGWvuoMppEZtukIS6tRBxqKErlIyOJZwTXJtXWcv0U3IyTQ+HIO96uXyM7OYZWLENe3EDcDsEzCPxxDvjiiKmarg+haHb036HPhGQ0Yg0ddiNMu4bKtBqTvQoQuDQ+Pyd6Z2TbSd29icDPArEOzhcbnEtXPeiYGUqucEfgkvJlMCQaplJHd3MLpByUMb2fgjQUKhTnGz8vY+ROB4M/vG+O4pK1slJ+fkdmeGnRHdzoY7bkY3qD3XXwO1L+I4NwnfJ7ZDni9ClRKtBBJudxIq1WIaxvo3Suj9yZQutXH5KsaOj/LUPzpI0Pj5K0GUXU9F6w3NBW/ePMaDn6vhNl2BgggOLRo4f+YqJTMtoH9baRVH/ZkAXZwZrjtVr2G2dtbGNx0sSgDkEDhSKL25eTSsF86NtkOzOPlXOPaDk5+fx2j64DkEqWnHM2PZySoe3lkIAc9B9CLWHbapU1TFRGLrRrSggVnmIAvMlgPXpJvTZISNq4WrbyHDa9WIFt1JE26njOPw+3HBJXM0+U9qL1xdOdgWbTo2hYQ+Eg6VURtD/ZMwD+akIXzeAo5m60UV1pbIz0XcGzjUyVsutfsKDNVvl6wpWOT7bM+N+eQ/QHQbhkbZ5QK9LsVPWRFF2whCCqSkjQF8YICXlSkKzx36fGvrNCFspU2FjCAYQuZRT9vDKfh6nygfS4qUkwVPdx18Se9/+712QCu8ujJV/R5UVY+1D2fs7vy+CvaSudzgpljXwn7XDr+xU3qFRDVqlAmWfU99z2ipKk2Ly+bN2yBBuWlsvHMfBZyMiXOtTqOzprVKUxysQCkJJfFegnjm2Usihx2JFF+NAF/dkIYfRganFtajJSvalGXt3Yw3S1iusbJ60QAxcMU4UMKGtHdjCyFS+sKNSi0GnXIjSbOPqxivAP4XQa/J1H/bAj51SO6iJU2Qgbukoa5WNDPbrVx9v0KxnuAtACvy1B+LlD+cgA8eUFbBOVMAAAgAElEQVQY+819TG7XIS2G4qMR5P3HlO375jWcfr+EqC2RhkSFLD2XqH9GgfcyTc0iJT0LfJ5CPj9cpmFtdTD4XhPnbzPwmEE45E/U+CJF8S+e0obZqANrdVpQlP00c11Ymx0M322j+7aFxf4ckAA/c8kN9F89WJq6FQvE6nId4OiMKvFKGYtbHUzXPQyvEQOLKwfWtY/OIR49oyoy8KkyDmizxdEZ5R1XyhA3ttF9p4TRTVAWdI+j+VmK0i+ek6bDc0kwBlCRoURIeegsubuFRcmBcBm8fkKd4MNDA/XouZSYRpfU+6yzBhm4WDRDsEzCGcxp+Hw+WN43tk33sW0BvkfdLOfkt1/2ENcUq20mwBNBmcgnZ0sLZ+WrbwgZlaJh1YjQxWwrxKxpgadA0M3gDhZwejPgfEB4fiFYsnAAumeVDTevV2nwWgyR1YuQFoc1UBGSSUrW7LZN3x2oCDM6Ah0TOyOFMgCaQ+jcb80G0nM7/R6EMGwiGS+MB5BBBvIGkq5roKDXZwPIzwAuwC3AcpFnnreC45tNAVgdGF9IE8v/+8Xn81GPQO6ivqAFyFfqZFCVLF8HXD2buGpQrWcLeofXgRJZthSmME7DK5Uhi2hOfG+dD6q9VjQn3PPoIlLtIXMdCrgo+UhLHqDemnswhDw4Xg4o1xrq3AIYjCBnEXixgHS7hfN7RczWSf1ZeZqhdH9IzIooohtgvQXp27DOx5D9wZJH3qxjfmMNs7aDRYlBWAzVRwuiYU6mYIEPsdcxNDy94cg0hbXZweh7beNhnzlAeEzh4lpYpofC2nnSPZ1APqVA+uTD23j2hx42v3eE0dzD+H4d7Z8LVP7yGOmzl/R5bW8g2qcOKXjSN7m/dqeN2VsbmGw41KkUSOVcfpaicP+MPPAHA1jNJtBSHdZwslT7vnkNUSfAwe9ysJTB6zFUHqvcZDVYtVoNyHX6zHlvjPSAoDUdtHP0N2wsahl4zNH4hKHyMDIWGAAoErFZhnQs2Kcjo1uwNzsYfriJ3h0L0VYKcIniQwfNT8kMT3R7wLUtzLZLyHwyAORPjyieEgCvV5HtthG3fCQFC6nHKNf3dEpD5cViydsHVqv9MASrVaBjD6Xr0KY6nlP053iyZPJoCASgTUAJvqZbAWZNDuGSN1F4Iili8gVx9xHHK+Iofb/xeg2yFCKthUhKDiQDskAlhs0EguMZ+GBKC69eNwKPFmFfLb6ZJBaTOnbaqRlmkLF4iHJsIr3QK3qqvh+0wZtRIysnYL3wy9GY7jP1uzPbWtpAKz2HnM1WoGRD8y0VSROU8zsC56/xDOAVC6cWW+X9dlYGvBcX/1zsoznUhcGtWYxV4PNKSHPOnjrfdQBYYTusQEbf4jvEA73ALyleGvfn1QrQqJqgCNMx5Gyk87/rSjUAmhUgy8ArZSTX1hHXXDjTlMyyemNycZzHxPlu1iEKAXmpDEbG6lZurmF8s4zhngUwdSM+m8P58iXBOb5HGL0y5WK9oWH0sJv7iLZLWJQtJCGDNxYID+YU3v70ham4swpVj/bDQ2NFoLUDp+95mG5nKD614I4kpZF9/cIoa/n6GrGBUkFqYWVcZu/v4ugPOuj/YIEf3XqMB/0WJr9oYu9f9CE++4aGv5sdxDt1JEUbfncO69ERsm4X9nobk/d3MLhuY74mYc0YwlOJwlGG4hcnZvHlYWiohPZBb3nuvR2M326jf9OGM5GQnKH56QzO6XhpSFetGG0Hi2ITlWg1m0je2MTwRoDxDllr2DOG5mcJwp9+g2xEVaSm2Yqit0w6O+/BajYxf2cHpx94sH7Yx+i0iOCZg/r9DJW/eAHRH4AVCkje2MRswydK8HlEQ34AvFnH7HYb84YNngKSAf55Av8p2YrILKPfW1WkYjwh4WEQULGy1oAIXWQFhzDxUUQagOmMLJjVAsZcd1ncKHsEsVZDtFHEaNcm628BBGcS4VmGwrMJ5V1HkfHK0V2tTFOz6aTNEhY1D1GTcH07lvB6Cdz+HHw4A8uEmasgk4DNgVTds0JAcg7pLZED4TtISg6sOIPTn4MPp1Tx6wpf8/OBpZhLL+Jq8edF1dUWA/DhdJn2pQs8XfkLQbRZtT6s6B30w7KWrD8p6V7VwjHgNdoA2O9/J7uHqzQdZJnBu1dyfS/aOGt4xXUMwyGvrHslFfRV+oG8KviCsMVQu66wkNALt96grnoNLxaIFcQZ5HBEN/4VAjQ6+SsEMS7BCWmrTHYMwxj8IVkp53FuCEFUuV7fBI8nO01MtnxELQ4rlvD7AoWXEXHwFRWVl0vEhU4zSo5SQ1NtGTBrWcgchuJxhuLjMUVEAvSebmwgKdrwuhGsw3Nk3R4J565vYXirhMkmR1Kma7T1MWkHsuNTwrIrZYLAlIpSu03qmcXZB2X03xKwWxGSsYfGL2y0fkaOmNpKYrFWABMqNObwhNhT+9s4/+EaBeUUM7gnNmr3JSqPZhR+Mhotg9WLIbFAopgUqfMY7O51RFtFdO85kFyzoKawu2MKjFGD3aRThT2IzGxAZhmsehXpG5QNPLxB8FjxMEP5yz5weIJsMAQvFGjjsC2jENf2yrxaweKtbZy/6WN0TUB6EoVnFjo/ncH++oWxORDNChUbNidNyWQKXi5hcX0d/dsBMp+BpRJBT6L4dGpYQ2bhV2peTQPVm3DSrpBa17dgzzM4x+Nl/GfOAReWRdemtkYRErLdwHyrRDnWFWZiKsOTFMHRlKigmv5YIDKAGI3VfctpLrFdQ+ZyCIcjrnAVNZmS4+r5hJhjnEEWfGQhdRz2aA7JGJiUkIxBehaSqoKyHHL0BAe8szmsYWTC3A1eP4+NUynjnO4FgO5Fbc5ocar2lQuoLiZZGFLFzzk9ly59v8zQVz9ybD/me4ZVZIRsaibwerOA1OMSE+dCShiAlUHrysKaC2XXfvz69RdjIr8tB0BX/vkoNj1z0MlGAC5DTvo9XpVJkJsJ6M5jZXCdG2ibYHnlD5SXgzOLKwy+QAt7JqjimBIWzwsFwmQLPtg8oSFf95zYHa0GRu9vYNYiZkZwtgz41lmtmtKoPW60NbXVqCO7sYnztwpIQwZ7KlF6mSD85gyi26MLut1Csk5Ysz2Ml/46jTrit3dw+i6pfe0Z2RgXjlMEv3lm7JL1YNVk1E5n4L4H8fYNTDcDnH6fI92g78R4A/2Kft5q1CHXW0gbAZ37qEu4fb2Kxb1dHP/Ax3QvhVVKILoeGh8ztH5KFhPaHE13Omw2N7MNXipCbrUxuFPGaJ+uv+BUovoohvOrB+Y9skIBrBiSrXBENg88CJC9cxOTnQBRiyMNAa8nEXYzlH5zZPQazPeWi2aSIOsNoNO22EYbZz9uIa4xzDrE/6dOKYL9zQFlKlcrwFqdFv3TPnVolgVrrYn57Q6G11zM2gzClSg+A5qfjMFfnJImRNuaK8KBnMfUfalzLzbKmHZcZC6DM5MofzlYprgp594VxWre86dSxGKrhsFND3GVofRcwBuksGIB92wKqFQzY72sbCq03xKr1yDKIebtEEnRgj0XYBlgTxKiYh6fm2AW6VhU8QOQvlL9pgJ8RpCxCF2kJRepb8EZJ2CZBF8o5XB/tOT8ey51Mwq6ZIWQrsmcjkeTMiSnxV/nIJhZjarixWnXLPrGdVW5luouwrD7LAtM32/zmBxRC2QloTcimaav2QZw0dsn/7jKmycP81xI9loRVCgsTT+uFImp4+RpnaZ1Vd4++YGrgZX05qSH0PnMgmSBSxRR9bCq1VWfdXXeFal8zvuDeZ6BelgQmKpwNWZuajoHHobUUVTLVJ2Mp0r05QG7m4i2SxjuO0gLQOm5QPF5BPv+c6IU5joSbT0hp1MKqC+XsNhfw3jXR1Jk4AugeKgW/pMzE2IvKiTU4ZMY8iVZS7Ob+xjcq2JwixSz7oCj+s1SvCQmE1po2k0TUC6PTk2SVnp3l9Ky9gRELQGb2Cg8t7D2l4q/3xvAun0ds/0KhM1IzarcMvnuJk5+fx29Hy4QlGJwLpF+VkHnowXC+yfEoQ988LUmzV1yA21m22C7m5heq6J7z4ZwAUig+XmG4GgO+6unpKzVvk7qJs2GxObRs4XxloPJLn21zoih8VWC8OsussfPl0FBtYoxetNiLLbRhqgW0HtLBbcERGENehLVXx1DnJ0vRU+hT95RoynEeQ/M85Dd3MLoRgGLEkNSYLDmQOkgRfGLM8ijU1NcsGqZNrw5dTlkRkg6kvlOFXGdMHZ3ksE/nhkoSsaLpcWJvjdzGRhiew1JxUNctWHFEsJl4AuJ8OmIsHfFIpKKe8/ixJAgNIa+6JSJdQMAFoM1VYZ3J4MVB1EWBpChbzYTMmoLsKh5EA4HkxL2LAOfZ5Au3U/O2dSQK1ZiGXVKn7Z0KARLCwhlzaI3SS0U0z5e2v5dV/xiPFl6f4Xh8l72vFXNjzakG42NQRwPfCJ3hP4SdpICcFz8yek/fk02AAUBrURCAqsLfx7quZAVDGC5EF88zgXjuEsxkBcfuurXAQ45qbZZoPMdhD5njkV0SSNw4fgmEzXXgZjhshaz5ARt0HzsUoFEKkkK9EdmGEQZojn/9FIJSNMVPre1vob4xhpmay6EDdixJKvnbw6MdbDOLkCWmUwCAODVCqY/2EcacsyaxCQqHKcIH/UgD46NK6UsFyEdG/x8ADGi6s3e3sDwgw2cvs+R1DPYAwu1+0D98zH4owPClBXUIapFWvhVyD0PArCNNobvtdG/xRFtpfBOLbKo+HIC65vnpqtY3NvFZMNF4TiB9/kL6iTefAMHf1DH7P0I//Fbv8Ave7u4/9k2Oj9hqP78AOnzl+Sfv9FG2q4STfH5KeHrir8/eKOI4U2ApQyZL1F5ADQ+HYE/OyZfF9ehLkyFf5vPu1nH7O0tjPYcRE2yEA6PJYpHKcIHvaW2QvHXTb7ubAYwDnt7A/F+C9Gai7jEMG9R1RyeJDDW38oBVi9SOuxcJimsm/vov9/ErEVCPXLzTMg0T1lNW+Ui0R4XCXHVB8NlpsD2BhYbVUy2fVgLCWdKjBzveAKcdFfiDfXCZ8gJ1QpYqYDFRhXzNU/ZIwD+aQxrHIMPJ9QxNMlaQ3Ju4ht1Dna0X4O0AGsuTFqX9+CYhrgq8QvAcjEtFSFD3+RLp1UfScmB8OgeFDbNGZxRCnuawhrHhgZqEsKkpBlcTIpe5rrkZupYS9pnJpamb+oe09g98zwqvBzbZGAYAzt1nSDwyY9JM4r0w3Woulf3Hn2QBO/mqaA6dxxZ9hrqAK5Q0/IgWGL/uUzgleHtPDYV96WBLLDK0c9xbQ0rKLdBaAm8GdLmjnsJCgJWh8ycGfrlCi31Ck8hc1wdJpNj9uS7EHMeVZGzTEAORlRh6o5HZxA46vUqs5U5NnilDFmvIGmGiGsOvO4C7uFgBVZhBXKmNAlkqvLQFhCzdQ/jLQvlFxn80xjuk1OK6/NcoFqmfFxljpV1SXHLtjoYvd1E/6aFpCTBU6D6NZmbiZMz+m7Xmkg2auTdr/OOZzNDAx1fL2GyaYGlgLWQKB6kKHypql4AvFFHtlZBUvVhTxMa7J73wO/exPM/quPdP/oSf7t2H59Mt/HHn76Dzf/dQuWnz5AeHcOqVoB2i9LVLlApZz+6hcFNB1FbgqWUttX+tWKlnHSJqtpsqDAf22xYzHXBtzcwebOFuGwhajEUjsi/Pziagj07WuLCrkv5vsCqgK/dwqJTxuCGB2kRRFY8XMDtUniK7iysehXMccicTcU0WtUq0Kgiut7AZMOBM5PLiv3ZsWHkmA4v8Chw5vAImgIqdtaQljykBQuSMbjjhGYnR6eGdCBn0RL6VMWaCZJpkvqbSSDzOXgsYM0zygdWimOZpLD3tmHC0gFIz0XSKSMp2kh9jmnbQvE4g3++gNOdERNnpFL0FFWal0tUpHGObK2CLKAc7UXVRlyykBQAbyjhjTLY04wyBTIBqzsGixUcUy6YTYOPp0sBl+tAKF8uPp5T1a/eJ9k9T9UaIVaM6XROsJxFBNGWlLEjQAu/0poAoI2EM7OZ6c1Ei8WMnXR+ncjFY74eG4BKBFupyi8qey8oDDX+rQdOFwetlzqFi4lfV8wNroSGcqH0AJbvQ1fx2sfjQkdh8o01VRRYbjYX8wdy1FStFAbjxpNcD3wAmEr/4vtlvrfMTlU0UF6tIN1smM/Dmi4oYKVHfGxeCKhyDAKimA6GtGGoIV/U8ZEElBVbOE5XA0iUbTAAEqWdD8ifp1JC/M4eercJ308V8aP9ywSFTw8MK0W2G8TIAMD7YxO4bm90kOy0TOqV6TRU6pRhA7UaRi2M8dQ4rVrX9/DiP+xgdi/Cf3D3E/z6fAcnP9lA56MY/sdPDXMGa3X63HpDiOEIIopg72xh8INNnH2PIalncHoWKg9AauFPHtOGqllQathnNixlXz3ZKyCu0HVWep6Qd/yzQ+NrwwsB4HkExaUZCdaiiGCB/W1MblUQlzmEDVgLoHiwgP/wdJnPazvglRJ9Z+Ox2Qx4GELe2cfwZlExsCTcYYrw/omxgrAqZcPEkYvEOHUCgLW9gfG9NSQFjsxlsGJJA+2jvgm91/bVYjQ2XQpApnCsUoaoFrFohhA2I4V5P6aIxfFsla6t7iPmOoDnIm2WkJTJl2e0SxYNhZMMzkQgeNwzKuH8+wVg0uZE6AM2R7RZwGTDBk+A8CQlCxDO4IwTWPOUFvEkNRnC0veICeRY1HX6HqRHpnDCJUdUa7YA7w5pkQ/8Feqn9uYxi7UUxlkUUB2J0jewKDYbhQw8Mztgi4QG/FFEvlXFAh1LCGOGp20w8vYv2o3g9fEC0h3ARTsFYLVi1zGM+Y5APYxbJ3AZ4tHGbsrK+RJVNGc3/Soa6cVOAMCKi5+p8C/kBb9KU0AHEJfeA+We2kts9QrYS3cJJmlMn5cxulhKBYhKCBZn5KXeGxjuNg8C8EqZKkdlWgYpYK+3Mf5wB5OORclTfQoId85mRnjFC+HlABIlqpq9t4vhNQeDeykggOrnNoJzSp/CswPqFho1JK0i7HEMftpfWkhvb2Cx10T/lg+eAMIGCscZwhdj4OHzJR5eKpI6EzBOojpndnSvgZMPOdj2DGliwXvoY+9fDiC/ekSQSKsB2WkasZuhd6qK/fBvWAhuDLFY2OBfFNH+ZYLwZ0TFNKIvKekmPzmjwW6xCFzfRu/tCmbrDPaMrBaqn6nELR3ergPdLct46hs6pdIljHZtSEYWGcWjFP7RxFT8hoJsWWCeSxYXKtBF237P65ahQpa/GYG9PEHWGxgFOgt9yNFkJXLQqtewuL6O8a6PuMbhjiSCsxTB4cRsXOa+yt1zzLEpa5lxoFZG2igiC22kgQV3nBhKKIZjk4mrk7aY60KGPkTRQ1r2MFujlC2p6qLwLEXwbEwwkfqcTIyi8tdnxQJkuQA2mWGx3UBScRCXLaQ+Q/2rKelDzqa0uC9IfMXSjLo1n7oEABQeJCVE4NBQOLTAYwF7mhKbSKl4TSC7MnCjzUuxgPTCrAberFYlmrQSa7HRBDJRITucU4aEej95M0dIYYoxOZuZQouFoSkmjWJYicRerw3g24zeXkWjvDgDAFbgFr3w8iAwtM8VK4f8psLYqkr3ivcA4NWsI00J1YliyG1E6gvW7yNfEeluQbeFehO6yH4y0JCUKxsPLxaXMXgqM0DjlHI8RjYYms9AG1Pp4Gw9G1jsNjHb8DFb4/B7AoXDBbwHx8i652bxNKrkNIM4V3TG9TUs9po4/n6Aya0ELObwuhZaH6cofXpiME5ZLpJuYDaHnMwM/z7bbKJ/p4RFmeIKnYlE7esI7pPTpSVBtUoSes5NgppMUqJS3txC950QUZshrpMVc+MziepnA6KBqqG3KLq0KLzsm9hM684NHP2tBoa3M5R2RhgPA9gHHnb+NIbz6wcEyay1gGaNWCQHp8sF9fouhm/VMelwzDoSVsxQfiLJvlpTSC0rF00oIUYj473POmuI9msY7ziIawz2FPAGAuXHEQXHn52vdIgXryWr1UB6rYP5moekwGHPJYW6HwyB3sC8T+a6xkpcf9/M98B2NhBtlRA1bSxKDOGZgD0TCJ8NjSqZuQ51a2o2sKJXadYQrxdhTxPa4GYJYHMyiNOpXXnows3RpQsB0lqIuOZiXrcwr9H5i8/nRq2rTdRkHC99ckCCNXBusH4WLTC524AV0aLNMgnnZIi8ZbOu+LNmCWmB3oczjMGjBNLmBBnVfAiHE6X1bEbzCOXfn8/wBbBkSWn2XhwvO2nPoU1uHhvRFjhbqo85p88kScnLSBM9FONLRvMVt09WLBh42bwmN3T/V/N/9hpsAHkI6FsGpysumzlfHgAruPvFSMeVXGD9b7nBLXBh89CPCzj+q4bHea/zqyCeK3UBUoIpvF6zfMSEnAivUjAbDYQQy9xgNaRmvk8XUqVEFZeK18tDVbr110IeDSXIrTaiToH4z+cxrN7UKIV15oAOptEpYUzlFiy2a8ZcjRZvoP4lZQvL6QxoNyECh5SY04jM3tR7Wby1i9Geh9QH+u+nKH7joP3LpS/RCluCcVo8lbGf3Wkj2WmhfzvEvMHgjuXSlE4Zz2ksPtmswh7Ml3RIJQib3Wzi+Icu4kYGe8ZRfgi0fkVqY7lIlhGNnktOot0u7I0Oojsd9O56GN5NAUui+LWDypMMlV8cIDul8HVeKtJisKBBXZ7GiWtbOH+3ivEuQxaQ0tg/F6jeH4Pdf0oDWNclz6g0JQbJbAbmKH+ddgPT62UkBQ5hMTgzQSluyshPM0qseo1wcZVSxn0PvFJGuruGuOYhatngiYQzE/DOF3Duv4AYU0YACwOgXjWCLjGeLC0eQg9JjbjzmcvhDheEpyvr45X4Q9clCCMk0Zgo0zA1LboYb1P17Pcz8p06ncHqjpZB6sXCyoBVUzC1rbc2dRM2h//kHLLXJ6aM8hBKmyVYvYkZ8LIkxWKzhqTiwJmkhkWUFl1Ii8GeJuCTBRnpRbEJgpfz+TJrWOP5+h6UgmYwWskPBa2p75D53tIywnVoI3Ns2lyUJsK4js7mxthOs7JWClmLG+1AXmPxetFAgeVwBFgd2Oqn8p46F6CcS06duccrmT+vEn3lZxD6qaugHJ0DcFUYzVW6hXyEZB6OukhHVZsdc9yVwbPudni1YtSRxjNEt/Z6I7xCucwcG1azgWy9hixwCOeMEvDhFNnhMVWoypuIFQt0Eyjs1dpoI7q5huF1F/M6OUu6I4ngPEX4dAQcUqi8jr9jQkL2hwSV+B7Y3hZOf6eBf/fv/zn++B//TTgzijnEcAJmW4avfnGeYbJrm3Vk9SKijQBxmTbm6v0JrGcnRlFs1asE0XTUfOLFEcRkAnu9jdnbW+i/4SKuAsKTsKcM6z+P4d8/ovlHzlCMRfFSKNdsoPe3dnDyQwnpSvAZR/Vrhvr9Odxvjshfx/chN5qU48CYsZfQv/dsv4LpGgXl8AQQFrD2MYXViN4AMk0ImqtVabA8mxNUxBn4jT1yYN3wkBSpOApPMxTvKzM9RQYwTrOqchbKi8Zaa0GWC0hqAZKKA2suwDIJ95MnZuDPHJs2DdehxQgw9tns5j7i9QImWy68kYAVCcLVIxrcy9HE5Fdrjx+9cMJxkdzdwrzhIvXJFiTopsgCDneYUu70cMno0U6autJlYWA2YlEOkQVUzNknQxrE6llGltHG63m0aduUnc1SCpJn4xlEo4xos2B+f+0SakUJ+GhmxFwwWd7ZUviljRjTbMW6mQUBFZfT2UrAPQsDGrBrckiS0rEC8gSCxSkuU/sI6U0kTU0noLM/AFDVr9MHAaMf+G29gOzvegFj7L8H8O8BOJVSvqWeqwP45wD2ADwF8B9JKfuMMQbgHwH4QwAzAP+JlPIv1c/8XQD/pTrsfyWl/KffdW7zyDN19N+vEGUBuGSoBmB18c/vnrhiJnDpA8gt1Hk9goZh9HsxvH4BqXjJMsn7EV3oXi6mlmVYzhS0f/qlhV+9d4YlL1nDATlWkAng1slEWnfAL8xCVBtq1atAo4as5COpeHAGc8O8yRSrwOC6aWp8aqxKGbi2g7MPaphsqcr1CKg+JP6/7Kthle+T+GmRQJx0kSlWjL27hentNfTuOIjWJP7Z5x/ixq/GmOwVqDM474H7Hmw1VBaj8XJRKxbBtzuYXqsi8xh4KmFFAsVxBv/hKbLDEwiABqMKkxX9AeSDpwY+iv/OBzi+5WD0Rgr4C5Q+d9H4RYrgcQ/Zw6cQgQ9erZBqNloAZz2kilo6/Z19nN+1kdybgguO4s8DSgn75ilEFEEUi+DNOrJGiXjxw7GJiLRu7GHwbmtp6rZg8M+A5qfkyJk+ewlhWSvzATmdGuU28z2k71zHcMdH5jK4EwH/eWrEdtlEmY3pa4Jz6vBUx2FVq8DGGuI1mplY0wSFrwaQozG9TmsPNAVVCMge8eqZZcHe3kDWLGPwRglJwCAcoHAsSM3dm1DlOhxRdey6gOPSwu+5NCgPfaRlH/0bPqBmG944g386I5+g4ZiOoe9TbafAOKA8pUQhgPAsMLVY270p2GRG9ErAwFu8VDTVuPRdiMBB3Azg9mPAs8EChzyxQJ2LM05gj+bGzZO6awksYuQjHk0SmL6fNF6vXq+Ht3kmkL43mfrT4PbKR0gGLtiMnFFXTOSyjBb/2dL+gjkO2WEIsez4jfXLKhvx2x7f2QEwxv4mgAmA/zG3Afw3AHpSyn/IGPsHAGpSyv+cMfaHAP4z0AbwAwD/SEr5A7Vh/ArABwAkgF8DeF9K2f+2c3+rHTSwhHJc95J6d2Vwe5Hzr4/xLW6dV1JG8+fOnf/SBvXbBNfrc+QCalbOlXs9c+xlfoHaJJahEMx8+Yb5dMWgO29xkR8aasdO6Vjg44jk9YOh4SibrAEhLvHQx9tUyaQ+Q9jNEB7MwJ+dkDgMILhESdbFZNGexHMAACAASURBVErYec7jJikwpCHgjCXq92O4h0MShym7AVYuQo4mtODpTIB2C6IUIKkFGO944IkklbJq90U0Xw5RS0XoHFYTrN6sI9lr4+z9AqZbUilGGTb+9QzOg8Ol2rhaMRCXDkWxWg3M3tvF2bsOojfmkAsL1U8crP9kYDx0KNqyTH4xJz3DJLIqZcjdDZz8qIrpNiAtgCVA+9cZguOl/xCzHWXx7RNUo+yZtX3EfL+BuGojLnN4I4HwcA77wcslhKdov0bhrmcDiumTrdeQVH0Im5HS9mhkuhJAxTl6HsE0Cuow4SWtOuLtKmZtB6nHYM8l/F5KC/9x31TdmiqdzwLQMFW8XsB424U9lxAOoy7xiZov6C41B8ESREKCMDRryAqugXqs6QJsMF4RVJku1fcIa2/VjTgy6ZSRORyZb4GnkgqHBaWuQUoa8I5jMnnTnH7NHIwiyGi+7KQKVPkzIZfcfSX+0t5EeiagNTxYJMvfUS/kamhN0ZOMigVgOQwGyPBRGctpeq/JC8kpj/Oowf+Z/fP/7yAgxtgegP81twF8DeB3pZRHjLEOgD+TUr7BGPtv1d//p/zr9H9Syv9UPb/yulc9roSALipor3DyvCqw5dLC/B3HMy97VbLXVcf4bcRkF94jgCszBFayUnNZw8YmNr/o54fXF1XTueOa+MliuMwulRJyPCE/GdVKGqm6whaN14vi1k/2ioiaHCwDqg8pdUqcnSPvbSJVu6wrdnu9jel72+jeczDdoYjHykOg9DyG9+CYaKAl8kSXkynknX3gk2/od3ZssI02Ru+sYV7jcMcS3jCDHaVwH58tGUvAlYQA7XeUXusg6viYrFtYVIDyU4HgLIH/2QuqznXoTCEg2b52xNzdxPjtNQz36Of4Aqg+FKh+3EX24Anh6K0Gko067NEcbDBG1j2nhe/aDgbfa2K8wxGtUaaxM6QNx310THOJ3KIvqkWw43P6TpKUhpvNGka3q0hCjrhGucDB0RzO0xOzwWihXx7y42EIXi5h9s42hM2QeeSE6Q4WsHtTQ58114b6zvXmwQMfbHMdSaeM8zs+pE0bdnBK/jze+Rz2UZ8gufFkhYKtoUmrUgYrFzG518G8ThRKJ5IoPJvAOh0SewYK4lGYuqE8AhD1EliSISt6mK8FYFLCO1PnHY9XvLHyNHCobgHNGrISZfOCM8Q1F4syByTg91KaVYxjWuylNIpbpNnqwBZQ2L21vN/zpAzt8ZMPb/FcqtRz0A0Agm+qZTP4hcXJooIxZAWy8TYpZGphpyJXU74TooKrv5v7X68dlvVbZwJ/JwT0ikdbSnkEAGoTWFPPbwJ4kXvdS/Xcq56/9GCM/T0Afw8AfIQX/5H+zC9yUkCuwvpLyOOKJK7VyphdcWwB4FsW8asW/78ipJSXxa8cU/07wUhXOIfmzysEpDrGRQM6mSbkjaOpsMot1dxYaUaBMGowpa0smO0sBXTKsRGA8feZtn0Ih7jctW9iOL0I7OAUQmOyhZDgBpVYBZDdQbK3hpM7ZG5mxUBwYKPxVYbyxyckbU9T8FoVslJEWglgffqQEq2yDPG/8x6EwzDespG55ApZfDmHc9iHODlDqhe/wF9qK1JhmE2sWoYMPCStApIiXe6FkwytT2I4T0+Rdc+RJSnBWQrnlpofr+ItT+8VMd1iYBlQ/5JyhfHwObLZjNhAjSpkJuA8P6MUryCAtbGO4fvrGO5ZmG0KAALlRxyNL+bwHp8hff4SmeuCv/kGRXaCAms0xdKq15DstTHZ8JH6DPMGR+FYIPwmRfjJC2TdHtI0oZyBShlykSztPopF8N0tLDYqWFRtDHdtVJ6mCLoLOAcDE/4OKBgPoEARJQZjrgN2cx/T62XMmhbmLYbMA/wuLf71z8fggynZhGfCpFiJaA6h9QMqdnOxVUPmkZ1zcJ7CGSZw+iqFLs0vWpw8bRaJYfOIome6FXua0sY1WZB/02B4ZQ74yuJfKSGpBch8y0RFuuMEdsTBUwFrmiwhKzMTs2jYqwawzLaAgk8GcsrTX7N1jH+/rsL1e9H3dzRfDmi1gFKJv6SCdlicUKfJPOrC5wnpEqaRGdxrS+gVZ1C1FqzYv7uOCZn5bR9/3Q3gVY+ruJryW56//KSU/wTAPwGoA3ildcPKD10c4Kp/Nx486v/FhZ0CuDyMBS4Pbs1GIq6s+i+9h1cYvS1fl0sDsywwR+V/5rUDwJKGCkAiB2dddDjNUVbFnLBIvXjzIKAbulImyqESRuVvHh4Epm03MxTGaSEpl5DsrSGuueApVW7sqEuY7CJR4iXlnKg0BbwQgr17G5P9Inq3LSyqAjwFyk+A5icT2M9OibIZhpQ7IKmNxvkA/MFTQ8+z2y2U/sET3P/fbiE8lqge5xY/TT1USWmGuqqiG5NWiHnDgbAY7FjAnmQInwxpuKY+h0zDE4XQ2C2AM1jra5h+r4PpuqWqZonWJymK3wzIv1+Jp+x2C9K2zECZF4uw7t7C5GYF07aF8T7gnwJrvwCqX41MmL2slMHeu0tdWJxSNX5yBrnWxPxOB7O2Q1nMClsvHCeo/2YM+ewAIpojsywTTgLA0EjtdgvZZhNRO0BcIevt4kGKjT/rgx12IedzZMrmwWo16OelMNoB7nvAzR1E2yUc/8hGsj+H+9BG6ZlE+WkM92xKi2OshvBquAllj2A1G8YdNSv7yAIbqVp8i4/HYLMYOOuZKtnkVWCJWzPbgmhVMd0tgmWAM0nhDWNYZ0NiAmm3TCHVvWEt52GWZRg/olFF0gyRFG2wTMI7n8MazOj791y65lyH+P8hXb98GgF9EtAh8IFaGcJ1SJQF0HvOBIm4Mlr8dUgL8z2KcFxEK4WqTFLS1mgXAc7oM5zOlp5AnIHN5sAsAtfeQWrWoL8jbalh1h6ZQwRyaABwxfr1LY+/7gZwwhjr5CAgRfPASwDbuddtAThUz//uhef/7DvPotq2lUDplUHwKwJXVjjSWC7GekPIMXnMB63hAjOIzUM/FzqPi7DZJabQt3QAcvXY+e7FqJY1zv8trCbz1vQGuViYHZXYR0LlB1OiGBQbIa/UNJ9TTkPAAx/WVoeYFUUPQmGthZMhqXpnM0goyEAdW2on0GoV+OAuzu4VMb5GOLczBOqfM1pAvqLsAFkqwmo2IJoV8NGMWEYq7Sv78Zvo3/DR+GyC8U6IF/+LhfKBQO0nz8mPBqBORn0uWsRmrbUg1xuYt0JImyMpcDgTCuT2j8ijRkdMGrdVtZFK5S1krTUxfXsT3Xcc6jZOJZqfzkn3cNqFUP79dq1KHVivb1TA1t1bGLxVQ9TgcGYSzkRi508W8B6f0UA6TWDvbIH5HRr2pQL85RktJFtt9P7oLnr3gLSWInzMUX4mUP1yZJxSMylgNeqwyyWCqFTurYjm4OUy0hsbOL8WIA1oHhOcJihNU1ifPlxSSEtFWIoarIVo4IxCX/bXETU8DK47yDyi7pb/Lx+Njwfg/TFVw763hCGUIInyDIpI2xVMm4TbO5MMbncGPk/hzmKw8RRiOKLrUwkSTQbAIoEshpDNCtKiB8kA6XB456rajxbAyRl1FnJZ+OS1B4xTxS8dG6ISmvvVmqew5imFv09UxKOt1gXHXrVziJQupRCo+EZLhcbPaeMB6LpRjB/YpOVgQUDzgTQjmqqGaO1csLti/cj+kOAegAb7hcBoA7BI6PewbbCUhG1SiKXW4OIap6jfNB9MIHRR91d8/HU3gH8J4O8C+Ifqz3+Re/7vM8b+Z9AQeKg2iT8B8F8zxmrqdX8A4L/4zrNIeVkqDlzG8q9Q0WomDr0+7xQqVoZMTFXjZlHNV9dXnffbBsm/zePiMfR7zT3HLAuw2ZIN9Kr4Sf2zjJvfUSuG5YLUvzKOqSvQSU2KRaKtI2QqTHtqb3YgQx9ZyYdwLFiTGHwcGcsAALRgBP7yuKB2P721idO7/297bxojWZbd9/3u2+LFvuRSlbV0V3VPz0zPDGkuY4qyTcGAZG6wJO+gYEAERUAQIMEWDAMiQcASbAgwLdiADRsWZIuQaNCURNuC+YECF9uQDJgjLqNZyZnprbqrupasXCJjf+v1h3PvfS8iI6urh5zubE5eIFFZL2O570W8c8895780KRoKSui+qRm+viJ6/QnlqbH8i0K8O7edjLM+PCIvCoI7t0lvD5ncbDC7Iec4u9Omc29O7wszmM7R/S4Me6ISacS00Foy2Z0Bi7t9ioYnjc2TlObrE4FsTqYUNZcq6Rflrqlu6/eLV6+T9nySnqJzv6T/2hz/rccUxycUYSAZd7eNSjLB9RvdnPL7PsX8ZkwZwHLXo/m0pP+NKd6DpxSHTylMfZ9+hzJuoJ4cg0HE6Ot7HH92yNF3awhKGoc+137Lo/flQyGlzWYivtbviTaQUujTM8qTU1mAR0OK20OOX4pJBwp/qcWl7CuPKvE435dyTFG6+r6Tnri2x+KlIdMXAhbXLFtZs/f5JdH9Y/TZBJSH3t+RDHaVUJ6cORlm75U7zF4ZkPR90o6RgX47IZgkro9RWOMXw9JXDcHBl/02eb9BGXgkwwB/pQlnuWGCCxLIql4CVbJhIcujAarZpOx3yLsNEetLcsooEHP446kL1uWwJygbi5IxAm7+kcn2fZ9yp+dYwN4iRc2WAietl3iCAIy2lWu62ro/OKVPKxmt2005jydTiGPT5xCNLKJQhO4Wqwox1WoabwC1ttuR+BSsxw3DOahLyrgQE0Wwer5w9Dww0F9EsvddpdQD4K8jgf8fKaV+EngH+PfNw38FQQC9jsBAfwJAa32ilPovgN82j/vPtdYnzzdFtgfaLc1f4MLHAdWXqR7sc6vDbR7u++sloXOY/Y3Sz7bp2p3FhaqiWxaS+pq2ieTx/LXXWusPbCiUWs9QqBpEayQ6T5kvT6UbZO0adaeFVgr/eIpvEB2FaQg69mhZOjKZPxjAwR6zVwashj7aE5mGzlvS4CsOn1L6vqCBjIGHPj4lPxk7Hfr5d97k9FrAaiQWk61DzfCrE7w3H8qN1Yjg2i7pXpvo0cRl3f71fdKX9ljuCo7cy41j1UNTKrHnXkOK6aySOvAMTLPst8maIXnLI5wXdO6t8N98SHEyRscNQcXYHcPRCflkRnBtj/zFfSa3mkxvy3er9aTk2uem+G8/oXh6TGFr8T1DEDo6Qc+X4vzV7XD8Qy+L4cwgg1zR/0rIwT89hdfedkHT7/ecCYi1xlS+j3/jOsuXd5kfRKRdRTTTNA+FLRzee1LxJoyGv1VvtaACbzQg++RNTj4ZUzQUixua+BB67xR0X5tIuUiXKLPTYTIT74LlSnYRRgJ7NfLJWuDl0DoSRFJ0/1igqKYkt9aYbTSg36XoxiS7TdJ+QBFCuNQ0TlPCd44c2maN1AgV49dCc4c9yjigiAOK2CecZaisIHw8dho6KgyllBN4lIGUWvyTGV5N4tmyj8vIE3/j45nAUC1T2MrLQLV7yPPK4tHJN0eupKNA/s0L4VNY5dzRQHoNnmD9vaIURrzyUI1Anm9ZxkXpMn9V6z24XVDNydCBVqxC8EWqCdtC0aUngvk/+Gyy1jOC9bn+gXncGlKk/nIbiJttkMy1cUFP4ML5bkMiXYDYcXOqNXbr521vcKcZbjIE1yOoew5seX2nEqo8x6q1eOtzjSSLVjIQNn/Qh5vXmX2sz/R2AFoaq61H0lgVKKC8rvUr1Yulq5Pz0i3Gn+rz5I9r4kOf/pslaBh+6RTeFR0e8TYIKiimVQk1UMizuxGrXUU01nQeF7TfmqIeSpnH7nSg+uzt/71OG/Z3KIbSO7CEIG+yQI8nQt4KA1FBjUIzb1Pi6vfIPnOX4880SYay6HTeLel/fYr3tuwWLJMaI9pXXyzLl29y+Nkuy2uK1UGOauZ0Px+z/7sLwq++XXEmrFigMVrXaSqm7i/fooxDxq80yWPwMujfSwUCa7wCVDOWunQjchLUgIAABn3ymyPmZuHyEtCBLF6DL5/Ao6eSnV8bCSRxKr4LACqOKV/YZ3nQZn7dJ28JU7l5XIgw2zJZ7y+BkyhRYSCljXbL7bSKEKJ5SWh4G/psIt87C4suKlc+K5thfXeL3R55tyHaTStBzFjSmF4sXVOaRkTZlf4WeSklIJAyjOeh44C8G1E0fKJxQvDkTIx68kJ2yaY3QFE4cpmzerT3USt2/hvOLMYauVsph7yAvSE6CgTnPxUzF3yv2tkslub8qtfWq5VL6LR1IauPGlrRCcqZvta3GgX0gY6tbFpYD+qb9o+bDd1a8NVFgcLf/hqbYnK1Buu5zHwz+JvXWys/ueObfYP1ks9mL2Lt3DcQR1U5y3AHslqpyDzOykmsvQ44+Kkldtla7ma27Eap3U7Ja7Xw9ndJXxix2olI2x6dhwXRWU7jwZno+SyWlXDVcrUuI/DqZzi722a551FEcOv/zpnegO7bK4JvvCs3y/6uoCS0hodPKOdLgTe+epfTT/eY3VSUEQRzGH6joPulQzg6oZwvKe05Wl6IYWP71w/QXelpzPeb6AD8ZUn87gzvdEJxdExuMfSDvpy2aaxiau/FSzeYGaaxl8PelzIaT1d4X31T+iKtljPzsaULnab4gwGr732J4zsRk5dAaci6BXf/t4L44Qz99tdlvjsDdL+FV2PQUmq8F29SjDpMXmgRzEv8tCRcaDoPMhqP5/DmO7LLakSom9cFO35y6ti+wZ3b5Ps9VoMGq6HPakesPftv5bQeLPBPZmijoaSaMcQNsV40AUp//AWmL3dZDZUTpPNykfZoPJ7jnU6kHGcY2vYecBj4dgvdaVE2Q7J+A7QmnBa0LRR1PHH6RC6DNcMJq/W7UsKx8MykIEwWqCyX79wqQVswhJFZIBABPGXKqzoKSHd7aF/OIzpd4S0zwlVOZI1cSo3utiv8va0YJJkrBam4UbnsJZkhbAGeGObIRQ+E7NVsoI3bl9eKIY9c8Fdxw+lnOf8C00wWOYhSdr++GMrb5M7BQbfEE9sPe1Z1YnNc/gVg44QuzK5tOWcj0FdPXA/S4JsSUuled9vz6pDNc4tJvTm8+R71x517/43Mf+3cWD+3LT2HcwuMbWqH0TnuwDaje5SSLWayXDOwd4tdEDg0kCsRGX2gtBOJh+9JRuthLllTXshNaDwPnEG3wdWnt3dIdiJXK24/KkSn5uGYzm9Kg7K8sSs3uNZ445lIUxcF3it3OPvMiKPvUOQdTeeeomUbpFbV0p6vXfQNIcjfHZHf3mO230QVGjyBAjaOlninU8qTMXm9N+L7lJOJu1x+r4N+8QZnn+izGorFYu/tVeUfXBRoDNa92xW3LqvJ3+tQfuZjLK63OH5VHNZ6b2mG31gRPppQvH4PHTfwru87hqr/+NQpgvo3D8gOBjz9TNMRlnYeJ3hpQe9ogXd0JtluSwhveiE16/L4BJQSP+dbOxx9xkCpS8n2uw9ymo9XBO+eCI7eNLFVGEiPoObeNv3Oaxx/OqCIxfugd09UYKOHE9RMzN2171VgBdtXacluQ7eblM3ISUEH85zGowVqlaKn84owGIWi8WM4ASoMUGHb8VVs0xytxVtisZLPOy+qrLy2Q6A094znOeJY1o8oYiW9hmkmTeHFqmq4NkUqgszg+E2d3zVme11BfBlSmd0RiEKvEYwc9eX5gW/QZiXlx24LOdK4g2HkTIBq/mbHoqzsg+cZpJRVFDA9BiPg5+5xuxAoVRlFYYiec55rXP4SkPen1rJe4PwCsCEI547BuYVijYBlM5bNHURt0bnIsP3CUe9NbJq/2Pls6AldzDnYLn299dzXdgbndz0oz2kM1fkH55zWavP0BwNhKhqmcNGKUFqLONa7T6o+QhRV21RAtVrQ77B8eYfFfkjeksyx/Th3W20HazPsTi/JUY+PxTvAeNeefNeQs5c9ilgTTRSD1wt6Xz6GJ0+rEpMh2lgmrK3tr17aZbEfkvQVwQp69xIabx+fM8xZu07KI7h5QLnTIxvEpP2ApC/lit7bKfGX71f+AkaJ1BGAjD6R1+/C/g7zlwbMr/vCNF5puvekPl8cnYg8RRiKEmpRoJ8cSZnh7m2y3RaLa4IaKUJFHisak5L2/QX+aw/kOqeZmPlY+evDI9EXardQL9xgddBhfhAxfUERLKH9qKR7b4m/zFD33nXXzkIY0aUj0vGZjzG702F+4LM40LQeSdAcvJEQTFORajg8lox/tVor+VjSVznsUsZyP3mJqWMvUzg5Q8/nlRJqPdEypRAVRYKaSVKplxvIplrWiFYGvUSp18lZhSQiKoood3qsrrdJ+j5+JjEumBfETxYiA51mThHUSj7oZsMsbCsJ7FEoWXxkvINXOd7ppBJ8s/pClkPgC7HLSk3bORP4ZjEM8VZ59R6Bv1bmRClhFc+XTsur7vLl7lOrJFovATnJiPwPnwn8YY36AuDGBmb/QqavfUy97m0QMIBkrIZIY1dkq39vH+vecovE8/OOi/oQW19vU/Bu6wtuWQBgvfxjSiDAmjKqpffX66zAVhaxtQQsOw2XLVlpAHftjEewM66OG5SDDtmoSdHwSfryBQ3nJa37U8la00wyO+M45cTNECG79NO3Gb/cIG8rigiiqab/Rkr8zhhOxqhmk2K/L34Gxl5S5zleq0X58k2SnZis65Mbuz/tK0ZfOoM37jtUjZXYdkQ345aV3h4yfqmBn4r2vJ8UhCdLvMNTgTFmuRi/GJtKfTqWxcRcr+KTLzL+uARlL9cinf3W0wrl0TDIs24HPVvIbqPU+Pu7JK9c58n3Sc05mMHo64kIoj05MY3E1PVsVEu8n23dXIUB6vYNjv/YHmlH4RWaaKLxMy0L5smZKFHaQBUElUCZbc7uDBh/x4jpCx7JUNM4UfTvSUPfmyVwfOpqzs63wEhYe4M+Zb9D2ZFs21uZpqcxUrcG5rooZJGypQ1r/hL4lMMu1Lx91XzlzFK0MVdxcgxGRlq1DH9lLoJtdlHN9jokuxFlIBpRjSNJVIJp4vyDyzjAW5m6eppJOcfsJGzJSuWlzCnwZGdq+kS2VKNbsWT7S9n9loO2CMzlpfMetkqnAGqVO6tJt+soymqBM6Ufaypjr5OezqoYVLuv12KFdT80yd9vlL/0R6QHoDVrYPk1xm7tMe8FzbRZvl0lbXmjjrXfbB5fRAjbeN1naQI5xM7afC+o02177frjty0Y9Wvj+ZU5SlE4DXGX8Zsdjt/uCLpkw0lJNRpGaCoQQs0qwTeQzcI0E+1c6uQxFQTog13yZkg6ivASUYVsHC0la5ov0bOF3LRxQ7Kb0zG5VcX8xEvMX+4xv+4zvyH+rL23BA3kH57JotXvoK/vyY04XcHTE0pj/Ze9dJ2TV5os90VRc/iNjO5rM7zxTOrpzsqy6Rira6YrdwZkHZ/VUDD8/W/MzLZ9RTlfoA0Cyms1QXkiPbFYSKnj059gdbPDaidgNfJonApxy3nz2usaGzTPyRjOpgJl3N9j+r03WOz4FE1F41RLeexxpalUGs0Yu9Dq6dR5MQTX9uDlWyz3W0xeDFjuK1pPtKiR3j8VcbezqUt6XOBPs6rJ3e8we2XA6ceNmmwO136npHGSET2auIWfPK806Y2Rjep1KbtNkpFg+lWpCY6XqLKUcpQx9SmXS7cDVa2mZMXGIUt3WqQ3eqisJO+ENN86RR3Pqrq+6WVZnwmnuQ+ucapaTcp2k7wfkw5ClAn6wSxF+1KqteRCtDa6O54L/i4Yh2IBWTYCtO8RTFcOo+/km3cG8jJQeff6vvAPAAoxkVFKoVty3dUqF/gyoOOIot/CW+WyqwBxRjOJme0HKGMa4wTj3D1eK1PXkEBrOmhxAyY817j8C0Bd76eeiV9YX99ABZnfrdk6bAR2Q4Cql0C2qYbWGcVO5nlb8K//7o5tKdls+hvYx3o1Fy8wdfza82uZ/uaC4dATpTbmEOvNXbtW6KKEbFFpyBi0htfrCgtxNpdAYTJUt1huGOzYm1G3m2TDmCLyKANFdJITnC2lDmobXKZ0YQ1nvLiB+u5PMr3TYXbTJ+sIqqV7T9N7J6203NttGPYoBi2Co6kcA9RwwOKT+6xGPslArBJVLsG//YV3yR89kcBt4ZC6MuPxuh24tktyvcPkhQivgObTnOFRSvTOCeWTp5TmBvOasVOTLc+mbtfov/ISi1dGTG8FYipeaLr3c7qffyhy0brmDmWYx3b4uyOWn77JaidkctcjPtLEJyW91+dyjqdnwpkw7mwYRc7y8KlbuLwXb7G4O2RyJyRrK5pHms4Xc1oP5rJo2mzZNBV1nqOnM1lMru2RXR+gI49kGDJ5IZBS0eMCf6VpPpqLRIIxDnIQUtMkV60m+bW+1OcDhbcS0bRgvERNJNsvaxIjLvhbKLHByOtmRDZq4qWCmGm+dSoLjvUP8H0oVk6FtB78AdlxDrvk/QZFKPdqNM7wzyRwq1JLeSbwKY0nMIUWrZ1lKqWjRiRw0mYoO4/c/H2aoGYWLuqZUlAojefZQrL1SExexM93IznzpezlHtuMKbtNykYNQZSXFezTBHYVNwQ1ZONKYXokhOiigm9v7vCVV33X3w8h7COwAJwnPwEO5bKN9rxNDG6t2QmuTLJ2fGMncY4V7LSHNhYiqLL++u/bOAN1bH/9/7Vg7szn6ySPeuDfvD4uwAu6SewYNyCstd1EOZvJtrPRcFIKRKFA16ASVnOKo5W7WrlKKlTPoEc+6giqaFXgrQqiU6PSaMo71sxCTsxDNWO8V15kdb3N9HbgavQ7v5fTfn2CN52LPWEQwI1rsErhbIr37mN0FFF+7DbzF9qc3fGZ3SloHHt03xbHreBwQvHuI3LjCqYaxqfW6hLdPGD5iWucflIMZ8KZpnGm6b82w7v3iHI6ozDKlcpkY/VAJhLUd0gOupy82mC1I/o4u19cCHFqsaIw/sm2XOLMYFot9CfvkOy1KGLF/JpPdkUqkwAAIABJREFUY6wZfS2n/dZUdiurBOquUsslLJeVxk+rhdfrUbx8wPxWkyKSGn/vXkrzjWMpReS5kUMu13Z/Vg00u7PP01eb+CnEJwWlr2g/Lum+OXO6OFZBVS+XDprpdTswGlCM2iQ7DclpPIifLEWmwapg1lQpbeKFkZfG85zRetGRhTF8uhCzFeMIV65WsmAVBcolXIEzUtF5ge530J5H2QpFP2eZE747czBPbUptOo4kwBoOgLeQ3SirBN1tO/y/KrUYvyeFqdEvpSQUhZR9KeugNd7xWN7f1P91GDhCl73n1SpxO15b49eDrisDeYtMFpEsFx/hwBeSnfEZ0GlSJZ9BIOUnAwW2n+ca4bMoq15AUWwlhj1rXP4FANhEvri6vdbnauvuYhgNjXozt864XWMYb+4Wmgb/q7Vo8NTmIa+9cYE35SG2BX/7nM2m8Gafwur5bL7PmnBdrTRkz7EsQHEOCbU291rz2RLHCAIJ0rN5deOaeVgZW+VV0tNeu4W3t0PZbZJ3GwQzg8G2Fo/tpgT/slzzL/X2d8n3euTdiGQYUEQKNOx8NROf2ceinqn7HdgbSRPwuLIw9K7vc/Y91zj6Tg/tS+Dd+x2P/hsLgq/fpzybUlo/WlNfLg6PAPBHA9LPvMjDz8YsbpZ4iWb4Ndj5F2PhDhwdUZqts2o1JbM8GTu4nn/zgOVLO0xvV/DY+KSk/0ZB8+FMhOFMH8Lrd2WnYBILf3+P7JUbpJ2Q5Y5I/jYmBb23c1q/L5wHfTZBG+kAK/Nrg76KIin1xA1WL+2iFeQdn2BZ0n5nRfB04pQ4iRsSLAznQkUR/t4O5e19pi+08ZOS5U5gfJ0LEVebJrL4nE0q/X1dGQmpKMQbDckPhuTdCFWKhHbjaCn17odH6CwVMTkLQwSjTtpyIm+60xLpBaUorejZLIGx1Co0OJKiisTsyMlSz+YSjPeHqLyUbN6QulSWu0SDbhfda8v3vFBoz0OFZhEpNUqbHUGzQd43InE28M9SKV2tUspWTLHbFVLkIpV6/nQu98t+XxYVv4ZM1BpmS5nLKpHyUBRK4A881CrDMwJzWIip1QEKA9R8KVBac1w1IolllniWpaZf46+VaNElFKkrawMOxfe846OxANSHw/dvMU0xYw3TXkfxKI+1cgy1co4Jjp6tl2p9DiK5vbdQK0Nt7iDqkNVt5Rqr/WNYqkBlIrMNZlqfh7tZTR9gbYFQ66Ume8y4gTnxrKJALxauIer8CYw8hl5W/gGq3UZ12wJZ9GQrHZ4a6OHhEdb0QiWZ28Jb0TT2RqxuD0j78nXzV5r4SFQhvfFMEBGtWLbTAKeTStJ4NCB75QbL6w2mt338JfTeLhl+8QQOT2SR0Rr/+r6roTooptH+P7vTZPqicA/a9z0Gb0ippnh8SGl7A42GBL7FUkolUYh66QWWd4fMDgJmtxV+Crtfzmi+OxckyaOnEiQNu1Onqds9eQbimbwwYnZT2MqtY6P9fzJ3zmKq1QLlSX19uXJABAmgHVS3S3FtIIEv9GgcLWk8zkVSwmb7gbBI9aoiYwXXr6FHfeZ3+6xGPmlX0X2gaUwKWk+EA6FWCZzNKFcr+exaMeXRiWSyrab4VLdi0r0ORSyLV3SWET2ZSd16uZQeQ81q1bLgvbYp1Vg+ipVhCDy8NMc/mcl7GVtHG/C00fVxUORWDN0WOgrI+w28pTxXFaU0Ry0L3nw3ARdkldYUxuxFK0XWF3SVv8zxUvOzzKqgHPjk+z20UvK3pMCbGoJZr0N2vYuXFPiTlUBZA995DQgnQIAQuhFRdGNUoStJCYMcWgvseQ7LpajphsY72Cp9FgU6Kx0UVPkGuWVlKUzP0hK/gHOs6ecZHw0UUH2sZb/vzaTdVkJyCJ8tuvHP0ui/UAl0M1M/F/yfQcyoN3ifs5l9rgFen5M9trEguXMrt3/ets5fZ0hbcw3bvLX2dHq2qPTIi1IQGMaKDl06gTRv0Gf5iWtkvUAMRBJN542JQAKN1r7LVjzPeb0q30ONhmTX+sxeaDqdmc7DRJqMD8SRjN0R1qrPZlEqDChfvsXJd/SYHyjSoab1rqLzqKT39TPhGBydOOSQlPRKpzHj7e2Q3t5hfjNmdtMj60I4hXAuaKTGb36teq75/CzbV0UR/u4O2Qt7+NOEs08PCFYlrQcCynb691aiYSrXwOrvK1sqAVFJBRc41TKpavK1HoxlZ68hmg72mL80oIwUSc8Tx7CjDC8pCB8Kycvp8KcZXrspujpGX8n2CPxlRrrTJG/6otMzS/HfPXKPK1cJlIWUY20N2/BplLk+lTiaccqyZunIPbZGOrSBv92k7Bmv6tBHRx7hkRFkOzmjnEwFiWWbt4GPWsl1cJDMwKdsRcL0jaREUzQUfqLFwOaJcTireRKXoS9GM2N5L90StrG1SFVai3eAKeHoKBSOQiaZvQ4D2Q3khfHqtXyBCsZJrVxDbpJS36u8MKYz5x3g8P4G82+lQORCVLIQdlcgUifC3/mjgwLaHGsQyAsQQWtjI4gqb51mXiNf2Rr6psfvWq1/c2wzq9fleUKXnedmeaYe0E2GvvX9bZmnroC6bWdQvy4GFVRHDDxLo6jeN/CasZBzQOQhZnNswxxwNUjANdFtb8C/cY309g5lwycdBEL3P8wJH4uiqJWecKJ0s7kEghv7lC/uM7/ZZLnr0RhrgqQUpvD9I0F9tJrSGG5Eki0+PZEbedBn9QOf4uTVkOnHCrRf4M88um95XPvcGepr92RXYkpfjhNhGcAv3iS9PeTwu2NWu+IS1TiGna8WtN9ZiD7Q8Qm0Ws5m0Ll9GU5AdmNE2g7I2z5qp0HnwUoE9U6mTrzLNs2ZL6WxbITV/NEQ3W5SjCQQ5N2IxqOpfJZHp2gjK0AQ4LXb0ttYLNz8+Zc/QzqKKWJFERlRvLOc+LAgPFnAI+lFFEbyeq0/NkcIVlGIvnXA4laXrOMRzCPCRU58mOKfLcUkxxCn2Kgz2zo9BrnjcPRhIGqgT8eyyzTCcCoKnQGNq3d32xSDtoPyhlOD2z9ORKZZl2jlCcnMEreSFLXMnUInYUAZB5RxCKUm7QWUocBB4yeJGPYYRA6DHnm/KX2EJCd4OpEdbLdFut8hGYVOXDB8PJZmruXa2BJQXjozFycbba0jAd2KUZ6SMpUujYx06pQ8nWyFUmD8A1QUSbC3Qb6W5RP5lRl9EIBNAEwS4mLBc46P3gJwUbbvTvoZvAD7vBpj9NyxzQC5GVQvQAa5v7mG8gZyxwbsehnGEs/qjdwN/163QLn3UNt/30Jec1+aOku6/rxN3oHZuXhtgTvavkDFMmTdTN7AKVUQSgDrtsl3OmhfUTZ8ouMljUe50+DHU2Ct+igpT0xW12mTffImx6/GeOZcW09Lul8fV5Z/SSqCdVGImszEgQzR9km/6y7Hn44ZfyYHcsKxT+9141b2zgnl02NxKjvooJaJuHVFEV6vS357l9VOg6TnMz/wKBrQewO6DzKa9yfo+4/QaUqR5XidjmjsLJYUyxNpCn/6E2SDmPnNWILMcUb3y4eV2bdld0YhLJZi4nM6doJvwcE112xcHrTFVH2V03j7BM7EDlMbvLw2wbKcmB4DELxwi+zWDtMXRNitez+lkaRED8dONbVMK6DEmt+E0YNSzSbl/pC802B2K6ZxVtB8nDjzFW3nbSUMyhoQwjMlQvM6epWgWrHMb7GUzy6TXoIlFgKyk0lSKW3sjSi7MdkgJusY7si0oHl/AofH6OXKBX3djmGVSbCdLSTzbjehFUuzN/QFaVNq0QpKtHABnq7wFhlaKfLrA4daCo6m0owFaEQU+32KZkje9GmcZgSTBP/U9LiiEB1H6CgQs/gskUUnK2RXUCevIVwD7Xv4m03ZWtkLEF+BybTaDQeBJF2rRHbhvo+mqCDrpgxkE4A60MPd+8/ZB/7oLADbkDR1Ru05du/FRKqtWTack4zeyth91qhn6u79tgTsevDffP5Gk/icEc5FpSGtsYufLkB5Ag9bYwXXX3vL4uVkIGq2gvUvVXXddGUaY/SBilGHohNJb+BkITXi6RQaop2i44YgH2qiX16rBTf2md/tM3khYHGgGf2+pv0oJZim8ORIarxNWZBYJeijEzE12duhuHud6a2mM51RqWLwex6jryc03pSMF99HXduVLft4QnE2xd8dsfiXbrPYD1juSm0/nGniE037sTRn9cJkYwZnrqeC0ilnM/x+D//WAYtXRpzdCYlPSuKTnOa9MZycCWrIKrMakhw1UTlAmsOfvMliGOIlGi8r8bJSsnVTU5bPQEmTXpfOotLWmr3RgPzaAK3E3tDLNY37YymHnY6dHtHmcPIeoyHlqEveisj6QpxqHaZE7545NqpOkkqDxlNrDUcL7SSQ+rWIEgpBzTWxa2RB1YodA1ZnucCOex3y3Y7ASZOCEAjmGcHhRATu8twBCFRRCrlstkAnCarboRy2pc7vKRGFM566eTfCS0vCM+ECqKKk7ESUDR8KTTBNZGeVJNKkbjcpRm3RBzpdEj41iChb9rSs67zAWyaC8okbVbmnLNGNiLIbS9CfJY5oporS8BCMC1inLfeZub5OLTUIhBxoxBgtgkpCh3LlzjU0UL20u8kOfo7xkekBXKjsWTNJtzXJC+vom3wCOPf3c4/fFJm7iA180Y5j26iVlTZF29w51t9rs6dQf09Yr/eb117jKsB683dD7dR5I2woitaD/iZb2PoLM+yJeFvgCXtzvqQ4OXW+wqrbEdbvMqF88hSd5fjX90VuYRgzvx4xP/DwE2H9Dr42kxqsUiI5AOulmtGAYq/P4laL6c0AP9X4K4hPC8GvPz6Vm6TXoeg38RaZaK6fnKLabfLbuzz6VzosDuQaNJ8qdr6c0Xr7DDVdiCl8MxYHNWP5Z/WGVNxAf/wFZnc7zK/75vklg6+cwuEJpYWA1kYdSOCazfs76GYkRivtZqUSaXekFhtuzEDqjWV8XySmjQSBjgXf7iQGzkSqwGlXme+OihsiGNdouEw62WvhFVokHhYC3S1PxlVZydadram58UAgCkXkzcAsVZIaNm5ZZaX2fI3rl9X90UUpssjtJkUvpgzEnlHlJd5E9HNUYRixYYCOG4KpX2XCRgbZsYy65INYkDqrHJVLkPWS3N0TKisgSSn7LfJug7zpEz9dileA0fohCtGNSHaWaSYLXyISzewNKXox3iw9bwwD8nxDENOdprCGfdMLWWVS27cSFmlmtP6Nj/eqxm8wBENq33MiKWGR1fg8UEmz15OxuqSG+duvzX/+j5AUhB2bzdILOAIXMnbr/930ErhgsYBn1M0vKqlsE4Vzr1vbWViDkloN/bkkI+yCcBHks/bcTS+EbedRl71YO99NiGpNQlp12qaxV66xbcFkhnaLq8v1mufN6yTXO2RdHy+R6+JlJdE4EYbveCLGK1lO8fjQZOAt9I1dlrc65E2P1dCDEkHVPFwKfv1sJhITtu6sdUXH77fJhjFH3xFTxJB1NNFYsfPVlPjdmShqmiawI7ctlo4/YKGU8xfaJD0PL9NEsxIv1bS/9C75Q2lKS1NZu8x7LfvttgU1UpbouIGOZdG0mS4gN73Tuykr/kGr5VBWZKmDRwKiI5Ok4t1gfH7roAb/+j7lqCtlEU9KcwJvFC0c/8nYGdyACSAGEVXORdXUBhVvb0fmHgYU3Qb+IsWbLIQ4Zxe6DaixEJWkXq16HYrdHmUcUoaeeAMXWpA2eeG0d/J+E3+aSNCdTKWUFkbCBu80xTi9KJ3sgjJ1eGVKMY6kBRS92GkS6cBDFVqaulpUbv25IWsZHD66rITfotBJN+i5OOk5/R6LtDHmNoAgwywCaZmsy0kblJBerNCrlewuTFZvPQWci5iVdU4SZ+BT55bYBdkKL9rPui778uurX/gj1gTe1ox9VlA+d3wdjbNVMG3j8a72viUYbn3fiwKxPbxB5nIGJU42Yn1x22Zr6W788vkWn03v4LU6obVE3FaKqj1HWXy98iqt+tkcx+7d0H+3pvKuYRw38EZDaa7ttSkDJXLMj+eouSGdzUXHnVZTSEzzBV4zpvzYbVa7TVZDn7QnpjHRRNN6khI9OBUST5KiR8JMRSmBN3qiIpncHjD+WETaU+Qt4Q8Mv17Q+doJ+sEjx0r2+z2sV21puAf+zgh9c4+zj/dI20p2G2ml8VOejMlns7XvlUXjuODb76AbviEsZajHx3hZjn5qMsNoffG10D4rOEcQoK/tSJAE9AIj8yGGJ0LAWlRibrbsYhzMVi+OxGbRFzVOf5biH56JaiiQ28asI/0pafiDqdvvyg6uKN1cVVkSPhAYank2MTajyn3XXSKTm2y4GaOv75H3Y4rYF3P2p3M4PJEFrSmNcbswBidz+WzMc7lxze0WdODhLzLx903SiombpML8DXzZNQSeeBrMUsnKC03RDUkHEeE8R2Wl9DiMMBueEiiy8ejlbIoqCoFhxmL96CSatZaFd7mS+zbwZAdVg4Y6PoJSUiJaJuil9T0OBL5rZZ9NmZFaM9iKJYqtq7nnlWd2BCZmGLKd3HyqSiTD5w/rH40FoJ69bzZjz2XHJsO+iAx17rVrSKLnUBPd+tzN32vz3uox7KQibBbg1/oR23sOboW3W/ttPQFV8zlmfZejomhtWw/PsQgiGaEzjslSSisGZ7VHDEMTwMrTrpmQ9LroQZfc4LGDWUr0UGQinJVeuyUkJpCteSOC0YCy12T2YltquKUE/uGXTkU6+WQmN8qwh27FDq+NJ/oy00/vMP6Yz+ylHChQqaL/NZ/r/99YzNnTTEheOyMJZIuFlKdGA/SL11nttUj6Pto3ap73M+L7Z07RssSUd+rkqVSMX9Sgh/Y9sYDMcmG6Pjx2EgmuoW63+YZ4VY7H7rP2BwPUsE++23VlDW18neWzyytxv9pnZdFEy5d38JOSIvZoHCf4pwvUKqF4+ITc7Da9fhffIrnMQm7RXepgn+zmAJVrIW1NV+iHT1BBsNbLQHmCNmvG6zvbuOHkD7JuAx16hKcrwodzSQ5sgPM9MWDJcul7PF46JAw39kmud9AKQWU9nqEm86rmbXZTaF3JPvieXO/JAh34lN2Y1X6LvOVJj+Q4xUsL4RIk5hxGfZl7lqNnC6cB5WC5zVhUQ0u9pvypigI9X+DXmsiEQUVUOxNyGEujp+R0x2RHbD8zu1vRxsNBL1eOeyP3a+F2DZWroRFg9EwJ3PfBxwkdPu+4/AvANkjTRTAnFxQr7PuF5ZttAX6bptBF/3+eEhFskNWesWDU/r8J53KBv/4+dSmJTXSRhbUav2DPMFxRYgBTRx+tSUhftIvIchS47Wi9LACsSQKDKQFFkQuEaC3kmfnS1dUdoSUK5car1T7TGwPyjqgxBosSVWqiMwOFe3KE32xKBhY3UKsUZYJieW3E/MUOiz2f488WQI4/9em+rRi8ltL8wlsCJe20BUViJY0NusV7+UWOv3eHZCjn33xaSrb/9jHl4ZHYHJoFHU9Vtf1WS+Z+sEdy0CWYSjbqn8ykhAGURtK3Lj6o5zm6mLnPOLhxIGSkawMBcXiSwXpWNXU6qz47SwIySUawfw3d75DutdFKEZ2l+KcLovEE0kxUS837+O2OXH/rOWsCv7+/ix50QWuKTgOVa4KnUzgZS0nMyIC43kIt01TN2InDZd0G6UCy1vhoRXgor0FRisCbER0kCOT7aOxH7XdUjYbk+z2SoeDw22+OUWczqc23WyK+Nqg5fVkHrqIQiGcYyDxGTZZ7EcGipPU4IRgvpUQEsnA0IrTZMar50qmuqiCQHWGaSqlzuYJ2UxBAnucYw0422vNEKC4KzevleOY1sUCAwHxmBuPvdKJAPlPrPRyFjuNA4MtiWSsZSdnYq5B59f6f1uvij88xLv8C8KwMfHNs4ubXXkc/O8Dbx9jXuei5tYbs1rp6/f1rZZe1932GR8Daa4DrEZxrfEMNk2+0T4pCGlF2QQgDR3Yizyus8Cayx9rNbe4+TGYqOxir52OYwjV/3fq8vGYsqIokEeSMhfoFUgu22Y7TowdT325I4GuFLK5FKA2ddxLB/1uLSTCKlktUHsqNZRq+s1dHnL0YUIagSuj/XiCuVU+neIenkmV2WtBtw3Re1debMeqVO6xudJncichbitaTkt4bM/xHJ5SnY3KTZa8tlsqrsv1mg+SgC0DaD/AXOcHTMfp0LAzQWsmvfm3tNfN3d4T8ZIhHXpKjDNRRn44pawSf+vW2XA29NyIdxGTdkGic4mcF/qOTqi9g38tIZNjvgdcUMxm1MyDvN8kaPmWgiO+f4b/9hPJkTFEUThrF73UkCbBJhREeU502DHos7opUgw5k1xGcLeHhEydtrDptVwe3EiT2nlPttmTigU/ejsjbIa03Tx3iR4MDFKCUE1KjKGQ32W2jo5Bit0vRDCQDXxV07s0JHp1KgPZ98p0OZezjzzPZBUznAneGSmzO7MosmU23m9Lk1VqADoUg6Cwz3pnGp0bywTR7Mf0StRQZdblXgyr5MU1eQEpMIc5ZrU7UcwttvV9QI4q5/sv7wP/bcfkXANgevN/rZHUJ1ALtJlN289i2/28e3+QKrJWmbI9igwdwIV+h/pgtpSfbQN3sC9RUQi/kL5jdgPMTNbIMwJr/gU4zdGl2FnYbD6YWXs1RF4iF5jNcxrxmXMtoTHZZczRShvEo8hNLx24kEg13HYckOzFF0yOaGJ2a+0eiomkzJnvNlIfOhLiU39xlcaPJ9JZPGUmZqHcvI5xkhPeeoLMMPRpQDFpSN57OKcZnMl/TkF7sh+SxIh6XNN7Kib/2yNlE2kDrylUGlurtjCj2++S9hpiJT1PKZkD3a6dOJqGYzNaNjGomQSqKhFDWbqHjhngU26bk2ChwGgRIHUlkS3lepy0BxjQaw9MlwdioYCbijVsaY/Y6j8Tu3vx+D3ZHTvNGaU14tMBbrIRjYWvJnnLEJLvoOy2pIMAbDQHIRobDME/xjiciSWG/Io1IDNrzXD6PxbKS5TZlN/odx54N3j3Gz8W0RQeBY8milNtFUpaubKiHPbJRi7wtbnd+UhAdLQSrbwxZykHbSUGEpyu8p+IloXyvgrKGJvmhFjuMMbxtMNvgX5rrrtJMkD6YnbA5X9eXWCYOTuxIcqSV96+5L7RpHtsdo/u+1WxqKUvXO3AVAdcL9Jxsiy6KP4I8gM1F4CKsfS3gnsPQ18czeAJrz3lGL+FZXr5bX9c+1+0i3Mlsh7nWS1o20G+K2FFlpDYzcxlnmq1pyzgBOHDCXSqKKn8AcFlZRZITfoEuqHYXtcXIbUODwEk/l6aZ6i5XUVSLrgmIXq/rBMJ0KHK60TjFf5iKPtB8IazP0fCc3onFbE/utkh7Ci+F7oOC1sMlwduHUtIZ9qU/YNyc/PFC5CdaTdSrL7M4aJO3PYpQ+gs7X5qIsfvJmNxdrwqi6w36gk4qNdm1PstRJCWSVYFnMm5KkZQoLCLKLuDms1oL3qaurD0PlWay00kSkfGu9WmqiyiQYW/Qh50BeS8WM/tVpXBJWYoWUv36mx2brQ17g36FpmmG+MtM4KiLlewYrAx2p21KFoU0hU2T0Ws28YYD8DzKnR6kOWqVEhzPpFSUpCKl7fuV8UuSUJpFXzUikbn2PDzLAB72JEs+HkuPJIpQ13Yd01cDTKV3YKGsRCFlu4mOA4p2SBEKwicar/Cfik0pnkc57FF0G5SxLxyJ6VwWIcMoJvAdJFTnBSrwK9kTJbwHfE8Yx6UWCey44cpGermURaptdpfgvAL0KpH6fCuuOAOlwFWVFYPzlCRENcit1ZYCjMJn7Z7f5A95Ci+Kq6/J+9ABgo/CAqA8zsk5QBWUN1U41/62pfZu/781sBsy1Wbwrz+2VorZak1pH3PRrqWesddeb+tita1UVH+f+jEqYo5l6KJF8tnpiRTFmnG0LQEAsg22ZYa1HYnlDlQNaweXtFmM763pl1jYmoO2ZpXKqBeFUnvttMhHbdFemaxQZzM8oxFDKDhzPE9uzjRzeimWMbvcDchb0H5S0Lo/x3vnUBASQSCSEqEvQlyHx7L72B8x+YG7JF2PaK6JJuJ2pZJCjOEPj6TcYRQsbb/D67Thxj6rgw5pPyBYyfVuHAvRx2a7hWmMqzCoGu8WCtmMJdNvRBSjNjor8A/PUEb7qLQ9lBp8c9NS1Ot28UYDym6bbLclSJjTOeXTYyP/LEHXBos6Msu7viOOWyALUuDhPR2jEslOC4sgAtNc9Fz5T/k+qtd2jf5y1EWvMnQcVgtHLmUgvTOUjHqZgFKSzZp+j2o05DHNBmVTCIPsDeT6vftYmvK2hDgcoBuRLApz8R5WvhEbjBsOWWW/m/4sJTwzGP1Sux2V9j1UZvSPDD9C9XswGgiiycoyg+wArOmL78u9k6TuO6itWXtROk6ARko3ut2kbMd441l1XxqQgba7AUPuIvBd2dM+zkKknfRKqcUHYaPBLzt10/jF7EaNleZag/h9kMEu/wIA64G1fuwcm3UbnFOf/7vyWNdXsO9Rg5nW/92GFLqQELYBVa0Rs7aWUOrPg7Wgf44XUBd3q/MYbJZey/gBvHa7JhJVwwxbPH+jgfKknOI8AGooorV5mXOpy81aluimM9Fa8LdfSmNGr7pdIY75nnjUzpZOPloQJWY3UWr0yiBFjC9xNmyRdQKKpkf3gdjwxa8fistWHMO1PWkCnpwJazhJ8IYD5t91k7MXQ5IheAUM/98l4b1DcdYqNXlRSKC0EhhJ4noZy1cPmNyJSAaK9qMS7fv0vjFBPTqSGjk4ITgKajsVEYbTnZawQw2KBMA7M0qaxsd4bSiv+lw931ko6pv7lEC62xKm7KNTiseHTsTPXfeavIlFEhWjjit/RPdPwTCiHWTQWjNq7XR+JLjFMOg5fSJ/luBNzWcymYnqqsnqdSMk3+3zObi7AAATgElEQVRIo9UQ2VQYGs5CKPwMWNsZeqdTkb/W4u3rPAMWyxpzWhBBqtkUVFErdlm/lxQO3USp0d0WRSsS4xcgOJrBeEJpdg7eaLjRyE1ckFXtVlXWyXJUXrsHIuENqFXqmsiqJUqplkel5is5b4vOajdFgjpJ0acr2WnUCGQWBWXVZDcRP2smMUGt7Gv6dtYLoA4jXyNyPue43EQwb0d/f/jD2+UQto16hlyv0T8rc94Gp1wL+lsWkI1hSwXbyjNbF633IG+de8wFDeJzo75AmHKDrmWX1hKRIBBERlqVe+ribvUdxNrrmXLPmhS3yVLrpSd7zZx5jEU2WJKWqYsC6Cxz+v2OXGPF4oymej5oknUC2eKfriSAPjqsrCvjBroRCtv4VKCU3s6I5OV95jcisqYCBc2TkvY7c9Tvvel0VmwvwjpVAfJ63RaTV4dkLfEfaD3NCc8yorcOK5kFmyGb4KmzHJ2l+Ls7sL9DZhA5wUyYtqSZK2XUd2LnFlmjx6TawrrVvpQLHOnr4ZP1xl/te+vKRMMe+V4X/8ywiKfzSqKBKrmoQ1J1nktiYL0Jmg3KfosyCvAXKerxsUhlNxpiidmM5fpb4xPDSVDNGHaGLO8MaBwtJTitDBx2JvaHyvPQZbnGqtV5IX0CKz9hyiGq23XN37LTQCWF63UQ+JQ98fAFZDd5OpHvVZ675+ooRDd88beezBws03oSy0Wy/Te1tmCzXDnAgf0O62YESokXRlnKwuV7FVkrzUxpRwtB0eyMdJ47NdS1OOUbJnCt9GqDvBUS1LUdatVINvdgnSSWJM/NBL7cOwC92XDcKMPA1qApX+otTF/3uluC/wXvf+6968+zr1sXdXNzKc+/Tl3J0z52q5porfQE5zV8nnHursRUJ5l5fiXdkKUO0meHNfbWqwQ9nxsqvEJZVUddEcaqkk7FW7DvV1eZdIYgZtuuG6HcUGfS4ATkplJeJQ9sjbAHPfB9im7sMr3m/YkYjJ9NJJNUSuSgoxB9PBaryGYszdlrA2bXxXmreZjRP13hPzyWAJOlwoTtdSRoJaZU1mpS7g3IOxF5JyTp+wRJSfMop/X2Gfr+IydPIGU1QTE5vRiTTXv9LuWL18m7DYGxLlP8ownaBF73mWx+nraZPujLTWyDxkoaiTpJxDPA2jNufMf9fg/V76HDwPnTBmOTZd57QG7lJJpxleXbzzQMqrJe3JCmPIgn9NFE/Gx1SXEyluZxFOIFPTd/vcoBk0m/eJOyFbG41ULlsNpvieFPWYoSrGVahyaglgZ/v1hW9f9uBy+Kqvq8pySTXqzwF9L41u3Y6QOpUgtc9nQiQnlFIf4V5nqABGTveCz1f9+vgn9ZQo6TurBa/cqwsuW7naEMp8ElRKb3QZpVInWFlmtlynF0zQIOlSdAvUavy4rAZ29pK+1cVKY8tqRq56vt64NrYNdJYn+ojmBKqZ8D/k3gUGv9GXPsbwF/GkiBN4Cf0FqPzd9+GvhJZEP8H2mtf9Uc/2Hgv0Xa6/+z1vq/fM/ZPatRC+cDrQmA6yUMe7NtCciev/4am5n5RSWlTZz8MzD0246tlVks9HJNHbRWf6/BTrcG/9p7rL1Olkq9PvArw5L53AX+unk8yqMcn0lWWhYS4JzrWunQGmiR40WXaxpGddE5Z2RiaqMAeipqihbV4sSvcuM6ZWCiarcHjUganFrjny5Et93q5helaMs0mxIclgn6zATWV++yuC6En9KH9qOU9msTyfasVHC/U+0+TMPVWlvOPzZkOQqI5iXhJKd5VBIdLVDvHkp/w/Okcd02do0PHrks1erj6FUCg540tJ+K6YueTOVmNje+K9Epzxl4W5kEQEpG1rv2yTHFZLK98e9kNwSRlB8IGkf7nmTrqwyePF1zFqvvVO2uz+t2pKnaiKQ8YvstxtR9zeCmGTt/AgCyVD7n/R7a88h2W3hZSdYJ8FeaYJmj0lK8cacmsWg1JWCGvriJWWw84F/fFztHpUTpMzWZ9Xwhn3m/Qz7qiNBbXuLPM5GCWCQuu7Y6SWgtTdfpvEowwHx3AtlNaS3kq5oktXVyw3BDHLy0E4le0cIge4w0tO53HIiBzNTiG5EYwudlhRIy7mrOtc2YJjnLzl7H7QTEz7v6zJ0SLNXOzbP+G1aWQudrkOPnHc+zA/h7wH8P/Hzt2K8DP621zpVSPwv8NPDXlFKfAn4M+DRwA/gNpdTHzXP+B+DfAB4Av62U+mWt9e+957tvKXmsG8Rf0PitHz+3zd7yWJvNPqvcsq1ctpl9b5ahLjgHwGXRDtdfbpjQbIN4nuM31FBPdaN6W5bB7AbMF3utMelJvbsu66yasewUrLrqbF7xDWqGMZtlOctUVt2OIByi0GU9ej53OwSHpc9EKtnrtEVp0ei4o5TowBhv4LJGEPOsMuNyiU5SvEGf4u510lHM9HYAGrr3M5oPpvDwUG6iVkvw/2UpDT9LGGq3odOi6DdJRzFZ2xe3rHcXeFPRjLcLD+DMyFWWo88m2JqrunUgjNM4EPXHvBDeQZZVjGsr5lVqt8B6vZ4I6QUiE4HBz6uswDs6cyJ0db5A3YvBll/YG1K0Irfwhw9PKE/G0li2n2lYlbrs7stae2rTjwGgEGMdPRZHNgsjxTP3hqnPO0huGFHc3HUonGCei4ViKcYpOg6EsW2/f8o8f5WIE9ZyJQtoryuoqKZByownsliY91DGmSwfCY8gmGdS+zf8Fdn1dOSzMbsmy+jVaeokr10ZB6SUZprg7rqCLHB+KPdGr0MxbDkF0fBkLs1cz0N3W05/SGUmaQt8dNgSgbysENZyWUryEVXNZb1KKgKeEeqzgVwvkprhj9l9byB7pBRb6QW9n4x/c7znAqC1/mdKqTsbx36t9t/PAf+e+f3PAv9Aa50AbymlXge+z/ztda31mwBKqX9gHvvsBeCC/sTWstDmcMHcq7bLm4F0EyW0iTg6h+G/oFewrTR1kYk7rGn+n/MAXvMB2DLf94KbOu+BUnRpanVGp0YJomm/Grvs0B8MnOk2ukRPl5UKKDjij9uymvcRFmwoAdWe32JJeXJaMWahhuPXEoAbDYEz7nadoJd/Ojc8gZUwRoNA0B9mzuVkKoF4Z0ix2+HsVkzWEqexwWsJjTcOKU9Ojb+sEazrtsFkbHrYg47cuMlOk2QQiMTASUb3SFQi9WIpOx+j0UIhCI1yfCY3a1cgs2p/F91qkDdlUQwfjaVuvEyq7K6o1BqtrICKR9CMSW8PyWMfPykF0fP4CUxnFEZLyPIPnARwmrldm4obZLd2KEMPFARTw5k4HVPYhdZk/KoRiUexsfxUcUN8FXxPzi3LYbKSBctAUK22v2fc3ty9ZOGd3S4EPsWOfHYUmvjpVPpKYSCQ0DBAjYXMVJdq17bM43t4L96Saxj5Qso6OXPXTrWaqF7XNV0pCoKTeVVbTzP0wR75sIVWyI7gJKtkyKFaXOpQT1OGcRm2qZ+rIHDOd+WgQ2lM3FVWECwz4RSA7ACt+q11AotCin5shOWWzg/A7TKisBKUSzPD4FaS/BjhP6udpcIAr92savw1VJ2dpwV01HcFdrj7bL2ydOH4w+gB/AXgH5rfbyILgh0PzDGA+xvH/9hzvfpFNW94dtkFXDA9R9zSGjafsi1L39KgWzu+jVxm52NrhfVyz5bdSh0nXkcX6Wx9Adk0tXeksG1mL5vIJZtBFuIB7DIM30dFsdwkUei0ZmzmZxE/KoqqnYLJzFQoAmI2M3ba5qZJ7EpIhu6vwsAZxBNG4j/bjiuLvbxwrErl+2LS0YicqYlqRHh7O6zu7nD2UoTKoTEtGX11jv/2E3n/IEAd7MuNkhqv16JEm0x/td+kjBR+UqIKCOeiQhocTkSvJctgIOUMtUwgy5xevN9sokd90v02pa+IxonwC5aZNALzwvm7UpauAe71u5L57QzEwawsKXoxKi1pzFKRizgdO9KYVRSFaudgewvs74g3bjPEP1sRzpfCNs5y8sUCv9/DGw7W+gXlVFzF/H7PXXfKEqYzJ0/h5tppV969WWaajYWT9QApMWlfNHb84ymsEqLTUAJhpyWyDFEIvsKb5YKGMR7PaI1/8wAdR2R7bbxljio1wdEUPZmKN25LeAba96RkY2+pLEefzQwjuE3+YpdkJ8bLShpHS7zJAj2do3Up2b7VWTIKrJjdrk7qpZVovRcQm8Z3Q8KilxYS+IuCctCpyjxZjrfIXXO57EQS/FNjAFQXqbN+AamW+fieq/Fb/SlXoqspfrrFNgrX7VYNg71q3kcVjLTZdAv5844/0AKglPoZIAd+wR7a8jANbOuybk3vlVJ/EfiL5r+z3yh/6Rg4euZEvhkg0ze/a3rW2AWO1uaz7bN4P/O1j023HNt2DnrjXzu2PbZgl5QjZlv/tn3udqTmZ37B3y/KQC56/HuPXZ5yxBvv8aiTb/r1ZTzdcszO+eH7eqVdCo7c6z1+jmdcdM0L5Hpum1t9nJqfzaEvOL7+HrucXHCfzfmDX1c73uvzmzzHaxyyyxvvERMu15C48KzxnBn7M5+3/hm/+DxP/6YXAKXUjyPN4T+pKyzpA+B27WG3qG6bi46vDa313wH+Tu19fud54EyXYXyU5gofrfl+lOYKV/P9Vo6P0lzhcs/3/asHgUX0/DXgz2itF7U//TLwY0qphlLqLvAK8FvAbwOvKKXuKqUipFH8y3+wqV+Nq3E1rsbV+IOM54GB/iLwrwO7SqkHwF9HUD8N4NeV1Jo/p7X+S1rrryql/hHS3M2Bv6y1gN+VUn8F+FUEBvpzWuuvfgvO52pcjatxNa7Gc47nQQH9uS2H/+4zHv83gb+55fivAL/yvmYn4++890MuzfgozRU+WvP9KM0Vrub7rRwfpbnCJZ7vpZaCuBpX42pcjavxrRvfVA/galyNq3E1rsZHf1zaBUAp9cNKqa8rpV5XSv3UJZjPbaXU/6OU+n2l1FeVUv+xOf43lFLvKqW+YH5+tPacnzbz/7pS6oc+hDnfU0p92czrd8yxkVLq15VSr5l/h+a4Ukr9d2a+X1JKfc8HPNdP1K7hF5RSE6XUX70s11cp9XNKqUOl1Fdqx973tVRK/bh5/GsGSfdBzvdvKaW+Zub0j5VSA3P8jlJqWbvGf7v2nO8136HXzTm9P62BP9h83/dn/0HEjQvm+g9r87ynlPqCOf6hX9tnDq31pftBGsVvAC8BEfBF4FMf8pwOgO8xv3eBbwCfAv4G8J9uefynzLwbwF1zPv4HPOd7wO7Gsf8K+Cnz+08BP2t+/1HgnyBcju8H/vmH/Pk/RrDMl+L6An8C+B7gK9/stQRGwJvm36H5ffgBzvcHgcD8/rO1+d6pP27jdX4L+OPmXP4J8CMf4Hzf12f/QcWNbXPd+Pt/Dfxnl+XaPuvnsu4Avg8jHaG1TgErHfGhDa31I631583vU+D3qVjO24aTxdBavwXUZTE+zPFngb9vfv/7wL9VO/7zWsbngIFS6uDDmCDwJ4E3tNZvP+MxH+j11Vr/M87Tod7vtfwh4Ne11ida61NEU+uHP6j5aq1/TWtthWU+h/BxLhxmzj2t9W9qiVg/T3WO3/L5PmNc9Nl/IHHjWXM1Wfx/APzis17jg7y2zxqXdQG4yXnpiGcF2w90KNFG+m7gn5tDf8Vsq3/OlgG4HOeggV9TSv2uEoY1wDWt9SOQRQ3YN8cvw3zt+DHWb6DLen3f77W8DHO24y8gWacdd5VS/0Ip9U+VUj9gjt1E5mjHhzHf9/PZX4br+wPAE631a7Vjl/XaXtoF4CJJiQ99KKU6wP8O/FWt9QT4H4GXge8CHiHbP7gc5/Cvaq2/B/gR4C8rpf7EMx57GeaLEqLgnwF+yRy6zNf3onHR3C7FnNV5CZdHwAta6+8G/hPgf1VK9fjw5/t+P/sPe74Af4715OWyXlvg8i4Az5KU+NCGUipEgv8vaK3/DwCt9ROtdaG1LoH/iaoM8aGfg9b6ofn3EPjHZm5PbGnH/HtoHv6hz9eMHwE+r7V+Apf7+vL+r+WHPmdVSbj8h6b0gCmlHJvffxepo3/czLdeJvpA5/tNfPYf6vVVSgXAv0Mljnlpr60dl3UBuHTSEaa293eB39da/ze14/U6+b8NWGTARbIYH9R820qprv0daQB+xczLok9+HPg/a/P98wbB8v3AmS1vfMBjLYO6rNe3Nof3cy1/FfhBpdTQlDN+0Bz7QIa6QMJFKbWnlPLN7y8h1/JNM+epUur7zff/z9fO8YOY7/v97D/suPGngK9prV1p57JeWzc+6K7z8/4gSIpvICvmz1yC+fxryBbtS8AXzM+PAv8L8GVz/JeBg9pzfsbM/+t8wB1+BAnxRfPzVXsNgR3g/wJeM/+OzHGFmPa8Yc7nsx/CNW4Bx0C/duxSXF9kUXoEZEj29pPfzLVEau+vm5+f+IDn+zpSI7ff379tHvvvmu/IF4HPA3+69jqfRQLvG4gxlPoA5/u+P/sPIm5sm6s5/veAv7Tx2A/92j7r54oJfDWuxtW4Gt+m47KWgK7G1bgaV+NqfIvH1QJwNa7G1bga36bjagG4GlfjalyNb9NxtQBcjatxNa7Gt+m4WgCuxtW4Glfj23RcLQBX42pcjavxbTquFoCrcTWuxtX4Nh1XC8DVuBpX42p8m47/H03OA5EqRlzLAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\21-Mar-2022_13-22PM\\Volume_Fluorescence Image_2022-03-21T132350437066f_channel_0_channel_1_channel_2.tif\n", - "(1, 4, 1, 1200, 1920)\n" + "C:\\Users\\Admin\\Github\\piescope_gui\\piescope_gui\\log\\28-Mar-2022_15-41PM\\Volume_Fluorescence Image_2022-03-28T154607648093_channel_3.tiff\n", + "(3, 5, 3, 1200, 1920)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -123,13 +242,15 @@ } ], "source": [ - "ch_img = tf.imread(filenames[-2])\n", - "print(filenames[-2])\n", - "print(ch_img.shape)\n", - "img = ch_img[0, 0, 0, :, :]\n", - "img.shape\n", - "plt.imshow(img)\n", - "plt.show()\n" + "for fname in filenames:\n", + " ch_img = tf.imread(fname)\n", + " print(fname)\n", + " print(ch_img.shape)\n", + " for n in range(ch_img.shape[2]):\n", + " img = ch_img[0, 0, n, :, :]\n", + " img.shape\n", + " plt.imshow(img)\n", + " plt.show()\n" ] }, { From 97d42181cc39e5a0852d1f23daf6eccc450905bd Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 14 Apr 2022 15:06:22 +1000 Subject: [PATCH 70/82] updated phase calculations (hardware) --- piescope/external/PI Macros/MAIN.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/piescope/external/PI Macros/MAIN.txt b/piescope/external/PI Macros/MAIN.txt index 539a730..39bf43c 100644 --- a/piescope/external/PI Macros/MAIN.txt +++ b/piescope/external/PI Macros/MAIN.txt @@ -1,9 +1,9 @@ -VAR 0DX 0.0082 +VAR 0DX 0.0164 VAR 0DY 0 -VAR 60DX 0.007101 -VAR 60DY 0.0041 -VAR 120DX -0.007101 -VAR 120DY 0.0041 +VAR 60DX 0.008031 +VAR 60DY 0.006564 +VAR 120DX -0.008031 +VAR 120DY 0.006564 MAC START MOVEA -2 -2 MAC NSTART PHASE $1 MAC START MOVER ${0DX} ${0DY} From 86a78f5d3bfcb2546ff61e4cefc73ef3a4849eb3 Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 14 Apr 2022 16:13:57 +1000 Subject: [PATCH 71/82] remove old volume acquisition function --- piescope/lm/volume.py | 215 +----------------------------------------- 1 file changed, 2 insertions(+), 213 deletions(-) diff --git a/piescope/lm/volume.py b/piescope/lm/volume.py index 21498ed..3b9a310 100644 --- a/piescope/lm/volume.py +++ b/piescope/lm/volume.py @@ -11,7 +11,7 @@ from piescope.lm.arduino import Arduino import piescope.lm.structured import piescope.lm.mirror -from piescope.lm.mirror import PIController, StagePosition, StageMacro, ImagingType +from piescope.lm.mirror import PIController, MirrorPosition, StageMacro, ImagingType from pypylon import pylon logger = logging.getLogger(__name__) @@ -93,7 +93,7 @@ def acquire_volume( for z_slice in range(num_z_slices): if imaging_type == ImagingType.WIDEFIELD: mirror_controller.stopAll() - mirror_controller.move_to(StagePosition.WIDEFIELD) + mirror_controller.move_to(MirrorPosition.WIDEFIELD) channel = 0 for laser in laser_controller.lasers.values(): @@ -217,214 +217,3 @@ def grab_slice( detector.camera.Close() # CPAYX return images - - -# def volume_acquisition( -# laser_dict, -# num_z_slices, -# z_slice_distance, -# time_delay=1, -# count_max=5, -# threshold=5, -# phases=1, -# angles=1, -# mode="widefield", -# detector=None, -# lasers=None, -# objective_stage=None, -# mirror_controller=None, -# arduino=None, -# laser_pins=None, -# ): -# """Acquire an image volume using the fluorescence microscope. - -# Parameters -# ---------- -# laser_dict : dict -# Dictionary with structure: {"name": (power, exposure)} with types -# {str: (int, int)} - -# num_z_slices : int -# Amount of slices to take for total volume - -# z_slice_distance : int -# Distance in nm between each z slice - -# time_delay : int, optional -# Pause after moving to the top of the imaging volume, by default 1 - -# count_max : int, optional -# Maximum number of attempts to move the stage to its target position. -# By default 5 - -# threshold : int, optional -# Threshold cutoff for deciding whether the current stage position -# is close enough to the target position. Must be a positive number. -# By default 5 - -# phases : int, optional -# The number of phases for structured illumination, typically 3. -# Must be a positive number. -# By default 1 for widefield imaging - -# angles : int, optional -# The number of angles for structured illumination, typically 3. -# Must be a positive number. -# By default 1 for widefield imaging - -# mode : str -# Imaging mode, by default widefield. -# Possible values are "widefield" and "sim". - -# detector : piescope.lm.detector.Basler(), optional -# Fluorescence detector class instance. -# Default value is None. - -# lasers : piescope.lm.lasers.Laser(), optional -# Lasers. -# Default value is None. - -# objective_stage : piescope.lm.objective.StageController(), optional -# Objective lens stage class instance. -# Default value is None. - -# mirror_controller : piescope.lm.mirror.PIController(), optional -# Stage controller for structured pattern mirror. -# Default value is None. - -# laser_pins : list of str -# Pin names to trigger pins via hardware. -# Individual names passed as 'PXX', with XX being the port and pin number, respectively -# Default values is None. - -# Returns -# ------- -# volume : multidimensional numpy array -# numpy.ndarray with shape (z_slices, columns, rows, channels) - -# Notes -# ----- -# It's good to assume a minimum of 0.5 microns per step, -# and a maximum 300 microns total height for the volume acquisition. -# """ -# logging.info("Acquiring fluorescence volume...") -# num_z_slices = int(num_z_slices) -# z_slice_distance = int(z_slice_distance) -# total_volume_height = (num_z_slices - 1) * z_slice_distance - -# # Initialise hardware -# if detector is None: -# detector = piescope.lm.detector.Basler() -# if lasers is None: -# lasers = piescope.lm.laser.initialise_lasers() -# if objective_stage is None: -# objective_stage = piescope.lm.objective.StageController() -# for laser_name, (laser_power, exposure_time) in laser_dict.items(): -# lasers[laser_name].laser_power = laser_power -# if mirror_controller is None: -# mirror_controller = piescope.lm.mirror.PIController() - -# # Move objective lens stage to the top of the volume -# original_center_position = str(objective_stage.current_position()) -# objective_stage.move_relative(int(total_volume_height / 2)) -# time.sleep(time_delay) # Pause to be sure movement is completed -# logger.debug("Objective lens stage moved to top of the image volume.") - -# if mode != "widefield": -# angles = 3 -# phases = 3 - - -# # Create volume array to put the results into -# array_shape = np.shape(detector.camera_grab()) # no lasers on -# volume = np.ndarray( -# dtype=np.uint8, -# shape=( -# len(laser_dict), -# angles, -# num_z_slices, -# phases, -# array_shape[0], -# array_shape[1], -# ), -# ) - -# # Acquire volume image -# # For each slice -# for z_slice in range(int(num_z_slices)): -# logging.debug("z_slice: {}".format(z_slice)) - -# if mode == "widefield": -# mirror_controller.stopAll() -# mirror_controller.move_to(StagePosition.WIDEFIELD) -# for channel, (laser_name, (laser_power, exposure_time)) in enumerate( -# laser_dict.items() -# ): -# logging.info("z_slice: {}, laser: {}".format(z_slice, laser_name)) -# logging.debug("laser_name: {}".format(laser_name)) - -# image = detector.camera_grab( -# exposure_time, -# trigger_mode="hardware", -# laser_name=laser_name, -# laser_pins=laser_pins, -# ) -# image = np.fliplr(image) -# volume[channel, 0, z_slice, 0, :, :] = image # (CAZPYX) - -# else: -# # n_images = angles * phases * len(laser_dict) -# slice = detector.grab_slice( -# mirror_controller=mirror_controller, -# arduino=arduino, -# laser_dict=laser_dict, -# ) - -# slice_reshaped = np.array(slice).reshape( -# len(laser_dict), angles, phases, array_shape[0], array_shape[1] -# ) -# # assert slice_reshaped.shape == () - -# img_index = list(range(len(slice))) -# for channel in range(len(laser_dict)): -# for angle in range(angles): -# for phase in range(phases): -# # get the index for each parameters image in the slice -# # see notebook for details -# idx = img_index[channel :: len(laser_dict)][angle::angles][ -# phase::phases -# ][0] -# # idx = test[a::N_LASERS][b::N_ANGLES][c::N_PHASES] -# slice_reshaped[channel, angle, phase] = slice[idx] - -# # Channel, then phase, then angle -# volume[:, :, z_slice, :, :, :] = slice_reshaped # (CAZPYX) - -# # Move objective lens stage -# target_position = ( -# float(original_center_position) -# + float(total_volume_height / 2.0) -# - (float(z_slice) * float(z_slice_distance)) -# ) -# objective_stage.move_relative(-int(z_slice_distance)) -# time.sleep(time_delay) # Pause to be sure movement is completed. -# # If objective stage movement not accurate enough, try it again -# count = 0 -# current_position = float(objective_stage.current_position()) -# difference = current_position - target_position -# while count < count_max and abs(difference) > threshold: -# objective_stage.move_relative(-int(difference)) -# time.sleep(time_delay) # Pause to be sure movement completed. -# current_position = float(objective_stage.current_position()) -# difference = current_position - target_position -# logger.debug("Difference is: {}".format(str(difference))) -# count = count + 1 -# piescope.lm.structured.single_line_pulse(100000, "P04") -# # PO4 IS OBJECTIVE READY PIN - -# # Finally, return the objective lens stage too original position -# objective_stage.move_absolute(original_center_position) -# logging.debug("Volume acquired, stage returned to its original position.") -# logging.debug("Volume array shape: {}".format(volume.shape)) -# logging.info("Fluorescence volume acquistion finished.") -# return volume From 23146b87aa350c1a8b56d18fe8ca1b2e1a3a877e Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 14 Apr 2022 16:16:42 +1000 Subject: [PATCH 72/82] add phase selection --- piescope/lm/mirror.py | 38 +++++++++++++++++--------------------- 1 file changed, 17 insertions(+), 21 deletions(-) diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index 3478203..d0a181f 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -2,13 +2,21 @@ from enum import Enum, auto import logging -class StagePosition(Enum): +h_move = [0.0164, 0] +s_move = [0.008031, 0.006564] +o_move = [-0.008031, 0.006564] + +class MirrorPosition(Enum): WIDEFIELD = [3, -2] HORIZONTAL = [-2, -2] + HORIZONTAL_120 = [HORIZONTAL[0]+h_move[0], HORIZONTAL[1]+h_move[1]] + HORIZONTAL_240 = [HORIZONTAL[0]+2*h_move[0], HORIZONTAL[1]+2*h_move[1]] SIXTY = [3, 3] + SIXTY_120 = [SIXTY[0]+s_move[0], SIXTY[1]+s_move[1]] + SIXTY_240 = [SIXTY[0]+2*s_move[0], SIXTY[1]+2*s_move[1]] ONETWENTY = [-2, 3] - - + ONETWENTY_120 = [ONETWENTY[0]+o_move[0], ONETWENTY[1]+o_move[1]] + ONETWENTY_240 = [ONETWENTY[0]+2*o_move[0], ONETWENTY[1]+2*o_move[1]] class StageMacro(Enum): MAIN = auto() @@ -30,37 +38,25 @@ def __init__(self): self.device = GCSDevice() self._open_device() self.axes = self.device.allaxes - self.move_to(StagePosition.WIDEFIELD) - self.current_position = StagePosition.WIDEFIELD - self.mode = ImagingType.WIDEFIELD + self.move_to(MirrorPosition.WIDEFIELD) + self.current_position = MirrorPosition.WIDEFIELD + self.set_mode(mode=ImagingType.WIDEFIELD) def home(self) -> None: """Returns the stage to 0 on all axes""" GCSDevice.MOV(self.device, self.axes, len(self.axes)*[0]) - def move_to(self, stage_position: StagePosition) -> None: + def move_to(self, mirror_position: MirrorPosition) -> None: self.stopAll() - GCSDevice.MOV(self.device, self.axes, stage_position.value) + GCSDevice.MOV(self.device, self.axes, mirror_position.value) self.start_macro(StageMacro.ONTARGET) - self.current_position = stage_position + self.current_position = mirror_position logging.info(f'Current position: {self.current_position.name}') def get_current_position(self): """Returns currently set position, not necessarily actual position""" return self.current_position.value - def next_position(self): - """Moves to the next SIM angle""" - if self.mode == ImagingType.WIDEFIELD: - return - self.stopAll() - if self.current_position == StagePosition.SIXTY: - self.move_to(StagePosition.ONETWENTY) - elif self.current_position == StagePosition.ONETWENTY: - self.move_to(StagePosition.HORIZONTAL) - elif self.current_position == StagePosition.HORIZONTAL: - self.move_to(StagePosition.SIXTY) - def set_mode(self, mode=ImagingType.WIDEFIELD): self.mode = mode From 52b7d3ce91b5724eaec400d038c2d62897f44081 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Thu, 14 Apr 2022 16:51:41 +1000 Subject: [PATCH 73/82] updated phase movements --- piescope/lm/mirror.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/lm/mirror.py b/piescope/lm/mirror.py index d0a181f..288e8f5 100644 --- a/piescope/lm/mirror.py +++ b/piescope/lm/mirror.py @@ -3,8 +3,8 @@ import logging h_move = [0.0164, 0] -s_move = [0.008031, 0.006564] -o_move = [-0.008031, 0.006564] +s_move = [0.008031*2, 0.006564*2] +o_move = [-0.008031*2, 0.006564*2] class MirrorPosition(Enum): WIDEFIELD = [3, -2] From 12c67317c486c910472faa44ad5be2acbfecdf97 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 9 May 2022 15:46:54 +1000 Subject: [PATCH 74/82] change to piescope filing --- piescope/external/{ => piescope_arduino}/piescope_arduino.ino | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename piescope/external/{ => piescope_arduino}/piescope_arduino.ino (100%) diff --git a/piescope/external/piescope_arduino.ino b/piescope/external/piescope_arduino/piescope_arduino.ino similarity index 100% rename from piescope/external/piescope_arduino.ino rename to piescope/external/piescope_arduino/piescope_arduino.ino From 995c14fc097fbc68bb6ef4a5b75e76003f2c3807 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 9 May 2022 15:47:02 +1000 Subject: [PATCH 75/82] updated stage shift --- piescope/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 3537169..948b648 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -4,8 +4,8 @@ system: default_path: log/ pretilt: 27 relative_lm_position: - - 0.0499092 - - -0.0001143 + - 0.0499651 + - -0.0000472 fibsem_min_position: -10.e-3 fibsem_max_position: 10.e-3 lm_min_position: 40.e-3 From 7f8d275961b8ca29b75e66ca8b1f2d9b65e9ffa3 Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 19 May 2022 16:25:14 +1000 Subject: [PATCH 76/82] add dcam API --- piescope/lm/dcam/dcam.py | 714 +++++++++ piescope/lm/dcam/dcam_live_capturing.py | 108 ++ piescope/lm/dcam/dcam_show_device_list.py | 45 + piescope/lm/dcam/dcam_show_properties.py | 43 + .../dcam/dcam_show_single_captured_image.py | 92 ++ piescope/lm/dcam/dcamapi4.py | 1336 +++++++++++++++++ 6 files changed, 2338 insertions(+) create mode 100644 piescope/lm/dcam/dcam.py create mode 100644 piescope/lm/dcam/dcam_live_capturing.py create mode 100644 piescope/lm/dcam/dcam_show_device_list.py create mode 100644 piescope/lm/dcam/dcam_show_properties.py create mode 100644 piescope/lm/dcam/dcam_show_single_captured_image.py create mode 100644 piescope/lm/dcam/dcamapi4.py diff --git a/piescope/lm/dcam/dcam.py b/piescope/lm/dcam/dcam.py new file mode 100644 index 0000000..1a07e4b --- /dev/null +++ b/piescope/lm/dcam/dcam.py @@ -0,0 +1,714 @@ +# dcam.py : Jun 30, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. +# +# The declarations of classes and functions in this file are subject to change without notice. + +from dcamapi4 import * +import numpy as np + + +# ==== DCAMAPI helper functions ==== + +def dcammisc_setupframe(hdcam, bufframe: DCAMBUF_FRAME): + """ + Setup DCAMBUF_FRAME instance based on camera setting with hdcam + + """ + fValue = c_double() + idprop = DCAM_IDPROP.IMAGE_PIXELTYPE + err = dcamprop_getvalue(hdcam, idprop, byref(fValue)) + if not err.is_failed(): + bufframe.type = int(fValue.value) + + idprop = DCAM_IDPROP.IMAGE_WIDTH + err = dcamprop_getvalue(hdcam, idprop, byref(fValue)) + if not err.is_failed(): + bufframe.width = int(fValue.value) + + idprop = DCAM_IDPROP.IMAGE_HEIGHT + err = dcamprop_getvalue(hdcam, idprop, byref(fValue)) + if not err.is_failed(): + bufframe.height = int(fValue.value) + + idprop = DCAM_IDPROP.IMAGE_ROWBYTES + err = dcamprop_getvalue(hdcam, idprop, byref(fValue)) + if not err.is_failed(): + bufframe.rowbytes = int(fValue.value) + + return err + + +def dcammisc_alloc_ndarray(frame: DCAMBUF_FRAME): + """ + Allocate NumPy ndarray based on information of DCAMBUF_FRAME. + + """ + + if frame.type == DCAM_PIXELTYPE.MONO16: + return np.zeros((frame.height, frame.width), dtype='uint16') + + if frame.type == DCAM_PIXELTYPE.MONO8: + return np.zeros((frame.height, frame.width), dtype='uint8') + + return False + + +# ==== declare Dcamapi class ==== + + +class Dcamapi: + # class instance + __lasterr = DCAMERR.SUCCESS # the last error from functions with dcamapi_ prefix. + __bInitialized = False # Once Dcamapi.init() is called, then True. Dcamapi.uninit() reset this. + __devicecount = 0 + + @classmethod + def __result(cls, errvalue): + """ + Internal use. Keep last error code + """ + if errvalue < 0: + cls.__lasterr = errvalue + return False + + return True + + @classmethod + def lasterr(cls): + """ + Return last error code of Dcamapi member functions + """ + return cls.__lasterr + + @classmethod + def init(cls, *initparams): + """ + Initialize dcamapi. + Do not call this when Dcam object exists because constructor of Dcam ececute this. + After calling close(), call this again if you need to resume measurement. + + Returns: + True: if dcamapi_init() succeeded. + False: if dcamapi_init() returned DCAMERR except SUCCESS. lasterr() returns the DCAMERR value. + """ + if cls.__bInitialized: + return cls.__result(DCAMERR.ALREADYINITIALIZED) # dcamapi_init() is called. New Error. + + paraminit = DCAMAPI_INIT() + err = dcamapi_init(byref(paraminit)) + cls.__bInitialized = True + if cls.__result(err) is False: + return False + + cls.__devicecount = paraminit.iDeviceCount + return True + + @classmethod + def uninit(cls): + """ + Uninitlaize dcamapi. + After using DCAM-API, call this function to close all resources. + + Returns: + True: + """ + if cls.__bInitialized: + dcamapi_uninit() + cls.__lasterr = DCAMERR.SUCCESS + cls.__bInitialized = False + cls.__devicecount = 0 + + return True + + @classmethod + def get_devicecount(cls): + """ + Return number of connected cameras. + + Returns: + nDeviceCount + False: if not initialized. + """ + if not cls.__bInitialized: + return False + + return cls.__devicecount + +# ==== Dcam class ==== + + +class Dcam: + def __init__(self, iDevice=0): + self.__lasterr = DCAMERR.SUCCESS + self.__iDevice = iDevice + self.__hdcam = 0 + self.__hdcamwait = 0 + self.__bufframe = DCAMBUF_FRAME() + + def __repr__(self): + return 'Dcam()' + + def __result(self, errvalue): + """ + Internal use. Keep last error code + """ + if errvalue < 0: + self.__lasterr = errvalue + return False + + return True + + def lasterr(self): + """ + Return last error code. + """ + return self.__lasterr + + def is_opened(self): + """ + Check DCAM handle is opened. + + Returns: + True: DCAM handle is opened + False: DCAM handle is not opened + """ + if self.__hdcam == 0: + return False + else: + return True + + def dev_open(self, index=-1): + """ + Get HDCAM handle for controling camera. + After calling close(), call this again if you need to resume measurement. + + Args: + arg1(int): device index + + Returns: + True: if dcamdev_open() succeeded. + False: if dcamdev_open() returned DCAMERR except SUCCESS. lasterr() returns the DCAMERR value. + """ + if self.is_opened(): + return self.__result(DCAMERR.ALREADYOPENED) # instance is already opened. New Error. + + paramopen = DCAMDEV_OPEN() + if index >= 0: + paramopen.index = index + else: + paramopen.index = self.__iDevice + + ret = self.__result(dcamdev_open(byref(paramopen))) + if ret is False: + return False + + self.__hdcam = paramopen.hdcam + return True + + def dev_close(self): + """ + Close dcam handle. + Call this if you need to close the current device. + + Returns: + True: + """ + if self.is_opened(): + self.__close_hdcamwait() + dcamdev_close(self.__hdcam) + self.__lasterr = DCAMERR.SUCCESS + self.__hdcam = 0 + + return True + + def dev_getstring(self, idstr): + """ + Get string of device + + Args: + arg1(DCAM_IDSTR): string id + + Returns: + String + False: error happened. lasterr() returns the DCAMERR value + """ + if self.is_opened(): + hdcam = self.__hdcam + else: + hdcam = self.__iDevice + + paramdevstr = DCAMDEV_STRING() + paramdevstr.iString = idstr + paramdevstr.alloctext(256) + + ret = self.__result(dcamdev_getstring(hdcam, byref(paramdevstr))) + if ret is False: + return False + + return paramdevstr.text.decode() + + # dcamprop functions + + def prop_getattr(self, idprop): + """ + Get property attribute + + args: + arg1(DCAM_IDPROP): property id + + Returns: + DCAMPROP_ATTR + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + propattr = DCAMPROP_ATTR() + propattr.iProp = idprop + ret = self.__result(dcamprop_getattr(self.__hdcam, byref(propattr))) + if ret is False: + return False + + return propattr + + def prop_getvalue(self, idprop): + """ + Get property value + + args: + arg1(DCAM_IDPROP): property id + + Returns: + double + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cDouble = c_double() + ret = self.__result(dcamprop_getvalue(self.__hdcam, idprop, byref(cDouble))) + if ret is False: + return False + + return cDouble.value + + def prop_setvalue(self, idprop, fValue): + """ + Set property value + + args: + arg1(DCAM_IDPROP): property id + arg2(double): setting value + + Returns: + True success + False error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + ret = self.__result(dcamprop_setvalue(self.__hdcam, idprop, fValue)) + if ret is False: + return False + + return True + + def prop_setgetvalue(self, idprop, fValue, option=0): + """ + Set and get property value + + args: + arg1(DCAM_IDPROP): property id + arg2(double): input value for setting and receive actual set value by ref + + Returns: + double + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cDouble = c_double(fValue) + cOption = c_int32(option) + ret = self.__result(dcamprop_setgetvalue(self.__hdcam, idprop, byref(cDouble), cOption)) + if ret is False: + return False + + return cDouble.value + + def prop_queryvalue(self, idprop, fValue, option=0): + """ + Query property value + + Args: + arg1(DCAM_IDPROP): property id + arg2(double): value of property + + Returns: + double + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cDouble = c_double(fValue) + cOption = c_int32(option) + ret = self.__result(dcamprop_queryvalue(self.__hdcam, idprop, byref(cDouble), cOption)) + if ret is False: + return False + + return cDouble.value + + def prop_getnextid(self, idprop): + """ + Get next property id + + Args: + arg1(DCAM_IDPROP): property id + + Returns: + DCAM_IDPROP + if False, no more property or error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cIdprop = c_int32(idprop) + cOption = c_int32(0) # search next ID + + ret = self.__result(dcamprop_getnextid(self.__hdcam, byref(cIdprop), cOption)) + if ret is False: + return False + + return cIdprop.value + + def prop_getname(self, idprop): + """ + Get name of property + + Args: + arg1(DCAM_IDPROP): property id + + Returns: + String + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + textbuf = create_string_buffer(256) + ret = self.__result(dcamprop_getname(self.__hdcam, idprop, textbuf, sizeof(textbuf))) + if ret is False: + return False + + return textbuf.value.decode() + + def prop_getvaluetext(self, idprop, fValue): + """ + Get text of property value + + Args: + arg1(DCAM_IDSTR): string id + arg2(double): setting value + + Returns: + String + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + paramvaluetext = DCAMPROP_VALUETEXT() + paramvaluetext.iProp = idprop + paramvaluetext.value = fValue + paramvaluetext.alloctext(256) + + ret = self.__result(dcamprop_getvaluetext(self.__hdcam, byref(paramvaluetext))) + if ret is False: + return False + + return paramvaluetext.text.decode() + + # dcambuf functions + + def buf_alloc(self, nFrame): + """ + Alloc DCAM internal buffer + + Arg: + arg1(int): Number of frames + + Returns: + True: buffer is prepared. + False: buffer is not prepared. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cFrame = c_int32(nFrame) + ret = self.__result(dcambuf_alloc(self.__hdcam, cFrame)) + if ret is False: + return False + + return self.__result(dcammisc_setupframe(self.__hdcam, self.__bufframe)) + + def buf_release(self): + """ + Release DCAM internal buffer + + Returns: + True: success + False: error happens during releasing buffer. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cOption = c_int32(0) + return self.__result(dcambuf_release(self.__hdcam, cOption)) + + def buf_getframe(self, iFrame): + """ + Return DCAMBUF_FRAME instance with image data specified by iFrame. + + Arg: + arg1(int): Index of target frame + + Returns: + (aFrame, npBuf): aFrame is DCAMBUF_FRAME, npBuf is NumPy buffer + False: error happens. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + npBuf = dcammisc_alloc_ndarray(self.__bufframe) + if npBuf is False: + return self.__result(DCAMERR.INVALIDPIXELTYPE) + + aFrame = DCAMBUF_FRAME() + aFrame.iFrame = iFrame + + aFrame.buf = npBuf.ctypes.data_as(c_void_p) + aFrame.rowbytes = self.__bufframe.rowbytes + aFrame.type = self.__bufframe.type + aFrame.width = self.__bufframe.width + aFrame.height = self.__bufframe.height + + ret = self.__result(dcambuf_copyframe(self.__hdcam, byref(aFrame))) + if ret is False: + return False + + return (aFrame, npBuf) + + def buf_getframedata(self, iFrame): + """ + Return NumPy buffer of image data specified by iFrame. + + Arg: + arg1(int): Index of target frame + + Returns: + npBuf: NumPy buffer + False: error happens. lasterr() returns the DCAMERR value + """ + ret = self.buf_getframe(iFrame) + if ret is False: + return False + + return ret[1] + + def buf_getlastframedata(self): + """ + Return NumPy buffer of image data of last updated frame + + Returns: + npBuf: NumPy buffer + False: error happens. lasterr() returns the DCAMERR value + """ + return self.buf_getframedata(-1) + + # dcamcap functions + + def cap_start(self, bSequence=True): + """ + Start capturing + + Arg: + arg1(Boolean) False means SNAPSHOT, others means SEQUENCE + + Returns: + True: start capture + False: error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + if bSequence: + mode = DCAMCAP_START.SEQUENCE + else: + mode = DCAMCAP_START.SNAP + + return self.__result(dcamcap_start(self.__hdcam, mode)) + + def cap_snapshot(self): + """ + Capture snapshot. Get the frames specified in buf_alloc(). + + Returns: + True: start snapshot + False: error happened. lasterr() returns the DCAMERR value + """ + return self.cap_start(False) + + def cap_stop(self): + """ + Stop capturing + + Returns: + True: stop capture + False: error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + return self.__result(dcamcap_stop(self.__hdcam)) + + def cap_status(self): + """ + Get capture status + + Returns: + DCAMCAP_STATUS + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cStatus = c_int32() + ret = self.__result(dcamcap_status(self.__hdcam, byref(cStatus))) + if ret is False: + return False + + return cStatus.value + + def cap_transferinfo(self): + """ + Get transfer info + + Args: + False + + Returns: + DCAMCAP_TRANSFERINFO + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + paramtransferinfo = DCAMCAP_TRANSFERINFO() + ret = self.__result(dcamcap_transferinfo(self.__hdcam, byref(paramtransferinfo))) + if ret is False: + return False + + return paramtransferinfo + + def cap_firetrigger(self): + """ + Fire software trigger + + Returns: + True Firing trigger was succeeded. + if False, error happened. lasterr() returns the DCAMERR value + """ + if not self.is_opened(): + return self.__result(DCAMERR.INVALIDHANDLE) # instance is not opened yet. + + cOption = c_int32(0) + ret = self.__result(dcamcap_firetrigger(self.__hdcam, cOption)) + if ret is False: + return False + + return True + + + # dcamwait functions + + def __open_hdcamwait(self): + """ + Get HDCAMWAIT handle + """ + if not self.__hdcamwait == 0: + return True + + paramwaitopen = DCAMWAIT_OPEN() + paramwaitopen.hdcam = self.__hdcam + ret = self.__result(dcamwait_open(byref(paramwaitopen))) + if ret is False: + return False + + if paramwaitopen.hwait == 0: + return self.__result(DCAMERR.INVALIDWAITHANDLE) + + self.__hdcamwait = paramwaitopen.hwait + return True + + def __close_hdcamwait(self): + """ + Close HDCAMWAIT handle + """ + + if self.__hdcamwait == 0: + return True + + ret = self.__result(dcamwait_close(self.__hdcamwait)) + if ret is False: + return False + + self.__hdcamwait = 0 + return True + + def wait_event(self, eventmask, timeout_millisec): + """ + Wait event + + Arg: + arg1(DCAMWAIT_CAPEVENT) Event mask to wait + arg2(int) timeout by milliseconds. + + Returns: + DCAMWAIT_CAPEVENT: happened event + False: error happened. lasterr() returns the DCAMERR value + """ + ret = self.__open_hdcamwait() + if ret is False: + return False + + paramwaitstart = DCAMWAIT_START() + paramwaitstart.eventmask = eventmask + paramwaitstart.timeout = timeout_millisec + ret = self.__result(dcamwait_start(self.__hdcamwait, byref(paramwaitstart))) + if ret is False: + return False + + return paramwaitstart.eventhappened + + def wait_capevent_frameready(self, timeout_millisec): + """ + Wait DCAMWAIT_CAPEVENT.FRAMEREADY event + + Arg: + arg1(int) timeout by milliseconds. + + Returns: + True: wait capture + False: error happened. lasterr() returns the DCAMERR value + """ + ret = self.wait_event(DCAMWAIT_CAPEVENT.FRAMEREADY, timeout_millisec) + if ret is False: + return False + + # ret is DCAMWAIT_CAPEVENT.FRAMEREADY + + return True + + diff --git a/piescope/lm/dcam/dcam_live_capturing.py b/piescope/lm/dcam/dcam_live_capturing.py new file mode 100644 index 0000000..59a3ede --- /dev/null +++ b/piescope/lm/dcam/dcam_live_capturing.py @@ -0,0 +1,108 @@ +# dcam_show_single_captured_image.py : Jun 18, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. +# +# This sample source code just shows how to use DCAM-API. +# The performance is not guranteed. + +""" +Sample script for showing a captured image with dcam.py +""" + +from dcam import * + +# import threading + +# pip install opencv-python +import cv2 + + +def dcamtest_show_framedata(data, windowtitle, iShown): + """ + Show numpy buffer as an image + + Arg1: NumPy array + Arg2: Window name + Arg3: Last window status. + 0 open as a new window + <0 already closed + >0 already openend + """ + if iShown > 0 and cv2.getWindowProperty(windowtitle, 0) < 0: + return -1 # Window has been closed. + if iShown < 0: + return -1 # Window is already closed. + + if data.dtype == np.uint16: + imax = np.amax(data) + if imax > 0: + imul = int(65535 / imax) + # print('Multiple %s' % imul) + data = data * imul + + cv2.imshow(windowtitle, data) + return 1 + else: + print('-NG: dcamtest_show_image(data) only support Numpy.uint16 data') + return -1 + + +def dcamtest_thread_live(dcam): + """ + Show live image + + Arg1: Dcam instance + """ + if dcam.cap_start() is not False: + + timeout_milisec = 100 + iWindowStatus = 0 + while iWindowStatus >= 0: + if dcam.wait_capevent_frameready(timeout_milisec) is not False: + data = dcam.buf_getlastframedata() + iWindowStatus = dcamtest_show_framedata(data, 'test', iWindowStatus) + else: + dcamerr = dcam.lasterr() + if dcamerr.is_timeout(): + print('===: timeout') + else: + print('-NG: Dcam.wait_event() fails with error {}'.format(dcamerr)) + break + + key = cv2.waitKey(1) + if key == ord('q') or key == ord('Q'): # if 'q' was pressed with the live window, close it + break + + dcam.cap_stop() + else: + print('-NG: Dcam.cap_start() fails with error {}'.format(dcam.lasterr())) + + +def dcam_live_capturing(iDevice=0): + """ + Capture and show a image + """ + if Dcamapi.init() is not False: + dcam = Dcam(iDevice) + if dcam.dev_open() is not False: + if dcam.buf_alloc(3) is not False: + # th = threading.Thread(target=dcamtest_thread_live, args=(dcam,)) + # th.start() + # th.join() + dcamtest_thread_live(dcam) + + # release buffer + dcam.buf_release() + else: + print('-NG: Dcam.buf_alloc(3) fails with error {}'.format(dcam.lasterr())) + dcam.dev_close() + else: + print('-NG: Dcam.dev_open() fails with error {}'.format(dcam.lasterr())) + else: + print('-NG: Dcamapi.init() fails with error {}'.format(Dcamapi.lasterr())) + + Dcamapi.uninit() + + +if __name__ == '__main__': + dcam_live_capturing() diff --git a/piescope/lm/dcam/dcam_show_device_list.py b/piescope/lm/dcam/dcam_show_device_list.py new file mode 100644 index 0000000..96fc1cf --- /dev/null +++ b/piescope/lm/dcam/dcam_show_device_list.py @@ -0,0 +1,45 @@ +# dcam_show_device_list.py : Jun 18, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. +# +# This sample source code just shows how to use DCAM-API. +# The performance is not guranteed. + +""" +Sample script for showing device list with dcam.py +""" + +from dcam import * + + +def dcam_show_device_list(): + """ + Show device list + """ + if Dcamapi.init() is not False: + n = Dcamapi.get_devicecount() + for i in range(0, n): + dcam = Dcam(i) + output = '#{}: '.format(i) + + model = dcam.dev_getstring(DCAM_IDSTR.MODEL) + if model is False: + output = output + 'No DCAM_IDSTR.MODEL' + else: + output = output + 'MODEL={}'.format(model) + + cameraid = dcam.dev_getstring(DCAM_IDSTR.CAMERAID) + if cameraid is False: + output = output + ', No DCAM_IDSTR.CAMERAID' + else: + output = output + ', CAMERAID={}'.format(cameraid) + + print(output) + else: + print('-NG: Dcamapi.init() fails with error {}'.format(Dcamapi.lasterr())) + + Dcamapi.uninit() + + +if __name__ == '__main__': + dcam_show_device_list() diff --git a/piescope/lm/dcam/dcam_show_properties.py b/piescope/lm/dcam/dcam_show_properties.py new file mode 100644 index 0000000..def9d9a --- /dev/null +++ b/piescope/lm/dcam/dcam_show_properties.py @@ -0,0 +1,43 @@ +# dcam_show_properties.py : Jun 18, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. +# +# This sample source code just shows how to use DCAM-API. +# The performance is not guranteed. + +""" +Sample script for showing device list with dcam.py +""" + +from dcam import * + +def dcam_show_properties(iDevice=0): + """ + Show supported properties + """ + if Dcamapi.init() is not False: + dcam = Dcam(iDevice) + if dcam.dev_open() is not False: + + idprop = dcam.prop_getnextid(0) + while idprop is not False: + output = '0x{:08X}: '.format(idprop) + + propname = dcam.prop_getname(idprop) + if propname is not False: + output = output + propname + + print(output) + idprop = dcam.prop_getnextid(idprop) + + dcam.dev_close() + else: + print('-NG: Dcam.dev_open() fails with error {}'.format(dcam.lasterr())) + else: + print('-NG: Dcamapi.init() fails with error {}'.format(Dcamapi.lasterr())) + + Dcamapi.uninit() + + +if __name__ == '__main__': + dcam_show_properties() diff --git a/piescope/lm/dcam/dcam_show_single_captured_image.py b/piescope/lm/dcam/dcam_show_single_captured_image.py new file mode 100644 index 0000000..2e33cf7 --- /dev/null +++ b/piescope/lm/dcam/dcam_show_single_captured_image.py @@ -0,0 +1,92 @@ +# dcam_show_single_captured_image.py : Jun 18, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. +# +# This sample source code just shows how to use DCAM-API. +# The performance is not guranteed. + +""" +Sample script for showing a captured image with dcam.py +""" + +from dcam import * + +# pip install opencv-python +# import cv2 +import matplotlib.pyplot as plt + + +def dcamtest_show_framedata(data): + """ + Show numpy buffer as an image + + Arg1: NumPy array + """ + print(data) + # plt.imshow(data) + # plt.show() + # plt.imshow('test', data) + return + + if data.dtype == np.uint16: + imax = np.amax(data) + if imax > 0: + imul = int(65535 / imax) + # print('Multiple %s' % imul) + data = data * imul + + plt.imshow('test', data) + # cv2.waitKey(0) + else: + print('-NG: dcamtest_show_image(data) only support Numpy.uint16 data') + + +def dcam_show_single_captured_image(iDevice=0): + """ + Capture and show a image + """ + if Dcamapi.init() is not False: + dcam = Dcam(iDevice) + if dcam.dev_open() is not False: + if dcam.buf_alloc(1) is not False: + + dcam.prop_setvalue(DCAM_IDPROP.EXPOSURETIME, 0.01) + dcam.prop_setvalue(DCAM_IDPROP.TRIGGERSOURCE, 2) + dcam.prop_setvalue(DCAM_IDPROP.TRIGGERACTIVE, 2) + dcam.prop_setvalue(DCAM_IDPROP.TRIGGER_MODE, 1) + dcam.prop_setvalue(DCAM_IDPROP.TRIGGERPOLARITY, 2) + + if dcam.cap_snapshot() is not False: + timeout_milisec = 2000 + while True: + if dcam.wait_capevent_frameready(timeout_milisec) is not False: + dcam.cap_firetrigger() + data = dcam.buf_getlastframedata() + # data = dcam.buf_getframedata() + dcamtest_show_framedata(data) + break + + dcamerr = dcam.lasterr() + if dcamerr.is_timeout(): + print('===: timeout') + continue + + print('-NG: Dcam.wait_event() fails with error {}'.format(dcamerr)) + break + else: + print('-NG: Dcam.cap_start() fails with error {}'.format(dcam.lasterr())) + + dcam.buf_release() + else: + print('-NG: Dcam.buf_alloc(1) fails with error {}'.format(dcam.lasterr())) + dcam.dev_close() + else: + print('-NG: Dcam.dev_open() fails with error {}'.format(dcam.lasterr())) + else: + print('-NG: Dcamapi.init() fails with error {}'.format(Dcamapi.lasterr())) + + Dcamapi.uninit() + + +if __name__ == '__main__': + dcam_show_single_captured_image() diff --git a/piescope/lm/dcam/dcamapi4.py b/piescope/lm/dcam/dcamapi4.py new file mode 100644 index 0000000..27aba72 --- /dev/null +++ b/piescope/lm/dcam/dcamapi4.py @@ -0,0 +1,1336 @@ +# dcamapi4.py : Jun 18, 2021 +# +# Copyright (C) 2021 Hamamatsu Photonics K.K.. All right reserved. + + +import platform +from enum import IntEnum +from ctypes import * + + +# ==== load shared library ==== + +# abosorb platform dependency + +__platform_system = platform.system() +if __platform_system == 'Windows': + __dll = windll.LoadLibrary('dcamapi.dll') +else: # Linux + __dll = cdll.LoadLibrary('/usr/local/lib/libdcamapi.so') + + +# ==== declare constants ==== + +class DCAMERR(IntEnum): + # status error + BUSY = -2147483391 # 0x80000101, API cannot process in busy state. + NOTREADY = -2147483389 # 0x80000103, API requires ready state. + NOTSTABLE = -2147483388 # 0x80000104, API requires stable or unstable state. + UNSTABLE = -2147483387 # 0x80000105, API does not support in unstable state. + NOTBUSY = -2147483385 # 0x80000107, API requires busy state. + EXCLUDED = -2147483376 # 0x80000110, some resource is exclusive and already used + COOLINGTROUBLE = -2147482878 # 0x80000302, something happens near cooler + NOTRIGGER = -2147482877 # 0x80000303, no trigger when necessary. Some camera supports this error. + TEMPERATURE_TROUBLE = -2147482876 # 0x80000304, camera warns its temperature + TOOFREQUENTTRIGGER = -2147482875 # 0x80000305, input too frequent trigger. Some camera supports this error. + # wait error + ABORT = -2147483390 # 0x80000102, abort process + TIMEOUT = -2147483386 # 0x80000106, timeout + LOSTFRAME = -2147482879 # 0x80000301, frame data is lost + MISSINGFRAME_TROUBLE = -2147479802 # 0x80000f06, frame is lost but reason is low lever driver's bug + INVALIDIMAGE = -2147482847 # 0x80000321, hpk format data is invalid data + # initialization error + NORESOURCE = -2147483135 # 0x80000201, not enough resource except memory + NOMEMORY = -2147483133 # 0x80000203, not enough memory + NOMODULE = -2147483132 # 0x80000204, no sub module + NODRIVER = -2147483131 # 0x80000205, no driver + NOCAMERA = -2147483130 # 0x80000206, no camera + NOGRABBER = -2147483129 # 0x80000207, no grabber + NOCOMBINATION = -2147483128 # 0x80000208, no combination on registry + FAILOPEN = -2147479551 # 0x80001001, DEPRECATED + FRAMEGRABBER_NEEDS_FIRMWAREUPDATE = -2147479550 # 0x80001002, need to update frame grabber firmware to use the camera + INVALIDMODULE = -2147483119 # 0x80000211, dcam_init() found invalid module + INVALIDCOMMPORT = -2147483118 # 0x80000212, invalid serial port + FAILOPENBUS = -2130702335 # 0x81001001, the bus or driver are not available + FAILOPENCAMERA = -2113925119 # 0x82001001, camera report error during opening + DEVICEPROBLEM = -2113925118 # 0x82001002, initialization failed(for maico) + # calling error + INVALIDCAMERA = -2147481594 # 0x80000806, invalid camera + INVALIDHANDLE = -2147481593 # 0x80000807, invalid camera handle + INVALIDPARAM = -2147481592 # 0x80000808, invalid parameter + INVALIDVALUE = -2147481567 # 0x80000821, invalid property value + OUTOFRANGE = -2147481566 # 0x80000822, value is out of range + NOTWRITABLE = -2147481565 # 0x80000823, the property is not writable + NOTREADABLE = -2147481564 # 0x80000824, the property is not readable + INVALIDPROPERTYID = -2147481563 # 0x80000825, the property id is invalid + NEWAPIREQUIRED = -2147481562 # 0x80000826, old API cannot present the value because only new API need to be used + WRONGHANDSHAKE = -2147481561 # 0x80000827, this error happens DCAM get error code from camera unexpectedly + NOPROPERTY = -2147481560 # 0x80000828, there is no altenative or influence id, or no more property id + INVALIDCHANNEL = -2147481559 # 0x80000829, the property id specifies channel but channel is invalid + INVALIDVIEW = -2147481558 # 0x8000082a, the property id specifies channel but channel is invalid + INVALIDSUBARRAY = -2147481557 # 0x8000082b, the combination of subarray values are invalid. e.g. DCAM_IDPROP_SUBARRAYHPOS + DCAM_IDPROP_SUBARRAYHSIZE is greater than the number of horizontal pixel of sensor. + ACCESSDENY = -2147481556 # 0x8000082c, the property cannot access during this DCAM STATUS + NOVALUETEXT = -2147481555 # 0x8000082d, the property does not have value text + WRONGPROPERTYVALUE = -2147481554 # 0x8000082e, at least one property value is wrong + DISHARMONY = -2147481552 # 0x80000830, the paired camera does not have same parameter + FRAMEBUNDLESHOULDBEOFF = -2147481550 # 0x80000832, framebundle mode should be OFF under current property settings + INVALIDFRAMEINDEX = -2147481549 # 0x80000833, the frame index is invalid + INVALIDSESSIONINDEX = -2147481548 # 0x80000834, the session index is invalid + NOCORRECTIONDATA = -2147481544 # 0x80000838, not take the dark and shading correction data yet. + CHANNELDEPENDENTVALUE = -2147481543 # 0x80000839, each channel has own property value so can't return overall property value. + VIEWDEPENDENTVALUE = -2147481542 # 0x8000083a, each view has own property value so can't return overall property value. + NODEVICEBUFFER = -2147481541 # 0x8000083b, the frame count is larger than device momory size on using device memory. + REQUIREDSNAP = -2147481540 # 0x8000083c, the capture mode is sequence on using device memory. + LESSSYSTEMMEMORY = -2147481537 # 0x8000083f, the sysmte memory size is too small. PC doesn't have enough memory or is limited memory by 32bit OS. + NOTSUPPORT = -2147479805 # 0x80000f03, camera does not support the function or property with current settings + # camera or bus trouble + FAILREADCAMERA = -2097147902 # 0x83001002, failed to read data from camera + FAILWRITECAMERA = -2097147901 # 0x83001003, failed to write data to the camera + CONFLICTCOMMPORT = -2097147900 # 0x83001004, conflict the com port name user set + OPTICS_UNPLUGGED = -2097147899 # 0x83001005, Optics part is unplugged so please check it. + FAILCALIBRATION = -2097147898 # 0x83001006, fail calibration + MISMATCH_CONFIGURATION = -2097147887 # 0x83001011, mismatch between camera output(connection) and frame grabber specs + # 0x84000100 - 0x840001FF, DCAMERR_INVALIDMEMBER_x + INVALIDMEMBER_3 = -2080374525 # 0x84000103, 3th member variable is invalid value + INVALIDMEMBER_5 = -2080374523 # 0x84000105, 5th member variable is invalid value + INVALIDMEMBER_7 = -2080374521 # 0x84000107, 7th member variable is invalid value + INVALIDMEMBER_8 = -2080374520 # 0x84000108, 7th member variable is invalid value + INVALIDMEMBER_9 = -2080374519 # 0x84000109, 9th member variable is invalid value + FAILEDOPENRECFILE = -2080370687 # 0x84001001, DCAMREC failed to open the file + INVALIDRECHANDLE = -2080370686 # 0x84001002, DCAMREC is invalid handle + FAILEDWRITEDATA = -2080370685 # 0x84001003, DCAMREC failed to write the data + FAILEDREADDATA = -2080370684 # 0x84001004, DCAMREC failed to read the data + NOWRECORDING = -2080370683 # 0x84001005, DCAMREC is recording data now + WRITEFULL = -2080370682 # 0x84001006, DCAMREC writes full frame of the session + ALREADYOCCUPIED = -2080370681 # 0x84001007, DCAMREC handle is already occupied by other HDCAM + TOOLARGEUSERDATASIZE = -2080370680 # 0x84001008, DCAMREC is set the large value to user data size + INVALIDWAITHANDLE = -2080366591 # 0x84002001, DCAMWAIT is invalid handle + NEWRUNTIMEREQUIRED = -2080366590 # 0x84002002, DCAM Module Version is older than the version that the camera requests + VERSIONMISMATCH = -2080366589 # 0x84002003, Camre returns the error on setting parameter to limit version + RUNAS_FACTORYMODE = -2080366588 # 0x84002004, Camera is running as a factory mode + IMAGE_UNKNOWNSIGNATURE = -2080362495 # 0x84003001, sigunature of image header is unknown or corrupted + IMAGE_NEWRUNTIMEREQUIRED = -2080362494 # 0x84003002, version of image header is newer than version that used DCAM supports + IMAGE_ERRORSTATUSEXIST = -2080362493 # 0x84003003, image header stands error status + IMAGE_HEADERCORRUPTED = -2080358396 # 0x84004004, image header value is strange + IMAGE_BROKENCONTENT = -2080358395 # 0x84004005, image content is corrupted + # calling error for DCAM-API 2.1.3 + UNKNOWNMSGID = -2147481599 # 0x80000801, unknown message id + UNKNOWNSTRID = -2147481598 # 0x80000802, unknown string id + UNKNOWNPARAMID = -2147481597 # 0x80000803, unkown parameter id + UNKNOWNBITSTYPE = -2147481596 # 0x80000804, unknown bitmap bits type + UNKNOWNDATATYPE = -2147481595 # 0x80000805, unknown frame data type + # internal error + NONE = 0 # 0, no error, nothing to have done + INSTALLATIONINPROGRESS = -2147479808 # 0x80000f00, installation progress + UNREACH = -2147479807 # 0x80000f01, internal error + UNLOADED = -2147479804 # 0x80000f04, calling after process terminated + THRUADAPTER = -2147479803 # 0x80000f05 + NOCONNECTION = -2147479801 # 0x80000f07, HDCAM lost connection to camera + NOTIMPLEMENT = -2147479806 # 0x80000f02, not yet implementation + DELAYEDFRAME = -2147479799 # 0x80000f09, the frame waiting re-load from hardware buffer with SNAPSHOT of DEVICEBUFFER MODE + DEVICEINITIALIZING = -1342177279 # 0xb0000001 + APIINIT_INITOPTIONBYTES = -1543438333 # 0xa4010003, DCAMAPI_INIT::initoptionbytes is invalid + APIINIT_INITOPTION = -1543438332 # 0xa4010004, DCAMAPI_INIT::initoption is invalid + INITOPTION_COLLISION_BASE = -1543389184 # 0xa401C000 + INITOPTION_COLLISION_MAX = -1543372801 # 0xa401FFFF + # Between DCAMERR_INITOPTION_COLLISION_BASE and DCAMERR_INITOPTION_COLLISION_MAX means there is collision with initoption in DCAMAPI_INIT. + # The value "(error code) - DCAMERR_INITOPTION_COLLISION_BASE" indicates the index which second INITOPTION group happens. + MISSPROP_TRIGGERSOURCE = -535822064 # 0xE0100110, the trigger mode is internal or syncreadout on using device memory. + # success + SUCCESS = 1 # 1, no error, general success code, app should check the value is positive + + + ALREADYINITIALIZED = -520093695 # 0xE1000001 + ALREADYOPENED = -520093694 # 0xE1000002 + INVALIDPIXELTYPE = -520093440 # 0xE1000100 + + SUCCESS_PROP_GETATTR = 88 # dcamprop_getattr() returns this value at SUCCESS + + def is_failed(self): + return True if int(self) < 0 else False + + def is_timeout(self): + return True if int(self) == DCAMERR.TIMEOUT else False + + +class DCAM_PIXELTYPE(IntEnum): + NONE = 0 # no pixeltype specified + MONO8 = 1 # B/W 8 bit + MONO16 = 2 # B/W 16 bit + + +class DCAMCAP_STATUS(IntEnum): + ERROR = 0x0000 + BUSY = 0x0001 + READY = 0x0002 + STABLE = 0x0003 + UNSTABLE = 0x0004 + + +class DCAMWAIT_CAPEVENT(IntEnum): + TRANSFERRED = 0x0001 + FRAMEREADY = 0x0002 + CYCLEEND = 0x0004 + EXPOSUREEND = 0x0008 + STOPPED = 0x0010 + + +class DCAMWAIT_RECEVENT(IntEnum): + STOPPED = 0x0100 + WARNING = 0x0200 + MISSED = 0x0400 + DISKFULL = 0x1000 + WRITEFAULT = 0x2000 + SKIPPED = 0x4000 + + +class DCAMCAP_START(IntEnum): + SEQUENCE = -1 + SNAP = 0 + + +class DCAM_IDSTR(IntEnum): + BUS = 0x04000101 + CAMERAID = 0x04000102 + VENDOR = 0x04000103 + MODEL = 0x04000104 + CAMERAVERSION = 0x04000105 + DRIVERVERSION = 0x04000106 + MODULEVERSION = 0x04000107 + DCAMAPIVERSION = 0x04000108 + CAMERA_SERIESNAME = 0x0400012c + + +class DCAMAPI_INITOPTION(IntEnum): + """ + Initialize parameter. + """ + APIVER__LATEST = 0x00000001 + APIVER__4_0 = 0x00000400 + ENDMARK = 0x00000000 + + +class DCAM_CODEPAGE(IntEnum): + SHIFT_JIS = 932 # Shift JIS + UTF16_LE = 1200 # UTF-16 (Little Endian) + UTF16_BE = 1201 # UTF-16 (Big Endian) + UTF7 = 65000 # UTF-7 translation + UTF8 = 65001 # UTF-8 translation + NONE = 0 + + +class DCAM_IDPROP(IntEnum): + # 0x00000000 - 0x00100000, reserved + # Group: TIMING + TRIGGERSOURCE = 1048848 # 0x00100110, R/W, mode, "TRIGGER SOURCE" + TRIGGERACTIVE = 1048864 # 0x00100120, R/W, mode, "TRIGGER ACTIVE" + TRIGGER_MODE = 1049104 # 0x00100210, R/W, mode, "TRIGGER MODE" + TRIGGERPOLARITY = 1049120 # 0x00100220, R/W, mode, "TRIGGER POLARITY" + TRIGGER_CONNECTOR = 1049136 # 0x00100230, R/W, mode, "TRIGGER CONNECTOR" + TRIGGERTIMES = 1049152 # 0x00100240, R/W, long, "TRIGGER TIMES" + # 0x00100250 is reserved + TRIGGERDELAY = 1049184 # 0x00100260, R/W, sec, "TRIGGER DELAY" + INTERNALTRIGGER_HANDLING = 1049200 # 0x00100270 + TRIGGERMULTIFRAME_COUNT = 1049216 # 0x00100280 + SYNCREADOUT_SYSTEMBLANK = 1049232 # 0x00100290, R/W, mode, "SYNC READOUT SYSTEM BLANK" + TRIGGERENABLE_ACTIVE = 1049616 # 0x00100410, R/W, mode, "TRIGGER ENABLE ACTIVE" + TRIGGERENABLE_POLARITY = 1049632 # 0x00100420 + TRIGGERNUMBER_FORFIRSTIMAGE = 1050640 # 0x00100810, R/O, long, "TRIGGER NUMBER FOR FIRST IMAGE" + TRIGGERNUMBER_FORNEXTIMAGE = 1050656 # 0x00100820, R/O, long, "TRIGGER NUMBER FOR NEXT IMAGE" + NUMBEROF_OUTPUTTRIGGERCONNECTOR = 1835024 # 0x001C0010 + OUTPUTTRIGGER_CHANNELSYNC = 1835056 # 0x001C0030, R/W, mode, "OUTPUT TRIGGER CHANNEL SYNC" + OUTPUTTRIGGER_PROGRAMABLESTART = 1835088 # 0x001C0050, R/W, mode, "OUTPUT TRIGGER PROGRAMABLE START" + OUTPUTTRIGGER_SOURCE = 1835280 # 0x001C0110, R/W, mode, "OUTPUT TRIGGER SOURCE" + OUTPUTTRIGGER_POLARITY = 1835296 # 0x001C0120, R/W, mode, "OUTPUT TRIGGER POLARITY" + OUTPUTTRIGGER_ACTIVE = 1835312 # 0x001C0130, R/W, mode, "OUTPUT TRIGGER ACTIVE" + OUTPUTTRIGGER_DELAY = 1835328 # 0x001C0140, R/W, sec, "OUTPUT TRIGGER DELAY" + OUTPUTTRIGGER_PERIOD = 1835344 # 0x001C0150, R/W, sec, "OUTPUT TRIGGER PERIOD" + OUTPUTTRIGGER_KIND = 1835360 # 0x001C0160, R/W, mode, "OUTPUT TRIGGER KIND" + OUTPUTTRIGGER_BASESENSOR = 1835376 # 0x001C0170, R/W, mode, "OUTPUT TRIGGER BASE SENSOR" + OUTPUTTRIGGER_PREHSYNCCOUNT = 1835408 # 0x001C0190, R/W, mode, "OUTPUT TRIGGER PRE HSYNC COUNT" + # - 0x001C10FF for 16 output trigger connector, reserved + _OUTPUTTRIGGER = 256 # 0x00000100, the offset of ID for Nth OUTPUT TRIGGER parameter + MASTERPULSE_MODE = 1966112 # 0x001E0020, R/W, mode, "MASTER PULSE MODE" + MASTERPULSE_TRIGGERSOURCE = 1966128 # 0x001E0030, R/W, mode, "MASTER PULSE TRIGGER SOURCE" + MASTERPULSE_INTERVAL = 1966144 # 0x001E0040, R/W, sec, "MASTER PULSE INTERVAL" + MASTERPULSE_BURSTTIMES = 1966160 # 0x001E0050, R/W, long, "MASTER PULSE BURST TIMES" + # Group: FEATURE + # exposure period + EXPOSURETIME = 2031888 # 0x001F0110, R/W, sec, "EXPOSURE TIME" + EXPOSURETIME_CONTROL = 2031920 # 0x001F0130, R/W, mode, "EXPOSURE TIME CONTROL" + TRIGGER_FIRSTEXPOSURE = 2032128 # 0x001F0200, R/W, mode, "TRIGGER FIRST EXPOSURE" + TRIGGER_GLOBALEXPOSURE = 2032384 # 0x001F0300, R/W, mode, "TRIGGER GLOBAL EXPOSURE" + FIRSTTRIGGER_BEHAVIOR = 2032400 # 0x001F0310, R/W, mode, "FIRST TRIGGER BEHAVIOR" + MULTIFRAME_EXPOSURE = 2035712 # 0x001F1000, R/W, sec, "MULTI FRAME EXPOSURE TIME" + # - 0x001F1FFF for 256 MULTI FRAME + _MULTIFRAME = 16 # 0x00000010, the offset of ID for Nth MULTIFRAME + # anti-blooming + LIGHTMODE = 2097424 # 0x00200110, R/W, mode, "LIGHT MODE" + # 0x00200120 is reserved + # sensitivity + SENSITIVITYMODE = 2097680 # 0x00200210, R/W, mode, "SENSITIVITY MODE" + SENSITIVITY = 2097696 # 0x00200220, R/W, long, "SENSITIVITY" + DIRECTEMGAIN_MODE = 2097744 # 0x00200250, R/W, mode, "DIRECT EM GAIN MODE" + EMGAINWARNING_STATUS = 2097760 # 0x00200260 + EMGAINWARNING_LEVEL = 2097776 # 0x00200270, R/W, long, "EM GAIN WARNING LEVEL" + EMGAINWARNING_ALARM = 2097792 # 0x00200280, R/W, mode, "EM GAIN WARNING ALARM" + EMGAINPROTECT_MODE = 2097808 # 0x00200290, R/W, mode, "EM GAIN PROTECT MODE" + EMGAINPROTECT_AFTERFRAMES = 2097824 # 0x002002A0, R/W, long, "EM GAIN PROTECT AFTER FRAMES" + MEASURED_SENSITIVITY = 2097840 # 0x002002B0, R/O, real, "MEASURED SENSITIVITY" + PHOTONIMAGINGMODE = 2097904 # 0x002002F0, R/W, mode, "PHOTON IMAGING MODE" + # sensor cooler + SENSORTEMPERATURE = 2097936 # 0x00200310, R/O, celsius,"SENSOR TEMPERATURE" + SENSORCOOLER = 2097952 # 0x00200320, R/W, mode, "SENSOR COOLER" + SENSORTEMPERATURETARGET = 2097968 # 0x00200330, R/W, celsius,"SENSOR TEMPERATURE TARGET" + SENSORCOOLERSTATUS = 2097984 # 0x00200340, R/O, mode, "SENSOR COOLER STATUS" + SENSORCOOLERFAN = 2098000 # 0x00200350, R/W, mode, "SENSOR COOLER FAN" + SENSORTEMPERATURE_AVE = 2098016 # 0x00200360, R/O, celsius,"SENSOR TEMPERATURE AVE" + SENSORTEMPERATURE_MIN = 2098032 # 0x00200370, R/O, celsius,"SENSOR TEMPERATURE MIN" + SENSORTEMPERATURE_MAX = 2098048 # 0x00200380, R/O, celsius,"SENSOR TEMPERATURE MAX" + SENSORTEMPERATURE_STATUS = 2098064 # 0x00200390, R/O, mode, "SENSOR TEMPERATURE STATUS" + SENSORTEMPERATURE_PROTECT = 2098176 # 0x00200400, R/W, mode, "SENSOR TEMPERATURE MODE" + # mechanical shutter + MECHANICALSHUTTER = 2098192 # 0x00200410, R/W, mode, "MECHANICAL SHUTTER" + # contrast enhance + CONTRASTGAIN = 3146016 # 0x00300120, R/W, long, "CONTRAST GAIN" + CONTRASTOFFSET = 3146032 # 0x00300130, R/W, long, "CONTRAST OFFSET" + # 0x00300140 is reserved + HIGHDYNAMICRANGE_MODE = 3146064 # 0x00300150, R/W, mode, "HIGH DYNAMIC RANGE MODE" + DIRECTGAIN_MODE = 3146080 # 0x00300160, R/W, mode, "DIRECT GAIN MODE" + REALTIMEGAINCORRECT_MODE = 3146096 # 0x00300170, R/W, mode, "REALTIME GAIN CORRECT MODE" + REALTIMEGAINCORRECT_LEVEL = 3146112 # 0x00300180, R/W, mode, "REALTIME GAIN CORRECT LEVEL" + REALTIMEGAINCORRECT_INTERVAL = 3146128 # 0x00300190, R/W, mode, "REALTIME GAIN CORRECT INTERVAL" + NUMBEROF_REALTIMEGAINCORRECTREGION = 3146144 # 0x003001A0 + # color features + VIVIDCOLOR = 3146240 # 0x00300200, R/W, mode, "VIVID COLOR" + WHITEBALANCEMODE = 3146256 # 0x00300210, R/W, mode, "WHITEBALANCE MODE" + WHITEBALANCETEMPERATURE = 3146272 # 0x00300220, R/W, color-temp., "WHITEBALANCE TEMPERATURE" + WHITEBALANCEUSERPRESET = 3146288 # 0x00300230, R/W, long, "WHITEBALANCE USER PRESET" + # 0x00300310 is reserved + REALTIMEGAINCORRECTREGION_HPOS = 3149824 # 0x00301000, R/W, long, "REALTIME GAIN CORRECT REGION HPOS" + REALTIMEGAINCORRECTREGION_HSIZE = 3153920 # 0x00302000, R/W, long, "REALTIME GAIN CORRECT REGION HSIZE" + _REALTIMEGAINCORRECTIONREGION = 16 # 0x00000010, the offset of ID for Nth REALTIME GAIN CORRECT REGION parameter + # Group: ALU + # ALU + INTERFRAMEALU_ENABLE = 3670032 # 0x00380010, R/W, mode, "INTERFRAME ALU ENABLE" + RECURSIVEFILTER = 3670288 # 0x00380110, R/W, mode, "RECURSIVE FILTER" + RECURSIVEFILTERFRAMES = 3670304 # 0x00380120 + SPOTNOISEREDUCER = 3670320 # 0x00380130, R/W, mode, "SPOT NOISE REDUCER" + SUBTRACT = 3670544 # 0x00380210, R/W, mode, "SUBTRACT" + SUBTRACTIMAGEMEMORY = 3670560 # 0x00380220, R/W, mode, "SUBTRACT IMAGE MEMORY" + STORESUBTRACTIMAGETOMEMORY = 3670576 # 0x00380230, W/O, mode, "STORE SUBTRACT IMAGE TO MEMORY" + SUBTRACTOFFSET = 3670592 # 0x00380240, R/W, long "SUBTRACT OFFSET" + DARKCALIB_STABLEMAXINTENSITY = 3670608 # 0x00380250, R/W, long, "DARKCALIB STABLE MAX INTENSITY" + SUBTRACT_DATASTATUS = 3670768 # 0x003802F0, R/W mode, "SUBTRACT DATA STATUS" + SHADINGCALIB_DATASTATUS = 3670784 # 0x00380300, R/W mode, "SHADING CALIB DATA STATUS" + SHADINGCORRECTION = 3670800 # 0x00380310, R/W, mode, "SHADING CORRECTION" + SHADINGCALIBDATAMEMORY = 3670816 # 0x00380320, R/W, mode, "SHADING CALIB DATA MEMORY" + STORESHADINGCALIBDATATOMEMORY = 3670832 # 0x00380330, W/O, mode, "STORE SHADING DATA TO MEMORY" + SHADINGCALIB_METHOD = 3670848 # 0x00380340, R/W, mode, "SHADING CALIB METHOD" + SHADINGCALIB_TARGET = 3670864 # 0x00380350, R/W, long, "SHADING CALIB TARGET" + SHADINGCALIB_STABLEMININTENSITY = 3670880 # 0x00380360, R/W, long, "SHADING CALIB STABLE MIN INTENSITY" + SHADINGCALIB_SAMPLES = 3670896 # 0x00380370, R/W, long, "SHADING CALIB SAMPLES" + SHADINGCALIB_STABLESAMPLES = 3670912 # 0x00380380, R/W, long, "SHADING CALIB STABLE SAMPLES" + SHADINGCALIB_STABLEMAXERRORPERCENT = 3670928 # 0x00380390, R/W, long, "SHADING CALIB STABLE MAX ERROR PERCENT" + FRAMEAVERAGINGMODE = 3670944 # 0x003803A0, R/W, mode, "FRAME AVERAGING MODE" + FRAMEAVERAGINGFRAMES = 3670960 # 0x003803B0 + DARKCALIB_STABLESAMPLES = 3670976 # 0x003803C0, R/W, long, "DARKCALIB STABLE SAMPLES" + DARKCALIB_SAMPLES = 3670992 # 0x003803D0, R/W, long, "DARKCALIB SAMPLES" + DARKCALIB_TARGET = 3671008 # 0x003803E0, R/W, long, "DARKCALIB TARGET" + CAPTUREMODE = 3671056 # 0x00380410, R/W, mode, "CAPTURE MODE" + LINEAVERAGING = 3671120 # 0x00380450, R/W, long, "LINE AVERAGING" + INTENSITYLUT_MODE = 3671312 # 0x00380510, R/W, mode, "INTENSITY LUT MODE" + INTENSITYLUT_PAGE = 3671328 # 0x00380520, R/W, long, "INTENSITY LUT PAGE" + INTENSITYLUT_WHITECLIP = 3671344 # 0x00380530, R/W, long, "INTENSITY LUT WHITE CLIP" + INTENSITYLUT_BLACKCLIP = 3671360 # 0x00380540, R/W, long, "INTENSITY LUT BLACK CLIP" + INTENSITY_GAMMA = 3671392 # 0x00380560, R/W, real, "INTENSITY GAMMA" + SENSORGAPCORRECT_MODE = 3671584 # 0x00380620, R/W, long, "SENSOR GAP CORRECT MODE" + ADVANCEDEDGEENHANCEMENT_MODE = 3671600 # 0x00380630, R/W, mode, "ADVANCED EDGE ENHANCEMENT MODE" + ADVANCEDEDGEENHANCEMENT_LEVEL = 3671616 # 0x00380640, R/W, long, "ADVANCED EDGE ENHANCEMENT LEVEL" + # TAP CALIBRATION + TAPGAINCALIB_METHOD = 3673872 # 0x00380F10, R/W, mode, "TAP GAIN CALIB METHOD" + TAPCALIB_BASEDATAMEMORY = 3673888 # 0x00380F20 + STORETAPCALIBDATATOMEMORY = 3673904 # 0x00380F30 + TAPCALIBDATAMEMORY = 3673920 # 0x00380F40, W/O, mode, "TAP CALIB DATA MEMORY" + NUMBEROF_TAPCALIB = 3674096 # 0x00380FF0, R/W, long, "NUMBER OF TAP CALIB" + TAPCALIB_GAIN = 3674112 # 0x00381000, R/W, mode, "TAP CALIB GAIN" + TAPCALIB_OFFSET = 3678208 # 0x00382000, R/W, mode, "TAP CALIB OFFSET" + _TAPCALIB = 16 # 0x00000010, the offset of ID for Nth TAPCALIB + # Group: READOUT + # readout speed + READOUTSPEED = 4194576 # 0x00400110, R/W, long, "READOUT SPEED" + # 0x00400120 is reserved + READOUT_DIRECTION = 4194608 # 0x00400130, R/W, mode, "READOUT DIRECTION" + READOUT_UNIT = 4194624 # 0x00400140, R/O, mode, "READOUT UNIT" + SHUTTER_MODE = 4194640 # 0x00400150, R/W, mode, "SHUTTER MODE" + # sensor mode + SENSORMODE = 4194832 # 0x00400210, R/W, mode, "SENSOR MODE" + SENSORMODE_LINEBUNDLEHEIGHT = 4194896 # 0x00400250, R/W, long, "SENSOR MODE LINE BUNDLEHEIGHT" + SENSORMODE_PANORAMICSTARTV = 4194944 # 0x00400280, R/W, long, "SENSOR MODE PANORAMIC START V" + # other readout mode + CCDMODE = 4195088 # 0x00400310, R/W, mode, "CCD MODE" + EMCCD_CALIBRATIONMODE = 4195104 # 0x00400320, R/W, mode, "EM CCD CALIBRATION MODE" + CMOSMODE = 4195152 # 0x00400350, R/W, mode, "CMOS MODE" + # output mode + OUTPUT_INTENSITY = 4195344 # 0x00400410, R/W, mode, "OUTPUT INTENSITY" + OUTPUTDATA_OPERATION = 4195392 # 0x00400440, R/W, mode, "OUTPUT DATA OPERATION" + TESTPATTERN_KIND = 4195600 # 0x00400510, R/W, mode, "TEST PATTERN KIND" + TESTPATTERN_OPTION = 4195616 # 0x00400520, R/W, long, "TEST PATTERN OPTION" + EXTRACTION_MODE = 4195872 # 0x00400620 + # Group: ROI + # binning and subarray + BINNING = 4198672 # 0x00401110, R/W, mode, "BINNING" + BINNING_INDEPENDENT = 4198688 # 0x00401120, R/W, mode, "BINNING INDEPENDENT" + BINNING_HORZ = 4198704 # 0x00401130, R/W, long, "BINNING HORZ" + BINNING_VERT = 4198720 # 0x00401140, R/W, long, "BINNING VERT" + SUBARRAYHPOS = 4202768 # 0x00402110, R/W, long, "SUBARRAY HPOS" + SUBARRAYHSIZE = 4202784 # 0x00402120, R/W, long, "SUBARRAY HSIZE" + SUBARRAYVPOS = 4202800 # 0x00402130, R/W, long, "SUBARRAY VPOS" + SUBARRAYVSIZE = 4202816 # 0x00402140, R/W, long, "SUBARRAY VSIZE" + SUBARRAYMODE = 4202832 # 0x00402150, R/W, mode, "SUBARRAY MODE" + DIGITALBINNING_METHOD = 4202848 # 0x00402160, R/W, mode, "DIGITALBINNING METHOD" + DIGITALBINNING_HORZ = 4202864 # 0x00402170, R/W, long, "DIGITALBINNING HORZ" + DIGITALBINNING_VERT = 4202880 # 0x00402180, R/W, long, "DIGITALBINNING VERT" + # Group: TIMING + # synchronous timing + TIMING_READOUTTIME = 4206608 # 0x00403010, R/O, sec, "TIMING READOUT TIME" + TIMING_CYCLICTRIGGERPERIOD = 4206624 # 0x00403020, R/O, sec, "TIMING CYCLIC TRIGGER PERIOD" + TIMING_MINTRIGGERBLANKING = 4206640 # 0x00403030, R/O, sec, "TIMING MINIMUM TRIGGER BLANKING" + # 0x00403040 is reserved + TIMING_MINTRIGGERINTERVAL = 4206672 # 0x00403050, R/O, sec, "TIMING MINIMUM TRIGGER INTERVAL" + TIMING_EXPOSURE = 4206688 # 0x00403060, R/O, mode, "TIMING EXPOSURE" + TIMING_INVALIDEXPOSUREPERIOD = 4206704 # 0x00403070, R/O, sec, "INVALID EXPOSURE PERIOD" + TIMING_FRAMESKIPNUMBER = 4206720 # 0x00403080, R/W, long, "TIMING FRAME SKIP NUMBER" + TIMING_GLOBALEXPOSUREDELAY = 4206736 # 0x00403090, R/O, sec, "TIMING GLOBAL EXPOSURE DELAY" + INTERNALFRAMERATE = 4208656 # 0x00403810, R/W, 1/sec, "INTERNAL FRAME RATE" + INTERNAL_FRAMEINTERVAL = 4208672 # 0x00403820, R/W, sec, "INTERNAL FRAME INTERVAL" + INTERNALLINERATE = 4208688 # 0x00403830, R/W, 1/sec, "INTERNAL LINE RATE" + INTERNALLINESPEED = 4208704 # 0x00403840, R/W, m/sec, "INTERNAL LINE SPEEED" + INTERNAL_LINEINTERVAL = 4208720 # 0x00403850, R/W, sec, "INTERNAL LINE INTERVAL" + # system information + TIMESTAMP_PRODUCER = 4262416 # 0x00410A10, R/O, mode, "TIME STAMP PRODUCER" + FRAMESTAMP_PRODUCER = 4262432 # 0x00410A20, R/O, mode, "FRAME STAMP PRODUCER" + TRANSFERINFO_FRAMECOUNT = 4262672 # 0x00410B10, R/O, long, "TRANSFER INFO FRAME COUNT" + TRANSFERINFO_LOSTCOUNT = 4262673 # 0x00410B11, R/O, long, "TRANSFER INFO LOST COUNT" + # Group: READOUT + # image information + # 0x00420110 is reserved + COLORTYPE = 4325664 # 0x00420120, R/W, mode, "COLORTYPE" + BITSPERCHANNEL = 4325680 # 0x00420130, R/W, long, "BIT PER CHANNEL" + # 0x00420140 is reserved + # 0x00420150 is reserved + NUMBEROF_CHANNEL = 4325760 # 0x00420180, R/O, long, "NUMBER OF CHANNEL" + ACTIVE_CHANNELINDEX = 4325776 # 0x00420190, R/W, mode, "ACTIVE CHANNEL INDEX" + NUMBEROF_VIEW = 4325824 # 0x004201C0, R/O, long, "NUMBER OF VIEW" + ACTIVE_VIEWINDEX = 4325840 # 0x004201D0, R/W, mode, "ACTIVE VIEW INDEX" + IMAGE_WIDTH = 4325904 # 0x00420210, R/O, long, "IMAGE WIDTH" + IMAGE_HEIGHT = 4325920 # 0x00420220, R/O, long, "IMAGE HEIGHT" + IMAGE_ROWBYTES = 4325936 # 0x00420230, R/O, long, "IMAGE ROWBYTES" + IMAGE_FRAMEBYTES = 4325952 # 0x00420240, R/O, long, "IMAGE FRAMEBYTES" + IMAGE_TOPOFFSETBYTES = 4325968 # 0x00420250 + IMAGE_PIXELTYPE = 4326000 # 0x00420270, R/W, DCAM_PIXELTYPE, "IMAGE PIXEL TYPE" + IMAGE_CAMERASTAMP = 4326144 # 0x00420300, R/W, long, "IMAGE CAMERA STAMP" + RECORDFIXEDBYTES_PERFILE = 4326416 # 0x00420410, R/O, long "RECORD FIXED BYTES PER FILE" + RECORDFIXEDBYTES_PERSESSION = 4326432 # 0x00420420 + RECORDFIXEDBYTES_PERFRAME = 4326448 # 0x00420430, R/O, long "RECORD FIXED BYTES PER FRAME" + # frame bundle + FRAMEBUNDLE_MODE = 4329488 # 0x00421010, R/W, mode, "FRAMEBUNDLE MODE" + FRAMEBUNDLE_NUMBER = 4329504 # 0x00421020, R/W, long, "FRAMEBUNDLE NUMBER" + FRAMEBUNDLE_ROWBYTES = 4329520 # 0x00421030, R/O, long, "FRAMEBUNDLE ROWBYTES" + FRAMEBUNDLE_FRAMESTEPBYTES = 4329536 # 0x00421040, R/O, long, "FRAMEBUNDLE FRAME STEP BYTES" + # partial area + NUMBEROF_PARTIALAREA = 4390928 # 0x00430010 + PARTIALAREA_HPOS = 4395008 # 0x00431000, R/W, long, "PARTIAL AREA HPOS" + PARTIALAREA_HSIZE = 4399104 # 0x00432000, R/W, long, "PARTIAL AREA HSIZE" + PARTIALAREA_VPOS = 4403200 # 0x00433000, R/W, long, "PARTIAL AREA VPOS" + PARTIALAREA_VSIZE = 4407296 # 0x00434000, R/W, long, "PARTIAL AREA VSIZE" + _PARTIALAREA = 16 # 0x00000010, the offset of ID for Nth PARTIAL AREA + # multi line + NUMBEROF_MULTILINE = 4517904 # 0x0044F010, R/W, long, "NUMBER OF MULTI LINE" + MULTILINE_VPOS = 4521984 # 0x00450000, R/W, long, "MULTI LINE VPOS" + MULTILINE_VSIZE = 4587520 # 0x00460000, R/W, long, "MULTI LINE VSIZE" + _MULTILINE = 16 # 0x00000010, the offset of ID for Nth MULTI LINE + # defect + DEFECTCORRECT_MODE = 4653072 # 0x00470010, R/W, mode, "DEFECT CORRECT MODE" + NUMBEROF_DEFECTCORRECT = 4653088 # 0x00470020, R/W, long, "NUMBER OF DEFECT CORRECT" + HOTPIXELCORRECT_LEVEL = 4653104 # 0x00470030, R/W, mode, "HOT PIXEL CORRECT LEVEL" + DEFECTCORRECT_HPOS = 4657152 # 0x00471000, R/W, long, "DEFECT CORRECT HPOS" + DEFECTCORRECT_METHOD = 4665344 # 0x00473000, R/W, mode, "DEFECT CORRECT METHOD" + # - 0x0047FFFF for 256 DEFECT + _DEFECTCORRECT = 16 # 0x00000010, the offset of ID for Nth DEFECT + # Group: device buffer countrol + DEVICEBUFFER_MODE = 4784128 # 0x00490000, R/W, mode, "DEVICE BUFFER MODE" + DEVICEBUFFER_FRAMECOUNTMAX = 4784160 # 0x00490020, R/O, long, "DEVICE BUFFER FRAME COUNT MAX" + # Group: CALIBREGION + CALIBREGION_MODE = 4203536 # 0x00402410, R/W, mode, "CALIBRATE REGION MODE" + NUMBEROF_CALIBREGION = 4203552 # 0x00402420 + CALIBREGION_HPOS = 4915200 # 0x004B0000, R/W, long, "CALIBRATE REGION HPOS" + CALIBREGION_HSIZE = 4919296 # 0x004B1000, R/W, long, "CALIBRATE REGION HSIZE" + # - 0x0048FFFF for 256 REGIONs at least + _CALIBREGION = 16 # 0x00000010, the offset of ID for Nth REGION + # Group: MASKREGION + MASKREGION_MODE = 4203792 # 0x00402510, R/W, mode, "MASK REGION MODE" + NUMBEROF_MASKREGION = 4203808 # 0x00402520, R/W, long, "NUMBER OF MASK REGION" + MASKREGION_HPOS = 4980736 # 0x004C0000, R/W, long, "MASK REGION HPOS" + MASKREGION_HSIZE = 4984832 # 0x004C1000, R/W, long, "MASK REGION HSIZE" + # - 0x0048FFFF for 256 REGIONs at least + _MASKREGION = 16 # 0x00000010, the offset of ID for Nth REGION + # Group: Camera Status + CAMERASTATUS_INTENSITY = 5050640 # 0x004D1110, R/O, mode, "CAMERASTATUS INTENSITY" + CAMERASTATUS_INPUTTRIGGER = 5050656 # 0x004D1120 + CAMERASTATUS_CALIBRATION = 5050672 # 0x004D1130, R/O, mode, "CAMERASTATUS CALIBRATION" + # Group: Back Focus Position + BACKFOCUSPOS_TARGET = 8405008 # 0x00804010, R/W, micro-meter,"BACK FOCUS POSITION TARGET" + BACKFOCUSPOS_CURRENT = 8405024 # 0x00804020, R/O, micro-meter,"BACK FOCUS POSITION CURRENT" + BACKFOCUSPOS_LOADFROMMEMORY = 8405072 # 0x00804050 + BACKFOCUSPOS_STORETOMEMORY = 8405088 # 0x00804060, W/O, long, "BACK FOCUS POSITION STORE TO MEMORY" + # Group: MAICO + CONFOCAL_SCANMODE = 9502736 # 0x00910010, R/W, mode, "CONFOCAL SCAN MODE" + CONFOCAL_SCANLINES = 9502752 # 0x00910020, R/W, long, "CONFOCAL SCANLINES" + CONFOCAL_ZOOM = 9502768 # 0x00910030, R/W, long, "CONFOCAL ZOOM" + SUBUNIT_IMAGEWIDTH = 9502944 # 0x009100e0, R/O, long, "SUBUNIT IMAGE WIDTH + NUMBEROF_SUBUNIT = 9502960 # 0x009100f0, R/O, long, "NUMBER OF SUBUNIT" + SUBUNIT_CONTROL = 9502976 # 0x00910100, R/W, mode, "SUBUNIT CONTROL" + SUBUNIT_LASERPOWER = 9503232 # 0x00910200, R/W, long, "SUBUNIT LASERPOWER" + SUBUNIT_PMTGAIN = 9503488 # 0x00910300, R/W, real, "SUBUNIT PMTGAIN" + SUBUNIT_PINHOLESIZE = 9503744 # 0x00910400, R/O, long, "SUBUNIT PINHOLE SIZE" + SUBUNIT_WAVELENGTH = 9504000 # 0x00910500, R/O, long, "SUBUNIT WAVELENGTH" + SUBUNIT_TOPOFFSETBYTES = 9504256 # 0x00910600, R/O, long, "SUBUNIT TOP OFFSET BYTES" + _SUBUNIT = 16 # 0x00000010, the offset of ID for Nth Subunit parameter + # Group: SYSTEM + # system property + SYSTEM_ALIVE = 16711696 # 0x00FF0010, R/O, mode, "SYSTEM ALIVE" + CONVERSIONFACTOR_COEFF = 16769040 # 0x00FFE010, R/O, double, "CONVERSION FACTOR COEFF" + CONVERSIONFACTOR_OFFSET = 16769056 # 0x00FFE020, R/O, double, "CONVERSION FACTOR OFFSET" + + +# ==== declare structures for DCAM-API functions ==== + + +class DCAMAPI_INIT(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('iDeviceCount', c_int32), # out + ('reserved', c_int32), + ('initoptionbytes', c_int32), + ('initoption', POINTER(c_int32)), + ('guid', c_void_p) # const DCAM_GUID* + ] + + def __init__(self): + self.size = sizeof(DCAMAPI_INIT) + + +class DCAMDEV_OPEN(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('index', c_int32), + ('hdcam', c_void_p) # out + ] + + def __init__(self): + self.size = sizeof(DCAMDEV_OPEN) + self.index = 0 + + +class DCAMDEV_STRING(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('iString', c_int32), + ('text', c_char_p), + ('textbytes', c_int32) + ] + + def __init__(self): + self.size = sizeof(DCAMDEV_STRING) + + def alloctext(self, maxlen): + textbuf = create_string_buffer(maxlen) + self.text = addressof(textbuf) + self.textbytes = sizeof(textbuf) + + +class DCAM_PROP: + class ATTR(IntEnum): + """ + Attributer flags. + """ + HASRANGE = -2147483647 # 0x80000000 + HASSTEP = 0x40000000 + HASDEFAULT = 0x20000000 + HASVALUETEXT = 0x10000000 + HASCHANNEL = 0x08000000 + AUTOROUNDING = 0x00800000 + STEPPING_INCONSISTENT = 0x00400000 + DATASTREAM = 0x00200000 + HASRATIO = 0x00100000 + VOLATILE = 0x00080000 + WRITABLE = 0x00020000 + READABLE = 0x00010000 + HASVIEW = 0x00008000 + _SYSTEM = 0x00004000 + ACCESSREADY = 0x00002000 + ACCESSBUSY = 0x00001000 + ADVANCED = 0x00000800 + EFFECTIVE = 0x00000200 + + class TYPE(IntEnum): + """ + property types. + """ + NONE = 0 + MODE = 1 + LONG = 2 + REAL = 3 + MASK = 15 + + class ATTR2(IntEnum): + """ + Attributer2 flags. + """ + ARRAYBASE = 134217728 # 0x08000000 + ARRAYELEMENT = 67108864 # 0x04000000 + REAL32 = 33554432 # 0x02000000 + INITIALIZEIMPROPER = 1 # 0x00000001 + CHANNELSEPARATEDDATA = 262144 # 0x00040000, Channel 0 value is total of each channels. + + + +class DCAMPROP_OPTION(IntEnum): + """ + options + """ + PRIOR = -16777215 # 0xFF000000 + NEXT = 0x01000000 + NEAREST = 0x80000000 + SUPPORT = 0x00000000 + UPDATED = 0x00000001 + VOLATILE = 0x00000002 + ARRAYELEMENT = 0x00000004 + NONE = 0x00000000 + + +class DCAMPROP_UNIT(IntEnum): + """ + Unit of value + """ + SECOND = 1 + CELSIUS = 2 + KELVIN = 3 + METERPERSECOND = 4 + PERSECOND = 5 + DEGREE = 6 + MICROMETER = 7 + NONE = 0 + +# property values + + +class DCAMPROP: + + class SENSORMODE(IntEnum): + AREA = 1 + LINE = 3 + TDI = 4 + TDI_EXTENDED = 10 + PROGRESSIVE = 12 + SPLITVIEW = 14 + DUALLIGHTSHEET = 16 + PHOTONNUMBERRESOLVING = 18 + + class SHUTTER_MODE(IntEnum): + GLOBAL = 1 + ROLLING = 2 + + class READOUTSPEED(IntEnum): + SLOWEST = 1 + FASTEST = 0x7FFFFFFF + + class READOUT_DIRECTION(IntEnum): + FORWARD = 1 + BACKWARD = 2 + BYTRIGGER = 3 + DIVERGE = 5 + + class READOUT_UNIT(IntEnum): + FRAME = 2 + BUNDLEDLINE = 3 + BUNDLEDFRAME = 4 + + class CCDMODE(IntEnum): + NORMALCCD = 1 + EMCCD = 2 + + class CMOSMODE(IntEnum): + NORMAL = 1 + NONDESTRUCTIVE = 2 + + class OUTPUT_INTENSITY(IntEnum): + NORMAL = 1 + TESTPATTERN = 2 + + class OUTPUTDATA_OPERATION(IntEnum): + RAW = 1 + ALIGNED = 2 + + class TESTPATTERN_KIND(IntEnum): + FLAT = 2 + IFLAT = 3 + HORZGRADATION = 4 + IHORZGRADATION = 5 + VERTGRADATION = 6 + IVERTGRADATION = 7 + LINE = 8 + ILINE = 9 + DIAGONAL = 10 + IDIAGONAL = 11 + FRAMECOUNT = 12 + + class DIGITALBINNING_METHOD(IntEnum): + MINIMUM = 1 + MAXIMUM = 2 + ODD = 3 + EVEN = 4 + SUM = 5 + AVERAGE = 6 + + class TRIGGERSOURCE(IntEnum): + INTERNAL = 1 + EXTERNAL = 2 + SOFTWARE = 3 + MASTERPULSE = 4 + + class TRIGGERACTIVE(IntEnum): + EDGE = 1 + LEVEL = 2 + SYNCREADOUT = 3 + POINT = 4 + + class BUS_SPEED(IntEnum): + SLOWEST = 1 + FASTEST = 0x7FFFFFFF + + class TRIGGER_MODE(IntEnum): + NORMAL = 1 + PIV = 3 + START = 6 + + class TRIGGERPOLARITY(IntEnum): + NEGATIVE = 1 + POSITIVE = 2 + + class TRIGGER_CONNECTOR(IntEnum): + INTERFACE = 1 + BNC = 2 + MULTI = 3 + + class INTERNALTRIGGER_HANDLING(IntEnum): + SHORTEREXPOSURETIME = 1 + FASTERFRAMERATE = 2 + ABANDONWRONGFRAME = 3 + BURSTMODE = 4 + INDIVIDUALEXPOSURE = 7 + + class SYNCREADOUT_SYSTEMBLANK(IntEnum): + STANDARD = 1 + MINIMUM = 2 + + class TRIGGERENABLE_ACTIVE(IntEnum): + DENY = 1 + ALWAYS = 2 + LEVEL = 3 + START = 4 + + class TRIGGERENABLE_POLARITY(IntEnum): + NEGATIVE = 1 + POSITIVE = 2 + INTERLOCK = 3 + + class OUTPUTTRIGGER_CHANNELSYNC(IntEnum): + _1CHANNEL = 1 + _2CHANNELS = 2 + _3CHANNELS = 3 + + class OUTPUTTRIGGER_PROGRAMABLESTART(IntEnum): + FIRSTEXPOSURE = 1 + FIRSTREADOUT = 2 + + class OUTPUTTRIGGER_SOURCE(IntEnum): + EXPOSURE = 1 + READOUTEND = 2 + VSYNC = 3 + HSYNC = 4 + TRIGGER = 6 + + class OUTPUTTRIGGER_POLARITY(IntEnum): + NEGATIVE = 1 + POSITIVE = 2 + + class OUTPUTTRIGGER_ACTIVE(IntEnum): + EDGE = 1 + LEVEL = 2 + + class OUTPUTTRIGGER_KIND(IntEnum): + LOW = 1 + GLOBALEXPOSURE = 2 + PROGRAMABLE = 3 + TRIGGERREADY = 4 + HIGH = 5 + ANYROWEXPOSURE = 6 + + class OUTPUTTRIGGER_BASESENSOR(IntEnum): + VIEW1 = 1 + VIEW2 = 2 + ANYVIEW = 15 + ALLVIEWS = 16 + + class EXPOSURETIME_CONTROL(IntEnum): + OFF = 1 + NORMAL = 2 + + class TRIGGER_FIRSTEXPOSURE(IntEnum): + NEW = 1 + CURRENT = 2 + + class TRIGGER_GLOBALEXPOSURE(IntEnum): + NONE = 1 + ALWAYS = 2 + DELAYED = 3 + EMULATE = 4 + GLOBALRESET = 5 + + class FIRSTTRIGGER_BEHAVIOR(IntEnum): + STARTEXPOSURE = 1 + STARTREADOUT = 2 + + class MASTERPULSE_MODE(IntEnum): + CONTINUOUS = 1 + START = 2 + BURST = 3 + + class MASTERPULSE_TRIGGERSOURCE(IntEnum): + EXTERNAL = 1 + SOFTWARE = 2 + + class MECHANICALSHUTTER(IntEnum): + AUTO = 1 + CLOSE = 2 + OPEN = 3 + + class LIGHTMODE(IntEnum): + LOWLIGHT = 1 + HIGHLIGHT = 2 + + class SENSITIVITYMODE(IntEnum): + OFF = 1 + ON = 2 + INTERLOCK = 3 + + class EMGAINWARNING_STATUS(IntEnum): + NORMAL = 1 + WARNING = 2 + PROTECTED = 3 + + class PHOTONIMAGINGMODE(IntEnum): + _0 = 0 + _1 = 1 + _2 = 2 + _3 = 3 + + class SENSORCOOLER(IntEnum): + OFF = 1 + ON = 2 + MAX = 4 + + class SENSORTEMPERATURE_STATUS(IntEnum): + NORMAL = 0 + WARNING = 1 + PROTECTION = 2 + + class SENSORCOOLERSTATUS(IntEnum): + ERROR4 = -4 + ERROR3 = -3 + ERROR2 = -2 + ERROR1 = -1 + NONE = 0 + OFF = 1 + READY = 2 + BUSY = 3 + ALWAYS = 4 + WARNING = 5 + + class REALTIMEGAINCORRECT_LEVEL(IntEnum): + _1 = 1 + _2 = 2 + _3 = 3 + _4 = 4 + _5 = 5 + + class WHITEBALANCEMODE(IntEnum): + FLAT = 1 + AUTO = 2 + TEMPERATURE = 3 + USERPRESET = 4 + + class DARKCALIB_TARGET(IntEnum): + ALL = 1 + ANALOG = 2 + + class SHADINGCALIB_METHOD(IntEnum): + AVERAGE = 1 + MAXIMUM = 2 + USETARGET = 3 + + class CAPTUREMODE(IntEnum): + NORMAL = 1 + DARKCALIB = 2 + SHADINGCALIB = 3 + TAPGAINCALIB = 4 + BACKFOCUSCALIB = 5 + + class INTERFRAMEALU_ENABLE(IntEnum): + OFF = 1 + TRIGGERSOURCE_ALL = 2 + TRIGGERSOURCE_INTERNAL = 3 + + class SHADINGCALIB_DATASTATUS(IntEnum): + NONE = 1 + FORWARD = 2 + BACKWARD = 3 + BOTH = 4 + + class TAPGAINCALIB_METHOD(IntEnum): + AVE = 1 + MAX = 2 + MIN = 3 + + class RECURSIVEFILTERFRAMES(IntEnum): + _2 = 2 + _4 = 4 + _8 = 8 + _16 = 16 + _32 = 32 + _64 = 64 + + class INTENSITYLUT_MODE(IntEnum): + THROUGH = 1 + PAGE = 2 + CLIP = 3 + + class BINNING(IntEnum): + _1 = 1 + _2 = 2 + _4 = 4 + _8 = 8 + _16 = 16 + _1_2 = 102 + _2_4 = 204 + + class COLORTYPE(IntEnum): + BW = 0x00000001 + RGB = 0x00000002 + BGR = 0x00000003 + + class BITSPERCHANNEL(IntEnum): + _8 = 8 + _10 = 10 + _12 = 12 + _14 = 14 + _16 = 16 + + class DEFECTCORRECT_MODE(IntEnum): + OFF = 1 + ON = 2 + + class DEFECTCORRECT_METHOD(IntEnum): + CEILING = 3 + PREVIOUS = 4 + + class HOTPIXELCORRECT_LEVEL(IntEnum): + STANDARD = 1 + MINIMUM = 2 + AGGRESSIVE = 3 + + class DEVICEBUFFER_MODE(IntEnum): + THRU = 1 + SNAPSHOT = 2 + + class SYSTEM_ALIVE(IntEnum): + OFFLINE = 1 + ONLINE = 2 + ERROR = 3 + + class TIMESTAMP_MODE(IntEnum): + NONE = 1 + LINEBEFORELEFT = 2 + LINEOVERWRITELEFT = 3 + AREABEFORELEFT = 4 + AREAOVERWRITELEFT = 5 + + class TIMING_EXPOSURE(IntEnum): + AFTERREADOUT = 1 + OVERLAPREADOUT = 2 + ROLLING = 3 + ALWAYS = 4 + TDI = 5 + + class TIMESTAMP_PRODUCER(IntEnum): + NONE = 1 + DCAMMODULE = 2 + KERNELDRIVER = 3 + CAPTUREDEVICE = 4 + IMAGINGDEVICE = 5 + + class FRAMESTAMP_PRODUCER(IntEnum): + NONE = 1 + DCAMMODULE = 2 + KERNELDRIVER = 3 + CAPTUREDEVICE = 4 + IMAGINGDEVICE = 5 + + class CAMERASTATUS_INTENSITY(IntEnum): + GOOD = 1 + TOODARK = 2 + TOOBRIGHT = 3 + UNCARE = 4 + EMGAIN_PROTECTION = 5 + INCONSISTENT_OPTICS = 6 + NODATA = 7 + + class CAMERASTATUS_INPUTTRIGGER(IntEnum): + GOOD = 1 + NONE = 2 + TOOFREQUENT = 3 + + class CAMERASTATUS_CALIBRATION(IntEnum): + DONE = 1 + NOTYET = 2 + NOTRIGGER = 3 + TOOFREQUENTTRIGGER = 4 + OUTOFADJUSTABLERANGE = 5 + UNSUITABLETABLE = 6 + TOODARK = 7 + TOOBRIGHT = 8 + NOTDETECTOBJECT = 9 + + class CONFOCAL_SCANMODE(IntEnum): + SIMULTANEOUS = 1 + SEQUENTIAL = 2 + + class SUBUNIT_CONTROL(IntEnum): + NOTINSTALLED = 0 + OFF = 1 + ON = 2 + + class SUBUNIT_PINHOLESIZE(IntEnum): + ERROR = 1 + SMALL = 2 + MEDIUM = 3 + LARGE = 4 + + class MODE(IntEnum): + OFF = 1 + ON = 2 + +class DCAMPROP_ATTR(Structure): + _pack_ = 8 + _fields_ = [ + ('cbSize', c_int32), + ('iProp', c_int32), + ('option', c_int32), + ('iReserved1', c_int32), + ('attribute', c_int32), + ('iGroup', c_int32), + ('iUnit', c_int32), + ('attribute2', c_int32), + ('valuemin', c_double), + ('valuemax', c_double), + ('valuestep', c_double), + ('valuedefault', c_double), + ('nMaxChannel', c_int32), + ('iReserved3', c_int32), + ('nMaxView', c_int32), + ('iProp_NumberOfElement', c_int32), + ('iProp_ArrayBase', c_int32), + ('iPropStep_Element', c_int32) + ] + + def __init__(self): + self.cbSize = sizeof(DCAMPROP_ATTR) + + def is_effective(self): + return True if self.attribute & DCAM_PROP.ATTR.EFFECTIVE else False + + def is_writable(self): + return True if self.attribute & DCAM_PROP.ATTR.WRITABLE else False + + def is_readable(self): + return True if self.attribute & DCAM_PROP.ATTR.READABLE else False + + def is_volatile(self): + return True if self.attribute & DCAM_PROP.ATTR.VOLATILE else False + + def is_accessready(self): + return True if self.attribute & DCAM_PROP.ATTR.ACCESSREADY else False + + def is_accessbusy(self): + return True if self.attribute & DCAM_PROP.ATTR.ACCESSBUSY else False + + def is_datastream(self): + return True if self.attribute & DCAM_PROP.ATTR.DATASTREAM else False + + def is_autorounding(self): + return True if self.attribute & DCAM_PROP.ATTR.AUTOROUNDING else False + + def is_stepping_inconsistent(self): + return True if self.attribute & DCAM_PROP.ATTR.STEPPING_INCONSISTENT else False + + def is_hasview(self): + return True if self.attribute & DCAM_PROP.ATTR.HASVIEW else False + + def is_haschannel(self): + return True if self.attribute & DCAM_PROP.ATTR.HASCHANNEL else False + + +class DCAMPROP_VALUETEXT(Structure): + _pack_ = 8 + _fields_ = [ + ('cbSize', c_int32), + ('iProp', c_int32), + ('value', c_double), + ('text', c_char_p), + ('textbytes', c_int32) + ] + + def __init__(self): + self.cbSize = sizeof(DCAMPROP_VALUETEXT) + + def alloctext(self, maxlen): + textbuf = create_string_buffer(maxlen) + self.text = addressof(textbuf) + self.textbytes = sizeof(textbuf) + + +class DCAM_TIMESTAMP(Structure): + _pack_ = 8 + _fields_ = [ + ('sec', c_uint32), + ('microsec', c_int32) + ] + + def __init__(self): + self.sec = 0 + self.microsec = 0 + + +class DCAMCAP_TRANSFERINFO(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('iKind', c_int32), + ('nNewestFrameIndex', c_int32), + ('nFrameCount', c_int32) + ] + + def __init__(self): + self.size = sizeof(DCAMCAP_TRANSFERINFO) + self.iKind = 0 + self.nNewestFrameIndex = -1 + self.nFrameCount = 0 + + +class DCAMBUF_FRAME(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('iKind', c_int32), + ('option', c_int32), + ('iFrame', c_int32), + ('buf', c_void_p), + ('rowbytes', c_int32), + ('type', c_int32), # DCAM_PIXELTYPE + ('width', c_int32), + ('height', c_int32), + ('left', c_int32), + ('top', c_int32), + ('timestamp', DCAM_TIMESTAMP), + ('framestamp', c_int32), + ('camerastamp', c_int32) + ] + + def __init__(self): + self.size = sizeof(DCAMBUF_FRAME) + self.iKind = 0 + self.option = 0 + self.iFrame = 0 + self.buf = 0 + self.rowbytes = 0 + self.type = DCAM_PIXELTYPE.MONO16 + self.width = 0 + self.height = 0 + self.left = 0 + self.top = 0 + self.timestamp = DCAM_TIMESTAMP() + self.framestamp = 0 + self.camerastamp = 0 + + +class DCAMWAIT_OPEN(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('supportevent', c_int32), # out + ('hwait', c_void_p), # out + ('hdcam', c_void_p) + ] + + def __init__(self): + self.size = sizeof(DCAMWAIT_OPEN) + + +class DCAMWAIT_START(Structure): + _pack_ = 8 + _fields_ = [ + ('size', c_int32), + ('eventhappened', c_int32), # out + ('eventmask', c_int32), + ('timeout', c_int32) + ] + + def __init__(self): + self.size = sizeof(DCAMWAIT_START) + + +if __platform_system == 'Windows': + class DCAMREC_OPEN(Structure): # DCAMREC_OPENW + _pack_ = 8 + _fields_ = [ + ('size', c_int32), # [in] size of this structure. + ('reserved', c_int32), # [in] + ('hrec', c_void_p), # [out] + ('path', c_wchar_p), # [in] wchar_t* + ('ext', c_wchar_p), # [in] wchar_t* + ('maxframepersession', c_int32), # [in] + ('userdatasize', c_int32), # [in] + ('userdatasize_session', c_int32), # [in] + ('userdatasize_file', c_int32), # [in] + ('usertextsize', c_int32), # [in] + ('usertextsize_session', c_int32), # [in] + ('usertextsize_file', c_int32), # [in] + ] + + def __init__(self): + self.size = sizeof(DCAMREC_OPEN) + # wtextbuf = create_unicode_buffer(256) + # self.path = addressof(wtextbuf) + self.ext = 0 # 'dcimg'.encode('UTF-16') + self.maxframepersession = 0 + self.userdatasize_file = 0 + self.usertextsize_file = 0 + self.userdatasize_session = 0 + self.usertextsize_session = 0 + self.userdatasize = 0 + self.usertextsize = 0 + + def setpath(self, filepath): + self.path = filepath + + +# ==== assign aliases ==== + +dcamapi_init = __dll.dcamapi_init +dcamapi_init.argtypes = [POINTER(DCAMAPI_INIT)] +dcamapi_init.restype = DCAMERR +dcamapi_uninit = __dll.dcamapi_uninit +dcamapi_uninit.restype = DCAMERR +dcamdev_open = __dll.dcamdev_open +dcamdev_open.argtypes = [POINTER(DCAMDEV_OPEN)] +dcamdev_open.restype = DCAMERR +dcamdev_close = __dll.dcamdev_close +dcamdev_close.argtypes = [c_void_p] +dcamdev_close.restype = DCAMERR +dcamdev_getstring = __dll.dcamdev_getstring +dcamdev_getstring.argtypes = [c_void_p, POINTER(DCAMDEV_STRING)] +dcamdev_getstring.restype = DCAMERR +dcamprop_getattr = __dll.dcamprop_getattr +dcamprop_getattr.argtypes = [c_void_p, POINTER(DCAMPROP_ATTR)] +dcamprop_getattr.restype = DCAMERR +dcamprop_getvalue = __dll.dcamprop_getvalue +dcamprop_getvalue.argtypes = [c_void_p, c_int32, POINTER(c_double)] +dcamprop_getvalue.restype = DCAMERR +dcamprop_setvalue = __dll.dcamprop_setvalue +dcamprop_setvalue.argtypes = [c_void_p, c_int32, c_double] +dcamprop_setvalue.restype = DCAMERR +dcamprop_setgetvalue = __dll.dcamprop_setgetvalue +dcamprop_setgetvalue.argtypes = [c_void_p, c_int32, POINTER(c_double), c_int32] +dcamprop_setgetvalue.restype = DCAMERR +dcamprop_queryvalue = __dll.dcamprop_queryvalue +dcamprop_queryvalue.argtypes = [c_void_p, c_int32, POINTER(c_double), c_int32] +dcamprop_queryvalue.restype = DCAMERR +dcamprop_getnextid = __dll.dcamprop_getnextid +dcamprop_getnextid.argtypes = [c_void_p, POINTER(c_int32), c_int32] +dcamprop_getnextid.restype = DCAMERR +dcamprop_getname = __dll.dcamprop_getname +dcamprop_getname.argtypes = [c_void_p, c_int32, c_char_p, c_int32] +dcamprop_getname.restype = DCAMERR +dcamprop_getvaluetext = __dll.dcamprop_getvaluetext +dcamprop_getvaluetext.argtypes = [c_void_p, POINTER(DCAMPROP_VALUETEXT)] +dcamprop_getvaluetext.restype = DCAMERR +dcambuf_alloc = __dll.dcambuf_alloc +dcambuf_alloc.argtypes = [c_void_p, c_int32] +dcambuf_alloc.restype = DCAMERR +dcambuf_release = __dll.dcambuf_release +dcambuf_release.argtypes = [c_void_p, c_int32] +dcambuf_release.restype = DCAMERR +dcambuf_lockframe = __dll.dcambuf_lockframe +dcambuf_lockframe.argtypes = [c_void_p, POINTER(DCAMBUF_FRAME)] +dcambuf_lockframe.restype = DCAMERR +dcambuf_copyframe = __dll.dcambuf_copyframe +dcambuf_copyframe.argtypes = [c_void_p, POINTER(DCAMBUF_FRAME)] +dcambuf_copyframe.restype = DCAMERR +dcamcap_start = __dll.dcamcap_start +dcamcap_start.argtypes = [c_void_p, c_int32] +dcamcap_start.restype = DCAMERR +dcamcap_stop = __dll.dcamcap_stop +dcamcap_stop.argtypes = [c_void_p] +dcamcap_stop.restype = DCAMERR +dcamcap_status = __dll.dcamcap_status +dcamcap_status.argtypes = [c_void_p, POINTER(c_int32)] +dcamcap_status.restype = DCAMERR +dcamcap_transferinfo = __dll.dcamcap_transferinfo +dcamcap_transferinfo.argtypes = [c_void_p, POINTER(DCAMCAP_TRANSFERINFO)] +dcamcap_transferinfo.restype = DCAMERR +dcamcap_firetrigger = __dll.dcamcap_firetrigger +dcamcap_firetrigger.argtypes = [c_void_p, c_int32] +dcamcap_firetrigger.restype = DCAMERR + +if __platform_system == 'Windows': + dcamcap_record = __dll.dcamcap_record + dcamcap_record.argtypes = [c_void_p, c_void_p] + dcamcap_record.restype = DCAMERR + +dcamwait_open = __dll.dcamwait_open +dcamwait_open.argtypes = [POINTER(DCAMWAIT_OPEN)] +dcamwait_open.restype = DCAMERR +dcamwait_close = __dll.dcamwait_close +dcamwait_close.argtypes = [c_void_p] +dcamwait_close.restype = DCAMERR +dcamwait_start = __dll.dcamwait_start +dcamwait_start.argtypes = [c_void_p, POINTER(DCAMWAIT_START)] +dcamwait_start.restype = DCAMERR +dcamwait_abort = __dll.dcamwait_abort +dcamwait_abort.argtypes = [c_void_p] +dcamwait_abort.restype = DCAMERR + +if __platform_system == 'Windows': + dcamrec_open = __dll.dcamrec_openW + dcamrec_open.argtypes = [POINTER(DCAMREC_OPEN)] # DCAMREC_OPENW + dcamrec_open.restype = DCAMERR + + dcamrec_close = __dll.dcamrec_close + dcamrec_close.argtypes = [c_void_p] + dcamrec_close.restype = DCAMERR + From 45f17ebe3422f55a2eee86b0ee1a7a857e271be4 Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 19 May 2022 16:25:31 +1000 Subject: [PATCH 77/82] add Hamamatsu Class --- piescope/lm/detector.py | 57 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 55 insertions(+), 2 deletions(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index c6f0a78..fb36cb0 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -1,10 +1,12 @@ """Module for the Basler fluorescence detector.""" +from msilib.schema import Error import numpy as np -import logging +import logging from piescope.lm import structured from piescope.lm.laser import Laser from piescope.lm.mirror import StageMacro from pypylon import pylon +from piescope.lm.dcam.dcam import * from piescope.utils import TriggerMode from enum import Enum, auto @@ -19,7 +21,7 @@ def __init__(self, settings: dict): ) logging.info(f"Using {self.camera.GetDeviceInfo().GetModelName()} for light imaging.") self.camera.MaxNumBuffer = settings["imaging"]["lm"]["camera"]["max_num_buffer"] - self.pixel_size = 5.86e-6 + self.pixel_size = 5.86e-6 def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: """Grabs a single fluorescence image @@ -112,3 +114,54 @@ def maximum_exposure(self): except Exception as e: raise e return max_exposure + +class Hamamatsu: + """Class for the Hamamatsu detector""" + def __init__(self, settings: dict) -> None: + super(Hamamatsu, self).__init__() + if Dcamapi.init() is not False: + self.camera = Dcam(0) + self.pixel_size = 6.5e-6 + self.camera.prop_setvalue(DCAM_IDPROP.EXPOSURETIME, 0.01) + self.camera.prop_setvalue(DCAM_IDPROP.TRIGGERSOURCE, 2) + self.camera.prop_setvalue(DCAM_IDPROP.TRIGGERACTIVE, 2) + self.camera.prop_setvalue(DCAM_IDPROP.TRIGGER_MODE, 1) + self.camera.prop_setvalue(DCAM_IDPROP.TRIGGERPOLARITY, 2) + + def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: + """Grabs a single fluorescence image + + Args: + laser (Laser): the laser to use when taking the image + settings (dict): settings dictionary + + Raises: + e: exception + RuntimeError: times out if takes too long to obtain an image + + Returns: + np.ndarray: an image of dimension (row, col) + """ + + self.camera.dev_open() + self.camera.cap_stop() + + self.camera.buf_alloc(1) + if self.camera.cap_snapshot() is not False: + timeout_millisec = 10000 + while True: + if self.camera.wait_capevent_frameready(timeout_millisec) is not False: + structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) + data = self.camera.buf_getlastframedata() + break + + dcamerr = self.camera.lasterr() + if dcamerr.is_timeout(): + raise TimeoutError() + + else: + raise dcamerr + self.camera.buf_release() + self.camera.dev_close() + + From 2a26f95fd9c894eea799cc6f34c7f60a7c8d54d9 Mon Sep 17 00:00:00 2001 From: daviddierickx Date: Thu, 19 May 2022 16:34:16 +1000 Subject: [PATCH 78/82] Add close_camera function --- piescope/lm/detector.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index fb36cb0..bd4fd18 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -115,6 +115,9 @@ def maximum_exposure(self): raise e return max_exposure + def close_camera(self): + self.camera.Close() + class Hamamatsu: """Class for the Hamamatsu detector""" def __init__(self, settings: dict) -> None: @@ -164,4 +167,5 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.buf_release() self.camera.dev_close() - + def close_camera(self): + self.camera.dev_close() From d27470b03deb7885ad1d681acbb21ad7abe015d6 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Tue, 24 May 2022 10:30:59 +1000 Subject: [PATCH 79/82] need for speed --- piescope/lm/dcam/dcam.py | 2 +- piescope/lm/detector.py | 26 +++++++++++++++++++++----- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/piescope/lm/dcam/dcam.py b/piescope/lm/dcam/dcam.py index 1a07e4b..f43f0eb 100644 --- a/piescope/lm/dcam/dcam.py +++ b/piescope/lm/dcam/dcam.py @@ -4,7 +4,7 @@ # # The declarations of classes and functions in this file are subject to change without notice. -from dcamapi4 import * +from piescope.lm.dcam.dcamapi4 import * import numpy as np diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index bd4fd18..38a72f0 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -124,6 +124,7 @@ def __init__(self, settings: dict) -> None: super(Hamamatsu, self).__init__() if Dcamapi.init() is not False: self.camera = Dcam(0) + self.camera.dev_open() self.pixel_size = 6.5e-6 self.camera.prop_setvalue(DCAM_IDPROP.EXPOSURETIME, 0.01) self.camera.prop_setvalue(DCAM_IDPROP.TRIGGERSOURCE, 2) @@ -146,16 +147,25 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: np.ndarray: an image of dimension (row, col) """ - self.camera.dev_open() + # self.camera.dev_open() self.camera.cap_stop() - + import time self.camera.buf_alloc(1) if self.camera.cap_snapshot() is not False: timeout_millisec = 10000 + now = time.time() + structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) + print(f'Exposure complete, took: {(time.time()-now)*1e3}ms') + now = time.time() while True: if self.camera.wait_capevent_frameready(timeout_millisec) is not False: - structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) - data = self.camera.buf_getlastframedata() + print(f'Frame ready, took: {(time.time()-now)*1e3}ms') + now = time.time() + + data = self.camera.buf_getframe(0) + print(data) + print(f'Data read, took: {(time.time()-now)*1e3}ms') + now = time.time() break dcamerr = self.camera.lasterr() @@ -165,7 +175,13 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: else: raise dcamerr self.camera.buf_release() - self.camera.dev_close() + print(f'Buffer released, took: {(time.time()-now)*1e3}ms') + now = time.time() + # self.camera.dev_close() + print(f'Camera close, took: {(time.time()-now)*1e3}ms') + now = time.time() + + # return data def close_camera(self): self.camera.dev_close() From 65af18a17dcc0cf78de94e4dc490681c3ca125bc Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 4 Jul 2022 11:25:53 +1000 Subject: [PATCH 80/82] updated for hammatsu --- piescope/config.yml | 4 ++-- piescope/fibsem.py | 4 ++-- piescope/lm/detector.py | 41 +++++++++++++++++------------------------ 3 files changed, 21 insertions(+), 28 deletions(-) diff --git a/piescope/config.yml b/piescope/config.yml index 948b648..b9b9217 100644 --- a/piescope/config.yml +++ b/piescope/config.yml @@ -4,8 +4,8 @@ system: default_path: log/ pretilt: 27 relative_lm_position: - - 0.0499651 - - -0.0000472 + - 0.0498779 + - -0.0000716 fibsem_min_position: -10.e-3 fibsem_max_position: 10.e-3 lm_min_position: 40.e-3 diff --git a/piescope/fibsem.py b/piescope/fibsem.py index 550ca09..dea3c24 100644 --- a/piescope/fibsem.py +++ b/piescope/fibsem.py @@ -1,8 +1,8 @@ import logging -from re import M import numpy as np from piescope.utils import Modality +from autoscript_sdb_microscope_client import SdbMicroscopeClient """Module for interacting with the FIBSEM using Autoscript.""" @@ -36,7 +36,7 @@ def move_to_microscope(microscope, settings: dict): microscope.specimen.stage.relative_move(new_position) -def new_ion_image(microscope, settings=None): +def new_ion_image(microscope:SdbMicroscopeClient, settings=None): """Take new ion beam image. Uses whichever camera settings (resolution, dwell time, etc) are current. diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 38a72f0..927c5ba 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -38,6 +38,7 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: np.ndarray: an image of dimension (row, col) """ self.camera.Open() + # TODO: Put this camera.open on init self.camera.StopGrabbing() trigger_mode = settings["imaging"]["lm"]["trigger_mode"] @@ -147,41 +148,33 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: np.ndarray: an image of dimension (row, col) """ + # self.camera.cap_stop() # self.camera.dev_open() - self.camera.cap_stop() - import time self.camera.buf_alloc(1) - if self.camera.cap_snapshot() is not False: + + if self.camera.cap_start() is not False: timeout_millisec = 10000 - now = time.time() structured.single_line_pulse(delay=laser.exposure_time, pin=laser.pin) - print(f'Exposure complete, took: {(time.time()-now)*1e3}ms') - now = time.time() while True: if self.camera.wait_capevent_frameready(timeout_millisec) is not False: - print(f'Frame ready, took: {(time.time()-now)*1e3}ms') - now = time.time() - data = self.camera.buf_getframe(0) - print(data) - print(f'Data read, took: {(time.time()-now)*1e3}ms') - now = time.time() break dcamerr = self.camera.lasterr() if dcamerr.is_timeout(): raise TimeoutError() - else: - raise dcamerr - self.camera.buf_release() - print(f'Buffer released, took: {(time.time()-now)*1e3}ms') - now = time.time() - # self.camera.dev_close() - print(f'Camera close, took: {(time.time()-now)*1e3}ms') - now = time.time() - - # return data - + print(dcamerr) + + self.camera.cap_stop() + self.camera.buf_release() + # self.camera.dev_close() + image = np.flipud(data[-1]).T + # image = np.fliplr(image) + return image + print(self.camera.lasterr()) + + # TODO: once basler has been changed to have open on init, remove this def close_camera(self): - self.camera.dev_close() + pass + # self.camera.dev_close() From ab73e1367754c4a351f84c08410473af2f5fc92b Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 4 Jul 2022 12:30:51 +1000 Subject: [PATCH 81/82] [FEAT] add zoom for light imaging --- piescope/lm/detector.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 927c5ba..3fd3eeb 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -170,6 +170,13 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.buf_release() # self.camera.dev_close() image = np.flipud(data[-1]).T + + print("pre_shape: ", image.shape) + # cy, cx = image.shape[0] //2 , image.shape[1] // 2 + # h, w = cy // 2, cx // 2 + # image = image[cy-h:cy+h, cx-w:cx+w] + print("post shape: ", image.shape) + # image = np.fliplr(image) return image print(self.camera.lasterr()) From 93b9a5fc40daa0fb06a79452c30a81e7e6a8b022 Mon Sep 17 00:00:00 2001 From: Daviddierickx Date: Mon, 4 Jul 2022 13:40:52 +1000 Subject: [PATCH 82/82] cleanup --- piescope/lm/detector.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/piescope/lm/detector.py b/piescope/lm/detector.py index 3fd3eeb..927c5ba 100644 --- a/piescope/lm/detector.py +++ b/piescope/lm/detector.py @@ -170,13 +170,6 @@ def camera_grab(self, laser: Laser, settings: dict) -> np.ndarray: self.camera.buf_release() # self.camera.dev_close() image = np.flipud(data[-1]).T - - print("pre_shape: ", image.shape) - # cy, cx = image.shape[0] //2 , image.shape[1] // 2 - # h, w = cy // 2, cx // 2 - # image = image[cy-h:cy+h, cx-w:cx+w] - print("post shape: ", image.shape) - # image = np.fliplr(image) return image print(self.camera.lasterr())