From 23d1c42846ad2c489162fb833b2a582d5bd5e449 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 1 Jul 2020 19:36:41 -0400 Subject: [PATCH 01/68] Add object oriented skeleton for datasets --- oscopetools/read_data.py | 250 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 249 insertions(+), 1 deletion(-) diff --git a/oscopetools/read_data.py b/oscopetools/read_data.py index ef42afd..adbbfa6 100644 --- a/oscopetools/read_data.py +++ b/oscopetools/read_data.py @@ -5,11 +5,16 @@ @author: saskiad """ +from abc import ABC, abstractmethod +from copy import deepcopy +import matplotlib.pyplot as plt import h5py import pandas as pd import numpy as np +FRAME_RATE = 30.0 # Assumed frame rate in Hz. TODO: load from a file + def get_dff_traces(file_path): f = h5py.File(file_path) @@ -109,4 +114,247 @@ def get_stimulus_epochs(file_path, session_type): def get_eye_tracking(file_path): - return pd.read_hdf(file_path, 'eye_tracking') + raw_eyetracking_dataset = pd.read_hdf(file_path, 'eye_tracking') + return EyeTracking(raw_eyetracking_dataset, 1.0 / FRAME_RATE) + + +class Dataset(ABC): + """A dataset that is interesting to analyze on its own.""" + + @abstractmethod + def __init__(self): + self._clean = False # Whether quality control has been applied + + @abstractmethod + def plot(self, ax=None, **pltargs): + """Display a diagnostic plot. + + Parameters + ---------- + ax : matplotlib.Axes object or None + Axes object onto which to draw the diagnostic plot. Defaults to the + current Axes if None. + pltargs + Parameters passed to `plt.plot()` (or similar) as keyword + arguments. See `plt.plot` for a list of valid arguments. Examples: + `color='red'`, `linestyle='dashed'`. + + Returns + ------- + axes : Axes + Axes object containing the diagnostic plot. + + """ + # Suggested implementation for derived classes: + # def plot(self, type_specific_arguments, ax=None, **pltargs): + # ax = super().plot(ax=ax, **pltargs) + # ax.plot(relevant_data, **pltargs) # pltargs might include color, linestyle, etc + # return ax # ax should be returned so the user can change axis labels, etc + + # Default to the current Axes if none are supplied. + if ax is None: + ax = plt.gca() + + return ax + + @abstractmethod + def apply_quality_control(self, inplace=False): + """Clean up the dataset. + + Parameters + ---------- + inplace : bool, default False + Whether to clean up the current Dataset instance (ie, self) or + a copy. In either case, a cleaned Dataset instance is returned. + + Returns + ------- + dataset : Dataset + A cleaned dataset. + + """ + # Suggested implementation for derived classes: + # def apply_quality_control(self, type_specific_arguments, inplace=False): + # dset_to_clean = super().apply_quality_control(inplace) + # # Do stuff to `dset_to_clean` to clean it. + # dset_to_clean._clean = True + # return dset_to_clean + + # Get a reference to the dataset to be cleaned. Might be the current + # dataset or a copy of it. + if inplace: + dset_to_clean = self + else: + dset_to_clean = self.copy() + + return dset_to_clean + + def copy(self): + """Get a deep copy of the current Dataset.""" + return deepcopy(self) + + +class TimeseriesDataset(Dataset): + """Abstract base class for Datasets containing timeseries.""" + + def __init__(self, timestep_width): + self._timestep_width = timestep_width + + def __len__(self): + return self.num_timesteps + + @property + @abstractmethod + def num_timesteps(self): + """Number of timesteps in timeseries.""" + raise NotImplementedError + + @property + def timestep_width(self): + """Width of each timestep in seconds.""" + return self._timestep_width + + @property + def duration(self): + """Duration of the timeseries in seconds.""" + return self.num_timesteps * self.timestep_width + + @property + def time_vec(self): + """A vector of timestamps the same length as the timeseries.""" + time_vec = np.arange( + 0, self.duration - 0.5 * self.timestep_width, self.timestep_width + ) + assert len(time_vec) == len( + self + ), 'Length of time_vec ({}) does not match instance length ({})'.format( + len(time_vec), len(self) + ) + return time_vec + + def get_time_range(self, start: float, stop: float = None): + """Extract a time window from the timeseries by time in seconds. + + Parameters + ---------- + start, stop : float + Beginning and end of the time window to extract in seconds. If + `stop` is omitted, only the frame closest to `start` is returned. + + Returns + ------- + windowed_timeseries : TimeseriesDataset + A timeseries of the same type as the current instance containing + only the frames in the specified window. Note that the `time_vec` + of `windowed_timeseries` will start at 0, not `start`. + + """ + frame_range = [ + self._get_nearest_frame(t_) + for t_ in (start, stop) + if t_ is not None + ] + return self.get_frame_range(*frame_range) + + @abstractmethod + def get_frame_range(self, start: int, stop: int = None): + """Extract a time window from the timeseries by frame number. + + Parameters + ---------- + start, stop : int + Beginning and end of the time window to extract in frames. If + `stop` is omitted, only the `start` frame is returned. + + Returns + ------- + windowed_timeseries : TimeseriesDataset + A timeseries of the same type as the current instance containing + only the frames in the specified window. Note that the `time_vec` + of `windowed_timeseries` will start at 0, not `start`. + + """ + raise NotImplementedError + + def _get_nearest_frame(self, time_: float): + """Round a timestamp to the nearest integer frame number.""" + if time_ <= 0.0: + raise ValueError( + 'Expected `time_` to be >= 0, got {}'.format(time_) + ) + + frame_num = int(np.round(time_ / self.timestep_width)) + assert frame_num <= len(self) + + return min(frame_num, len(self) - 1) + + +class RawFluorescence(TimeseriesDataset): + pass + + +class DeltaFluorescence(TimeseriesDataset): + # This cannot be instantiated until all of the methods of its parents have + # been implemented. + pass + + +class EyeTracking(TimeseriesDataset): + _x_pos_name = 'x_pos_deg' + _y_pos_name = 'y_pos_deg' + + def __init__( + self, tracked_attributes: pd.DataFrame, timestep_width: float + ): + super().__init__(timestep_width) + self._dframe = pd.DataFrame(tracked_attributes) + + @property + def num_timesteps(self): + """Number of timesteps in EyeTracking dataset.""" + return self._dframe.shape[0] + + def get_frame_range(self, start: int, stop: int = None): + window = self.copy() + if stop is not None: + window._dframe = window._dframe.iloc[start:stop, :] + else: + window._dframe = window._dframe.iloc[start, :] + + return window + + def plot(self, channel='position', ax=None, **pltargs): + """Make a diagnostic plot of eyetracking data.""" + ax = super().plot(ax, **pltargs) + + # Check whether the `channel` argument is valid + if channel not in self._dframe.columns and channel != 'position': + raise ValueError( + 'Got unrecognized channel `{}`, expected one of ' + '{} or `position`'.format( + channel, self._dframe.columns.tolist() + ) + ) + + if channel in self._dframe.columns: + ax.plot(self.time_vec, self._dframe[channel], **pltargs) + elif channel == 'position': + ax.plot( + self._dframe[self._x_pos_name], + self._dframe[self._y_pos_name], + **pltargs + ) + else: + raise NotImplementedError( + 'Plotting for channel {} is not implemented.'.format(channel) + ) + + return ax + + def apply_quality_control(self, inplace=False): + super().apply_quality_control(inplace) + raise NotImplementedError + + +class RunningSpeed(TimeseriesDataset): + pass From b54d2cb29e9a8c70daf65b4bddcf2dbfff577f99 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 1 Jul 2020 19:17:50 -0500 Subject: [PATCH 02/68] Add density plot for EyeTracking position --- oscopetools/read_data.py | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/oscopetools/read_data.py b/oscopetools/read_data.py index adbbfa6..981c00c 100644 --- a/oscopetools/read_data.py +++ b/oscopetools/read_data.py @@ -7,8 +7,10 @@ """ from abc import ABC, abstractmethod from copy import deepcopy +import warnings import matplotlib.pyplot as plt +import seaborn as sns import h5py import pandas as pd import numpy as np @@ -339,11 +341,22 @@ def plot(self, channel='position', ax=None, **pltargs): if channel in self._dframe.columns: ax.plot(self.time_vec, self._dframe[channel], **pltargs) elif channel == 'position': - ax.plot( - self._dframe[self._x_pos_name], - self._dframe[self._y_pos_name], - **pltargs - ) + if pltargs.pop('style', None) in ['contour', 'density']: + x = self._dframe[self._x_pos_name] + y = self._dframe[self._y_pos_name] + mask = np.isnan(x) | np.isnan(y) + if any(mask): + warnings.warn( + 'Dropping {} NaN entries in order to estimate ' + 'density.'.format(sum(mask)) + ) + sns.kdeplot(x[~mask], y[~mask], ax=ax, **pltargs) + else: + ax.plot( + self._dframe[self._x_pos_name], + self._dframe[self._y_pos_name], + **pltargs + ) else: raise NotImplementedError( 'Plotting for channel {} is not implemented.'.format(channel) From 6fd956c0b4d24b4671dbbb0a8bbfb9caaad398bb Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 1 Jul 2020 19:18:13 -0500 Subject: [PATCH 03/68] Add .ipynb_checkpoints to gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 2cd9ef5..89d4d90 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,5 @@ *.pyc __pycache__ *.egg-info +.ipynb_checkpoints plots/ From 8899cf67d95db0ffe0fea72c83c78d92cd3863a7 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 3 Jul 2020 17:31:31 -0400 Subject: [PATCH 04/68] Add fluorescence objects --- oscopetools/read_data.py | 258 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 250 insertions(+), 8 deletions(-) diff --git a/oscopetools/read_data.py b/oscopetools/read_data.py index 981c00c..0710c34 100644 --- a/oscopetools/read_data.py +++ b/oscopetools/read_data.py @@ -234,7 +234,7 @@ def time_vec(self): ) return time_vec - def get_time_range(self, start: float, stop: float = None): + def get_time_range(self, start, stop=None): """Extract a time window from the timeseries by time in seconds. Parameters @@ -259,7 +259,7 @@ def get_time_range(self, start: float, stop: float = None): return self.get_frame_range(*frame_range) @abstractmethod - def get_frame_range(self, start: int, stop: int = None): + def get_frame_range(self, start, stop=None): """Extract a time window from the timeseries by frame number. Parameters @@ -278,7 +278,7 @@ def get_frame_range(self, start: int, stop: int = None): """ raise NotImplementedError - def _get_nearest_frame(self, time_: float): + def _get_nearest_frame(self, time_): """Round a timestamp to the nearest integer frame number.""" if time_ <= 0.0: raise ValueError( @@ -291,14 +291,256 @@ def _get_nearest_frame(self, time_: float): return min(frame_num, len(self) - 1) -class RawFluorescence(TimeseriesDataset): +class SliceParseError(Exception): pass -class DeltaFluorescence(TimeseriesDataset): - # This cannot be instantiated until all of the methods of its parents have - # been implemented. - pass +class TrialDataset(Dataset): + """Abstract base class for datasets that are divided into trials. + + All children should have a list-like `_trial_num` attribute. + + """ + + @property + def num_trials(self): + """Number of trials.""" + return len(self._trial_num) + + @property + def trial_vec(self): + """Trial numbers.""" + return self._trial_num + + def get_trials(self, *args): + """Get a subset of the trials in TrialDataset. + + Parameters + ---------- + start, stop : int + Get a range of trials from `start` to an optional `stop`. + mask : bool vector-like + A boolean mask used to select trials. + + Returns + ------- + trial_subset : TrialDataset + A new `TrialDataset` object containing only the specified trials. + + """ + # Implementation note: + # This function tries to convert positional arguments to a boolean + # trial mask. `_get_trials_from_mask` is reponsible for actually + # getting the `trial_subset` to be returned. + try: + # Try to parse positional arguments as a range of trials + trial_range = self._try_parse_positionals_as_slice_like(*args) + mask = self._trial_range_to_mask(*trial_range) + except SliceParseError: + # Couldn't parse pos args as a range of trials. Try parsing as + # a boolean trial mask. + if len(args) == 1: + mask = self._validate_trial_mask_shape(args[0]) + else: + raise ValueError( + 'Expected a single mask argument, got {}'.format(len(args)) + ) + + return self._get_trials_from_mask(mask) + + @abstractmethod + def _get_trials_from_mask(self, mask): + """Get a subset of trials using a boolean mask. + + Subclasses are required to implement this method to get the rest of + TrialDataset functionality. + + Parameters + ---------- + mask : bool vector-like + A boolean trial mask, the length of which is guaranteed to match + the number of trials. + + Returns + ------- + trial_subset : TrialDataset + A new `TrialDataset` object containing only the specified trials. + + """ + raise NotImplementedError + + def _try_parse_positionals_as_slice_like(self, *args): + if len(args) == 0: + # Case: Positional arguments are empty + raise ValueError('Empty positional arguments') + elif len(args) == 1: + # Case: Positional arguments contain a single element. + # If it's an integer, use that as the value for slice `start` + # If it's a tuple, try to use it as a `(start, stop)` pair + try: + # Check if args contains a single integer scalar + if int(args[0]) == args[0]: + return args[0] + else: + raise SliceParseError( + 'Positional argument {} is not int-like'.format( + args[0] + ) + ) + except TypeError: + if (len(args[0]) == 1) or (len(args[0]) == 2): + return args[0] + else: + raise SliceParseError( + 'Found more than two elements in tuple {}'.format( + args[0] + ) + ) + elif len(args) == 2: + return args + else: + raise SliceParseError + + def _validate_trial_mask_shape(self, mask): + if np.ndim(mask) != 1: + raise ValueError( + 'Expected mask to be vector-like, got ' + '{}D array instead'.format(np.ndim(mask)) + ) + + mask = np.asarray(mask).flatten() + if len(mask) != self.num_trials: + raise ValueError( + 'len of mask {} does not match number of ' + 'trials {}'.format(len(mask), self.num_trials) + ) + + return mask + + def _trial_range_to_mask(self, start, stop=None): + """Convert a range of trials to a boolean trial mask.""" + mask = self.trial_vec >= start + if stop is not None: + mask &= self.trial_vec < stop + return mask + + +class Fluorescence(TimeseriesDataset): + """A fluorescence timeseries. + + Any fluorescence timeseries. May have one or more cells and one or more + trials. + + """ + + @property + def num_timesteps(self): + """Number of timesteps.""" + return self.fluo.shape[-1] + + def get_frame_range(self, start, stop=None): + """Get a time window by frame number.""" + fluo_copy = self.copy() + + if stop is None: + time_slice = self.fluo[..., start][..., np.newaxis] + else: + time_slice = self.fluo[..., start:stop] + + fluo_copy.fluo = time_slice + return fluo_copy + + def _xticks_to_timestamps(self, ax): + xtick_locations = ax.get_xticks() + time_stamps = self.time_vec[np.round(xtick_locations).astype(int)] + ax.set_xticklabels(time_stamps) + ax.set_xlabel('Time (s)') + + +class RawFluorescence(TimeseriesDataset): + """Fluorescence timeseries from a full imaging session. + + Not divided into trials. + + """ + + def __init__(self, fluorescence_array): + fluorescence_array = np.asarray(fluorescence_array) + assert fluorescence_array.ndim() == 2 + + self.fluo = fluorescence_array + self.is_z_score = False + self.is_dff = False + + def z_score(self): + """Convert to Z-score.""" + if self.is_z_score: + raise ValueError('Instance is already a Z-score') + else: + z_score = self.fluo - self.fluo.mean(axis=1)[:, np.newaxis] + z_score /= z_score.std(axis=1)[:, np.newaxis] + self.fluo = z_score + self.is_z_score = True + + def cut_by_trials(self, trial_times): + """Divide fluorescence traces up into equal-length trials. + + Parameters + ---------- + trial_times + + Returns + ------- + trial_fluorescence : TrialFluorescence + + """ + # TODO: divide up into trials + raise NotImplementedError + + def plot(self, ax=None, **pltargs): + if ax is not None: + ax = plt.gca() + + ax.imshow(self.fluo, **pltargs) + self._xticks_to_timestamps(ax) + + return ax + + def apply_quality_control(self, inplace=False): + raise NotImplementedError + + +class TrialFluorescence(TrialDataset, TimeseriesDataset): + """Fluorescence timeseries divided into trials.""" + + def __init__(self, fluorescence_array, trial_num): + fluorescence_array = np.asarray(fluorescence_array) + assert fluorescence_array.ndim() == 3 + assert fluorescence_array.shape[0] == len(trial_num) + + self.fluo = fluorescence_array + self._trial_num = trial_num + self.is_z_score = False + self.is_dff = False + + def _get_trials_from_mask(self, mask): + trial_subset = self.copy() + trial_subset._trial_num = trial_subset._trial_num[mask] + trial_subset.fluo = trial_subset.fluo[mask, ...] + + return trial_subset + + def plot(self, ax=None, **pltargs): + if ax is None: + ax = plt.gca() + + ax.imshow(self.fluo.mean(axis=0), **pltargs) + self._xticks_to_timestamps(ax) + + return ax + + def apply_quality_control(self, inplace=False): + raise NotImplementedError class EyeTracking(TimeseriesDataset): From 96d1247d2d6789e684878db6f0e678f1e2745369 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 3 Jul 2020 17:53:31 -0400 Subject: [PATCH 05/68] Add RawFluorescence to read_data factory functions Make read_data.{get_dff_traces, get_raw_traces} build RawFluorescence objects instead of returning numpy arrays. RawFluorescence is untested. --- oscopetools/read_data.py | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/oscopetools/read_data.py b/oscopetools/read_data.py index 0710c34..9d94b6c 100644 --- a/oscopetools/read_data.py +++ b/oscopetools/read_data.py @@ -22,14 +22,22 @@ def get_dff_traces(file_path): f = h5py.File(file_path) dff = f['dff_traces'][()] f.close() - return dff + + fluorescence_dataset = RawFluorescence(dff, 1.0 / FRAME_RATE) + fluorescence_dataset.is_dff = True + + return fluorescence_dataset def get_raw_traces(file_path): f = h5py.File(file_path) raw = f['raw_traces'][()] f.close() - return raw + + fluorescence_dataset = RawFluorescence(raw, 1.0 / FRAME_RATE) + fluorescence_dataset.is_dff = False + + return fluorescence_dataset def get_running_speed(file_path): @@ -457,17 +465,19 @@ def _xticks_to_timestamps(self, ax): ax.set_xlabel('Time (s)') -class RawFluorescence(TimeseriesDataset): +class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. Not divided into trials. """ - def __init__(self, fluorescence_array): + def __init__(self, fluorescence_array, timestep_width): fluorescence_array = np.asarray(fluorescence_array) assert fluorescence_array.ndim() == 2 + super().__init__(timestep_width) + self.fluo = fluorescence_array self.is_z_score = False self.is_dff = False @@ -510,14 +520,16 @@ def apply_quality_control(self, inplace=False): raise NotImplementedError -class TrialFluorescence(TrialDataset, TimeseriesDataset): +class TrialFluorescence(TrialDataset, Fluorescence): """Fluorescence timeseries divided into trials.""" - def __init__(self, fluorescence_array, trial_num): + def __init__(self, fluorescence_array, trial_num, timestep_width): fluorescence_array = np.asarray(fluorescence_array) assert fluorescence_array.ndim() == 3 assert fluorescence_array.shape[0] == len(trial_num) + self._timestep_width = timestep_width + self.fluo = fluorescence_array self._trial_num = trial_num self.is_z_score = False From 8ebfc1b673fdf9d52260e747b8d4ac63e301e071 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Mon, 6 Jul 2020 17:32:37 -0400 Subject: [PATCH 06/68] Break up read_data and introduce CenterSurround classes - Break up oscopetools.read_data into multiple files. Changes nothing for clients--all the functions and classes are still loaded into the `read_data` namespace. - Introduce a `CenterSurroundStimulus` object to represent a center-surround stimulus and make `get_stimulus_table('path/to/dfile.h5', 'center_surround')` load it. --- oscopetools/read_data/__init__.py | 3 + oscopetools/read_data/conditions.py | 357 ++++++++++++++++++ .../dataset_objects.py} | 125 +----- oscopetools/read_data/factories.py | 218 +++++++++++ oscopetools/read_data/test_conditions.py | 105 ++++++ 5 files changed, 687 insertions(+), 121 deletions(-) create mode 100644 oscopetools/read_data/__init__.py create mode 100644 oscopetools/read_data/conditions.py rename oscopetools/{read_data.py => read_data/dataset_objects.py} (83%) create mode 100644 oscopetools/read_data/factories.py create mode 100644 oscopetools/read_data/test_conditions.py diff --git a/oscopetools/read_data/__init__.py b/oscopetools/read_data/__init__.py new file mode 100644 index 0000000..bba457b --- /dev/null +++ b/oscopetools/read_data/__init__.py @@ -0,0 +1,3 @@ +from .factories import * +from .dataset_objects import * +from .conditions import * diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py new file mode 100644 index 0000000..b34a2cc --- /dev/null +++ b/oscopetools/read_data/conditions.py @@ -0,0 +1,357 @@ +"""Types for representing experimental conditions.""" + +__all__ = ( + 'Orientation', + 'TemporalFrequency', + 'SpatialFrequency', + 'Contrast', + 'CenterSurroundStimulus', +) + +import warnings + +import numpy as np + + +class _IterableNamedOrderedSet(type): + def __iter__(cls): + for member in cls._MEMBERS: + yield cls(member) + + +class SetMembershipError(Exception): + pass + + +class _NamedOrderedSet(metaclass=_IterableNamedOrderedSet): + _MEMBERS = () + + def __init__(self, member_value): + if member_value in self._MEMBERS: + self._member_value = member_value + elif np.isnan(member_value): + self._member_value = None + else: + raise SetMembershipError( + 'Unrecognized member {}, expected ' + 'one of {}'.format(member_value, self._MEMBERS) + ) + + def __eq__(self, other): + raise NotImplementedError + + def __lt__(self, other): + raise NotImplementedError + + def __le__(self, other): + return self.__lt__(other) or self.__eq__(other) + + def __gt__(self, other): + return not self.__le__(other) + + def __ge__(self, other): + return not self.__lt__(other) + + def __repr__(self): + return '_NamedOrderedSet({})'.format(self._member_value) + + +class Orientation(_NamedOrderedSet): + """Orientation of part of a CenterSurroundStimulus.""" + + _MEMBERS = (None, 0, 45, 90, 135, 180, 225, 270, 315) + + def __init__(self, orientation): + if issubclass(type(orientation), Orientation): + member_value = orientation._member_value + else: + member_value = orientation + + super().__init__(member_value) + + @property + def orientation(self): + """Orientation in degrees.""" + return self._member_value + + def __lt__(self, other): + other_as_ori = Orientation(other) + + if (self._member_value is not None) and ( + other_as_ori.orientation is not None + ): + result = self._member_value < other_as_ori.orientation + elif (self._member_value is None) and ( + other_as_ori.orientation is not None + ): + result = True + else: + result = False + + return result + + def __eq__(self, other): + other_as_ori = Orientation(other) + return other_as_ori.orientation == self._member_value + + def __repr__(self): + return 'Orientation({})'.format(self._member_value) + + +class Contrast(_NamedOrderedSet): + """Contrast of a CenterSurroundStimulus.""" + + _MEMBERS = [0.8] + + def __init__(self, contrast): + if issubclass(type(contrast), Contrast): + member_value = contrast._member_value + else: + member_value = contrast + + super().__init__(member_value) + + def __lt__(self, other): + other_as_contrast = Contrast(other) + + if (self._member_value is not None) and ( + other_as_contrast._member_value is not None + ): + result = self._member_value < other_as_contrast._member_value + elif (self._member_value is None) and ( + other_as_contrast._member_value is not None + ): + result = True + else: + result = False + + return result + + def __eq__(self, other): + other_as_contrast = Contrast(other) + return other_as_contrast._member_value == self._member_value + + def __repr__(self): + return 'Contrast({})'.format(self._member_value) + + +class TemporalFrequency(_NamedOrderedSet): + """Temporal frequency of a CenterSurroundStimulus.""" + + _MEMBERS = (1, 2) + + def __init__(self, temporal_frequency): + if issubclass(type(temporal_frequency), TemporalFrequency): + member_value = temporal_frequency._member_value + else: + member_value = temporal_frequency + + super().__init__(member_value) + + def __lt__(self, other): + other_as_tf = TemporalFrequency(other) + + if (self._member_value is not None) and ( + other_as_tf._member_value is not None + ): + result = self._member_value < other_as_tf._member_value + elif (self._member_value is None) and ( + other_as_tf._member_value is not None + ): + result = True + else: + result = False + + return result + + def __eq__(self, other): + other_as_tf = TemporalFrequency(other) + return other_as_tf._member_value == self._member_value + + def __repr__(self): + return 'TemporalFrequency({})'.format(self._member_value) + + +class SpatialFrequency(_NamedOrderedSet): + """Spatial frequency of a CenterSurroundStimulus.""" + + _MEMBERS = [0.04] + + def __init__(self, spatial_frequency): + if issubclass(type(spatial_frequency), SpatialFrequency): + member_value = spatial_frequency._member_value + else: + member_value = spatial_frequency + + super().__init__(member_value) + + def __lt__(self, other): + other_as_tf = SpatialFrequency(other) + + if (self._member_value is not None) and ( + other_as_tf._member_value is not None + ): + result = self._member_value < other_as_tf._member_value + elif (self._member_value is None) and ( + other_as_tf._member_value is not None + ): + result = True + else: + result = False + + return result + + def __eq__(self, other): + other_as_tf = SpatialFrequency(other) + return other_as_tf._member_value == self._member_value + + def __repr__(self): + return 'SpatialFrequency({})'.format(self._member_value) + + +class CenterSurroundStimulus: + """A center-surround stimulus with possibly empty components. + + Methods + ------- + is_empty() + Returns True if the stimulus is completely empty. + center_is_empty() + Returns True if the center of the visual field is empty. + surround_is_empty() + Returns True if the surround part of the visual field is empty. + + Attributes + ---------- + temporal_frequency : TemporalFrequency + spatial_frequency : SpatialFrequency + contrast : Contrast + center_orientation, surround_orientation : Orientation + Orientation of center and surround part of the visual field. Can be + empty if this part of the visual field is omitted. + + Notes + ----- + Please use this class instead of a DataFrame with NaN entries. NaN is not + equal to itself, is not greater or less than other quantities, and is not + equal to zero (coercing it to zero using np.nan_to_num could cause bugs by + mixing empty stimuli with eg. stimulus with 0 deg orientation), whereas + `CenterSurroundStimulus` and its attributes are always guaranteed to be + well-defined. + + """ + + def __init__( + self, + temporal_frequency, + spatial_frequency, + contrast, + center_orientation, + surround_orientation, + ): + """Initialize CenterSurroundStimulus. + + Parameters + ---------- + temporal_frequency : int, float, or TemporalFrequency + spatial_frequency : int, float, or SpatialFrequency + contrast : int, float, or Contrast + center_orientation, surround_orientation : int, float, None, NaN, or Orientation + Orientation in degrees, or None or NaN if absent. + + Returns + ------- + center_surround_stimulus : CenterSurroundStimulus + + Raises + ------ + SetMembershipError + If one of the parameters has an invalid value. + + """ + if (center_orientation is None) or np.isnan(center_orientation): + warnings.warn( + 'Constructing a CenterSurroundStimulus with an empty center.' + ) + self._stimulus_attributes = { + 'temporal_frequency': TemporalFrequency(temporal_frequency), + 'spatial_frequency': SpatialFrequency(spatial_frequency), + 'contrast': Contrast(contrast), + 'center_orientation': Orientation(center_orientation), + 'surround_orientation': Orientation(surround_orientation), + } + + @property + def temporal_frequency(self): + return self._stimulus_attributes['temporal_frequency'] + + @property + def spatial_frequency(self): + return self._stimulus_attributes['spatial_frequency'] + + @property + def contrast(self): + return self._stimulus_attributes['contrast'] + + @property + def center_orientation(self): + """Center orientation in degrees.""" + return self._stimulus_attributes['center_orientation'] + + @property + def surround_orientation(self): + """Surround orientation in degrees.""" + return self._stimulus_attributes['surround_orientation'] + + def is_empty(self): + """Check whether the stimulus is completely empty.""" + return self == CenterSurroundStimulus(None, None, None, None, None) + + def center_is_empty(self): + """Check whether the center of the stimulus is empty.""" + return self.center_orientation == Orientation(None) + + def surround_is_empty(self): + """Check whether the surround portion of the stimulus is empty.""" + return self.surround_orientation == Orientation(None) + + def __repr__(self): + return ( + f'CenterSurroundStimulus(' + f'{self.temporal_frequency._member_value}, ' + f'{self.spatial_frequency._member_value}, ' + f'{self.contrast._member_value}, ' + f'{self.center_orientation._member_value}, ' + f'{self.surround_orientation._member_value})' + ) + + def __str__(self): + return ( + '\rCenterSurroundStimulus with attributes' + f'\n temporal_frequency {str(self.temporal_frequency._member_value):>5}' + f'\n spatial_frequency {str(self.spatial_frequency._member_value):>5}' + f'\n contrast {str(self.contrast._member_value):>5}' + f'\n center_orientation {str(self.center_orientation._member_value):>5}' + f'\n surround_orientation {str(self.surround_orientation._member_value):>5}\n' + ) + + def __eq__(self, other): + """Test equality.""" + if not issubclass(type(other), CenterSurroundStimulus): + raise TypeError( + '`==` is not supported between types ' + '`CenterSurroundStimulus` and `{}`'.format(type(other)) + ) + + # Two CenterSurroundStimulus objects are equal if all attrs are equal. + if all( + [ + getattr(self, name) == getattr(other, name) + for name in self._stimulus_attributes + ] + ): + result = True + else: + result = False + + return result diff --git a/oscopetools/read_data.py b/oscopetools/read_data/dataset_objects.py similarity index 83% rename from oscopetools/read_data.py rename to oscopetools/read_data/dataset_objects.py index 9d94b6c..057441c 100644 --- a/oscopetools/read_data.py +++ b/oscopetools/read_data/dataset_objects.py @@ -1,131 +1,14 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Sat Jun 6 21:59:56 2020 +"""Classes for interacting with OpenScope datasets.""" +__all__ = ('RawFluorescence', 'TrialFluorescence', 'EyeTracking') -@author: saskiad -""" from abc import ABC, abstractmethod from copy import deepcopy import warnings -import matplotlib.pyplot as plt +import numpy as np import seaborn as sns -import h5py +import matplotlib.pyplot as plt import pandas as pd -import numpy as np - -FRAME_RATE = 30.0 # Assumed frame rate in Hz. TODO: load from a file - - -def get_dff_traces(file_path): - f = h5py.File(file_path) - dff = f['dff_traces'][()] - f.close() - - fluorescence_dataset = RawFluorescence(dff, 1.0 / FRAME_RATE) - fluorescence_dataset.is_dff = True - - return fluorescence_dataset - - -def get_raw_traces(file_path): - f = h5py.File(file_path) - raw = f['raw_traces'][()] - f.close() - - fluorescence_dataset = RawFluorescence(raw, 1.0 / FRAME_RATE) - fluorescence_dataset.is_dff = False - - return fluorescence_dataset - - -def get_running_speed(file_path): - f = h5py.File(file_path) - dx = f['running_speed'][()] - f.close() - return dx - - -def get_cell_ids(file_path): - f = h5py.File(file_path) - cell_ids = f['cell_ids'][()] - f.close() - return cell_ids - - -def get_max_projection(file_path): - f = h5py.File(file_path) - max_proj = f['max_projection'][()] - f.close() - return max_proj - - -def get_metadata(file_path): - import ast - - f = h5py.File(file_path) - md = f.get('meta_data')[...].tolist() - f.close() - meta_data = ast.literal_eval(md) - return meta_data - - -def get_roi_table(file_path): - return pd.read_hdf(file_path, 'roi_table') - - -def get_stimulus_table(file_path, stimulus): - return pd.read_hdf(file_path, stimulus) - - -def get_stimulus_epochs(file_path, session_type): - if session_type == 'drifting_gratings_grid': - stim_name_1 = 'drifting_gratings_grid' - elif session_type == 'center_surround': - stim_name_1 = 'center_surround' - elif session_type == 'size_tuning': - stim_name_1 = np.NaN # TODO: figure this out - - stim1 = get_stimulus_table(file_path, stim_name_1) - stim2 = get_stimulus_table(file_path, 'locally_sparse_noise') - stim_epoch = pd.DataFrame(columns=('Start', 'End', 'Stimulus_name')) - break1 = np.where(np.ediff1d(stim1.Start) > 1000)[0][0] - break2 = np.where(np.ediff1d(stim2.Start) > 1000)[0][0] - stim_epoch.loc[0] = [stim1.Start[0], stim1.End[break1], stim_name_1] - stim_epoch.loc[1] = [stim1.Start[break1 + 1], stim1.End.max(), stim_name_1] - stim_epoch.loc[2] = [ - stim2.Start[0], - stim2.End[break2], - 'locally_sparse_noise', - ] - stim_epoch.loc[3] = [ - stim2.Start[break2 + 1], - stim2.End.max(), - 'locally_sparse_noise', - ] - stim_epoch.sort_values(by='Start', inplace=True) - stim_epoch.loc[4] = [ - 0, - stim_epoch.Start.iloc[0] - 1, - 'spontaneous_activity', - ] - for i in range(1, 4): - stim_epoch.loc[4 + i] = [ - stim_epoch.End.iloc[i - 1] + 1, - stim_epoch.Start.iloc[i] - 1, - 'spontaneous_activity', - ] - stim_epoch.sort_values(by='Start', inplace=True) - stim_epoch.reset_index(inplace=True) - stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start - - return stim_epoch - - -def get_eye_tracking(file_path): - raw_eyetracking_dataset = pd.read_hdf(file_path, 'eye_tracking') - return EyeTracking(raw_eyetracking_dataset, 1.0 / FRAME_RATE) class Dataset(ABC): diff --git a/oscopetools/read_data/factories.py b/oscopetools/read_data/factories.py new file mode 100644 index 0000000..9ed72e8 --- /dev/null +++ b/oscopetools/read_data/factories.py @@ -0,0 +1,218 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sat Jun 6 21:59:56 2020 + +@author: saskiad +""" + +__all__ = ( + 'get_dff_traces', + 'get_raw_traces', + 'get_cell_ids', + 'get_max_projection', + 'get_metadata', + 'get_stimulus_table', + 'get_stimulus_epochs', + 'get_eye_tracking', + 'get_running_speed', + 'get_roi_table', +) + +import warnings + +import h5py +import pandas as pd +import numpy as np + +from .dataset_objects import RawFluorescence, EyeTracking +from .conditions import CenterSurroundStimulus, SetMembershipError + +FRAME_RATE = 30.0 # Assumed frame rate in Hz. TODO: load from a file + + +def get_dff_traces(file_path): + """Get DFF normalized fluorescence traces. + + Parameters + ---------- + file_path : str + Path to an HDF5 file containing DFF-normalized fluorescence traces. + + Returns + ------- + dff_fluorescence : RawFluorescence + A `TimeseriesDataset` subclass containing DFF-normalized fluorescence + traces. + + """ + f = h5py.File(file_path) + dff = f['dff_traces'][()] + f.close() + + fluorescence_dataset = RawFluorescence(dff, 1.0 / FRAME_RATE) + fluorescence_dataset.is_dff = True + + return fluorescence_dataset + + +def get_raw_traces(file_path): + """Get raw fluorescence traces. + + Parameters + ---------- + file_path : str + Path to an HDF5 file containing raw fluorescence traces. + + Returns + ------- + raw_fluoresence : RawFluorescence + A `TimeseriesDataset` subclass containing fluorescence traces. + + """ + f = h5py.File(file_path) + raw = f['raw_traces'][()] + f.close() + + fluorescence_dataset = RawFluorescence(raw, 1.0 / FRAME_RATE) + fluorescence_dataset.is_dff = False + + return fluorescence_dataset + + +def get_running_speed(file_path): + f = h5py.File(file_path) + dx = f['running_speed'][()] + f.close() + return dx + + +def get_cell_ids(file_path): + f = h5py.File(file_path) + cell_ids = f['cell_ids'][()] + f.close() + return cell_ids + + +def get_max_projection(file_path): + f = h5py.File(file_path) + max_proj = f['max_projection'][()] + f.close() + return max_proj + + +def get_metadata(file_path): + import ast + + f = h5py.File(file_path) + md = f.get('meta_data')[...].tolist() + f.close() + meta_data = ast.literal_eval(md) + return meta_data + + +def get_roi_table(file_path): + return pd.read_hdf(file_path, 'roi_table') + + +def get_stimulus_table(file_path, stimulus): + """Read stimulus table into a pd.DataFrame. + + Parameters + ---------- + file_path : str + stimulus : str + Type of stimulus to load. + + Returns + ------- + stimulus_table : pd.DataFrame + + Notes + ----- + If `stimulus` is 'center_surround', details of the stimulus are loaded + into `CenterSurroundStimulus` objects. See + `oscopetools.read_data.CenterSurroundStimulus` for details. + + """ + df = pd.read_hdf(file_path, stimulus) + + center_surround_objects = [] + invalid_rows = [] + if stimulus == 'center_surround': + for ind, row in df.iterrows(): + try: + cs_stimulus = CenterSurroundStimulus( + row['TF'], + row['SF'], + row['Contrast'], + row['Center_Ori'], + row['Surround_Ori'], + ) + center_surround_objects.append(cs_stimulus) + except SetMembershipError: + invalid_rows.append(ind) + + if len(invalid_rows) > 0: + warnings.warn( + 'Removed {} trials with invalid stimulus parameters: {}'.format( + len(invalid_rows), df.loc[invalid_rows, :] + ) + ) + + df['center_surround'] = center_surround_objects + df.drop( + columns=['TF', 'SF', 'Contrast', 'Center_Ori', 'Surround_Ori'], + inplace=True, + ) + + return pd.read_hdf(file_path, stimulus) + + +def get_stimulus_epochs(file_path, session_type): + if session_type == 'drifting_gratings_grid': + stim_name_1 = 'drifting_gratings_grid' + elif session_type == 'center_surround': + stim_name_1 = 'center_surround' + elif session_type == 'size_tuning': + stim_name_1 = np.NaN # TODO: figure this out + + stim1 = get_stimulus_table(file_path, stim_name_1) + stim2 = get_stimulus_table(file_path, 'locally_sparse_noise') + stim_epoch = pd.DataFrame(columns=('Start', 'End', 'Stimulus_name')) + break1 = np.where(np.ediff1d(stim1.Start) > 1000)[0][0] + break2 = np.where(np.ediff1d(stim2.Start) > 1000)[0][0] + stim_epoch.loc[0] = [stim1.Start[0], stim1.End[break1], stim_name_1] + stim_epoch.loc[1] = [stim1.Start[break1 + 1], stim1.End.max(), stim_name_1] + stim_epoch.loc[2] = [ + stim2.Start[0], + stim2.End[break2], + 'locally_sparse_noise', + ] + stim_epoch.loc[3] = [ + stim2.Start[break2 + 1], + stim2.End.max(), + 'locally_sparse_noise', + ] + stim_epoch.sort_values(by='Start', inplace=True) + stim_epoch.loc[4] = [ + 0, + stim_epoch.Start.iloc[0] - 1, + 'spontaneous_activity', + ] + for i in range(1, 4): + stim_epoch.loc[4 + i] = [ + stim_epoch.End.iloc[i - 1] + 1, + stim_epoch.Start.iloc[i] - 1, + 'spontaneous_activity', + ] + stim_epoch.sort_values(by='Start', inplace=True) + stim_epoch.reset_index(inplace=True) + stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start + + return stim_epoch + + +def get_eye_tracking(file_path): + raw_eyetracking_dataset = pd.read_hdf(file_path, 'eye_tracking') + return EyeTracking(raw_eyetracking_dataset, 1.0 / FRAME_RATE) diff --git a/oscopetools/read_data/test_conditions.py b/oscopetools/read_data/test_conditions.py new file mode 100644 index 0000000..5457736 --- /dev/null +++ b/oscopetools/read_data/test_conditions.py @@ -0,0 +1,105 @@ +import unittest + +import numpy as np + +from . import conditions as cond + + +class OrientationOrdering(unittest.TestCase): + def test_le_numeric(self): + self.assertLess(cond.Orientation(45), cond.Orientation(90)) + self.assertLess(cond.Orientation(90), cond.Orientation(180)) + + def test_le_none(self): + self.assertLess(cond.Orientation(None), cond.Orientation(45)) + self.assertLess(cond.Orientation(None), cond.Orientation(0)) + + def test_le_nan(self): + self.assertLess(cond.Orientation(np.nan), cond.Orientation(45)) + self.assertLess(cond.Orientation(np.nan), cond.Orientation(0)) + + def test_ge_numeric(self): + self.assertGreater(cond.Orientation(90), cond.Orientation(45)) + + def test_ge_none(self): + self.assertGreater(cond.Orientation(45), cond.Orientation(None)) + self.assertGreater(cond.Orientation(0), cond.Orientation(None)) + + def test_ge_nan(self): + self.assertGreater(cond.Orientation(45), cond.Orientation(np.nan)) + self.assertGreater(cond.Orientation(0), cond.Orientation(np.nan)) + + def test_eq_numeric(self): + self.assertEqual(cond.Orientation(45), cond.Orientation(45)) + self.assertEqual(cond.Orientation(90), cond.Orientation(90.0)) + + def test_eq_none(self): + """Assert that None orientation is equal to itself.""" + self.assertEqual(cond.Orientation(None), cond.Orientation(None)) + self.assertNotEqual(cond.Orientation(None), cond.Orientation(0)) + + def test_eq_nan(self): + """Assert that NaN orientation is equal to itself.""" + self.assertEqual(cond.Orientation(np.nan), cond.Orientation(np.nan)) + self.assertNotEqual(cond.Orientation(np.nan), cond.Orientation(0)) + + def test_eq_nan_none(self): + """Assert that None and NaN orientations are equal.""" + self.assertEqual(cond.Orientation(np.nan), cond.Orientation(None)) + + +class OrientationIteration(unittest.TestCase): + def test_iteration(self): + """Iteration yield all allowed values + None""" + for allowed_value, orientation_value in zip( + cond.Orientation._MEMBERS, cond.Orientation + ): + self.assertEqual(orientation_value, allowed_value) + + +class CenterSurroundStimulusEquality(unittest.TestCase): + def test_equal_all_numeric(self): + css1 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, 90) + css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, 90) + self.assertEqual(css1, css2) + + def test_neq_all_numeric(self): + css1 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, 90) + + # Not equal if surround orientation differs + css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, 45) + self.assertNotEqual(css1, css2) + + # Not equal if center orientation differs + css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 90, 90) + self.assertNotEqual(css1, css2) + + # Not equal if temporal_frequency differs + css2 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, 45, 90) + self.assertNotEqual(css1, css2) + + def test_eq_all_none(self): + css1 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, None, None) + css2 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, None, None) + self.assertEqual(css1, css2) + + def test_eq_all_nan(self): + css1 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, np.nan, np.nan) + css2 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, np.nan, np.nan) + self.assertEqual(css1, css2) + + def test_eq_nan_none(self): + css1 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, np.nan, np.nan) + css2 = cond.CenterSurroundStimulus(1.0, 0.04, 0.8, None, None) + self.assertEqual(css1, css2) + + def test_neq_some_none(self): + css1 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, 90) + + # Not equal if surround orientation differs + css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, 45, None) + self.assertNotEqual(css1, css2) + + # Not equal if center orientation differs + css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, None, 90) + self.assertNotEqual(css1, css2) From 1237f0be40b3aae81b81c3499c5e5e3b5e226888 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Mon, 6 Jul 2020 16:46:52 -0500 Subject: [PATCH 07/68] Bugfixes in CenterSurroundStimulus and factory --- oscopetools/read_data/conditions.py | 2 +- oscopetools/read_data/factories.py | 26 +++++++++++++++----------- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index b34a2cc..7126fe8 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -29,7 +29,7 @@ class _NamedOrderedSet(metaclass=_IterableNamedOrderedSet): def __init__(self, member_value): if member_value in self._MEMBERS: self._member_value = member_value - elif np.isnan(member_value): + elif np.isnan(member_value) and (None in self._MEMBERS): self._member_value = None else: raise SetMembershipError( diff --git a/oscopetools/read_data/factories.py b/oscopetools/read_data/factories.py index 9ed72e8..b6d3b27 100644 --- a/oscopetools/read_data/factories.py +++ b/oscopetools/read_data/factories.py @@ -153,20 +153,24 @@ def get_stimulus_table(file_path, stimulus): except SetMembershipError: invalid_rows.append(ind) - if len(invalid_rows) > 0: - warnings.warn( - 'Removed {} trials with invalid stimulus parameters: {}'.format( - len(invalid_rows), df.loc[invalid_rows, :] + if len(invalid_rows) > 0: + warnings.warn( + 'Removed {} trials with invalid stimulus parameters: {}'.format( + len(invalid_rows), df.loc[invalid_rows, :] + ) ) - ) - df['center_surround'] = center_surround_objects - df.drop( - columns=['TF', 'SF', 'Contrast', 'Center_Ori', 'Surround_Ori'], - inplace=True, - ) + print(len(center_surround_objects)) + print(len(invalid_rows)) + print(df.shape[0]) + df.drop(index=invalid_rows, inplace=True) + df['center_surround'] = center_surround_objects + df.drop( + columns=['TF', 'SF', 'Contrast', 'Center_Ori', 'Surround_Ori'], + inplace=True, + ) - return pd.read_hdf(file_path, stimulus) + return df def get_stimulus_epochs(file_path, session_type): From c1d4db01285985954738e9666de54acaba5aa4a8 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Mon, 6 Jul 2020 17:51:10 -0400 Subject: [PATCH 08/68] Implement hashing for CenterSurroundStimulus --- oscopetools/read_data/conditions.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index 7126fe8..a80ab3b 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -55,6 +55,9 @@ def __ge__(self, other): def __repr__(self): return '_NamedOrderedSet({})'.format(self._member_value) + def __hash__(self): + return hash(self._member_value) + class Orientation(_NamedOrderedSet): """Orientation of part of a CenterSurroundStimulus.""" @@ -355,3 +358,6 @@ def __eq__(self, other): result = False return result + + def __hash__(self): + return hash((value for value in self._stimulus_attributes.values())) From e538236fadd4879248d50c5147d88acea708a24c Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Mon, 6 Jul 2020 18:21:28 -0400 Subject: [PATCH 09/68] Implement slicing RawFluorescence into TrialFluorescence --- oscopetools/read_data/dataset_objects.py | 65 ++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 4 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 057441c..5145f00 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -329,6 +329,11 @@ def num_timesteps(self): """Number of timesteps.""" return self.fluo.shape[-1] + @property + def num_cells(self): + """Number of ROIs.""" + return self.fluo.shape[-2] + def get_frame_range(self, start, stop=None): """Get a time window by frame number.""" fluo_copy = self.copy() @@ -375,20 +380,72 @@ def z_score(self): self.fluo = z_score self.is_z_score = True - def cut_by_trials(self, trial_times): + def cut_by_trials(self, trial_timetable): """Divide fluorescence traces up into equal-length trials. Parameters ---------- - trial_times + trial_timetable : pd.DataFrame-like + A DataFrame-like object with 'Start' and 'End' items for the start + and end frames of each trial, respectively. Returns ------- trial_fluorescence : TrialFluorescence """ - # TODO: divide up into trials - raise NotImplementedError + if ('Start' not in trial_timetable) or ('End' not in trial_timetable): + raise ValueError( + 'Could not find `Start` and `End` in trial_timetable.' + ) + + # Slice the RawFluorescence up into trials. + trials = [] + num_frames = [] + for start, end in zip( + trial_timetable['Start'], trial_timetable['End'] + ): + trials.append(self.get_frame_range(start, end)) + num_frames = end - start + + # Truncate all trials to the same length if necessary + min_num_frames = min(num_frames) + if not all([dur == min_num_frames for dur in num_frames]): + warnings.warn( + 'Truncating all trials to shortest duration {} ' + 'frames (longest trial is {} frames)'.format( + min_num_frames, max(num_frames) + ) + ) + for i in range(len(trials)): + trials[i] = trials[i].get_frame_range(0, min_num_frames) + + # Try to get a vector of trial numbers + try: + trial_num = trial_timetable['trial_num'] + except KeyError: + try: + trial_num = trial_timetable.index.tolist() + except AttributeError: + warnings.warn( + 'Could not get trial_num from trial_timetable. ' + 'Falling back to arange.' + ) + trial_num = np.arange(0, len(trials)) + + # Construct TrialFluorescence and return it. + trial_fluorescence = TrialFluorescence( + np.array([tr.fluo for tr in trials]), + trial_num, + self.timestep_width, + ) + + # Check that trial_fluorescence was constructed correctly. + assert trial_fluorescence.num_cells == self.num_cells + assert trial_fluorescence.num_timesteps == min_num_frames + assert trial_fluorescence.num_trials == len(trials) + + return trial_fluorescence def plot(self, ax=None, **pltargs): if ax is not None: From 3b5eeff4c4c1bae3531693753310efdb1f7b56cb Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Mon, 6 Jul 2020 18:56:42 -0500 Subject: [PATCH 10/68] Fix bugs with plotting fluorescence --- oscopetools/read_data/dataset_objects.py | 55 ++++++++++++++++-------- 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 5145f00..6b74008 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -271,7 +271,7 @@ def _try_parse_positionals_as_slice_like(self, *args): try: # Check if args contains a single integer scalar if int(args[0]) == args[0]: - return args[0] + return [args[0]] else: raise SliceParseError( 'Positional argument {} is not int-like'.format( @@ -280,7 +280,7 @@ def _try_parse_positionals_as_slice_like(self, *args): ) except TypeError: if (len(args[0]) == 1) or (len(args[0]) == 2): - return args[0] + return np.atleast_1d(args[0]) else: raise SliceParseError( 'Found more than two elements in tuple {}'.format( @@ -310,9 +310,11 @@ def _validate_trial_mask_shape(self, mask): def _trial_range_to_mask(self, start, stop=None): """Convert a range of trials to a boolean trial mask.""" - mask = self.trial_vec >= start if stop is not None: + mask = self.trial_vec >= start mask &= self.trial_vec < stop + else: + mask = self.trial_vec == start return mask @@ -346,12 +348,6 @@ def get_frame_range(self, start, stop=None): fluo_copy.fluo = time_slice return fluo_copy - def _xticks_to_timestamps(self, ax): - xtick_locations = ax.get_xticks() - time_stamps = self.time_vec[np.round(xtick_locations).astype(int)] - ax.set_xticklabels(time_stamps) - ax.set_xlabel('Time (s)') - class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. @@ -362,7 +358,7 @@ class RawFluorescence(Fluorescence): def __init__(self, fluorescence_array, timestep_width): fluorescence_array = np.asarray(fluorescence_array) - assert fluorescence_array.ndim() == 2 + assert fluorescence_array.ndim == 2 super().__init__(timestep_width) @@ -380,7 +376,7 @@ def z_score(self): self.fluo = z_score self.is_z_score = True - def cut_by_trials(self, trial_timetable): + def cut_by_trials(self, trial_timetable, num_baseline_frames=None): """Divide fluorescence traces up into equal-length trials. Parameters @@ -399,14 +395,28 @@ def cut_by_trials(self, trial_timetable): 'Could not find `Start` and `End` in trial_timetable.' ) + if (num_baseline_frames is None) or (num_baseline_frames < 0): + num_baseline_frames = 0 + # Slice the RawFluorescence up into trials. trials = [] num_frames = [] for start, end in zip( trial_timetable['Start'], trial_timetable['End'] ): - trials.append(self.get_frame_range(start, end)) - num_frames = end - start + # Coerce `start` and `end` to ints if possible + if (int(start) != start) or (int(end) != end): + raise ValueError( + 'Expected trial start and end frame numbers' + ' to be ints, got {} and {} instead'.format( + start, end + ) + ) + start = max(int(start) - num_baseline_frames, 0) + end = int(end) + + trials.append(self.fluo[..., start:end]) + num_frames.append(end - start) # Truncate all trials to the same length if necessary min_num_frames = min(num_frames) @@ -418,7 +428,7 @@ def cut_by_trials(self, trial_timetable): ) ) for i in range(len(trials)): - trials[i] = trials[i].get_frame_range(0, min_num_frames) + trials[i] = trials[i][..., :min_num_frames] # Try to get a vector of trial numbers try: @@ -435,10 +445,13 @@ def cut_by_trials(self, trial_timetable): # Construct TrialFluorescence and return it. trial_fluorescence = TrialFluorescence( - np.array([tr.fluo for tr in trials]), + np.asarray(trials), trial_num, self.timestep_width, ) + trial_fluorescence.is_z_score = self.is_z_score + trial_fluorescence.is_dff = self.is_dff + trial_fluorescence._baseline_duration = num_baseline_frames * self.timestep_width # Check that trial_fluorescence was constructed correctly. assert trial_fluorescence.num_cells == self.num_cells @@ -452,7 +465,6 @@ def plot(self, ax=None, **pltargs): ax = plt.gca() ax.imshow(self.fluo, **pltargs) - self._xticks_to_timestamps(ax) return ax @@ -465,16 +477,22 @@ class TrialFluorescence(TrialDataset, Fluorescence): def __init__(self, fluorescence_array, trial_num, timestep_width): fluorescence_array = np.asarray(fluorescence_array) - assert fluorescence_array.ndim() == 3 + assert fluorescence_array.ndim == 3 assert fluorescence_array.shape[0] == len(trial_num) self._timestep_width = timestep_width + self._baseline_duration = 0 self.fluo = fluorescence_array - self._trial_num = trial_num + self._trial_num = np.asarray(trial_num) self.is_z_score = False self.is_dff = False + @property + def time_vec(self): + time_vec_without_baseline = super().time_vec + return time_vec_without_baseline - self._baseline_duration + def _get_trials_from_mask(self, mask): trial_subset = self.copy() trial_subset._trial_num = trial_subset._trial_num[mask] @@ -487,7 +505,6 @@ def plot(self, ax=None, **pltargs): ax = plt.gca() ax.imshow(self.fluo.mean(axis=0), **pltargs) - self._xticks_to_timestamps(ax) return ax From 9cc637fa707e5860c91e6c0dbae5f81aa42cbdd0 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 7 Jul 2020 09:35:08 -0400 Subject: [PATCH 11/68] Update python and dep requirements --- requirements.txt | 10 ++++++++++ setup.py | 1 + 2 files changed, 11 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..4119a83 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +numpy>=1.18.5 +matplotlib>=3.2.1 +seaborn>=0.10.1 +pandas>=1.0.3 +tqdm>=4.45.0 +h5py>=2.10.0 +psychopy==2020.1.2 +pillow>=7.1.2 +pg8000>=1.15.2 +nd2reader>=3.2.1 diff --git a/setup.py b/setup.py index 17055e7..c121b77 100644 --- a/setup.py +++ b/setup.py @@ -4,6 +4,7 @@ name='openscope', description='Tools for surround-suppression AIBS Open Scope project.', packages=['oscopetools'], + python_requires='>=3', install_requires=[ 'psychopy', 'numpy', From 1153cafa21a3f3a9746f86a61a607f46de99c54e Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 7 Jul 2020 10:50:02 -0400 Subject: [PATCH 12/68] Add read_data import to oscopetools init --- oscopetools/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/oscopetools/__init__.py b/oscopetools/__init__.py index 216b588..6f8f16b 100644 --- a/oscopetools/__init__.py +++ b/oscopetools/__init__.py @@ -1,6 +1,7 @@ from . import chi_square_lsn from . import chisq_categorical from . import get_all_data +from . import read_data from . import locally_sparse_noise from . import nd2_zstack from . import roi_information From 7e8a2096e95527bf7658b91b96f8e6b227b789ae Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 7 Jul 2020 10:50:35 -0400 Subject: [PATCH 13/68] Add sphinx docs Run `make doc` to generate HTML documentation for oscopetools. --- .gitignore | 1 + Makefile | 11 +++++++++++ conf.py | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ index.rst | 18 +++++++++++++++++ 4 files changed, 88 insertions(+) create mode 100644 Makefile create mode 100644 conf.py create mode 100644 index.rst diff --git a/.gitignore b/.gitignore index 89d4d90..4040aa5 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ __pycache__ *.egg-info .ipynb_checkpoints plots/ +_build/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..dcc9dea --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ +.PHONY : doc +doc : + mkdir -p _build/docsource + cp index.rst _build/docsource/ + sphinx-apidoc -f -o _build/docsource oscopetools **/test_*.py + sphinx-build _build/docsource _build/html -c . + open _build/html/index.html + +.PHONY : clean +clean : + rm -rf _build/* diff --git a/conf.py b/conf.py new file mode 100644 index 0000000..a4ecbc4 --- /dev/null +++ b/conf.py @@ -0,0 +1,58 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +project = 'OScopeTools' +copyright = '2020, Saskia de Vries, Dan Millman, Emerson Harkin' +author = 'Saskia de Vries, Dan Millman, Emerson Harkin' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.napoleon', + 'sphinx_rtd_theme' +] + +autodoc_default_options = { + 'inherited-members': True +} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'test_*.py'] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] diff --git a/index.rst b/index.rst new file mode 100644 index 0000000..8d3031d --- /dev/null +++ b/index.rst @@ -0,0 +1,18 @@ +.. OScopeTools documentation master file, created by + sphinx-quickstart on Tue Jul 7 09:38:50 2020. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to OScopeTools's documentation! +======================================= + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` From 93536d934d7bfe5ae84e2bc1bc75b55b688f8d9c Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 7 Jul 2020 10:53:41 -0400 Subject: [PATCH 14/68] Add sphinx dependencies to requirements.txt --- requirements.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/requirements.txt b/requirements.txt index 4119a83..3716ea9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,3 +8,6 @@ psychopy==2020.1.2 pillow>=7.1.2 pg8000>=1.15.2 nd2reader>=3.2.1 + +sphinx>=3.1.1 +sphinx-rtd-theme>=0.5.0 From 43db06d589774a13666fc64d78af76bcb933d88c Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 7 Jul 2020 15:24:06 -0400 Subject: [PATCH 15/68] Improve performance of copy operations Optionally copy fluorescence datasets more quickly by getting a read-only view of the underlying fluorescence array instead of copying it. This provides an order of magnitude speedup of slicing operations such as `get_time_range`. --- oscopetools/read_data/dataset_objects.py | 36 ++++++++++++++++++++---- 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 6b74008..a6df60a 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -338,16 +338,40 @@ def num_cells(self): def get_frame_range(self, start, stop=None): """Get a time window by frame number.""" - fluo_copy = self.copy() + fluo_copy = self.copy(read_only=True) if stop is None: time_slice = self.fluo[..., start][..., np.newaxis] else: time_slice = self.fluo[..., start:stop] - fluo_copy.fluo = time_slice + fluo_copy.fluo = time_slice.copy() return fluo_copy + def copy(self, read_only=False): + """Get a deep copy. + + Parameters + ---------- + read_only : bool, default False + Whether to get a read-only copy of the underlying `fluo` array. + Getting a read-only copy is much faster and should be used if a + large number of copies need to be created. + + """ + if read_only: + # Get a read-only view of the fluo array + # This is much faster than creating a full copy + read_only_fluo = self.fluo.view() + read_only_fluo.flags.writeable = False + + deepcopy_memo = {id(self.fluo): read_only_fluo} + copy_ = deepcopy(self, deepcopy_memo) + else: + copy_ = deepcopy(self) + + return copy_ + class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. @@ -494,9 +518,9 @@ def time_vec(self): return time_vec_without_baseline - self._baseline_duration def _get_trials_from_mask(self, mask): - trial_subset = self.copy() + trial_subset = self.copy(read_only=True) trial_subset._trial_num = trial_subset._trial_num[mask] - trial_subset.fluo = trial_subset.fluo[mask, ...] + trial_subset.fluo = trial_subset.fluo[mask, ...].copy() return trial_subset @@ -530,9 +554,9 @@ def num_timesteps(self): def get_frame_range(self, start: int, stop: int = None): window = self.copy() if stop is not None: - window._dframe = window._dframe.iloc[start:stop, :] + window._dframe = window._dframe.iloc[start:stop, :].copy() else: - window._dframe = window._dframe.iloc[start, :] + window._dframe = window._dframe.iloc[start, :].copy() return window From 0dedcddc189208f68fba6ae14f420e140259a3a6 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 14:56:32 -0400 Subject: [PATCH 16/68] Add subsetting by cell to Fluorescence objects --- oscopetools/read_data/dataset_objects.py | 201 +++++++++++------- oscopetools/read_data/test_dataset_objects.py | 99 +++++++++ 2 files changed, 224 insertions(+), 76 deletions(-) create mode 100644 oscopetools/read_data/test_dataset_objects.py diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index a6df60a..eb7f48a 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -11,6 +11,84 @@ import pandas as pd +class SliceParseError(Exception): + pass + +def _try_parse_positionals_as_slice_like(*args): + """Try to parse positional arguments as a slice-like int or pair of ints. + + Output can be treated as a `(start, stop)` range (where `stop` is optional) + on success, and can be treated as a boolean mask if a `SliceParseError` is + raised. + + Returns + ------- + slice_like : [int] or [int, int] + + Raises + ------ + SliceParseError + If positional arguments are a boolean mask, not a slice. + TypeError + If positional arguments are not bool-like or int-like. + ValueError + If positional arguments are empty or have more than two entries. + + """ + flattened_args = np.asarray(args).flatten() + if len(flattened_args) == 0: + raise ValueError('Empty positional arguments') + elif _is_bool(flattened_args[0]): + raise SliceParseError('Cannot parse bool positionals as slice.') + elif int(flattened_args[0]) != flattened_args[0]: + raise TypeError( + 'Expected positionals to be bool-like or int-like, ' + 'got type {} instead'.format( + flattened_args.dtype + ) + ) + elif (len(flattened_args) > 0) and (len(flattened_args) <= 2): + # Positional arguments are a valid slice-like int or pair of ints + return flattened_args.tolist() + else: + # Case: positionals are not bool and are of the wrong length + raise ValueError( + 'Positionals of length {} cannot be parsed as slice-like'.format( + len(flattened_args) + ) + ) + +def _is_bool(x): + return isinstance(x, (bool, np.bool, np.bool8, np.bool_)) + + +def _validate_vector_mask_length(mask, expected_length): + if np.ndim(mask) != 1: + raise ValueError( + 'Expected mask to be vector-like, got ' + '{}D array instead'.format(np.ndim(mask)) + ) + + mask = np.asarray(mask).flatten() + if len(mask) != expected_length: + raise ValueError( + 'Expected mask of length {}, got mask of ' + 'length {} instead.'.format(len(mask), expected_length) + ) + + return mask + + +def _get_vector_mask_from_range(values_to_mask, start, stop=None): + """Unmask all values within a range.""" + if stop is not None: + mask = values_to_mask >= start + mask &= values_to_mask < stop + else: + mask = values_to_mask == start + return mask + + class Dataset(ABC): """A dataset that is interesting to analyze on its own.""" @@ -181,11 +259,6 @@ def _get_nearest_frame(self, time_): return min(frame_num, len(self) - 1) - -class SliceParseError(Exception): - pass - - class TrialDataset(Dataset): """Abstract base class for datasets that are divided into trials. @@ -225,13 +298,13 @@ def get_trials(self, *args): # getting the `trial_subset` to be returned. try: # Try to parse positional arguments as a range of trials - trial_range = self._try_parse_positionals_as_slice_like(*args) - mask = self._trial_range_to_mask(*trial_range) + trial_range = _try_parse_positionals_as_slice_like(*args) + mask = _get_vector_mask_from_range(self.trial_vec, *trial_range) except SliceParseError: # Couldn't parse pos args as a range of trials. Try parsing as # a boolean trial mask. if len(args) == 1: - mask = self._validate_trial_mask_shape(args[0]) + mask = _validate_vector_mask_length(args[0], self.num_trials) else: raise ValueError( 'Expected a single mask argument, got {}'.format(len(args)) @@ -260,63 +333,6 @@ def _get_trials_from_mask(self, mask): """ raise NotImplementedError - def _try_parse_positionals_as_slice_like(self, *args): - if len(args) == 0: - # Case: Positional arguments are empty - raise ValueError('Empty positional arguments') - elif len(args) == 1: - # Case: Positional arguments contain a single element. - # If it's an integer, use that as the value for slice `start` - # If it's a tuple, try to use it as a `(start, stop)` pair - try: - # Check if args contains a single integer scalar - if int(args[0]) == args[0]: - return [args[0]] - else: - raise SliceParseError( - 'Positional argument {} is not int-like'.format( - args[0] - ) - ) - except TypeError: - if (len(args[0]) == 1) or (len(args[0]) == 2): - return np.atleast_1d(args[0]) - else: - raise SliceParseError( - 'Found more than two elements in tuple {}'.format( - args[0] - ) - ) - elif len(args) == 2: - return args - else: - raise SliceParseError - - def _validate_trial_mask_shape(self, mask): - if np.ndim(mask) != 1: - raise ValueError( - 'Expected mask to be vector-like, got ' - '{}D array instead'.format(np.ndim(mask)) - ) - - mask = np.asarray(mask).flatten() - if len(mask) != self.num_trials: - raise ValueError( - 'len of mask {} does not match number of ' - 'trials {}'.format(len(mask), self.num_trials) - ) - - return mask - - def _trial_range_to_mask(self, start, stop=None): - """Convert a range of trials to a boolean trial mask.""" - if stop is not None: - mask = self.trial_vec >= start - mask &= self.trial_vec < stop - else: - mask = self.trial_vec == start - return mask - class Fluorescence(TimeseriesDataset): """A fluorescence timeseries. @@ -326,6 +342,14 @@ class Fluorescence(TimeseriesDataset): """ + def __init__(self, fluorescence_array, timestep_width): + super().__init__(timestep_width) + + self.fluo = np.asarray(fluorescence_array) + self.cell_vec = np.arange(0, self.num_cells) + self.is_z_score = False + self.is_dff = False + @property def num_timesteps(self): """Number of timesteps.""" @@ -336,6 +360,27 @@ def num_cells(self): """Number of ROIs.""" return self.fluo.shape[-2] + def get_cells(self, *args): + # Implementation note: + # This function tries to convert positional arguments to a boolean + # cell mask. `_get_cells_from_mask` is reponsible for actually + # getting the `cell_subset` to be returned. + try: + # Try to parse positional arguments as a range of cells + cell_range = _try_parse_positionals_as_slice_like(*args) + mask = _get_vector_mask_from_range(self.cell_vec, *cell_range) + except SliceParseError: + # Couldn't parse pos args as a range of cells. Try parsing as + # a boolean cell mask. + if len(args) == 1: + mask = _validate_vector_mask_length(args[0], self.num_cells) + else: + raise ValueError( + 'Expected a single mask argument, got {}'.format(len(args)) + ) + + return self._get_cells_from_mask(mask) + def get_frame_range(self, start, stop=None): """Get a time window by frame number.""" fluo_copy = self.copy(read_only=True) @@ -372,6 +417,17 @@ def copy(self, read_only=False): return copy_ + def _get_cells_from_mask(self, mask): + cell_subset = self.copy(read_only=False) + cell_subset.cell_vec = self.cell_vec[mask].copy() + cell_subset.fluo = self.fluo[..., mask, :].copy() + + assert cell_subset.fluo.ndim == self.fluo.ndim + assert cell_subset.num_cells == np.sum(mask) + + return cell_subset + + class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. @@ -384,11 +440,7 @@ def __init__(self, fluorescence_array, timestep_width): fluorescence_array = np.asarray(fluorescence_array) assert fluorescence_array.ndim == 2 - super().__init__(timestep_width) - - self.fluo = fluorescence_array - self.is_z_score = False - self.is_dff = False + super().__init__(fluorescence_array, timestep_width) def z_score(self): """Convert to Z-score.""" @@ -496,7 +548,7 @@ def apply_quality_control(self, inplace=False): raise NotImplementedError -class TrialFluorescence(TrialDataset, Fluorescence): +class TrialFluorescence(Fluorescence, TrialDataset): """Fluorescence timeseries divided into trials.""" def __init__(self, fluorescence_array, trial_num, timestep_width): @@ -504,13 +556,10 @@ def __init__(self, fluorescence_array, trial_num, timestep_width): assert fluorescence_array.ndim == 3 assert fluorescence_array.shape[0] == len(trial_num) - self._timestep_width = timestep_width + super().__init__(fluorescence_array, timestep_width) self._baseline_duration = 0 - self.fluo = fluorescence_array self._trial_num = np.asarray(trial_num) - self.is_z_score = False - self.is_dff = False @property def time_vec(self): @@ -519,7 +568,7 @@ def time_vec(self): def _get_trials_from_mask(self, mask): trial_subset = self.copy(read_only=True) - trial_subset._trial_num = trial_subset._trial_num[mask] + trial_subset._trial_num = trial_subset._trial_num[mask].copy() trial_subset.fluo = trial_subset.fluo[mask, ...].copy() return trial_subset diff --git a/oscopetools/read_data/test_dataset_objects.py b/oscopetools/read_data/test_dataset_objects.py new file mode 100644 index 0000000..7b5e7be --- /dev/null +++ b/oscopetools/read_data/test_dataset_objects.py @@ -0,0 +1,99 @@ +import unittest + +import numpy as np +from numpy import testing as npt + +from . import dataset_objects as do + +class TestTrialFluorescenceSubsetting(unittest.TestCase): + def setUp(self): + self.fluo_matrix = np.array([ + # Trial 0 + [[1, 2], # Cell 0 + [3, 4], # Cell 1 + [5, 6]], # Cell 2 + # Trial 1 + [[7, 8], # Cell 0 + [9, 10], # Cell 1 + [11, 12]] # Cell 2 + ]) + self.trial_fluorescence = do.TrialFluorescence( + self.fluo_matrix, [0, 1], 1. / 30. + ) + + def test_cell_subset_by_single_int(self): + # Test whether fluorescence is extracted correctly + cell_to_extract = 0 + expected_fluo = self.fluo_matrix[:, cell_to_extract, :][:, np.newaxis, :] + actual_fluo = self.trial_fluorescence.get_cells(cell_to_extract).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether cell labels are subsetted correctly + npt.assert_array_equal( + [cell_to_extract], + self.trial_fluorescence.get_cells(cell_to_extract).cell_vec + ) + + def test_cell_subset_by_pair_of_ints(self): + # Test whether fluorescence is extracted correctly + expected_fluo = self.fluo_matrix[:, 0:2, :] + actual_fluo = self.trial_fluorescence.get_cells(0, 2).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether cell labels are subsetted correctly + npt.assert_array_equal( + [0, 1], + self.trial_fluorescence.get_cells(0, 2).cell_vec + ) + + def test_cell_subset_by_tuple_of_ints(self): + # Test whether fluorescence is extracted correctly + expected_fluo = self.fluo_matrix[:, 0:2, :] + actual_fluo = self.trial_fluorescence.get_cells((0, 2)).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether cell labels are subsetted correctly + npt.assert_array_equal( + [0, 1], + self.trial_fluorescence.get_cells((0, 2)).cell_vec + ) + + def test_cell_subset_by_bool_mask(self): + mask = [True, False, True] + expected_fluo = self.fluo_matrix[:, mask, :] + actual_fluo = self.trial_fluorescence.get_cells(mask).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether cell labels are subsetted correctly + npt.assert_array_equal( + [0, 2], + self.trial_fluorescence.get_cells(mask).cell_vec + ) + + def test_trial_subset_by_single_int(self): + # Test whether fluorescence is extracted correctly + trial_to_extract = 0 + expected_fluo = self.fluo_matrix[trial_to_extract, :, :][np.newaxis, :, :] + actual_fluo = self.trial_fluorescence.get_trials(trial_to_extract).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether cell labels are subsetted correctly + npt.assert_array_equal( + [trial_to_extract], + self.trial_fluorescence.get_trials(trial_to_extract).trial_vec + ) + + def test_trial_subset_by_bool_mask(self): + mask = [False, True] + expected_fluo = self.fluo_matrix[mask, :, :] + actual_fluo = self.trial_fluorescence.get_trials(mask).fluo + npt.assert_array_equal(expected_fluo, actual_fluo) + + # Test whether trial labels are subsetted correctly + npt.assert_array_equal( + [1], + self.trial_fluorescence.get_trials(mask).trial_vec + ) + + + From 7ef8dbdea8336d220771860b999a668d99819560 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 15:17:01 -0400 Subject: [PATCH 17/68] Autoformat and add summary stats to TrialFluorescence - Autoformat `dataset_objects.py` - Add `trial_mean()` and `trial_std()` to `TrialFluorescence` --- oscopetools/read_data/dataset_objects.py | 117 +++++++++++++++--- oscopetools/read_data/test_dataset_objects.py | 58 +++++++++ 2 files changed, 157 insertions(+), 18 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index eb7f48a..dcf6516 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -14,6 +14,7 @@ class SliceParseError(Exception): pass + def _try_parse_positionals_as_slice_like(*args): """Try to parse positional arguments as a slice-like int or pair of ints. @@ -43,9 +44,7 @@ def _try_parse_positionals_as_slice_like(*args): elif int(flattened_args[0]) != flattened_args[0]: raise TypeError( 'Expected positionals to be bool-like or int-like, ' - 'got type {} instead'.format( - flattened_args.dtype - ) + 'got type {} instead'.format(flattened_args.dtype) ) elif (len(flattened_args) > 0) and (len(flattened_args) <= 2): # Positional arguments are a valid slice-like int or pair of ints @@ -58,6 +57,7 @@ def _try_parse_positionals_as_slice_like(*args): ) ) + def _is_bool(x): return isinstance(x, (bool, np.bool, np.bool8, np.bool_)) @@ -259,6 +259,7 @@ def _get_nearest_frame(self, time_): return min(frame_num, len(self) - 1) + class TrialDataset(Dataset): """Abstract base class for datasets that are divided into trials. @@ -333,6 +334,32 @@ def _get_trials_from_mask(self, mask): """ raise NotImplementedError + @abstractmethod + def trial_mean(self): + """Get the mean across all trials. + + Returns + ------- + trial_mean : TrialDataset + A new `TrialDataset` object containing the mean of all trials in + the current one. + + """ + raise NotImplementedError + + @abstractmethod + def trial_std(self): + """Get the standard deviation across all trials. + + Returns + ------- + trial_std : TrialDataset + A new `TrialDataset` object containing the standard deviation of + all trials in the current one. + + """ + raise NotImplementedError + class Fluorescence(TimeseriesDataset): """A fluorescence timeseries. @@ -428,7 +455,6 @@ def _get_cells_from_mask(self, mask): return cell_subset - class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. @@ -484,9 +510,7 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None): if (int(start) != start) or (int(end) != end): raise ValueError( 'Expected trial start and end frame numbers' - ' to be ints, got {} and {} instead'.format( - start, end - ) + ' to be ints, got {} and {} instead'.format(start, end) ) start = max(int(start) - num_baseline_frames, 0) end = int(end) @@ -521,13 +545,13 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None): # Construct TrialFluorescence and return it. trial_fluorescence = TrialFluorescence( - np.asarray(trials), - trial_num, - self.timestep_width, + np.asarray(trials), trial_num, self.timestep_width, ) trial_fluorescence.is_z_score = self.is_z_score trial_fluorescence.is_dff = self.is_dff - trial_fluorescence._baseline_duration = num_baseline_frames * self.timestep_width + trial_fluorescence._baseline_duration = ( + num_baseline_frames * self.timestep_width + ) # Check that trial_fluorescence was constructed correctly. assert trial_fluorescence.num_cells == self.num_cells @@ -566,6 +590,17 @@ def time_vec(self): time_vec_without_baseline = super().time_vec return time_vec_without_baseline - self._baseline_duration + def plot(self, ax=None, **pltargs): + if ax is None: + ax = plt.gca() + + ax.imshow(self.trial_mean().fluo[0, ...], **pltargs) + + return ax + + def apply_quality_control(self, inplace=False): + raise NotImplementedError + def _get_trials_from_mask(self, mask): trial_subset = self.copy(read_only=True) trial_subset._trial_num = trial_subset._trial_num[mask].copy() @@ -573,16 +608,62 @@ def _get_trials_from_mask(self, mask): return trial_subset - def plot(self, ax=None, **pltargs): - if ax is None: - ax = plt.gca() + def trial_mean(self, ignore_nan=False): + """Get the mean fluorescence for each cell across all trials. - ax.imshow(self.fluo.mean(axis=0), **pltargs) + Parameters + ---------- + ignore_nan : bool, default False + Whether to return the `mean` or `nanmean` for each cell. - return ax + Returns + ------- + trial_mean : TrialFluoresence + A new `TrialFluorescence` object with the mean across trials. - def apply_quality_control(self, inplace=False): - raise NotImplementedError + See Also + -------- + `trial_std()` + + """ + trial_mean = self.copy(read_only=True) + trial_mean._trial_num = np.asarray([np.nan]) + + if ignore_nan: + trial_mean.fluo = np.nanmean(self.fluo, axis=0)[np.newaxis, :, :] + else: + trial_mean.fluo = self.fluo.mean(axis=0)[np.newaxis, :, :] + + return trial_mean + + def trial_std(self, ignore_nan=False): + """Get the standard deviation of the fluorescence for each cell across trials. + + Parameters + ---------- + ignore_nan : bool, default False + Whether to return the `std` or `nanstd` for each cell. + + Returns + ------- + trial_std : TrialFluorescence + A new `TrialFluorescence` object with the standard deviation across + trials. + + See Also + -------- + `trial_mean()` + + """ + trial_std = self.copy(read_only=True) + trial_std._trial_num = np.asarray([np.nan]) + + if ignore_nan: + trial_std.fluo = np.nanstd(self.fluo, axis=0)[np.newaxis, :, :] + else: + trial_std.fluo = self.fluo.std(axis=0)[np.newaxis, :, :] + + return trial_std class EyeTracking(TimeseriesDataset): diff --git a/oscopetools/read_data/test_dataset_objects.py b/oscopetools/read_data/test_dataset_objects.py index 7b5e7be..7f507a9 100644 --- a/oscopetools/read_data/test_dataset_objects.py +++ b/oscopetools/read_data/test_dataset_objects.py @@ -96,4 +96,62 @@ def test_trial_subset_by_bool_mask(self): ) +class TestTrialFluorescenceSummaryStatistics(unittest.TestCase): + def setUp(self): + self.fluo_matrix = np.array([ + # Trial 0 + [[1, 2], # Cell 0 + [3, 4], # Cell 1 + [5, 6]], # Cell 2 + # Trial 1 + [[7, 8], # Cell 0 + [9, 10], # Cell 1 + [11, 12]] # Cell 2 + ]) + self.trial_fluorescence = do.TrialFluorescence( + self.fluo_matrix, [0, 1], 1. / 30. + ) + + def test_trial_mean(self): + expected = self.fluo_matrix.mean(axis=0)[np.newaxis, :, :] + actual = self.trial_fluorescence.trial_mean().fluo + npt.assert_allclose( + actual, expected, err_msg='Trial mean not correct to within tol.' + ) + + def test_trial_std(self): + expected = self.fluo_matrix.std(axis=0)[np.newaxis, :, :] + actual = self.trial_fluorescence.trial_std().fluo + npt.assert_allclose( + actual, expected, err_msg='Trial std not correct to within tol.' + ) + + def test_trial_num_isnan_after_mean(self): + tr_mean = self.trial_fluorescence.trial_mean() + self.assertEqual( + len(tr_mean.trial_vec), + 1, + 'Expected only 1 trial after taking mean.' + ) + self.assertTrue( + np.isnan(tr_mean.trial_vec[0]), + 'Expected trial_num to be NaN after taking mean across trials' + ) + + def test_trial_num_isnan_after_std(self): + tr_mean = self.trial_fluorescence.trial_std() + self.assertEqual( + len(tr_mean.trial_vec), + 1, + 'Expected only 1 trial after taking std.' + ) + self.assertTrue( + np.isnan(tr_mean.trial_vec[0]), + 'Expected trial_num to be NaN after taking std across trials' + ) + + + +if __name__ == '__main__': + unittest.main() From de9e0d6cf7738c69d766e4e88fc47bb7edc8f3a5 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 15:48:39 -0400 Subject: [PATCH 18/68] Add trial and cell iterators for TrialFluorescence --- oscopetools/read_data/dataset_objects.py | 40 +++++++++++++++++++ oscopetools/read_data/test_dataset_objects.py | 29 ++++++++++++++ 2 files changed, 69 insertions(+) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index dcf6516..c4a136f 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -313,6 +313,27 @@ def get_trials(self, *args): return self._get_trials_from_mask(mask) + def iter_trials(self): + """Get an iterator over all trials. + + Yields + ------ + (trial_num, trial_contents): (int, TrialDataset) + Yields a tuple containing the trial number and a `TrialDataset` + containing that trial for each trial in the original + `TrialDataset`. + + Example + ------- + >>> trials = TrialDataset() + >>> for trial_num, trial in trials.iter_trials(): + >>> print(trial_num) + >>> trial.plot() + + """ + for trial_num in self.trial_vec: + yield (trial_num, self.get_trials(trial_num)) + @abstractmethod def _get_trials_from_mask(self, mask): """Get a subset of trials using a boolean mask. @@ -408,6 +429,25 @@ def get_cells(self, *args): return self._get_cells_from_mask(mask) + def iter_cells(self): + """Get an iterator over all cells in the fluorescence dataset. + + Yields + ------ + (cell_num, cell_fluorescence) : (int, Fluorescence) + Yields a tuple of the cell number and fluorescence for each cell. + + Example + ------- + >>> fluo_dset = Fluorescence() + >>> for cell_num, cell_fluorescence in fluo_dset.iter_cells(): + >>> print('Cell number {}'.format(cell_num)) + >>> cell_fluorescence.plot() + + """ + for cell_num in self.cell_vec: + yield (cell_num, self.get_cells(cell_num)) + def get_frame_range(self, start, stop=None): """Get a time window by frame number.""" fluo_copy = self.copy(read_only=True) diff --git a/oscopetools/read_data/test_dataset_objects.py b/oscopetools/read_data/test_dataset_objects.py index 7f507a9..be0b6be 100644 --- a/oscopetools/read_data/test_dataset_objects.py +++ b/oscopetools/read_data/test_dataset_objects.py @@ -151,6 +151,35 @@ def test_trial_num_isnan_after_std(self): ) +class TestTrialFluorescenceIterators(unittest.TestCase): + def setUp(self): + self.fluo_matrix = np.array([ + # Trial 0 + [[1, 2], # Cell 0 + [3, 4], # Cell 1 + [5, 6]], # Cell 2 + # Trial 1 + [[7, 8], # Cell 0 + [9, 10], # Cell 1 + [11, 12]] # Cell 2 + ]) + self.trial_fluorescence = do.TrialFluorescence( + self.fluo_matrix, [0, 1], 1. / 30. + ) + + def test_trial_iterator(self): + for trial_num, trial_data in self.trial_fluorescence.iter_trials(): + npt.assert_array_equal( + trial_data.fluo, + self.fluo_matrix[trial_num, ...][np.newaxis, :, :] + ) + + def test_cell_iterator(self): + for cell_num, cell_data in self.trial_fluorescence.iter_cells(): + npt.assert_array_equal( + cell_data.fluo, + self.fluo_matrix[:, cell_num, :][:, np.newaxis, :] + ) if __name__ == '__main__': From e10ca0ca24039a468f39b0325f5cf6bd27b46ced Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 16:05:46 -0400 Subject: [PATCH 19/68] TrialFluorescence.plot() produces lineplot if only one cell --- oscopetools/read_data/dataset_objects.py | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index c4a136f..718f400 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -634,7 +634,26 @@ def plot(self, ax=None, **pltargs): if ax is None: ax = plt.gca() - ax.imshow(self.trial_mean().fluo[0, ...], **pltargs) + if self.num_cells == 1: + # If there is only one cell, make a line plot + alpha = pltargs.pop('alpha', 1) + + fluo_mean = self.trial_mean().fluo[0, 0, :] + fluo_std = self.trial_std().fluo[0, 0, :] + ax.fill_between( + self.time_vec, + fluo_mean - fluo_std, + fluo_mean + fluo_std, + label='Mean $\pm$ SD', + alpha=alpha * 0.6, + **pltargs + ) + ax.plot(self.time_vec, fluo_mean, alpha=alpha, **pltargs) + ax.set_xlabel('Time (s)') + ax.legend() + else: + # If there are many cells, just show the mean as a matrix. + ax.imshow(self.trial_mean().fluo[0, ...], **pltargs) return ax From 12c82c25a1d22248f27a2c6d9634a395131bf3de Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 16:23:40 -0400 Subject: [PATCH 20/68] Change behaviour of Orientation(None) This patch allows Orientation to be initialized with None/np.nan, but iterating over Orientation no longer produces Orientation(None). --- oscopetools/read_data/conditions.py | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index a80ab3b..d0d53a5 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -25,11 +25,16 @@ class SetMembershipError(Exception): class _NamedOrderedSet(metaclass=_IterableNamedOrderedSet): _MEMBERS = () + _NULL_ALLOWED = ( + False # Whether None or NaN can be used to initialize the class. + ) def __init__(self, member_value): if member_value in self._MEMBERS: self._member_value = member_value - elif np.isnan(member_value) and (None in self._MEMBERS): + elif self._NULL_ALLOWED and ( + (member_value is None) or np.isnan(member_value) + ): self._member_value = None else: raise SetMembershipError( @@ -62,7 +67,8 @@ def __hash__(self): class Orientation(_NamedOrderedSet): """Orientation of part of a CenterSurroundStimulus.""" - _MEMBERS = (None, 0, 45, 90, 135, 180, 225, 270, 315) + _MEMBERS = (0, 45, 90, 135, 180, 225, 270, 315) + _NULL_ALLOWED = True def __init__(self, orientation): if issubclass(type(orientation), Orientation): @@ -72,20 +78,15 @@ def __init__(self, orientation): super().__init__(member_value) - @property - def orientation(self): - """Orientation in degrees.""" - return self._member_value - def __lt__(self, other): other_as_ori = Orientation(other) if (self._member_value is not None) and ( - other_as_ori.orientation is not None + other_as_ori._member_value is not None ): - result = self._member_value < other_as_ori.orientation + result = self._member_value < other_as_ori._member_value elif (self._member_value is None) and ( - other_as_ori.orientation is not None + other_as_ori._member_value is not None ): result = True else: @@ -95,7 +96,7 @@ def __lt__(self, other): def __eq__(self, other): other_as_ori = Orientation(other) - return other_as_ori.orientation == self._member_value + return other_as_ori._member_value == self._member_value def __repr__(self): return 'Orientation({})'.format(self._member_value) From 25d41adc276943c6d514fdead54ac190d7768dc0 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 16:51:07 -0400 Subject: [PATCH 21/68] Implement Orientation arithmetic - Allow orientations to be added to or subtracted from eachother or numeric types. The result is guaranteed to be a valid Orientation. --- oscopetools/read_data/conditions.py | 51 +++++++++++++++++++++++ oscopetools/read_data/test_conditions.py | 53 ++++++++++++++++++++++++ 2 files changed, 104 insertions(+) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index d0d53a5..7b78ba5 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -101,6 +101,57 @@ def __eq__(self, other): def __repr__(self): return 'Orientation({})'.format(self._member_value) + def __add__(self, other): + other_as_ori = Orientation(other) + + if (self._member_value is None) or ( + other_as_ori._member_value is None + ): + new_orientation = Orientation(None) + else: + new_angle = ( + self._member_value + other_as_ori._member_value + ) % 360.0 + new_orientation = Orientation(new_angle) + + return new_orientation + + __radd__ = __add__ + + def __sub__(self, other): + other_as_ori = Orientation(other) + + if (self._member_value is None) or ( + other_as_ori._member_value is None + ): + new_orientation = Orientation(None) + else: + new_angle = ( + self._member_value - other_as_ori._member_value + ) % 360.0 + new_orientation = Orientation(new_angle) + + return new_orientation + + def __rsub__(self, lhs): + lhs_as_ori = Orientation(lhs) + + if (self._member_value is None) or (lhs_as_ori._member_value is None): + new_orientation = Orientation(None) + else: + new_angle = (lhs_as_ori._member_value - self._member_value) % 360.0 + new_orientation = Orientation(new_angle) + + return new_orientation + + def orthogonal(self): + """Return a tuple of orthogonal Orientations.""" + return (self + 90.0, self - 90.0) + + def opposite(self): + """Return the Orientation opposite to the current one.""" + return self + 180.0 + class Contrast(_NamedOrderedSet): """Contrast of a CenterSurroundStimulus.""" diff --git a/oscopetools/read_data/test_conditions.py b/oscopetools/read_data/test_conditions.py index 5457736..ada86a4 100644 --- a/oscopetools/read_data/test_conditions.py +++ b/oscopetools/read_data/test_conditions.py @@ -48,6 +48,55 @@ def test_eq_nan_none(self): self.assertEqual(cond.Orientation(np.nan), cond.Orientation(None)) +class OrientationArithmetic(unittest.TestCase): + def test_lhs_add(self): + expected = cond.Orientation(180.0) + actual = cond.Orientation(90.0) + 90.0 + self.assertEqual(expected, actual, "90 + 90 != 180") + + expected = cond.Orientation(45) + actual = cond.Orientation(90) + 315.0 + self.assertEqual(expected, actual, "90 + 315 != 45") + + def test_lhs_subtract(self): + expected = cond.Orientation(90.0) + actual = cond.Orientation(180.0) - 90.0 + self.assertEqual(expected, actual, "180 - 90 != 90") + + expected = cond.Orientation(315) + actual = cond.Orientation(45) - 90.0 + self.assertEqual(expected, actual, "45 - 90 != 315") + + def test_none_propagation(self): + expected = cond.Orientation(None) + + # Try various combinations that should all produce Orientation(None) + actual = cond.Orientation(90) + None + self.assertEqual(expected, actual) + + actual = cond.Orientation(90) + np.nan + self.assertEqual(expected, actual) + + actual = cond.Orientation(None) + np.nan + self.assertEqual(expected, actual) + + actual = cond.Orientation(None) + 90 + self.assertEqual(expected, actual) + + actual = cond.Orientation(np.nan) + 90 + self.assertEqual(expected, actual) + + def test_rhs_add(self): + expected = cond.Orientation(180) + actual = 90.0 + cond.Orientation(90) + self.assertEqual(expected, actual) + + def test_rhs_sub(self): + expected = cond.Orientation(90) + actual = 180 - cond.Orientation(90) + self.assertEqual(expected, actual) + + class OrientationIteration(unittest.TestCase): def test_iteration(self): """Iteration yield all allowed values + None""" @@ -103,3 +152,7 @@ def test_neq_some_none(self): # Not equal if center orientation differs css2 = cond.CenterSurroundStimulus(2.0, 0.04, 0.8, None, 90) self.assertNotEqual(css1, css2) + + +if __name__ == '__main__': + unittest.main() From 045b40826ba9b459db339bf977d977774b12a6cc Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 15:55:41 -0500 Subject: [PATCH 22/68] Implement len for _NamedOrderedSet --- oscopetools/read_data/conditions.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index 7b78ba5..e93cc4a 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -18,6 +18,9 @@ def __iter__(cls): for member in cls._MEMBERS: yield cls(member) + def __len__(cls): + return len(cls._MEMBERS) + class SetMembershipError(Exception): pass From 37a9303662daf91ba5356dd85c7925312a659e57 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 16:55:36 -0500 Subject: [PATCH 23/68] Add Orientation.radians property --- oscopetools/read_data/conditions.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index e93cc4a..874392c 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -155,6 +155,15 @@ def opposite(self): """Return the Orientation opposite to the current one.""" return self + 180.0 + @property + def radians(self): + """Get the equivalent Orientation in radians.""" + if self._member_value is None: + result = np.nan + else: + result = self._member_value / 360. * (2. * np.pi) + return result + class Contrast(_NamedOrderedSet): """Contrast of a CenterSurroundStimulus.""" From 57075ca009ffa7820046dbb64a914604605e20ef Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 16:55:54 -0500 Subject: [PATCH 24/68] Remove guard against getting negative time window Remove a guard against trying to get a negative time window in TimeseriesDataset. In some cases, t=0 might be the start of a trial, so t<0 might represent a valid baseline period. --- oscopetools/read_data/dataset_objects.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 718f400..f328337 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -249,11 +249,6 @@ def get_frame_range(self, start, stop=None): def _get_nearest_frame(self, time_): """Round a timestamp to the nearest integer frame number.""" - if time_ <= 0.0: - raise ValueError( - 'Expected `time_` to be >= 0, got {}'.format(time_) - ) - frame_num = int(np.round(time_ / self.timestep_width)) assert frame_num <= len(self) From 26f47430a8f37ac3ae174e163dc69a326fbbc52a Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 8 Jul 2020 19:53:27 -0400 Subject: [PATCH 25/68] Add script for diagnostic plots of orientation tuning --- analysis/orientation_plots.py | 211 +++++++++++++++++++++++ oscopetools/read_data/conditions.py | 3 + oscopetools/read_data/dataset_objects.py | 2 +- 3 files changed, 215 insertions(+), 1 deletion(-) create mode 100644 analysis/orientation_plots.py diff --git a/analysis/orientation_plots.py b/analysis/orientation_plots.py new file mode 100644 index 0000000..c14041d --- /dev/null +++ b/analysis/orientation_plots.py @@ -0,0 +1,211 @@ +import os +import argparse + +from tqdm import tqdm +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.gridspec as gs + +from oscopetools import read_data as rd + +parser = argparse.ArgumentParser() +parser.add_argument( + 'DATA_PATH', help='Path to folder with center-surround data files.' +) +parser.add_argument( + '-o', '--output', help='Path to folder in which to place diagnostic plots.' +) + +args = parser.parse_args() + + +def _complete_circle(ls): + """Close a circular list. Use to join 0 deg and 360 deg in polar plots.""" + ls.append(ls[0]) + + +# Define placement of plots +## Define gridspec layout +row_spec = gs.GridSpec( + 2, + 1, + left=0.1, + top=0.9, + bottom=0.1, + right=0.95, + hspace=0.35, + height_ratios=[0.7, 0.3], +) +top_spec = gs.GridSpecFromSubplotSpec( + 1, 3, row_spec[0, :], width_ratios=[0.65, 0.2, 0.15], wspace=0.3 +) +mean_spec = gs.GridSpecFromSubplotSpec( + 2, 4, top_spec[:, 0], wspace=0.45, hspace=0.5 +) +max_resp_spec = gs.GridSpecFromSubplotSpec(1, 3, row_spec[1, :], wspace=0.3) + +## Get lists to use for placing plots. +## Gridspecs can be safely ignored from here on. +mean_slots = [mean_spec[i // 4, i % 4] for i in range(8)] +polar_slot = top_spec[:, 1] +waterfall_slot = top_spec[:, 2] +max_resp_slots = [max_resp_spec[0, i] for i in range(3)] + +del row_spec, top_spec, mean_spec, max_resp_spec + +# Make a set of plots for each file. + +STIM_TIME_WINDOW = (0, 2) + +# ITERATE OVER FILES +for dfile in os.listdir(args.DATA_PATH): + if not dfile.endswith('.h5'): + continue + + stim_table = rd.get_stimulus_table( + os.path.join(args.DATA_PATH, dfile), 'center_surround', + ) + dff_fluo = rd.get_dff_traces(os.path.join(args.DATA_PATH, dfile)) + dff_fluo.z_score() # Convert to Z-score + trial_fluo = dff_fluo.cut_by_trials(stim_table, num_baseline_frames=30) + + # ITERATE OVER ALL CELLS IN A FILE + for cell_num, cell_fluo in tqdm(trial_fluo.iter_cells()): + + plt.figure(figsize=(9, 7)) + plt.suptitle('{} cell {}'.format(dfile.strip('.h5'), cell_num)) + + # Create a set of axes for plotting the mean response of each cell + mean_axes = [plt.subplot(mean_slots[0])] + mean_axes.extend( + [plt.subplot(spec, sharey=mean_axes[0]) for spec in mean_slots[1:]] + ) + + # Plot the mean response for each surround condition, + # and collect the max response for each condition at the same time. + # (Use this later to plot the preferred orientation of each cell.) + orientations = [] + max_responses = { + 'no_surround': [], + 'ortho_surround': [], + 'iso_surround': [], + } + for i, ori in enumerate(rd.Orientation): + mean_axes[i].set_title(str(int(ori))) + orientations.append(ori) + + ## Plot NO-SURROUND trials + no_surround = stim_table['center_surround'].apply( + lambda x: (x.center_orientation == ori) + and x.surround_is_empty() + ) + no_surround_trials = cell_fluo.get_trials(no_surround) + no_surround_trials.plot(ax=mean_axes[i], alpha=0.7) + max_responses['no_surround'].append( + no_surround_trials.get_time_range(*STIM_TIME_WINDOW) + .trial_mean() + .fluo.max() + ) + + ## Plot ORTHOGONAL surround trials + ortho_surround = stim_table['center_surround'].apply( + lambda x: (x.center_orientation == ori) + and (x.surround_orientation in ori.orthogonal()) + ) + ortho_surround_trials = cell_fluo.get_trials(ortho_surround) + ortho_surround_trials.plot(ax=mean_axes[i], alpha=0.7) + max_responses['ortho_surround'].append( + ortho_surround_trials.get_time_range(*STIM_TIME_WINDOW) + .trial_mean() + .fluo.max() + ) + + ## Plot ISO surround trials + iso_surround = stim_table['center_surround'].apply( + lambda x: (x.center_orientation == ori) + and (x.surround_orientation == x.center_orientation) + ) + iso_surround_trials = cell_fluo.get_trials(iso_surround) + iso_surround_trials.plot(ax=mean_axes[i], alpha=0.7) + max_responses['iso_surround'].append( + iso_surround_trials.get_time_range(*STIM_TIME_WINDOW) + .trial_mean() + .fluo.max() + ) + + mean_axes[i].legend().remove() + if i < 4: + mean_axes[i].set_xlabel('') + if (i % 4) == 0: + mean_axes[i].set_ylabel('Z-score') + + # Polar plot of angular tuning + ## Link 0 deg and 360 deg inplace with `_complete_circle` + _complete_circle(orientations) + orientations_in_rad = [ori.radians for ori in orientations] + {_complete_circle(val) for val in max_responses.values()} + + polar_ax = plt.subplot(polar_slot, polar=True) + polar_ax.set_title( + 'Max resp. in {} window'.format(STIM_TIME_WINDOW), + pad=25 + ) + for surround_condition in max_responses: + polar_ax.fill_between( + orientations_in_rad, + np.zeros_like(orientations_in_rad), + np.clip(max_responses[surround_condition], 0, np.inf), + alpha=0.5, + ) + polar_ax.plot( + orientations_in_rad, + np.clip(max_responses[surround_condition], 0, np.inf), + label=surround_condition, + ) + polar_ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.2)) + + # Plot all trials in chronological order + water_ax = plt.subplot(waterfall_slot) + water_ax.set_title('All trials') + water_ax.imshow(cell_fluo.fluo[:, 0, :], aspect='auto') + water_ax.set_yticks([]) + water_ax.set_xticks([]) + + # Plot trial-resolved response for preferred orientation + preferred_orientation = orientations[ + np.argmax(max_responses['iso_surround']) + ] + surround_orientations = { + 'no surr': [rd.Orientation(None)], + 'ortho surr': preferred_orientation.orthogonal(), + 'iso surr': [preferred_orientation], + } + + for (surr_condition, surr_orientations_), plot_slot in zip( + surround_orientations.items(), max_resp_slots + ): + trial_resolved_ax = plt.subplot(plot_slot) + trial_resolved_ax.set_title( + 'Center {} + {}'.format(int(preferred_orientation), surr_condition) + ) + + trial_mask = stim_table['center_surround'].apply( + lambda x: (x.center_orientation == preferred_orientation) + and (x.surround_orientation in surr_orientations_) + ) + trial_resolved_ax.plot( + cell_fluo.time_vec, + cell_fluo.get_trials(trial_mask).fluo[:, 0, :].T, + 'k-', + alpha=0.5, + ) + trial_resolved_ax.set_xlabel('Time (s)') + trial_resolved_ax.set_ylabel('Z-score') + + plt.savefig( + os.path.join( + args.output, '{}_{}.png'.format(dfile.strip('.h5'), cell_num) + ), + dpi=600, + ) + plt.close() diff --git a/oscopetools/read_data/conditions.py b/oscopetools/read_data/conditions.py index 874392c..805fec1 100644 --- a/oscopetools/read_data/conditions.py +++ b/oscopetools/read_data/conditions.py @@ -81,6 +81,9 @@ def __init__(self, orientation): super().__init__(member_value) + def __int__(self): + return int(self._member_value) + def __lt__(self, other): other_as_ori = Orientation(other) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index f328337..2a59d7f 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -249,7 +249,7 @@ def get_frame_range(self, start, stop=None): def _get_nearest_frame(self, time_): """Round a timestamp to the nearest integer frame number.""" - frame_num = int(np.round(time_ / self.timestep_width)) + frame_num = np.argmin(np.abs(self.time_vec - time_)) assert frame_num <= len(self) return min(frame_num, len(self) - 1) From 842b5dfde8edef0063b2d366c2841d13677e4941 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 16:13:29 -0400 Subject: [PATCH 26/68] Add `data` attribute to `Dataset`s - Include a `data` attribute in implemented `Datasets` to provide access to underlying data. - Replaces the `fluo` attribute on `Fluorescence` classes and the `_dframe` attribute on `Eyetracking` --- analysis/orientation_plots.py | 10 +-- oscopetools/read_data/dataset_objects.py | 68 +++++++++---------- oscopetools/read_data/test_dataset_objects.py | 20 +++--- 3 files changed, 49 insertions(+), 49 deletions(-) diff --git a/analysis/orientation_plots.py b/analysis/orientation_plots.py index c14041d..0d39802 100644 --- a/analysis/orientation_plots.py +++ b/analysis/orientation_plots.py @@ -104,7 +104,7 @@ def _complete_circle(ls): max_responses['no_surround'].append( no_surround_trials.get_time_range(*STIM_TIME_WINDOW) .trial_mean() - .fluo.max() + .data.max() ) ## Plot ORTHOGONAL surround trials @@ -117,7 +117,7 @@ def _complete_circle(ls): max_responses['ortho_surround'].append( ortho_surround_trials.get_time_range(*STIM_TIME_WINDOW) .trial_mean() - .fluo.max() + .data.max() ) ## Plot ISO surround trials @@ -130,7 +130,7 @@ def _complete_circle(ls): max_responses['iso_surround'].append( iso_surround_trials.get_time_range(*STIM_TIME_WINDOW) .trial_mean() - .fluo.max() + .data.max() ) mean_axes[i].legend().remove() @@ -167,7 +167,7 @@ def _complete_circle(ls): # Plot all trials in chronological order water_ax = plt.subplot(waterfall_slot) water_ax.set_title('All trials') - water_ax.imshow(cell_fluo.fluo[:, 0, :], aspect='auto') + water_ax.imshow(cell_fluo.data[:, 0, :], aspect='auto') water_ax.set_yticks([]) water_ax.set_xticks([]) @@ -195,7 +195,7 @@ def _complete_circle(ls): ) trial_resolved_ax.plot( cell_fluo.time_vec, - cell_fluo.get_trials(trial_mask).fluo[:, 0, :].T, + cell_fluo.get_trials(trial_mask).data[:, 0, :].T, 'k-', alpha=0.5, ) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 2a59d7f..3f6f97a 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -388,7 +388,7 @@ class Fluorescence(TimeseriesDataset): def __init__(self, fluorescence_array, timestep_width): super().__init__(timestep_width) - self.fluo = np.asarray(fluorescence_array) + self.data = np.asarray(fluorescence_array) self.cell_vec = np.arange(0, self.num_cells) self.is_z_score = False self.is_dff = False @@ -396,12 +396,12 @@ def __init__(self, fluorescence_array, timestep_width): @property def num_timesteps(self): """Number of timesteps.""" - return self.fluo.shape[-1] + return self.data.shape[-1] @property def num_cells(self): """Number of ROIs.""" - return self.fluo.shape[-2] + return self.data.shape[-2] def get_cells(self, *args): # Implementation note: @@ -448,11 +448,11 @@ def get_frame_range(self, start, stop=None): fluo_copy = self.copy(read_only=True) if stop is None: - time_slice = self.fluo[..., start][..., np.newaxis] + time_slice = self.data[..., start][..., np.newaxis] else: - time_slice = self.fluo[..., start:stop] + time_slice = self.data[..., start:stop] - fluo_copy.fluo = time_slice.copy() + fluo_copy.data = time_slice.copy() return fluo_copy def copy(self, read_only=False): @@ -469,10 +469,10 @@ def copy(self, read_only=False): if read_only: # Get a read-only view of the fluo array # This is much faster than creating a full copy - read_only_fluo = self.fluo.view() + read_only_fluo = self.data.view() read_only_fluo.flags.writeable = False - deepcopy_memo = {id(self.fluo): read_only_fluo} + deepcopy_memo = {id(self.data): read_only_fluo} copy_ = deepcopy(self, deepcopy_memo) else: copy_ = deepcopy(self) @@ -482,9 +482,9 @@ def copy(self, read_only=False): def _get_cells_from_mask(self, mask): cell_subset = self.copy(read_only=False) cell_subset.cell_vec = self.cell_vec[mask].copy() - cell_subset.fluo = self.fluo[..., mask, :].copy() + cell_subset.data = self.data[..., mask, :].copy() - assert cell_subset.fluo.ndim == self.fluo.ndim + assert cell_subset.data.ndim == self.data.ndim assert cell_subset.num_cells == np.sum(mask) return cell_subset @@ -508,9 +508,9 @@ def z_score(self): if self.is_z_score: raise ValueError('Instance is already a Z-score') else: - z_score = self.fluo - self.fluo.mean(axis=1)[:, np.newaxis] + z_score = self.data - self.data.mean(axis=1)[:, np.newaxis] z_score /= z_score.std(axis=1)[:, np.newaxis] - self.fluo = z_score + self.data = z_score self.is_z_score = True def cut_by_trials(self, trial_timetable, num_baseline_frames=None): @@ -550,7 +550,7 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None): start = max(int(start) - num_baseline_frames, 0) end = int(end) - trials.append(self.fluo[..., start:end]) + trials.append(self.data[..., start:end]) num_frames.append(end - start) # Truncate all trials to the same length if necessary @@ -599,7 +599,7 @@ def plot(self, ax=None, **pltargs): if ax is not None: ax = plt.gca() - ax.imshow(self.fluo, **pltargs) + ax.imshow(self.data, **pltargs) return ax @@ -633,8 +633,8 @@ def plot(self, ax=None, **pltargs): # If there is only one cell, make a line plot alpha = pltargs.pop('alpha', 1) - fluo_mean = self.trial_mean().fluo[0, 0, :] - fluo_std = self.trial_std().fluo[0, 0, :] + fluo_mean = self.trial_mean().data[0, 0, :] + fluo_std = self.trial_std().data[0, 0, :] ax.fill_between( self.time_vec, fluo_mean - fluo_std, @@ -648,7 +648,7 @@ def plot(self, ax=None, **pltargs): ax.legend() else: # If there are many cells, just show the mean as a matrix. - ax.imshow(self.trial_mean().fluo[0, ...], **pltargs) + ax.imshow(self.trial_mean().data[0, ...], **pltargs) return ax @@ -658,7 +658,7 @@ def apply_quality_control(self, inplace=False): def _get_trials_from_mask(self, mask): trial_subset = self.copy(read_only=True) trial_subset._trial_num = trial_subset._trial_num[mask].copy() - trial_subset.fluo = trial_subset.fluo[mask, ...].copy() + trial_subset.data = trial_subset.data[mask, ...].copy() return trial_subset @@ -684,9 +684,9 @@ def trial_mean(self, ignore_nan=False): trial_mean._trial_num = np.asarray([np.nan]) if ignore_nan: - trial_mean.fluo = np.nanmean(self.fluo, axis=0)[np.newaxis, :, :] + trial_mean.data = np.nanmean(self.data, axis=0)[np.newaxis, :, :] else: - trial_mean.fluo = self.fluo.mean(axis=0)[np.newaxis, :, :] + trial_mean.data = self.data.mean(axis=0)[np.newaxis, :, :] return trial_mean @@ -713,9 +713,9 @@ def trial_std(self, ignore_nan=False): trial_std._trial_num = np.asarray([np.nan]) if ignore_nan: - trial_std.fluo = np.nanstd(self.fluo, axis=0)[np.newaxis, :, :] + trial_std.data = np.nanstd(self.data, axis=0)[np.newaxis, :, :] else: - trial_std.fluo = self.fluo.std(axis=0)[np.newaxis, :, :] + trial_std.data = self.data.std(axis=0)[np.newaxis, :, :] return trial_std @@ -728,19 +728,19 @@ def __init__( self, tracked_attributes: pd.DataFrame, timestep_width: float ): super().__init__(timestep_width) - self._dframe = pd.DataFrame(tracked_attributes) + self.data = pd.DataFrame(tracked_attributes) @property def num_timesteps(self): """Number of timesteps in EyeTracking dataset.""" - return self._dframe.shape[0] + return self.data.shape[0] def get_frame_range(self, start: int, stop: int = None): window = self.copy() if stop is not None: - window._dframe = window._dframe.iloc[start:stop, :].copy() + window.data = window.data.iloc[start:stop, :].copy() else: - window._dframe = window._dframe.iloc[start, :].copy() + window.data = window.data.iloc[start, :].copy() return window @@ -749,20 +749,20 @@ def plot(self, channel='position', ax=None, **pltargs): ax = super().plot(ax, **pltargs) # Check whether the `channel` argument is valid - if channel not in self._dframe.columns and channel != 'position': + if channel not in self.data.columns and channel != 'position': raise ValueError( 'Got unrecognized channel `{}`, expected one of ' '{} or `position`'.format( - channel, self._dframe.columns.tolist() + channel, self.data.columns.tolist() ) ) - if channel in self._dframe.columns: - ax.plot(self.time_vec, self._dframe[channel], **pltargs) + if channel in self.data.columns: + ax.plot(self.time_vec, self.data[channel], **pltargs) elif channel == 'position': if pltargs.pop('style', None) in ['contour', 'density']: - x = self._dframe[self._x_pos_name] - y = self._dframe[self._y_pos_name] + x = self.data[self._x_pos_name] + y = self.data[self._y_pos_name] mask = np.isnan(x) | np.isnan(y) if any(mask): warnings.warn( @@ -772,8 +772,8 @@ def plot(self, channel='position', ax=None, **pltargs): sns.kdeplot(x[~mask], y[~mask], ax=ax, **pltargs) else: ax.plot( - self._dframe[self._x_pos_name], - self._dframe[self._y_pos_name], + self.data[self._x_pos_name], + self.data[self._y_pos_name], **pltargs ) else: diff --git a/oscopetools/read_data/test_dataset_objects.py b/oscopetools/read_data/test_dataset_objects.py index be0b6be..1883e4e 100644 --- a/oscopetools/read_data/test_dataset_objects.py +++ b/oscopetools/read_data/test_dataset_objects.py @@ -25,7 +25,7 @@ def test_cell_subset_by_single_int(self): # Test whether fluorescence is extracted correctly cell_to_extract = 0 expected_fluo = self.fluo_matrix[:, cell_to_extract, :][:, np.newaxis, :] - actual_fluo = self.trial_fluorescence.get_cells(cell_to_extract).fluo + actual_fluo = self.trial_fluorescence.get_cells(cell_to_extract).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether cell labels are subsetted correctly @@ -37,7 +37,7 @@ def test_cell_subset_by_single_int(self): def test_cell_subset_by_pair_of_ints(self): # Test whether fluorescence is extracted correctly expected_fluo = self.fluo_matrix[:, 0:2, :] - actual_fluo = self.trial_fluorescence.get_cells(0, 2).fluo + actual_fluo = self.trial_fluorescence.get_cells(0, 2).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether cell labels are subsetted correctly @@ -49,7 +49,7 @@ def test_cell_subset_by_pair_of_ints(self): def test_cell_subset_by_tuple_of_ints(self): # Test whether fluorescence is extracted correctly expected_fluo = self.fluo_matrix[:, 0:2, :] - actual_fluo = self.trial_fluorescence.get_cells((0, 2)).fluo + actual_fluo = self.trial_fluorescence.get_cells((0, 2)).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether cell labels are subsetted correctly @@ -61,7 +61,7 @@ def test_cell_subset_by_tuple_of_ints(self): def test_cell_subset_by_bool_mask(self): mask = [True, False, True] expected_fluo = self.fluo_matrix[:, mask, :] - actual_fluo = self.trial_fluorescence.get_cells(mask).fluo + actual_fluo = self.trial_fluorescence.get_cells(mask).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether cell labels are subsetted correctly @@ -74,7 +74,7 @@ def test_trial_subset_by_single_int(self): # Test whether fluorescence is extracted correctly trial_to_extract = 0 expected_fluo = self.fluo_matrix[trial_to_extract, :, :][np.newaxis, :, :] - actual_fluo = self.trial_fluorescence.get_trials(trial_to_extract).fluo + actual_fluo = self.trial_fluorescence.get_trials(trial_to_extract).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether cell labels are subsetted correctly @@ -86,7 +86,7 @@ def test_trial_subset_by_single_int(self): def test_trial_subset_by_bool_mask(self): mask = [False, True] expected_fluo = self.fluo_matrix[mask, :, :] - actual_fluo = self.trial_fluorescence.get_trials(mask).fluo + actual_fluo = self.trial_fluorescence.get_trials(mask).data npt.assert_array_equal(expected_fluo, actual_fluo) # Test whether trial labels are subsetted correctly @@ -114,14 +114,14 @@ def setUp(self): def test_trial_mean(self): expected = self.fluo_matrix.mean(axis=0)[np.newaxis, :, :] - actual = self.trial_fluorescence.trial_mean().fluo + actual = self.trial_fluorescence.trial_mean().data npt.assert_allclose( actual, expected, err_msg='Trial mean not correct to within tol.' ) def test_trial_std(self): expected = self.fluo_matrix.std(axis=0)[np.newaxis, :, :] - actual = self.trial_fluorescence.trial_std().fluo + actual = self.trial_fluorescence.trial_std().data npt.assert_allclose( actual, expected, err_msg='Trial std not correct to within tol.' ) @@ -170,14 +170,14 @@ def setUp(self): def test_trial_iterator(self): for trial_num, trial_data in self.trial_fluorescence.iter_trials(): npt.assert_array_equal( - trial_data.fluo, + trial_data.data, self.fluo_matrix[trial_num, ...][np.newaxis, :, :] ) def test_cell_iterator(self): for cell_num, cell_data in self.trial_fluorescence.iter_cells(): npt.assert_array_equal( - cell_data.fluo, + cell_data.data, self.fluo_matrix[:, cell_num, :][:, np.newaxis, :] ) From 2c0f1b183b872e3e1e4f9e67abc951c4a3a6fb34 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 16:23:10 -0400 Subject: [PATCH 27/68] Switch to np.squeeze() for data matrices Getting a single cell or a single trial from a `Fluorescence` or `TrialDataset` yields an array with one or more dimensions of size one. For example, >>> fluorescence.get_cells(0).data.shape [10, 1, 462] The resulting array can usually be expressed as a matrix, which is convenient for passing to matplotlib plotting functions. Before this patch, this was done by manual slicing to remove dimensions of length one. >>> plt.plot(fluorescence.get_cells(0).data[:, 0, :].T) This patch switches to using `np.squeeze()`, which produces the same result without having to remember the order of the dimensions (except that time is last). >>> plt.plot(fluorescence.get_cells(0).data.squeeze().T) --- analysis/orientation_plots.py | 4 ++-- oscopetools/read_data/test_dataset_objects.py | 9 +++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/analysis/orientation_plots.py b/analysis/orientation_plots.py index 0d39802..0f3e6ae 100644 --- a/analysis/orientation_plots.py +++ b/analysis/orientation_plots.py @@ -167,7 +167,7 @@ def _complete_circle(ls): # Plot all trials in chronological order water_ax = plt.subplot(waterfall_slot) water_ax.set_title('All trials') - water_ax.imshow(cell_fluo.data[:, 0, :], aspect='auto') + water_ax.imshow(cell_fluo.data.squeeze(), aspect='auto') water_ax.set_yticks([]) water_ax.set_xticks([]) @@ -195,7 +195,7 @@ def _complete_circle(ls): ) trial_resolved_ax.plot( cell_fluo.time_vec, - cell_fluo.get_trials(trial_mask).data[:, 0, :].T, + cell_fluo.get_trials(trial_mask).data.squeeze().T, 'k-', alpha=0.5, ) diff --git a/oscopetools/read_data/test_dataset_objects.py b/oscopetools/read_data/test_dataset_objects.py index 1883e4e..7653df5 100644 --- a/oscopetools/read_data/test_dataset_objects.py +++ b/oscopetools/read_data/test_dataset_objects.py @@ -34,6 +34,15 @@ def test_cell_subset_by_single_int(self): self.trial_fluorescence.get_cells(cell_to_extract).cell_vec ) + def test_squeezed_cell_subset_by_single_int(self): + # Test whether fluorescence is extracted correctly + cell_to_extract = 0 + expected_fluo = self.fluo_matrix[:, cell_to_extract, :] + actual_fluo = self.trial_fluorescence.get_cells( + cell_to_extract + ).data.squeeze() + npt.assert_array_equal(expected_fluo, actual_fluo) + def test_cell_subset_by_pair_of_ints(self): # Test whether fluorescence is extracted correctly expected_fluo = self.fluo_matrix[:, 0:2, :] From 81d18feb6fc943a71df234a19b4d942a515f5c23 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 16:42:34 -0400 Subject: [PATCH 28/68] Add xlabel to Eyetracking plot --- oscopetools/read_data/dataset_objects.py | 1 + 1 file changed, 1 insertion(+) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 3f6f97a..74021bd 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -759,6 +759,7 @@ def plot(self, channel='position', ax=None, **pltargs): if channel in self.data.columns: ax.plot(self.time_vec, self.data[channel], **pltargs) + ax.set_xlabel('Time (s)') elif channel == 'position': if pltargs.pop('style', None) in ['contour', 'density']: x = self.data[self._x_pos_name] From f4182ca091f1bc8472d8383bfcabe5e0c1518dfb Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 16:43:01 -0400 Subject: [PATCH 29/68] Implement RunningSpeed Dataset --- oscopetools/read_data/dataset_objects.py | 37 +++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 74021bd..5ae4f71 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -790,4 +790,39 @@ def apply_quality_control(self, inplace=False): class RunningSpeed(TimeseriesDataset): - pass + def __init__( + self, running_speed: np.ndarray, timestep_width: float + ): + running_speed = np.asarray(running_speed) + assert running_speed.ndim == 1 + + super().__init__(timestep_width) + self.data = running_speed + + @property + def num_timesteps(self): + """Number of timesteps in RunningSpeed dataset.""" + return len(self.data) + + def get_frame_range(self, start: int, stop: int = None): + window = self.copy() + if stop is not None: + window.data = window.data[start:stop, :].copy() + else: + window.data = window.data[start, :].copy() + + return window + + def plot(self, ax=None, **pltargs): + if ax is None: + ax = plt.gca() + + ax.plot(self.time_vec, self.data, **pltargs) + ax.set_xlabel('Time (s)') + ax.set_ylabel('Running speed') + + return ax + + def apply_quality_control(self, inplace=False): + super().apply_quality_control(inplace) + raise NotImplementedError From fc07c9a820588293fc42671d725b3bce246aa403 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 17:02:57 -0400 Subject: [PATCH 30/68] Add robust_range for robust dataset visualization --- oscopetools/read_data/dataset_objects.py | 64 +++++++++++++++++++++--- 1 file changed, 56 insertions(+), 8 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 5ae4f71..0a04cc8 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -11,6 +11,11 @@ import pandas as pd +def _stripnan(values): + values_arr = np.asarray(values).flatten() + return values_arr[~np.isnan(values_arr)] + + class SliceParseError(Exception): pass @@ -89,6 +94,41 @@ def _get_vector_mask_from_range(values_to_mask, start, stop=None): return mask +def robust_range( + values, half_width=1.5, center='median', spread='interquartile_range' +): + """Get a range around a center point robust to outliers.""" + if center == 'median': + center_val = np.nanmedian(values) + elif center == 'mean': + center_val = np.nanmean(values) + else: + raise ValueError( + 'Unrecognized `center` {}, expected ' + '`median` or `mean`.'.format(center) + ) + + if spread in ('interquartile_range', 'iqr'): + lower_quantile, upper_quantile = np.percentile( + _stripnan(values), (25, 75) + ) + spread_val = upper_quantile - lower_quantile + elif spread in ('standard_deviation', 'std'): + spread_val = np.nanstd(values) + else: + raise ValueError( + 'Unrecognized `spread` {}, expected ' + '`interquartile_range` (`iqr`) or `standard_deviation` (`std`)'.format( + spread + ) + ) + + lower_bound = center_val - half_width * spread_val + upper_bound = center_val + half_width * spread_val + + return (lower_bound, upper_bound) + + class Dataset(ABC): """A dataset that is interesting to analyze on its own.""" @@ -744,7 +784,7 @@ def get_frame_range(self, start: int, stop: int = None): return window - def plot(self, channel='position', ax=None, **pltargs): + def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): """Make a diagnostic plot of eyetracking data.""" ax = super().plot(ax, **pltargs) @@ -752,14 +792,16 @@ def plot(self, channel='position', ax=None, **pltargs): if channel not in self.data.columns and channel != 'position': raise ValueError( 'Got unrecognized channel `{}`, expected one of ' - '{} or `position`'.format( - channel, self.data.columns.tolist() - ) + '{} or `position`'.format(channel, self.data.columns.tolist()) ) if channel in self.data.columns: ax.plot(self.time_vec, self.data[channel], **pltargs) ax.set_xlabel('Time (s)') + + if robust_range_: + ax.set_ylim(robust_range(self.data[channel])) + elif channel == 'position': if pltargs.pop('style', None) in ['contour', 'density']: x = self.data[self._x_pos_name] @@ -777,6 +819,11 @@ def plot(self, channel='position', ax=None, **pltargs): self.data[self._y_pos_name], **pltargs ) + + if robust_range_: + ax.set_ylim(robust_range(self.data[self._y_pos_name])) + ax.set_xlim(robust_range(self.data[self._x_pos_name])) + else: raise NotImplementedError( 'Plotting for channel {} is not implemented.'.format(channel) @@ -790,9 +837,7 @@ def apply_quality_control(self, inplace=False): class RunningSpeed(TimeseriesDataset): - def __init__( - self, running_speed: np.ndarray, timestep_width: float - ): + def __init__(self, running_speed: np.ndarray, timestep_width: float): running_speed = np.asarray(running_speed) assert running_speed.ndim == 1 @@ -813,7 +858,7 @@ def get_frame_range(self, start: int, stop: int = None): return window - def plot(self, ax=None, **pltargs): + def plot(self, robust_range_=False, ax=None, **pltargs): if ax is None: ax = plt.gca() @@ -821,6 +866,9 @@ def plot(self, ax=None, **pltargs): ax.set_xlabel('Time (s)') ax.set_ylabel('Running speed') + if robust_range_: + ax.set_ylim(robust_range(self.data)) + return ax def apply_quality_control(self, inplace=False): From 5d356388551f48dd62770c0da83ac9d6941c0911 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 17:09:06 -0400 Subject: [PATCH 31/68] Add RunningSpeed to do.__all__ and make factories open files in r mode --- oscopetools/read_data/dataset_objects.py | 7 ++++++- oscopetools/read_data/factories.py | 18 ++++++++++-------- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 0a04cc8..163c1cc 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -1,5 +1,10 @@ """Classes for interacting with OpenScope datasets.""" -__all__ = ('RawFluorescence', 'TrialFluorescence', 'EyeTracking') +__all__ = ( + 'RawFluorescence', + 'TrialFluorescence', + 'EyeTracking', + 'RunningSpeed', +) from abc import ABC, abstractmethod from copy import deepcopy diff --git a/oscopetools/read_data/factories.py b/oscopetools/read_data/factories.py index b6d3b27..f08e036 100644 --- a/oscopetools/read_data/factories.py +++ b/oscopetools/read_data/factories.py @@ -25,7 +25,7 @@ import pandas as pd import numpy as np -from .dataset_objects import RawFluorescence, EyeTracking +from .dataset_objects import RawFluorescence, EyeTracking, RunningSpeed from .conditions import CenterSurroundStimulus, SetMembershipError FRAME_RATE = 30.0 # Assumed frame rate in Hz. TODO: load from a file @@ -46,7 +46,7 @@ def get_dff_traces(file_path): traces. """ - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') dff = f['dff_traces'][()] f.close() @@ -70,7 +70,7 @@ def get_raw_traces(file_path): A `TimeseriesDataset` subclass containing fluorescence traces. """ - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') raw = f['raw_traces'][()] f.close() @@ -81,21 +81,23 @@ def get_raw_traces(file_path): def get_running_speed(file_path): - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') dx = f['running_speed'][()] f.close() - return dx + + speed = RunningSpeed(dx, 1.0/FRAME_RATE) + return speed def get_cell_ids(file_path): - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') cell_ids = f['cell_ids'][()] f.close() return cell_ids def get_max_projection(file_path): - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') max_proj = f['max_projection'][()] f.close() return max_proj @@ -104,7 +106,7 @@ def get_max_projection(file_path): def get_metadata(file_path): import ast - f = h5py.File(file_path) + f = h5py.File(file_path, 'r') md = f.get('meta_data')[...].tolist() f.close() meta_data = ast.literal_eval(md) From 3db8f01962bdec1a7b83338b08efb75747822e2a Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 16:45:28 -0500 Subject: [PATCH 32/68] Robust range tweaks --- oscopetools/read_data/dataset_objects.py | 50 +++++++++++++++++++++--- 1 file changed, 45 insertions(+), 5 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 163c1cc..d35fb23 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -4,6 +4,7 @@ 'TrialFluorescence', 'EyeTracking', 'RunningSpeed', + 'robust_range', ) from abc import ABC, abstractmethod @@ -100,7 +101,7 @@ def _get_vector_mask_from_range(values_to_mask, start, stop=None): def robust_range( - values, half_width=1.5, center='median', spread='interquartile_range' + values, half_width=2, center='median', spread='interquartile_range' ): """Get a range around a center point robust to outliers.""" if center == 'median': @@ -134,6 +135,9 @@ def robust_range( return (lower_bound, upper_bound) +ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH = 3 + + class Dataset(ABC): """A dataset that is interesting to analyze on its own.""" @@ -801,11 +805,26 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): ) if channel in self.data.columns: + if robust_range_: + ax.axhspan( + *robust_range( + self.data[channel], + half_width=1.5, + center='median', + spread='iqr' + ), + color='gray', + label='Median $\pm$ 1.5 IQR', + alpha=0.5, + ) + ax.legend() + ax.plot(self.time_vec, self.data[channel], **pltargs) ax.set_xlabel('Time (s)') if robust_range_: - ax.set_ylim(robust_range(self.data[channel])) + ax.set_ylim(robust_range(self.data[channel], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) elif channel == 'position': if pltargs.pop('style', None) in ['contour', 'density']: @@ -826,8 +845,10 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): ) if robust_range_: - ax.set_ylim(robust_range(self.data[self._y_pos_name])) - ax.set_xlim(robust_range(self.data[self._x_pos_name])) + ax.set_ylim(robust_range(self.data[self._y_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + ax.set_xlim(robust_range(self.data[self._x_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) else: raise NotImplementedError( @@ -867,12 +888,31 @@ def plot(self, robust_range_=False, ax=None, **pltargs): if ax is None: ax = plt.gca() + if robust_range_: + ax.axhspan( + *robust_range( + self.data, + half_width=1.5, + center='median', + spread='iqr' + ), + color='gray', + label='Median $\pm$ 1.5 IQR', + alpha=0.5, + ) + ax.legend() + ax.plot(self.time_vec, self.data, **pltargs) ax.set_xlabel('Time (s)') ax.set_ylabel('Running speed') if robust_range_: - ax.set_ylim(robust_range(self.data)) + ax.set_ylim( + robust_range( + self.data, + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH + ) + ) return ax From fcbf792dba8f0a44fb04fb4403ceeb791f104473 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Thu, 9 Jul 2020 17:48:22 -0400 Subject: [PATCH 33/68] Add script for generating behavioural plots --- analysis/behavioral_plots.py | 61 ++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 analysis/behavioral_plots.py diff --git a/analysis/behavioral_plots.py b/analysis/behavioral_plots.py new file mode 100644 index 0000000..b0dd4b9 --- /dev/null +++ b/analysis/behavioral_plots.py @@ -0,0 +1,61 @@ +import os +import argparse + +from tqdm import tqdm +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.gridspec as gs + +from oscopetools import read_data as rd + +parser = argparse.ArgumentParser() +parser.add_argument('DATA_PATH', help='Path to folder with data files.') +parser.add_argument( + '-o', '--output', help='Path to folder in which to place diagnostic plots.' +) + +args = parser.parse_args() + +spec = gs.GridSpec(2, 3, width_ratios=[1, 1, 0.5]) + +# ITERATE OVER FILES +for dfile in tqdm(os.listdir(args.DATA_PATH)): + if not dfile.endswith('.h5'): + continue + + eyetracking = rd.get_eye_tracking(os.path.join(args.DATA_PATH, dfile)) + runningspeed = rd.get_running_speed(os.path.join(args.DATA_PATH, dfile)) + + plt.figure(figsize=(8, 4)) + + plt.subplot(spec[0, 0]) + plt.title('Running speed') + runningspeed.plot() + plt.xlabel('') + plt.xticks([]) + + plt.subplot(spec[1, 0]) + runningspeed.plot(robust_range_=True, lw=0.7) + + plt.subplot(spec[0, 1]) + plt.title('Pupil area') + eyetracking.plot('pupil_area') + plt.xlabel('') + plt.xticks([]) + + plt.subplot(spec[1, 1]) + eyetracking.plot('pupil_area', robust_range_=True, lw=0.7) + + plt.subplot(spec[0, 2]) + plt.title('Position') + eyetracking.plot( + 'position', marker='o', ls='none', markeredgecolor='w', alpha=0.7 + ) + + plt.subplot(spec[1, 2]) + eyetracking.plot('position', style='density', robust_range_=True) + + plt.tight_layout() + plt.savefig(os.path.join(args.output, dfile.strip('.h5') + '.png'), dpi=600) + + plt.close() From c1c31d4f560586f1e78009700830328ae6c906ec Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 10 Jul 2020 10:40:55 -0400 Subject: [PATCH 34/68] Set eye position plot to 180 deg range by default --- oscopetools/read_data/dataset_objects.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index d35fb23..2901671 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -845,10 +845,15 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): ) if robust_range_: + # Set limits based on approx. data range, excluding outliers ax.set_ylim(robust_range(self.data[self._y_pos_name], half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) ax.set_xlim(robust_range(self.data[self._x_pos_name], half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + else: + # Set limits to a 180 deg standard range + ax.set_xlim(-90., 90.) + ax.set_ylim(-90., 90.) else: raise NotImplementedError( From c86730c48907b984dc11239aa9330a58cefb6b6c Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 10 Jul 2020 10:41:36 -0400 Subject: [PATCH 35/68] Autoformat dataset_objects.py --- oscopetools/read_data/dataset_objects.py | 46 ++++++++++++++---------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 2901671..697f989 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -690,7 +690,7 @@ def plot(self, ax=None, **pltargs): fluo_mean + fluo_std, label='Mean $\pm$ SD', alpha=alpha * 0.6, - **pltargs + **pltargs, ) ax.plot(self.time_vec, fluo_mean, alpha=alpha, **pltargs) ax.set_xlabel('Time (s)') @@ -793,7 +793,9 @@ def get_frame_range(self, start: int, stop: int = None): return window - def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): + def plot( + self, channel='position', robust_range_=False, ax=None, **pltargs + ): """Make a diagnostic plot of eyetracking data.""" ax = super().plot(ax, **pltargs) @@ -811,7 +813,7 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): self.data[channel], half_width=1.5, center='median', - spread='iqr' + spread='iqr', ), color='gray', label='Median $\pm$ 1.5 IQR', @@ -823,8 +825,12 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): ax.set_xlabel('Time (s)') if robust_range_: - ax.set_ylim(robust_range(self.data[channel], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + ax.set_ylim( + robust_range( + self.data[channel], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) elif channel == 'position': if pltargs.pop('style', None) in ['contour', 'density']: @@ -841,19 +847,27 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): ax.plot( self.data[self._x_pos_name], self.data[self._y_pos_name], - **pltargs + **pltargs, ) if robust_range_: # Set limits based on approx. data range, excluding outliers - ax.set_ylim(robust_range(self.data[self._y_pos_name], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) - ax.set_xlim(robust_range(self.data[self._x_pos_name], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + ax.set_ylim( + robust_range( + self.data[self._y_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) + ax.set_xlim( + robust_range( + self.data[self._x_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) else: # Set limits to a 180 deg standard range - ax.set_xlim(-90., 90.) - ax.set_ylim(-90., 90.) + ax.set_xlim(-90.0, 90.0) + ax.set_ylim(-90.0, 90.0) else: raise NotImplementedError( @@ -896,10 +910,7 @@ def plot(self, robust_range_=False, ax=None, **pltargs): if robust_range_: ax.axhspan( *robust_range( - self.data, - half_width=1.5, - center='median', - spread='iqr' + self.data, half_width=1.5, center='median', spread='iqr' ), color='gray', label='Median $\pm$ 1.5 IQR', @@ -914,8 +925,7 @@ def plot(self, robust_range_=False, ax=None, **pltargs): if robust_range_: ax.set_ylim( robust_range( - self.data, - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH + self.data, half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH ) ) From 97c2a49623cfab94976177d57f6e2b033d9a4192 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 10 Jul 2020 11:30:33 -0400 Subject: [PATCH 36/68] Change position markeredgecolor to improve clarity --- analysis/behavioral_plots.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/analysis/behavioral_plots.py b/analysis/behavioral_plots.py index b0dd4b9..0c16bcb 100644 --- a/analysis/behavioral_plots.py +++ b/analysis/behavioral_plots.py @@ -49,13 +49,20 @@ plt.subplot(spec[0, 2]) plt.title('Position') eyetracking.plot( - 'position', marker='o', ls='none', markeredgecolor='w', alpha=0.7 + 'position', + marker='o', + ls='none', + markeredgecolor='gray', + markeredgewidth=0.5, + alpha=0.7, ) plt.subplot(spec[1, 2]) eyetracking.plot('position', style='density', robust_range_=True) plt.tight_layout() - plt.savefig(os.path.join(args.output, dfile.strip('.h5') + '.png'), dpi=600) + plt.savefig( + os.path.join(args.output, dfile.strip('.h5') + '.png'), dpi=600 + ) plt.close() From c351cea935dcb75586f21dffb7adc85f95d8faa8 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Fri, 10 Jul 2020 11:34:45 -0500 Subject: [PATCH 37/68] Add jupyter notebook for inspecting eyetracking --- .../inspect_center_surround_eyetracking.ipynb | 194 ++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 analysis/inspect_center_surround_eyetracking.ipynb diff --git a/analysis/inspect_center_surround_eyetracking.ipynb b/analysis/inspect_center_surround_eyetracking.ipynb new file mode 100644 index 0000000..885dcef --- /dev/null +++ b/analysis/inspect_center_surround_eyetracking.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/eharkin/miniconda3/envs/oscope/lib/python3.8/site-packages/pims/image_reader.py:26: RuntimeWarning: PIMS image_reader.py could not find scikit-image. Falling back to matplotlib's imread(), which uses floats instead of integers. This may break your scripts. \n", + "(To ignore this warning, include the line \"warnings.simplefilter(\"ignore\", RuntimeWarning)\" in your script.)\n", + " warnings.warn(RuntimeWarning(ski_preferred))\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gs\n", + "import seaborn as sns\n", + "import numpy as np\n", + "\n", + "from oscopetools import read_data as rd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "DATA_PATH = '/data/eharkin/openscope2019_data/center_surround'\n", + "IMG_PATH = '/data/eharkin/openscope2019_data/plots/behaviour_summary'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "eyetracking = [\n", + " rd.get_eye_tracking(os.path.join(DATA_PATH, fname)) \n", + " for fname in os.listdir(DATA_PATH) \n", + " if fname.endswith('.h5')\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.logspace(-4.5, -0.5)\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "all_ax = plt.subplot(211)\n", + "all_ax.set_xscale('log')\n", + "all_ax.set_title('Pupil area, all center-surround sessions')\n", + "\n", + "sessions = []\n", + "for et in eyetracking:\n", + " sessions.append(et.data['pupil_area'].to_numpy())\n", + " \n", + "all_ax.hist(np.concatenate(sessions), bins=bins)\n", + "all_ax.set_yticks([])\n", + "all_ax.set_xlabel('Pupil area')\n", + "\n", + "individual_ax = plt.subplot(212)\n", + "individual_ax.set_title('Individual center-surround sessions')\n", + "individual_ax.imshow(np.array([np.histogram(sess, bins=bins)[0] for sess in sessions]), aspect='auto')\n", + "individual_ax.set_xticks([])\n", + "individual_ax.set_yticks([])\n", + "individual_ax.set_ylabel('Sessions')\n", + "individual_ax.set_xlabel('Pupil area (same scale as above)')\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig(os.path.join(IMG_PATH, 'pupil_area_center_surround.png'), dpi=600)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.linspace(-30, 30)\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "plt.suptitle('Eye position')\n", + "\n", + "all_x_ax = plt.subplot(221)\n", + "individual_x_ax = plt.subplot(223)\n", + "all_y_ax = plt.subplot(222)\n", + "individual_y_ax = plt.subplot(224)\n", + "\n", + "sessions = {\n", + " 'x': [],\n", + " 'y': []\n", + "}\n", + "\n", + "for et in eyetracking:\n", + " sessions['x'].append(et.data['x_pos_deg'].to_numpy())\n", + " sessions['y'].append(et.data['y_pos_deg'].to_numpy())\n", + " \n", + "all_x_ax.hist(np.concatenate(sessions['x']), bins=bins)\n", + "all_x_ax.set_title('All center-surround sessions pooled', loc='left')\n", + "all_x_ax.set_yticks([])\n", + "all_x_ax.set_xlabel('x position (deg)')\n", + "individual_x_ax.imshow(np.array([np.histogram(sess, bins=bins)[0] for sess in sessions['x']]), aspect='auto')\n", + "individual_x_ax.set_title('Individual center-surround sessions', loc='left')\n", + "individual_x_ax.set_ylabel('Sessions')\n", + "individual_x_ax.set_yticks([])\n", + "individual_x_ax.set_xticks([])\n", + "\n", + "all_y_ax.hist(np.concatenate(sessions['y']), bins=bins)\n", + "all_y_ax.set_yticks([])\n", + "all_y_ax.set_xlabel('y position (deg)')\n", + "individual_y_ax.imshow(np.array([np.histogram(sess, bins=bins)[0] for sess in sessions['y']]), aspect='auto')\n", + "individual_y_ax.set_yticks([])\n", + "individual_y_ax.set_xticks([])\n", + "\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(top=0.85)\n", + "\n", + "plt.savefig(os.path.join(IMG_PATH, 'eye_position_center_surround.png'), dpi=600)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 9e253346ba1efb5722f861a5e57e938646865fd6 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Fri, 24 Jul 2020 10:24:13 +0200 Subject: [PATCH 38/68] Added both_ends_baseline to cut_by_trials. --- oscopetools/read_data/dataset_objects.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index d35fb23..6bfb922 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -562,7 +562,7 @@ def z_score(self): self.data = z_score self.is_z_score = True - def cut_by_trials(self, trial_timetable, num_baseline_frames=None): + def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_baseline=False): """Divide fluorescence traces up into equal-length trials. Parameters @@ -597,7 +597,7 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None): ' to be ints, got {} and {} instead'.format(start, end) ) start = max(int(start) - num_baseline_frames, 0) - end = int(end) + end = int(end) + num_baseline_frames if both_ends_baseline else int(end) trials.append(self.data[..., start:end]) num_frames.append(end - start) From 0531075fa93c162d2e6b9c177533244c0ab4ced2 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Fri, 24 Jul 2020 10:30:07 +0200 Subject: [PATCH 39/68] LSN analysis and RF plotting --- oscopetools/LSN_analysis.py | 303 ++++++++++++++++++++++++++++++++++++ oscopetools/__init__.py | 2 + oscopetools/adjust_stim.py | 69 ++++++++ 3 files changed, 374 insertions(+) create mode 100644 oscopetools/LSN_analysis.py create mode 100644 oscopetools/adjust_stim.py diff --git a/oscopetools/LSN_analysis.py b/oscopetools/LSN_analysis.py new file mode 100644 index 0000000..2dff79c --- /dev/null +++ b/oscopetools/LSN_analysis.py @@ -0,0 +1,303 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Jul 22 02:35:35 2020 + +@author: kailun +""" + +import numpy as np +import matplotlib.pyplot as plt +from oscopetools import read_data as rd +from .adjust_stim import * +import warnings + +class LSN_analysis: + _ON_stim_value = 255 + _OFF_stim_value = 0 + _background_stim_value = 127 + _yx_ref = None # The reference y- and x-positions used for correcting the LSN stimulus array. + _stim_size = 10 # The side length of the stimulus in degree (same unit as eye pos). + _frame_rate_Hz = 30 # The frame rate of fluorescent responses in Hz. + + def __init__(self, datafile_path, LSN_stim_path, num_baseline_frames = None, use_dff_z_score = False): + """ + To analyze the locally-sparse-noise-stimulated cell responses. + + Parameters + ---------- + datafile_path: str. The path to the data file. + LSN_stim_path: str. The path to the LSN stimulus npy file. + num_baseline_frames: int or None. The number of baseline frames before the start and after the end of a trial. + use_dff_z_score: bool. If True, the cell responses will be converted to z-score before analysis. + + """ + self.datafile_path = datafile_path + self.LSN_stim_path = LSN_stim_path + self.num_baseline_frames = num_baseline_frames + if (self.num_baseline_frames is None) or (self.num_baseline_frames < 0): + self.num_baseline_frames = 0 + self.is_use_dff_z_score = use_dff_z_score + self.is_use_corrected_LSN = False + self.is_use_valid_eye_pos = False + self.is_use_positive_fluo = False + self.dff_fluo = rd.get_dff_traces(self.datafile_path) + self.num_cells = self.dff_fluo.data.shape[0] + self.LSN_stim_table = rd.get_stimulus_table(self.datafile_path, 'locally_sparse_noise') + if self.is_use_dff_z_score: + self.dff_fluo.z_score() + self.trial_fluo = self.dff_fluo.cut_by_trials(self.LSN_stim_table, self.num_baseline_frames, both_ends_baseline=True) + self._full_LSN_stim = np.load(self.LSN_stim_path) + self.eye_tracking = rd.get_eye_tracking(self.datafile_path) + self._corrected_LSN_stim, self.valid_eye_pos, self.yx_ref = correct_LSN_stim_by_eye_pos(self._full_LSN_stim, self.LSN_stim_table, self.eye_tracking.data, + self._yx_ref, self._stim_size, self._background_stim_value) + self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] + self._trial_mask = self.valid_eye_pos + self._update_responses() + + def __str__(self): + return ("Analyzing file: {}\n" + "ON LSN stimulus value: {}\n" + "OFF LSN stimulus value: {}\n" + "Background LSN value: {}\n" + "LSN stimulus size: {} degree\n" + "Number of cells: {}\n" + "Use DF/F z-score: {}\n" + "Use corrected LSN: {}\n" + "Use only valid eye positions: {}\n" + "Use only positive fluorescence responses: {}").format( + self.datafile_path, self._ON_stim_value, self._OFF_stim_value, + self._background_stim_value, self._stim_size, self.num_cells, self.is_use_dff_z_score, + self.is_use_corrected_LSN, self.is_use_valid_eye_pos, self.is_use_positive_fluo + ) + + def correct_LSN_by_eye_pos(self, value = True): + """ + value: bool. If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN stimulus will be used. + The stimulus wlll remain unchanged for those frames without valid eye positions. + """ + if self.is_use_corrected_LSN == bool(value): + raise ValueError('LSN stim is already corrected.' if bool(value) else 'LSN stim is already original.') + if value: + self.LSN_stim = self._corrected_LSN_stim + else: + self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] + self._update_responses() + self.is_use_corrected_LSN = bool(value) + + def use_valid_eye_pos(self, value = True): + """ + value: bool. If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used. + """ + if self.is_use_valid_eye_pos == bool(value): + raise ValueError('The valid eye positions are used.' if bool(value) else 'All eye positions are used.') + if value: + self._trial_mask = self.valid_eye_pos + else: + self._trial_mask = np.array([True] * self.LSN_stim_table.shape[0]) + self._update_responses() + self.is_use_valid_eye_pos = bool(value) + + def use_positive_fluo(self, value = True): + """ + value: bool. If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses. + """ + if self.is_use_positive_fluo == bool(value): + raise ValueError('The positive responses are already used.' if bool(value) else 'Both positive and negative responses are already used.') + self.is_use_positive_fluo = bool(value) + self._update_responses() + + def _update_responses(self): + self.ON_avg_responses = self._compute_avg_pixel_response(self.trial_fluo.data[self._trial_mask], self.LSN_stim[self._trial_mask], self._ON_stim_value) + self.OFF_avg_responses = self._compute_avg_pixel_response(self.trial_fluo.data[self._trial_mask], self.LSN_stim[self._trial_mask], self._OFF_stim_value) + self.get_RFs() + + def _compute_avg_pixel_response(self, trial_responses, LSN_stim, target): + """ + Parameters + ---------- + trial_responses: 3d np.array. The DF/F trial responses, shape = (num_trials, num_cells, trial_len). + LSN_stim: 3d np.array. LSN stimulus array, shape = (num_frame, ylen, xlen). + target: int. The target value (value of interest) in the stimulus array. + + Returns + ------- + avg_responses: 4d np.array. The trial-averaged responses within pixel, shape = (num_cells, ylen, xlen, trial_len). + """ + if self.is_use_positive_fluo: + trial_responses[trial_responses<0] = 0 + avg_responses = np.zeros((trial_responses.shape[1], LSN_stim.shape[1], + LSN_stim.shape[2], trial_responses.shape[2])) + for y in range(LSN_stim.shape[1]): + for x in range(LSN_stim.shape[2]): + targets, = np.where(LSN_stim[:, y, x] == target) + avg_responses[:, y, x, :] = trial_responses[targets].mean(0) + return avg_responses + + def _compute_p_values(self): + raise NotImplementedError + + def get_RFs(self, threshold = 0, window_start = None, window_len = None): + """ + To get the ON and OFF RFs and the position of their max response. + + Parameters + ---------- + threshold: int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. + window_start: int. The start index (within a trial) of the integration window for computing the RFs. + window_len: int. The length of the integration window in frames for computing the RFs. + + Creates + ------- + ON_ and OFF_RFs: 3d np.array, shape = (num_cells, ylen, xlen). + ON_ and OFF_RF_peaks_yx: 2d np.array. The yx-indices of the peak responses of each cell, shape = (num_cells, 2). + """ + if window_start is None: + window_start = self.num_baseline_frames + if window_len is None: + window_len = self.ON_avg_responses.shape[-1] - 2*self.num_baseline_frames + if window_start + window_len > self.ON_avg_responses.shape[-1]: + warnings.warn("The integration window [{}:{}] is shifted beyond the trial of length {}!".format(window_start, + window_start+window_len, self.ON_avg_responses.shape[-1])) + self._integration_window_start = int(window_start) + self._integration_window_len = int(window_len) + if self._integration_window_start < 0: + self._integration_window_start = 0 + if self._integration_window_len < 0: + self._integration_window_len = 0 + if threshold < 0: + threshold = 0 + self.ON_RFs = self._compute_RF_subfield('ON', threshold, self._integration_window_start, self._integration_window_len) + self.OFF_RFs = self._compute_RF_subfield('OFF', threshold, self._integration_window_start, self._integration_window_len) + ON_cell_peak_idx = self.ON_RFs.reshape(self.ON_RFs.shape[0], -1).argmax(1) + OFF_cell_peak_idx = self.OFF_RFs.reshape(self.OFF_RFs.shape[0], -1).argmin(1) + self.ON_RF_peaks_yx = np.column_stack(np.unravel_index(ON_cell_peak_idx, self.ON_RFs[0,:,:].shape)) + self.OFF_RF_peaks_yx = np.column_stack(np.unravel_index(OFF_cell_peak_idx, self.OFF_RFs[0,:,:].shape)) + + def _compute_RF_subfield(self, polarity, threshold, window_start, window_len): + """ + To compute the ON or OFF subfield given a threshold. + + Parameters + ---------- + polarity: str. 'ON' or 'OFF'. + threshold: int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. + window_start: int. The start index (within a trial) of the integration window for computing the RFs. + window_len: int. The length of the integration window in frames for computing the RFs. + + Returns + ------- + RFs: 3d np.array. Array containing ON or OFF RFs for all cells, shape = (num_cells, ylen, xlen). + """ + if polarity not in ['ON', 'OFF', 'on', 'off']: + raise ValueError("Please enter 'ON', 'OFF', 'on', or 'off' for the polarity.") + if polarity in ['ON', 'on']: + RFs = self.ON_avg_responses[..., window_start:window_start+window_len].mean(-1) + pol = 1 + else: + RFs = self.OFF_avg_responses[..., window_start:window_start+window_len].mean(-1) + pol = -1 + RFs -= np.nanmean(RFs, axis=(1,2))[:, None, None] + RFs /= np.nanmax(abs(RFs), axis=(1,2))[:, None, None] + RFs[RFs < threshold] = 0. + RFs *= pol + return RFs + + def plot_RFs(self, title, cell_idx_lst, polarity = 'both', num_cols = 5, label_peak = True, contour_levels = []): + """ + To plot the RFs. + + Parameters + ---------- + title: str. The title of the figure. + cell_idx_lst: list or np.array. The cell numbers to be plotted. + polarity: str, 'ON', 'OFF', or 'both' (default). The polarity of the RFs to be plotted. + num_cols: int. The number of columns of the subplots. + label_peak: bool. If True, the pixel with max response will be labeled. + contour_levels: array-like. The contour levels to be plotted. + """ + if polarity not in ['ON', 'OFF', 'both']: + raise ValueError("Please enter 'ON', 'OFF', or 'both' for the polarity.") + figsize_x = num_cols * 2 + num_rows = np.ceil(len(cell_idx_lst) / num_cols).astype(int) + figsize_factor = (self.LSN_stim.shape[1] * num_rows) / (self.LSN_stim.shape[2] * num_cols) * 1.5 + figsize_y = figsize_x * figsize_factor + fig, axes = plt.subplots(num_rows, num_cols, figsize=(figsize_x, figsize_y)) + axes = axes.flatten() + fig.tight_layout() + fig.subplots_adjust(wspace=0.1, hspace=0.2, top=0.95, bottom=0.01, left=0.002, right=0.998) + fig.suptitle(title, fontsize=30) + for i, ax in enumerate(axes): + idx = cell_idx_lst[i] + if idx < len(cell_idx_lst) or idx < self.num_cells: + if polarity == 'ON': + pcol = ax.pcolormesh(self.ON_RFs[idx]) + if label_peak: + ax.plot(self.ON_RF_peaks_yx[idx, 1] + 0.5, self.ON_RF_peaks_yx[idx, 0] + 0.5, '.r') + if polarity == 'OFF': + pcol = ax.pcolormesh(self.OFF_RFs[idx]) + if label_peak: + ax.plot(self.OFF_RF_peaks_yx[idx, 1] + 0.5, self.OFF_RF_peaks_yx[idx, 0] + 0.5, '.b') + if polarity == 'both': + pcol = ax.pcolormesh(self.ON_RFs[idx] + self.OFF_RFs[idx]) # plus because OFF_RFs are already negative. + if label_peak: + ax.plot(self.ON_RF_peaks_yx[idx, 1] + 0.5, self.ON_RF_peaks_yx[idx, 0] + 0.5, '.r') + ax.plot(self.OFF_RF_peaks_yx[idx, 1] + 0.5, self.OFF_RF_peaks_yx[idx, 0] + 0.5, '.b') + ax.set_aspect('equal', 'box') + pcol.set_edgecolor('face') + pcol.set_clim([-1,1]) + ax.set_xticks([]) + ax.set_yticks([]) + ax.set_title("Cell {}".format(idx), fontsize=15, y=.99) + if contour_levels: + if polarity != 'ON': + ax.contour(-self.OFF_RFs[idx], contour_levels, colors = 'deepskyblue', origin = 'lower') + if polarity != 'OFF': + ax.contour(self.ON_RFs[idx], contour_levels, colors = 'gold', origin = 'lower') + else: + ax.set_visible(False) + + def plot_pixel_avg_dff_traces(self, polarity, cell_idx, num_std=2, **pltargs): + """ + To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell. + + Parameters + ---------- + polarity: str, 'ON' or 'OFF'. The polarity of the responses to be plotted. + cell_idx: int. The cell index to be plotted. + num_std: int or float. Number of standard deviation from mean for plotting the horizontal span. + pltargs: other kwargs as for plt.plot(). + """ + if polarity not in ['ON', 'on', 'OFF', 'off']: + raise ValueError("Please enter 'ON' or 'OFF' for the polarity.") + avg_responses = self.ON_avg_responses if polarity in ['ON', 'on'] else self.OFF_avg_responses + flat_response = avg_responses[cell_idx].reshape(-1, avg_responses.shape[3]) + response_mean = np.nanmean(flat_response) + response_std = np.nanstd(flat_response) + lower_bound = response_mean - num_std * response_std + upper_bound = response_mean + num_std * response_std + plt.figure(figsize=(15,10)) + frame_duration_sec = 1 / self._frame_rate_Hz + to_sec = lambda nframes: nframes * frame_duration_sec + start_sec = to_sec(-self.num_baseline_frames) + end_sec = to_sec(-self.num_baseline_frames + avg_responses.shape[3] - 1) + time_vec = np.arange(start_sec, end_sec+frame_duration_sec, frame_duration_sec) + for i in range(flat_response.shape[0]): + plt.plot(time_vec, flat_response[i], **pltargs) + trial_end_sec = to_sec(avg_responses.shape[3] - 2*self.num_baseline_frames - 1) + plt.axvspan(start_sec, 0, color='gray', alpha=0.3, label='Baseline before and after trial') + plt.axvspan(trial_end_sec, end_sec, color='gray', alpha=0.3) + integration_start_sec = to_sec(self._integration_window_start - self.num_baseline_frames) + integration_end_sec = integration_start_sec + to_sec(self._integration_window_len - 1) + plt.axvspan(integration_start_sec, integration_end_sec, color='lightblue', alpha=0.5, label='RF integration window') + plt.axhspan(lower_bound, upper_bound, color='lightgreen', alpha=0.5, label='Mean $\pm$ {} std'.format(num_std)) + plt.legend() + plt.title('Cell {} ({} responses)\nTrial-averaged DF/F traces within pixel'.format(cell_idx, polarity), fontsize = 30) + plt.xlabel('Time (sec)', fontsize = 20) + if self.is_use_dff_z_score: + plt.ylabel('DF/F (z-score)', fontsize = 20) + else: + plt.ylabel('DF/F', fontsize = 20) + + def save_data(self, save_path): + raise NotImplementedError \ No newline at end of file diff --git a/oscopetools/__init__.py b/oscopetools/__init__.py index 6f8f16b..cd1650d 100644 --- a/oscopetools/__init__.py +++ b/oscopetools/__init__.py @@ -7,3 +7,5 @@ from . import roi_information from . import stim_table from . import util +from . import adjust_stim +from . import LSN_analysis diff --git a/oscopetools/adjust_stim.py b/oscopetools/adjust_stim.py new file mode 100644 index 0000000..16fd81e --- /dev/null +++ b/oscopetools/adjust_stim.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Tue Jul 21 17:18:47 2020 + +@author: kailun +""" + +import numpy as np + +def correct_LSN_stim_by_eye_pos(LSN_stim, LSN_stim_table, eye_tracking, yx_ref = None, stim_size = 10, stim_background_value = 127): + """ + To correct the LSN stimulus array by using the eye position averaged within trial. + + Parameters + ---------- + LSN_stim: 3d np.array. The LSN stimulus array, shape = (num_trials, ylen, xlen). + LSN_stim_table: pd.DataFrame. The stim_table of loccally sparse noise. + eye_tracking: pd.DataFrame. The eye tracking data. + yx_ref: list, np.array, or None. The reference y- and x-positions (hypothetical eye position looking at the center of the + stimulus monitor), where corrected_stim_pos = original_stim_pos - yx_ref. If None, the mean y- and x-positions of the + eye during LSN stimuli will be the yx_ref. + stim_size: int. The side length of the stimulus in degree. + stim_background_value: int. The background value (gray) of the LSN stimulus. + + Returns + ------- + corrected_stim_arr: 3d np.array. The corrected LSN stimulus array according to the eye positions averaged within trial. + isvalid_eye_pos: bool vector-like. Boolean array showing valid eye position (not NaN). Use corrected_stim_arr[isvalid_eye_pos] + to get the trials with valid eye position. + yx_ref: 1d np.array. The reference y- and x-positions used for correcting the LSN stimulus array. + """ + yx_eye_pos = get_trial_yx_eye_pos(eye_tracking, LSN_stim_table) + if isinstance(yx_ref, type(None)): + yx_ref = np.nanmean(yx_eye_pos, 0) + border = np.ceil(np.nanmax(abs(yx_eye_pos - yx_ref)) / stim_size).astype(int) + 1 # + 1 for ensuring that the border is wide enough + corrected_stim_arr = np.zeros((LSN_stim_table.shape[0], LSN_stim.shape[1]+2*border, LSN_stim.shape[2]+2*border), dtype = 'int32') + corrected_stim_arr += stim_background_value + corrected_stim_arr[:, border:-border, border:-border] = LSN_stim[LSN_stim_table['Frame']] + isvalid_eye_pos = [] + for i in range(LSN_stim_table.shape[0]): + if np.isnan(yx_eye_pos[i]).any(): + isvalid_eye_pos.append(False) + continue + else: + isvalid_eye_pos.append(True) + yx_deviation = np.around((yx_eye_pos[i]-yx_ref) / stim_size).astype(int) + corrected_stim_arr[i] = np.roll(corrected_stim_arr[i], (yx_deviation[0], yx_deviation[1]), (0, 1)) + return corrected_stim_arr[:, border:-border, border:-border], np.array(isvalid_eye_pos), yx_ref + +def get_trial_yx_eye_pos(eye_tracking, stim_table): + """ + To get the y- and x-position of the eye averaed within trial. + + Parameters + ---------- + eye_tracking: pd.DataFrame. The eye tracking data. + stim_table: pd.DataFrame. The stimulus table. + + Returns + ------- + yx_eye_pos: 2d np.array. The y- and x-positions of the eye averaged within trial, shape = (num_trials, 2). + """ + yx_eye_pos = np.zeros((stim_table.shape[0], 2), dtype = 'float32') + for trial_no in range(stim_table.shape[0]): + mean_y = eye_tracking['y_pos_deg'][int(stim_table['Start'][trial_no]):int(stim_table['End'][trial_no])].mean() + mean_x = eye_tracking['x_pos_deg'][int(stim_table['Start'][trial_no]):int(stim_table['End'][trial_no])].mean() + yx_eye_pos[trial_no] = [mean_y, mean_x] + return yx_eye_pos \ No newline at end of file From 400a4000839db8712cf81c44b8ba7ec294263512 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Fri, 24 Jul 2020 10:31:54 +0200 Subject: [PATCH 40/68] LSN analysis and RF plotting --- analysis/compute_and_plot_RFs.py | 67 ++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 analysis/compute_and_plot_RFs.py diff --git a/analysis/compute_and_plot_RFs.py b/analysis/compute_and_plot_RFs.py new file mode 100644 index 0000000..2e2802f --- /dev/null +++ b/analysis/compute_and_plot_RFs.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Jul 22 05:34:22 2020 + +@author: kailun +""" + +import numpy as np +from oscopetools.LSN_analysis import LSN_analysis + +# The path to the data file. +datafile_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround_976474801_data.h5' +# The path to the LSN stimulus npy file. +LSN_stim_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/openscope_surround-master/stimulus/sparse_noise_8x14.npy' +num_baseline_frames = 3 # int or None. The number of baseline frames before the start and after the end of a trial. +use_dff_z_score = False # True or False. If True, the cell responses will be converted to z-score before analysis. + +# To initialize the analysis. +LSN_data = LSN_analysis(datafile_path, LSN_stim_path, num_baseline_frames, use_dff_z_score) + +#%% +# To get an overview of the data. +print(LSN_data) + +#%% +# Other variables (RFs, ON/OFF responses, etc.) will be automatically updated. +correct_LSN = False # If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN stimulus will be used. +LSN_data.correct_LSN_by_eye_pos(correct_LSN) + +#%% +# Other variables (RFs, ON/OFF responses, etc.) will be automatically updated. +use_only_valid_eye_pos = False # If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used. +LSN_data.use_valid_eye_pos(use_only_valid_eye_pos) + +#%% +# Other variables (RFs, ON/OFF responses, etc.) will be automatically updated. +use_only_positive_responses = False # If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses. +LSN_data.use_positive_fluo(use_only_positive_responses) + +#%% +# The RFs are computed during initialization with default parameters. Here, we can change the threshold and integration window for RFs. +# To compute the RFs by using different thresholds (default = 0) and different integration windows by adjusting the window_start (shifting) +# and window_len (length of the integration window). + +threshold = 0. # int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. +window_start = None # int or None. The start index (within a trial) of the integration window for computing the RFs. +window_len = None # int or None. The length of the integration window in frames for computing the RFs. +LSN_data.get_RFs(threshold, window_start, window_len) + +#%% +# To plot the RFs. +fig_title = "Receptive fields" # The title of the figure. +cell_idx_lst = np.arange(100) # list or np.array. The cell numbers to be plotted. +polarity = 'both' # 'ON', 'OFF', or 'both'. The polarity of the RFs to be plotted. +num_cols = 10 # int. The number of columns of the subplots. +label_peak = True # bool. If True, the pixel with max response will be labeled. The ON peaks are labeled with red dots and OFF peaks with blue dots. +contour_levels = [0.6] # list or array-like. The contour levels to be plotted. Examples: [], [0.5], [0.6, 0.8]. +LSN_data.plot_RFs(fig_title, cell_idx_lst, polarity, num_cols, label_peak, contour_levels) + +#%% +# To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell. +# Other keyword arguments can be added for plt.plot(). +polarity = 'ON' # 'ON' or 'OFF'. The polarity of the responses to be plotted. +cell_idx = 10 # The cell index to be plotted. +num_std = 2 # int or float. Number of standard deviation from mean for plotting the horizontal span. +LSN_data.plot_pixel_avg_dff_traces(polarity, cell_idx, num_std) \ No newline at end of file From 2776d57d00a8eebb89fc6177ca55d0942581ff3e Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Thu, 30 Jul 2020 06:46:03 +0200 Subject: [PATCH 41/68] Modified with Emerson's suggestions. --- oscopetools/LSN_analysis.py | 604 +++++++++++++++++++++++++----------- oscopetools/adjust_stim.py | 105 ++++--- 2 files changed, 495 insertions(+), 214 deletions(-) diff --git a/oscopetools/LSN_analysis.py b/oscopetools/LSN_analysis.py index 2dff79c..c82a20e 100644 --- a/oscopetools/LSN_analysis.py +++ b/oscopetools/LSN_analysis.py @@ -10,294 +10,552 @@ import matplotlib.pyplot as plt from oscopetools import read_data as rd from .adjust_stim import * +from enum import Enum import warnings + class LSN_analysis: _ON_stim_value = 255 _OFF_stim_value = 0 _background_stim_value = 127 - _yx_ref = None # The reference y- and x-positions used for correcting the LSN stimulus array. - _stim_size = 10 # The side length of the stimulus in degree (same unit as eye pos). - _frame_rate_Hz = 30 # The frame rate of fluorescent responses in Hz. - - def __init__(self, datafile_path, LSN_stim_path, num_baseline_frames = None, use_dff_z_score = False): - """ - To analyze the locally-sparse-noise-stimulated cell responses. + _yx_ref = None # The reference y- and x-positions used for correcting the LSN stimulus array. + _stim_size = ( + 10 # The side length of the stimulus in degree (same unit as eye pos). + ) + _frame_rate_Hz = 30 # The frame rate of fluorescent responses in Hz. + + def __init__( + self, + datafile_path, + LSN_stim_path, + num_baseline_frames=None, + use_dff_z_score=False, + ): + """To analyze the locally-sparse-noise-stimulated cell responses. Parameters ---------- - datafile_path: str. The path to the data file. - LSN_stim_path: str. The path to the LSN stimulus npy file. - num_baseline_frames: int or None. The number of baseline frames before the start and after the end of a trial. - use_dff_z_score: bool. If True, the cell responses will be converted to z-score before analysis. + datafile_path : str + The path to the data file. + LSN_stim_path : str + The path to the LSN stimulus npy file. + num_baseline_frames : int or None + The number of baseline frames before the start and after the end of a trial. + use_dff_z_score : bool + If True, the cell responses will be converted to z-score before analysis. """ self.datafile_path = datafile_path self.LSN_stim_path = LSN_stim_path self.num_baseline_frames = num_baseline_frames - if (self.num_baseline_frames is None) or (self.num_baseline_frames < 0): + if (self.num_baseline_frames is None) or ( + self.num_baseline_frames < 0 + ): self.num_baseline_frames = 0 self.is_use_dff_z_score = use_dff_z_score self.is_use_corrected_LSN = False self.is_use_valid_eye_pos = False self.is_use_positive_fluo = False self.dff_fluo = rd.get_dff_traces(self.datafile_path) - self.num_cells = self.dff_fluo.data.shape[0] - self.LSN_stim_table = rd.get_stimulus_table(self.datafile_path, 'locally_sparse_noise') + self.num_cells = self.dff_fluo.num_cells + self.LSN_stim_table = rd.get_stimulus_table( + self.datafile_path, "locally_sparse_noise" + ) if self.is_use_dff_z_score: self.dff_fluo.z_score() - self.trial_fluo = self.dff_fluo.cut_by_trials(self.LSN_stim_table, self.num_baseline_frames, both_ends_baseline=True) + self.trial_fluo = self.dff_fluo.cut_by_trials( + self.LSN_stim_table, + self.num_baseline_frames, + both_ends_baseline=True, + ) self._full_LSN_stim = np.load(self.LSN_stim_path) self.eye_tracking = rd.get_eye_tracking(self.datafile_path) - self._corrected_LSN_stim, self.valid_eye_pos, self.yx_ref = correct_LSN_stim_by_eye_pos(self._full_LSN_stim, self.LSN_stim_table, self.eye_tracking.data, - self._yx_ref, self._stim_size, self._background_stim_value) + ( + self._corrected_LSN_stim, + self.valid_eye_pos, + self.yx_ref, + ) = correct_LSN_stim_by_eye_pos( + self._full_LSN_stim, + self.LSN_stim_table, + self.eye_tracking, + self._yx_ref, + self._stim_size, + self._background_stim_value, + ) self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] self._trial_mask = self.valid_eye_pos self._update_responses() - + def __str__(self): - return ("Analyzing file: {}\n" - "ON LSN stimulus value: {}\n" - "OFF LSN stimulus value: {}\n" - "Background LSN value: {}\n" - "LSN stimulus size: {} degree\n" - "Number of cells: {}\n" - "Use DF/F z-score: {}\n" - "Use corrected LSN: {}\n" - "Use only valid eye positions: {}\n" - "Use only positive fluorescence responses: {}").format( - self.datafile_path, self._ON_stim_value, self._OFF_stim_value, - self._background_stim_value, self._stim_size, self.num_cells, self.is_use_dff_z_score, - self.is_use_corrected_LSN, self.is_use_valid_eye_pos, self.is_use_positive_fluo - ) - - def correct_LSN_by_eye_pos(self, value = True): + return ( + "Analyzing file: {}\n" + "ON LSN stimulus value: {}\n" + "OFF LSN stimulus value: {}\n" + "Background LSN value: {}\n" + "LSN stimulus size: {} degree\n" + "Number of cells: {}\n" + "Use DF/F z-score: {}\n" + "Use corrected LSN: {}\n" + "Use only valid eye positions: {}\n" + "Use only positive fluorescence responses: {}" + ).format( + self.datafile_path, + self._ON_stim_value, + self._OFF_stim_value, + self._background_stim_value, + self._stim_size, + self.num_cells, + self.is_use_dff_z_score, + self.is_use_corrected_LSN, + self.is_use_valid_eye_pos, + self.is_use_positive_fluo, + ) + + def correct_LSN_by_eye_pos(self, value=True): """ - value: bool. If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN stimulus will be used. - The stimulus wlll remain unchanged for those frames without valid eye positions. + value : bool + If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN stimulus will be used. + The stimulus wlll remain unchanged for those frames without valid eye positions. """ if self.is_use_corrected_LSN == bool(value): - raise ValueError('LSN stim is already corrected.' if bool(value) else 'LSN stim is already original.') + raise ValueError( + "LSN stim is already corrected." + if bool(value) + else "LSN stim is already original." + ) if value: self.LSN_stim = self._corrected_LSN_stim else: self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] self._update_responses() self.is_use_corrected_LSN = bool(value) - - def use_valid_eye_pos(self, value = True): + + def use_valid_eye_pos(self, value=True): """ - value: bool. If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used. + value : bool + If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used. """ if self.is_use_valid_eye_pos == bool(value): - raise ValueError('The valid eye positions are used.' if bool(value) else 'All eye positions are used.') + raise ValueError( + "The valid eye positions are used." + if bool(value) + else "All eye positions are used." + ) if value: self._trial_mask = self.valid_eye_pos else: self._trial_mask = np.array([True] * self.LSN_stim_table.shape[0]) self._update_responses() self.is_use_valid_eye_pos = bool(value) - - def use_positive_fluo(self, value = True): + + def use_positive_fluo(self, value=True): """ - value: bool. If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses. + value : bool + If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses. """ if self.is_use_positive_fluo == bool(value): - raise ValueError('The positive responses are already used.' if bool(value) else 'Both positive and negative responses are already used.') + raise ValueError( + "The positive responses are already used." + if bool(value) + else "Both positive and negative responses are already used." + ) self.is_use_positive_fluo = bool(value) self._update_responses() - + def _update_responses(self): - self.ON_avg_responses = self._compute_avg_pixel_response(self.trial_fluo.data[self._trial_mask], self.LSN_stim[self._trial_mask], self._ON_stim_value) - self.OFF_avg_responses = self._compute_avg_pixel_response(self.trial_fluo.data[self._trial_mask], self.LSN_stim[self._trial_mask], self._OFF_stim_value) + self.ON_avg_responses = self._compute_avg_pixel_response( + self.trial_fluo.get_trials(self._trial_mask), + self.LSN_stim[self._trial_mask], + self._ON_stim_value, + ) + self.OFF_avg_responses = self._compute_avg_pixel_response( + self.trial_fluo.get_trials(self._trial_mask), + self.LSN_stim[self._trial_mask], + self._OFF_stim_value, + ) self.get_RFs() - - def _compute_avg_pixel_response(self, trial_responses, LSN_stim, target): + + def _compute_avg_pixel_response(self, trial_response, LSN_stim, target): """ Parameters ---------- - trial_responses: 3d np.array. The DF/F trial responses, shape = (num_trials, num_cells, trial_len). - LSN_stim: 3d np.array. LSN stimulus array, shape = (num_frame, ylen, xlen). - target: int. The target value (value of interest) in the stimulus array. + trial_response : TrialFluorescence object + The DF/F trial response. + LSN_stim : 3d np.array + LSN stimulus array, shape = (num_frame, ylen, xlen). + target : int + The target value (value of interest) in the stimulus array. Returns ------- - avg_responses: 4d np.array. The trial-averaged responses within pixel, shape = (num_cells, ylen, xlen, trial_len). + avg_responses : 4d np.array + The trial-averaged responses within pixel, shape = (num_cells, ylen, xlen, trial_len). """ - if self.is_use_positive_fluo: - trial_responses[trial_responses<0] = 0 - avg_responses = np.zeros((trial_responses.shape[1], LSN_stim.shape[1], - LSN_stim.shape[2], trial_responses.shape[2])) + response = ( + trial_response.positive_part() + if self.is_use_positive_fluo + else trial_response + ) + avg_responses = np.zeros( + ( + response.num_cells, + LSN_stim.shape[1], + LSN_stim.shape[2], + response.num_timesteps, + ) + ) for y in range(LSN_stim.shape[1]): for x in range(LSN_stim.shape[2]): - targets, = np.where(LSN_stim[:, y, x] == target) - avg_responses[:, y, x, :] = trial_responses[targets].mean(0) + avg_responses[:, y, x, :] = ( + response.get_trials(LSN_stim[:, y, x] == target) + .trial_mean() + .data + ) return avg_responses - + def _compute_p_values(self): raise NotImplementedError - - def get_RFs(self, threshold = 0, window_start = None, window_len = None): - """ - To get the ON and OFF RFs and the position of their max response. + + def get_RFs(self, threshold=0, window_start=None, window_len=None): + """To get the ON and OFF RFs and the position of their max response. Parameters ---------- - threshold: int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. - window_start: int. The start index (within a trial) of the integration window for computing the RFs. - window_len: int. The length of the integration window in frames for computing the RFs. + threshold : int or float + Range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. + window_start : int + The start frame index (within a trial) of the integration window for computing the RFs. + window_len : int + The length of the integration window in frames for computing the RFs. Creates ------- - ON_ and OFF_RFs: 3d np.array, shape = (num_cells, ylen, xlen). - ON_ and OFF_RF_peaks_yx: 2d np.array. The yx-indices of the peak responses of each cell, shape = (num_cells, 2). + ON_RFs : 3d np.array + The ON receptive field array, shape = (num_cells, ylen, xlen). + OFF_RFs : 3d np.array + The OFF receptive field array, shape = (num_cells, ylen, xlen). + ON_RF_peaks_yx : 2d np.array + The yx-indices of the peak ON responses of each cell, shape = (num_cells, 2). + OFF_RF_peaks_yx : 2d np.array + The yx-indices of the peak OFF responses of each cell, shape = (num_cells, 2). """ if window_start is None: window_start = self.num_baseline_frames if window_len is None: - window_len = self.ON_avg_responses.shape[-1] - 2*self.num_baseline_frames + window_len = ( + self.ON_avg_responses.shape[-1] - 2 * self.num_baseline_frames + ) if window_start + window_len > self.ON_avg_responses.shape[-1]: - warnings.warn("The integration window [{}:{}] is shifted beyond the trial of length {}!".format(window_start, - window_start+window_len, self.ON_avg_responses.shape[-1])) - self._integration_window_start = int(window_start) - self._integration_window_len = int(window_len) - if self._integration_window_start < 0: - self._integration_window_start = 0 - if self._integration_window_len < 0: - self._integration_window_len = 0 - if threshold < 0: - threshold = 0 - self.ON_RFs = self._compute_RF_subfield('ON', threshold, self._integration_window_start, self._integration_window_len) - self.OFF_RFs = self._compute_RF_subfield('OFF', threshold, self._integration_window_start, self._integration_window_len) - ON_cell_peak_idx = self.ON_RFs.reshape(self.ON_RFs.shape[0], -1).argmax(1) - OFF_cell_peak_idx = self.OFF_RFs.reshape(self.OFF_RFs.shape[0], -1).argmin(1) - self.ON_RF_peaks_yx = np.column_stack(np.unravel_index(ON_cell_peak_idx, self.ON_RFs[0,:,:].shape)) - self.OFF_RF_peaks_yx = np.column_stack(np.unravel_index(OFF_cell_peak_idx, self.OFF_RFs[0,:,:].shape)) - - def _compute_RF_subfield(self, polarity, threshold, window_start, window_len): - """ - To compute the ON or OFF subfield given a threshold. + warnings.warn( + "The integration window [{}:{}] is shifted beyond the trial of length {}!".format( + window_start, + window_start + window_len, + self.ON_avg_responses.shape[-1], + ) + ) + self._integration_window_start = max(0, int(window_start)) + self._integration_window_len = max(0, int(window_len)) + threshold = max(0, threshold) + self.ON_RFs = self._compute_RF_subfield( + "ON", + threshold, + self._integration_window_start, + self._integration_window_len, + ) + self.OFF_RFs = self._compute_RF_subfield( + "OFF", + threshold, + self._integration_window_start, + self._integration_window_len, + ) + ON_cell_peak_idx = self.ON_RFs.reshape( + self.ON_RFs.shape[0], -1 + ).argmax(1) + OFF_cell_peak_idx = self.OFF_RFs.reshape( + self.OFF_RFs.shape[0], -1 + ).argmin(1) + self.ON_RF_peaks_yx = np.column_stack( + np.unravel_index(ON_cell_peak_idx, self.ON_RFs[0, :, :].shape) + ) + self.OFF_RF_peaks_yx = np.column_stack( + np.unravel_index(OFF_cell_peak_idx, self.OFF_RFs[0, :, :].shape) + ) + + def _compute_RF_subfield( + self, polarity, threshold, window_start, window_len + ): + """To compute the ON or OFF subfield given a threshold. Parameters ---------- - polarity: str. 'ON' or 'OFF'. - threshold: int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. - window_start: int. The start index (within a trial) of the integration window for computing the RFs. - window_len: int. The length of the integration window in frames for computing the RFs. + polarity : str + 'ON' or 'OFF'. + threshold : int or float + Range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0. + window_start : int + The start index (within a trial) of the integration window for computing the RFs. + window_len : int + The length of the integration window in frames for computing the RFs. Returns ------- - RFs: 3d np.array. Array containing ON or OFF RFs for all cells, shape = (num_cells, ylen, xlen). + RFs : 3d np.array + Array containing ON or OFF RFs for all cells, shape = (num_cells, ylen, xlen). """ - if polarity not in ['ON', 'OFF', 'on', 'off']: - raise ValueError("Please enter 'ON', 'OFF', 'on', or 'off' for the polarity.") - if polarity in ['ON', 'on']: - RFs = self.ON_avg_responses[..., window_start:window_start+window_len].mean(-1) + polarity = ReceptiveFieldPolarity.from_(polarity) + if polarity == ReceptiveFieldPolarity.ON: + RFs = self.ON_avg_responses[ + ..., window_start : window_start + window_len + ].mean(-1) pol = 1 - else: - RFs = self.OFF_avg_responses[..., window_start:window_start+window_len].mean(-1) + elif polarity == ReceptiveFieldPolarity.OFF: + RFs = self.OFF_avg_responses[ + ..., window_start : window_start + window_len + ].mean(-1) pol = -1 - RFs -= np.nanmean(RFs, axis=(1,2))[:, None, None] - RFs /= np.nanmax(abs(RFs), axis=(1,2))[:, None, None] - RFs[RFs < threshold] = 0. + else: + raise ValueError("Please enter 'ON' or 'OFF' for the polarity.") + RFs -= np.nanmean(RFs, axis=(1, 2))[:, None, None] + RFs /= np.nanmax(abs(RFs), axis=(1, 2))[:, None, None] + RFs[RFs < threshold] = 0.0 RFs *= pol return RFs - - def plot_RFs(self, title, cell_idx_lst, polarity = 'both', num_cols = 5, label_peak = True, contour_levels = []): - """ - To plot the RFs. + + def plot_RFs( + self, + title, + cell_idx_lst, + polarity="both", + num_cols=5, + label_peak=True, + contour_levels=[], + ): + """To plot the RFs. Parameters ---------- - title: str. The title of the figure. - cell_idx_lst: list or np.array. The cell numbers to be plotted. - polarity: str, 'ON', 'OFF', or 'both' (default). The polarity of the RFs to be plotted. - num_cols: int. The number of columns of the subplots. - label_peak: bool. If True, the pixel with max response will be labeled. - contour_levels: array-like. The contour levels to be plotted. + title : str + The title of the figure. + cell_idx_lst : list or np.array + The cell numbers to be plotted. + polarity : str + 'ON', 'OFF', or 'both' (default). The polarity of the RFs to be plotted. + num_cols : int + The number of columns of the subplots. + label_peak : bool + If True, the pixel with max response will be labeled. + contour_levels : array-like + The contour levels to be plotted. """ - if polarity not in ['ON', 'OFF', 'both']: - raise ValueError("Please enter 'ON', 'OFF', or 'both' for the polarity.") + polarity = ReceptiveFieldPolarity.from_(polarity) figsize_x = num_cols * 2 num_rows = np.ceil(len(cell_idx_lst) / num_cols).astype(int) - figsize_factor = (self.LSN_stim.shape[1] * num_rows) / (self.LSN_stim.shape[2] * num_cols) * 1.5 + figsize_factor = ( + (self.LSN_stim.shape[1] * num_rows) + / (self.LSN_stim.shape[2] * num_cols) + * 1.5 + ) figsize_y = figsize_x * figsize_factor - fig, axes = plt.subplots(num_rows, num_cols, figsize=(figsize_x, figsize_y)) + fig, axes = plt.subplots( + num_rows, num_cols, figsize=(figsize_x, figsize_y) + ) axes = axes.flatten() fig.tight_layout() - fig.subplots_adjust(wspace=0.1, hspace=0.2, top=0.95, bottom=0.01, left=0.002, right=0.998) - fig.suptitle(title, fontsize=30) + fig.subplots_adjust( + wspace=0.1, + hspace=0.2, + top=0.95, + bottom=0.01, + left=0.002, + right=0.998, + ) + fig.suptitle(title) for i, ax in enumerate(axes): - idx = cell_idx_lst[i] - if idx < len(cell_idx_lst) or idx < self.num_cells: - if polarity == 'ON': + if i < len(cell_idx_lst) and cell_idx_lst[i] < self.num_cells: + idx = cell_idx_lst[i] + if polarity == ReceptiveFieldPolarity.ON: pcol = ax.pcolormesh(self.ON_RFs[idx]) if label_peak: - ax.plot(self.ON_RF_peaks_yx[idx, 1] + 0.5, self.ON_RF_peaks_yx[idx, 0] + 0.5, '.r') - if polarity == 'OFF': + ax.plot( + self.ON_RF_peaks_yx[idx, 1] + 0.5, + self.ON_RF_peaks_yx[idx, 0] + 0.5, + ".r", + ) + if polarity == ReceptiveFieldPolarity.OFF: pcol = ax.pcolormesh(self.OFF_RFs[idx]) if label_peak: - ax.plot(self.OFF_RF_peaks_yx[idx, 1] + 0.5, self.OFF_RF_peaks_yx[idx, 0] + 0.5, '.b') - if polarity == 'both': - pcol = ax.pcolormesh(self.ON_RFs[idx] + self.OFF_RFs[idx]) # plus because OFF_RFs are already negative. + ax.plot( + self.OFF_RF_peaks_yx[idx, 1] + 0.5, + self.OFF_RF_peaks_yx[idx, 0] + 0.5, + ".b", + ) + if polarity == ReceptiveFieldPolarity.BOTH: + pcol = ax.pcolormesh( + self.ON_RFs[idx] + self.OFF_RFs[idx] + ) # plus because OFF_RFs are already negative. if label_peak: - ax.plot(self.ON_RF_peaks_yx[idx, 1] + 0.5, self.ON_RF_peaks_yx[idx, 0] + 0.5, '.r') - ax.plot(self.OFF_RF_peaks_yx[idx, 1] + 0.5, self.OFF_RF_peaks_yx[idx, 0] + 0.5, '.b') - ax.set_aspect('equal', 'box') - pcol.set_edgecolor('face') - pcol.set_clim([-1,1]) + ax.plot( + self.ON_RF_peaks_yx[idx, 1] + 0.5, + self.ON_RF_peaks_yx[idx, 0] + 0.5, + ".r", + ) + ax.plot( + self.OFF_RF_peaks_yx[idx, 1] + 0.5, + self.OFF_RF_peaks_yx[idx, 0] + 0.5, + ".b", + ) + ax.set_aspect("equal", "box") + pcol.set_edgecolor("face") + pcol.set_clim([-1, 1]) ax.set_xticks([]) ax.set_yticks([]) - ax.set_title("Cell {}".format(idx), fontsize=15, y=.99) + ax.set_title("Cell {}".format(idx), y=0.99) if contour_levels: - if polarity != 'ON': - ax.contour(-self.OFF_RFs[idx], contour_levels, colors = 'deepskyblue', origin = 'lower') - if polarity != 'OFF': - ax.contour(self.ON_RFs[idx], contour_levels, colors = 'gold', origin = 'lower') + if polarity != ReceptiveFieldPolarity.ON: + ax.contour( + -self.OFF_RFs[idx], + contour_levels, + colors="deepskyblue", + origin="lower", + ) + if polarity != ReceptiveFieldPolarity.OFF: + ax.contour( + self.ON_RFs[idx], + contour_levels, + colors="gold", + origin="lower", + ) else: ax.set_visible(False) - - def plot_pixel_avg_dff_traces(self, polarity, cell_idx, num_std=2, **pltargs): - """ - To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell. + return fig + + def plot_pixel_avg_dff_traces( + self, polarity, cell_idx, num_std=2, ax=None, **pltargs + ): + """To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell. Parameters ---------- - polarity: str, 'ON' or 'OFF'. The polarity of the responses to be plotted. - cell_idx: int. The cell index to be plotted. - num_std: int or float. Number of standard deviation from mean for plotting the horizontal span. - pltargs: other kwargs as for plt.plot(). + polarity : str + 'ON' or 'OFF'. The polarity of the responses to be plotted. + cell_idx : int + The cell index to be plotted. + num_std : int or float + Number of standard deviation from mean for plotting the horizontal span. + pltargs + Other kwargs as for plt.plot(). """ - if polarity not in ['ON', 'on', 'OFF', 'off']: + polarity = ReceptiveFieldPolarity.from_(polarity) + if polarity == ReceptiveFieldPolarity.ON: + avg_responses = self.ON_avg_responses + elif polarity == ReceptiveFieldPolarity.OFF: + avg_responses = self.OFF_avg_responses + else: raise ValueError("Please enter 'ON' or 'OFF' for the polarity.") - avg_responses = self.ON_avg_responses if polarity in ['ON', 'on'] else self.OFF_avg_responses - flat_response = avg_responses[cell_idx].reshape(-1, avg_responses.shape[3]) + flat_response = avg_responses[cell_idx].reshape( + -1, self.trial_fluo.num_timesteps + ) response_mean = np.nanmean(flat_response) response_std = np.nanstd(flat_response) lower_bound = response_mean - num_std * response_std upper_bound = response_mean + num_std * response_std - plt.figure(figsize=(15,10)) - frame_duration_sec = 1 / self._frame_rate_Hz - to_sec = lambda nframes: nframes * frame_duration_sec - start_sec = to_sec(-self.num_baseline_frames) - end_sec = to_sec(-self.num_baseline_frames + avg_responses.shape[3] - 1) - time_vec = np.arange(start_sec, end_sec+frame_duration_sec, frame_duration_sec) - for i in range(flat_response.shape[0]): - plt.plot(time_vec, flat_response[i], **pltargs) - trial_end_sec = to_sec(avg_responses.shape[3] - 2*self.num_baseline_frames - 1) - plt.axvspan(start_sec, 0, color='gray', alpha=0.3, label='Baseline before and after trial') - plt.axvspan(trial_end_sec, end_sec, color='gray', alpha=0.3) - integration_start_sec = to_sec(self._integration_window_start - self.num_baseline_frames) - integration_end_sec = integration_start_sec + to_sec(self._integration_window_len - 1) - plt.axvspan(integration_start_sec, integration_end_sec, color='lightblue', alpha=0.5, label='RF integration window') - plt.axhspan(lower_bound, upper_bound, color='lightgreen', alpha=0.5, label='Mean $\pm$ {} std'.format(num_std)) - plt.legend() - plt.title('Cell {} ({} responses)\nTrial-averaged DF/F traces within pixel'.format(cell_idx, polarity), fontsize = 30) - plt.xlabel('Time (sec)', fontsize = 20) - if self.is_use_dff_z_score: - plt.ylabel('DF/F (z-score)', fontsize = 20) + if ax is None: + ax = plt.gca() + if polarity == ReceptiveFieldPolarity.ON: + target = self._ON_stim_value + else: + target = self._OFF_stim_value + if self.is_use_positive_fluo: + single_cell_data = ( + self.trial_fluo.get_trials(self._trial_mask) + .get_cells(cell_idx) + .positive_part() + ) else: - plt.ylabel('DF/F', fontsize = 20) - + single_cell_data = self.trial_fluo.get_trials( + self._trial_mask + ).get_cells(cell_idx) + stimulus_highlighted = False # Add a flag so we can avoid highlighting the stimulus multiple times + for y in range(self.LSN_stim.shape[1]): + for x in range(self.LSN_stim.shape[2]): + trial_mean = single_cell_data.get_trials( + self.LSN_stim[self._trial_mask, y, x] == target + ).trial_mean() + if not stimulus_highlighted: + trial_mean.plot( + ax=ax, + fill_mean_pm_std=False, + highlight_non_baseline=True, + **pltargs + ) + stimulus_highlighted = True + else: + trial_mean.plot( + ax=ax, + fill_mean_pm_std=False, + highlight_non_baseline=False, + **pltargs + ) + integration_start_sec = ( + self._integration_window_start * self.trial_fluo.timestep_width + - self.trial_fluo._baseline_duration + ) + integration_end_sec = ( + integration_start_sec + + (self._integration_window_len - 1) + * self.trial_fluo.timestep_width + ) + ax.axvspan( + integration_start_sec, + integration_end_sec, + color="lightblue", + alpha=0.5, + label="RF integration window", + ) + ax.axhspan( + lower_bound, + upper_bound, + color="lightgreen", + alpha=0.5, + label="Mean $\pm$ {} std".format(num_std), + ) + ax.legend() + ax.set_title( + "Cell {} ({} responses)\nTrial-averaged DF/F traces within pixel".format( + cell_idx, polarity.name + ) + ) + return ax + def save_data(self, save_path): - raise NotImplementedError \ No newline at end of file + raise NotImplementedError + + +class ReceptiveFieldPolarity(Enum): + ON = 1 + OFF = 2 + BOTH = 3 + + @staticmethod + def from_(polarity): + """Coerce `polarity` to a ReceptiveFieldPolarity.""" + if isinstance(polarity, ReceptiveFieldPolarity): + return polarity + elif polarity.upper() == "ON": + return ReceptiveFieldPolarity.ON + elif polarity.upper() == "OFF": + return ReceptiveFieldPolarity.OFF + elif polarity.upper() == "ANY": + pol_value = ReceptiveFieldPolarity._get_any() + return ( + ReceptiveFieldPolarity.ON + if pol_value == 1 + else ReceptiveFieldPolarity.OFF + ) + elif polarity.upper() == "BOTH": + return ReceptiveFieldPolarity.BOTH + else: + raise ValueError("Polarity must be 'ON', 'OFF', 'ANY' or 'BOTH'.") + + def _get_any(): + return np.random.randint(1, 3) diff --git a/oscopetools/adjust_stim.py b/oscopetools/adjust_stim.py index 16fd81e..9b53681 100644 --- a/oscopetools/adjust_stim.py +++ b/oscopetools/adjust_stim.py @@ -8,35 +8,70 @@ import numpy as np -def correct_LSN_stim_by_eye_pos(LSN_stim, LSN_stim_table, eye_tracking, yx_ref = None, stim_size = 10, stim_background_value = 127): + +def correct_LSN_stim_by_eye_pos( + LSN_stim, + LSN_stim_table, + eye_tracking, + yx_ref=None, + stim_size=10, + stim_background_value=127, +): """ To correct the LSN stimulus array by using the eye position averaged within trial. Parameters ---------- - LSN_stim: 3d np.array. The LSN stimulus array, shape = (num_trials, ylen, xlen). - LSN_stim_table: pd.DataFrame. The stim_table of loccally sparse noise. - eye_tracking: pd.DataFrame. The eye tracking data. - yx_ref: list, np.array, or None. The reference y- and x-positions (hypothetical eye position looking at the center of the - stimulus monitor), where corrected_stim_pos = original_stim_pos - yx_ref. If None, the mean y- and x-positions of the - eye during LSN stimuli will be the yx_ref. - stim_size: int. The side length of the stimulus in degree. - stim_background_value: int. The background value (gray) of the LSN stimulus. + LSN_stim : 3d np.array + The LSN stimulus array, shape = (num_trials, ylen, xlen). + LSN_stim_table : pd.DataFrame + The stim_table of loccally sparse noise. + eye_tracking : EyeTracking + The eye tracking data. + yx_ref : list, np.array, or None, default None + The reference y- and x-positions (hypothetical eye position looking at the center of the stimulus monitor), + where corrected_stim_pos = original_stim_pos - yx_ref. If None, the mean y- and x-positions of the + eye during LSN stimuli will be the yx_ref. + stim_size : int, default 10 + The side length of the stimulus in degree. + stim_background_value : int, default 127 + The background value (gray) of the LSN stimulus. Returns ------- - corrected_stim_arr: 3d np.array. The corrected LSN stimulus array according to the eye positions averaged within trial. - isvalid_eye_pos: bool vector-like. Boolean array showing valid eye position (not NaN). Use corrected_stim_arr[isvalid_eye_pos] - to get the trials with valid eye position. - yx_ref: 1d np.array. The reference y- and x-positions used for correcting the LSN stimulus array. + corrected_stim_arr : 3d np.array + The corrected LSN stimulus array according to the eye positions averaged within trial. + isvalid_eye_pos : bool vector-like + Boolean array showing valid eye position (not NaN). Use corrected_stim_arr[isvalid_eye_pos] + to get the trials with valid eye position. + yx_ref : 1d np.array + The reference y- and x-positions used for correcting the LSN stimulus array. """ - yx_eye_pos = get_trial_yx_eye_pos(eye_tracking, LSN_stim_table) - if isinstance(yx_ref, type(None)): + eye_trials = eye_tracking.cut_by_trials(LSN_stim_table) + eye_trial_mean = eye_trials.trial_mean(within_trial=True, ignore_nan=True) + yx_eye_pos = np.squeeze( + np.dstack( + [eye_trial_mean.data.y_pos_deg, eye_trial_mean.data.x_pos_deg] + ) + ) + if yx_ref is None: yx_ref = np.nanmean(yx_eye_pos, 0) - border = np.ceil(np.nanmax(abs(yx_eye_pos - yx_ref)) / stim_size).astype(int) + 1 # + 1 for ensuring that the border is wide enough - corrected_stim_arr = np.zeros((LSN_stim_table.shape[0], LSN_stim.shape[1]+2*border, LSN_stim.shape[2]+2*border), dtype = 'int32') + border = ( + np.ceil(np.nanmax(abs(yx_eye_pos - yx_ref)) / stim_size).astype(int) + + 1 + ) # + 1 for ensuring that the border is wide enough + corrected_stim_arr = np.zeros( + ( + LSN_stim_table.shape[0], + LSN_stim.shape[1] + 2 * border, + LSN_stim.shape[2] + 2 * border, + ), + dtype="int32", + ) corrected_stim_arr += stim_background_value - corrected_stim_arr[:, border:-border, border:-border] = LSN_stim[LSN_stim_table['Frame']] + corrected_stim_arr[:, border:-border, border:-border] = LSN_stim[ + LSN_stim_table["Frame"] + ] isvalid_eye_pos = [] for i in range(LSN_stim_table.shape[0]): if np.isnan(yx_eye_pos[i]).any(): @@ -44,26 +79,14 @@ def correct_LSN_stim_by_eye_pos(LSN_stim, LSN_stim_table, eye_tracking, yx_ref = continue else: isvalid_eye_pos.append(True) - yx_deviation = np.around((yx_eye_pos[i]-yx_ref) / stim_size).astype(int) - corrected_stim_arr[i] = np.roll(corrected_stim_arr[i], (yx_deviation[0], yx_deviation[1]), (0, 1)) - return corrected_stim_arr[:, border:-border, border:-border], np.array(isvalid_eye_pos), yx_ref - -def get_trial_yx_eye_pos(eye_tracking, stim_table): - """ - To get the y- and x-position of the eye averaed within trial. - - Parameters - ---------- - eye_tracking: pd.DataFrame. The eye tracking data. - stim_table: pd.DataFrame. The stimulus table. - - Returns - ------- - yx_eye_pos: 2d np.array. The y- and x-positions of the eye averaged within trial, shape = (num_trials, 2). - """ - yx_eye_pos = np.zeros((stim_table.shape[0], 2), dtype = 'float32') - for trial_no in range(stim_table.shape[0]): - mean_y = eye_tracking['y_pos_deg'][int(stim_table['Start'][trial_no]):int(stim_table['End'][trial_no])].mean() - mean_x = eye_tracking['x_pos_deg'][int(stim_table['Start'][trial_no]):int(stim_table['End'][trial_no])].mean() - yx_eye_pos[trial_no] = [mean_y, mean_x] - return yx_eye_pos \ No newline at end of file + yx_deviation = np.around((yx_eye_pos[i] - yx_ref) / stim_size).astype( + int + ) + corrected_stim_arr[i] = np.roll( + corrected_stim_arr[i], (yx_deviation[0], yx_deviation[1]), (0, 1) + ) + return ( + corrected_stim_arr[:, border:-border, border:-border], + np.array(isvalid_eye_pos), + yx_ref, + ) From 5cea92a64323987d9e031e2c88d76a8a6647f1d9 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Thu, 30 Jul 2020 06:47:19 +0200 Subject: [PATCH 42/68] Added TrialEyeTracking --- oscopetools/read_data/dataset_objects.py | 476 +++++++++++++++++++---- 1 file changed, 390 insertions(+), 86 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 6bfb922..c0eed22 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -1,10 +1,10 @@ """Classes for interacting with OpenScope datasets.""" __all__ = ( - 'RawFluorescence', - 'TrialFluorescence', - 'EyeTracking', - 'RunningSpeed', - 'robust_range', + "RawFluorescence", + "TrialFluorescence", + "EyeTracking", + "RunningSpeed", + "robust_range", ) from abc import ABC, abstractmethod @@ -49,13 +49,13 @@ def _try_parse_positionals_as_slice_like(*args): """ flattened_args = np.asarray(args).flatten() if len(flattened_args) == 0: - raise ValueError('Empty positional arguments') + raise ValueError("Empty positional arguments") elif _is_bool(flattened_args[0]): - raise SliceParseError('Cannot parse bool positionals as slice.') + raise SliceParseError("Cannot parse bool positionals as slice.") elif int(flattened_args[0]) != flattened_args[0]: raise TypeError( - 'Expected positionals to be bool-like or int-like, ' - 'got type {} instead'.format(flattened_args.dtype) + "Expected positionals to be bool-like or int-like, " + "got type {} instead".format(flattened_args.dtype) ) elif (len(flattened_args) > 0) and (len(flattened_args) <= 2): # Positional arguments are a valid slice-like int or pair of ints @@ -63,7 +63,7 @@ def _try_parse_positionals_as_slice_like(*args): else: # Case: positionals are not bool and are of the wrong length raise ValueError( - 'Positionals of length {} cannot be parsed as slice-like'.format( + "Positionals of length {} cannot be parsed as slice-like".format( len(flattened_args) ) ) @@ -76,15 +76,15 @@ def _is_bool(x): def _validate_vector_mask_length(mask, expected_length): if np.ndim(mask) != 1: raise ValueError( - 'Expected mask to be vector-like, got ' - '{}D array instead'.format(np.ndim(mask)) + "Expected mask to be vector-like, got " + "{}D array instead".format(np.ndim(mask)) ) mask = np.asarray(mask).flatten() if len(mask) != expected_length: raise ValueError( - 'Expected mask of length {}, got mask of ' - 'length {} instead.'.format(len(mask), expected_length) + "Expected mask of length {}, got mask of " + "length {} instead.".format(len(mask), expected_length) ) return mask @@ -101,30 +101,30 @@ def _get_vector_mask_from_range(values_to_mask, start, stop=None): def robust_range( - values, half_width=2, center='median', spread='interquartile_range' + values, half_width=2, center="median", spread="interquartile_range" ): """Get a range around a center point robust to outliers.""" - if center == 'median': + if center == "median": center_val = np.nanmedian(values) - elif center == 'mean': + elif center == "mean": center_val = np.nanmean(values) else: raise ValueError( - 'Unrecognized `center` {}, expected ' - '`median` or `mean`.'.format(center) + "Unrecognized `center` {}, expected " + "`median` or `mean`.".format(center) ) - if spread in ('interquartile_range', 'iqr'): + if spread in ("interquartile_range", "iqr"): lower_quantile, upper_quantile = np.percentile( _stripnan(values), (25, 75) ) spread_val = upper_quantile - lower_quantile - elif spread in ('standard_deviation', 'std'): + elif spread in ("standard_deviation", "std"): spread_val = np.nanstd(values) else: raise ValueError( - 'Unrecognized `spread` {}, expected ' - '`interquartile_range` (`iqr`) or `standard_deviation` (`std`)'.format( + "Unrecognized `spread` {}, expected " + "`interquartile_range` (`iqr`) or `standard_deviation` (`std`)".format( spread ) ) @@ -247,7 +247,7 @@ def time_vec(self): ) assert len(time_vec) == len( self - ), 'Length of time_vec ({}) does not match instance length ({})'.format( + ), "Length of time_vec ({}) does not match instance length ({})".format( len(time_vec), len(self) ) return time_vec @@ -352,7 +352,7 @@ def get_trials(self, *args): mask = _validate_vector_mask_length(args[0], self.num_trials) else: raise ValueError( - 'Expected a single mask argument, got {}'.format(len(args)) + "Expected a single mask argument, got {}".format(len(args)) ) return self._get_trials_from_mask(mask) @@ -441,6 +441,7 @@ def __init__(self, fluorescence_array, timestep_width): self.cell_vec = np.arange(0, self.num_cells) self.is_z_score = False self.is_dff = False + self.is_positive_clipped = False @property def num_timesteps(self): @@ -468,7 +469,7 @@ def get_cells(self, *args): mask = _validate_vector_mask_length(args[0], self.num_cells) else: raise ValueError( - 'Expected a single mask argument, got {}'.format(len(args)) + "Expected a single mask argument, got {}".format(len(args)) ) return self._get_cells_from_mask(mask) @@ -538,6 +539,15 @@ def _get_cells_from_mask(self, mask): return cell_subset + def positive_part(self): + """Set the negative part of data to zero.""" + if self.is_positive_clipped: + raise ValueError("Instance is already positive clipped.") + fluo_copy = self.copy(read_only=False) + fluo_copy.data[fluo_copy.data < 0] = 0 + fluo_copy.is_positive_clipped = True + return fluo_copy + class RawFluorescence(Fluorescence): """Fluorescence timeseries from a full imaging session. @@ -555,14 +565,19 @@ def __init__(self, fluorescence_array, timestep_width): def z_score(self): """Convert to Z-score.""" if self.is_z_score: - raise ValueError('Instance is already a Z-score') + raise ValueError("Instance is already a Z-score") else: z_score = self.data - self.data.mean(axis=1)[:, np.newaxis] z_score /= z_score.std(axis=1)[:, np.newaxis] self.data = z_score self.is_z_score = True - def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_baseline=False): + def cut_by_trials( + self, + trial_timetable, + num_baseline_frames=None, + both_ends_baseline=False, + ): """Divide fluorescence traces up into equal-length trials. Parameters @@ -576,9 +591,9 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_bas trial_fluorescence : TrialFluorescence """ - if ('Start' not in trial_timetable) or ('End' not in trial_timetable): + if ("Start" not in trial_timetable) or ("End" not in trial_timetable): raise ValueError( - 'Could not find `Start` and `End` in trial_timetable.' + "Could not find `Start` and `End` in trial_timetable." ) if (num_baseline_frames is None) or (num_baseline_frames < 0): @@ -588,16 +603,19 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_bas trials = [] num_frames = [] for start, end in zip( - trial_timetable['Start'], trial_timetable['End'] + trial_timetable["Start"], trial_timetable["End"] ): # Coerce `start` and `end` to ints if possible if (int(start) != start) or (int(end) != end): raise ValueError( - 'Expected trial start and end frame numbers' - ' to be ints, got {} and {} instead'.format(start, end) + "Expected trial start and end frame numbers" + " to be ints, got {} and {} instead".format(start, end) ) start = max(int(start) - num_baseline_frames, 0) - end = int(end) + num_baseline_frames if both_ends_baseline else int(end) + if both_ends_baseline: + end = int(end) + num_baseline_frames + else: + end = int(end) trials.append(self.data[..., start:end]) num_frames.append(end - start) @@ -606,8 +624,8 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_bas min_num_frames = min(num_frames) if not all([dur == min_num_frames for dur in num_frames]): warnings.warn( - 'Truncating all trials to shortest duration {} ' - 'frames (longest trial is {} frames)'.format( + "Truncating all trials to shortest duration {} " + "frames (longest trial is {} frames)".format( min_num_frames, max(num_frames) ) ) @@ -616,14 +634,14 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_bas # Try to get a vector of trial numbers try: - trial_num = trial_timetable['trial_num'] + trial_num = trial_timetable["trial_num"] except KeyError: try: trial_num = trial_timetable.index.tolist() except AttributeError: warnings.warn( - 'Could not get trial_num from trial_timetable. ' - 'Falling back to arange.' + "Could not get trial_num from trial_timetable. " + "Falling back to arange." ) trial_num = np.arange(0, len(trials)) @@ -636,6 +654,7 @@ def cut_by_trials(self, trial_timetable, num_baseline_frames=None, both_ends_bas trial_fluorescence._baseline_duration = ( num_baseline_frames * self.timestep_width ) + trial_fluorescence._both_ends_baseline = both_ends_baseline # Check that trial_fluorescence was constructed correctly. assert trial_fluorescence.num_cells == self.num_cells @@ -667,6 +686,7 @@ def __init__(self, fluorescence_array, trial_num, timestep_width): super().__init__(fluorescence_array, timestep_width) self._baseline_duration = 0 + self._both_ends_baseline = False self._trial_num = np.asarray(trial_num) @property @@ -674,26 +694,50 @@ def time_vec(self): time_vec_without_baseline = super().time_vec return time_vec_without_baseline - self._baseline_duration - def plot(self, ax=None, **pltargs): + def plot( + self, + ax=None, + fill_mean_pm_std=True, + highlight_non_baseline=False, + **pltargs + ): if ax is None: ax = plt.gca() if self.num_cells == 1: # If there is only one cell, make a line plot - alpha = pltargs.pop('alpha', 1) + alpha = pltargs.pop("alpha", 1) fluo_mean = self.trial_mean().data[0, 0, :] fluo_std = self.trial_std().data[0, 0, :] - ax.fill_between( - self.time_vec, - fluo_mean - fluo_std, - fluo_mean + fluo_std, - label='Mean $\pm$ SD', - alpha=alpha * 0.6, - **pltargs - ) + if fill_mean_pm_std: + ax.fill_between( + self.time_vec, + fluo_mean - fluo_std, + fluo_mean + fluo_std, + label="Mean $\pm$ SD", + alpha=alpha * 0.6, + **pltargs, + ) ax.plot(self.time_vec, fluo_mean, alpha=alpha, **pltargs) - ax.set_xlabel('Time (s)') + if highlight_non_baseline: + stim_start = self.time_vec[0] + self._baseline_duration + if self._both_ends_baseline: + stim_end = self.time_vec[-1] - self._baseline_duration + else: + stim_end = self.time_vec[-1] + ax.axvspan( + stim_start, + stim_end, + color="gray", + alpha=0.3, + label="Stimulus", + ) + ax.set_xlabel("Time (s)") + if self.is_z_score: + ax.set_ylabel("DF/F (Z-score)") + else: + ax.set_ylabel("DF/F") ax.legend() else: # If there are many cells, just show the mean as a matrix. @@ -770,38 +814,161 @@ def trial_std(self, ignore_nan=False): class EyeTracking(TimeseriesDataset): - _x_pos_name = 'x_pos_deg' - _y_pos_name = 'y_pos_deg' + _eye_area_name = "eye_area" + _pupil_area_name = "pupil_area" + _x_pos_name = "x_pos_deg" + _y_pos_name = "y_pos_deg" def __init__( self, tracked_attributes: pd.DataFrame, timestep_width: float ): super().__init__(timestep_width) self.data = pd.DataFrame(tracked_attributes) + self._is_trial = False @property def num_timesteps(self): """Number of timesteps in EyeTracking dataset.""" - return self.data.shape[0] + if self._is_trial: + if self._within_trial: + return 1 + else: + return len(self.data.iloc[0, 0]) + else: + return self.data.shape[0] def get_frame_range(self, start: int, stop: int = None): window = self.copy() if stop is not None: - window.data = window.data.iloc[start:stop, :].copy() + if self._is_trial: + if not self._within_trial: + window.data = window.data.applymap( + lambda x: x[start:stop] + ).copy() + else: + window.data = window.data.iloc[start:stop, :].copy() else: - window.data = window.data.iloc[start, :].copy() + if self._is_trial: + if not self._within_trial: + window.data = window.data.applymap( + lambda x: x[start : start + 1] + ).copy() + else: + window.data = window.data.iloc[start, :].copy() return window - def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): + def cut_by_trials( + self, + trial_timetable, + num_baseline_frames=None, + both_ends_baseline=False, + ): + """Divide eye tracking parameters up into equal-length trials. + + Parameters + ---------- + trial_timetable : pd.DataFrame-like + A DataFrame-like object with 'Start' and 'End' items for the start + and end frames of each trial, respectively. + + Returns + ------- + trial_eyetracking : TrialEyeTracking + + """ + if ("Start" not in trial_timetable) or ("End" not in trial_timetable): + raise ValueError( + "Could not find `Start` and `End` in trial_timetable." + ) + + if (num_baseline_frames is None) or (num_baseline_frames < 0): + num_baseline_frames = 0 + + # Slice one EyeTracking parameter up into trials. + # 4 columns in total: col_0, col_1, col_2, and col_3, + # corresponding to eye_area, pupil_area, x_pos_deg, and y_pos_deg, + # Noneed to worry even if the columns are switched. + col_0 = [] + col_1 = [] + col_2 = [] + col_3 = [] + num_frames = [] + for start, end in zip( + trial_timetable["Start"], trial_timetable["End"] + ): + # Coerce `start` and `end` to ints if possible + if (int(start) != start) or (int(end) != end): + raise ValueError( + "Expected trial start and end frame numbers" + " to be ints, got {} and {} instead".format(start, end) + ) + start = max(int(start) - num_baseline_frames, 0) + if both_ends_baseline: + end = int(end) + num_baseline_frames + else: + end = int(end) + + col_0.append(self.data.iloc[start:end, 0].values) + col_1.append(self.data.iloc[start:end, 1].values) + col_2.append(self.data.iloc[start:end, 2].values) + col_3.append(self.data.iloc[start:end, 3].values) + num_frames.append(end - start) + + # Create a new pd.DataFrame with trials as rows + list_of_tuples = list(zip(col_0, col_1, col_2, col_3)) + trials = pd.DataFrame(list_of_tuples, columns=self.data.columns) + + # Truncate all trials to the same length if necessary + min_num_frames = min(num_frames) + if not all([dur == min_num_frames for dur in num_frames]): + warnings.warn( + "Truncating all trials to shortest duration {} " + "frames (longest trial is {} frames)".format( + min_num_frames, max(num_frames) + ) + ) + trials = trials.applymap(lambda x: x[:min_num_frames]) + + # Try to get a vector of trial numbers + try: + trial_num = trial_timetable["trial_num"] + except KeyError: + try: + trial_num = trial_timetable.index.tolist() + except AttributeError: + warnings.warn( + "Could not get trial_num from trial_timetable. " + "Falling back to arange." + ) + trial_num = np.arange(0, len(trials)) + + # Construct TrialEyeTracking and return it. + trial_eyetracking = TrialEyeTracking( + trials, trial_num, self.timestep_width, + ) + trial_eyetracking._baseline_duration = ( + num_baseline_frames * self.timestep_width + ) + trial_eyetracking._both_ends_baseline = both_ends_baseline + + # Check that trial_eyetracking was constructed correctly. + assert trial_eyetracking.num_timesteps == min_num_frames + assert trial_eyetracking.num_trials == len(trials) + + return trial_eyetracking + + def plot( + self, channel="position", robust_range_=False, ax=None, **pltargs + ): """Make a diagnostic plot of eyetracking data.""" ax = super().plot(ax, **pltargs) # Check whether the `channel` argument is valid - if channel not in self.data.columns and channel != 'position': + if channel not in self.data.columns and channel != "position": raise ValueError( - 'Got unrecognized channel `{}`, expected one of ' - '{} or `position`'.format(channel, self.data.columns.tolist()) + "Got unrecognized channel `{}`, expected one of " + "{} or `position`".format(channel, self.data.columns.tolist()) ) if channel in self.data.columns: @@ -810,49 +977,61 @@ def plot(self, channel='position', robust_range_=False, ax=None, **pltargs): *robust_range( self.data[channel], half_width=1.5, - center='median', - spread='iqr' + center="median", + spread="iqr", ), - color='gray', - label='Median $\pm$ 1.5 IQR', + color="gray", + label="Median $\pm$ 1.5 IQR", alpha=0.5, ) ax.legend() ax.plot(self.time_vec, self.data[channel], **pltargs) - ax.set_xlabel('Time (s)') + ax.set_xlabel("Time (s)") if robust_range_: - ax.set_ylim(robust_range(self.data[channel], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + ax.set_ylim( + robust_range( + self.data[channel], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) - elif channel == 'position': - if pltargs.pop('style', None) in ['contour', 'density']: + elif channel == "position": + if pltargs.pop("style", None) in ["contour", "density"]: x = self.data[self._x_pos_name] y = self.data[self._y_pos_name] mask = np.isnan(x) | np.isnan(y) if any(mask): warnings.warn( - 'Dropping {} NaN entries in order to estimate ' - 'density.'.format(sum(mask)) + "Dropping {} NaN entries in order to estimate " + "density.".format(sum(mask)) ) sns.kdeplot(x[~mask], y[~mask], ax=ax, **pltargs) else: ax.plot( self.data[self._x_pos_name], self.data[self._y_pos_name], - **pltargs + **pltargs, ) if robust_range_: - ax.set_ylim(robust_range(self.data[self._y_pos_name], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) - ax.set_xlim(robust_range(self.data[self._x_pos_name], - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH)) + ax.set_ylim( + robust_range( + self.data[self._y_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) + ax.set_xlim( + robust_range( + self.data[self._x_pos_name], + half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, + ) + ) else: raise NotImplementedError( - 'Plotting for channel {} is not implemented.'.format(channel) + "Plotting for channel {} is not implemented.".format(channel) ) return ax @@ -862,6 +1041,135 @@ def apply_quality_control(self, inplace=False): raise NotImplementedError +class TrialEyeTracking(EyeTracking, TrialDataset): + """EyeTracking timeseries divided into trials.""" + + def __init__(self, eye_tracking_df, trial_num, timestep_width): + eye_tracking_df = pd.DataFrame(eye_tracking_df) + assert eye_tracking_df.ndim == 2 + assert eye_tracking_df.shape[0] == len(trial_num) + + super().__init__(eye_tracking_df, timestep_width) + + self._is_trial = True + self._baseline_duration = 0 + self._both_ends_baseline = False + self._trial_num = np.asarray(trial_num) + self._within_trial = False + + def _get_trials_from_mask(self, mask): + trial_subset = self.copy() + trial_subset._trial_num = trial_subset._trial_num[mask].copy() + trial_subset.data = trial_subset.data[mask].copy() + + return trial_subset + + def trial_mean(self, within_trial=True, ignore_nan=False): + """Get the mean eye parameters within or across trials. + + Parameters + ---------- + within_trial : bool, default True + Whether to compute within_trial_mean or across_trial_mean. + ignore_nan : bool, default False + Whether to return the `mean` or `nanmean`. + + Returns + ------- + trial_mean : TrialEyeTracking + A new `TrialEyeTracking` object with the mean within/across trials. + + See Also + -------- + `trial_std()` + + """ + trial_mean = self.copy() + if within_trial: + trial_mean._within_trial = True + else: + trial_mean._trial_num = np.asarray([np.nan]) + + if ignore_nan: + if within_trial: + trial_mean.data = self.data.applymap(np.nanmean) + else: + trial_mean.data = self._across_trials_operation(np.nanmean) + else: + if within_trial: + trial_mean.data = self.data.applymap(np.mean) + else: + trial_mean.data = self._across_trials_operation(np.mean) + + return trial_mean + + def trial_std(self, within_trial=True, ignore_nan=False): + """Get the standard deviation of the eye parameters within or across trials. + + Parameters + ---------- + within_trial : bool, default True + Whether to compute within_trial_std or across_trial_std. + ignore_nan : bool, default False + Whether to return the `std` or `nanstd`. + + Returns + ------- + trial_std : TrialEyeTracking + A new `TrialEyeTracking` object with the standard deviation within/ + across trials. + + See Also + -------- + `trial_mean()` + + """ + trial_std = self.copy() + if within_trial: + trial_std._within_trial = True + else: + trial_std._trial_num = np.asarray([np.nan]) + + if ignore_nan: + if within_trial: + trial_std.data = self.data.applymap(np.nanstd) + else: + trial_std.data = self._across_trials_operation(np.nanstd) + else: + if within_trial: + trial_std.data = self.data.applymap(np.std) + else: + trial_std.data = self._across_trials_operation(np.std) + + return trial_std + + def _across_trials_operation(self, func): + """Perform operation across trials (axis=0) for the pd.DataFrame data. + + Parameters + ---------- + func : function + Function for performing the operation along axis 0. + + Returns + ------- + func_df : pd.DataFrame + Dataframe that contains the results. + + """ + trials = [] + for i in range(self.data.shape[0]): + eye_param = [] + for j in range(self.data.shape[1]): + eye_param.append(self.data.iloc[i, j].tolist()) + trials.append(eye_param) + trials = np.asarray(trials) + func_arr = func(trials, axis=0) + eye_param_lst = [list(func_arr)] + func_df = pd.DataFrame(eye_param_lst, columns=self.data.columns) + return func_df + + class RunningSpeed(TimeseriesDataset): def __init__(self, running_speed: np.ndarray, timestep_width: float): running_speed = np.asarray(running_speed) @@ -891,26 +1199,22 @@ def plot(self, robust_range_=False, ax=None, **pltargs): if robust_range_: ax.axhspan( *robust_range( - self.data, - half_width=1.5, - center='median', - spread='iqr' + self.data, half_width=1.5, center="median", spread="iqr" ), - color='gray', - label='Median $\pm$ 1.5 IQR', + color="gray", + label="Median $\pm$ 1.5 IQR", alpha=0.5, ) ax.legend() ax.plot(self.time_vec, self.data, **pltargs) - ax.set_xlabel('Time (s)') - ax.set_ylabel('Running speed') + ax.set_xlabel("Time (s)") + ax.set_ylabel("Running speed") if robust_range_: ax.set_ylim( robust_range( - self.data, - half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH + self.data, half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH ) ) From 543ab4ea5944ce38963b0cbdd5fb69aba267c982 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Thu, 30 Jul 2020 07:13:53 +0200 Subject: [PATCH 43/68] Add files via upload --- analysis/compute_and_plot_RFs.ipynb | 367 ++++++++++++++++++++++++++++ 1 file changed, 367 insertions(+) create mode 100644 analysis/compute_and_plot_RFs.ipynb diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb new file mode 100644 index 0000000..6e4ec29 --- /dev/null +++ b/analysis/compute_and_plot_RFs.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:25:28.028408Z", + "start_time": "2020-07-30T04:25:27.174293Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib as mpl\n", + "from oscopetools.LSN_analysis import LSN_analysis\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:25:28.651599Z", + "start_time": "2020-07-30T04:25:28.646742Z" + } + }, + "outputs": [], + "source": [ + "mpl.rcParams['figure.figsize'] = [15,10]\n", + "mpl.rcParams['font.size'] = 20\n", + "mpl.rcParams['figure.titlesize'] = 'x-large'\n", + "mpl.rcParams['axes.titlesize'] = 'medium'\n", + "mpl.rcParams['axes.labelsize'] = 'small'\n", + "mpl.rcParams['legend.fontsize'] = 'xx-small'\n", + "mpl.rcParams['xtick.labelsize'] = 'xx-small'\n", + "mpl.rcParams['ytick.labelsize'] = 'xx-small'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## To initialize the analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:25:36.015226Z", + "start_time": "2020-07-30T04:25:31.134480Z" + } + }, + "outputs": [], + "source": [ + "# The path to the data file.\n", + "datafile_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround_976474801_data.h5'\n", + "# The path to the LSN stimulus npy file.\n", + "LSN_stim_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/openscope_surround-master/stimulus/sparse_noise_8x14.npy'\n", + "num_baseline_frames = 3 # int or None. The number of baseline frames before the start and after the end of a trial.\n", + "use_dff_z_score = False # True or False. If True, the cell responses will be converted to z-score before analysis.\n", + "\n", + "LSN_data = LSN_analysis(datafile_path, LSN_stim_path, num_baseline_frames, use_dff_z_score)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## To get an overview of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:25:40.882536Z", + "start_time": "2020-07-30T04:25:40.878063Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround_976474801_data.h5\n", + "ON LSN stimulus value: 255\n", + "OFF LSN stimulus value: 0\n", + "Background LSN value: 127\n", + "LSN stimulus size: 10 degree\n", + "Number of cells: 240\n", + "Use DF/F z-score: False\n", + "Use corrected LSN: False\n", + "Use only valid eye positions: False\n", + "Use only positive fluorescence responses: False\n" + ] + } + ], + "source": [ + "print(LSN_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Different conditions for computing ON-OFF responses and RFs\n", + "\n", + "- Other variables (RFs, ON/OFF responses, etc.) will be automatically updated.\n", + "- The RF arrays for RF plotting will also be automatically updated with default RF parameters:\n", + " - threshold = 0\n", + " - window_start = None (the start frame of the stimulus will be used)\n", + " - window_len = None (the stimulus trial length in frames will be used)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T03:58:17.524670Z", + "start_time": "2020-07-30T03:58:17.286905Z" + } + }, + "outputs": [], + "source": [ + "# If True, the LSN stimulus corrected by eye positions will be used. \n", + "# Otherwise, the original LSN stimulus will be used.\n", + "correct_LSN = True\n", + "LSN_data.correct_LSN_by_eye_pos(correct_LSN)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T03:44:49.129003Z", + "start_time": "2020-07-30T03:44:48.718561Z" + } + }, + "outputs": [], + "source": [ + "# If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used.\n", + "use_only_valid_eye_pos = True\n", + "LSN_data.use_valid_eye_pos(use_only_valid_eye_pos)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T03:44:46.396178Z", + "start_time": "2020-07-30T03:44:45.990706Z" + } + }, + "outputs": [], + "source": [ + "# If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses.\n", + "use_only_positive_responses = True\n", + "LSN_data.use_positive_fluo(use_only_positive_responses)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## RF plotting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting parameters\n", + "\n", + "- The RFs are computed during initialization with default parameters. \n", + "- The threshold and integration window for RFs can be changed.\n", + "- To compute the RFs by using different thresholds (default = 0) and different integration windows by adjusting:\n", + " - window_start:\n", + " The start of the window in frame. If there are baseline frames, then index $0$ to $n-1$ are the first $n$ baseline frames. The stimulus starts at the $n$th frame.\n", + " - window_len: \n", + " The length of the integration window in frames. If None, the stimulus trial length in frames will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:26:34.676148Z", + "start_time": "2020-07-30T04:26:34.669444Z" + } + }, + "outputs": [], + "source": [ + "threshold = 0. # int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0.\n", + "window_start = 5 # int or None. The start index (within a trial) of the integration window for computing the RFs.\n", + "window_len = 7 # int or None. The length of the integration window in frames for computing the RFs.\n", + "LSN_data.get_RFs(threshold, window_start, window_len)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell.\n", + "\n", + "- To visualize the integration window of the RF (blue) relative to the stimulus (gray).\n", + "- Each line plot is the average ON or OFF response of the selected cell on a square pixel of the LSN stimulus.\n", + "- Other keyword arguments can be added for plt.plot()." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:26:44.643252Z", + "start_time": "2020-07-30T04:26:43.646534Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "polarity = 'ON' # 'ON' or 'OFF'. The polarity of the responses to be plotted.\n", + "cell_idx = 0 # The cell index to be plotted.\n", + "num_std = 2 # int or float. Number of standard deviation from mean for plotting the horizontal span.\n", + "ax = LSN_data.plot_pixel_avg_dff_traces(polarity, cell_idx, num_std)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### To plot the RFs\n", + "\n", + "- To plot the RF of selected cells using the integration window set above.\n", + "- Choose the polarity (ON, OFF, or both) to be plotted." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-07-30T04:27:27.146884Z", + "start_time": "2020-07-30T04:27:19.503583Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABawAAASzCAYAAACRqX/HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzddXgc1/Xw8e+Z3RUz2DIz27Ed27Edh7lhaKjhNE25SdP29xbTlLlNKW04bZOGsWF0OI5jx8wMYmYt3fePWdmyLGlG9kqrlc7nefZZaefuzNnZswN37twrxhiUUkoppZRSSimllFJKqVizYh2AUkoppZRSSimllFJKKQVaYa2UUkoppZRSSimllFKqj9AKa6WUUkoppZRSSimllFJ9glZYK6WUUkoppZRSSimllOoTtMJaKaWUUkoppZRSSimlVJ+gFdZKKaWUUkoppZRSSiml+gStsFZKKaWUUqoTInKbiJjIY3Ss44kWEZkkIveJyHYRaW7zGa+NTL+2zWsn9GAcUVu/bebzQHSiU0oppZRSseCNdQBKKaWUUmq/SKXd9k4mB4FaYBvwPnCvMWZ1L4Wm+gkRmYmdP6mxjkUppZRSSqn2tIW1UkoppVT88AI5wFzgJmCFiPwitiHFH22Jy6+xK6tDwPeAo4EZkcczsQtLKaWUUkopbWGtlFJKKdWXfQJc1+b/ZGAscDFwEXbjg++LSLEx5q8xiK/fM8bcBtwW4zCiRkR8wImRf58xxvy6o3LGmAeAB3opLKWUUkoppfbRFtZKKaWUUn1XgzFmTZvHUmPMo8aYzwJfalPuVhHxxCpIFVfygMTI3xtjGYhSSimllFId0QprpZRSSqn4dBf7+7rOA+bEMBYVPxLb/B2IWRRKKaWUUkp1QiuslVJKKaXikDHGAMvavDSyq/IicrSI3C0iG0WkVkSaRGS7iDwkIie4WaaIWCJysYg8Enlvg4i0iMguEXleRL4hInldvD9BRL4gIi+IyN7Ie6tEZLmI/EpEhnTx3hPa9D19beS1C0XkJREpisxrp4jcKyKTO5nHDhExbV66ps089z3avee2NtNGt3m9QESCkdf/62LdSSQ+IyIbuig3TUT+IiKrI+umRUT2iMiTInK+iIjTsjqZ7wORz9Z2QM8ft/vsi9uUv7bN6yc4zHuUiPxaRD4RkQoR8Ue+kxdF5BoROexuCEUkRUS+JyKfikidiNSIyAoR+aGIpLuchy+Sf6+ISGFk3dZHvpelIvInETnjcGNVSimllFKHR/uwVkoppZSKX6FO/t5HRJKBu4ErOpg8OvL4nIj8G7jRGNPSyXzGA08AMzuYPCLyOAu7j+2bO3j/LODJyPS2EoDZkcfXReQaY8yTHcXQbn53AV9o9/JI4HrgChG53hjjWJF8qIwxxSLyGnAGcL6IpBtj6rp4ywnsv6jw7/YTI126/BZ73bVvVDIMuDDyeEVELjXG1BzeJ4gOEfk28Avs77GtAuAzkcfXReQ8Y8zeQ1zGKOB1YHy7STMjj6tF5FSHeQwCXuXg/E3AHoByJPZgpl9Hz5GUUkoppWJKD8aUUkoppeLX1DZ/b28/MVIJ+jxwUuSlN4CHImXrgEnAjcDxwNVAmAMHeWydz2jgQ+yuRwDexx6Qbx3QDAwFFgKf7ShIEZkBvAukAY3Y3Zm8D+zE7qLiGOAm7ErOR0XkNGPMm1187q8A84CVwJ+AtUAGcG5kWiLwbxHZa4x5u837TsOuoFwd+f9Z4IddLMfJv7ErrJOxB8K8r4uyV0WeDfBgB9PvBa6J/P1J5P8tQCX2RYWrgPOB04EnReR0Y0yHFyk68QPg99jf1SuR1/4B3NGmTEM35oeI3Ab8OPLvxsj8NgKlkeVchJ1Xc4CXRWSBMaa7y0gBXmN/ZfVbkeVsA/KBy7HXzWMOs/or+yurX8X+DnZg/w5ysH9LJ2HniFJKKaWUiiGtsFZKKaWUikMichowI/LvBuzK2/b+D7sSLgBcbIx5tt30ZcB/ReSPwDeBa0XkXmPMe+3KPcT+yuofGWN+3m76cuB5EfkhdmvgtnF6gEexK6tXAacbY4rbvf89EbkPu1J7IvAPEZlijAl38vHnYVdinm2M8bd5/U0ReQl4AfAAd7WdjzFmUySm1vLVxpg1nSzDjWeAWuzK8qvppMI60sq9tTJ/sTFmV7vpl7O/svorxph/tJvFcuApEbkJuB04GbuitqOK7w5FWjfvFZH6Ni+XHurnF5FFwK2Rf38N/KDd99WaE89ht6yfjp1j7XPHyfeBCZG/7zHGtG9V/7KIvIt9F0FnsSYBF0T+fdoYc2EHxd4E/iYiud2MTymllFJKRZn2Ya2UUkopFSdEJElEporIj4GnIy8HgG9G+rRuWzYF+Fbk3z93UFnd1neBosjfB1QIisiJwNGRf5/toLJ6H2Pb0+7li4Ap2C2Lr+igsrr1vaVt4p2I3eq7M37gunaV1a3zeQW7dXLrfHqsxawxpgl4PPLvcZGuKzpyPtDaz/K/Opj+o8jzEx1UVrdd3p+xW1/Dwd2h9LYfAAJ8DHy/s4sLxpingaci/3YrZhHxAV+M/FuI3Qq/o2Xcg91qujM5gC/y9+KulmmMqehOjEoppZRSKvq0wloppZRSqu86vt1ggE3Y3V/cBqQAa7BbGb/cwXuPA1pbi3bZl3Ok4veDyL+L2k0+t83fv+te+IDd7zLAaheteRe3+bt9HG296tAf8j1t/u7pLh5a+6MW9nf70d7VkecG7NbG+0QGiJwS+ddNn9utXZwsiLRe73Uikga09hn9SPuLJR1YHHkeKSLDu7GoI9nfsv9hY0xjF2Xv6WJaOXbXNQCXiUhqN2JQSimllFK9TCuslVJKKaXikx+43xjTWcvSo9r8vbxtxXdHD+yW0ABD2s1nTuS5CVhyCHG2xnGEixjaDlrYPo62PnZY5qfY6wfgiEOIuTveZX//4QdVWItIAfsrd582xtS3K9L2e3rKxTpqbYWegN1yOBaOZH/Xgn90EfNf27y3q++1vbbfnVPudTo9ckHmP5F/FwI7ReSfInJxF63ilVJKKaVUjGiFtVJKKaVU3/UJdj/VrY8TsSssd2FXWP5BRH7fyXsHHeIyU9r9nx95LjXGBA9hftGKo62Srt4YibMy8m+P9kkcaV3cWhk6UUQWtCvyOez+tGF/a+y2DnX9QNfrqCf1Vsxtv7suv3MX02/G7vPbROb7ReyBGneIyO5IBfbsbsSmlFJKKaV6iA66qJRSSinVdzV00I3GYhG5H3gfuyuJb4nIm8aYF9uVa3ucdxr7+6juba1xLAWu78b7qnoglp7yb/YPQHgV8FGbaa3dgewF3ujgvW2/p+vY30e1G4XdKBtNbWP+AfBcN9673blI9EW6E7lKRH4JXIp98WcekAwMx67A/qKI/MkYc0ssYlRKKaWUUjatsFZKKaWUijPGmCoRuQK7ctMCbheR14wxgTbFytr8Xe2i/+jOlAGTgUEi4j2EVtZl2BWCqYcRQ3uDu5ooIl72d5fR44PoGWO2isgH2INTXioi3zTG+EVkBjAzUuzBTgYmbPs9dXSBoi9qG3OgB2Nu+911+Z27mA6AMWY9dh/wt0UGdZwLXIBdYZ0BfFNE1hpj7u18LkoppZRSqidplyBKKaWUUnHIGPMp+7uimADc0K7IsjZ/H3cYi2pt8ZsMzD+E97fGMVlE8rss6d5RDtNnY3eZArAqSst00trdRy5wVuTvqzuY3l60vqfe9CnQWvnekzG3/e6ccq/buWmMCRhjPjTG/B9wSptJl3V3XkoppZRSKnq0wloppZRSKn79DGht8fx9EUloM+0NoDby91dF5FD7O362zd/fPoT3PxV5ttg/YODhOk1EhnUxvW3lfUeDUjZFnhOjFA/Ao0BL5O+rRcTC7r8aYJkxZl0n71sJbGvzvsPpH7pXGGMqgbcj/35GRKb10KKWA+WRvy93yOH2F2y6xRizlP3d0ETrwopSSimllDoEWmGtlFJKKRWnjDFbsQeSA7vbjRvaTKsDWgdkHAM8LCKpXc1PRE4VkUXtlvE28F7k3/NF5AddvF9EZHi7l/8LbIz8/R0RucYhhjQRuSVS4duZBOD+SJcO7d9/OvD5yL+b6LjCurXv54ldxdIdxphq9vflfCZ2P8lDI///q4v3GewuKsDukuJZp5boInKUiJx5OPFGwW3YAxh6gKdFZGxXhUVkioh0q+VypIubOyP/DgX+3Mm8b8Dup72zZY8VkZMc4jsKyI78u62rskoppZRSqmdpH9ZKKaWUUvHt59gD/XmA74nIvcaY1pa+vwQWAacD5wIbReQu4APslqvJwAjswecuAMYBX8Ae0LGtq7AHTcwDfi4inwHuB9ZityoeAiwALgFeBm5ufaMxJigiF0XmmQk8ICJXAw9H3t8EZGEPIHkccDaQBvyF/d1OtPcxcCrwsYj8EVgHpAPnAV+NrIsQcGMn/Ua/G/msR4rIT4Hn2d8aHWPMhk6W6+TfwMXYFep3RF4LYH/WThlj/iMix2FfcFgAbBCRe4DFQHFkfkOBOdjf4wzgF0D7gTZ7jTHmHRH5EXb+TQBWi8gD2BcI9mA3jBkMzMLuImUB8BDwSDcX9UvsvJoA3CAi47DX7TbsltCXY3e98jGddxUzEnhDRLZi3zHwMbALaAYGAccDX279aMDfuxmjUkoppZSKIq2wVkoppZSKY5EB/x4ErmF/K+u/R6aFRORc4E/Al4BhwE+6mh1tKm7bLGOHiBwNPA1Mw64EX9S+XMTLHbx/rYgswO424wjgpMijM3WRWDrzD2AFcCMd9w3tB66PtA7vyO+wK0FTgB9FHm1JF8vuystAKXYlaFbktZeMMeWdvmO/G4HdwA+xB4z8v8ijMzWHGGPUGGN+ISJlwB+BVOArkUdnuh2zMaZRRE4DXgPGAydGHm1twr5QsNNhduOAW7qY3gLcbIx5o7txKqWUUkqp6NEuQZRSSiml4t/PsVsUA3xXRPb1zWyM8Rtjvopd0fx77EEUKyLlG4CtwP+w+5ceb4x5rKMFGGM2AzOxW1s/g92KtiXy2BWZx1fY371F+/dvwB4M8SLsbkK2AvXYfXBXYQ/kdy/2gHcFxphQR/NpM78vRub1ClCCXUm9G7gPmGmMeaiL964D5kaWtxlo7GpZbhljgtifra3OBlts/15jjPkpMBa7b/L3sSu/g9it0Hdif9YfAjOMMb+LRsyHyxhzFzAK+C7wJnaLcD926+W9wFvYrcEXRPLwUJaxAzv3foDd53cD9kWNlcCtwFxjzK4uZvEucCz2en0V2ICdc0GgGvvugV8DU4wx/zyUGJVSSimlVPSI3W2eUkoppZRSfZeInIBd+QlwnTHmgZgFo5RSSimllOox2sJaKaWUUkoppZRSSimlVJ+gFdZKKaWUUkoppZRSSiml+gStsFZKKaWUUkoppZRSSinVJ2iFtVJKKaWUUkoppZRSSqk+QSuslVJKKaWUUkoppZRSSvUJYoyJdQxKKaWUUkoppZRSSimllLaw7i4RWSwipt1rJ4iIEZHbYhSWiiOaQ+pwaQ6pw6H5ow6X5pA6XJpD6nBpDqnDofmjDpfmkDpcmkPO+l2FtYhMFpG/isgaEakREb+IFIrICyLyeRFJjHWMrUTkaBF5UUQqRaRJRFaJyM0i4ol1bANZPOSQiPhE5CYRuV9EVkRiNCJyQ6xjU3GTQxNE5P+JyJsisjsSY4mIPCsiJ8Y6voEsTvJnhIjcISJLRKRYRFoiMb4rIteJiC/WMQ5k8ZBDHRGReyL7MiMi42Mdz0AWDzkkIqPb5EtHj0diHeNAFg851EpEPCJyg4i8IyJVkfOybSLyqIhMjHV8A1E85I+IPOCwDTIi8kas4xyo4iGHAEQkUUS+KiIfi0i5iNSLyHoR+YuIjIp1fANZHOVQuoj8QkQ2iEhzZD/2ioicHOvYDpc31gFEk4jcCvwYuyL+Q+BfQD0wGDgBuAf4MjA3RiHuIyLnAU8CzcCjQCVwDvAnYBFwceyiG7jiKIdSgdsjf5cAxcCImEWj9omjHPoZcCmwDngRexs0CTgXOFdEbjLG/CWG8Q1IcZQ/44ArgCXAM9j5kwt8BrgPuEpETjPGBGMW4QAVRzl0ABE5B/g8dqxpMQ5nQIvDHFqJvR1qb00vx6Ei4imHRCQNeBY4CViBHWszMAw4FpgIbIpVfANRHOXPM8COTqZdBYwFXuqtYNR+8ZJDIuIF3sCu/9kAPAy0APOArwNXi8jRxph1sYtyYIqjHMoG3gOmAmuBf2IfR58HvC4iNxhj7o1hiIel31RYi8j3gZ8Au4GLjTFLOihzNvCt3o6tgzgygLuBEHCCMeaTyOs/At4EPisilxljtGVIL4qnHAIagTOBFcaYIrFvGflxbENScZZDLwO/McZ82vZFETkeeA34nYg8bowpikl0A1Cc5c8HQLYxJtz2RbFbVr8KnAhcCDwWg9gGrDjLoX1EJB/7uOhRoAA4PrYRDVxxmkMrjDG3xToIZYvDHLoTu7L6S8aYO9tPFL1jqFfFU/4YY56hg4tlIpIF/B/gBx7ozZhUfOUQcAF2ZfUbwGltj6tF5CfArcC3getjE97AFGc5dBt2ZfVTwKWtjYUin+ET4K8i8ooxZk/sQjx0/aJLEBEZjf1FBYAzO0ooAGPM88AZHbx/vog8IfZtzX6xb4+/U0SG9lDInwXygUdaK6sj8TUDP4z8++UeWrbqQLzlkDHGb4x5SSsT+444zKEH2ldWR15/G1gMJABH98Sy1cHiMH/87SurI68H2H/yNqEnlq06Fm851M5dkeev9sKyVCfiPIdUHxBvOSQiRwKfAx7tqLI6EmugJ5atDhZv+dOFq4Bk4CljTHkvL3tAi8McGht5fqGD4+pnI8/5PbRs1YE4zKELIs+3tr2z1RhTCvwRe1sUtxc8+ksL6+sAH3YFcJe3/xljWtr+LyLXY58otQDPYV9FmQDcAJwjIguMMbuiHO9JkeeXO5j2Dnbr2aNFJLF9vKrHxFsOqb6nP+VQ68mZdufQe/pF/og9BsOZkX9X9cYy1T5xmUMici1wPnC+MaZCRHpiMcqduMwhYKiIfBG7W6IK4ENjjG5/YiPecuhzkeeHRSQTu3vGEdh59KYxZkuUl6e6Fm/505kvRJ7v6rKU6gnxlkNrI8+fEZE/t6u0Pjvy/HqUl6m6Fm85VBB53tbBtNbXTgZ+GuXl9or+UmF9TOS5W4MaiD2Ixj+x+5463hizt820k7Fva/4z+69aRMukyPNB/aEZY4Iish2Yhn3FbX2Ul606Fm85pPqefpFDYg/ucTL2hbN3emOZCojT/BGRPOBrgGC3ADkVGA/81xjzv55YpupU3OVQZHvzZ+BBY8yzTuVVj4u7HIo4NfJoG9Ni4BptMNDr4i2H5kWeRwFbsS96tDIi8g/gG8aYUJSXqzoWb/nTUSwLgRnAJmPMWz29PHWQeMuhF7C7crgQWC0ir2N3JTMH+7P8Ffh7lJepuhZvOVQODAHGYI9N1VZrC/5JxKl+0SUI9hcE0N1+Wb6MffXkprYJBWCMeQP7qsg5IpJ++CEeIDPyXNPJ9NbXs6K8XNW5eMsh1ffEfQ6JPdLxQ0AicJsxpqqnl6n2idf8ycPuP//WSCzjgN8D1/bQ8lTn4iqHRMRi/wA234jmvNUhi6scwr6w+jPsE/vsyON44C3sAZHeEJHUKC9TdS3ecmhQ5PmP2N2hTQHSgVOwK7C/AvwoystUnYu3/OnIjZHnu3thWepgcZVDxhiD3V3sT7ArFb+B3Wf1idgNh/5rdADz3hZXOYR90QPgJ5E7XYF948N8M/JvdpSX2Wv6SwvrQ7Uw8ny8iMzrYPogwIM9OvSyXotKxRPNIXW4+kQORXZw/8Ee+ONR7EpH1ffFNH+MMRsAieTPMOxWAz8FjhGRs4wxldFepoq6WOXQN7ErF8/Si2NxLyY5FOmf8dZ2L78jIqcB7wHzsW/D/XO0lql6TKy2Q62NtzZgD1bV2pL6DRH5LLAcuEVEfmmM8UdxuSq6+sqxdCZwCTrYYjyKSQ6JSBLwb+Az2ON4PIt9MXYR8BfsfdrFehdaXIjVduhW4HTsCx8rROQNIBU4D9gLjAQOGncoXvSXCusi7Cviw7r5vtbbvr7jUC6t2xF1rbUFdWYn01tfr47yclXn4i2HVN8TtzkUqWx8ELgYeAy4MnLFX/WeuM0fgMhJ/i7gzyJSAjyMXXH9tZ5crjpA3ORQ5LbJXwD3G2NejNZ81WGLmxzqSqR7vXuwK6yPQyuse1O85VB15Pl/7bv9MMasjHTTOA77M62M8rLVweItf9q7EkjB7vtWB1uMjXjLoe9in3/d1G7g15ciF81WYO/DtMK698RVDhljiiIV5D/C7vf8K9jdhDyKnTubgdJoLrM39ZcuQd6LPJ/czfftqzg2xkgXj7ejGCvAxsjzxPYTRMSL3f9MkI47Tlc9I95ySPU9cZlDIuLDrly8DPgv8Dm99Swm4jJ/OvFS5PmEXlymiq8cmord9dB1ImLaPrBbXQNsjrx2fhSXq7oWTznkpCzyrF2C9K54y6HWc7LqTqa33v2RHOXlqo7FW/601zrY4p1dllI9Kd5yqHVgxYP6OzfGrMTeBo0Skdz201WPibccwhhTYoz5mjFmtDEmwRgz1BjzdezW1QBLo73M3tJfKqzvBwLARSIytauCkT5aW30UeT62pwLrxJuR5zM6mHYc9pXZD0y7UUdVj4q3HFJ9T9zlkIgkAI9jX9n/N3BV+xZGqtfEXf50obVFgl746F3xlEM7gHs7eRRHyjwe+X9HL8Y10MVTDjlZEHnWxh+9K95y6PXI8/T2EyLxTYj8u6O3Ahrg4i1/9hGR+cBM7MEWF8cqDhV3OdQaQ377CZH4Wvs71i6Jek+85VBXro48/zemURyGflFhbYzZAdwGJAAviMjcjsqJyBnsb/kF8DfsZPxT5PbU9uUTRKQnEu4J7Gb6l7WNNdKH0c8j//6jB5arOhGHOaT6mHjLocgO9mns/q3uBa4zxsRt/1bxLg7z58i2A3u0eT2N/bffv9B+uuo58ZRDxpgVxpgbOnqwv8Xj9yOvrYjmslXn4imHIvM9MjJ4Z/vXT2b/QEMPRnu5qnPxlkPAk0AhcKmIHNVu2o+wu2l8yxhTfNA7VdTFYf601TrY4l09vBzVhTjMoXcjz99vV/kJ9ufwAkuNMXU9sGzVgXjLIRGxIudf7V+/CrvC+gPgmWgvt7f0lz6sMcb8MtKdxo+BpSLyAfAJ9ujzg7FbLk+IvNb6ng0icj1wH7BWRF4GNmGP7jkS++pIGTA5yrHWisgXsCuuF4vII0AlcC726LBPYPc5o3pRPOUQgIh8t818Z0WerxORYyJ/v2eMuSfay1Wdi7Mc+idwJvbFs73ArSLSvsxibSXSe+Isf24FFkVi3IU9QMwI7EFjsrAPjn4V5WUqB3GWQ6oPirMc+iMwIRLjnshrRwAnRf7+kTHmgygvUzmIpxwyxjSIyLXA88C7IvIU9jHRfOAY7H4/vxjNZaquxVP+tBKRDOBSoAX4V08sQ7kXZzn0C+Ac7O4nNkSW24Q96OJRkb9vivIylYM4y6EUoEREXgO2Yg+wuAh7EMj1wMVx3SjNGNOvHtgdpP8VWAPUYt8+UYR99ePzQGIH75mBPZLvTuwdTWXk/XcCJ7Uru9hebQe8dgJggNu6Gesi4EXsvomagNXYLUI8sV6PA/kRLznUOp8uHg/Eel0O1Ec85JCL/On2Nk0fAyp/zsJuubgJu8+2APaJ/evYrYy8sV6PA/kRDznUReyt26bxsV6PA/kRDzkUieN57O4a6iPL3IXd6OPYWK/Dgf6Ihxxq876Z2A2GyiJx7sK+23VorNfjQH3EWf58OfK+h2O93vQRfzmE3R3I77ErF5sjce7E7ppicqzX40B+xEMOYVeI34t9h2JD5LEC+D6QEut1eLgPiXxIpZRSSimllFJKKaWUUiqm+kUf1koppZRSSimllFJKKaXin1ZYK6WUUkoppZRSSimllOoTtMJaKaWUUkoppZRSSimlVJ/g7U5hT3qq8eZndV4g4KL+W9wtywo6l3Hb+3ZilfPMmvO7tSoOm5vPB2AFnMuEEpzLGI+75bnl372n3BiT3533JGYlm9SC9C7LNDQmHlZcbYmLsVCNi5T11blbXiDHxQLd/EYAb6NzGSvo/AsIpLr7wZlE59h91e5id5OPAM0l3c8hT1qq8ebkdF3IcrFlMC7WSwy693fzew8nO39X0uLuu7L8zmW8ze4GFQ4Mdl5hYX90N0SHsh3yZSabxMGZnU4P+N3tC5KTnFeeP+Tu84qLdAw2R28flZDsnGj+Zp+7mbn4naSnNjmWqWtMcrW4xErnBfoHuZoVAC3bCrudQwlZySa5IKPT6c1+F+su6PJgKIrEzXGVm5R1GbqbfbCbmNwKu9j3SMjlzFxsZwFatnY/f9zsx9ysOyvZ3YcJNzl/qW6Ohdyuu2gfbzrxJDoH5mYdACSmudiuV7k7yDEuN9kthT10LOSCJDgnmnF5POEmP9zmhqvjdzfz8ro8kHOzrfK7PYF1UcTNuV03TocO5VgoKSvJpA7p/JysvsHdPtnVOnaxv3PzOwYItbj44t0ev7v4St3EFQq6bP8XjuK5h5tyLsPy7+p+/gDk5eWZ0aNHd/dtqh9atmxZz+zHPM6J7qtxt20O57r4LbvYvojP3fGhNDr/AMMuT7Xc7DNSs5zPtQLb3O2EQ6kuK3NcCKS5K9fVfqxbZ8De/CyG/fyrnRcodbFzc1OZBCSWOX/Jbg98Rj9Z7lhm0w25zjOS6NVgJZa724ukFjovs3aM8w81mO7ux+XW9pu+vbO770ktSOfk+y7qssyyT8YfckztWc0uNhRJzutlyDvuvvfii1scy5gSdweAecudv9OkKucNb/F8dz/x4Gjnjdzg/7k7eq4f5i631/zhlm7nkDcnh2HfvrnLMm4qdN0cPFuB3q9QSi5yXnfNM52/K8/WZFfLS9vtXCZ7g/PyAIq/6Xyi37Sz6wtW3XUo26HEwZnMuuPqTqfv2e7ueGvG5F2OZfbWdV4x3pbXcs7Z8k0u9lEuDZ9W7Fhm15bBruZltTj/To5dsM6xzNsrJrta3viHnI/adn3Dba0kbP7srd3OoeSCDI6+67JOp2/YVeA4D6mM3sGgWwmVztuXQIbz/s64rARysw9OrHA1K1cX+RtGOf+OvLUuK9+murtSvemiH/fIfszN7yp1SpWr5TWuca7YDKa6uGhd527dBdOie7zpJH1stWMZN+sAYPzROxzL7HlmtKt5teS5KsbmH/TMsZCb6/KJwxocywS2uzvb9NU6L9DN9gXA4yL/3eSZyXFxVR4Iu6ikSN7lrmYhmOb8GVMKnT9f/Rj3v6NDOicbks4ZD5zf6fQPlrrbJ5PlvI7d7O/SxtS4Wlz9dhfHVW4qhgHjojIs08X2pboi1dXyaHI+J3Oz7Qd3F1BCKe5yaOdXv9Pt/AEYPXo0n3zyyaG8VfUzItIz5/RZzsf8Q15yt21uvKLasUzdtizHMlaBu/PihFXO24XmQe5+o0klzsdf885b41im9JLOG9u0VXPUcMcybuthSxa6K9fVfky7BFFKKaWUUkoppZRSSinVJ2iFtVJKKaWUUkoppZRSSg0AVS2j2FpzMlUto2IdSqcGVIW1EWHn8QsJ+exbB0qnT6Yl3eVtPEoppWjKymTd+WcTSIpef/NKHapgQgLlE8Zh3HQErpRSSimllFIDVEtmOs1ZmVS1jGJpyVfYXP0ZlpZ85YBK67BlUTVqTAyj3G9AVVhXjR3FhgvPZMk3b2Tn8Qv59AtXsPnsU2MdllJKxY3iI6ZTPOsI1lzSdX/0SvWGj790PSuvvJRtJx4X61CUUkoppZRSqk8K+Xy88+vvs/WcU6hsHk/YeAAPYeOhsnn/WHK7FhzLhrMupD6/GyPZ95ABVWGds3UHs+96kKa8HDZ89myyt+5k8pMvxjospZSKG6PfeZ9Z//ovk597IdahKEVaSSkAmbv3xDgSpZRSSimllOqbPIEAgz5dQ9HCOWSl7sCSEBDCkhA5SVsAqBw9jqJZcylY9SlpZaWxDRhwHq62nxm0diMLfv8Pio6cweg338frdzeCtFLqYDuOPpGEhnqGrlwa61BULxEgZ/uOWIehFACTnn+FtNIycrZuj3UoSimllFJKKdVnDX9nCUVHz6Xl2CzmLb6Dyubx5CRtITtxJ4152Ww56QxSS4sZ9cHbsQ4VGGAtrFullpYz/uW3tLJaqcNQWzCM4hlHsmv+sdQNHhLrcJRSccMw07sLL6HDnlNiQwNj33oXKxyOQlxKKaWUUkop1T/lbNxKcmk5e46bT3biTsZlvkF24k7CHg8rv3wNCEx89Xms8OGfp0XDgKywVkodvj1zF+JrbCChvo5tx51G2PLEOiSlVBwYa5VzS8rrnODbGOtQlFJKKaWUUmpAEGMY/u4SKqdMoDE/d9/rGy89h5pxoxj35isk1dbEMMIDRbfCelCzc5mwRG1xEsVK/4n3VDgXMtGLvSUveq3BMrYbxzLeOr020RGr2Xm9FB0XxZwd7OI34lJztnMFccGSYNSWV3JOy76/a4cMo3bYKIau+Jgx775GU04ee2cfFbVl9QVhn/Pvqq8KjWuK2ryqJidHbV7xYPiYsqjNa1h639nZd9fI8SU9Nu/p3r0HPAMcP2tD1OY/8i+xvXg2eWSxYxmT0zfv8PLVOu/vJBjFY6Fc5zJupe503p8HM/pPS/yG9dm9urxAevyuu5TplVGb1/Dzd0RtXvHAN6Y+evNysX2JJqlMOOi1+pTp1KbNxdC9WJpGBqIVlitp22N73nb0vOjtk93s7+q3Z0ZteVjRO36v2ZblWCYrtyFqywsnRi92T6Oe+6v+r+gzvbttDhdH77w4qbR3f6ODHqvd9/ewd5dCOMye4+YDUHLkDHaedjyjXn2b3O1bHOcVzXpYJ93rwzpoQXlip5PH/7cB6PrAZse33R0g+AOpjmVS97ib16Yv5LgqB9HZSYS9zvOxguKq0lqCzonsa4Bkh/7Q68a5O9FI39pzPxx/WSJ7/ja+yzKhk5zjzFnuLm1bspzLNBe4Wy9uKq1zXnPegFUe4S7HSo923goklnipcfgJD3unheFvOc9rxzmd/65bTfzx+n1/b/zpWSRUVjPhz4/h8QeoTR1G4dFHMfrfL9MyowdPoj2GcFbXO6bkLc6fpSXbxffgcfddJRc6/2aMy59V0xDnfAzX+RzLpGx39xupnO2cG1mrPVRMd87thFecyzRNdv58CRU9u/MONPsoXDe4yzJuIlj76WjHMmk73H2W6tHO68VNZVzDKHfbsz1rCxzLWM2WqwOEcJLzMjdV5x/w/7hB9g5roqeEbdU5BPFQsiHf1XpvHOz8+64fbpH0vouZHaKWugS2vje60+nBtLBjVYib7xPcf6du+HOiMy8JCBJw3ie6yQ1fjUUwzXmZLfnO2ypPo+VYmW68xlWltWxzEVQPclNpkbzXIviu8/FtON95XuLy8DeYFp0cSt7rLv9b8pwDa1nqvA78k5tglPOF3E1LRzmWMT4DLrbZSSU9uC8TCCd0vW4sv/Nv1L/H+VwLABcX8P25zmXcbBMAQqkuLpylO1dSTPr6tgP+33nmSey44RwAzN6RzPjzfSSXV1J47VTHedXOaqF5XItjuYRdLvZRY5zXw5inWsj/1LEYAIcygkNDbRJL3+j8c7vZjwHQwUWBQxWtSuv0sdWuytW5qIwGqN3qUC4sro5fLjnpA8cyj79+tKuYQqnOOWQFBCuKF5iViiZPC6Rv6/qX421w3p6Wzw9SeLLz7yFjsfOxgpnt3LBQyhMJF6U4lgs5h04g090+sXmQ8/71kyenO5YZ9KkfJu7/P2frNvacsIC8PdtZdd3nSC8sZNTyj6mZ4HwGOOrSrY5lAFpqs1yV60qP1gyELYstp55AxfgxPbkYpVQvqpw2iaoZkxn79Et4/PYJw+T7HsHb1MSar17T7VYrSqmBI0VamJ5YyFZ/HqmWn+mJhbEOSSmlVD+388yT2HDD5Qz6aDnT/3Y/tWNH8cEfb6X46LmxDk0ppZTqdUNWrsKfns6nV1+BGJj69LN9ckygHquwNsCaS85n+8nH8em1l1M+YVxPLUop1Yu2XH4uiZXVDH/1nX2vJdTWM/neR6iZNI6agpkxjE4p1ZcdmbQLr4S5q+ZYQkY4KulQ2oYppZRS7uw644R9ldUz/3AXw978gKNv+SmphSWs/PYX2TPrtLhobFE8fSohr44Xo5RS6vDlbtmKr6GBQGoqk59/geSaWuc3xUCPVVgHUpIpOWIa2dt2YCyLwrmzempRSqleErYs6kaPwPL7Cabuvx3GAIEM+xbqxszhMYpOKdXXZVuNAHgI4zdecjzR6/tRKaWUam/vSYsgFGbc489jhezuhVJKyph0/2NY/gBVI6YQSI5tN0BOwh4Pm884ldKpU2IdilJKqX7ACoeZ9OLLTHrhJfI2O/dbHSs9VmGd0NjE4NVrqRo7GiyL4Us+6alFKaV6iRUOc+Qv/oI/M4OPf/YdWrIzCSYmsPrmG9jw+csZtORTBm95NdZhKqX6qNcap1AaTOOX+c+SIEEerp0X65CUUkr1Y0f86W4Sq2v45NZvUjdyKMYStl10Jkt/9m0SamoZ+/4TJDTVxTrMLlmhEAv/cgdDVq2JdShKKaX6ibzNWxiyclWsw+hSj/ZhPeat9+yFBIJkb9vZk4tSSvWS7PVbmPOz22nJyeLtu3/LO3f9hqJjj2LCg08x6zd34Ak5jwaulBqYmk0Cd9YcB8AbjZPZGcyLcURKKaX6s9SiUubd+nusYJAPbv8Jb93/RzZfcQGDP1rO0d/8CamVe2Mdoitev/NAk0oppVR/4jwE5GFILy7l5O//DCAOegZTSrnVWmn9yW3fIpiSzJyf3k7eynWxDkspFQdeapjOiw3T9bhAKaVUr2ittF72w5toHpTL9L/cx9DFH+p+SCmllOrDerTCGsAKm55ehOrnwuIl5E0j5Ekl7EklND6DQHIqwaQUAkmpBJNSCSSlkl6yixGfvIYVDsU65AEhe/0WTrnsKxjL2tcnoFJKOWkd3EqPDpRSSvWW1KJSjv3qD+zj1nA41uEopZRSykGPV1grdaiC3nRqshfSkDEdpM2o2EOAcAhfcyPe5gZ8jXUk1lVRNXoKgeRUxrz/PzxB7ZaiN4gxSD+rrPZIiLyEegpSqyhIrKUgqZqCxBoKkmoYnFjD9sZ8frHxXBpDibEOVSkVJ1or57U1n4olIx4qhh9DQ/ZEEhtKSK7bRXLtLrzhCs1NNSAIIFpZrZRSSsWFqFZYFx+d7lgmtNNdm6pQivPBRCjR41gGIG27c1fdjUOd4wqmujvASdnjHFco2dWsaJzsXPGasCfBsUzOKnenImULgq7KHYpAhqHotK7nP/RVL/7kVPbOnk/plBkADF63mrTSQnyNjSQ0NpBSVoe3uemgk6vSyVPYeMaZbD/6IqY9/QTeZud11zDW+TtNKnL3M6k8wnleYXcpi7fGuaC4+Kq2XeAudm+9829k00/cjkzecycC4hcS9nRdUTzkwxbH+ZR/o/GA/wd7a7ht0AuMTywlz1OPRw7cHoSBoHgIicX88DYuGLmMvYnZBC0vZz38HcflZWxzLGIvJ9H5ewg2uxh6wGXNQ+awGscyNf4sV/OSKDWX9ef28ImkZQind36RJWmXz9Vsxjyw+4D/Gwbns3fRXMa89Ba+pmYANt403F1ILr7ThlHRWy95y5wTpOY8dwNQjcqudiyzbc0wxzImyd3nKzzbuVzCbud94uGwUkIkH1HZ6fS8P6Yc8H/5+HFsOPdM/KmpeAIBLH8AJgSxQgEkFMAKBbBCQaxggOTqveTsXrnvvWNmOPetWvzyCFdxNw1zXnfid84Nk+Dux566wzmvmxc2uJqXZ3eKYxnjYruXUOVu6JbA5EbnQjHmbXZXbuJfdgHQOCiXFV+9htrBI8lbuZ6GIflUjBwPQEJtHTnbdpK9dQc5W7eTXH3wvmHrJc7fAQCWc34Yl8dCgWznC+L5Myscy5SsHeRqecEs5wMrCbrLocEn73FVbv0vXRU7MIYQ+Kq7XoluzqOMm8OJKO6S3ezr3ErYkuRYZtNtk13NK5zonGfeEnf7lUCmi+2si03o1s93Y1297b5oK+OBYFr/rLivKU9zVS5a2Zg4yt3x0iPLjnIsYxW427B7PC62syXOvxGl+rLKmc7bqMQsd7+ZhpHOxzBDn3Hezl/982ddLe83r5zrWGbwh65mRfEi59970zDnMqVHN7laXtNO5/qj1cvHuJqXyT38RqTawlr1GSErmZ3zF1IybRbGssjfuIZhy5eQ2HDggYCvueON16AN6/G2tLD+nHNZdenljH/rqYPeqwaexuxsKiaMJ7W0lIzCIrz+Azec4xJK+cfQh0m1Wni9fjKlwXRKghlcP/JDguIhaFmEsEDs2pCUYAtDW6oY1VRBYVJ2LD6S6mPKp05gxVeuIZiaQsW0Scz9/T/3VVqrgStsWWw9+QR2L5xPWnEJQ5etIJTgI+zzUT80ibDHt+8RTEwklJZE7ZBJ+JrrSS/bGuvwVT9SdNQs1nz+MiQcZvbt9zB4+RoAGvNyqJw6gfK5M6gcN5riWdMBSK6sInvrDkYvfp+UquoYRq6UUkop1UcZwwK2k0iAd5iIEb1fLdq0wlrF1EV5y2ghiQ3eRaxJ+gwlI0aQt3kdw5d9SFKd3cKnrnwItSUjyBi8m/S8oi7nl7N9G9OfeJy151/IhjMuY+LrT5Jc03lLONW/VYwdw9oLziOUFGllYAyppWUkJO4iJbSbRb53uGvIv/AbL9ftuZpN/oJ9773U++lB80ta5ifpwwDF8zPJm1bHiOYKLh35IY/uWthbH0n1MbtOPJr1V1xAalEpI594gfVXXMDS73yZeb//Z6xDUzHUlJXFmovOo27YUIYtXcb4V9/A06b7pKIFB7d8MmKxff7lFE09meQP9uIN6EUPdXjCloe111zM7pMXkbV5OzPv+DfNhZlsbTmFnMQtZJfvIOWdJRRs24oBGgblUTV2NJXjRlNyxFTKJ41nzj3/IbVcj6OUUkoppdo6ih3MxL6jKoTFe2b8vkZuKjq0wlrF1B/GPx756z8AfPP5r/JRm1sM6sqHsP7NiwmHPFieEFNOepycpK5vkc4s3MsRjz3C6osvZuNpFzPjmfvxBLRP64GmKTOTVZdeTGpZOVP//RAt6WnUDhtK7bBhVA+aRkZyHvflXklhqICv7rmI4mDXtwolLfMz4vIKJADGB3v/m03OtAZ+MetxCpuyebfM3a2nqv8onzaRdVd/lsxtu5j3u3/gbW7B19jEyi9fzfrPnU8i78Y6RBUDBlh2/VWEvF6mP/YUgzZsdPU+MWGGrnmF7Qs+R9n4RQxZ/0bPBqr6vV3zzqR26HjGPP8GE558gZrGkSwt+wph48GSEPPy7yA7cQdg9ySVVlpOWmk5Iz76hPpBeSy/4UpWXn0pR//xHzH9HEoppZRSfUmBqWE2u9lCPn68TKOIneSym5xYh9avRK8zMaUOwZLa0ZQFsykN5fNe3WTWrz+wn0GrLjvSMaVFOGxRW+Kur8608jLGv/UcweRUSifO7IHIVV+X0NCAt8VPank5aWVl5G7bzph332fmI48xtf7X/C7xcjwS4OTKN3kn4TsEJKPL+aV86EcCdt+REoCkjwIA1AWS2FA7tDc+kupjMnbsIX3nHmpHDqN01jTCXg97jluAhEIULF3pPAPVLwmQVlyKFQ6Ts227y/eE+c6c57j/qF+RU7iamqFTCHl7ti9u1b81Zg2mduh4Jjz+ApMe+x9WKExly3jCxgN4CBsPlS3jO31/Wmk5wz/8hMa8XMIel51OK6WUUkoNAJWkUk0y4yljKkXUkUgZzmP6qe7pExXWQV8ajRmjYx2GioFL132JOctvZWjRNk6ufJPq5gMHyrj6jCdITPDjsQJYVpiMwbs7mdPB0sqLyCjcQcnUOYS8ejPBQOMJBilYtYqyyZNoSU09YNpwbyUXpC/hyZpZeBveJmBlsjXlBqq8swhIx4O1NC5MwPjsgWqMD2SeITXs5zfrzqaspevKbtU/JTQ0ctRv7iB783ZWffFKXr37d1RMm8j0+x9l0Mp1sQ5PxdCYt98lkJLCnnlzHMsKYX40/ymum7aY44ev51r5J8bjo7ZA79pQh6500lF4/M2Meu2dfa/lJG7BkhAQwpIQOYlbupxHYp09KKY/1eWAi0oppZRSA4BfvLzMtH3/v8pUmsUXw4j6p5hXWBvxUDThQoonXEhN/uxYh6NiwAq3kF35Bv7EIRRPm7Xv9dy0Wm767L+445dX8bObbuW2737DsQ/r9oas+ohgcgplE46IctQqHgxb/inG46Fo1oHf/4057xI0Hu6rXERaaBtjG+8DDHuSL2RD2v+xOeXL/KHieyxpWojf2Due5jkJ7H44l/JvpVP432yypzfSaCXw6M4FMfhkqq/wNTUz5493MXjZKgiHmfzfpxn2/iexDkvFWObeQnI3bWHXwvkEEzpvKS2EuXX+k1w26QPuXn0Sa8qH861Jj5FRt5Oq4TNwHvNbqYM1ZeRRO3Q8eVuW421u2fd6duIO5uXfwYTMlw7oDqQzvoZIhXVaapfllFJKKaUGmhpJ4W6O4W6OoVy0dXVPiHmFddWQBQSS80hsKKZi5InU5k6PdUgqBlIaN5DUuJXdc4+hJdX+sX923vt4rDAvbJnI+Fnv8oMr7mTG8B3dmm96aSHpxbspmTaXsKW3tA40KZVVZG/bTuGRswkmJgIwNK+CczJW8UTNkZSF7FxLDhczqeF2xjfcweCW1/CYZu6v/hLXFD7Jgu1r+WrRfTxScxVbjhhH5dfSyJjehGAoSczExH4zqmLMEwwy628PcPrnv83o17TfamUb8/a7BFOS2T1/bofTWyurL530IXetPpk/fXoWf/r0bIamVXEzv6YlYxC1jOzlqFV/UDrpKKxAC7nbVhw0LTtxOzMKXnCsrAZIqNcW1koppZRSnQmLRVi0PqCn9OiaTfL4+eWJD3LdzDewJHzQ9OaUAqoL5pFWvoahGx8luWYH5aNOpT57Uk+GpfogAXIqXwNL2LHoJJJ8LVw49wPe3jCdPVV5/OONMympyeIH5z5KgjfQrXkPWfURgZQ0yifoxZCBaPR77+NPTWXVJZ8l5PVy5elv2a2rq44+oJxgSA4XM8j/LmOb7uejMdP4W8H1nJP+FOv907it/DecsmsJd5feREaomUpfGn5Lu5pRNok8nAR9aYQtvV1sIMgoKiZvwyZ2LziKQOSCWSshzI8XPLGvsvr2T88EhA+LJvJB4URuHvEfMkLlFLIwNsGruNWcnkPNsInkbVuBN9BywLSUlBZuve15Hn3iLm74wrukpLR0MhdbQkMjoC2slVJKKaVU74tqbcuXvvjcvr8tE+YM1jCaSgAunf8ebzCZu773WQBCHi8rPnc6ifX1TH/8Tbz+AAUfPsPa8y6idPRnGLUkSGbRti6XVzf+4ErwjoSTXZRLcC4z9sGDb841QNjnwxPYX4laO8r5OkDlES5v9A05V4G0DHauwK1Mc9e6OHuFu5TY5apUOyHBqu18/ok0kJuzmLLRp7Lohs1kJDdxV/I8qi+upxr4Ye1Z3DvyQa474TXuef4Mx8X50+xlJdbvIaWikKIZ88goXINl9n/X0uL8XXm6Pp/bZ+ws57Xiv3Wwq3n5yhocy2z6ovMItOOmFLpa3vbVw1yVc2PQx26q7cDdUGQHMh4IpnX9W91+XvvKwBLy9r5I2YizqbjpSE4Z+f/4T+V89jR2vf5uvukL+94/hkcoyM6mefJwvnHW31nfOIEv/foGwn4hfLzzb7l6qrvfu2dIk2OZhBXOFQfBI+tdLa9pe5ZjGXG5qUqocP4tpS8ocyxTkFbnboEcWg4RFqy6zreH/mx3+5V1PypwLDP5jtoD/i+dOolVV12Mp6WFca+9zfCPlmGFQmz6ZmInc9hv7L3OMe3+atC5EFCOc2tJ2dZxX+7tbR3sYmBAj3MSWc3urp9fsmBJu1cMmTRR0+YzLRk+ytW8ADa7LrlfuNFD8/LOtx/bz9v/eRNkCcHkiay+ZiHZJR8CdmX1T2c+xiUFH/O33Sfyu9pTYdz+7+4XpafzwtC/8r2kH/D95r+R+foneIL+TpfXONJdznobnNexP9/5eOK46ZtcLe99pjiWCTe7PAzN7/zztzJ+F5/P5eCB4doeHPDSMoTTQ10WGTa8wnE2jRs63gaVjZ+HFQoyaMOnWAHY9Ft7MOuRCRX8ecxTjE0q553aCVzw2U857vxN/LbwdF57YUSHdwuFvHYuV03OJmtE7UHTOxIMOq/jxqQkV/NK3eGcHw0utkHG63IfnOxiG1ruvL0G2LG25wZjNh4IZHedQwXvOv8eyl2MSZ62090xXcDFndBNQ6J33ua8RYD0sdWulte0wvl4OpjhLna3x0xOpvzq4N9bfcEg0opLD3p95yHM35cUYOjUkk6nl1S5G5slVJTsWCac4OIYoMndMYAMdT5OtlzEZBd0jstpWw0QCrmL/Y4T/n3A/2IMWaaRWkkmFGmd+dttzue3ABUNzucCDWGX60GpGAglQc3krn9flt95/xMsdHcH2N/Ouf+A/5NMgIJQDRZ2ozWA1+dOwcJgEcYSg4UhaCyerZtFYTALgP/ecpar5Z3zc+fuIZ/NmOVqXl3Vn7Vys51t2umuy5JLTvjQsczbv3bXoKZkweEfT/dM80BjOJ5NjKaSt5lAAA/HsplL+YSds0fzyqdz2LVwEU05uUx7+nG8fvuwwxMMMvW5p1h7wcXsOuosRn/4HOmlh7Ib7h0hj4c1n72Q6lEjGbHkY0Z+uGTfZ1GHJqflI+oTpnJd3mKWN45kRdP+26E/aBjPk9WzuOzkd3h7xQw273FXySrA4A0fsX3RhVSNmkrujjU9FP2hCfm8NGVnE0hOIphkP8Ihi2BKsv1aSjKBlGS8Tc1Mfvx5EhqdD9bUgVJrNxEufI3vTH0IPwncVX5st94vQEZtGb8a+XeGe/ZwTNN7bDw9n8kvPOf4XqUAimbPYM1lF5BeWISnxc+GC85k57ELmPDSGxi2uGqdrQ52hmcNJ3g2sSo8jOeDR1DrojK+NyU2l5FSvYma/CPJKP8Ub6iRn099kstbK6t3nU77tvlrGobzv/Ij+Hr2v/hTxU+pHjaF3J0rY/MBVFxpSc2kauRk8jcvx9uy/1jh6LSt/HX0wxjg2q3X8mH9OGYk7+HW4c/zu1FPsvLCT/j1uxeyrmzEAfOzggEkFCSY2Ld+V0oNNDuPW8D6S85mzh3/Jn+du4uGqu9KDzdzRHAvmaaZFrxs9uaz28qOdVhKDQjJxs8C/w6SObCRxqQc+4Jg2EAYwSBYGD6b8Sk3FV/CmpboNfBT7vVIhfV8tjOFYpYyivIVaQz7uJo3501i5uy9/PCSR5k3eweXp19PweoVZO86sELaGwgw7dknWXHZpexYcA5j3n+atIq9PRHmYQl5PKy5+EIqx40je/sOdh6ziMLZsxn93vukVazFCru7Eq8OJIS52vo547w7uLryV0ALszbuZt6aHSydPprfWqdzgmzlO597gi///muEwu5aS6WV7CS5qpiySUeRs3MtYvrGUFaN2Vl8es0VtGRldjjd29iEr7EJb1Mz9ZPH05iXw9y/3Y+3RS+MdNcRLW9yZdKD3N54M+sSL2FQ8EXXlYTpyY38/Mp/01I7iIu+cy87B/movHoCm0/9DKnNL2tlo+rS7oVzWX/BWWRv28HYv7xDTcUw8qdvpPCa2ay66mIS/EVk17xJsv+Q7l0ZsI60dnKCZxPbw3lMkSIm+Yp5PTSVTxhOiL4zZkF2yYc0Zk6gctjx3JV2A5eP+KjDyuojt+5kwcZtfDRpLL9POp0zctbwE9/3uHnkb8jZuVK3M8pRyZR5iAkzaOPyyCuGq/I+5IfDXmRbcx43br+KvDX1fGnd2yyZOoZLmm7kguwV/L/8V3nos7fz9Pqj+NuSM6lsslvhCOBtadQKa6ViaOdxC1h/2bkMWrmO3I1bYx2OOgyWCTM+VMbYUDkBPKz1FFAQrmV6sIgxVLA0eQNvNU3C6B5fqR6RYvzM92/Hg+F931jqxL5ryiD8YP35hNt18jjKV8HfhzzM3UP/w/dLLmA5cwlbFg15+dQNKaB+cAF1BQWkVFQw6eWXsELOd2Wo7ol6hfUUU8QcdrGWIez6NJtzr1+Jxx8mlGDxv/uOoKR0KDec9iqrQzO4ee31FJN1cFAtLYx9/ym2HHcJO44+n/Fv/Zek+qpoh3rIDLDuwvOpHDeOSc+/yNCVq6gdUsDWk05k8+mnklg3j/FvPU1Sbd+JOZ7cmPUC2wPDeCj0bc7b/APu+/G/8AVDBLwerv/JNdz+7nn87IYHufjE93jkjeNdzVOAvK0r2D33DOoGjSKjZEePfgY3AklJfHrtFYR8PqY+9SwJdQ14m5vxNTeTvLsCb3PLARXrJTOnsuKGy1l5/WXM+ce/u5iz6siXR7+BR8I8tncetRlzAMhtXIzXNHbxLsNREzZx83nPsH3HZE6+7g2CQR+WFaLA9ynFl8+mpbSR3L3v9M6HUHFn98K5rL/obPLWbWT03z9g+forCRsPVlGIObv+TePxuWz47EmU5F9BctNm8que46bBL3Ns5mau2nQ9Lebg/q7r8/PYO+dIakYMY+RHH1Owem0MPllsDZVqLvQsZ2s4n3uDx5BJE+d6V3CWdzVT8gv5ZsUl1PaR22ETmivIKv6AH0x8mstTP+If207id0Wn0b6y+r+/vxtfMEjA6+Vz3/4Cjww9is8P/je/Dt5KU1YBKdXFsfsQqs9rTsuicvQ08rauxNdsdyv2rWOf48rhb/NazWS+tfMSJm4o4T+/uG9fnl31g+t5auKRvP/qHG6c+ypXHPEOp45byY/e+ByLd9jjftgV1n3jt6TUQLN3/ux9ldWz7nlYK0PiWJLxc1RgJ2nGzx4ri/XewQTEy06TQ364nkmhEm7NeYFL/Uv5YcX5lIXd3b6vlHIn0QT2VVYv8Y2mzjqwe7JwB12j7QzkctXe6/hLwaP8oeAJbvjaCTzguxHjtatRvU1NpJaVUTZ1KsbjYepzz/bKZxlIoj7oYhrNADSSwLClNXj8YawweAJhhi6tobopncZwCnmeCrwTO25VGkxIpGzCXAIpGRgRQgnu+rrrTY052XibmsneYbcQTy8qZsiKlViBAP6UdAJJOkDNofJImHyrnJmeTzhiQwu+YAhv2OALhjhm7WbOmL8MgKQEd62MQ94ESifOpfCIEwD6TOvqpuwsWjIzGfvmOxSsWkvO9h1kFBWTXFWNr6n5oDiTK6rwtPhpys2ib3yC+NIYsq+gvjPuKh5O/QyT0oPsyPkGpalnELAO3BYJYY6btpq7v/YX/vD5e0nwhvi/O75DMOgDLMJhi/AaHxhDMKHj7ZhSAIVzZ5G+p4hZDzxKdfUIwsYDWISNRVXtKIZ9soJhJXeSXfMWTUnjqMg6g5OyNjAjZS9J1v5b1QxQPmEcn15xGR9/+QsUHTmT+iEFVIwfF7PPFktpNOOVMCUmgzAWNSSzPZxHyAiDPXWkS3OsQzxAVukShobscTlOyl/HsVkH9p69YOM2fMEgXmPwhYIct2kT09P2YoyQKg20pOfGImwVR0IJiWBZtKRlE7bsOwzmDNvCzpYcvrz9ChrCicxft93Os7DBFwwyf509EkBDIIk/fXgun3vim2QkNrNguN3lQDAhiZa0nAO6F1FK9Z6mXLubiLSiEkQrq+NaZriZNONnlXcoq3zDCEik3aAIZZ503vON4/7ahUxKKGW0z3kcA6VU9ySZAMkE2eQddFBldVeqQql8ofAqysNZnFGwGOP1klxZyREP/5eFf/srMx99hPSiIuoHuxurTHVP1FtYL2U0abQwj52sm1dAKMGCQJiwz2LcvFIWzH6U5TvH84Xau1l+5AkMsZYz5t3FWOEwYcuieMZMds1fSDApmexd6xi87gMSmtwNINZbBJj+xFMsv+ZqVl/yWaY+8yxbTzqRyvHjyNi7l+HLXye5Rnc0h+qmPZfw8Oh7eTHnbL409y4CD90BwSAhr4cLT/uU/KkN/OWJc3j6naO7nE/Ql0jFuNmUj59NKCGJ9OLtDNqwhNTKol76JF1LLy7B19hIzYhhDP9keaflAslJlE2fxIaLzsLX1MScv/9LbxQ7BLdtvICH9izkquEfcMHQN7ks/WWWt0zlr0238EjS5/H4d5PdvIxLUv/Hl/PeZPz0MvaU5/KbJy/i5eVzaPLWY1khwmGDeA1ll04mtbSEvOJXYv3RVB8WTEokrbgUKxwmJ30HloQIG4Ml9v8AFkEy6z/CYFGdeTyn7LqT9Ea7z+Kw+KhPOYKPvjqXptwcEmrrGPvGYjL37uXTq68ge/uO2H24GNpkCngvNJ5jPFsAGCPlDLFqWBMeyk9Kz6K8j7VMEuDGwl/ybPO5/Dbt2zw47V4WV03k59vPYnNTAR9NGkvA64VQkIDHyylnrGNKWjFffe/rrJswjeHBHbH+CKqPS60soWD1+xTPWMSGM65m6Mp3eXnTbL55zPOMSqhkhz+PJVPH2HkWaWG9ZOqYA+aRl2IPevverskAlI+bTdiXQP7mT2Bur38kpQa8cS+9RVNOFtvOOBEJhRn/wht6DhCnGsUefCzUWXtBEZojd9VtCgzqrbCUGjBqJJlmvOSF69nlcR5st60W4yXLqqVpVT35DesomzyZ1ZdcSv6G9eRs207dkCGMeXtxzwQ+wEW/D2sR3jKTAJg6u5gN9w0mdamfIfOqSJ/dwm+e/CwvLJtHkixn6KI0Co+cS0P+IPI3rKPwyLk0ZeeQuXsXgza9Q3JNWdTDi5bUikqmPfU0K6+4nKU33oDl9zP+1dcZ/sky6kYefAu3cq8kmMkXd1/Bg6Pu5xfH/oirfv0rrl9zPyefvAHPDMM3/3Ija7aP7vT9/pQUdh81j73zZhP2JZJRuIVBGz4mpbrz0bBjQYwhZ/NWKieMw4gc0KK6JSOdkplTKJ05lcqJYzEeD8llFcz5+79IrqqJYdTxbXNDAbduvJA/1p3A+VkruSLnY+7PuoE/pN/C1tB4cq0qxnq3syYwhS+tvoW3P51G6t5ikkLVZOQUMn3RY5Q1TabkczNIHF7H9MefoPQo7U9cdS6YlIS3yW7tm5W2h7kT/0Vl3Why0neQlbbngLKZ9R/QnDiCiqzT8IQbaE4YSV3qTIyVRMaevYx98hny12/ECofZftwiMIbczQO3P8sXQzMYIjUc7dlKjUniP4EFrDXD+lxldSuDxdON57ByRSlXTHiHb4x4g1dm385/i+fzJ9+pfO7bX2DRxi2cePoGZi/azU2bLuO1kqNgAlihgPMC1IBXsP5jUipLKJx1HDsWncPfq4byDfMCF+R8yp+KT+XTiSO56gfXM3/ddpZMHcOnE0ce8P7jRq2jKeBj6d7xhHyJlI+fTcbezSTVVqAZqFTvE2OY/tDTAGw962Qyd+1l0OoNMY5KHYqGSIV1qmnptMyUhGIKg5nUhHXcAKWiToRiK4MR4So8JkxI3Hc2ke+pI0FClO9OYsqHzzPm3XfYM3cuxTOOoHSa3YVawapVPRX5gNYjgy62Vlob7EprZsMW8nmX8Tz/yXzAHnRg7LuLSS8pZuMZZ1E7bDjJlRVMfe4psrdvo25E3xkwqTM5O3Yy6z8P0ZyVRdbOXSTXaEVitGxuGczX9lzK3SP/yxOf+TZ8Bj5uHM/Xd16NrygDr7Qc1GVGS1oauxbMp2j2TMJeL5l7NjJo48ck1/bd1u55m7ZQMnMGtcOH4mtopGzyRMqmTKJ22FCwLFJKyhn1xvsMXrmWzJ17+0x3JvGuIZzEQ5XzeajyKOanbueKnI+ZlLST6kAmV5b9jGcCF9OcPorQafbtQr6GBjIK95JeUkT5kZPxBZuZ/tjj+JqaoA8N7qb6nkByIt7m/ScnWWl7DqqobiVAftX/KBx0PaW5F4MJkdq0kfT6pUy9r/CAsmWTJpK5Zy+JDQ09GX6fFsbiX8GjScZPMz5aiIeLxQa/8XJP4XE8WTqHm0a8zlVDPuL8/E/55+ATmH32Lubk7OL/bbmI58pnIV77BNcK6oUx5U5GyU7SX32QijHT2Tl9Ia/5T+PcvFX8vvQCPOF6Pp048qCKapvhuNHrWLJnIi2hBMonzCLsS2TwhiW9/hmUUvu1VlrnbtxK/pqNsQ5HHaKwWDThI9V0vj+f7CtinX9IL0al1MBS7MlgdLiS/HAdxR733XoO81UDUFRpd9OUVFvL+DffZNQHH1A+YSL5Gzfg9euxek/omQprABFurf8BaxpPYaRnB7PTn2FUwsE72fxNG8jYu4dQQgJJNdVY4XCPhdQTsnfthl27Yx1Gv7S0cQzfKb6Wi3LWszw4l/+r+y3BNB/cYk/3NLfgbWnG29yC199C7ZAhGMuiYPVaRn74Ec2D+lZXMh3J2Wr3abrs89fsey29sIjxL7zB4JXrSC0q1Vv/epSwpGEsSxrGwr6ewQ1DeYxBDybRmJtH7dBh1A4ZRu2wYVRMmIivsYFpTz9GYn1dLANXcSBsWYQTEvC2dN6apj1PuJFBFY/TlDiWtMY1eMMH51lTZib1QwoY/9ob0Qw3Lvnx4u/BQ5moa3PNsSqYym3bz+M/xQv53ugX+c4ou3uhn2w7m0dKjgIg7LEr4a2gtm9V7okx5G1bTfauDTx54XzOKHiFMcOmsqIqmayGD7HaVJgYIJCYwqhh9QzLqOT3JV9h2zEX0ZAzhPSirX36bkcVfUFfGlawCctof8l9iRjD0KUrYx1GVKR6mvnhlDdZ0zyBe0vPJBwGyxdCwiEkHERM0H4OB/EEG/tVLjZIQqcV1gkmSIG3jqcajuzlqJQaOKokhRY8FIRru1VhPdxXBUBhxYFjyviamxmyWltW96SonuX9/pWz+fbpzwNQFBjFs3U3MiFxBcuCs/i4ag7/L+9LXP7rF3j4u2cd8L7Ehno4hEZi6Vss6sZHqYLbb0FC1/PadqUw9sHotHDNWSVUHhGdeYkFxmE1hFJDeBriryXoa9XDeLFmEgFPDoPlScKSREiSSF6WRjAxiWBSIsEk+3nIylWM+GgJyTW1ADQPSnCcf+ZGi5pJXa+8xiFhUoqiMz5pwk9L8N+6v0N+X3MLR973b7adeBz5GzeTt2ETydU1+MqcfxAT76xk0xe77n9p++phjJmx97DjHhgOvDRQemUzgx8sJ7WinCGr7ZMEf0oqHr8fT3crj0ICnt5rHe9dnkbwyOhcsDEC0osN+4vr0ylI6x8XA9Z/JQtgX5cgbiUGSkgMdN6FUfmkCQDkbTxw4L4Rf/ey+6vB7gXZCZNgEH/vXS4Lew1WMDrLm5+3kyXlo6Iyr0PhqxECmR39aPZ/Pk+9l1Ca/V1tbRrEDeuv5Yi03exuzqEquH/Q5rA3UmHdRZcgqbssGkZG51goocyHP7/r7ds7ayZy3PRNUVmeVeUjnB2dynhJCGP8Xe+r4/VYqCMpFxTT+HRBl2U8wQAflAh1+Ul8PuFvXJX2DHXJs0hvWkHISsXvzSXgzSN8VjLnpv4agCdSrycUSCBr7yYGr/tw37x8b2YSOCk6dxIm5DTjr+y9AdXTR9dQtyNKAyTntUB5YnTm1YcYoGroQqqGLURCflJqdpBatYWQZzuZ26LTaiy5yKJpSO81TKrblkX62OqozMtbaxHM6L3YN34pl0n/jN0dooOzaympyojKvCy/EE6w94lJaVk8MOPvzEtcAbzFJYM/4iu1d/BBYFHH7w00ULDtGRIb3XfrKEOaMEXJUYgcrDoP4fSuK8z9dYkkpLtrmNAgCQwN14AxIAce82SF7cFt1/u73q67lTq2hoZtOjC8Um0ZEUqsDIaGa7BMmLDLbkGGeasJG9h0iZfUO6ITy3kzV/DsylnRmZkL4QSDFaVzu+O/+yFv/3phVOblJKoV1uNu/oinySPs8bD077ci+U3kf/5OMnKy+OSvv+DXa39NftVLWHOdr5T6RzgfHFnV7sK3mpwT0WoRnG7tD2aE2fZZ5+VlbHROhNqJLq8WuziBt1KdT/YSNrrbcddOjG0L98Q3Dj44sk8LqiMPqB1nIA0SgIQQ9sWOBsCC0qOB1tvCB7sY1b48EcvFV9E8yHm9bCnJdyzjXZUKx7Z/tYKCbU+DD6pmQBXJ+DOdT+SsoOBp7LpM6oxKKhpTuy7kUt4ydxu44tNcVj48dBjBdME3xGGlAMlvpzmWacmFstkHvRp5brPtcVOba7mr8Q0VOvdZFxjpnLAjXgbWOf/mCy91PsAelFPrWAagZINz/vseyHUsUznVog7neR0qT7N9oaozNePdfVdpG527nwiTBqOhcZhFyYLOTxqGPuO8ffG3qQAtmT6ZlPJyvKF6/Jn749h7osBe5wt1rSeOXbH8gnFRzlPmvLxQmnPOWk3uKhEfWek88ltuXs9e8LACkFza+XR/FnjKDt5eeoZAyAtJZcKoRwoPmh4kiSE0MoT927Dl34sM0pTmx9/Jqg6mhV1thkIp7vbvThW6KXssPt04zXE+ZqaLCzWVCUi182+pYJJzK1832yBvrbsTk+hc9umYBAVvedfHr0V1LgbcMgKTXHzx4QRerJrG+dkvMW7XP9mTfhbVaYuwQg0kBMtJbVqPt7mSC9IeYFXDCKxdj9G69KYp0HokZdV6YZdz//BhFz9lK0Rnw44doHma83FcqMQ5JjfnAQDhOuftGUFx1ROYm2PLQ+Wth8Hvd/2Z6oY5H7ON/9U6AIKJCaz5xvVUDZvDkHeW4G1sovSoWZSOm4iEQmTm7CZ362Zyt24hsb7ji+H+VAt/WjpNWTk0ZeXQnJVDMCGRMe+9gddvH2uUzBcIuzivcfF9mVzn80TT4KWm0EWla47zl+XJ8bu64zHkcNEMIGGP8wWPYFqYjV9yPmYC4CZ3xdoKNPsoXDe40+neWsvV5013cQNG7fgwQckmYdgUHh/1RSZ6N3Hl5h+R1FLOT8Y/yvu5x/DUmuO5/aPPURnMIeT1YjxeQj4fu+fNp3jsJUx+4Tlydm6n9Ejn4+S8BcXg4ti1aL3zdnboVOeK8sJ1gwnWOceVNa+RsEfwhcPkWfUE5cANyeBQLSEjvL5xBk3hrrdFlpsLrx7j+vxDqV5ncK48DTlvhSbN2elqcbc88Pl9fx9TsIF7TryLp984hrf3TNn3+mcu6LwLtDm+XdSQQu2KfGqPdl7e7nedz1esFnFVGXvsCasdy7yzbbxjmXBZEsbF4dBji11WRC9wLuK24eT2Lqb1yH2026+8kLqJYzni1t+RUF1LQnUt0371V1b99DuY0gCDN7+i3RwopZTq18KR/oc9AfddgjgJJCVTO3QYI5Zqv7JxqZvjEIQtuzJXdNBFdRieqpzNpXnLOCf1TZ6pqMSID8vsz6nMUDNzUzfxt70n6fH5ANOUm82n3/sadaOGM+n+xxj1v9cQYMrd/6Vmwhj2XnQSFeMnsPXkU9l68qmkFxWSu2UzibW1NOXk0JidQ1NOLk3Z2YR9+y8+eVqaCfkS8LY0M+b9N2P3AVVMBX2JVA6ZT2Z+Di/nnsYw2cN1n36eDysygUw+LP0WXx/zGjdMeYeTxizlny+fxYvL5mIitSo527ey9ryLWHfuBUx4/RWE+B5wslns30hyOECd58BK57RwC5saBjtWViulDs9HpeOpDmaw6MhGXmwYQWqVc/e+udJAhYlOI0DVPVGvsK6dOJYdV17EkFcWM+i9j6k2E6liKtnvrmPsfY+w7frLSGwsJ3vvsmgvWimllOozQr7IgHkBuyWYEOZHJz7Orpo8/rX8RIyrNoYHqhw7DiyL3G1bohqr6nnGoSqwqnkUlU1jyUneRnaS3WJkXx/WWmGtDsMnDaPY1ZLNRTnLebZqFmIOzKfTstfiEcPrVVM6mYPqj6onjuXT//cVwgk+jvzVX8lfvobq4FgqA5PI8W0ka9M2Et71Mvrdd2jMyaVi/Hgqxk9gx7HH2zMIh0mqrSG5spKMol0kVVeSXFNJclUl3uYmdhxzMiVTZzJ43UpSqvruAOgq+gxCxbhZlExewJiknbyRtYhMU83Vy29gec1oZm/fwYLNW/lowjh+EzqbD56dwy3nPcV3L3qcs+Z8zO+e+Swr18+mZtMIRhcvZu8189l82mfI255Ozp6lsf54h6wpUmGdZALU0eZuWmNIC7ewsm5EjCJTauAoGn0CzwTWcknyY5Qfk8/jKyZTtbvrO7RzpIGNoeh016O6J+oV1rvPPwPj8TD0pTepNhNZzq2E8WIRZMYzf8S6upmKEQvI2rtMW3EopZTqt/a1sA7aFdaT8/dy4TS7ZfSKwrGsKB7T7XlWjhlLQl0tqaXu+3NUfYMVCtCSlsueGWeR9eGLZO7cf5tcVfMolhbeSNh4sCTEvKF3YU0MUjdoKp5AI4Le1qsOncHiiYojuWXoG/xp1GPcU7qI8UllLEjbxoL07YxKrGR3czZrGobGOlTVi9Z85RqMZTH/e78mbU8R1cGxLK37FmE8WM0h5qX/gQTs3vdTKytI/biCkR8voSXNHkcmuboKK2R3pxFIPfgC7KD1qyiZNouyidMYteSd3v1wKqbqB42k8IgTAPip5yZGJhRxy5rL91VWP/S3O/EFgwS8Xq742hfZXjKKb9z9JX72uf9w/PQ1nDxxOw/d/SvCYQ/WhhBTeIqGW/IoH3MMGSXr8AYOYfCrPqBFvIQQ8kINlHnS9vVjnRdqwEeY5XWxG39DqYEg6EuictQ8flZyC/kJ6/jakL9z5cJMPlN0S6fvEQxZ0kQ10ekbX3VP1Cusxzz4FJVHzmDVT77N4OvfJVzpBTyEgTVnfQMjHgo2vayV1Uoppfq3yGi4JjKgR3F91r5Ja0u734rGADXDRpCzbYvuQ+PQ4E2L8TXXUTViJh/+6GZy121mzMtvkbtuM5VNYwkbD+AhbGDbkBMp/94kPOEmhmz4X6xDV/3AnaXH4ZUwXxz8Dufl2AMJ1wSTWFI/hgeKjualyhmHdNeHil+5azaw+9RjSai2+/utDEwiTGQ7FPm/gK0HvS+xvr7TvqxbGWDnwhOw/H4Gr1sZ/eBVn5ZWupNhn75O6aSjuDX9rxwbPJ4fTvofG+sHs2DzVnzBIF5jIBRkweatLBuUyrfOf4qjJmxm7a6R3P7o5wmHPYBF2MCW3NMJpKaRt/3duK2sBnvAt52+bMYGKhkarKXQl0lquIVxgXJqrESeLjky1iEq1a95A83kbXufbWMXcTYfM7/0PT4afCzXTn6bbWR1+B6DEDQWHm08EhNRr7BOKSxmzi0/Ydkff0zR/52A9b0QYQMkWFjTAgxd/TRJDS5GaFBKKaXimBW2W54Zy64EqmpK58vP3Ug4bBEId3/325CXTzA5maw9zn2tqb7HG2hm0Nb3yd2xFCpGs/OUY/jklhvJ2LmHQQ+uwXojcrzkE8qunUb+unWkt7yNJ+hi8EKlHASMl9uLT+HpytkM8tXSGE5gfdMQwliEW9wNeqr6l2Gvv8uuM0+i6Lj5jHrxTXJ8G7GaQ4QBixA5vo0c6qli6eQZ1A4bydi3XyWpriaqcau+T4DcHavJ3rWOwrlTONH/Eq8VnMdD8+7jJ3suJ/CKF0JBAh4vw46r4qYz/kAg5OUPz17Ac0sWEE6qwrL27xNbjk1n4svPQ+rmWH+0w1bsySAz1MyoYCXNlpcx/goC4mFjwmACpkeGF1NKtZG782OsQDOhhBRKSrfyyuwjuG7yYn4d+gwNdDwobgteEtHu+WKhR7aKbSutW/6aCisgJXMXc27/GcXfnNoTi1RKKaX6FAlHWlhb+yuDPtw1+ZDnVzNiJACZe3YdXmAqpjwhP6NeXszo199l78I5bD/9eLb84AysM/2wzgMzQkxa+z9Gv/Yu264bEutwVT+z05/LTn9urMNQfUDGjj1kbNnBnlOPZeSLb5Ll3ca89D/s78Pau41GJnZ7vkFfAnvmLSK9aA/5G1b3QOQqXljhEBmVqwhUeTiv8hc8OflH/PTCh/hWzq+Zu+R9TjzpI66Y/xEvFp7Aj1ffTKnJg3kGMYZBU9ZS1jQFM0uYuulpsvbspvTIfnBxTYQtCfnMbNnLZH8pYWBVwjCC0g8+m1JxIrtw1b6//7z6M5wyfDUnyzqeC87usLwfLwkEeys81UaPXcazK61vY+cl5yIpISb87UE8fn9PLU4ppZTqU2RfC+vonIRUDx9JUnWV463YKj5YwRAj3v2Y4e8tpWT2NHaefAxJ42oY9fz7ZG3TixJKqZ43/PV3Wfelq6gZP5qsLTvI8m4jy7vtsOZZOPsoAimpTHr5ae2+SgEgJkRtcTFXVF/Ng/Pu446TvgUnwa7gCM6pfJrnORdmtuuS6GhIrKlh6v+eJrWiPDaB95CQWGxMGERWqIlGK4FGKyHWISk1YG2rHcyzO+ZyzphlvB2cRA0pB5VpMV4SRSusY6FH7ztJKSxhyu139+QilFJKqT6ptcI63O0Ka0N2aj1pSc2kJjWRlthMakILEydmMLRiM6NPWkVqUjMeK8wTHyyisDIv+sGrXiPGULB8DQXL18Q6FKXUADPk3Y/ZeO0l7D3lWLK27HAsn5zYzE+vfJCM5CZ++dgl7CwdfMD0lrR0imbMIW/TOtLKdHBgdaDS5nQ+t+Q6zhq8ivzEWu7YfjKNoa0c8+YfAbvvc0QwIiCChEL99qJHg5VIg9Vx9wNKqd71t9Wnc+6YZZzuXctjwXkHTbe7BNEK61iIaoX11tsXOJbxNLqbl1Xdu304hROdO1G3WtztMhuGO88rZY+7CozmQWHHMr4i5xFL/bnO8+kL8j89eCCNhrxcUsor9h2wVM90t3O3ynv3ICDk4nsI5bnrrF9CLpaX4vyd1m7NcrW8sIt0LJ/jLvbM5bFtJRDce/BV0fZqJjuvYCvY+4fIKXucl1k/3Tn2vSe6235mve2csyVTovc7KjzFOWetpqgtrkOhZKg6ovN16HY7H0pxLpdQaR/YeAIWCfWd/34qpu1vVTQxs5Bb5z7J3PztHZT8F+QBkyCAhWA4c9HHvCAzqJVkfvny+a5it/zOsQ+d6q6ioXDdYOdCYRfrVNxtX0Y95ryx2n1qjqt5HapQEtROPLx96vofurvI4O3l+p7kIudB9xpnufuRmhrnfYHlcvyaiqXOeZbs4saDjB3uvreSha6KHRJjuTvmdOTyNxOudfE9uNzuuWG5OH5xK9zsvC9LKHcu451U62p5LbvTHMv4atwNTBnI6LnBmYKpUDa36/lbTc7facNxdncfuVs3UXTCAkZsXo4ncGAfnXtP2v95s30N/O3Iu5mSXkhdMIm7v/lnfrXpHP6z+2jCSfZvq6zgWLAMid53KDrxwN+b1Ry9QT2lwjmvk0fWuZpXy5YMxzIh3B3bJpY776OS51Q6lqnek+lqeT0lmOFuW1nnvOqQvJYD/q8gkX83zYMmIBuEFqqva+n4ze3j2uy8XorWD3I1r+HTip3nVem8PJPj7g7yq5dc7zwvj8vterLz95M8OH4Hp1QKYMqcHY5l1q8Y5Wpe3hldHyTuIYHtnlzmyzaqk5Kol6QDpicH/aTQQniCy99VsfM59rij3N1N+cHLRziWsVyc+vtcdnYRdA6dvJXu9hHbGeZuoV3Qnv1Vn1Y1eiTLvnA1Rzz0OIPWbYx1OEop5ZqEWvuwdj5JT/U28/Xpr3DlxHep9Sfzh5VnUdSYRX0gifpAEoOPzuTJ+i/w7bwvk2zVYUTINg2caVZzllnNC8zo6Y+jlFKqHypYs5rSaTMomzCJgnUd3+kxOLGGf8+5kxHJlXxpxbWsrh3Ob6c9xk+mPM0Jeev5zpaL2euZRGPGFDIrPsAbdFdZrJRSSvUF660CxoQrmBYqYol3zAHTgnhINtq9cSxohbXq0wqPtK8oFc0+QiuslVJxxXLVh7XhMyNW8N3Zz5KfXMdjWxfwp1VnUuNPPaCUr3khfoEkTz0mcr+Jb0WIrUvymTCvlLNmr+afKaewozG/pz6OUkqpfii9aC/JlRWUTD+iwwrrUcnl/GfunWT6Grl2+RcILPdw8Zal/HXjybx13GS+N/F5Xp7zR26ovIPng/VkVH4cg0+hlFJKHboW8bHJGsTUcDEbzGBqZP9d20EsvMRHjwX9jVZYqz7LiFA6bTIA5RPHE0xIwKsDdyql4oSE7Arrxuw8DHTYD+O3TnmGS+e+x6bqAr7+3nWsqjz41ramjAK2+2dydPJL+14b9GktZ167BssfJpwgcB88OPefnPTed/GHfT30iZRSSvU3Agxes4odx51I1chRZO/auW9asqeFR4/6O0lWgCuWfhnfqiAP/v1OfMEgAa+XK/ki51bezF/nPM4zBddw067lPGsO/xZgpZRSqrdtsgYxPlzGtFARH3jH7XtdK6xjJ3qdiSkVdYbM3YUApBcXY4W0o3ulVPzwtjSRvWMTpVOPZOvxZxHyHdwH5rbyAlpCXkakVXD80PUke/b34xi2vJSOO45dsy8jzarlxNSn900b8nENlj+MFQYrYPAtDVHYlE3ATYf0SimlVBsFa1eTUlHO2gsvYePpZ1I+fiLBhAT8YS+7GnPJ8DVzbN5GFmzZii8YxGsMvlCQBdt2cdQkDyMTS6gOpVNW3cMDUSillFI9JCBetlu5FJhaPGb/oBwZNNMo2iAoFrSFteqzxMDMhx4j7PEiJowV0qtaSqn4IcC4xc9TPH0ue448hsbcQYx/63+kVJXvK/P0ioW8HpjMLUc8z1env8rF4z7iT6vO5L+V51E0+QwCyVlk7V3JbXP+j2Rr/6jFRUdlEk6wIBBGfFA1L4Xrl9+A0evQSimlusnb0sKMxx6mcPYcCmcdSdmUaUgoRGLTXs7bMZO/B27lOxNe4s3TJhN4xQuhIEGvl3M/u45Jec/xfPXR/GTDiZT5YztYoFJKKXU4iiWDSZSSb+oplkx8JkiOaWCDVRDr0AYkrbBWfZonEMQT0JbVSqn4JMCQNZ+QVlrI1uPPZu15V5NcWYrH78dYFsayCCVZvBe8mfl7l/L73B/yq/mP8Cse4d3mhdRVh6jLtJjIXpqNl2Z8NOOjaZaPFfcP58iPd1E1L4X/HXkE9a8kOcajlFJKdcTX0syoj95n5JIPqB0ylKox4yiZPpbCIadzQfg0bqv+Pj8+9dds/OcwGpZmcsRxG8iYUcsX1nyF1ypHxzp8pZRS6rCVSxpBhAJTSzGZ5Jt6LKBEMmId2oCkFdZKKaVUD0svLWTac/+hfMJ0qkeMRYzBCviRcBgLAybMivrRnFb2AOdmvMZxKe8xw1rFhOQ6crIayKYey7Sb6SwomZXOyzKNgOjuXCml1OETY8gs3Etm4V58ie8R9KXTmD6G32TcwEYzlf8efTUcvZd/VZzLH989irpAEiTpXZBKKaXiX1gsyiSdgnAteGCwqSWARYWkxjq0AUnPcJVSPao+bzhJtRV4/dqvoRrYfC1NDFmzlCFrlh7weu3oA4dj/Bj4mGOAY/a99u3LnySRIEkESCJAMgG8hNlJjlZWK6WU6jHeQB0ZlavIqFzFBzs9jM/4F2mmhtpaHQhdKaVU/1MiGQwxe0gxLQwO11EmaRgR5zf2giHJVRyRs4vX9s4gPAC6guz1TxhK0SvwAC057ZvKHbpAlvM69VX3n2Se8ECLc6G+SqL3vUuwdzeahzKWW3NaNjvmn8femSdHP6AeFvZG77vqbeHM6HWjk7W+d7cd4eTY7iPCidH73mvHRPE3KkKL+KiRFEokkx2SxxYZdEBl9ffPeCZqiytcNzhq83IjnBC99T7itb5/nGHVRu8ig9UUvd9o0xDndZe8Ojlqywv7ongslOZcpnZ0/zkWUu4FN0bvNt5AZt/fvkTTsDcP/LyWCRGuKTukyupwL7fCbt6VHrV5eRp7d9uRNbymV5fXo8oSHYs0NDiXcUsC0Tv2GpLj/D14E0OOZdzypUfvIlBTibYGVf3flFk7e2S+xZa9/xgbLiedln3dgfxqztNRW8bmlSO6/Z4Z2bt44pQ/8Zej/8Xjp9zOzJwdrt8bSuj24jpVPrP39om93iwrnGgIu9iwWy194wpGW65PrLICzmWaPTS6OLkyHudlJpT5CDskYGiku9at3h3ROxE9FFsvdbd8y8XHMS5+RxLFY+ewi+89aZu7AzLfkdWOZeqKnRPIana3MTFJzr/JxGJ3I+MOfWYXAMGEBD669TI8TX5m//4hkqoOPOhb5Wpu3Tdmxl7HMttXD3Ms4xve4Gp5gT3OB4RuK2Hrxzn/3n0pznkWqEhyVQHoZsdVPdPF9gzw1LnYnbjYhKZv6uHdkonO/mXkC3UH/B+2hPohg0nfW0zr3LdcmUp5tvO8cieUO5b58z8vdCzTMDq6lQFuKq0Tqpy3MeLmXM7l7nX3yc7fXTgx7H6Gh8DTBFnrOv/c1VPdfQ9uKq3dbDvCGe4uULlZnviF5tyu151JMFDuYl+W5RyXJ8HdiX7QuOifXQxBh/qp3AkVBI9zscDNua7iOiSWIZTW9ef21B/CFeLOFtcHj6fdsuqc18OCE9c6lnl/yRRCu52PmXw1ztsza3otuDjHTH0vtn1dutl27D0peiecbo83oybkYl+QFaSxKsWxnDfsPC/jNXhcfMZgmvO+p8ZFTFZJItHbCsSYESh12IaLocFFxbZxcWzrtm3QnrUuBlBzkRvW0EZX+zLZ6q4C2U2dUijV+fftHdpIKKQXaVX8Wr9iVNTmlfK28zHAioltl2dY4NvBlHAJAG83T6KMDB7/37GuWvyG012cC+S1sHnvIMdiW77wD/uPQD3SUAyWh3BiPtOkiMdO/gsmIYMrCy+m1nRdj7Z69SjcnNWPesE59p2fheJTnOeVvN1d/VFXdCumlIo6A6y97hLqhw5m5j//c1BltVL9zeYzT2HJTTdSOHdmrENRSimllFJKKXVIhM1hu+FOnUmkjOjdsXNIWqqRhiLwJGA25MOdYcymAkxiFvhr+WfOg5yRtAaL/ncXmFZYK6WibveJR1O0cA4Tnn6ZvHWbYh2OUj2qasxIdh2zAMvvZ+O5Z9CUpaNIK6WUUkoppVQ82hK2Wz834wNid7eaNJVjNZWBNxWzIQ+5tBj5bQVySSFmbRomfSTbg3l8NX0xv896gqGeqpjF2hO0wlopFXVlM6cCkFpYHONIlOp5lePHgCWEExIIJSVSO8K5yxmllFJKKaWUUn3PZjOIZ4OzeDh4VMxisAhDSw1GPJjUAviwGQLG7m4xYOCDJvAk8sOa81nhH84EXymLErfGLN6eoBXWSqmom3HPw2Ru3cGKr17LrhOPjnU4SvWoMW++R+6GLQCMfPcjBq1eH+OIlFJKKaWUUkodihZ8fBweQ4nJjFkMYSxMyiDEhJCmcjg6GXyC8QA+sf83hpvSX2dWwh5ea5rCU42zYxZvT+j1QReVUv1fQn0D837zD1Z+5WrWXXMxweQkxr74ZqzDUqpHWKEQsx542B7ox5gY3jSmlFJKKaWUUqpfSEjHhFqQlirMjCTM48PsltVHJ8OcBKRhLycnNfFgw3webZxLLLsv6QlaYa2U6hFev5/Zf7mPDZ87n5xI61Ol+isr7HJYeqWUUkoppZRSygWTlAuhZqSpFDNrOMzNgXAAqdsDYT9/qj2ZN1umxDrMHqEV1kqpHmOFw0x98KlYh6GUUkoppZRSSikVX0QwKQVI3W6koQiTMhhpLAZjMKnDeLOsf1ZWQwz6sLZa4reJuhWIYuxJoajNyp8fcCzj2ZUcteX1J6aXfwHNY1uiNq/0gnrHMuGkcNSW11LgnGf9SWBPatTmZTX1bqL5cpujNq+slb6ozcuNuonBXl1eTxr/YEOvLi91RxwPSxHF3avVEtv1kLWud5dv1Uav7YFJcL5TQPzR+7JCfk/U5oVxjqtic270lqfixqL50RtXILwmI2rzUj3Lqo7etlGCvXv+Gh4cvfOFmBMXd6C52H67FcVZgeUce7gwJYoLjJ5gH41LqXh28TnvRm9m5YndK295MalDEBPEatgLCCZ9OPjc/dZnzNjZ/Rg7MeqJqM3KUVRbWLvZQYhxV2ntqmJ7VKOLqCBc7FxZ6611PsH0TKt1tbymmiTHMlnLElzNq3aCuwrHUIqLci5+FMGUHrytXSCc2PX8c5c5n7xWHOmust9NpV2wxYPTJ5ZKd98VDc4/Jysg+HOcv6umMufK0vQNPtJcBeascYRzmYXzN8B053IfZEx2t9BvuCvWXbs/dP4waeXO86kfHe6TldaBauff8fAxZZDtvL1qWjbEsUzVjDCeeuffpUSpntlb5aUpPzrz6klbroxebtQ2Oe8zyHIuEshyt78IZztffLKq3F2oGP6G8354z8nOB1ISwlWltfE476POXrTceUYRf3Ndcr9QmqHy6M4rE6zq6F3kMTl+50JVCUhddA7nTK7fcZ/oVmamc27UbcvCuDkUdVPh4UL6Ngv/NhcbmLHRu9jbngSEpL1d50ggs+eW3xE3x9xmZJOreYVc7KNyR1a5mlfV5hzHMsufnuZYpmmou/XpZr1bTRahTc6V1s1HRu/CcTwIpTkfm7s5lnDLTSOicFIYq855mbmrnbcv5bPAzcbR+JwLZS5x3ufXTgi7mtchswyh1M6/M0+Du+/KN9z5wnxgT2rUtuFRmg0AQ6eWOJYpXDfYsdI6cYRzAyKApjznA2Vpdneu4GY9JLj4bpSKlcEZNdx02ktdlvnTx6c6zicr193vr9bFidTDixe5mhfpUTxGc1E/t2jVhQf8Py9xB4O8tXzcPIayUDoAI9OrHedT+/kcplB5wGvNmRmEvR5SKvYfl234inPjjvRtFhmrHYtRP/rw15V2CaKUOiQWYT6XtITqcArP+4+gv3Xwr5TqvrBlEUhNIbHO3QGkUkoppZRSSilnS1tGQxRuwmnMzeajb3+JcIKPo/54Fxl7iw9/pj0gju8fVkrFikWYrya/xWcS13J58lI+l/QxrpqeKKX6tTWXXMB737mJxlznlpFKKaWUUiq+fXjXan51+mI+vMtFk0ulOmAR5hTWkY3eGdAbWtJS+eTr12E8HrzNzSz72rU05mTFOqwOaQtrpVS3ZUgT471l/LfpKHKtemZ495DEbJpx2X2KUqrfMSIEku1bnZuys0ipqHR4h1JKKaWUilcf3rWak784Dj9TSHjVzxusZuGNM2IdloozmTQxhnLKSaOK6HW7qDrWMDifYFISc+74F97mFpbedD31wwpIqayOdWgH0QprpVS3VZtUvlt3IU0kAIZkAlpZrdQAJ8Yw5/6HCFuCFdY7LpRSSiml+rPFT1bgZwohvPgxLH6ygoU3xjoqFW+qSOVBFtBE9MaBUZ3L2bqD4279HV6/Pa7RsT/+w76/+xrtEkQpdUia9lVQS5u/lVIDnVZWK6WUUkr1fydclEsCfjwESCDACRc5D9imVEfs+gQdE6u3tK2g7quV1aAtrJVSSimllFJKKaVUNyy8cQZvsJrFT1ZwwkW52h2IUiqqtMJaKaWUUkoppZRSSnXLwhtnaDcgSqkeIca4v3VXRMqAnT0Xjoojo4wx+d15g+aPakdzSB0uzSF1uDSH1OHQ/FGHS3NIHS7NIXU4up0/oDmkDqDbIHW4Os2hblVYK6WUUkoppZRSSimllFI9RQddVEoppZRSSimllFJKKdUnaIW1UkoppZRSSimllFJKqT5BK6yVUkoppZRSSimllFJK9QlaYa2UUkoppZRSSimllFKqT9AKa6WUUkoppZRSSimllFJ9glZYK6WUUkoppZRSSimllOoTtMJaKaWUUkoppZRSSimlVJ+gFdZKKaWUUkoppZRSSiml+gStsFZKKaWUUkoppZRSSinVJ2iFtVJKKaWUUkoppZRSSqk+QSuslVJKKaWUUkoppZRSSvUJWmGtlFJKKaWUUkoppZRSqk/QCmullFJKKaWUUkoppZRSfYJWWCullFJKKaWUUkoppZTqE7TCWimllFJKKaWUUkoppVSfoBXWSimllFJKKaWUUkoppfoErbBWSimllFJKKaWUUkop1SdohbVSSimllFJKKaWUUkqpPkErrJVSSimllFJKKaWUUkr1CVphrZRSSimllFJKKaWUUqpP0AprpZRSSimllFJKKaWUUn2CVlgrpZRSSimllFJKKaWU6hO0wroTIrJYREy7104QESMit8UoLBVHNIfU4dD8UYdLc0gdLs0hdbg0h9Th0PxRh0tzSB0uzSF1uDSHDl3cVliLyGQR+auIrBGRGhHxi0ihiLwgIp8XkcQ+EKNPRG4SkftFZEUkRiMiN7h47zUi8rGI1Ec+32IRObs34h4o+msOichwEfmBiDwuIltEJBx5z/jejL2/68f5s0hEfisiS0WkTERaRGS7iNyjORRd/TiHjhOR/0Q+V4WINEdy6DkRObk34+/v+msOdTCPxMhnNCKypyfjHWj6aw6JyLWRMp09vtSbn6G/6q/50+a9mSLyUxFZJfY5WW3ks94pIr7eiL+/6685JCI7HLZBRkR+1Jufo7/qrzkUed8gsc/L1ohIXeS4epmIfEdE0nsr/v6un+fQ+Mh79kTeUyT2edq43or9cHhjHcChEJFbgR9jV7h/CPwLqAcGAycA9wBfBubGKMRWqcDtkb9LgGJghNObROT3wLeAPcDdQAJwGfA/Efm6MeZvPRLtANLPc2gu8HPAANuBGiCrZ8IbmPp5/jwJ5AMfAA8BQWAh8HngMhE51RjzYY9EO4D08xw6KfJYArwJNAAjgXOBc0Tk58YYPUk7TP08h9r7JTAqijEpBkwOPQus6OD1Tw47qgGuv+ePiEwGXgWGAa8DLwE+YDRwCfa5WiDq0Q4g/TyHbqfj8y8Bvo9dD/NSVKIbwPpzDonIaOxj6UHAYux8SQJOA34LXCkiC4wxTT0S8QDRz3NoLva5WDrwBvAw9vH0ZcC5InKCMebTngo4GuKuwlpEvg/8BNgNXGyMWdJBmbOxDyJirRE4E1hhjCkSu7n/j7t6g4gcjR37VmCeMaYq8vrvgGXA70XkeWPMjp4MvD/r7zmEfRJ2HLDSGFMrIouB43s0ygFkAOTPn4D/GGMK274Y+dy/AO4CZvRArAPGAMihXxtjbmv/oogMA5YD3xeRO4wxRdEOdqAYADm0j4icAHwT+Arwjx6Ib0AaQDn0jDHmgZ4KbKDq7/kjIinAc9gn+YuMMR+1m+4FQj0T7sDQ33PIGHN7R6+LyOnYdTCfGmP0wtlh6O85BHwHu7L6NmPMT1pfFBEP9sW0k4CLgX/3SMQDwADIoXux92O3GGP+1PqiiByDfRHkfhGZbYwxnbw/5uKqS5DIVabbsK9mn9lRQgEYY54Hzujg/fNF5AkRKY40h98t9i1dQ3siXmOM3xjzUjdPyltvUfxFa2V1ZF47gL8DicB10YtyYBkIOWSM2WOMedcYU9sTMQ1kAyR/ftO+sjriN0ATMF1EcqMW5AAzQHKouZPX92K33LeAsVEKccAZCDnUJtYM4AHgDWPMP6Me3AA1kHJIRd8AyZ8vAROA77WvrI7MM9iXT/D7ugGSQ525MfJ8ZxTmNWANkBxqPVZ+rt28QsALkX/zoxHfQNTfc0hExgJHAKXAn9vN6z3geWAmcGy0Y42meGthfR32rViPGGPWdFXQGNPS9n8RuR67ZWAL9o9+N/aByA3YtygvMMbs6pGou+ekyPPLHUx7CfhRpIzr1knqAAMhh1TPGcj5Y7C7BwFtVXQ4BmwOicggYD52/BtjHE48G0g59BcgG7tLIhU9AymHZonIzdi3Ue8F3jLGaD/oh2cg5M/nsI97HolUanwGu3uHXcDLxpiK2IXWLwyEHDqIiAwGzsHubuC/MQ4n3g2EHFqLXVF6FrCv2wYRsbC3SWHs7h7UoenvOVQQed5hjAl3MH1b5Plk4J3eCan74q3C+pjI8xvdeZOITAT+CewAjo+08mqddjL2LRV/Bi6ITpiHRkRSsftJq+/kysnmyPPE3ouq3+nXOaR63EDOn4uxbyn6yBhTHeNY4tmAySGx+007G/tYYzj2SVom8HVjTHksY4tzAyKHROQC4Brghj5w0N/fDIgcirip3f8hEbkHuLmzu0GUo36dP2IPpjgTKAO+gN2Hfttz5gYR+YYx5r5YxNdP9Osc6sL12BVkDxhj6mIdTJwbCDn0W+zj6J+JyInY3eolYPdhXYB9fNSn+x/u4/p7DrWea40SEengrqDWFvyTejGmbourLkGAIZHn7raM+DL2zuGmtgkFYIx5A/uqyDkS+5FWMyPPNZ1Mb309q+dD6bf6ew6pnjUg80dExgB/xW5hfUuMw4l3AymH5mLfDfQD7IpHH3CdMUb7IT48/T6HIq3Q7gJeMsbcG+t4+qF+n0PYg05/HftELBUYij1Q3g7gi4BWNh66/p4/OdgV1LnAr4CfYQ9slYfdes4A94jISZ3OQTnp7zl0EBER7PwBe/+mDk+/zyFjTCmwAHga+w77bwPfwN6vPYY9GKw6dP06h4wxm7AbvA7Gzpt9xB437+zIv9m9HFq3xFsL60O1MPJ8vIjM62D6IMCD3XJ5Wa9FpeKJ5pA6HHGbP5FuHF7C7iPtq8aYD2Mc0kAVdzlk7D6H/ykiScAY7D5B/y0ii4wxX+r63aoHxFMO3Y19jHqDU0HVq+Imh4wxbwNvt3mpEXhcRD4CVgKXi8hvjDErYxLgwBQv+dPaoMsD3GmM+WmbafeKPSDjX4D/h96O39viJYc6cgp2i8blRgdbjKW4yaFId0TPAcnYg+29D6QA5wF/AM4TkYXGmO0xC3Jgipscwj73egm4XezBI1dgX4C9EFgNzMLuWqbPircK6yJgCna3Gd3ROkDYdxzKpXU7ouhqbUGd2cn01terez6Ufqu/55DqWQMqfyKV1W9iX8m/yRhzR4xD6g8GVA7BvkEY1wM3iUgi8EURed0Y80SMQ4tX/TqHRORq7O5jrjEdDwCrDl+/zqGuGGN2i8iLwBXAcdiV16p7+nv+tL3T9ekOpj+NXWF9VO+E0y/19xzqSOtgi9q6OjoGQg49AMwAZhpjVkVeqwXujDQGuR37TsZrYxFcP9Dvc8gY86aILAB+iH3Mczx239X/D3tcj0exB2Xss+KtS5D3Is8nd/N9+yqCjTHSxePtLufSw4wxDdiJkyYiQzooMiHyvKn3oup3+nUOqR43YPInsg1aDEzFbln9l9hG1G8MmBzqxEuR5xNiGUSc6+85dGTk+V8iYto+Iq8Pa/NaVoxijHf9PYeclEWeU2MaRfzq1/ljjGnEHkALOm4kVBV5Tu6VgPqnfp1D7UUagJyHDrYYTf06hyLdSRwPVLaprG7rrcjznN6Lqt/p1znUyhjzqTHmImNMvjEmwRgz2RjzJ2B6pMjSWMbnJN4qrO8HAsBFIjK1q4KRVlytPoo8H9tTgUVR661lZ3Qw7TPtyqjuGwg5pHrOgMgfERmOfSv1ZOBL2rI6qgZEDnWhtRVDMKZRxLf+nkMfAvd28gC7a4fW/1s6moFy1N9zyMn8yPO2mEYRvwZC/rT2DTu9g2mtr+lt+IduIORQW9dh93n7sNHBFqOlv+dQQuQ5Q0QSOpieH3n291I8/VF/z6FORQYXvhz78/fpO17jqsLaGLMDuA37B/yCiMztqJyInMH+VlwAf8P+Mv4UGdWzffkEEekrCffPyPMPRGRfB+iRPoy+in1ydn8M4uoXBkgOqR4yEPJHREYB7wDjgOuNMXrrYhQNkBzq8DZpERkHfD/y7wu9F1H/0t9zyBjzqDHmho4ekSJVbV5rimmwcaq/5xBAR59JRCwR+R52/5PlwMu9Hlg/MBDyB/g7dr+e3xWR1oohIrfh/yLy78OxCKw/GCA5BBw02OKdsYylP+nvOWSMqcDuTs8L/KjttMh26IeRf9/o5dD6jf6eQwAikioinnavebG7tRoP/NEYUxyT4FyKtz6sMcb8MrKSfwwsFZEPgE+wb7EZjN03y4TIa63v2SAi12OPCL5WRF7G7lbDB4zEvjpSht2aMKpE5Ltt5jsr8nydiBwT+fs9Y8w9bWL9QET+CNwCrBKRJ7B/RJdij1r99ciPSx2i/p5Dkfc80Obf1vf+RkRar+rfY4x5D9VtAyB/FgOjsQeJGC0it3Uw2wd0O3ToBkAOvSoipcCn2LdVe7EvgJwR+fuvxpjXoh3nQDIAckj1sAGQQ0tFZA12H9V7sceBWYTdOrYRuMIYUxvtOAeK/p4/xphlIvIT4CfAGhF5DmgGTo98rg+A30Y7zoGkv+dQGydhVwwtN8bEegC2fmUA5NA3sBt4/FBETsXe7iRj33U/CtgC/CbacQ4kAyCHTgTuEZHXgT3Y/WqfgX1e9gTtLob0ScaYuHxgd5D+V2ANdufzfuyO018CPg8kdvCeGdid1+/EbqlcGXn/ncBJ7coutlfPAa+dABjgtm7EuTjyns4eD3Tyvmux+5NpAOqwb88/O9brvT89+nMOOZQ3wLWxXv/x/uiv+eMidwxwQqzXf3949OMc+gbwfCTGxkicu4DHgdNjvd7706O/5lAX8zHAnliv9/706K85BPwO+9i5ELuisRHYgN0yamys13t/efTX/Gnzvgux7zqrjeTRWuAHHX0ufWgOdfK+RyPTvxjrdd1fH/05h4AjgP9gH0f7gabIduiXQFas131/efTXHAImAk9iNyBqwR6D4S3sgacl1uvdzUMiH0QppZRSSimllFJKKaWUiqm46sNaKaWUUkoppZRSSimlVP+lFdZKKaWUUkoppZRSSiml+gStsFZKKaWUUkoppZRSSinVJ3i7UzghM9kkFWR0Oj1YneA4j3Ba2NWyTKAP1qVbLvv7DoljEV9ywN2san2OZYzHeT7G5er0+N2VayrdU26MyXdXOjLvtFTjzcnpsowVdJ6PleqiEBBs6VZ6d0pC7sq5WsfOqQGA5SI9ws6pgZXgLvhwMIq/t7C7D+nffQg5lJ5qvHnZXZaRgPPyTYKL7VAU10lSsrsfVnOT8zY0qlxs0sTNugKseuf15ea3FMp0tzyAlm2F3c4hb3Kq8WV2vh0K9/JXEE3ictW52VZlpDW6mldDINGxTLjJeSflZj8GMCyj0rFMmT/d3cyA+k0l3c+hjBSTMDir0+mhkIsVHHS5M3BRTHwuj6v8vXtc5Wa719Lg8gfnYlvlar+Z7nJduTiOA/Dv3Nsjx0JuPq/b44locbt9wUU54/bwzMVxt6t9vsvtSzS5XV8te3vmeDpaXB8Dx2AdO3J52paY4mJbFcXjM0+Lcxm358twaMdCvswUkzi483P6QLOLkwwgPbXJsUx9bbJjGbf543FeHCHnxbnmaXYu43q/4qZuw+vye3czL5f7iEM5HwPn7ZCb3Eh182MAimuz3IblyE0OudlHuTkPd83t/ryPDj3XU+f0ruoU+ug6ieYxmuXmZ+Jmk+Byfx52kf8uf7oEU9yV6yqHulWjl1SQwfw7P9fp9NKnRjrOo/HYBlfLChW52Lm5PPdyfZDtIJTibkbeaue97pBZxa7mVf3KEMcy/kzn+YRS3P2a03a4+3Wt+ustO10VbMObk8Owb9/cZZnEcucvNW1hmavlVWzOdVXOibfWXaKFkpzXsUlw9z0klTovs3mQcz4mj6pztbyG0lTHMsbjLnZPvbujzu03fbv7OZSXzZAff73LMr5iFxfORjsfrYQqnCviACwXG/8JM3e7mtfmlSNclYsWNyf61kh3FZfJHzjnUGK1cw5Vn+lueQBbLvlRt3PIl5nD+Ctv6XR6w8go7TBiwGp2t60KJzl/xtMWrXA1rw8KxziWaVzvcEAKBNPcHUX9/LTHHcvctfNYV/MCePuUP3Q7hxIGZzH+jzd0Or3Oxcm5VLir/Ah7nX8zSQXufjMte51/oxLFA383272tS0a5mpebi9mpe53L1J/g7hg0UO1u+7/zxv/rkWMhcXFBw7jIjWjyNLrbvrg5ifFnu9vOujnuTix2PpUJZvT+dt3t+tryvZ45no4Wr4uL0QDBblSw9hbxuzunGTvXxbbK5fGZcXGRJWOr8zptONrdtgpg66XdPxZKHJzBzL9f0+n0ovWDXM3n2AXrHMt89Mp0xzIBl40VstY6r7vqqS63jS52eJkbXXxXJ9a7Wlyw0EXNTb67WiApTHIsY3zu1sOhnI+BvR0a+n83dzr9hPlrHOexIGObq2X95pVz3YblKGudi3NsF9cDmwuit80Lu6wfsFxu03rbIZ/T//RrXReqc96/W24bgERJ2O3FWTcH1C5DT93hvNCwi8PWhGp3y2tysfnP3OouZytmuVvm9pu/1WkO9cFmzEoppZRSSimllFJKKaUGIq2wVkoppZRSSimllFJKKdUnaIW1UkoppeJKsvEzPHxgf9ZJJsDEsLvutpRSSimlVGxNNkUcZzYxzpSSZOz+5EeZClKMy05ylVL9WnRGpVNKKaWU6iUzwnsZZ8pYwhi2WfkMCteyKLwVHyEKPDUUh1wM7qCUUkoppWImjRbGUsYU7AYHFSaFbBrZxGDeZlKMo1NKxZpWWCullFIqriyzRpIabmFBeDtDTA0jTCV1JPGmZ5JWViullFJKxYFPZDTL/j979x0nV1U3fvxz7vTtvW82vfdCCr2DgCJFFBVQEcWG9fF59Gd59HnUx4fHBlZABUQFaQoCUkMJSUhIQnrfku29Tp97fn/MJqTuvUlmd7Z836/XvDaZOXPuuTNnzj33e889R1eQTw+ldFJKJ/tIZRWTk100IcQwIAFrIYQQQowoMeXgVWMqZ5l7qdDtVKlc3jLGE1V2l+8WQgghhBDJppWimQyayWAj45JdHCHEMCIBazGgiDcV0+nC09uZ7KIIIYQQh5jK4HVjCln46SAFlEp2kYQQQgghhBBi2PNnF2I6nKS11iW7KCckiy6KE9LAgUWXsPfcGzAdcm1DCCHE8KKVokOlSrBaCCGEEEIIIWzwZxey7+zr2X/WtfQUDN87G045YJ1l9PHljBeY6ao/9FzBNTWW70t5PfVUN3kMZSYsK1sc/sTF9xs2FSUsL3eXdRqH/+RP5tsmzqe3cDxF21djxKKnULLB0bs6f0i3F81IXEVT4cQFVbzN1vUxUJ2esO2p2NgKCDlyE7c69Z53yhOW11Aza1KGdHtZzwzt9o6WWjNyr+Oa3sS1Vc+vmp+wvOxw9iZuKo/bKl5PWF6nIj0jYJlG54YTtr1gY+J+M3qIm/lJS6sTlldfqXWatJWJ64Mmm4oO7ZcVS0lc++LuGNp21tk9ctv1ZIumDfHJVgJpt05YXpPmHUhYXnakvpnctqp4RnPC8lp26VbLNK6uxP1Gs7Ynrm3smmZd/1NfSUvY9mjxJCwrFUnuedvKtbMt06zpnjgEJTl53nYbaRoTV2eNBMYHxhrTmbh23g4jlsDMhrbohLPe/XcoJZOq5e/DFfLj7W6neulVBDLtx9i6Jg1dnT2pYbO57j4+Uro2/kYd40JzJ1NTm3jDmALAfz57LUweuGE3syIQsN6so8A6WKSbPcMyaK1d1vmYGVFqD+RZJ5xiHSg2gtZlyprcYb0toOAP8V9Ob1EBW688i7xtu5j1+5c5ukputpXbkZQJRmDgsoby7H2hoT25lmm8Tdafi3+6jaCkPvIHfiJGh9s6kbLXMgVzrdNl7lF42gfex47lIfq6vdbFCll/VnPnV1qmAdiyYYKtdKfC1aUoeXbg9qPxTOs6ZByw8ZlEla0rerFUe3XWVtDaRrRIO6zrht12sWCO9QlJQ302sT7rRi232XqjzUttFQsafDYTnjzTDX3jhubAMW5Wg610Nc05lmkWVNRaptm4flLCgtZmZpTntlqfbBxzcDgOw2aZDBsBuP/edrllmt7Wwb3oYShNijtywtebd+XZ+VjsbSvLOrCdnd1nK6+wHtoASEuf9Ul8554c8Fi3aWZZ0DKNd6uPkMV6m/6pYbDRnuVssNc9Tly4/UjaxgmYETBsBSRMn/Xvz8y00dfsctoKWscS+PNLyfVbpnFvybBM0zXd3hmmr8H6wpmdQSIAXfNP3EYMF2aWdRl9e+0F0MI5NupsAoMydgaAaLe2FbTet7nMMo3pNcFnXY9S91u3Hb3l1mXSLg2Ng9cXivpdNG048eApO+0GwOtrZlqmydmsSLeIzMQ8CmwEADtnDe2Jv7fJIJQ1cJrowl5bec1aUGWZZt+zE2197/5S68/B3WFAYPCCSspt4ik5cf/D1IpVNQMHpKN1KbyKjb6mDXYvTKY0W/+OmxfbGEQxrddWIE1tt+4LRTJNW+2jEbJxzLfRpxoOVEThqh34+GLnHNv0mraC1s4u6+/U2WfjuGLzOkUkK3Ftla/Vev9C2dZlL/tn/Lw/nJrCmq99BBVVnHHnvTiDIdb822eoWfxelv7415jLrGNaPVNjtNiIbyfiwtkpXxqKKgf7VR7jdRtuPfw7ZcI+0+lg803X4wyFmP3QY3T5y9nfcg6d/pE7SlQIIZLNTZQ7Ml/kutS3cTByR60JIYQQQgghhBg5Yi4nG27/KMGcLBb++gEiVSnU7V/I1P96jpjLxduf+xhRV+Lu9EiE07qXYbcqxIFmkm5NVHnEMLD3PRfSU17CrD8/QaAph3WVH2dP00Wsq/y4BK2FEOIUOInxvdx/8P60d/hc1kp+lf9nShydyS6WEEIIIYQYYtlGH19Ie4lMZX0niRBCnC4NbL75A3ROGMfcPzwC2zTraj7BnpaL2brpGqb84F/483KoOeN9mGr4TKV2WiXxEEUDmVjP1yhGjtbpU3CEwvjaOmjvm4CpHYADUzto7xu86R6EEGK0uiFtPcu8ldzZcTHfbb+Scc52Ppq+JtnFEkIIIYQQQ2yeqxa3ijLV1ZTsogghxoCY20XLnOmkNrVQsHkH7f4j43zR3T6y91fjzy4h4kvcOmin65QD1oY2OcvcSyc+3lbDd1VJcfLm/eGvOP0B1n3+E3jHdWGoGBDDUDFyUu3NYyyEECKuyNHFTRlreDUwhaf9c1kZmMbmcClTXIlb1EgIIYQQQowMK0NT+VnPRawLy2AwIcTgc4YjzH7wMfqKC9l249XkpFQeEefzX5xL+7RJFG1/HY/f5oIdQ+CkFl08nKkMXjamEcJFRJ1yNmIYSm1pY8ld97Hu859g57euYNb3nyRYk0lOaiVZKUO7SrYQQox0n898GVMr7u4679BzeyMFLExbj5NELjcthBBCCCGGP0UUG4v7CSFEgpSsf4e+onz2XXEhaY3NLPnHfbT7JxBb7GL/Jy+kbNU6MtvfTnYxj3BaU4K0qzT61PCalFskxsGgtRGNsu+rFzC+8A0JVgshxEk607uXM337+UPPCvbG5lCjzqebcvZF8nEpkwpnW7KLKIQQQgghhBBilJv8z5coWr+ZXVdfRmRpKjlnVFH5pXPJ2bWPmX/5OyrZBTyKDI0WJ3QwaB31ejBMM9nFEUKIEcVQbj6TuYrtkcl8xf8kQUcWAEpHKY6GgH8y2d3CK0xPajmFEEIIIYQQQoxuSmvmPPA3AnnZbLj9JgBSmlpY8Ls/YcSG352/CV3+8TuXP2a9wU5XwranCkIJy2uoGd2Ju1Zgeq2DyZ17s08p79SWNjIP1J/Se0eClJ027hBI5GUmnbjMuqZoyzTZqxN3B8TmTWNrjjXttP58hyudwJa9uKQjcZmNchpFMKWEjsIV1E3+MBdnaEqdrXym624y9R5mmA9yRuyHZFDDc+ZXCJgeJrlaErb9BYv3JSwvo2vkXs9Oy/MndfsF01qHdHsdHalDur1EyprSnrC8grOtFwBP2e1O2PaSzfSd/EACA5OPjXuNPyy8h7kZNSe3vczoSW9vuMjcmbjb7sOZCctqRAhMTty5luke2n6VCieuz20EE3rKbElFkjvGzQgkbn/b51p/747Q8OxzBwut21nnhrSEbW/S5fsTllc4O7mDzQxl/Z06SxPXX4tmJG5/C9bbCNrtStz37upK3O/NCA238bGDa8jb5hE8hrP2ioJD/3ZEoiz49YM4/QEwTRb98n5c/qDtvNJ3D910Rid1RtrYks2dv7n+hK/3VVh/g44+A0efdRDt4+974ZjnnMSOmOvpnhcusswH7P1w7QR9MW02AIZ1A61zwvbioL3WJ1cqZiMnQ9sKWrffbrPD8Fl7yQ6nHZpo9sAnPPdc/Psj/q+0Jlv76VZeoir+3d9Zc6mt7f2/iqcPy8ekONZNjuknqJwElJuAcvFM3zw6SMEc4NrN40+faWt74XzrkznbHUCH9fdw0wWvwcUDp3ngxXMx2qzrkHd8t2Ua3z8zqX1nkmU68+zBu5AUc0NP+cCfoafcel9CB6w7GRMet7cfveVeyzRNy+0d3YpWWadpXmqdZvzfI7a2V3iGdbBo9aaptvLqnGynbg+Do7wCc4CLEXlv2/uNHt5hiXi8NM1cRMvUucS8vviBv/tVvpr6vzzceDbVm7eSAgSBIG6y1D+Ill/G5px5FKLJfd6H0gP/5jcumGyrXHaYGTbaqh5HwoLWdo6vS2bbO0nb8xfr+hjMA5+t3E5NJOikeWf+iRPYOEmze/Fywr3W6eo/H8YfTEwg1tlrXf+jafZ+x8FVudZpCk17n1erdb/RzIrinx4eMI2j1YWj3XrgRPvsQWyrFJiegffZTr8122awf92Cv8X/EQuj/E2oWBCN4py8XeDORPtyuWD7+y3zKU2ztwDP6rWJu2MkvN/GKvUZ1klC+SaGjQBgoMQ6SJG+14FpY+yNcg3eKKWMtAAXrdg8YJrnN862zmeT9e/KYbNLF5hkY381mNZdJluDemLpNs45M+2da8WCNk68gw5b54GBYhvtmY02z0wf3FFuygRX34lfD+XZawPtHMp8jQb+woHT+MfbuyCWuc26bvRMTFz77eoyiFnU2WBJBDqtf0tb68dbplGmgkLr+uEqsL5AG6tNIZo6eBcCdNggXHviC+amy+a2baSz036DvaB1+3Tr37t/QhQYuE46uhxQaT1gQGdal8n2BeEE9cvt9h8W5NfZSnffKZTBGYC8LQN/Nt0V1n3SYK7GEbb+TosWNFqm8T9abJmmr9QyCQDFr1nX69rL7P1G2ufZOTe1zitrm0HTOQVHPDf7778BoHeGg94Z8dfCWdZbi2RoexcL7PTxLYyYIVTjaOMGtZ6VeirrGFsjPceqNDPI7GgD6TpEBIMaRzY1jpyTykNpTWGsm3HRDjzE8CsXaWYIFz0AzHI3EtWKNtJo0emHHlvMUiIj5+chhEiCiDeFxlmLaJk2D9PpIrt6D9nVu8mor+Y31/yUvqib/91x4TEnzIaOkV/zT7bnl/C+7FfZc8FVTHr1GRzRkTuCUQgxTGkN4S5UoBWUwkwpBFcqKtAO4U5UpJcLfDt5OTCNxN5SJoQQQgghhquR0OsbERE5LxGuUptxYHKB2kWTzqAG65E7YmRSWjM+1sbEWCsRHGx3FpFr9jIp1kZFrIOmtFU83reALp1ywjwMTApiPYyLtuPTUbqVh13OQroc8XF3Th3DpyPs8ReRr3rIVz0UqB5mqAYcSjPfrOEP0bPQI+Jn/K5CumgnVYLtg6Sjopy+/HwKtu/E7U/utAMnSyuFNoxhOTfVSBPxpdI0YzEt0+ZiGg5yKndRvGUtvq74iIXLZ77N4op9fHP7tbRHjhzNP24V+DbnEpjbRmW5Iie3g/RyFzsv+wBTX3oSV2Bk1SsxtDTQW1hAanMLhsWofCFKnR2o3jpULIB2pqBTCmFDBN7sQq9Ig/npqEAz3875J5cFt/Kzzouoj2Ulu9hCCCGEEEKMjKjWIqrIUEH+bC7hcrWVi9UO7tNnJbtYYpCMj7UxOdZKt/KywVVORDmoc2SRZgaZE63ng6nrudi7gxtbbz1hHh9Le5NpkWZ6lZutriI6jBRQ7wafo8pBj3Lwtjn+iPcZmJxhVHK1cxPLjX28aSbuNvzBlkcPtztfZY9ZwEPmsmQXZ9SJOR1suulGtMNB5fnncOb//WJELUbaMH8ukRQfFavWJLsoI5pWiu3v+TDRlDQyD+yjfP2reLs7D73udkT4wvlPsbV+HH+tPXL+lnGr4K1HbieMG/fOMFPSGmEGXLjzfu6f/m32n3UZ0154fIj3SIwkLdOnsfUD1+Bra2fCytcp3L4j2UUSw1SaEeTBkj9ALIzpKwR3OrwdRF1fBxENLoX+Wyl6UTm/qB7HrRlvcG/BA1zb+GkCevTM9S2EEEIIIUamoZ2l/BR1Eh9J68TES5R2TjyyVox8TUY6vcpNhg4yOdqCQ8fIi/UwM9pImg7TEkvjj73LB8yjp3+SvG3uYjocqUcEqwdiYrDGnEiVmctZjj0oG/MBDRdd+Hg4tpg3RlCQfSQxojEc4fj8qEWbt4yoYDVA8cZ3KF+zLtnFGPGU1hRtX4+KRektKKU3r/iIVuLyWW+Tl9bDL199D/qoQ6xvcy5h3MRwEsZF6uYc+qJuVua+H0yTvL3bh3ZnxIjTl58HxOvh9mvfx9pP30q3a9YIOlKJoXK2by+ZjiA6rQQ8GfF+0JsBiGhUjHjQ+s0AKMUTfQv4l38mCgjpETGWRQghhBBCjHIjole6iyICejsfMN4GYP1Ro2LF6OI3PKx1jWdSrJWKWDtl4U4AArjY7izi35qutZzyYn24gk+wiqyYn2anjRV5jqB4IzaFj7jWMFPV89ip7caQi+Bkhy5JdjFGLQWc/T8/JZiZga/LemHH4UYBSqYDSYjCHRvIPFBJ9YpLqDr7ctonzqBi9Yt4+rq4cclr7GoqYX3NZI6euSowtw33zjBhNG4iXHvlU9zTewvVubOY+Noz5FbtTs4OiREjkpqCMxBg6a9+R/PM6VSdcxb1adfhjp1DXuBV0iPbUUCWw09EG/TZWeFMjErnp+6iOZpGnuOwOrDCFx9ZTXyENSveXZ50qquJPZGCARehFkIIIYQY6dxESTHCdJoyEHa4GxEB6ygOtlHKYqrp0l4OkJ3sIolBZiqDPc4Cmo000nWIGIpGIxOtlK35mfdH8wjjINsM0GxnCfmjbNfFdOgUznTsPZXii1FKwYgMVovE83V3MO25h2mZNo/aRWez7X038cGmu5mY18S3n7qReG05ctxrzZlwBr/GtzmXiy97iTM+8DYfbPork1c+TXaNtDXCWjglBZc/gAIKt++kYPtOdn15Cq2+c6lPux53rJm5kcf4R9nXCJhuPlh1Kx0x61XsxejiVRHO9O3j773zuD7vsGPWYh/6b6XxkdUrfLA4HrB2YDLZ1cJT/rlJKrEYKUzDQU/BOJzhAKntjckujhBCCGFLgaOb5d79rPDuZ5GnGo3ik80foSqal+yiiQGMiIA1wEZdTikdrNUTGBnrWYpE6DJS6DqlKWAUHUYKOWYfaG17SpCDTAzejE3iCucWZmTWsqOr7BTKIIQYzRRQsOsdMmv3U73sIj42+5/UxUr42ZQ78aY3oXw1eHtrccQCh95TcybkXNTAZ878Gw/4P0qscj3ZNVVJ2wcxskRSU3D39R36vwIyIttIj2ynxzUTf8piflt6Dx5DkW708quyv3BLzc2EtCt5hRZDbrlvP14jyit907ieo6aCWvxuoPqgcc52vEaU3eHCISylGCliThfdRRPoKptMd9EETJcbFYsyeeXfJGgthBBiWHKoGPOzqjm/cAcXF2xmsrsVgPpoJs/4Z3O+bzffzXmK25o/SnjkhEXHnBHzzbSSzh/1mckuhhhBOhw+Cs0e0nWIHuVlT2gGm0OLWeF7mWJXneX715njuUhv5+bJr/Pvb39oCEoshBiOclO7mVtSRYo7TIo7SIorTIorRIo7hM8VIsUdJtX9E8707uQHOz6F6gvSNmkmpms+AK5AC76+A3h7D+AKtfPBuRtxqQi/3zWPlJ5K5CKssCuckoKvo+OY5xWazMgWfp/2HeY7d/D+tocwHF4ey7qWH5c8zpfqrk9CaUWynJ+6i86Yjw3BcXB0wPo4prqbANgVkYC1iIu6vXQXTqSncAo9hePQDifOYB/ZNTtJb6yift45VJ75Xqa89Fc8frnzTAghxHCguahwG1eUbOKc/J1kuQNETIMt4VJ+2Xkuq4MTqYrmAoo3g5O4M+8xbs98lZ93XZjsgosTOKmAtemGvooTLzSWu9H6pLtjhr1t/WXfYss0k+YdsJVX5dpxlmm8zdZz9oXTbW2Oin+FLNM0nmFvXslAifXCbsrG2m/a5pSE8+ZW2UpXbS+7owqhMIIDF+RTT91qmY2ry97OfLrz87x867d57a2lfDv6I7rKpgDwc75DWlMNOVXbqFiyEgfRE+YxN2MOV5Rv4IcHLqMlPPDUIkbAulzeRntlDxZaL6H1l92LrDMy7C3FFd5jPW1KcI7NRQYDg3cdzHRD37iBy+HebGMKmGzrfdn3IbetMmnHsfNC6/7pIA62iMWv2Pve26/xH/OcS0WJHLYIlrE3zTKf2vM9trbX0lxsmWbOLHu/9qwFAcs0xd4uyzRPPr3C1vZOmQYjeuJj1Te+8eAR/0/TQc6J7sV7VDthakUQJ0HtIqRdBLSLjZFyqkv6eC//jakdvFx1JkFvBUHPOHpy5tCdt5As1cFt6XfwVOcZNET7IAu0YV3XUmusj6/Z76m3TAMQM63rY9PGIlt5mV7r31LOBus24e2gzcVipwyDxU4dGjMnfMKXfbutf39RmzcOtcw7sq8QykzFHWg64nlza/zfn5v5HJdmbOdH77yX7XtaaJ1wFl+e8hN+lvElvty6hv+OXWq5vZR57ZZpuvdl2Sp7sND6uzLT7c2r72y1rkOq1XoUubI5jb+zdxDncdZghE7/ItX5JcefRshBjPPdu9hmlnJOyX4aY72WeZXGOumLuVndOPGEc1hX77A+XkBiL7+ZRdb96bC2/r15m+z2vazrbNDmncPuysGbP76718eLbw48fUuKjfOaUNaR/9dAV9FsevKnEcgqA2Xgbe9g3GtrKXxnG1n7a1A63q8sfWUfa7/0KWoWXsXSn/6WzunWjZqyuTqsGuAYfaisqdY/ZlXjs0wD4LDRV9Zue4U3PdZ1yAhb75+3anDvijGdEMo7cVntnBfHM7JO4p9h/Tt2tNjrc3dNs/7eX3/v/x3xf6cZJTPUg6kMOj0Z6P67bs95/KuWeUXSrb/31Nxj++7H496YaZmme6q9Pk6swUbddgzucsyTs5r489U/O/T/9FiQoHISMeLH6w/88cuWedhd4zealri+X9T6NIrrzlh/xP8VmjMde9gRK6aNeEDo+T8us7W9Cdfut0yzZcMEW3kVTGu1TNO8I98yTceeHFvbe7Fm8KbhjWXH6Lx+4P5JZK918O1X19576N+pZogZ0UZytZ8QDlqNNKqMHNqMVH7fc07/3J5QQScADWTzbGgW16dvoNrI45dnW+/vhN/b6+Xsv95Gv9XGsQ7sxb4imda/EYtQ1rvpsqzz0hknjp8dznCd/vpZI2aE9UjWPr6C+oXzyduzl8It22Qs3RBp8IxnQ98cFs9soKexnKJtq8ms3UNX6WTax8+iZunl1OnzKGAjxfot0jlwzHfzeN8CrknbxIdL1/CzykuSsh9iZJmc52B2seLh4A00x3IxzAhNH4jgiEQwohEckXD/3wjerg4y6g+Q2tKIoY88OJS5OvheyT+Y56vlswc+xJq+iUnao7HLp8OcFd0HwGuOSQSUmygGURw82raYgUIzhorhCdfjCdeTyWo0DkKeYj5X/DIZRg+/rT1jiPZCjBYaiLp9OMPHnhxfXraJz896nscql/CH3ediEKNg/6v8rWM8E874DHdM/BV7HZP46/bJ0gcZ5SapFlJUhC2m/anMZvvq2BYolgUXxzDTcNA47XJ686fg9reRc2Adaa17mf6H7cdtM9KaWllw759Z/9lb2PSJG0mP/AOlh8EFRTEijPO04VZRKoN5xHAMyjaU1qSHe8kI96FRKDTuWIRWXxYxQ0IgiWRok/JQO6ZS7PPkHwpajxZLjf1c7dzEEqOKn0cukmPlMOPQMSbFWqmItRPDYLuziANGlq0pYf8aPIOZzgZu873GI86FtERPfu0zMbhGV2syzAQyM9h78QW0zJyBEYnQPHsmdYsXMvXZ5wHrkYbi1ART82kft5TevCk8E9vBN10/YtmLd9Oyr4zuuomkl9ZQWLSW3vwyes+dQBOLaTBWkKIbKNZvccG2v7PknT1smlfG9lklvNg6gw+XrubX1ecTMmUeUHGsdEeA9+Vv4obiDcxNjY9I/l7at/hh6238uufDuFpSiDldmC4XUbcHMzWNmMtD69RZABiRMOmNdTi9+0mL7ueTmU/wpYIXMbVBazSVe8c9yFfqruNf3bOSuZu2Zas+lrn2M87RTpuZSouZTrOZjgK68I2Ijp5HRzgrug8XMV5zTqZLHT16zH7Yz6linJu5g+vy7ufCrJ283DmNHQF7oxWFOCjm8oBh4AwdeTfDrKwD/HDJX9jQOp7vbLgeUARqiglUleEbX8vdvbMZf8Gl/Pe437DfcTdrtoMjFkzOTohBN8dRS0g72W3anN5Da2b4GvlL25LBLZgYtqIuH/Uz30swo5j8fSvJrtt46LXjHek6/eW0900gx1/JrL88wdaPXk+4/WJy6/4lF8SEpSuyN/PzSQ/jVCZB08muQCE720vZ0V3Kju4SdvYU0xv1HbpPUXHyI4W90SDZwR6cOkaf00unJx23GSU30ElhXxttvqwE79XYZiqDKk8uE0OtTAq1sM9jPcp3pMjAzxXOzbTrVEqNTs5x7GZlbHqyiyUA0BTFupkWbcJLlFojk93OAiLKOsQ5eUsTMzc0sH1hMXfPO5//SnuSn0x4lJv23IIeAeepY4kErAdJ4+xZ7LzqctCaCa+8yrjVb9E0awb7LjyfdZ/8GHn71lKwd3WyizmqaBSN0y6jp2A6RjRI0bbV7O4O4Xi/ybRoN6v/cS065kA5Ykx+72OkU0u5XsMUnqBZz6NRnUH+jgJ+9rW/4o6EiLoMvvK/1/H7vLP584LfcUXBOzzeaD1VjRhLNF+veIaPlazC54iwKTyHL3T8mD01LXx93N/5UeFPuSXtL3znpZuobis45t0Rj4+e4jK6S8rpLinHmz6Lv2Z9k2XutTwbOJfv155HJBbiN+Me4udlj/Dl2ut4muVJ2E97clQvn0p5jemOBgwF7WYKmSqA47D7gGNa0UEK7TqVVbHJ7DBLklji41Nac2Z0Pz7CrHJMOk6w2p4MR4Dbil/jhrz15Lt7aYmkcX/Tcn7bcE6CSyzGgqgnXg+doXdHWKe7A/zqzN/THkrjc29+jIjpJFBTTO0f3z3eld3yGN8yz6f0khr+UPJVVjhepnXHDtyhY+fCFiObQjPLqOeAziFq84TLZUbxGRG2+odfWywGX8zh4cD8G4i601lSeR8vLfk8/+V8P09WH/8CRqe/nHWVH8fUDgwVYwm/Z1Ley+y7/AJcwRYy2zYM8R6IkeTcjF38fNLDbOgdx19bljAjpYEZvgYuKtjGDeVvHUq3PzqeTdH5POO/hFe3+zC7raerAshwBsjzd+CLhYgYTpq9OYSc8elGgoaDptRc8gKd5Ac6uKZ4HY83yIW6RPE7POz35B0KWqe7AvRE7E3LM5y91/kOTkx+Gz6HK52budSxjU2x8mQXa8wzMPndGfcxL1pHt/KwyVlKl2HvfG3ylia+8blncEZMoi6DH9z9Hh5cuJxbM97g5oLV/LH55NbNq128kEhKChNee+NUdkVYkID1IAlkZ2G6XHg6u0hrasaIRklracXb3U0kLZVQmr25g4R9WhmEUnMBcIb78Ha1saO+iN2txUwwYxAzQBvoGPTWlZFa1BBPS5AS1lKi13Ltxp24I2GcpgkRzfx3ajlwVXzCwpjdicDFmJHj6uMz5St5pX0aP2r4EM/nfpucpmdJ69nGzds+wSU52/jB5Mf55Ud/zWcevJ2ao4LWrlCAnKo95FTtIcUd5Odf+A2TnC3c2vJ9fh/9Kh5vC2Xd9/Oxqpt5bvJdXJG5dVgHrFNUmApHG4aCqlgOb4Yn41UR5jsPMNEZn3fNoTR59JFKmGzszfs31Aw0HqLEMIiok79V1UOESzzb+OW8h0hzhHixcwaPVC1iZdc0onpwbn0Vo58jEgJtEszIhf51g33OEJluP5vbx9ERSgUgUFWGjjkOHe8CVWX4xjWwpz2TxWkBcjx+6n0FErAepbq1j8lGM59xvcLT0XkDplXaJCvYSU/Mw+pemXZqLDIdTmJOH2iTLHeAdS2TKE7pPGH69r4JmNoBODA1tAYm01cQ7yebzpEfnBKD672579AZ9XHL7lvwmx5oiz/vaHGhZ17AzLRqFulVzHVvYbF3LdfkPEnvilSeqZ/NoweW8FZwHCe6wy3X1csD8+7BGwvR6Umnx5VyzJQAUcNJlzuVvGAXU1KbBnlvxx6/w0O3w0tmLECKMzQqAtYeohiYTDaayVF9gMaj7M3fKwaP2xGlLCXej1VAio7QrfWhOeoHMnNDA86IicPUEDWZuaGBjCXxOw8zHdZrMh3N19GJr6PzpN8n7Bl1AesLvTtQaF4MzkxqOSa8vorM2jr2XHoRWz54/aHn3T29zHjiKfAdf7EcceoMHaNiw0P05E+jbdxSqlZcSWPXMj6wtpSvTnkErydEMOwGQ5NWWguAiUEPZXQyhQ41hdD8Rj7uegX6R1i3LUrhm1Oe4sXWGfy9aUGS91AMNxXeeE/7wcbl7OhIQ2VHiXgKoGcboHi+fTaVW/J5ZNpv+eVHf8NnHridA+3H3ibnNKL88LoHmOGt5/aaG3mtV1PofobG9Gto951NbuA1uk3vKd0WOZRqzRy+1H0DF3m2c7l7Kzf64qNlmmLprIuMp0OlUK+zqDcz6SSFxC7PlTgxZfC6cxJnR/dxVnQfrzsn0aOsO90HFzt7n2cTWUaAFzpmcGftJewK2FvAUIiBuEJ+0puq6Bg3i8Kdq1Fa0+zP4nsbr+WHS/7K7TNf4JfbL8U3vhbliKFjoBwxfONruXb8Wj40bg2/qL+OV4wLKA38Idm7IwaBRvGLyIUsMSq51LmNL7hfIhDw0u1JP3bOVq3JCXTgNKPcXvVRmmXexjHJFe6jYsOfaJx+OS+UfZ43264gp3YNHqMVwzx2saSc1EoMFcPUYBgmDbfOw78gl+yG18hoXZeEPRAjSYYjSFM4Ix6sPoLigJpES5ObHdX7gWLgYmYV9/HeaTXcUPwXPlC2ln19+TzSuITHGxfRctgKYsWeTv4073eUeDtp9WUTdB5/MVanGSUn2E3YcPLT/dYLEYuT44uFyY4FaHam0RTISnZxEuJP0WXc6nqN611vA/C78Dk0aesFNEXiRV2ptJeuILt+DYR7uOLVr/C3q3/GhFgbc6P1TKaFSmcu9UYmpjrxQMPtC4uJugyImkSdBpOXN7HIc4DfN63gFw0XnHS5cvdZL6wpTt2oCljPctXztczncSiN2WnwcjC58wvlVFax5He/p27xQnoLC3AFAox/bRXOcJjGMwZv9fCxTKHJaNlJessuwq6pNM5cyjuLPsQdPSu48/8+Q9feYkqm7GVl5jye4IP0qjJiKv5dpOo6DsyKcdv/foFz3lnFrvmFfOnsl2gLp/HV7TcwXINrInnKffFbFGsCuShM3MF6gt4jbxPbEyjks3/6NL/86K/55Ud/zWcfPDporfnmVY+wdNJu/r3ual7tnQpAengbfaEptPvOIjuwGq3VsA9YAwRw81RoPs+HZpGmgvRpD0Hit2MWe0fO3P29ynsoaH1OdC+7jEICyo2TGE4d42rPRrwqgo8wPhXBqyKUO9rJM/rYES3iF/4L+f2ek7ulTAgrOdVbqC56H13FU8iq3w3A41VLWJq/l8/NfJ63WyayBii75bFDc1gvmfcW31n4GG+0TuG7rV9D5UZwhTqTuh9i8JgYrDUnsTE8jvMcu7iIHRREg/S5UunxpKGVAVqTFezCEwvT4c1kde+kZBdbJJEr1EPZO3+jrWIpnaULOLDgRtAmbn8H3Sm1ZNQ2kF4Xf2RxgCUTfk+dZyGNt8wmPCedhb/7E+1ntiR7N8QIkOX00xU7dgCABmKuFBzRw++8U2xrSGOl6wt8Me8n3NbxFT5U/CL/MekZvjbhOV5um8EjDUuoDORx/7x7yXAG+eg7n+Sn5z5+3G0rbZIb6EQraPVlE5Z1iRJLa0ojHUQwaHKNngugIVzcGzmHYtWFiaJG5ya7SGNWT94sevLnEEwroXTHwxAL0uDIpMHIIN/sZWKslVnRRqbSTLORTrfy0me46VMe4q1MPJazd04hP7j7PczaUM+M5Q0sWnKAJ4Lz+X7tFUi8Z/gZNQHrFBXi65nP0RyLL+711cznaTNTeSec3DmGDNOk/K31SS3DWKTQZB/YRdaB3XSWTaFp5lI+O/MPfHLRPdyQ+jA3Ox/lq6GH+E3gel7zV5BGNW76AKibBX+ZtYT/l/UMxY4ubnjndjqjqUneIzEcjesfYV0Tik/x4wnW0p29AtNwY5jhQ+kqW4r43IOf5pcf/c0xQevPXPAMl8/dwG9fuYzHCxYekX9aaDs9njmEnfmYKJQa/gHrg0K4COmRfTJwMGi9OFbDXLP+iNfmeesJaScB7SKgXQRxURfL5veBs9gSLUU6PGIwpDdW4uluo3n6MjLr9/RfxFL854ZrmZNTw53L/sTVz3+F1nHgG9dAtruXu1b8gdZgOnds+gj+8SW4A80j4uKXOD1hXDwfm83czFbSwz2kRvpIifjp8aThME1SogG63WkEXKc2R78YXRSavOo1ZNVvJpBZQig1n1BaPp0Tx9G4+N2pZdzdPaQ1NNExaTy+tg4W/N+fSGtqpf1MmepQWMt0BtgbOHZNF2240YYTR+TYqeJy6t6gNnMSv3J/j8c2TmeSr4kPFK/j2qL1XJK/DYC2cCof2vgptvWWHX/DWpMd7MZlRmnxZRMzZHq2RMuO+Uk1I9S4swcc3ToShXBRpfOSXYwxry9rEs5QN1FPJg1Tr6Zk16PxF5SixZFOi5FGjvZTEuuiwOyhlC7ov1FoaUYV9bH4Xb71Zhb1C7KYtLSFOa56/hJYwtPheci52/A0agLWn81YSYGjhy+3X09NNIef5jzCd7Oe4ovtN1DJuGQXTySJQpNdu5us2t10lU7hWc8kXtB3c33q43xyzj+5K+/7NKZl8HDvYp7xzyJMPMD2npStXJiyi3u7z2R914Qk74UYrip8bTSGMgj1j9LwBmrpzlGEvKX4/JVHpN3fUsznDo20jk8PsnzyTm468xUef3sZf3jjQrjmyHmzPLFmAEKOgsOuC4uh1Ku8rHRMIVv7iSqDKA6iGDzatgRzBKwi7SKKRhFFTs5GA4WmcOdqas64ks6yaWTX7gTAH/Nwx+qb+duFP+POpQ/x8dc+hVKanyx7kFxPLx96+fO0R9MI+wpIa9+e5L0QQ8k0HHR5s+hzpZIR6iEz1ANAn8tHrzstyaUTQ2V+XiVnl+7kN1suJmKe+PTPGfGT3rqX9Nb41IUT/tZKOMVHb0kRPaVFdJcV01NaTOE725n58N9xBYJDtQtiFMhyBI47wjraf+HsyBHWcY5YkNzaV2me8B56s+exv2MTP9p/BXdWXsZ5OTs5P3cnv689m33+YwPhB6VF/KRGg3S60widYLoQceoMbVIc7qLPcNPhkIugIvGizhRCacXk1L6BK9BO0+QraZp0JVF9L86Dc4orRbtKpd1IBa1xEyNVh0jVYWr6cik1OpnubOIsYx8ApobfB87kpfCMJO6ZsJLQs+22BdYjdrJ3JG5UT1NPOgDneHZziW8Hf+47g+2REnq1l292XE1IO/nv7CfJ93Rb5hVOt96eu+d0S/yuorcS18HTTuvPVEVHT6grkmme9HsUkFW3h7z9m8mq3MULW2dxw1++yhee+gStZhp3ZL3MXwvv5cNpa5ntruMLmS+zLljBn3vPYML0hoSVPVh08mU/kcgB6xNNV1lfwrZnhEZPHbLDzv6O87ZTE3x3VJE7WA86Rsh35J0dDefHv/d9zfGgtdsZ4Xcfu4svXfp3Xt01izufvYbjhaOdZidKhwg7CtDYnxIkkXc5VnUM7aipq698c0i3d7Sv/vMjxz6pFB1GKj3KR0C5iSinrWD12dOGdq2CjmdKjnpG85O8R7mn4EE8KnJSeRUuaExcwWzI2j78g/92BaaGLNM4T2O90YyGPXg7m2methytDDzxmYnY013M9zdew/LCPdw+8wW+PPsZVhTu4TtvX8e2znKiniy0w43Hf+KFprp3Z1tvf1LnqRf+KEZP4i6kqGOn2z3GaFrz9PFXzzji/wqTGUY9OfQeN33U4aI9JYdWXw5Nqfl0eTKPWZBsIEb+yA1MhrITd+4RS0lcP26oTMps5DcX3MPtc17gp+fcj8uwv2BY5fV5uP0BcvZWUvHqauY89DgrfvxL5v3x4ZMOVush7kZGck/uuDcQFR7awodzk1vPggWJ237KjoMBYk2m009X9NiAdSQvPnWcI3L885bUjp34uqvoyD+bqDN+12tUO3ixbRbf3H3tEcHqs//xlSO3HwmQFerB7/TQ4z65O2a1w7rtCFYlbvqLjN0jsy+kgG6HlzpX1qHjyiO3/MT6fcN07cJ//HOZZZpLblmTsO3NWVhpncimghk2pmcyR945vT8rvjB0Sud+0jr3klf9Ev6siXxow1/Qx/uZKkVYOekwUql1ZPOn4HL+x385d/R8kI933cw3e67mP3qvOelgdeXHR+4div7yxLXrqnvoxj2f1JaUOXAQx/Roy6D1nVf86Zjn8s0eCnUPO4xCYip+NvGdbe+1LM+dc/6GR0c4M7yfTuWlMKeLr+b+69Dru8wCzohU8+CFv+RrndcS1O4T5rV/5XhiJ34ZgEiGvQoa+kaHZZr65izAxiqkLdZzXRtB60bHHGdvxdMtGwZvNLERAW/jwAdibaNGhjM0UZ/1d+F9X7Nlmmc2zeKZ52ayJGc/n57yErcWrgKgJZjO5179OG2hdExvYsdR2glaG0XW35dzRyp0DnylJXt5E0y3joy0rym0TOPqBTtjfEODGN80QpBaNfC3YSdY64nZ+EaPU8X6ssoIZhaT0lGDt7uZcYvbeTM0AWfawZOiCJ5IA6HUUpyhd0+UXLt8dManpmY9Zdz8+u388bzfsLF1PF/Y8lFCU+IVP9x97KgPV2orAYoxYwY6ahDJsz4Bc/Q5MG0szH1R2T7LNM+8PY8tTdYXR3Letv7xrpppXfeztxrYuH44aNIqDb57902W6bKurLdMU1117AKbx9M2386xxTrNT6988Ij/F5pdzIvGF5j9Xdmf2OyM3yr71bevs8zLrE4Bw3qbF63YbJnmefccyzRGAoMBvrpBPuGLKYyOEzc0WTust985w16nsbfi+J9LZvubNE28msb5Mxj3+rb+9hn+VXMGK1L28YVZ8b7Q3zat4IXXzyAN6CyNn9B7+ppRJ9i8dmm692UNWKa0CV2kTbCej17biE71VWXYClpPOqPGMs2uymLLNHYP5q46iw7haTAi4G0euCDv/8Drlvm81V7BOx0luIhyqW8716W+Tamzi9eCU/h+5xWH0l1Wc6tlXq7t1iPiwrlmwu7yMT32+tPuSus+sK/VOp+eiSbBQhvbtBNRVdpW0DqW5IDA1s/9Ov4PM4rqPQBaY3pyuKBsG5tu+i46tZjJD3/GMh9HULHvw9a3wrtsDOqJptlr92wNxLHzWw4YRNOsr2R5ik7jCuJRQr3Wo3dNZd3mGSE1qEFrIwLephN/iOEMe4O5PJ3Wac69Pr5YnYsoHiNGUW4378ncekSax7bMBMCh+074/efWv0jD9JtwT1/ERb5fnnB7bzw+n0t/+W8AnFe2jV+c9wfeap7Ep1/6JKHDTvYnX2J9XAlErU8q6rcW2Qpaf+ZzT1mm+cnzV1imGS6qgzl8dveHTvh6y+piy9PGUxmEdroGuMHkkOydmld/vnTANF3v6YMzj3+B+HB2YisqqmwdXzvXnPgugoPCUwJQMPDFxP9c8g8bW4Nn2ubaSldtK9WRzKhBoHPgk9UZ97w7wGLDZy7F29rOrF9s6/+smth7Jex978Xc8swfKdv0xoB5tZ1nPZjEcFnXR93kpep9lslwdlkfpEyfvfqfYmMMUZeNdUC1gr5x1tu0MwOps9TecTPlldO/ky/pU4Kk6yDLYpW4MCk0u1njnNA/MboNWjMnUo9Cs8VVilaKzA1+ctb4aV+WQtfCFN5xljFf1/KNjGf5btdVI+IWbjHUFOvaJ7Fu7SRmZtTywfGreeLAEtpCyQybieEm5nBTP+cKYu74ib0v0klhypfZE5hJxJGJKxYP4HjDNXSlLsXEicHxhw7s6izloqe/STDmImYx5M8dbsWfOqV/SpCRe1VXDDGtmRFrpBc3jUYmk80WWsw0GoysZJdMJICvez+evgY6ipZRZuzEMA8GZRQ/eulavK4w0ZiDO1+5+tB7QikFYMZwB9uSUmaRWKkqyFUpm3l/yiZyHH52hAuJRByUOqwHTYgxQpuovgYwY+hd+bA2hrk4G2NmB/Q14DYisvCcGDKpKr62S99xBpDF+kdNHz4lyLhV4NucS2BuGzVngivcxUL331kXvp7q6BtUON8ZcHtLi/bw03PvZ3t7KZ99+RNHBKuHB00JnTSSKfEJkVROHWOeriVTB6hV2dSoHIJq+BwbYm4XrTOnUPb6uiMC+5OefpHO6QU0zT4DV7CPwp0bk1ZGMXiSGrB26hjLopXEMHjHUcbcWB3nR3ezzlFh6/0VsXZytZ+tzmL8yk3mBj9LPlKDCmu0W7HuT+NoXZjGL9vP5wsZL/O59Ff4Rc8FyEyw4kS2d5fx7c3XJ7sYYhhqr1hMzJ1C2cbHMV0eSopjGEqzxXk5B/I/jDPaTkqoEofZB8pByF2KL3zia859UeuRYwCucDNmxjw0jpO5e1uMccW6i0wd5G1HOXVGFrm6l/nRWjoGcYG1dBVgoaOGGAaropPRcqwdNArIblhF4+TraJ08h4Ldmw69Foh4+PpTtxzznnBKAe5gK0qPvCkNxLtSCHG2Yw/fyP8nqUaYumgW/9N5Fm+FJvCpjNc427MXZNUDoTXK3wSxIHpHLurGFohocCnMh+JB698s+COf3niLBK3FkEghPsLRz/EC1imgTYxo/A7TcavgrUduJ4wb984wZ/Bras6EOa5n2Rtdzpuhmyhx/AcuFT4mL4C5edX88vz7qO7O41Mv3YbfZp976GjOZTdzqKeSXJ5ltgStRVLk6R7ONPeRTohePCzVVSzRVTSTTsTt5LXwFEIk9xjRNn0ypttNweYj12BRwLh1LxP1plC7+HxcQT85VbuSU0gxaJLaMpbqTtIJUWnkUmPksN0owk2MBbED2Ln9uSLWTgxFb/+I7Jw1flRYY5igIpqcNfGrtDWxHLpML5f7tpFnWN+6IYQQR+som0ta8x7S2qvJaNrN+JpXADgrcj+53c/jjrbRkzKPjvRzQEdpTb+YsOP05kfRQMSdx9mu15jsa6InKgvFCHuKzW5iKBqNTLQy2Gvk4ybGOLN90Lb5Be9LfNi7lpu8q5nlqBu07Yg4b28N3p4D1C46l6oVlxFMzzpuupjLzYFF5xFIH4e3N3FrMojkOM+xi3Mce0g14oGaUmcnX896nscKf8slvh24VRQ3Nib0FqObGUZFesHpg3UaIjo+z3tEw3qFdqZwXv5Ozs/fkeySijFmhqOB45/nK7rzFqCJj6wO4yaGkzAufJtzAejR+bgJ0KvzqI/NOiYHA5NPzn6R+y/9Ja2BdG598dN0hU5u3uqhkIOfOdTTRioTaGMcg9c3E2Igy8xKMgixWZXypDGPVWoiERwU0cPHU1ZxmWdbsotIX1F8ikXTfWTgPJyaQtukWUTd8QtS9XOXD3nZxOBL6gjrWpVFuepghtnEDDM+R003XjY4yrEzMmSzq5S5kTrOiFSx15FP+9IUtFthRjTapehb6mZupI5Ls3fQHEvjv7sup9WUaR6EECdPGy7cgXfnbd3aXs7f9i7l9skv0BV2cHfHNQQ84/GGqsjsW0NL1nupy/04+d3PkM2Ri2kYyuS84u3keXvoiXjpiXjpjfho9TnpiXnpiXrpVrm0517Ee3M3cH/GTRwIZvGjmvcM9W6fsmBGDoHMXLIP7El2UcakaiOHcrODqbEmahw5zIvV0YubKsN6LtJTUaw6qXC082RoPle4NzPN0cjWWNmgbEvEKaCg6imCjjNomTqP9opp5FZup2jrW3h6u9BAx/jp1C48h6jHR0bLZnLqBp7jb6SY7apjqaeSP/YuJ8YoWknRhhdiM9lhFrO/JxePisUD1CqKR0WJaAfbI8WEkz/jn0g2w412Z6LCXbDIAS6FJj7CWi0IoKIBHq1bzMvNM5NdUjFG1OssXojM4GLXDmLa4OHIEg6e72e0vE3Ym0d7yfkEU8sZN/8Z3DvDhNG4ieCf30Vb8bk86p+PkzBL3X+m3LHpiPzLjHZu9rxJxcJ2/lU9l/9aey1tweF53t+NlxiKLOKD6zoYvLvfhBjIamMiZ5r7mKfrmKfjg01MoJ5MnvbPZVV4cnILCJS9sY6GJfPYeNtHmHP/3zBdThoXzaVtxmS0w4Gnp5OiLWvJ3Z/84LpIvKT2aGPKwWrHRBbHqsnVfewz8thtFKBtraQBnUYKb7onMivawNRYC21zUnjnwRLS14bwLokwZ3Y9yoSH+s7gb32Lkn47gxBihDtiGWLFd9+6Hl+un38vfY4DKRfyW3+Qgq6/4zT78LTeR1PW1TRnXU1oymYK9q7Eo0JcVfE2t814mfHpA6/iHNMG3TqDbKOTNd0TuG3nTXTHhn+HVgOtU+ZRN+8ctNOJ99kH8HXJnLlDrc1Io9rIYYrZwhSzhSBOVrsmElaDc9hf5KzG1LAqOplZznqmOKwXvRWnzxELUrb5dQp3vE3TzCW0TJlL24QZpDfVEvWmEMjOJ6W1kckrnyRc0GSd4TCn0Fyfsp5b0lbjUJoD0WyeDx47ym40i+CkUuezLmxv+jwxRimF9sVHpalZXeg/paHXu1AL+lBzApjeXP5tyweRqWPE0FE8EVkAwMWuHZzl3Mses5BGM4P8Uj97erayKXghO/Lfz5sfu5mlzj+Tvt5Jx3Ifb9z4SUyHj2nOV1nifhSf8e4qn05ivMe9hctdW+jVHu5YeTMv1MxL1k7aEsVBHVmMo4NOfHRJwFokSZtK45/GHKbqJlII04WPGpVNWLl4JTw92cUDwOUPsPin97L+S7ey+db4Qp++ljbGP/8aXrMWX0eLHMlGsaQPwYgpg7XOCfFA0ClM0BpVDt5xltJqdjE92sjC2X6YHX+t0Uhnl7OAPzUvS3CphRBjjVaKo29hNLXBl6uvx/DkclfWv6H69vKsOQ4Ap9lDSftDtKedS6hkPu8p+ydfS7uT0pR2tneUcseqm9nYVkG6K0i6K0iaK4AxzocjYzxprih5sf0UhHfSFXby67rzCOnhf8Et4vFRs/QSuksmkt5QRW9BGW0T51C2cWWyizYmbXMUU9E/Bcha5wT8dhc0PgWLnVXsMQvp0insiRVwqWsbbiKE5ULxkHAF/ZRteJWCHetpmrmE1slzcERClK99kbx9W1FaE7ZeXH5YS1cBvpb5PEs9VawMTqXc0c4Nqet5MThD5v4U4niOClqrWaBRmClF4E5HgtVi6MWD1ltipSx37qdIdbHUuZ/zZuzuf/23dEVT2BmbyfYvzabeLMGtwnwk8jyZgUomZtbgJIZLmTgwcREj3+gh3+jlzchEHgktGfbB6oMOBqzbGX5TloixJaYMdqjiZBdjQG5/gCU/uYdAXg5aKTJq6lBAyzmFyS6aGGRJD1gfcjqriSlFnSOLTuVjYqwVJybVjhzaDTkACCES53itVHvKUq7p/hrPs4Kfld5DLPJBnu+Kj/hLMwLc5vseH89eQ4Gnk1WhZfz7pktZtyvjUG7NAYi402iZdC49vqk4/R3ktL2IL6CBCUO2b6erq3g8NUsvIebyUPb2K+Tt2UTV8stpnzCDks2vY8RkTtWhFlFO/u6ai4HGtHnn0qkoNjopcXTxUHAaAHtjhbzHvZUJjlZ2xYZ3B3i0cQf6KH97JaUbX0NpjdLW64GMBDNcDXwj8xmyjAB3dZ/H04G5nOXZy7eynuFszx5eDU1LdhGFGJ76g9bacKDMKNqdCc7htgCdGFsUe81C9oYPBpo0G9dNYlJqM5NSm5ic2syktBYuS/8nhc5WQtpFxG0Q9jkxHCZRHES1QRQHEQxazHT+ElrK1lhpUvfqZO2mCA9RdjN2Am4xhxsjFpZLZeKUuAJBXAfqk10MMcSGT8A6AfoMD1uMkXWwEkKMFOqoKUEgkFFEW/qFpAT38Znmq3hgUis/q3iYr9Vcx0RPC7fkrybLGWBV41S+uPdWnij4IsGiUrJiG8nf9zoKTUfpAlrHLwMMMjteJ7PrLZQeOcFdUznpzDuHnimL8Ha2MPmVxw5NAZK3bwudFdPpLJtCTvXOJJd0jFIKc5BPDRY7qzC1YmMsPkXBvlg+poapjiYJWCeJYZrJLkKCaD5R8Rpfz/4nLbE0vtR+PXuj8ZP7VaHJVEdz+GDqOl4LTU1yOcVYpYHu3AU4o72kdg3TNRuUAm+ujeXshV2pRpCflD7Kq71T+HPH0mQXZ4RTNIUyaQpl8mb7lAFTXrRi8xCVafD14OVNkj8/8FAJpBdTO+davD0NFO98FmfEn+wiCSFGgJMKWGsDTM+JuzveRusRXF/950dsbcvVZZ3XZ/beaisvI2x9sl64yTpAVH+evZP++u3WV0pNt71uozNsncbVa50mELU3um76fZ220lVaJzmG6YJg0dCdRLe+beN7SE1ceVTUun7EvPa2F+t1WyfyWSdpaMi2tb2lF++yTLP+TXsBAU/H4AXHTA/0jR/4M8zYY13XZ12z3TJN6+eOXDBu5/mKjH0hxv2rG4Bwio81X3wPaUY7V+X8HE+un/vMs/i6fo5fjH8YgA2Rcp7um8vzd50HwALjYapXnEP9gsV0Fc3FEQ4R9aWQs38vE15/hfYF3f1bO71FxFLHd1snAp57Y4FlmtLXT/xaX04eey55D/6sfCqeeZmpf34CRyR66PUCdlM/41y6syYz42f/oHOmdcc8aqNenxY98G+1d4K932j05RLLNI7CxLUvdo6J39r2Xlt5xRqsP+TCufbmoL4l7zXmh+roUR6uyVt/6Hl/0M3Z3t3kZvbwSsd8y3yiafY+K0fQun0JlCY5WGtj87EUe2X01Vl307ou7rOVl260/t61jea7b3eWve25rPs57ztn3Qlf8xHmQ663mOOoY7cu5FljNhXZnVTQeSjNFkq50tjCbflv8PXV1v1Lu597LIF9g6OZLggWDJz/QxutA2DOJhv9BMC00e9wDHa7exQjZK+foKdZ1+2gTuDdlMq6zk764ppD/9bAnk/fRPsHLgCg5JmXmXb373EEQzR9cUXiynUKZv7mdutEOdZ1I2Z3MLaRuHB4xqROyzTd+7IStj077l34wKF/K62ZFWkg2wxwTvoerqrYTJ8Rn3Lro8992jIvO+elg810QXCAPoqdvjRA9xTrOmSnr2nXC6vnWqZx22zP9hywPk80OmxMa2az7q/qtO4D22mvAYxg8qfBikSc1NbmnvD1Kd9589C/+8qKWX/XJ3C3dhHKLKR2ygeY/V8/Qy/NsrWtbhs3nJo+e5/dhDNqLNPs9VkvGq7qEzfveCzd3kAl7bTxvbdaT//3nWevt7W9QWUqjJ6Bz3d3fc7OXHb2fn+uauuDWTQ9cX0/O/XR22Tvdxyx0c1x+K3zimTbq2euFus4RMUj9sreloBlZkbVCGuReKGMNKIeN6kt7ckuihDJZahDt9drBVs+9H5C6alc5PkpHhUfJeDHw52BS8lRvcRwUGseecHAME0mvLGSjLoD1Cw/G20oprz4HDlV+/tTJP8kxg4NNMxdQPXyc3CGQ8x46jEq/vTiMekUUPbyG+z+8DX0loydWx7HkhQdIUVH2OfMOOL5bsNLYaxn1ExJIYZWuWrnZtebZCk/T0Tms8dRyPHaxx0Uc5beyzK1j3jLNDLaUDHyHQxW13zgKsqeeBZnn5+qG99P18ypzPn+T5NdPDFYtGZytIVsM8B+Zy5l0U6mRprZ5C7rX+tECHG4cFYGm370DTA1i77yXUyPh83f+TIb7vwOxdvepHD7OjlyCzEKdJUW4/b78XV0JTRfCViLE+oqL2HjrTfi7ulj+Z2/loOJEP0qLzibtulTmPHY0+TdVH3Eaz3aS48e+CpubuU+civ3jcjwilaKXZdeRfukKWRX7mPSK//CHQgck64jMoH28FTSn6tF3RCj9sKzULyThBKLwZQb60MD7Y4jL//3OLyUxLpJ1aHkFEyMWMsd+7jGuYFuvNwVvoBqnUex48jOb8mmDsrXtXNgSQ5r50/kUmMbZ+bvZlWLzGUtBt/hweryx5+h8K5VdDCTqa//gaofXMNbv/ohRTtfI6d6y4g7xouBjYt1UBTrodqRTZ0zi6ByMTPSSHmsgxpnTrKLJ8SwEvN62PTf/04oJ5tFX/4u4bpMOpjJtNvupf7fLqThgrPozStl/JrncIaDyS6uEOIUaKDmzKXsufRClDYp3riZCSvfwNdp745vKxKwFsfVW5jPW1+4FXdfH7P//IR0uMWYdnCMaDgtleaZU9l7yXkUbdhM2Zq34aZTz3ck/q4a5iygfdIUyteuomz9muPuQ0dkAus6voiJA6MvRtbje6m7bCllVRKwHm1yYn2EleOYG/L8Kn4bbbopAWth3xyjlg+41rM9VsxDkaX4OfbW1pJNHdzwiXU4wiYxt8Hf7ltMaIGTj09eKQFrMSQOvP+y+MjqJ5+j8K5VbODbmDgxdkeZ87H/o+a7V1G/8CKi3jQKd61OdnFFgmTF/FREO2gzUqhxxu+ga3Ok0hZLoTzaQZORnuQSCjG87P7MLXTPmMLcb/0YvcN4t60MRVn4/e/hyghRu/hCdl1yIzOeuR/DHDlr+Agh4g4sX8Keyy8if/suPF3d1C5fQsP8ucz9y2MY1J12/smfAEkMSy5/AFcggOl0YsTk4CHGNgUUbdxC7fLFbPrYh8ioa2DmY0+PyIDz6fJ1tmNEIzTNmktP0fHncW4PT8XEATgwceBvKsTdbWOyfTHitDtScesYC4K1FEW7UFrj0jGmhZuJoeg27E6AKgSE++fvdxLDo6LHTVO+rh1H2MQwwYiYnLNuNx4VZWtn+VAWVYxhKfVNEDPpnTCONuc8TJzEj3dOWlOW4C8tRpkxPD1tyS6qSKCQchLCQbbppyzWCVqTHesjywwQVC6iSk6rhThcSm09AO2L5tLBzKPaykV0lU4CwNvVipJgtRAjkq+9AxWN0TJzGi0z4wNHfJ2deLp7EpK/HFnFcXl6elly9x9AazbeeiOmIVVFjG2zH36SiS+8yoSX32DR7x7EGY4ku0hJkV1Txcx/PAZas/WaD7L/7POJuY5clCbHvRuDGBDDMExCF2Qx/pmXk1NgMagOuLLZ5Cmlz3AzMdLO4mANS4I1eHSUHe7CQwtRCWHHLrOIf0VnMdXRzLc9T/P/3E/zQedbzKSONOK3Cx9YkkPMbRBzAC5F2RmdrNMV/HTH5cktvBgz8tZuZPYPfk7n7Om0fHYJBlEghnJo6r55AUY0ysTXHyarfneyiyoSKGC42eApp81IZUK0nbND+5kdacSvXGx2lxJTp7dgthCjzbhHnqLi4X9Qe/Vl9L2v7N220jA58O1L6c0vpWz9S0x8/R9jchCQEKNB/q69LLj/z2QcqMOIRpn52FMs+8VvyWhoTEj+MiWIOKHU5laW3P0HIj4vhpm4VVOFGImMmMnk51cmuxjDQkZDHQv+8keql51F45wFdIyfxOzW+8l/ZwcA2a5KlmT/jPbwVFpvmUlveQklr61l77KKJJdcDIaA4Wa7u4hs08+ESDsRHOx35dLt8CW7aGLEUTwXncWmWDmTjWamGE3MdtSRqsIAtOsUahbksOa+iUxc10LpGV2sm1/BK3o6I3OSJTFSFb3yJgBbv3EHnow2eAdCl+RT2PQGM/7jd7TdtiDJJRSDIaoc7HQV0m72UB7txK/c7HYVEJPR1UIcQwGTf/sgMa+H2i9eSqHxOn0dZfReN4FURzWl/3oDb09HsosphDhNOZU1nPHbPw7K+lwSsBYDSmtqSXYRhBDDkCMSYeLrr5C3Zxf7zr+Et7/xBUpWrmb6A4/i7vOT7arEXdbLnmvey6THn8URGZsj0scMpehwpNJhpICSwKE4HYpGnUljLJM3YlNQaOa6axlHO+NUGzNoxLMwCgthnZZgtUieQ0Hrb30JLoAZP/4VJc+9IrVxtFOKZkcGzY6MZJdEiGFPAdN+cR8xj4eGL5wHwMQ/Psz4h56g4xNLk1o2IURiDUb/RwLWQgghTllGYz3zHnmQ5oJpVL73Elrnz2Lm7/9K0dqNVL/nfFQsxrjnX0t2McVQkWC1SDCNopkMmslgvR6PwqRQ9+AhQjW5SLBaJFPRK2+Sv2o9ptuFq7cv2cURQoikmJVSR00ol57YsWuXKK2ZceevmXj/I0TSU8nYWzX0BRRCjEgJvX8pWGQ9bYS3MXGbdPYl7iSl6QzrecdKVuqEbc8IJ67skQzrcvl2yzyix+PoG9pb+BzBxG0vkmc9YtXZ5E7Y9havGFtzMebdXZuwvKb8+7aE5WVHX9WpjfrRKIIppRzeojScbf0+IxZj6sP/YPk3foS3vZNNX76NDV/5FHXnraBk1To8Xd22y9Az6djjSNQ9dAv3qWji2mZv09C2L6FN2QnLq2lnfsLyssPZm7jPygglN4DZOcu6L5S7LnHjBZw7UhOWl7LRzTHdiesL/f21JSf9Ho1BI5lUk8fhwepPvvd5y/c6/KPntv1oYXhItzeSPztXV+LKvu9ny455zhEOWwarE/erGWLGiC15Qt264aZkF2FIdU8ZuVNBhrMSV3Yze2jvDlw+d8+Qbi9RMhwB/jzzHn479QHc/Qsm7/n94iPSGKaJr6nliGB17u/eTFgZjEDi2vnJc6zPAXUCu5qJLLsYOYKFQ9vOujoSt85C9WUpCcvLykmdMakouNtO/IMK5ZkEigf+4O2cDAFEMq2/QCOkUDYWlI2k28grBvXnJablsRPwSD1gb1u9E+xV5FC+9QdrdLgs0+y8LcvW9vicvWRHcGjLA7+zwTqwbnrtfSYOG+dy4WzrvMpm2ZswvqE90zJNrMGHYaN+2Fkn2dHrsPVZGF3WP/NNL06zTBPONsFjXc+CuZZJTpmKgrtj4IN6x3zrzuU7j860TOMvN+Gj1mXatXWGZRrV64DzrPOy2z7aYSdoPe1/qg792zQMNn/2ZhrnLqTslTeZdd9fUVpTeVc+bR+y3l7HtKkAlFQ+jje2iJZFy9EOJ27vPqo/GX/NY2OGodR6zeGn9v6sPHZdfAMVa14gpzoBF00UmK4Tf9B2v4PQnIBlGt2cuAuF4YlByzTOA14C22wErVPstaF2gtYf2flZ64y81h9qLDNqp0gobd3ZUmGFSuBF4aO5uzXlL5z4MzxwsWEdtDYVjl7rfbFzjAKg0Xq+cFeZ9ejPSG2qrd+AHuA3dDLMzChPvGM916+d45hWQOrAn9fVZ6+zVa4nNiV3/uGUPdYXm4MFpq0+gJ2LQaUrrTtMldfZO6FWYet0KbX28urLsO63GjbOF1RU2eqbZ+6xTtM5wzxu0PpoU+9pPfRvDbzz8Q+SWVXLhJffOCLdFsucTk04JzEnwqbnyGPyiTi7rNszu/337n1Z1nllWR8zfHvtDdoIR9Ms02in5uba2y3T2anZA51LH+Ra1Gkjp1NnhCG1+sTl6JkepXOuje/LY6MNarL+HUcL7AWGp1RYn5Pt21xmK45A1Pp7MHqs63XWZHtzMK9ZZ32u5W0xsLP6R2ByyDJN0fP26n+lrVTHmpPRyluX3ffuE+FMVjj3s+usH6FTipjy59vZ/7/LB8wj3pew/q5Mn43zXZtB333vlFsnUtry3i0zK2LrQqTRaV3/yQvZG0UasD6vsHOBNppirw83d9k+W+lOtQ4lwkDt2OH6KoY2OGymW0dznM0uwjbGmEVzrI93ymedRve47PzcyKi0rh+ty2Lsudm6jUlLwDU4mRJECCHGuEPB6mULyd2yk9rzVwAw676/nnReSmtyq9eT3ryHUGoO3t5W6zedQNTtZd9578URjZDelLgR70IIIcRQaVw4h6YFc8iqPJDsogghROKtD8CbUczFGRgzuyHYluwSCSFGCQlYCyHEGKbhULB62kNPMP6Zl9l73RXse/9lKNMkhZdPKV93oAt3oOu0ylV51uVEUtKZ+vwjuIL+U85LCCGESIZwago7rruKzKoDVKxM3O3vQggxLKwPoK6vg4gGl0I/mIqa3cFHKt7gT9VnJbt0QogRTibMEUKIMSzq89K8cA7etg5KX12DAspffB1XTx8Nyxaik3SYMJ0uegtKcUSsb3sUQgghhqO+onwi6al4urrRsiitEGK0eTMAER2fpjWi0esdaOCyosGa8EgIMZZIwFoIIcYwVyDIgp/eQzg9jfX/8Vl6S4tY943PY7qcLLrztyg7k10NAkc0wrR/PYwRCbP7kg/QU2hjzjkhhBBiGMneV83UJ5+jed4s9lx1SbKLI4QQibXCFx9Z7QBcCjWvGwwXX33HxgI4QghhQaYEEUKIMS5/8w4W/PQeNnz5k7zx42/iCIZY/D+/Inv3fjqxXnhvsKR0tDDjmYdonL2U1Jb6pJVDCCGEOFUTXnodZyBI/rZdyS6KEEIk1mIf+m+l8EZ3PFi9yIVOK6MxmJXskgkhRgEJWAshhCB/8w4W/t/v6CstInN/Ddm79ye7SAA4wyHKNryW7GIIIYQQp6z8zXXJLoIQQgyORR7UlD5Q8WA1hoSYhBCJIa2JEEIIAPK37CR/y85kF0MIIYQQQggxEigDnVoEhluC1UKIhEroHNaeVuvsdALXGzE9OnF5ORKWlS195Ykr+1hjBBNXbd0d1nnVbitK2PYcxYGE5RVLiyUsLzvsfFajScqBxO2vHuLvKpEmfL5lSLfXV5LcRakSeYxSBUO7YGS0PDik20skR1fiTnC0O7nH1/IXbMz7bgzPPoCrrG9It2ck8HtXNj7SJ19fkrDtJZu3eWiPyRMeTdx6Bv6yoV0bQTsT93vL2jG2+kJGKHEHxUT23+0ITA4nLC8VHdq+SeTtrCHd3tHSdyaubY4WRizTOJtdCdvepLm1CcvLTLfuv3fuzU7Y9oL5iWsbGy9JXP23xZlyRLB6z4d/Y/kWFUnc78r0JfC4YuNkwOhMXJ2l1ZOwrCKZ1p+D0z96FgDuq0jOWkuJEC2wbhsTSaUnbnt5a4YueHpSRyMFqAHqhIqBr2HgzkiwyF6lstOA2f2xXXTBRss0z6+abysvO2K51pXB6HLSO8G6A23nIkAoL3E/1IG+39POO6Tw7h24QQ7nWhdA2+zvmjaOI9E06+2ZWVFq6vIs0znc1p2aiUUt2JkSeM+eEss0ngbrn68Rtd4W2KtDsRR7lcNhDt4JiXZrgiUD75Sjz7oB7Z1jHUjM3OAhfb/1vvRMtEzCgsX7rBMBex+eYpnmga/85Ij/e8wI5eEO2pypdDhTAfjUN75ka3u7vj7eMo2r04Ct1nkFC6zrh512Xbs0ocGcNtvQmKkn/q06eu0dgJ17fJZpcrbb+800LbX+XCqK2izT1GwrtvU7ffTqnx/x/9RYiMJoD7WuLML9JxvXPXmHZT62OayPdc4Sv60OSbQ3xTKNmTW4HcBwNlR/4MR1SIcNYODjgaPPMeRB609MX22Z5jcvXmSZxsy29/kaHdYH4fR9BuC2TOfusf6s2uZrW0Hrv79mHbQe1LCaAtPiokpsYY9lNpHaVFubszMgo/pKe6cDho1rYna25y3uI2bdzYFW63bWTpDCCBi2gtadM6zT6Bx7QaDdn8yxlY5TbGqt4ik6w7oDaPeCkZ2gdTTDug9sNzjlKvZbb6/e+liwZMkesO5WseWpaZZpQrnaVvk9HTY+K+uiE86OEaxLt054ikwP9Ew58XfmbnPgbrauH7PO22uZZntTIaQN3O+O1Kbaqo8HVo6zTBPOsdf3mlDRZJmmeqt1Q2WEFN3brH/vKa3WdSNQato6Jyt70vqzSr2jFj5pmQwespHmOLa25jPjnttP+Hok0wTXwG2q3fOjjesmWyey0wHAXntmeu3VITtBazsDYTJ3G2DjvKJ7ir1yWQWtXV2GrThaTXeWre0lm52gdVqVdc8u9TLrNqFpR4GtMrmarOtGNNW0dd7mabT+vacdsE7TMdvEzlG4fZ71b8nuwEkjAadkcs+GEEKMUF4zzKRgKw5MUsJhFNDutBfEEALiwerJoRYcaHxmmD2egkNBazH6OYgRY4hvMRNCCCGEEEIIC2PrvjYhhBglUmIhJgVbMJWiZns2oXsclK3tICc6tLf0i5HrYLA6ohzs9eTh0JopoWbcps1bM8SItogqPq9eJh/r0bxCCCGEEEIIMZRkGJUQQoxAaWaImHJQvy2Dig93oMIa3JB1fx+gwdZNP2IsSzNDRJSD3d4CosrBHm8+k4Mt+MwhnvdQJEWu6sOtYmToAC0M3q3nQgghhBBCCHGyJGAthBAjULMznVZnGnlre1ERjTJBR6B3vRcJVgs7mlwZtDjTMFX8ZquA4Wabr/jQ/8Xo9ryexYt6BqbcbCeEEEIIIYQYZuQsRQghRiKlMJVB7zIP2qXQDtAuRe/yxK00LUa/o4PTEqweWyRYLYQQQgghhBiOZIS1EEKMYP5FHvb9OY+0NSF6l3nwL/LAY8kulRBCCCGEEEIIIcSpkYC1EEKMcP5F/YFqIYQQQgghhBBCiBFOaa3tJ1aqBagevOKIEaRCa51/Mm+Q+iOOInVInC6pQ+J0SR0Sp0PqjzhdUofE6ZI6JE7HSdcfkDokjiBtkDhdJ6xDJxWwFkIIIYQQQgghhBBCCCEGi6y2I4QQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtYnoJRaqZTSRz13nlJKK6W+m6RiiRFE6pA4HVJ/xOmSOiROl9QhcbqkDonTIfVHnC6pQ+J0SR0Sp0vq0KkbsQFrpdR0pdRdSqmtSqkupVRYKVWvlPqnUuoTSinPMCjjFKXU15VSLyulDvSXsUkp9Xel1PkW771ZKfWWUqq3f/9WKqWuHKqyjwWjtQ4ppcqUUt9USv1NKbVXKWX2N4aTh7r8o9korj9nKqV+rJRap5RqUUqFlFKVSql7pQ4l1iiuQ+copR7s3682pVSwvw79Qyl14VDvw2g2WuvQcfLw9O+jVkrVDnaZx5LRWoeUUrf015cTPT491PsxGo3W+nPYezOVUt9TSm1W8XOy7v59/a1SyjVU+zCajdY6pJSqsmiDtFLqW0O9L6PRaK1D/e8rUPHzsq1KqR4V71e/rZT6mlIqfSj3YTQb5XVoslLqD0qp2v73NKj4edqkoSz/qXImuwCnQin1beA7xAPuq4H7gV6gEDgPuBe4HVicpCIe9H3gBmA78AzQDkwD3gu8Vyl1h9b6F0e/SSl1J/AVoBa4B3ADHwSeUkp9Xmt99xCVf9Qa5XVoMfBfgAYqgS4ga6gKPBaM8vrzGJAPvAk8BESB5cAngA8qpS7WWq8eovKPWqO8Dl3Q/1gLvAz0AeP633OVUuq/tNZyknaaRnkdOtoPgIpBLeUYNEbq0N+BTcd5fv0glHNMGe31Ryk1HXgeKAVeBJ4FXMB44APEz9UiQ1D+UWuU16GfcfzzLwV8g3gc5tlBKu+YMZrrkFJqPPG+dAGwknh98QKXAD8GPqKUWqa1DgzRPoxKo7wOLSZ+LpYOvAT8hXh/+oP97zlPa71x6HbhFGitR9SDeAOvgRpg6QnSXAm8cprbWRn/eI547rz+bX/XZh63AAuO8/y5QBgIAcVHvbaifxt7gezDnh8PtAFBYHyyv4eR/BgDdagMOBvIOLwcwORkf/aj4TEG6s/XgZIB9ntLsr+Dkf4YA3XIe4K8SoEmIHb0e+QhdWiA958HmMCn+7dbm+zPfzQ8Rnsd6n+PBm5J9mc9Gh9joP6kALuBDmDZcd7rBFSyv4eR/BjtdWiAvC7t3/aGZH8HI/0x2usQ8Mv+bXznqOcdxIOPGrgp2d/DSH6MgTr0Tv82vnTU82cRH5S2abgfy5JegJP8osf3fxlhYLZFWs9xnlsKPAo09udxAPgtxw/OnHalsijf8/15XXvU8w/0P/+x47zne/2v/Weyv4uR+hgLdehE5UAC1lJ/TqH+HJbeAfj735Ob7O9ipD7Gch3qf88T/e85M9nfxUh9jKU6BGQAVcAL/f+XgLXUIVt1CAlYS/05vfrz5f7nP53sz3s0PsZCHRog/WP96T+V7O9hJD/GQh0iPqJac/wg5cE26ivJ/i5G6mO01yFgYv9zTYBxnPc82f/6Ocn+LgZ6jLQpQT5G/Fasv2qttw6UUGsdOvz/SqmPA78jfuXhH8Qr1BTgVuK3KC/TWtcMSqmP7+AtZNGjnr+g/+9zx3nPs8C3+tN8Z5DKNdqNhTokBs9Yrj/6sLSxxBdnzBizdUgpVUC8cxcCdg1WocaAsVSHfgFkE5+SSCTOWKpD85VSXyR+G3Ud8VFSMg/66RkL9edG4v2ev/bfln858ekdaoDntNZtQ1XAUWos1KFjKKUKgauITzfw58Es1BgwFurQNuAy4Apg48EnlVIG8TbJJD7dgzg1o70OFfX/rdJam8d5z/7+vxcCrw1WwU7XSAtYn9X/96WTeZNSairwG+KjdM7VWtcd9tqFxK9I/Bx4f2KKaVmeCuIVw89hlUMplUr8lulerXXDcd66p//v1EEv5Og1quuQGHRjuf5cT3z+qzVa685BKtpYMGbqUP+8aVcS72uUET9JywQ+r7VuHYpyjlJjog4ppd4P3AzcOsSd/rFgTNShfncc9f+YUupe4Ita6+Bglm8UG9X1R8UXU5wHtACfJD6H/uHnzH1KqS9orX8/FOUcpUZ1HRrAx4kHyP6ote4ZzLKNAWOhDv2YeD/6+/2L6m0gvrbZJcSDkbfq4T7/8PA22uvQwXOtCqWU0v3Dqg8zsf/vtEEu4mkxkl2Ak1Tc//dkR0bcTvzgcMfhFQpAa/0S8asiVw3FSqv9K4w+BHiID//vOOzlzP6/XSd4+8HnswandGPCaK9DYnCNyfqjlJoA3EX8qu2XB7eEo95YqkOLid8N9E3igUcX8emufj3YZRzlRn0d6h+F9jvgWa31fYNdnjFo1Nch4otOf574iVgqUEJ8obwq4FOABBtP3WivPznEA9S5wA+JL3RVDuQRHz2ngXuVUhcgTtVor0PHS6+I1x+IH9/E6Rn1dUhr3QwsIz6d3gXAV4EvED+uPUJ8MVhx6kZ1HdJa7yY+4LWQeL05/H0riF8MgfidjMPWSBthfaqW9/89Vym15DivFxCfn3Uq8PZgFUIp5QAeBM4EHgbuHKxtiYSTOiROx4itP/3TODwL5AOf1VqvHqzyiQGNuDqktf4N8BullBeYQHzRvAeUUmdqrT89WGUUJzSS6tA9xPuotx7nNZE8I6YOaa1fBV497Ck/8Del1BriixB9SCn1P1rrdwarnOIYI6X+HBzQ5QB+q7X+3mGv3aeUSiE+XdHXkdvxh9pIqUPHcxHxEY0btNbrB6tswtKIqUP90xH9A/AB7wFWEV8Q9n3A/wHvU0ot11pXDlY5xXGNmDpE/NzrWeBnSqkriS+yWA5cA2wB5hOfWmbYGmkB6wZgBvFpM05Gbv/fr1mkSzvpEtnUX6H+RPy2+keAjxxnWP7BEdSZHN/B5zsTXsCxY7TXITG4xlT96Q9Wv0z8Sv4dWutfDVb5xpAxVYcA+m+73wHc0T8S4FNKqRe11o8OVllHuVFdh5RSNxGfPuZmrXX9YJVljBvVdWggWusDSqlngA8D5xAPXouTM9rrz+F3uj5xnGyeIB6wPmNQCjk2jPY6dDy39f+V0dWJMRbq0B+BOcA8rfXm/ue6gd/2Dwb5GfE7GW8ZrLKOcqO+DmmtX1ZKLQP+H/E+z7nE567+OvF1PR4GmgernIkw0qYEeaP/74Un+b5DgWCttRrg8eqAuZyi/rnQ/gJ8kPgCCzdqrY9ZmEFr3Ue84qQppYqPfp34RO4AuwejnGPEqK5DYtCNmfrT3watBGYSH1n9i8Eo2xg0ZurQCTzb//e8BBVtLBrtdWhh/9/7lVL68Ef/86WHPZc1GGUdA0Z7HbLS0v83NVFlG2NGdf3RWvuJL6AFxx8kdPCWa98gFHOsGNV16DjvKyA+KlYWW0ycUV2H+qeTOBdoPyxYfbhX+v8uGoxyjhGjug4dpLXeqLW+Vmudr7V2a62na61/CszuT7JuMMqZKCMtYP0H4itgXquUmjlQwv5RXAet6f979mAVbIByuIG/Eb/68QDwUa11bIC3HLy17LLjvHb5UWnEyRsLdUgMnjFRf5RSZcRvpZ4OfFrLyOpEGhN1aAAHRzHIBbdTN9rr0GrgvhM8ID61w8H/h46XgbA02uuQlaX9f/cnomxj0FioPwfnhp19nNcOPie34Z+6sVCHDvcx4nPe/kXLYouJMtrrkLv/b0b/+46W3/83nNhSjimjvQ4NlI8L+BDx/R/ed7xqrUfUA/gG8cUuKoHFJ0hzGfDyYf+fTvzHvBuYepz0buDso55bGf94jnjuvP5tf9dmWT3AP/vfcy9g2HjPiv70e4Hsw54fD7QBQWB8sr+HkfwY7XXoOHms7H//5GR/9qPhMdrrD1BB/CQ+BtyS7M97ND7GQB064wTPTyK+sIkGLk729zCSH6O9Dg2QlwZqk/35j4bHaK9Dx9sn4gN1/qM/nxYgI9nfw0h9jIH6s4h4P2gPkH/Y817iwWwNfDvZ38NIfoz2OnTYe1V/PdLAomR/7qPpMdrrELC9P/33j3reS3yEtQZ+nOzvYSQ/xkAdSgUcRz3nBH7dn8+Pkv0dWD1G2hzWaK1/oJRyEp+vZ51S6k1gPfFbbAqJz80ypf+5g+/ZqZT6OPEVwbcppZ4jXsFcwDjiV0daiFe+RPoN8QnyW4lP9fHt+ALBR1iptV55WFnfVEr9BPgysFkp9SjxSn8D8VWrP6+1rkpwOceU0V6HAJRSfzzsvwfL9D9KqYNX9e/VWr+BOGljoP6sJH6B7G1gvFLqu8fJ94/SDp26MVCHnldKNQMbid9W7SQerL6s/993aa1fSHA5x5QxUIfEIBsDdWidUmor8Tmq64ivA3Mm8dGxfuDDWuvuBJdzzBjt9Udr/bZS6j+B/wS2KqX+QXzQ0KX9+/Um8OMEl3NMGe116DAXAJOJL7Y4aAuwjUVjoA59gXiA8v8ppS4m3u74iN91X0F8gOP/JLicY8oYqEPnA/cqpV4kPmgojfj52CTiI6u/leAyJl6yI+an+iA+QfpdwFbik8+HiU+c/izwCcBznPfMIT55fTXx20jb+9//W+CCo9Ku5PSvgqzsTz/Q47h5EZ88fx3QB/QQvz3/ymR/7qPpMZrrkI333JLsz3+kP0Zr/bGRXgPnJfvzHw2PUVyHvgA83V9Gf385a4jfwnZpsj/30fQYrXVogLw0MsJa6pC9duh/ifed64kHGv3ATuBuYGKyP/fR8hit9eew914DvNa/b0FgG/DN4+2XPKQOneC9D/e//qlkf9aj9TGa6xAwF3iQeD86DAT626EfAFnJ/uxHy2O01iFgKvAY8QFEIeJrMLxCfOFplezP3c5D9e+IEEIIIYQQQgghhBBCCJFUI23RRSGEEEIIIYQQQgghhBCjlASshRBCCCGEEEIIIYQQQgwLErAWQgghhBBCCCGEEEIIMSw4TyaxIy1VO7NzTpzgmEUqxyblMi3TZHv9tvLqjngt00SDJ/U1DkjF7KUL1de2aq3zTyZvR1qqduYMUH/GAoe9OeNVyMaPyWddz3TY3jUpZZ0V2u7lLZvtQPjAydchV6ZPe4syB8434LLMx+GxruixkMNeoex8p6a9D8URsE4Ts24SbP+OtZ1dtLnMgRFNTF62ytTvlNuh3AHaoQQu62DrMwFMG024re/U5m/Pzm85kXXITl7KZ2+DZtjOBm1lBUC45uTrUF5enh4/fvzJvEWMUm+//Xbi2yCw1Q7Z6WsC6MjQjk2x83u32867+mzklcDdi6Zaf/DOHnsNTDTV3jZPpS80HPvTM7KbLNPs6CgcgpK8y+mxdxCOhqwPwh5f2FZeMdO6Qto6bzuZ49hg1CHDZmfIRv82kW2CrbbRZtGdNk7FYx7rNKbb3vYS2b9M5Gd6KvUHhrgdsvPZ2fzNJOpcK5FxL1evvXSpRdYHxU5/inVGNs9L7cQHAEJ1p9AGpadqZ37WwIm0jXLabKtU0LpttrO/pnWYwT6bdUjZOJQl8pzeTrkMe4dETJ+9jYar6k5Yh04q0unMzqH0K186cQK7B7dRzlFs3RJeO22Trbxerp9qmaZlT65lGtsH7x57Pf89/+/L1fZyPCzvnBxKv/rFk33biGHaaSjSI7by8u6z7iHFZlsftGJ1Ng5agKvbumWKptmrRNppL13lHV896TrkLcpk8a8/PGCa6q0llvmkTeiyTNNbOXBg/CAzy8Z32mevqc3aZl2JuqdaH01dXfZ+x6Ec67wcdi6eAJ4263SOoHU+oZPo+55SO5SbQ/HX7zjh60Y0cT1QT6vN7yHP+ntwdlvnZffkJJZqow512it72EYdcndY5+We12lre31VGZZpTI/9vkj1p7920nVo/PjxrF+//mTfJkYhpVTC2yCw1w45S+wNfIjW2+sHJIqd408k095ZcMFbNvomNgIL2rDXrrctsT4rLHzdXkPbsnjw+kJD2p+2EzAAXrr+J5Zpljz6xdMszMnJndJmK13rXuvzqMlzam3l1RnwWaZp35FnmcZuXxoGpw7FUu1dRHb0Wf8enL02gvhp9toEFbERILcZZMvfYP0Zd1dYl71vvL3Pyghbl93mz81WvyqSZe+DOJX6A0PbDik7n53b3m8ma7v1Z9c5zUZeNgeh2VH8ur10i79h3fd88u2Flmns/G4BDJvngPu+fgrnY/lZlP7XZwdMY0atvys7g9AAnLut+0J2LmIFim02MDaYNtt5d6f192WnDbXzOwJ7vyVfnb3zxL7ZIVvpqm/6jxPWIZkSRAghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyHkcVGJWcZe5JdDCGEEEIIIYSwT2s84T7QR91OrE3cEXtT2AghhBBitNFcn7ce01OI3zvppN4pAethwkGMixw7OMexGyc2V7sSQgghhBBCiCRzxUKkBTtJDXa+G7TWmnR/O2mBDiakNCe1fEIIIYQYegvTavjfCY/xy4kP4I21n9R7T2rRRTF4Yjj4ZeR8NIoodpdKFkIIIYQQQojkiji9+N3ppIR7MJWDgCedtEAH7liIXm8Wlf6CZBdRCCFGDQOTNEJ0Y73YqxDJtKG3gm9XX8X3Kp6iugDurLvU9nslYD2M9EhjI4QQQgghhBiBAp50DB0jJdyDKxbCFQvT58kg5E5NdtGEEGJUOdOxl/e5NvHfoSvo0NLGiuHtgeYVdMd8vNI57aTeJ1OCCCGEEEIIIYQ4PUrR580i7PTiioUJuFMJutOSXSohhBh1pjiacSmT5Y59yS6KELY82baArljKSb1HAtZCCCGEEEIIIU6fUvT4cuhKycPvyQSlkl0iIYQYZTTjjVYAVjj34ZA10MQoldiAtSkdErse2zU/YXnlT2mzTKPlqxkeelwJy8qx1frWH0dp4lZld/aOrUqUNqErcZmlRhOXlw2RTDNhecU8OmF52eE5uXUYEs50Jm5/Q3mJ+x7sUAnsq0ayhrbs4XeyEpaXERpbbZUYm6L1JzdCZThxdQ3teBllJq5dbzp7jAUF1Cl+dkoRdXqOCFavu+6nCSqUPW17chOW194tZQnLyw4VTe5xzNGXuPWUomnW/Qlnb+LaBJ3A5iWj2rrsqVWJ+6xO9ed2PK7OsTUuUYUT95vJ2mUjr1jittdw9sm/J1v5yVRBtsZKSFch5jpqAbh60QbL98ZSR89xLBYa2rXffA2J+10ZQ9zOa3fiGphA6dCdJ57cHNYKMIYmeKEiifsCnX7rvBIZ4DEPWJ9EeCZ284/9sy3TBWvSLdM4/IblF3nH1U9Z5gPwSvt0W+n22Eo1OLK22WsouqZa11XtSlx9Nmy0/ZPm1trKa1+ndcd48p/74F8W+VyXhp1fktNGXLt3sr2gq8M/eB2kcMBF9daS086nu8H6d2UE7e2H0Zm4ixDdUxPTDnla7JU9tazHMs3k3FZbee16YZJlmmCF9f4ZgUHuYOvEdBDsBFxytpuA9T435VlvL5phnY/dkzSdbv1bzlrvtpWXMq03GrWxPIOvGXg1yzKdHm/9OSgtQWsxjCWoDQJ7QevJf7E+wO/9UOKC34nsT3dXWH9OudutO181V9krU+5b1sdzX2sMO+167kZ7DXKlrVQnb8LjIcs0tRdaN85e6zExACz65x2Waewe302vjb6CzT6araC1nZ+jgr1brfvmykZV80yw7nuFQy5bxRosGbsN7IxrC9rovxScXW+ZpuaAjYwAo9s6dKEiylZ/qG2Wjf5LhnU/LnV8N9ZnFdBXlWEjlb2gdXSajRO3Ot+gXvhQ5sC/6UiudV/T7jmjnUCbETRQQev97Zw5tAMy7PRHPW2KTuvTKBamVR/693izFTRUuXKpMNu43L0V5YDvPH+tZduhfTFiNs4FUIMXDHa7YowrHHiUUkuv9XRSkYi9MsbPyQbWtNxWVgnjabVX/93d1mkWXrzVMs3qp+fa2l5wvHXdcKWFCRdb56UaT3+NvrF16U0cIZs+ZlJPKsFkF0UkQMzpYO8l59M5bmhHgQghhBBiZAhkZlC/YK7ceSeEEEKMUPn0EMGgnVR2qSIK6SFL9yW7WEIknASsx6gcermWDVzALj7Gaq5nPXM5gGJob/8XiWEainc+8gEqLzibtz/5UdomT0x2kYQQQggxjAQz0ln/qZvZ9oH3seuqy5JdHDGEalYs5c07PkMgOyvZRRFj3Gx3Ha+V3snnM19OdlGEGLEKdA9tpKGVYq/KJ4Zium5KdrGESDgJWI9R42nDS5ROfJhAIT0spRIvkWQXTZyCcHo6bdOnkNLciuly0bBgTrKLJIQQQohhpGXmNILZWWQcqOPA0kWYhpwGjBXVZy4jmJ1F+4TxyS6KGOMu9m0H4NrUDXhVOMmlEWJkMtCkEyRT+1moa3CgSdXWU0EJMdKc3BzWYtR4hzIm0Eox3XThZSsl7KCYAPbmLRXDi7erm9K3NlB3xkIAJr70WpJLJIQQQojhxNfeAUAwMwNvZxeGObRzeYrkWXb3bzGdTtw9vckuihjj7uq6gMf7FhDWToJazjuFOBWrjMlcbm7havMdTGCbKmaTKk92sYRIOAlYj1ExHDzGQtII0YsHeyuOiOFs8nMv4e7pJb2xiZT+k1IhhBBCCIC0xmYAwhnp5G/fleTSiKHkCsh6NeL0dJVMwp9ThCvQizPQhyvYi+npwxnuQ2n7F7+iOKiO2ltkUQhxfO0qleeNmWToIB0qlXaVmuwiCTEoJGA9pil68Sa7EKfNNBzULTgHZzhI0ZbVYzb07vYHmPzCymQXQwghhBDDkKe7ByMcwXS7DgWvhRDJN8ndTGU4D3OYztYZSs2keul70I7jhw4c4T6coT6c4V48fW3kVq7G0LEhLqUQY0uLyqBFZSS7GEIMKglYixEt5nSz/+yr6C0aB0AoLYtxa5/HMKWTJIQYOqZyEEorwNvTMGYvmgkhhjcFGGYMEwlYi+MLpBXi6WuVYOMQujx9Kz8pe5Q/ty/h+01XJLs4x9BA3fzzUKbJ9OfuQZkxot40Ir5U/PlpRN1pRD2pRN1pjEtr4fLyN3iIZWTtfyvZRRdCCDHCDc/LuEng6hrajyK0P3FXw2Ip1rdh/fzJqxK2vWTrnBXf34g3hT0XXsfEkjaejJzPPcHriE4oYd+5VxNz2psTTUWODi1plmTtJ90ZSHCp4/ZtLktYXntvtL71Z9KjiZurMG3v2Lq+ZXpH7tyeofzElX1v29Detmn6Rt7n7s8so3rhRzgw/4PUz7iKmNMDQPvMoT2uqAR+dJ2Lh3YhpEBB4vLScsVAjFFhTzYRd+bAiXT8T1rT2AlYj3sqcW1xIM+RsLyGm46SBRxYcCN1s6/GNOJ9vmBu4vIficf3Q/TgZFvi6uC7xU/RZ7q4MWcd56XFp+pxeyKDs0Gbuqe++111F0+kp3giRdtX4w704goF8HW1kNFYRVbDVvKq11C0+yWuavgZq4ov5P8yvsrXZj5GIKMIgObXSyy3N668NWFl167EfVnObuu2o69qmI5wLR2cc1m7XG3W5412Yhh2jejzttzE1dn/vOQxyzQqMHqOYy5X8i+u+tMn0pMz56QPE6G8oa2zy6/cnLC8Ir1Dt/5AQiNQP3zPX4/4v1tHWWpW0k4K240StFLce8vVx7yvdvECWqdPIaO2nuyqGjJq64ilWh8gDlxsr/iRzKGtDGah9Qqt18/eYCuvp/RsyzShmnRivoF/ImZOmDvXXWK9wUFswJTLxFniHzBNuN16ihIjaNCyIJ30KfO4L/sLfCjlEXoiXlKcIS4Jv87Nzj/z5pXXU7r1CZyRgbf3resfPvRvnw6z1KyknE468PGCMYOQcvGdZ6+3tX/OXus6G0k32bvFOmjtabfOK+qD/e9PHzBN+ZJaxtFlmVf1VuvOJKbC0WujfhiD1KsHVBTcHQN/NoFy606+nf1w9Nk7wY0UWwf2MjfZa9RDFnEGgHCuvfbMTtDa7LL+veXm91DbY12wYLF1h8HOZxrzmZjpg9f5cHqi5E5pO+HrzfVZtvIpf8Ek4vOx/5xzaZo9B29nJ4Xb3qJu4SJqZ97IjKefomdKKy0LrPfZCFn/ZkyPdRojaK/OxrKs64Zq8dA90cZv2UZw2Myx/k16qtyEbdR/NXjNixBDwt2tKX9h4N9g48esAw0TvnNkX7Nt2iQ23PZRTLeLnF37KHtzHYWbt1N/cfYR6Sa++QARbzpd00N0uwrIPQABAABJREFUT0sDIGvyidvEg3o32otcRtOt2xc7QSAAV491mgNXWx8vjC6nreN+9wTr7aU0Qc84G3nNsRlw/KO9ZEcwtOVxMvIt67VMxn3r3e+qafYMWs48l4zaerpLymkrupL5DzyM7/v1torUs6nCVjo77BzLSmY2Waap315oa3u2jysJOv5sW/5Qf34a1VsLsQg6vRztb+RX4x5Gp1cw7YHPD+6oMkMTSz1xHZp6X7xvG3O52HXhuaQ2NjP9b6uOWah1740+AN5T8A4/mfUX6kNZvNY4na8U/ZQ3Fv+JDVsMvG0mTasGPs/Qs3pxp1v3p6Pd1uf+ZmbUMg2A7kpMGERFFf691h0Yw0bX1up8/tA263yWaRz+wb1670sLMeesvSd8/Z23J+LwD1yLTY+2178N2dsXO0FrO+ci2sbpbtoBOyUCf7F1mmiaSaDE+nP49utXW6bJyOsjvbx7wDSxt7KwM241WDB4MbRwxEFNc86AaYof91jmo202lI1n2ktnZcrXNx3x//rzV1D5lfeBw8BsLWXWT+7B19JG4ycXWubVM9m0FbQO2Rg7tuGhuZZpIud1YSywjgulrrZuz+LHTZdlus987FnLNABfHuC1QRsy6dZRzovtJhM/JXSRZ/ayxph4RBqtFLvfczEHli/B091D69TJYCiMSJT0xgYyDxwgs/YAGfX1OCLJvdIsho/cTINPz3qdm1M/Tch0cvf+C7mn6jwmpzZx5+y/8kruRdzl+Sz/b+43yN72L9zBzoEz1JrJuoVFugYDzQ5VxBTdxMXmDl4wZgzJPgkhRg4NNM6cxf7zziPm9lC+dg3j1qzGEY2St3s3O666inc+eCM5ta+T2bRRpggRQgyqg8HqlJY2ijZupW75QjZ/7IO4evvIaNlJds1WPH3tALhCfbhCfUkusRhOOivK2Xb9+8isqWXh7x+iefZ0tl33PjbddANn6LtxKDkHGxShdlQsiJlSCA43OqUI1VOD8jeiMNHD4EboyvPPIpidxaLf3X9MsDpO86mKlfz7lH+yvnM8t73zMfpibsantXNf3uc5p+x+Im0nDmoKIcRIVX/+CrZ+5VNkb9lJ0Wtr2H3rh1j96x8w/VcPoAjI+V+CDErA+mCwOoMArxtT8BFmkVnDJbHtvDThADsry4m6XWy9/mpaZ0xl3Kq1THnuJaJeD50V5XSMH0f7pApqli0DYwUqFiOtqZGsmhrK1q3DFZSVrseiPFcPn5q4jpsKXgbgD3UX8Lu9K2gLpzNuFfg3L+K2+eXceMvTfL7il1zmeY6Pe39H9TsevL3HH4mRpoMsNyspoptGMlhtTKBXeanVWZxv7uJicwf/4+qjIyIr7wohIOLKpj3/EkKTKsioq2PKC8+T2tZKd0cJnW3lZHUcYGHnA+y+9DLaJp9HML2M/MrnccSs77wRQoiTdXiwesld9+Hu8zPx+ZW0TZtE7YrFNM+bT9uERaS015F9YCsZDbsxTHsjEMXo15efy6aPfgBvZyfzHnyEno5Cgv/MYELja1R+7hzW69tYzO8kaJ1o0QAq2I52pYM7A9YH4M0AenEWxswOPjF5JffuvSCpRezLz6X6rGUUb9hMdtUBOntK6eiuIDujmqz0OgwjxvenP85HylbzVON8vrr9BsJmfMTdHe/cwD+W3cU9E37AjVWfx91lPSL+WBqPihLS1qP4hBBiKB0erF743f/DEQqTu3ErW7/6KbZ+7dNk1u2hdOOLOMMStzzcfGrYQwF9WN/lfdCgBKznmwfIxs8qYyKNRnxIeadK4YLYTu782n1c/6X/YO3V76d12mSmPfUc5WvfBsAVCJK/cw/5O/cQznQRdbvpLimlq7ycrvIyDixbTigjg+n//OdgFFsMYx4jwjOLfkaOy88f+z7KvZun0dwb78CMWwVvPXI7Ydy4d4aJmA6ev3IWP571KCsLLmbGnM3o1S+gjrqXz8DkMnMbPqKsV+PYoYpAxa+FNapMXjemcL65m29Pf5IvbfnwkO+zEGJ40Rg0ln4U7fAy8ZWXKd3wNgro7ihh8+oPYJoODCPG3OWPMPPvT7L1g2fTUboMgKK9TyW38EKIUSeUnsqG2z5yRLAaQGlN3s695O3cS9X7yuksnUlH+Wzq5l1KZ+kMxr9lPcelGBt2vO89KG2y4I9/xd+cw4btH4kfy2pjTOA1Kr9wLvv0RUxV9m7rFfaoQCug0L48WB9AXV8HEQ0uhb7fxZdnP8NfqlbQF7V/Up9oVWcvRzsdjFu1ls6e0nfrhhFj4cw/8bH3P8pHylbzZvsk7th64xEjwqsDedxdeSHfmPwPLp13Ha+8dvKjxc9P28UkTwv3tp2dyN0SQojTEszNZutXPkVqXcOhYDVASmMLS/7tv9lx+03UXnkRMZeHiW9If+ugUto5X+0iS/tZyXTb7xuUe41qVA4mMEm3YGgThzaZYTbiRPPcG4vocmbTMnMaFavWHgpWH48zHCanqpIJr7/GtGeeAcDX1j4YRRbD3IqsvRS4e/hw/U/4ZO8f2ONddug13+ZcwriJ4SSMC9/mXNZ2TOZfPecSxo2/qeOYYDWAicF2VYwJTNHNZHHYnJFaM9FsQQNPNc4f9P0TQgxf/17xDD+c9BiKGBld60FrGufMxZ8bn9O1s60c03QABqZp0NlWTjAzk97caSgzSnrr1uTugBBiVGqaPxvT7Wbu/Y8cClYfzRkOkFf5NpNfewBHOIgjPPDaHmJscYZCOAMhfB2ddHRXHHEsM7fFB4a4VHIXbxuNtDsThUb5m+BNP0Q0Kkb875oITx5YTF/Uev7WwVT69js4QiE233gtLeFpR9SNju4KVm2cwaauclbk7ONXcx8gz/3uvLkz0uq5ffxKqmIVrKkuPaXtr+qbxL1tZyVob4QQIjE8HZ3kr91I37hS6i4+59DzGqi9/ALqLzobRzhI3t6NySvkMNRCOh06hV5O7tg2KAHrRiOTdcZ4inQPZ5t7OD+2izLdwUajjLv/fCWNc2ehHQ6KN9pfqbJx9hwwTYq2bhmMIoth7qKc7fRG3WzY7ye1cxftJefRnTMHgMDcNtyEcRDBTYTA3Da68xdxRd4qnu86C9/+dSfMd7tRwovGdNzEuNzcxiSzBYCF+gAVdLBejePllllDso9CiOGn3NPGbaWvcWPRW1xfsJ7MjjcpaHiEiM/Hxg9/lIbZc8jMPYBhxIAYhmHintzLpg99mJjTR/HOx0jtrEz2bgghRqHGhXNIbWgivcH6dvtAViExt5f05v1DUDIxUmTvryKQl0MwI53sjOojjmXMj6fJZ3syizg6eTIwfQWoqB+1oC8+stoBygV6RQrf3PgBbK1qPIiyqg+w8L6HiKT4qP/Y3CPqRnZGNc1tWVy3/nP8aM8VnJ+7k+eX3cl7CzcwNbWBBxbdR6/K4L17f0GguuGUth/WLpL9GQghxNGUqZn3w7vIX/02Oz97MzVXXkQwJ4sN3/sqOz53C9lbdzH1xQfIaJT+1uHCuHiIpazHxgrXhxm0RRerjDx8RJhr1gHwhjGJOiMbUDQsmEt6XQNpza228tJK0TRnDjn79+Pp7R2sIothS3NB7k5e75hKRDvIP/AMpuGkrfRiDDNCzZk7OYNf49ucS2BuG1vet5DZ4xTFjkZe3nWJZVenSWXytDGbs819rND7WRGLNy47VSE7VdHg754QYti6teQNYtpgS28x35nwFKs6J1MfgEV/v5+d77mCPZdeRv647cxyPE5PczHGrAh7b7sIVyBA0b5HcQflriAhROIFMzPomFjBpGdftpW+p2AimCb5bbuZkF3Pno6iYbGom0iunP3VAHRMHE9x9xYWzvzToXmKq847Ex+tpNKc5FKOUp5MTMCY0wy/B9bFg9X6zBL03uHx28ysrWfRPQ+y4eMfxvhRhJx/1JLv2oU7xU/E7yWqFb+tPp8XWmbxvzMf5udz/gxAfayYyw/cT++BTXgk6CyEGGWMaIx5P7iLd77xeXZ+9mZ2fvZmjGCI6Xf/kfJ/vkTTJxcmu4jDUuQUws+DFrAG2KGK2O/Iw4lJn4oP/e4tzKenpIipT//Ldj7tEycSTkujaIv9Edli9JiVVkexp4v/a78UAKVNCqqfpmnC+2kpvxxlRqk5cy+c2UZ3zlzaS87nQ8ZHCERdvNo4w9Y2gsrNi8Z05uo65uo6qslmvao4NKe1EGLsyXL28YHCdTzZMp9fHLiQfy34GT+e8igf2XYrbn8fcx77GwfOWErVijPpvaOInMr91M9fQEpbK7Mff4zWhbLQohBicDTNnwWGQdFGe3ce9hRM5JrI/dz1vu9RktbBge5cnthzBn/fs4SOQS6rGL7SGptw+f20T6xgdtUqPv3BZ3h65RJqWoromDieUtZKV3gw9Qet1cI2WJqK9hUMu3OP9MZmFt/zADuuvoLW70+llanvvqg1RixIbSzIme2f547Irwi6cnmpbzk9+9djoJFR0kKI0ehg0Lry+isJ5WZT8cRzpNY1JrtYAIS9aTTMPof8fRtI6RgeZTpVgxqwRilCuDj8lL1h/hxULEbRZvu3l7XMmckN+k/ctuJ/qZ+Sy9t7J7O1soLBLr4YHi7K2YGpFa+0vzs5u6GjFFY9SeOE62gedwWFVU8Sc6XSVnYxqd27+f/s3XecHVXd+PHPmdv2bu89fdN7r0CA0IOgNBVEUBQVH7H+rI+iPlZUrCgqikqX3jsBAum9180m23u/fc7vj7sJCUl2JsndvVu+79frvnb37rlnzsw9M3PmO2fOuWrYM7xVM57OiP0xcrRSbFLFbNZF6D7WWBR9w6T0Q0zPPEBEG4S1gakNAqkmYe048l4EA1/ExaaOIbRH4jdZjjhzn8hfSaIjxN8qz+ZQIIv/K72Mn5U8yQ35K1nOApTWDF21ktTycnYuvZyKmbNILzvAhGeexhkMIucoIURPqZ4xmeSKKpJrrJ9WzMiM8MDQz3FVwhPsbcrjZyuv5LyhW/nSzBe5bfpLrPCP5Om2qbzVMYYwjl4o/ekJJSTRmZFHatV+CYHFiNKQXnqQeVN2cs85fyItpZNZk/by8ft/SsTjJkfJcCA9zpOG9qTFuxTdSqprYMa9/6G1uIiQN4FQopew10vNnBRMRwKmI4GIw8tdbV9C6RA55S/iNEPxLrYY5PyJRRgRH+6APO0oeoYRjjDqoafjXYxjBBNT2b/waoJJaXRmFjD6zftxhvpvJ6qYXk3/4s6Pd/t/rRSVH5pMWkUpvkKND+9J01769bfwEmQidUxWf2KY4yDt+W4SCXHDkjcJa4NalUKlSqeCNOpJOWmQ8acvXXkmq3XE2GkHbaUre3m4ZZrHGuZZpgFwNdt4JCzt+AkFP8hzwF7gNpAbsZXudOiQQbgysds0+WOPv/C6OH8LWwOFuAqD5NNIU8f79aY4eD/lnk9QM/JqABJD+7nC/UtyPG0865tEsDjY7fLuvPs6y3KbNntJhnFZpsnYau8RPztx9mCJaZnmwPZCW8tT2saln2FdzwAwe+4yUjshmNH9ehse6zo8elSlZZp8b9uR39NUJ9d41nKWe691IbuETAdrm4azrG48ZdekURbJxKqXiVNZf6fbK62HqXHt7H4/OyyYY728hrIMW3kVvmn9vVcvtK5DieU9GywJB5w07Mk66f8vWbgRACcRPpv4NlvDhYwaU8co6mgikW3hAr4/8lkuuGYsB/2H8yknt/o+UGBEAlRcFN2uo0YfOiZvrwpyW+oyNgSG8Lr//ac/Wv9TbFnuhmnW62YmWH+fAKrO+gDjarO3HwczrZdpNFs3NQLD7R1nndXWZQ8X9N9GmRj4gqmKQxd03xbwrknp9v+hhGSazxlG8drlNE0/+fHMUCZ/+/QfmWpWoFC8aU6hNDOZnAX1bCGfAzqNMUYtoxx13Jn3BA2hJJ6sm84jtbPZ4/vAuSbLXvvQCFofO9L32mtPZL37fq+ghnGj2PmZjxNMTWbES8sY8/gLKCCcWGCdkc1mSdjGqbN9uL3jrNHSgzcsTYXR1v25Ms3tt8xm51fScKsQPyn+Jp9Jf4ZtviLuLF/Cj4qe5fOff4r32m+ifkuARnO4ZV7O4g7LNOEKe20TO3K81stL+U35ce8FU5LQhoGn5f023u4vDbHMK7HCXiXqGGZdP0oevdUyjVnQ/fXLGTMVRufJ69Cez5+s/h7bU694TXfn5OhxLrKgtZs0Uf7yZMs0YG9XtrvvuZusr8k8Nh4/CZzdZp0ICJYnWaaxcRkAQCTJOuGYv9sL0u6xt8jjKKVJcJz8poSz1Xr7OmxW88T51jdm1ePvnws1UD1xDlUlizCCAca8/jhJDdG6O+cL6yzz2txoff1crW2ce4Ahs48/Dn1Q2VZ71+t2uF1hyzRNufYqWuEE6/kxAE5rpp6wARbXIxUXWJfTXW/3XGtz57Kw5xfTbKXLf9d6efnvWh8bAWoWpFumydkQnVC7IyuTXZ+6BtNwMe7pF9i19CLqh53L5IefYP/I7tuWhw27KHZ19k/PXGIrHbx60v/0avevtvyhhBKTydrb/d36kdnVLDU2MVWV41IR3gws5hVzHJXKg4sIw1QDI1QdY1UNs3QZs4AgDqp1KhUqnVKy6VTxnVlZxEa2o43xnmr+3HT2Cf/v0H6K2h6gLvEiFGFyO17i0vzN+EwXbzSPO+FnhLDLQYQL3du5wrMRJxGeDUzhteAETBQOTAw069aXYHpS8GWPI5Q6FENBrlnOuUnvcVniE3x73HMA1EaSWRscztrAMDaGhuDT7jivnejOPOd+UpWfV0MTjnpXcX9wHt/3PsedYx/lY5tuxey6IHOYvm7zyzA6+FnmU4x21XKhdzudTW5WBEb14BoIIQaq1rzoI/mZpbtPmmZsXjnfuuQxJuhDLA/P4+ttv+CW7O8ek6ZNeVmnhvHT9Zdxdvpurs1dw435K7ilcDkb24bwrf1XsbPT3kV5T9HAgQvPYddVl5BUXUf21p2UXrwYrRRjH3s+rmXr70Z5arlryKOM99ZwV8eX+U3lIhL8O8h3tfLFvOd5M/A73uzBTgi9rb0gl9Xfug3tcDDrzr+QVmZ9US7EQNGRk0nVrKmMemkZStvshNQPmYaDsnkX0DhyAhkHdtGZlcfu8686JmgtRG9ryytg14WX4wiHcPl8OH2dJE5rwd3eEX11dP1s6yCprgEjcuqdSNtzc1h/88fRSjHz3vtJqa4l7PGw9+LzqZw5FdgV+xXrBb0asG4cPgFHwE96+bH3YdprC2irKWLhjOV85SP3MXfEHsLaYJMu5stN91Ku8/hk2vco3tjI8LUNHJiVxSvTJrHdWYhHhyikhULdTCHNDNVNTOMQLzCZJmV9J1P0bbMSopPBrPCNPGkap+6koONJAAxMLkzdwVvto/GZEhAUp2+K8xAf96yiwNHKhtAQHvTPJWWzn0Xr9rBjZgF7J+VSY45hTf7V+NJGocwwybXbSKtbR3OwjZUF1/Dt3J8zom4Tt6bfwUL3FhZ7dnGpdyshbbAtVMi64DA2BIewP5yDlgec+wyFZolrB2WRTHaZeYzYXMeYdTXsnplH6ZQcHgnO4qa0FdxctJx7K058M+1oxY5Gfp75JOmGjzualvLRpDV8L+MFvtFwFdtDsetVIYQYHFryx5BYX0NCW/Mx77fVFeCvz+eTl/yX7330LzR1JvMSU1ja8BbnJz0OQO6GVgpWt1A1J43a6akAmBgsax7HsuZxZDrb+XDOej5X+BZ3j7mfyzbfHrf2VNjjYctN11Azawp5azcz+b7/4ggEcPr8HLjoHLShSIysk7PnKdNcmLCdW0qW4zNd3HLgBv7p/j+SXPtI8O/grvoPMTnD5PeZ3+NDibdT2pkb7wKfsbbCfNZ88wuAxuEPsOabX2Dmr+8hY19ZvIsmRI8LJnlZ94WbCCV5KX5vHQkt9np29jchj5d953yIjtwiCje+S/qyUprqSqi/cuKRoLUQvU0rRelZ54NSJNXVEvJ68ael05GdTzA5CYxjn0bw1jcy5tmXyd2603b7prUgnw03fQwjEmHmP+4nqa6B5tYi9MMGKUYluy67kILSWtyB/jdrSa8FrCNOF83FJWSW7cYw379j0F5bwO5XrwLT4Jnts/jEvDe4+2AJ7QtNVgfOZ3lwCR9O/g3FGxv55GfewxE0ibgN/vW3BTAHAspFKdmUqmwAMnQHF+ttXKq38DTTaFcyhmx/Nt1ziDbTw96QdWPZq4J8PHM1Oc52Xmqd2AulEwORgcm3017k7IS9VEVS+XXnBWwOD2HUllq+eduLOEMmYZeDK37zMK9MuAojsZP0qvdIrd+EI/J+L9usyrfwth2kbNhFfLfzYab7/k6+2sF4VxWz3WXM8hzg08nvAtBsennbP5q/dVgHP/uLQFIyTcNHkb9tU7yLcsomOSrIN1q517+QEZvr+crnX8MRihBxObjrz0tYOWUkxe3N/L8RL/FKw0QO+U/+SH6Bo5nfZz+CqRVfbbya3aF8NgeL+H3WI/wk82k+U3cDH7xsqB4/g8YR4xj/woMSiBFCHCOYkII/vYCCzWuOeb+troDdr0Xb07/YOhenEeaNimHkfyGBCG6mJiwnd0Mrl960FSNoYroNXrhv0pGg9WGN4WTurTqbbR1FPDjhb3xr2Av8oPTKXlzDqIjLzYrvfJGO/BzG/vc5hr/y9pHj4fiHn0FpKLvgbLL3usndu6LXy9ef3Zb8Jhd7t/Ne+0i+fuhq6sIpeFPL6HQNx8RJi2cKH2++li2ZY/nD1P+wdMVX6c8T5/ky01nzrS+gIiazf3k3jkCQNf/vC6z9xueZ+5Pfx7t4QvQoDWy85eP4M9OY/bt7B2ywOpCcxu4lVxNKSOQjW+/kQ8YKPv/y/QSDblzrgtz1ly+zbOk51EWGkeOQG1Wi99SNGU9HTh6jX32e7L07j7yfsrcVrRQhbwLB5CSCyUn4M9IpPW8Rm27+GJm79zH93gct8/enZLLt0utwBgLM+Mf9JDY209xaxPpt12OaDoxfRFCZEeomXELRXuv8+pre62GtFC5/Bw2jJmCEQhSvX44zGKC1phhtGpimE39A8fk/f5+caRsxppaw1n8puY4DjPesYPjaBhxBE8MEHTKjPa3nHB8kaFJJVOh0RlOLG+sxfETf1mQmkmIEeHvonXSabgLahd90EdBOAqYz+lM7CWkH072HSHEE2OQr4s22MdaZC3ESk1yVNJle/rfjSkJdh8nx66pwhkwcpsYMaeZu3EjLtHaqNrVg6BMfaxLbSina+R8qJ32SGj2NbLWbLaFitoSK8Gsn2YntpBgB0g0fQ5z9745ndzwd7STV1fTr+eEnOiupXpeKIxTBYQJhkzHrakicHmRGahkh08BjdH+eSVYBPCqMT7tIN6I3NBJVEIXGRRivOn78P9PpJP3QXrQyUDo2Y64JIQYGpTWOQAdVk2cR9iRQvG45Lr+Ptupj29N3P3cToVuSeKNlKsNd2xnl3kbB6haMrrY0IZOC1S3HBawP2+fLwWe6yHPFJ7hhOp0EU5Nx+gOklFcdcx5RQHJl9NHusEeepjxVGUZ0rMvRnlquyljPgw1z6PBvpiN1PPtzvgXADcYfSTICuI0wThWdXLq/CickEPYmkFRVi7utAyMcxtPSSmduFqHkREDmPRADmFIEkxNREROt7M2l1N+ESWDvuVcScbkZ++oj/PSy3/KfRz5DIOjBNB3oEJSvLuSe2Z9nQv16Lkv+KR7V/VB+QsSKNqLnz6ZhI8nat+uYIXmU1rg7fbg7fVBbD5SRv2ELmz9xDbWTxhFxW8+RFk5IJOxNYMjKNSQ2NkeX1ToM03QABqapSVzegn9aWr+8Lu+1gLUjFGTci/+hZsJ8asZPp3noKIauepOU2nLqnSHCYTCVxhjrZ9uHPkHAn8a8hKc4L+kBXCrIgVlZRNwGOmRiugwOzDpxj7bhup4x1LKRYhqVvQkcRN/1j+aFrPMPY25CKW4Vxq3CEAGPCuMxQl0/w6QYAd5oG8sjTbNY5xtK/9sVRV9hYvC39rP4ZtrLLHDt463QWAB2zCwg5HJhhiKEXS7Cc3YzxllJje6+N78zHJ0YyOD9mUXOS9jJJ5JXsSYwjHcCo1kbHEaTmWRr0sX+JKW2f44VtyVSzNPBqVzh3sTKucOJ/N0BYZOI06BgbgsfTtjIjvYCbttxPft93T/9sSecxxfqP85301/gZ5lPsTlQxEhXPSaKbzRezaFI5nGfKdyyuqdWTQjRz7kC7ZQsv4+W3LnUTJxO4/DRFG1YQUp9OZ4dQQIh0AbUXTOJ0NgULkp6kCtS/45DRaiak4bpNqCrLV01J+0kS9F8b/jzOFWEnx+8tFfX7zCXr5P5P/kD62/7JGtv/zRjH3+R4a+8hQLKF8xk2w0fIWfzDrKq3oxL+fqz/2u9jEmuCi5ybONr+a/xuZy3eaRpFn9qbWG78yK+lfxrfpD5R9Z0DONzqz/Vr4PVACmV1cz47b2sv/1TvHfHVzEiEXzZmUy9536yduyl4QLrSReF6K+U1sz6w32s+fKnWXfbJzn7+7/C0249aWl/oTEodX+UgDud0a8/zuKk5YzNraTGFUYrE5RCK832gJdMRzOXJbzOMt8tXOj9A0rCBaIX5O3YQjAxiYqZ8/CnpjH6tRdIaGs5aXrDNOnMySK99GA0kE33c/Ml15WTu3UHZYvmUbBhM4mNzWSklmEYEUxTYxgmnednkdawql9GyHp1DGtHOMTQNW+RtX8HBxZcwL5zLyd91D7+c+W1vPzOEp7MuYCypUtwd7TxybTvMdy17chny6dl8q+/LTgyhnX5tEyKOWr2W62ZSBVzdSl1JLNeDe3NVRM9JIiTNf7hrPEPP/JeU4c3fgUSg8Ib/rFckbSJaz1rWRceRrtO4O0J5/Hir7/Fhzc/QOfsCsqn2LshpoEIbpxdAet8o4XbkpexNVjIHS2XH5m0T/QtL4Ymka46OWf2Hl776zjCqx1MnF/BvJmlvBMq4ZaNNxMwre96A5SFs7it/mN8NvUdPpK0kYZIIl9ruOaEwWohhLDiCAcZuuZtcnZvoWzuuRycdy7zprzB6584n68+82NWLjgPNQLGvfhfrr7lz0c+Vzs9lRfum3TcGNZHSzIC/HTUE1yRvZHfHTqfA/7s3ly1YyTWNzLvZ39k683Xsuuay2gZVkTWzn1su+HDZO3Yw7Q//4eKK3LiVr7+S7E1VMxjh2YyNqGaW7KXc2PWSj6RtRJX143zp5um8J2KD+MLDYzOP9nbdjHjt/ey9v99HoDpv/8Heeu3xLlUQvSOhNY2Zv/2XhrHjBhgwWo45FpKm2M0w957mZTacm74yFs0dCSzzZfCmEseo626mJT8ciqUYl99Hl9L/xn/qN/HttAOJrlfi/cqiEFiyLqVeFua2H/2EjZf+wlGvPMGyXtXnjCA3JGdRXtBHmOfetF2/mOff4WGkhHs/NAlTL/vIdJTK5gx8QGaWofRfmEOtRPGk7qr/w3TCb0csD4sqaGWCc89SM2EGVRMm8+lRW9QPrOEe9smkLNrM0PWvMXwL2877nPl0zIpn3b8Bb5LhzlL72Uk9ZSRyVtqDOYAfeRFCNEbFP/2z+fHSU9xjWctv++8kncCnyVpUgObZmmcyv4FvFZOwMChghiYfCPtZUwUd7ZeKMHqPk3xcHA2acrPkjk7YQ74tZN/+BeyOjLCdrD6sBBO/tR6Lve2LSKsDcL07x5rQoj487Y0MfaVJ2geOopzLtrM/JErKSuaQNbunQx78g2coeBxn6mdnnrSYUDGJ1bypzEPMCyhgTsPXsTdFYt7eA2sOYMhpt7zAKllFey+6lKq50wjc8ceZvzpXzjCMvTfmdrlz+cb5VdzV80Sbsp+jyJXM9v9BfypdjED7WnF7O27WXLrNwFwBo7fN4QYyBJa2yhcuznexYipOsd86p1zyQu9Rfb+bYzIqmbhyJ38efnFBCMukvOqSM6r6kqteGzjAr655EkuT7if5/3Xk+fYS47jQDxXQQwi2Xt3kVJdyZ7zL2Xv+ZfQnlnM+Mefw+XzH5Oudsp4APK2bLedt6etnZJXlrHrQxdTPXUiBZu2kZ5aQXJ2Lcs//CVyt+3ESXtM16e3xCVgDdHHU/K3rWN4zQaSbumkrtbL6OVPkl5Rekr5pOtOlugdpOJjjRrGJoqR5zuEEGeqwszgleBELvFs5Wft89AoFnvuxqlO7SJHG9HDrIMAH0tazQRXNT9vuZha88QBA9F3aAzuDSzkSr2RTNXBU8Fp1OiTPUJvj1+fWqBbCCG6o4CMg/v4UNuD7HMVkv70W6TUVVl+7lia6/NW8f3hz9IUTuRj2z7L6raRPVHc06KAkS8tI23/QRyhEMkV1ThCEqyOpcpQOj+tis/wL71JAtVCDAwtxhjKXZeSFtlOYfhVIJPrZ76FP+TisU3zT/iZF7bP4vbzn+X/Jf2YNwKX8Ern/3BN8vdwy3jWopd42tuY+MyjVEyfTfmsBTQPH8KkB58gc//7E4HWTB5P6sFyEppPbQ6R4jXrqZo+md2XXED27n24fH6qpk8h7E1g6HurqV8Q67XpHTHt3tc80Xr81bDn2GDyUMfB6PsbKk89WB3q5Aq9EQ9hXlST2KSG9GiwetfG2A0zklBz/KZ3qggGpz6GravFep1DqdoyTX+RkRS7k0rrdOuGa+r67scNOhV29hG7UvZa774xHRJZD64bQdW+FJ4KTKc6ks3PUn7MOZ57SDHqTjkf04gGKGe6tvCxxDW85hvHW4GenRQ0NK4zZnkZab17cefPj+843q+8O+2Yv0M4+W9wFvcEzjnlYPW+PQUxLFnvCqX07jnDaI5dIN9ZFbtjthB9VXvR++dkpxFmWvF+1u8dccrBapcO88fRD/KTkU+ysnUkl266/cTBak/sjs31M07v+JK1ez/ppYdwBo+frLZbMTycuVoG15NRjsLYtSecRbHLy46EB2LXfuks6uVzYkvc+pQBoGJ4Tna8Z91BI6G4b/b8C2RYp/G8nXLce4kqwBBX4wlS954dt8d32LmZS3ZYpom4Ty/vZmMCpe7r8OpqhgcfRaHJuKaMSyes47lts2jxnXgoo45gAqvDI5jj3MdHEn9Jm85mme/T6A/s3lMyKy3LkD/zVG8Mn9ywSdbLs6u+yvpaJWN0fOtmLAWze/LmtWZaWhlFCbHdXkpritevZuJTD2OEI6z9/E3sueR8TMPAl55G69Bi8jZb7z8nynf8Uy8Q9iaw5+Lz0QoOzZtN6qEK0sorGfWo3zoTm2JZZ63E9GyoFTRN6r5Be9XZx04mNdGoAKBwaQVn6/cDkRF98gahgwgXG1uZ5yhlbcdQbj94HbXhM+utuHCudaUYlWQvWLUrzzqw/YULXjnm70QCXMtaFPAU02giOuv5H9eea5lXSpoPq+P9kqG7LPMBePrt2bbSnRYNKth90LNxTfcTmAGEU+1dNBWMs/6+anbm0D7COj+jybrhZtp8wr9xivXyUvZbXxBdedPblmke3TPdVplC5UmWaQy/gZ3HQxPqbS2yxySvS7BMU//WMMs0WsGOkZfRdM5SHk2/jiUbhvPIprOOT2dxzDNdTlJVCz/x3kNFRybffOlGOsInLmNonPXNGF1rHYzz1Nm8oK6zzuuKs9fYyurFqrmWaVSu9fqpg16C6bYW2WM+GLQ+EY+NoEVwhJ/9Fdbjq+rZNo5BIRv7Xq29772zMGKZJqnM3gEtYqPOehOsg0sdB1JtBa3NBOttZbo1dMT3Yl+IM6Gsd1G+8Zn/Hvk9V7eSaAbJnlPHF+Y+dky63b78k+ZRqJr5sHMDaVmd/KXlbB5on0NigZ9Ejr+oqdyeZ38FLDjbDZpt3LcNJlvf9LNzY76zOHbBdhVSKBvHY+2Kb0eRbRuGWyey0RHBO7wVhlv38vKVHR+0O13ONutz2a7nSyzT+PNN+Kr18lSu9UV8uN1Fq41LTUenddkvW7TeMs3zy2f0eNBaWVRRZePap3OI9b6VdMDA+U73G69juNnrA9DYCZZGkkyCFkHr3y3917FvaM3C8H7StI+3XKPpUNG29u3ln7RcXuGEGutCAQWJbZZp1q0tYdfnsqwzu93WIo/T0ZHAqtVjT/r/gncgx6Ijnj/DXrvV+7folxD0JrJ/8fk0jB5LUl0N4595Bk9HNDi99LaVOB0mfzIWUH/2ydudv3/iCs6+7ldM3bKTVzvfY9+ks/C/00FW6fvDpfjPsd6+gaokSLau/6U2rgOStnuwM0PXlCtOFM/RHH19vmLDGBoOdF9p7VxTQGzP+8cXQhNJ7H772TmeAoRtfA9minXD6jNz3o+tKDQXqm3MMqI9n+t0Mnt1Lr/fsoS1rcMJ6e6Pz5WXWS+v6JkqJj9xP6WLzqV0ydnUTR5NSlU0EJzcVEb7iOh5dci1+y3z2jLhcGyjhZSmtVTOnEv7sACd2VlkVzzHnus9XDp3I6Mtc4KXllvHj4yAstXz2TjF/gUnEvcrugwVHfi/SSfaSp9GJ9c51jDEaOLeugX8qvrCuI4FOlZVMUw18oo58bTzSCTAdawlFR8hHFzPKp5jCgeI30Q3Qgx2nRm5lM86l5dKy1mZOYYvLHiRx95aSkXpGFIKy0nKs3dnXRsu/pR6G4WeOq5//YsnDVb3JyNUHS14adQDYzImIYTozwp0Cxqoxm7nDc1co5RLHVtox8OX6j7K5mBxTxZRCCEGhVFmPZm6kwiKaeFDvOcchZbhSs+IBurHjGP/OecRcbsZ+t47FK1fg2FGA5UeV5BP5K7k9eZxlPrfDxDP2FvGvB37WTl+JOtLogG9PY2FrK8awdUT3uPfD62mI7uYysnn4OpsJbXmQBzW7nRprk5YzznuXfyi/WLKTZnIPVZchLnS2MAYVcu29QW410RInBNg9rQDPDT1r7SFPSxvGs2bTeNY1jiW2uDpDxfpCIUoefMVMg6Wsu/cC2nPKyCxvg5vS/Np55lWv4LO1LG0Zs/FCHeS2Lr7tPPqC+IfsKaToHbQQfc9/VyEGaXquNKxAQcmD4Xn8PPqS3qplCeWjJ+POaK9D18zx5/WBGpHB6sfZwateLmSDXyE9bxFzw4bIAae4aqOGp2GdZ970Z2wO4HSRUtx+jsZ/t6L/CLpI3x18jtsfurjBENuqo0Io5c+bito/eHcVdzgfYBf7bmOTQ3De77wPWySUc7Nrvdox8Pvg+fTIEFrIYSIq3zdQgNJBFX3PSKdRMhRbSx27GKSUclOM4/HwzMlWC2EEDGQYvoZG6mhSqVSaaQxM3KIUWYdex3WTxCLEwslJFK69HyaRpaQUlVJyesvk9jYcEyaS2asJdPVyd+q338SdsbeMh74xd9xhcOEnE6u/+YtR4LWj2xdyC8uuJ/5xXsIr32R0oVXUTb3coaterbfBK2vS1jLlQkbCWmDbye/yA/aP0S9GbsnXQarRAJcZ6whnxZWrh/BzE+X4QiaRNwGD/99Nm8ljOPczJ0sztzJJTlbAdjaVsijNbP5d+UCTney4qx9e0iurqJs4Tlk7t97Rutg6DAj657kfye8Dr4mfueeSV2w/86dFfeAtVOZGGgucGynQSeRqvyk4CfD6CAFP8kqQAp+ElR0fJpqncrD4Tk0EP8gyVhVfeR3FxECpxGwns4hslQHz+nJlBO9M/YQc7iBlZyrdpPjaqUu1H8rmOg9TiKMVTWk42Ojjt1464NR85ASgslppFbsB60pa8rlD8/cSCTsBG2gTWirLLYMWI9IbuJno+7jneAi/rzjIlw0984K9KClzs0YSpOKn3Mcu3giPDPeRRJCiEEtDR8aRY5uo06l4NAR0vCRrn0MdzSQq1rJUW1k0oGhIKIVL4Yn8a5Zgu71B/GFEGJgGmo24kBzyJFBg0oiEHEwPNIgAeszUDN+Fk0jS8jct4dxLzyD+sCA0xnJbdx07utsbC9mdduII+/P27EfVziM09QQDjNvx/4jAetQ1zie84bsYkX5WIatfo6dF9xM9cSz+kXAOlO1c2XCRjaFinjcP5MfpTzDpZ4t/NvXT2fV60NmqjIKVQtvm6OJrDZwBE0ME3TIpGhNM69OmMirDRMBzbikaj5V9A7X5q9lUsrTLG8azX7f6e/rno52xrzyfEzW4/OZD3GD91XwQnpJBV/cfkNM8o2HuAesXwuPZ6irgYuc2468F9QO2kigTSdQo1PZq3NpJ4EW7WW7LiAU/2IDsEEPpTXipVxnEOD0JqfYQhEzdRmTqWAn+YBiFHVkqU426mIJVgvbwjh41ZyA4zQm7hTHyizdgT8lndpxM9lx6Y0MWfcGhelv43YH8QUUyjBJKSzvNg93YhJ3z7oHH4l8af1tuDpjNzlHPC2PjOYqIzr+4nuRUXEujRBCiDeNcZxl7uFScysm0f49h8PQYUPRoJOpMtPZxBBqdQrlZgbNWM9dIYQQwr69jhxyzXbmhKPj3poo1jilE9GZyNuxFl9aPo2jRnNwzgKGrnr3yPnNUCY/uO5BUrydfGvnzRzdu3Xl+JGEnE7o6mG9cnx0MuErxq7m+4sfZUvNUP66bSm+1Gwqpp6HQlOw1Xp+qL6gUSexMVTMGGcNZ7n3ALA8aGd0YmFlnR7GBF3JXFXKK7MnEHEb6JCJ6TIom50FHZrRiTVcmr2Fi7O3MD452oH18ZoZ7PdZj1feW/5ycDGrmkdSnNDIy/WT4l2cMxL3yG8bXn4fWkKeaiGMgzadQAAn3liM0N3DTAz26DMbjL4VL8sYw4VqB1N0BTWkchHbOKQzeINxMSqpGCxMjNMamkYcyzAjFG1aTsbB3RycewGlZ32IgsgrvDptCdfe9QuSCytO2LtaA1o58aWO5K7Jf6PEuZ9rtn4H34GBEawGeDcyinbtwYebap0e7+IIIcSgV6dSeNaYwhDdRDFNNJNIs/LSgpd1/uHSLhBCiF4QUC7ec41gUWgfiYRY4xxKrSGdz86Ey9/JpCcfZd/iJZTPnU9ndjZjXnkBRyjEp85/hVmj9vLTx65l59D3J+nVGKwaN4OPfP9HzN+xh7enzGPlhLncnvkAP8p8mFd85/MR/QQd53d9N1ozdM0LpNSWxWktT5Xi3775/Cb1v1zg2cHK4Aj2R/pOsLQ/68TDg+ZcbjRWcP6MHTz/9ymkremkbXYCJdNred3/K0Yl1mFqxZrW4fxw74d4qWESVYH0eBf9GH7TzYpm68mJ+4O4B6wBNGpQBz42U8xYXcOFajsArTqBZ5kiFxhCxFliUy1jX36ImnEzcS10MaVgC61fHUagPZ1a9wwibg+BVA+m4/0XysF3kn7Cld5n+cGea9hYnWYxQn//ojHYaEpvESGE6EtCysl+lcN+jr1olbakEEL0noBy8bprbPQPmWwxJoxIhJLXXyapvo7Ssxaz+ZqP8+ntP+am817nqS2L+Hfr9TSnZhJyZRFyZRNyZYJyUFkILy0EpYP8KvlrfDXljzzWtJQv7v4hSb7tpPk7cQU68LQ1ktDWGO/VPCVVZjpP+adxlnsPj/hnxbs4A0ob3iNB6ytnbqR9hodkFcDUsCJQwj8rFvFy/STqQjJmeG/oEwFroXiZiXyWdwB4iml0DqgQlxD9l9Im+TvWUDxsAx2jEvCnZ+NPzcQZCuAIBnBEOnEFmzAiAdyRDr6a/Q++lfxPnqyawb8PzIl38YUQQgghhBC9RQLVMaeAwk3rSWxsoH3pNH5w9QNsCk3hYzmv4L/UC1rjDDfjCtXj9e3DFarHFaonwWzkV8Pu56qUDfyzegG/e3IxebwV79WJiUf8s3nEPzvexRiQmkjiQXMOM1UZ6crHW2Y+u3Uev9tyYbyLNuhIwLqPaMXLXXoJBmafGaNbCPG+ZNoIdsDkJ+855v2mSdExw8clV3LnxEeYlFrBM9XT+M72qzndmYKFEEIIIYQQQrwv/dAB/ha+A6/ZwReXf48hB98gsbGBxkV1GDp8TNoEI8jdJQ9wXvou7jx0IX+qOpc0eepI2FRHKi/pydExP0XcnFJk1AiDp+7kO3nYxvwtT74+19ayIhlhyzRGm8NWXna8u2q8ZZr3QhNs5fX1pc9apvnL7rNs5WVnB8lI6rRM8+S79u6+GdkBW+lOiwLt7n6FEiqtA3ytOfaOGjU7e3csJyNincbVYu8k2TbGOrMH3lxkmcb02puA0dDW291MsJdXZ7GtZD2mY7h1OTuD1uv7tcuP3Y/H6zK8BLjlq88c8/4ft5zDZ3Pe4Qs5b9FqJvDFgx/lldYJkBfGRfQ45nd7bZXdqEqwTuSwrv+hyR22lrdw2AHLNLaPHVnW292533o7KBv7UU9yttrbR0MlPss0qs7ekzKxuq3hz7U54aqNVQxk2zvORmqsv9O2ZLd1Rk57y0s6ZH3eD2RKy1L0b53F1vvyD1+8qhdK8j4bzQQAlI3dz1NvL6/mSdYnBGem3zKNa5e9CSZDadbbPdFGOxXA3WYvXamtVKfO0Wl9oI8kWq+vryyGjzzn2LvGCCZYT2QfTrFxIrO5PF1rfa62e8Vp+KzLtfZXM6wzmmdzgXHmbrJeXzvtcttsHIiKX7fXkGwbYl32i25dYZnm9uc+aWt5dtS3JttKV7ndeg4td2N8A7Otw6yX3zbF3j56+aQtR35f5NzDfPd2HgnOZtrcp6ArtLS77djr/lyjle+lv0CJs5bftp7Ha+7xjB1Wzb7qYZbLM8utzxm2t26T9fHsk594xVZW9+22F0ezokL2zk/a1XPt6aykDm6c+163aV66yzpedvFX3rG1vHe/bL3t7qs53zKNMcz6+g9Am9bbuOpse99D1Ybhlmns1MeXlk+3tTxXs3VuOQvszc/V8USBdSIL0pW3lyit0fJ4kBD9losIoQ9csmTqdh4d9Vcmeat4rnkyP666lKaIvQtjIYQQQgghhBDWslUbV7rWsyOSz/LwySeUm+/Zx9dSX8VA8+OWy1gRGNWLpRRCxJIErHvBcF3PBWynVGezkpG0Kxu9KIUQfYqLCH6id8kNbTKdg8yijGZX4vu9qoUQQgghhBBCxIzC5Ab3SiIYPBicx4meT3QS4dPJy/lI0kZ2h3L5acslVEXSe72sZ04zj/2YKDYwVIaLPQXJ+LnesZIqnc6z5lS0DM/Z70nt72GZup2L2EY7HkZTywjqeVzbeBRMCNGnOIngwiBTt3MeO8mlnT3kcMOeT0mvaiGEEEIIIYToAfMd+xnlqOOBwFyadeJx/88x2vhe+vOMc9XwVOdU/t62qN8GesdQw9nGHgBm6IP8Uy8kgPXQIv1ZCj5GqTo26qFnlM8nnCvIo5Vio5kO3LxunrhDWcXM6dSNG8ukRx/HGQqd0TJFz+qfe3E/4seFDxdpRMfYa8GLDxvjeQoh+pS95DKXA3yUtXTi4iUmsF/lSrBaCCGEEEIIIXpIvU7G1DDGUcPKyEiO7mFdYtTwyaz3cBHhx82XsjwwOn4FjQE378/lpoHwIJgoshMPlTr9jPNp0okUGi1Hfj+ZlMoqsnfuxhG2njdPxJcErHtYp/LwtJ5GIS0oNDsokLGsheiH1jGMZhLxEmQvufiV3HgSQgghhBBCiJ6028znhdAUlro3c8DM4u3wWEBzrnMXV7g2UBFJ50fNSzkUyYx3Uc/Yft6fQPJFPZmI7Wlf+68IBrWknnE+T0ZmUK334cPNej38pOlSq6rPeFmid0jAuhe0qERaOPkdHiFEP6AU+8iNdymEEEIIIYQQYlB5JTyRoUYDH3Gtp9ZMZa5zP7OcZWwKF3NH41I6tSfeRYyJTjw8as4kkSAHyYp3cfqVAC6WmePiXQwRQxKwFkIIIYQQQgghhBB9kkbxn+B8vpHwMrclvAnAM8GpvBqeMGCC1YcdOKqXtRCDmQSshRBCCCGEEEKIQUtz9LjAQvRFftz8LXA2xUYjHdrDDrMw3kUSQvSgmI7g7uywscBg7E6EZkokZnnZoV06Znl9bsw7McvrYIX1oyJDxw2ccXpSd/XfcZxCaWbM8jI91vXR8MVwF9eDqxH762cvj1le7ixfzPKyw6z2xiyvs2btiFledug4797h1Njto+QEYpdXLwunxHA72OGN3fI8jYPrWCVEb1CxawLTMbx3jy+RsTYuUGzqGNbLx8aBpK6Xe0D29vJiKG9l7y7vhiHvctfkB3Gq2F9bu5t6d8K48vNj15B8+Z6FlmmuXbwiZssLlsduIvdgZnyPVR1DrZefsvn09tFqncbayIhjgtVjUupOK68TMfy9W2f/8tqSmOWVWNBumSaSOHDOYy/ddVaP5R1xuKkZdRH+5Pwj7znKYneNrbOCMcurt9W9V9BryzqlHtbagHA3x1E7lV/l2ruAN2qtD2A6M4jOtD6xGtU28nJbt8RVWNm68fyrl5daJ7LJzvyMSkN5c363abS9okN9fBt37TYvYoxAbAISrhbrE1Isg8x281NJIeuMmt1oi+Ir02bQ2saV6Dnzt1rnAyzbPcZWuniys7+jFb96yUbQ2sa2u2zRehhpndXzy2dYJ7LJTtB69a6JtvKyc1QY8XD9MX/7MtNpLBlO3qbtOAPRE3LzdOuba+0FPRtsNIKQVHbyfaJtdIRgto3zio0LYbsXacEM62OC6bSuZ45Mew0fO+dXsHdTzFttvY6dNo7rI0bZu6l6MNO6DqW+7cXdIkFr0X85Oqz3q0hS715w2jkeABg2yq6d2lbQWrtsrOMB6wCPmWBi2mh7uRutyx7MNG0FrV3bejDgoUFZdACyc03mHdZmmcZXlmK7WLbYOHfa2XKjpx6yTLNn0xB7QWs7HTJs3rExbdx8rZlnY3FhhQrbWuRpmZBRw5tX//bI355AG95AC5cO2UGHN5Npz3/ZVj7+kdbXK64KD47O7r/VULq9QLl2WadzdDgoX2LjOGTYuB4z4dFl87tPFLHZ3nBY1yEzwcRfb91+t7OPuJuMuHaYd7YZBDK6TxNOMTGaXZZ5vV1pfRHVtj/dVrkMG/uy3fOdHXaOsyMzG3inocQyXUaSdQeomo15lgG+4hmVlvkA1L5RZCvd6WhoT+I/KxZ0m8aYZuO7Sonwn7UW+ygw4rs1lmlKbj32ZtfmT11HW84Egs4iFvz4t3jaOjj4K3vz0tk5d2oVu9NPYrmNo4LNah2yMfdlKFlTuaX7+COAGnnm+5IMCSKEECKmmkYMZeOt1xNMSWanz0/RinUMXRa7HihCCCGEECI2wlvcBJcn4JruJ3lWPakOH62R2PUkFEKI/qRq9lQq58+kcMU6qmdNYfOnP8qs3/0j3sUalCRgLYQQImZqpk5g083X4W1qZsJDT1M9fRIHz5lH2eL5pB/az7BVb5PQ2hzvYgohhBBCDHqOtQGSr6uHkAYXOP4R5JGpf+Gjm2+lJWyvN6EQQgwU/ow0tt3wEdL2lTHpvv+SsecA2268itKLzsHJ6ngXb9Dp3QF6hBBCDGiVc6ahXU6GvL2KvE3bGfPUyxSs3QyGQfOwEpqG2hgbRQghhBBC9DjnigCENCoChMBc62B8chUTkuwNGyCEEANJ65BCwolekmrqUKYZ/RmJUD9hdLyLNihJD2shhBAxM+n+J9jk8bDr6svYdfVlqEgErRR5G7aSWbGNlOqKeBdRCCGEEEIA4fkecCk0XT2sZ0W4Y++HWNFiPaauEEIMNDmbdzDixTcpveRcWoYPwZedSWJNPVPufZja/4136QYfCVgLIYSIGZfPz4y7/8WeKy6kPT+X5Koahr69Cm9js61JF4UQQgghRO+IzPLQ8XAm3rebMGaZdMzP4L5XFsW7WEIIERcKGPPEi5hOB2UXnE1idR1zfvUXPG0dgAyT1NskYC2EECKmDNNk7JMvxbsYQgghhBCnQRMNWwwO7okdGGNNOrxZhF0y2aIQYnBTwLhHn2PMky+hlcIZDMW7SIOWjGEthBBCCCGEEGLQOzt7J2+c9TNKkqrjXZRe40tIpz0xR4LVQgjRRQGOUFiC1XEW04C1o9M6O13ridnyVKM7dnkFre+ia6eO2fJiSdvoAKD6ZtHjLpRmWqZxtfTR+zrpQcskOoZFf2vFpNhl1h/EcKd5fvmMmOU10CVXxfdglbLHEbO8ghnWx5dYisTwnNjbSvflxyyv1rN9MctLiL7K0dG7bRMjELvepircuz1XDX/stpW7sY+2CXuId1hbvItw2kZPPXTKn0ly+PnphEcZntjA/457mmhPa+xdbMVQb19zasNJxPn+NfrGpb+PWd6hooBlGldz7NpekaRIzPKydR3liN13FctjVW+3QT8onGK9fGdb7NY3ZWRzzPKK5fnOjv2NsRsyMW9ajWWa8vWFMVtevBltsTt22DH0650xy6vX43MnqdanUwxXe+/tI6c+JEg3a7Tg/K2WH1/+zkSoSLBMlzWh3jJNw65sVL11AFy7Y1MbzLSwrXRzx5Raplmzxt4sozrN+o6O0eyylZetnaKXG2SnI3esdd0AqNmdbZlGZQcI5VgkqrN3k8XMsHH3zW/zoBqyTpe00/p7902zF7gxbSzPUevi7bcmW6bzlrTaWubpMIKQeKj7xk0wwzqfQJ6N/arTYWunsXuyiVXQ2tlq3bhLtG6rAGDYqLLKZnt3962ZlmlS9lofX1rGx+5C40RMD7SNPvkyvBUOvBXW+0PERickZ4e9Mtk57KYOsd6v2vemo6usz6+RFOttbLdemy7r+mj4rNO4Gwyqyost0+lMG/tkCFpHyl1a0Te52iF/efdpqhfFLtBgJwAS8Vovz91sL7AQyLVxDPfYO847Wq0vUzJ2WO/rDdOwdaANZsZuuzdPjG+wyLRx7ePfk2qZJuLVYKPpmr7Dun60jrG3Tey0c/ZsGmKZxkwwIcF6mY9cdPeR34cGG8iPtFHnSOKs7N28ePkvaXYk8rGnv2iZTyz19A2p7Y15zHzwK92XwUY+ERv7lRFQRBK7/x5USNlaZ+2ysTwbbQ4ANdK6kRapsm7s2e3YFEqz1y6JWdBaK4LpPdgWcmp01sk7T6kGt2XQ2tlu4Gy3Xt+O7dbXGKaNfR3A9MQoLpRur9etryzFVrptNtLZCaSbHg0W62gElK2g9VdvfOaYv106jIkioo49Otz2U8usjpOcGGDh1N3v502YqxPW8bR/Gp1EYy8rVo2zzueAgZ0+uGVtNoL0X7DevgWTakjHOr7iy7HuRKQMbWvgKV1jfW3nbrHOJ3f5sTE0f1oKm2+6FmWazPzTvzDM6D609wfWxz2z2t7TOIkVZ348G1zdBIQQQgghhBBCiKMkmQHyI23UOlIodWXjUy6GhhpRWm6ACiEGN5cOczmbuZht0APHxGGORi52b+NrSa/iwl4nUXH6mkYNY8U3b6NlxBAax5VQeuE58S7SSUnAWgghhBDiNKz46xZ+dtEyVvx1S7yLIoQQ4nRpzYhgAyEcHHJloJWizJWBV4fJC/fck4NCCNHXHQ5W59DGDgpAxf6J/L2RXP7sO4cxjmq+mPgmBvF9Smmg0kDZOfNYc/uncfoDzP/F3eSv2cS+S8+lZWhRvIt3Qqc+JIgQQgghxCC34q9bOP/WUQQZj/uVIK+zhfmftR42SQghRN/ixMRUijJXJhEV7c/V4kik0UjEOK0RPoUQYmBIJkAqPl5lAvuV1Viqp29laBQpys8F7h0kK+ux78Wp0w4HlXOmk719D5P/9V9cPj8THnmGtuICfJnppB2siHcRjyMBayGEEEKIU7Ts8QaCjCeCkyCaZY83MP+z8S6VEEKIUxVWDra7j5/8d487p0d6EwohRH/RpJK4X88jrHp+gsNXgxNZFhxLSMKUPcKIRJj1x3/i9AeODHfl8vlZ+JPf99nhr2RIECGEEEKIU7T4qizcBHEQwk2IxVfFbpZ3IYQQvUyp44PTEqwWQoheCVYfJsHqnuXy+Y8LTvfVYDVID2shhBBCiFM2/7OTeZ0tLHu8gcVXZclwIEIIIYQQQggRIxKwFkIIIYQ4DfM/O1mGARFCCCGEEEKIGFP6FLp/K6XqgLKeK47oR4ZprU9p1H2pP+IDpA6JMyV1SJwpqUPiTEj9EWdK6pA4U1KHxJk45foDUofEMeQYJM7USevQKQWshRBCCCGEEEIIIYQQQoieIpMuCiGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgLUQQgghhBBCCCGEEEKIPkEC1kIIIYQQQgghhBBCCCH6BAlYCyGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgLUQQgghhBBCCCGEEEKIPkEC1kIIIYQQQgghhBBCCCH6BAlYCyGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgLUQQgghhBBCCCGEEEKIPkEC1kIIIYQQQgghhBBCCCH6BAlYCyGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgLUQQgghhBBCCCGEEEKIPkEC1kIIIYQQQgghhBBCCCH6BAlYCyGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgLUQQgghhBBCCCGEEEKIPkEC1kIIIYQQQgghhBBCCCH6BAlYCyGEEEIIIYQQQgghhOgTJGAthBBCCCGEEEIIIYQQok+QgPVJKKWWKaX0B95brJTSSqk74lQs0Y9IHRJnQuqPOFNSh8SZkjokzpTUIXEmpP6IMyV1SJwpqUPiTEkdOn39NmCtlBqnlPqDUmqrUqpFKRVUSlUqpZ5XSn1aKeXpA2UcopS6Wym1SilVrZQKdJXxHaXUzUopVzef/aRSarVSqr1r/ZYppZb2ZvkHuoFah5RSxUqp7yql/quU2quUMrsOhiXxWIeBagDXn4VKqV8qpdYopeq6PlOqlPq71KHYGsB16Gyl1H+61qtBKeXvqkPPKKXOj8d6DFQDtQ6dIA9P1zpqpVR5b5R7sBiodUgpdVNXfTnZ63PxWJeBZqDWn6M+m6aU+pFSarOKXpO1dq3rPXaOXcLaQK1DSqkDFscgrZT633isz0AzUOtQ1+dyVfS6bKtSqk1F29XrlFLfUEql9PZ6DFQDvA6VKKX+qZQq71qvKhW9ThvV2+twOpzxLsDpUEp9H/gB0YD7CuBfQDuQBywG/g58HpgVpyIeNgq4HlgFPAU0AlnAJcA/gE8opS7UWoeP/pBS6lfA14By4G+AG/go8KxS6n+01n/stTUYoAZ4HZoF/B+ggVKgBUjvvSIPfAO8/jwO5ADvAQ8AYWA+8Gngo0qpC7TWK3ptDQaoAV6Hzut6rQLeADqAocCHgMuVUv+ntZaLtDM0wOvQB/0UGNbD5Rx0BkkdehrYeIL31/ZISQeRgV5/lFLjgFeAIuA14EXABQwHriV6rRbqlTUYoAZ4HfotJ77+UsB3iMZhXuyxEg8SA7kOKaWGd6XPBZYRrS8JwIXAL4EblFLztNa+XluLAWiA16FZRK/FUoDXgYeItqc/CnxIKbVYa72hN1filGmt+9WL6AFeAweBuSdJsxR48wyXsyy6eY55b3HXsu+wmYcbME7wvgt4syuvaz/wvwVd7+8FMo56fzjQAPiB4fH+HvrzaxDUoWLgLCD16HIAJfHe9gPhNQjqzzeBwm7We0u8v4P+/hoEdSjhJHkVATVABCiI9/fQn18DvQ6dYHkm8LmutOXx3v4D4TXQ6xBwU9f7N8V7Ww/E1yCoP4nAbqAJmHeCzzoBFe/voT+/Bnod6iavi7rSr4/3d9DfXwO9DgF/6nr/Bx9430E0+KiBG+P9PfTn1yCoQ5u63v/KB95fRLRT2sa+fi7rV0OCdN1luoPo3exLtdarTpROa/0ccPEJPj9XKfVYVxf6oFLqUNcjXYU9UV6tdVBrbZ7g/RDRuyIAoz/w78OPKP5Ea9101GcOED1oeYCbY17YQWIw1CGtdbnW+h2tdWtPlGkwGyT15xda68oTZPcLwAdMUkplxbqsg8UgqUP+k+RVQbTnvgGMjG1JB4/BUIeOKmsqcB/wutb6Lz1RvsFoMNUhEXuDpP58ruu9b2utV57gs2HdddUvTt0gqUMn89mun/fEoGiD1iCpQ4fbys984DMR4PmuP3NiWMxBZaDXIaXUSGAKUAv87gOfWQ48B0wl2tGxz+pvQ4LcTPQOwsNa663dJdRaB47+Wyn1KeCvQIDoTn+I6Bd6C9FHlOdprQ/2SKk/QCnlAC7t+nPzB/59XtfPl07w0ReB/+1K84OeKd2ANxjqkOg5g7n+aKJ3YiHaQ1acnkFbh5RSucBcouXf1UNFGwwGUx36PZBBdEgiETuDqQ5NU0p9mehj1BVEe0nJOOhnZjDUn48Tbfc83BXUuITo8A4HgZe01g29UcYBbDDUoROlzwMuJzrcwIM9WLTBYDDUoW1EA6WXARuO+oxB9JhkEh3uQZyegV6H8rt+HjhRoBvY3/XzfODtHireGetvAetFXT9fP5UPKaXGAH8BDgDndPXyOvy/84mOT/Y74MOxKeZxy88Gvkh0zKoc4AKgBHhQa/3sUemSiD4y3a61rjpBVnu6fo7piXIOEgO6DokeN5jrzzVEx79aqbVu7olyDhKDpg6p6LhpS4m2NYqJXqSlAf+jta7viXIOEoOiDimlPgx8Eriltxr9g8igqENdbv/A3xGl1N+BL5/saRBhaUDXHxWduGoqUAd8hugY+kdfM3copb6ktf5HT5RzkBjQdagbnyIaILtPa93WE2UcRAZDHfol0Xb0j5VS5wLriQ4LcSHRYOQtuq+PP9y3DfQ6dPhaa5hSSp3gqaDDPfjH9kQ5Y6W/BawLun6eas+IzxM9Odx+dIUC0Fq/rpR6huidkJQeOnlkc2yPaA38iuiYOUdL6/rZcpJ8Dr+fHrOSDT4DvQ6JnjUo649SagTwB6I9rL8a89INLoOpDs36wGfagJu11v+JffEGlQFfh7p6of0VeFFrfW8PlGWwG/B1iOik0/9D9MKxnGgbexHwM+BWIJVoL1px6gZ6/ckkeo2cRbS+/IjohFY+4Eqik+n9XSl1QGstvRtPz0CvQ8dRSimivS8hen4TZ2bA1yGtda1Sah7R48+Hef9JfA38jehksOL0Deg6pLXerZTaQ7Tn95c4algQpdQCojdDIPokY5/V3wLWp2t+189zlFKzT/D/XKKD148B1sV64VrrnUTPUw6iPag/TLTxs0gpdZnWujHWyxQxJ3VInIl+W3+6hnF4kegd3Nu01itiXT5hS7+rQzo65vBflFIJwAiiY4L+Wym1UGv9uQ+mFz2uP9WhvxFto95yfE4ijvpNHdJavwW8ddTHO4H/KqVWEp2E6GNKqV9orTfFupzipPpL/Tk8x5MDuEdr/aOjsrlXKZVIdLiibyKP4/e2/lKHTmQJ0R6N67XWa2NdNmFbv6lDXcMRPQN4iQ758C7RCWGvAH4NXKGUmq+1Lo11OUW3+k0dInrt9SLwW6XUUqKTLA4BPgJsAaYRHVqmz+pvAesqYDzRL+ZUHJ4g7BsW6ZJPuUSnQEcHyD8I/E4pVQM8RLRyfbEryeEe1Gkn+PjR7zf3VBkHgYFeh0TPGlT1pytY/QbRR4Vu11rf3ZPlGyQGVR3q+owf2AHcrpTyALcqpV7TWj/Wk2UdwAZ0HVJK3Uh0+JhP6hNPACvO3ICuQxafPaSUegG4HjibaPBanJqBXn+OftL1yRNk8STRgPWcniznADfQ69CJHJ5sUXpXx8ZgqEP3AZOBqVrrw2MTtwL3dHUG+S3RnrY39WRZB7ABX4e01m909dL/HtE2zzlEx67+JtF5PR4hOiljn2VYJ+lTlnf9PP8UP3ckEKy1Vt283uo2l9h6sevn4sNvaK07iFacZKVUwQk+c3jWz909W7QBbUDXIdHjBk396ToGLQMmEO1Z/fveKdaAN2jqUAw/I4410OvQjK6f/1JK6aNfXe8XHfVeem8VdIAZ6HXISl3Xz6TYFmXQGND1R2vdSXQCLThxJ6Gmrp/eHivVwDeg69AHdXUAuQKZbDGWBnQdUkqlEA0uNh4VrD7am10/Z/Zs0Qa0AV2HDtNab9BaX6W1ztFau7XW47TWdwGTupKs6a1Cno7+FrD+JxACrlJKTeguYVcvrsNWdv08q6cKdhoO38kJf+D9w4+WXXyCz1zygTTi1A2GOiR6zqCoP0qpYqKPUo8DPic9q2NqUNShGH9GHGug16EVwL0neUF0aIfDfx8za7uwbaDXIStzu37uj3FZBovBUH8Ojw07ieMdfk8ewz99g6EOHe1momPePqRlssVYGeh1yN31M1Up5eZ4OV0/gz1WqoFvoNehk1LRyYU/RnT9+/QTr/0qYK21PgDcQXQHfl4pNetE6ZRSF/P+XQaAPxL9Mu5S0Vk9P5jerZSKeYVTSs3oGlvmg+8n8/6g589/4N9/6fr5XaVUxlGfGQ7cRvTi7J+xLutgMUjqkOghg6H+KKWGAW8Do4BPaa3l0cUYGiR16ISPSSulRvH+hCBy3DpNA70Oaa0f0VrfcqJXV5Kmo97zxbq8g8FAr0Nd/ztunZRShlLq20THn6wHXop1WQeDwVB/gD8RHdfzW0qpnKM+kwD8pOvPh2Jd1sFikNShw2mOnmzxnliXbbAa6HVIa91AdDg9J/C/H/hMAtEhHgBej3VZB4uBXoe6/pf0wc8opZxEh7UqAX6jta6OdVljqb+NYY3W+qddG/kHwBql1HvAWqKP2OQRHZtldNd7hz+zUyn1KaIzrG5TSr1EdFgNFzCU6N2ROqK9CWPp+8DCrjIeJNoraAjRntLpwHtEZ58+ev3eU0r9BvgqsFkp9RjRneg6orNW/0/XziVO00CvQwBKqfuO+vNwmX6hlDp8V//vWuvliFM2COrPMmA40Ukihiul7jhBvvfJcej0DYI69IpSqhbYQPSxaifRGyAXd/3+B631qzEu56AyCOqQ6GGDoA6tUUptJTpGdQXReWAWEu0d2wlcr7VujXE5B42BXn+01uuUUj8EfghsVUo9A/iBi7rW6z3glzEu56Ay0OvQUc4jGhhar7WO+QRsg9kgqENfIhqA/J5S6oKuNN6uzwwD9gK/iHE5B5VBUIfOBf6ulHoNKCc6rvbFRK/LHuMDN0P6JK11v3wRHSD9D8BWooPPB4kOnP4i8GnAc4LPTCY6eH0Z0Z7KjV2fvwc47wNpl0U3zzHvLQY0cIfNMl4G3E+0ArcQvRNTS/Qxs88Czm4+exPR8WQ6gDaij+cvjfd2H0ivgVyHupbR3eumeG///v4aqPXHRt3RwOJ4b/+B8BrAdehLwHNdZezsKudB4L/ARfHe7gPpNVDrUDd5aaA83tt9IL0Gah0C7iTadq4kGmjsBHYS7Rk1Mt7bfaC8Bmr9OeqzHyH61FlrVz3aBnz3ROslL6lDJ/nsI13LujXe23qgvgZyHQKmAP8h2o4OAr6u49BPgfR4b/uB8hqodQgYAzxOtANRgOgcDG8SnXhaxXu723mprhURQgghhBBCCCGEEEIIIeKqX41hLYQQQgghhBBCCCGEEGLgkoC1EEIIIYQQQgghhBBCiD5BAtZCCCGEEEIIIYQQQggh+gTnqSROznDrzKKEk/6/pi3NOhObQ2Yr00ZWLpuZmcoyieGKWGcTdNhanJ2yqwTr5QGYERv3FCLW64dhb1sZThuFB/z7quq11jm2EndxJCdpZ2bmqXzkxGyuC9rGdrGRlbL3VaE9NrZd2N49IneLdcGCGTYysrEJADz11stLGtppK6/GtmRb6YKHynukDsVq/7O7v9ti83vAzu5nIy9Xh73Fhex8Vb18zDYCdjcW+KtiX4cMt81jcyzrhw1GyDqN6YrhAm1+Dc526zThROs0Rtje8mK6jpzmcSg1STtz0k+eICR9AQCU2/qgYHcaFY/TuoIEOt3WGdk9vNgsV7D8NOpPSpJ2ZlmcwG20W/sqO20mHcPDpxGM3fKMRBttA5+9zLTNw0BPtYVQ1pVY2Tgn62Dsjme229N2NrGd9rvdaZpstN+Vzcy0nWuPgPU2tX2NCwQPVMS8DnkTA7by8XV6TmWxJ9VX2162zgV2D9cOG5mF7WWWk9ZqmaYpYKPxBXTurT7l+gPWdai3zwU4be4zNrexlYRKv610/sKTx85OlcPGIiN2Fmc3PtBob5u2tcf+GCROjXJZn8ecDntxvpDPOkRs57oUwLTRNIfu20KnFLDOLErga4/NOen/73rjYss8DJsHCTtBi3CejVYqQLv1aiYWWl91+w+m2FqcnbK7Stps5eVrs24IqBbrK3idbK8hkJJlL9K19YofldlKeBRnZiZFX/9yt2lsxZhtrgt+6wahEbJeoLPNXmM9PMJnnajeXsNu6AvWF+elV1uXS9m8AVHyT+ttOvcPa23l9dCyhbbSld7+9R6pQ44O6+3iGt9imcbu/m6HafPCw7BRZ+00ePNW2locVefELoBs+KzLHi6wPmZ799g8swE7/++rMa9D3mE2j81lsasfdiRUW29ff769/d0O02bDP2+FdbnqZlrnk1Bvr575c2O3jnCax6GcdIp/+oWT/l/XxO7ipD9zFVu3J8Ihe1erw3MbLNOUbiy2zshOwABQQXv1cf83vnbq9Scrg/zv3d5tGkdn/73pYafNFE6J3X6cWG69vJDNw7VnWpNlms7tdnoLgOm1t4491RYyE6yX78m2breGypPsFsuSs91mezrJRrDdxsWysnnjR42wPla5XPbuqobD1sc0vce6t0DIRnvpsLKbvxXzOjRx+gFb+WzbMPxUF31CniE27n4DgUP2OsXEjJ06ZLMjlZluXWmNRntt4M9d+KplmkfKZtjKa/2lPz3l+gPWdcjVbL2/BzPtHSdtdYrJtLfPKJvb2MqYO3baSrfrG+Ms09i9uZa+w3qbNo+33lh2r0tHPWovKvnGsu/0yHkspuwEmWzf5ex7nEXWHQszk+11Pqzdbn3vIbHK3vm1s/jM20L9t0UshBBCCCGEEEIIIYQQYkCRgLUQ4oRaWos4cHA+La1F8S6KEEIIIYQQQgghhBgkzihgnYyfFGwMgyCE6PNCCR7qx5QA0WD1+s0fZ9+Bc1i/+eMcTJ1Nh5ka5xIKIYQQQgghhDgslU7msp85lMa7KIOO6XRw6MJz0OrYIRKqFs4mkNa7wwf2hoZRI+1O8yFETJxRwHoGZXyClbiwOVuSEKLP2nf+YjZ/9CqahxbT1DwU03QABqZ2sDfnPF7vvCneRRRCCCGEEEII0eUctZtzjN1MUuUYtmZwF7FSM28m2z93A9s+d8ORoPWhC89m89c+y/6rLo1z6WIrmJSIq7PT9jyjQsTCKU26eDQDk3HUUEo2odPPRgjRR5S8tozGkcPZcu1HGLfveYyDEUwTcClcYzo5P/G+eBdRCCGEEEIIIUSXl/UktutCSsnGlBFfe1X+8tW0Dylg/zVLAUjdf5Adt95AztrNjP334+z535I4lzB23B2duDvsTdwnRKycdqQ5iQDNeNlBQSzLI4SIE2cgwJRHnmDNZz5J2a0LmBp8hJ3DLsV/dipTVz5K0qWt8S5iD9Mg94yFEEIIIYQQ/UQQJ/vIjXcxBiUFlDz0NAD7r1lKBZCzdjPTfvlnjLCMQiDEmTrtgHUbXh5lNsgoNkIMGMm1dUx46nm2Xvthdn7rEnzZmYx/6jlSK6vjXbQeNdJdx9+H/Ie/NpzFw82z410cIYQQQgghhBB93OGgtdPnp6Mglwl/e0iC1ULESAzG8pAeiUIMJHnbdtD6XiEHF8ylaM16CjdsjneRelSiEeB3RY+S72rjW7kvs9E3hJ2B/HgXSwghhBBCCCFiQp4l7TkKGPHUy/EuhhADTkwHOfrKeS9ZpjGdseuR7axxxyyvzspkyzQJQ9titrzQ3tjNGqvTQpZpVLsjZsuLt1iui+myro/hlBhOXpEdiFlWIx6zLpcOn94uPurVN5j274cY8+IrR95b9T+zTiuvvk3zk/ynGeZu4PaKa2iOeLmz8HESVCim+7sR6t3mYc282OVlenr3KRrf6GCvLu+45Zf13xm9E6pjd0o3wr1bZ/3ZA+dpLZXnj3cR+g2nKxKzvEZMK7dOFJFL9b7A2dZzY6yayqBmzAL8yVlH3nPF7nRO4oSm2GXWD7iKO2KWVzi5dyeD00bsziuhUO/O1+Sqit017unYtmF4ry4vcMj6Ojwu7NQhM3bnFTMzdm3g64atP+bvZmM8+903YPbS3GOhdOv93d0Yu3OBauzdfWb3HeNilpeOYdMkfYf1Nu3t61LRNzS2J8Ysr86C3rtuO6UjVkvIyws1k076/z2bhsQsAh5JsN4ISoPR7IrREsF/sPtAhbOoE2eR9UDz4QrryqANiFRYn5yduT7LNGbYgKzuA6FaK1t3VDv3ptlI1XOUjbrvLLQ32L93U2waP+Z5zbbShQ+kxmR5AAcvtbdrOiw2xdXnrLSVz/M7Fpzg3WpqcjxH/vIVmexfttAyr1iedI+jNGZC9w0gM936Eaxd8x6M/uJvwvDXYyZkc9fEjRBKI7ejgnWT/0TJE9+3tc+Y+dY3IVSj217jwBG7g7+doPXQkhrLNBUb7M1TYHptXIj6rG82pe2I/821WAWtvcPsRUl8ndaNbD8eyzSxlLcC7PTDKfyfvZZpShzWN1Xf3TSGzqHW5TL88Z9MSAUM1IGTn+dt7QuDQKg8yTKNEbDXNskfbr0vrVo2wbIN6h7bYmNp0Fndg8ETU+Ho7L16nLPGegs7Atbnnvop9socTu3d+j/kqWOHLNt51aXUl8ylM3UUC378O5yBILt/ZK9tm/BahmWatlEm2NjH03b14HfsNC07QBj11ucMO/torNkJWttqR9qJTWmFtjF0pTpofd12yyWvHffeZMqpIZVa3m///+218y3zMousg5JGkwujJXbXuKejN4PW46eV2Uq3w0Zg29Fhb9+zE2vAoe0Fre3osL62M0LK1vL+/MYSyzQlX1pJJrsBqF0wi9I7PkrKrv2k/79SnJ3W8QUrOamtfGbJ6yf9/39/d4FlHs0TTZSNU0ZCjfV3+qkbrDtOAjx+aLplmrpN1uOBmx5tK2htJ7aRNNzePFHNxCbWMPJxex3o9l9l89pj2emXpbd4K61PLBGvdRpzcrut5dmJB9plp/OYneUVjK+1tzwbbZy5U62v/wDWrBltK1134n/lJ4QQ8RDqRPnr0a5k8KTDWh/82Y/elowKtrAkb2u8SyiEEEIIm+onjObAReeQtX0PndmZbP/4lfEukhigRlDHUmMLV6t1uJCxakXfVbtgFlvu+Bopu/cz6usPc6jjIpr1mHgXq1eMpI4hNMa7GEKIMyABayEGmXMdO/iEcwVqME+YaoZRndVguNCJebDOj7qmAvXLBrihA73Zxc+mPkKOx94dbyGEEELETzA5kc03X0dyZQ0z7v4Xo55/ncr5M6mcMy3eRRMDjIMIF6lttGkPacrPImWvp5kQva1+7oxjgtWbfN9kHx9lPd+PedB6HvvIx95TTL1hEhV8RG3gOrWWS9mMgTz9djIa2HrVFaz6/C2EPb37RKcQViRgLcQgM8+xn8mOChKJ71jBcRX2o3QE7UkHZcB7PghpVAQIafRaN5nuTqakH4x3SYUQQghhoT0/l2BaCklVNRihMGllFQA0jh0V55KJgSaZAGn4SCb6WH0RzfEtkBAnUXvWXLTTSfHTL9PqG9U1frUDEydNTIjZclLwca6xmxLsDTnQG8ZRddTv1aRx5sOgDFQRj5uaKRNpz8+lIyfL+gNC9KLenUFCCBF3vwheAoA5mO9XuZLQDg/K34R2p8ICL7i6xjp0KdRMP7tb83mzJnaNOSGEEEL0jMy9Byh5+hX2XnEh734/h86cbFLLyhn72POUflt6jInYaSGRZ/Q0rjQ20qHdPK2nxrtIQpzQmD//i45hxez4xucZWf0wxuYwJmAQJoPtMVtOG17+Yp5NGwkxy/NMvcxELtTbSSLAq0ygid4fs7+/cAaCLLrzdwB42mM30a4QsSABayEGmUEdqD5MKbQ3B6O9HPyN6FnZ6P8WRXtaz4pgTGjmztWXyrYSQggh+olRz79OOMHDgYvOIaGxmVm/uxeXzw+9PGmtGPh2UMBOMw8ALW1F0Uc5OzqZ/q2fsOHn32X/rz/KyK89DJsVGWwnXe2O6bL6WkC4DS+PMzPexeg3JFAt+ioJWAshBienF+1KgUAzuFNhlhdmelCtB9BGAm/USu9qIYQQor9QwNjHX6DkudeAaK8xIXqKBKpFf3B00Lr051ez6PrbcDfLHD1CiP5BAtZCiEFLe7NRoXaUrx6dXAiBZpSOYHoLiF76CiGEEKK/UEigWgghjnY4aN06ZqQEq4UAmosm0DBiFo5gJy5/O05/G45IO85AG65AO85AO45Qp0QD+oCY3hoePfVQLLOzpHu5BoUrEmOWl4rhRLWG0zozpXTsFhhn4crYfQ92GG+k9+ryYumxt+bFLC9vxQDsSWI40QlZqHAHBFujY1q7ksDpZc8Nf4nZYnRm/714LppeZZ0ohlrGR3p1ebGyKHM398/6M9PSyo685ytLiWOJzkzN/N5d3sKpsX00NZ4M3wA8VvYQ0xO7tsncxdbjcQZ3pcVseYNN9uYYNlx72Zjvt8Qsr5R9sn/3GzG89vn7i0tilpcdZkaoV5cXbzs2DotZXpGkGB6rIr0bbDBdsauze39/7DWgs6OTzA1bY5a/lWtuf/W49yJON0evYfq20z+emoYTfVQ48R/3X3zaeX1QzlTrySONQOzqRseB1JjlZcf+qwb3MFlt2cOpnHwBaBOtDDozCmkYMZPaMedROfkKymZdz76Ft7Ln7P9h/5yb6EwvPvJZY0tyHEt+Zqp25MYsr1WbSmKWl5VT6mHtdoQZkdxw0v+/tHoqWBxojZC9nbuvxldjFbQ208O20rnd1ulCIScOV/cnZ/NQoq07ROnjT/799iV2gtbKxiZuGWujUaOAg9Ynkr56B85O0NocaR0kVEF7a6h78lpOWefvaLY+rH2i7Jz30xPh58lPUNhZA8DXGy+hqj6dkYn1fPyidyzz+s/GuZZplNK2gtbTRpRbptm8cpRlmowdx7/nT0nHdLlJbHy/EdY03Ho/cj2fjp0QT8t5Nmbf7nRZJjHaHLSN7MHAiKExvSfP39lo77S4+5N/fv+PUAeqowrQPD73j2hvDnjSmPCXzxNptN56ufOtG8ZVHdbbztFpb+ezE1A1vaatoHX1euv66MyzrhvhGm/MjqE3nve27bQ/PI38VUIE99iTB8D8B2N3o+L6c5dbpvnPOns3Jl1Vbss0Mb3Qt0Hl+bHT3Ht3p3XDuKiwkbwZ1d2mqajMJNzitczLCPT9oGRCjb0ythdZp/HlW6cxPSZg3Vaw286PlV235VknUhqsD7O0jrau/9qwd4HSNMfmjeq77SU7RtiA+oEbcLB1DWin15LStjKL5FoHhx01bv7+gnXQ+v+ufOTYz2mTRIK0qfcno3u6brplPqu2jML09s8b+B/kbLc+Vrna4EDVCMt0Rqb19+lptHcM8iVZ52U6rPMxbH5NrhbrzMzhNtrSALX29v99v7XRPrj9MXvL/IC69hT+snLxSf8/7g8d5NB85G9fRhrv/b9PM/TtVYx+8Q0A9tyYZuumQPqeY4/NLYXF7PrQNQC4fJ24OjvxtLbzq1eX4O5ox93Rgbu9A3dHB8m1tTgDgSOfNVKs2/lVZwExvKFuxfAZ+HakW6Zz2TithNLstePsBK2nztxvK69SW6k+QGnMhO7LaiTbuHFXZ2+iz5SK6PfZmZlNxdTLSGyoY8Jzj+IIR5ehgcS9fvwZ6fjTU/FnpBFIT6V6+iRqh13Iwvt/j8vnp+yqbBybrIPWwXwb7aWwvWOVN9d6fHFt45x4VclGW8tbbaOiVbaksbXWRuMxBmRIECHEoBbBwb/98/lW0kusDI6gykw/Lo0Dk1GqlslGOV5ClOksSnU2lfr4tH1Re04he879MNrhZOTbz5BecVpNC3Eih4PVDjc6MR/lq8Pw1aIjftxGiKBpHWgWwq4Egiww9rHBHNrnJjgSQgjxPqeOcG5kFzm000ASe40cylRWvIslRFzsu+hcIgkJHDhvIUVrNpJY33ha+WilOLDoXNwd7eTs2kYoMYlQYhLhxEQ6c7IJJiWhHe/fHFDhMNm7d5O/eQsZZWXd5CwGuqA3iV0XXokjFGTsK08fCVZDtOOhp60DT1sHaQcrjryft2Ebq75+K7uuupRJ9z8Rh1L3rCzacaswVX04piEBayHEoLclXMz1LZ/m6H7yCs1wVc9ko5yJqpJEFaJTu+jAw1gj2hs7oJ0sHr2TlW0jWdk2ki0dRZh9bBKe1vwh7Ft8Ja7ONhyhIPvP/pAErWPl6GD1jixY2Y6enwGTPKhAE/ef/0e+9O5NVHdmxLukg55CH/PoaH+UQJCbHO9RZDQz39jHk5EZbNeF8S6WEEKIDzgcrM6ig+0qnwLdwlzzADM5SE5iO68HxrEnkkfffT5TiNhpz8uhcvZUCtZuonbSOHZ96EKm/+Ph08qrdtwkOrNzGf3ys2Tve384OXdr9NFqDYQTEggmJxNITqZhdAm1EyZQN2ECnpZWcnZvI3fnNhJaYzdUlOj7Ig4nuy+8grDHy4TnHiZQlkJdzXhS88pJyTn58JdpBysY/to7lF60mLz1W4HTu9HSF6Xg57Out0kkwBuR8Swzx/bJayUJWAtxlOGJdXxu+Js8UjGHDS3D410c0auOPUCfZezmAkd0bI2dZh5rIiPYp3OJYJCEnxGqgRGqjnkppZybHm0w3VN1Fj8rv7TXS34ypuFg3+IrUZEwY195FBWJsH3pjew/+3KmPno6zyGLI7QZDVYrA70jC3VdFYQ0uBT6v0XoyS6mZB3idwv/xXWvfjnepR3UvAS52ljL4+ZMOum/j9Ff5thMnmrlqfA0ZhplfMy5mrXmMJ52TKU1Yj3MhRBCiN4x1Swnh3ZWG8PZa+SyUWuy6GBupJRzPbs417OL37afz4pQ740DKkS8lM+fCcDYp14ioamF0gvOpjMzHWwNCnasqqkzSKyrJWvfiec+UYDL78fl95NUX0/mgQOMeuNNaidMYO+S8ymfPZ+KGXOY/sA/SGiTCSgHi+pJ0+nIyWfMK09h7nSy8/WrMSMODEeEcec/1m3QuuSFN6ieMZm9S5dQuO/RXix1z1rs2Emyig6Xs8S5A3/YxQrTeqjH3ta3ugIKEScJRpCvjXqRl+b/iuuKVvPjcU9wOidRMXBsNovZYUbHZhqqGilQLTi6xu9MJES+amGMUYPXEaI94uax+hk8Uj87nkU+jmFGyNq7lYjHS82EWdSPnkwoKYXM0p04IvbG0RcnoQxwp6B0BPVOI4Q0KkI0aL28DeVvxB92ct/OcyyzEj3Lh4uXzEkE6N/Ds+SoNvbrHNbp4dwbOYu3I6OZocp4ecpdnJd+goHrhRBCxMUBI4sQBuPMKjJ1OxN1FQsj+0jHR7vp4QX/JDaHi60zEmIASC2vAsOgtbiA5uFD8LS04mltP628kupr8aelE3Fbd0DQQEtxEXsuvJA9Fywh4vGQ0NTI0JXL8bS3ndbyRf/kCEWH/0hsqKO1phgz4gAMTNNBa431sTjs9ZJYV9/Dpexdq8yRbDMLKDfTeTcyim1m33xqU3pYi0FOc2HOVr4/9mmKvM08WTmDne0FfHvM81yQs41X6ybFu4AiTppJ4sHIPAojzZzr2MESxw4WGztRgENpTA17dS7f3/8hXmmegN+0ntAsHoasfROAmgmzAMg4sJNhq46fuVucOu2NzrasZrSiXV23uFygprYATj7++pfY3iQXpPGnqKN3Z2DvCSkEqO6aAjWCwavmRLbrQhZHdvKPcf/iibrp/KhsKc1hGdtanJxWBhFXAs5gZ7yLIsSA1aCSedMxlnMju7g4sh2AapXKJlXMn5sWE5JLcDGI5G/Yyp6lS9h480cxPW7GPvkijvDpdZwp3LiO+jETqJkwmaKNa4+8H3E66czKoiMn5/1Xbg7B5GQcgQC5O3aQv3kL3taaPjjogehpKTWVALTnFZCaV47hiKBNjTJMUvPKu/1s7aRxhJITKVy1gc7xvVHa3lGrU3kwbG/i9niSs6UYtIam1fHV6U+wOHsXO9sKuG7Nx1jdPAqHivDR4lXcPvIVXq2biIwvNziUOGopi2QedxFRSToPROZTZDYxx9iPC5NDZgZbzGLaSeCZxmnxKbBNimjQOqmhGqU1GWW7UVqeHogJpaJB67kK9Y8WWAPMBj07EZ2YL8FqETMKTRIB2vWxs6FX6Awu3/I/3Fb0JrcVvslZaXv43wNX8FLj5DiVVPRVGkVLwVjqRs8nlJhOcl0p2ftWk9hcGe+iCTEg1asUXnBMJkX7aVce2lX0+C3BajHYGJEIQ95Zzd6lSwAoXrHutPNKqq8l7VAZBxecQ8TjwZeeSWdmNv60dDCigweocJik+noySktJLztIzq5dR3rYhlJk/xuMvI31GOEQbbmFjMp7nft+fR3lZWNZNPMdnOn1vL1rEpsOFNLYlHLcZyvnTsfT3Er2jr0cHC8T5/Y22WPFoJPgDPLpma/xyRlvEtBOfrjzCv5TvoCIjs4oHNEO/rh/Cb+e9HC0l3W99LIe6AqMZn6Y/AyvBsZzn3/hCdNU6AyejMzs5ZLFhgKySmXIgB6hFNqbA3OBGR3gTkEnZIGSG10idrwEcShN2wnG4A5pJ78tv4CXGyfyy5GP85cxD/B8w2TuOPAh6kLHN7zF4KKBttxR1I1eQCAlm4SWGlL3r6a5eBIH5l1HYmM5KU2r8bYdOHJ7fkZ6KXeMf5Knq2Zy74GzkRv3QpyeDuWhQ/XfuROEiJUhK9bSkZ9D1q69R4LHp6to3Uo6snOpmDmPhOYmEhvrydu2g6S6OpLq6vA2NUnnHHEMQ5sk1dXQnlvIree8yCcWvsmf3riUsoCLczIa+Oalj8OlsGN3Ie+tGsuK1WMor8wikJxE/cQxDHvjXalTcdKjAes0Zye3DHmb5U2jWdXc9wbwFoON5tyRW/jGoqcpTG3iuZ0z+VHNZdQFj39U/Onq6Xxx5GvRXtb10st6oFvk2gPAee6dvBycSJWZHt8Cif5FKRo9JbwYPIurE17Brc6sIS7EB6XgBziuh/XRdnQWcuXWL/CZwnf4SvHrLMnYyTONM/h31Wy2dEhv/8FGAx2ZQ6kbtRB/ej7u9kaKNzxHSs0eFJCzdxVNQybRMHwWNZkfwd1ZQ0bNSm7P+DvfGPMCAdPJd8c9wxBvAz/acSVmvFdI9AsRw0PYk0bYnYZWTpJadqG01B4hBjtXp4/JDzwRk7zSKsuZ/sDfUaZ5ZGgRd6vMzSO6l1xTybTZtdyY9SZPrp/Hf947H4A/vrGUEdk1XJS6mgVzdvPpT7zJpz/xJgfLs3ip5ly2u+opWrUhzqUfvE4pYB2MOCltP3k3+P0f/mv0F60h2Iry16O0yReHv4FOLgKnl5JHbz2jAh/NCNgLIjo7rNPpKdYD74fKbY4LadpYXshe2YNB668o3GJ9537hQnu9K1esGmcrXTy5m+zNFfrgN391zN+5wVayQ+34lZMDnixGzqzizshDJ/18IOJgYqiSC4Zv4tWWCdYLbLAew9hunbVTh0I51kExZ6PNXTzB+mLCkee3lVWorQfHcjYVjs7uv/+iN63vfq7yv/99Kkx+seRx1jWPYmxyORe07+K2NTez0mHvLqoraP1dRZLsXaxtMIdYplEe63I1TbBXz/QBG+P6TrRXdodhXS7d5rBMk7arZ+cCdvgUadtOvl+YNhd/UeHUI7+3jB/Nlu9/BX9eDl98dSdTfvhrPI3N+O8L2sqruibNMo1yWn8Pnnp7+3sgO3bBAxWxrmvGTutzp0qzVybDb/0FPfDsYlt5RT1zCmmjTFMR8J/ZcU7brGdVgWjdyHB0gAvKgllUmcfWF6P1/e897Ejhh4E/8/eGMF9O/C2fzPwX12SvYl3baP6dPJsXa6YQ0ievJ7Nm7LUs05o9w22V3WixUR/LvbbyIsv6fFexP8cyjd1zcNYYexPrlNpKdercjdYVJG/NyY8vLUWFlC4+m+Zhw/C0tjDmpRfJ277tA72DwuRuWYtprOfgbSMIeSdyz/S/c3nCc7zQOY+f1y3ilrR3uHHYuwzLruWrz3wKX9i6vekrsN6Xlc1DkJ3vS1ufVsh/z975PJhivd0bJ9qrQxEb5TptDo2ZYbFP2GhH2tlHh7x6/JcVdrtpLSjEn5aGPz0df1oaQcNDZ34O4eRjj/eRTcOZ9os/4erwsesnEy2XB+Bqtf4ewsnWlcjucfb2WW9YpvnjpsW28vreC9daJ7Jx3swa12BreQBltlPaF0mO2EqXtN96MuPMxVWWaWrWFthanmmjDewriF0vyPSd1pWo4JoDtvLas2K4ZRpda683vrZxGMrY3rPtaVeLYsjzJ19G01Trtm32JnvLqpl7ohU+fAyM/i+SY/N791mnu3DmFss0r6y39wS2nXZrxi57ZW+Y1rs9fPc8XdJzmWtluW0iTutzVPYYe8fKWjOLnKwt/CvjW2xvH8J36q4kcOTBaUUt+YTnjud5xpPV3M5s1wFm55byqaIn+ZD5Fvf8dB5bw0X49tp7ctFojt1E7/7yZMs02mldN55ac5at5c368FbLNPs22+sIY3rP/Joz9j2sw36UrxYVCaAdCZgJWdG/2yujQWsh4iAj1EF2qJ0mZyJV7jRbj+vXGCkMVY3cXvg6r7aMR3pZDzxhdzKThgcpTmzi/wX/yOi2rfyw4GfMzNzP2pYR8S6e6OM0cPDqpez97PV46hopuec/7L/xGlbd80um3PHreBdPDCCpygdAiz55gNefWEDt0MsxnV5aDrzOLzqm8cvsD/PhovXclvI3fjfpQb4z9iUerJjHwwdnUhu0vpgU/Ut7Tjal55xNw5jRuDo6KHnlVfK3b8GInDz4ZJgmi53P8POcm8lydPDV5v/jLv93cLla2NO2joORu/l25pP884K7ue3NW2jwyzAzg5k/JZXN116HPz0diI4Vm9DaQtL+CtJ27yexug5vTfTVOnIY2z9/I6t+8V1m/uiu+Bb8FCQRYCIVbGQIQWIXdBBCCBEfDhXhnpKf48XHzQd+Q8CsO2naBjOZZ/0z+WHHb0gzEngm/WL+N+VZHvPPZB1DMOnZm0HiWDELWKepTlRnDSrYilYOzMQ8cKXAOj/63WTUtFbUtArGJlexq93eXVQhYiEl7CM/2EKrI8FWsDp1vY+0lT5a5nk5ODWTiYlVXJC2w14va9HnmQ4HbZljaMuZiC91GN9N+yztZiLL92bxXO7/8NnUf/G16W9z3dtjMEwZ2kGcWCglmW3fvI36BbPIeWcVRT97mTbfKMa//Vf2//Ja1t11Bxmtb5DcvkFudYkzltZNwFoDrVnTaSw4B2eojYK9DzH69Vq8m7PwTdnIM4ucPJJ6J7OHtHBr5qPcPuwFvjjsFZ5vmMMjZZPZ1lZMW9hmT2fRJ4Xdbg6ctYjy2TNxBoKMePMtiteuwxEKYXqOvbBqbSqkuWEI6VmHSM2o4Nqz3+bWghepDqfyqcob2R7sZJTxb4bvTmT25j08P+3rbJx2Bf/O+CwPXPpHPvfapznQmhunNRXxdDhYHUpIYOJTT5BcU4O7vR0FeN8+9knO5vAogjtTGbf3Ifb89COsvPN7ZDU8h8dXHZ/C2+QgwofYSL5qpUTX8iQz8NGDTw4KIY4IeROpHTOFsMdL9r5tJDXUxrtI4ijBhBQMM4Iz2BnvopyyL5W8wryMvdxU92e2OueT180Tls1mESvDn6GdHM7e9ktWbyqkaYGDa+eso3hcE7fvu466kI2nlEVMxCRgPclVwR3pz0IwgPakoxMyQTlgrQ91TQWENLgU/NPg3zP/ymUrvkL9CcYNFiLWEiJBigJN+AwXFZ4MW8HqKddXYAQ1plux+f5CDpZk8KXCNyRgPQBUTJvBwbkLiCQk4Ay0klf1DtdmP8BrFRNwV24nu3o3v+JG7hr6c2bMymL1pgDuQFO8iy36mFBCMqv++ksCmRmM+cM/SH1iH+v5PiZOjMowUz7zCw59fykN8y4k5Mwgs9n6cWMhupOmfAS1g8AJmm31RRfQnjWFxNZ9ZB96kRFvB1j96OcJ4sa9M8gc/szBhXvZ2gafc3+EnPxPc2PBm9yc+W+uzH4PgNpACvs6cnnJOYHtYXkarj9pz8lm83XXEkxNoXD9BkYsexuX/8RDeLU2FbJ5xbWYpgPDiPD7H97MbZc/zxsdY/hh/VLazQQUsGjbG/zl2w/iDEcIuVwsvfNBFk9/i+cyLuf+pX/hmmXfpaqyJ8e8EH1NyOM5Eqye8tijpNTUnDRtc3gUazq/Hj0nbgkz8X/+yd6fXUX1iGvJK32MBF9lL5b81CxmF/mqldV6ONM5yLWs4QHmxbtYQgx4h2adTc34aWiHExUJUzthOkl11Yx66zmgNd7FG/QiTjcH5l2D09/BiJWP9KvOOFM85dxW8DrvNZTwRN0i/CmFmIbrmI5pGkWdWUKVOZm95mLcdPL5nbdz11f+jDNkEr7P4LG7p3PZ3K28MOkPfGzHLez158VxrQaPmPRnTzN8eFUIUGjl4MjQCe/5IKRREaJB6zWaREcAr0N6LYre4UBjAEHlxM6oT2krfRhBjTJBhTRDVzRR5G4maMqF2UAQSEklkhCdtCyhrZyU5r10hj0syNlNcWIDM9L28pWcewlrB2HDi+k8+QRnYvCKON0EMjNI2bOf4mdfpYkJmDgBByZO2nyjGHXfI6A1YVdmvIsrBoBaMwW3ijDHefyoycHEfBzBVnIPPIUjEsC7OYsgbiI4CeLCu/n9uUdcwSaaD+7nt6tHsnDvAxyIDAMg19PG5NRyUpW9uQpE3xFxe4i4o8MWtOfkUD9mNIHkE4932NwwBNN0AAZaG7Q2DuFvL17EN2qvot18/3w3a/NBnOEITlPjCoX48Lo/4ntrDaXt+aQabXgyrcdTFANLxOPBn55O0Yb13QarARojY485J/qrspn7/36CNlz4Uob3SnlPVwJhTA0ZdKJRuAnjkClHhehxgeRUtCN6U/7wz0ByCqZThuXpC7ThJOLyoB39LyZiYNIe9rAgay9bR57Pd9PvxDluIQFvLm2ZE6gdfhkHJ3+et8JfY495PvlqG0tcP2XhxtU4QyYOU+MMmQRWu3iqYRo5rnYyXf2vl3l/FZMe1u8GSri14Qb+nv84hr8BHWxBJ2TD/ARwKTQaXMAsk0+tv4VDvpNP3ChELHU4PNS6UsgNtREMOal3dz/2Yss8L6ZboULROps1s5MXmyfytQPX9FKJRU8a+c4y8rdsYu/FM2nLnsDe7AlcVjOM14uuZNmSnwBwIDyMc6v+TenOWhJ89ibeEoNLQnsj43/1Z7Z/+3/Y8ZXPUPTL1zEIYwIGYVJSytj0w2/giLSR1fBCvIsrBoC3wmOYF9nP9Z5V7I7k0azfn9gspWETDcUX4E8qwttRgW9KA+6dQYJo3ITwTTl+QhpDR/h27l8pNCp5qmYWL1RP4u2GsUye1hPTd4melFZRwfw//pnqqZMpnz2LXUsvBSCpto6M/aWkl5eRVlGOIxwmPesQhhHBNDUed4BRI7Zx96vnwrhje6+tnTKUsNMB4Qhhp4NNU4v489Q/Mjt1N9e3PMCWmkRS2B+P1RVxktDaSkplJQ0loxn+3rvdps107DrmnJjp2IWjq9d/Xx9q7WUmkkSA0aqWSp3Gc0whIONYC9HjSpY9R2dmDvUlEzFCIZIaqkk7VIqhTTqt56QXPcwZ7GTo2qcxzEi/6l0NsDEwlLlv3MGFeVu4tng1P8q+gzuSf8gTeR/hZ+3fZpOviMSWvUzKe488tQNXV+eN7TMKCbsMCJmEXQaB2U4+lfse/66Zx+o2meuqt8RsDOvySAY6uRAd6kT56jA6q9HjEtAPZaLeaYJZJvqsYtY8MTJWixTClnpXMm4dJjfURlgZtDm9aKLjfiqtoz2vu4YKaZ3hZdv9+Yx5t46E2WHKZmVy2+qPdfXTFgNBYnMTOWVvkln+Hm05E9mSN4vLWl/m20k/o02n8M19t+E6sB6P6tsXVSK+Cl99G19hPqWfvIbE8ipmPPgjmphAumMX+/7vo4TSU8mtexCHKXfgxZnTGPzDv4gfJD7LJz0r+J3/fA4/zZbctJ2m/EW0Zs/E21HBwYUwhz93jWHdwMGFx+eXl+Xio2nPc0/DNfxqy6zeXRkRc85gkOI16yhas4723FyaRg6nceQIKmbNoHzeHIxQiLSKcjIOHGB06suUmE1895N38/jaiWh9fPtmy/hiPvezjzNr80E2TCnmxrNXsShpD1/Z9lUezvoYozr+GYe1FPGWt2M7e89fQntODsl1J5+wKt25j9mJv6IxMpZMxy7SnfsIeKNDQSoz2FvFPS1hHDzBDBzaJIRDJtcSp+XihK3MdJfxk9ZLod+F9+InsbGOoauXxbsY4iSSmvrucE5WAqaLZ6tm8GzVDIq8jVwzbAM3D3mBq7Mf5+nK6fy67hLyChqP+czuSfn86PeXM2F9JWUzsvj8/LfY3ZnLTw5eGqe1GJxiFrA+wpWIdg5FB1tR/gaMcQ3ocaCTi8Epk/qIOFCKKnc6LjNCYbAFgi1H/jW+66cGTBQahZqoYSJsd+VT50iRYPUA5YgESK9eT1r1BvZnjORTrq/gCHWQ3LQaAN3/nngSvWzkvx7FV5TPvs9cz6Squxix7Cl2fOkzNE+ZwKT/+y1tNwbiXUQxgNTqVB4LzuR6zyoucG3n1dBEAAwdJqVhEy25cwm503EFm6NB6oXH96wGMJWTz49eRUi7uG/H+BOmEf2TAlJqa0mprWXoytVEXC6aRg2ladhwGoePYP/ic0k+t423s0ZyoCqXNbvHnDSvLeOL2T6+kJ/mPsU5SXv40aqr+I/5UVRGGJev5aSfEwNXzq6d7Ft8LrXjJ5Bc91a3adOd+0h37jvyd9gbHXLGiPT982IYB2GkEShOj5MIn0haSaajk8m+CraEiuNdJCHEUSp8mfx25/ncu3cBnx3xJp8a8TaX5G/m1eAEHvfNoO2oCc53T8pn96Q8vpn8EkkqwMf23UJAy1M3vSn2AWuI9lb1pKHdKehIAJQTHH3ni+3IGEpbzhgSmw+RXL8PwwzHu0iih2mlKEvIIikSwK3DKKK9qzu1G6V1V6gajK6RrmscKbQbMn7xYKDQJDfts04oxAcoYMKdd+PPzWb7t26jYc50qi5ezLCHniL/jXdpu1F6rorYejM0lvGOKq52r+OgmcmuSAEAqQ0bacmZTWv2dLIq3+w2j8whw7g+6WvcW3UR9YGkbtOK/s0RCpFZWkpmaSmjeBN/SgofvXwFuXn1LPU+R9XZiuHvLj/hZw1MfpDzHEuSdvKbhvN5ePdCAtMycXc2o7SdWUHEQOPy+cg4UErtuPGMeOftU6oH4cRoAKCvDwkixJla4NlHpqOTiFZc7t0sAesuvvQsasdOIWf3FhKbZMhFEX9tYS+/3nMp9x9cyO2jX+ba4tWc697FU/5pPO+fTLBrOKgLPduY5S7jnx0L2OkriHOpB5+Ydh29ZNcHuscrI9qr+qhg9d5r74nZ8kzPqTWYQ+4kKidcRvnUq2jNH0/VhEvZu+BWqsZdROehSV0hy5NzFXecSXGP4WiL3b0CZ5p1b4V3N5+8F01/E8w4zclPlKLDmUCTK5lGVzIN7hR8Hg9lriwOuLIpdWWzz5XDPlfOMcHq+xbG7tHXU62z3XHVWd8ECmfG7mZMuNkTs7z6AxWJ3SN8jo7e7aVvuvtvMKFlbHwnNzJOcfFGKMyU79+Jq6mVqosXk7VqPSX3PgTA6JvW9kAJT843sm8/at0dV0vs9pF4Px2hcq3Pyeq0q7niH/6F1OpUbvW8TYbq4LwFW3CGO0hu2UlbxiQixsmP1X5vIbcXP0VIO/n73uNvqKxdX2JZgtmjD5xu4Y+jXTE8VnkilklieQ6Ot6oF7lP+TJq/gZtHP867OydQvs5D+ew5bPj4DfhU7jHp3CrMd7Nf5LLkrdzddDYPtM7Fu6ieQFIm7o7Gk+Ru3wlGIelR1Qtit8DMbTHLql84dMGx2y5v+zaCKSk0Dxl6SvlEunpY9+aQIKd/nD3eF6cui11mNjTtjO98T4722J1IG5dZB3jyZlXFbHmx1DrauhJV/Xf4MX9/yLuJynAaT3ZOZ4FnH9lGm+3lGb7YHauaJsS3Pe1uiy7fl57F3nMuY+sVN1I7fjpl886nJ87EjrpTPyeezCvrJlumuXDG1pgtr2HawGmb9Lb6qrQzzqMmkMZ3tl7L11quYVu4kI8nruYP6Q9xnnsHQx0NfDJxBeuDQ3ghMJnZJf13rpeOodbtZLvOmrc9ZnlZOaWoaSDspLTu5CfQcGUiJZtu7T6T7ED0ZcGMWB+ws96xF0Dz1ptUTp3OwVmLMA2DoSuWU7RuLW35BdSNG0/96DG05k/A1XEhuTt2krtjO8nV1ceFr8tvDKHy/JbL09U2hj5RGkeHdWNg7OhayzTb9hWDs/sDndHiZMUKG4/+GvE9YGZtsA4SthfbCyRe9vYXLdOoBnsnNztLdHRa19lQWgTTxgW6EbJeYtJBA69F0LptUpBIto3eLH7ruqjCikitdd1WjvjWoYpzrbedCluXMXWvws433zIudg3CxJ3Wx7SIjY7/gYIwERuHRzsNY9Pi2HKYOpRomSZhZKtlGq0VfruTq9xtM91RIh5oG3ny72zYc/Zu8jTesuCYv0tWPg1K4Qj4afrUPACaJpkYzTYys3FOpN76C9WZQfxjrM9RqtH6uOettHfR1DHMuvHjnmp9sdZxINXW8syE+F6AQde9ePfJ64m/OQGSu98ujhYnyka78bUNE0/4/nZvEU9P+wM3mCv5dM0nSB7RgsN4i72OiQRLRpMTOn5StNDKbLxnl3CD9xPcv/NsOkvT+eBe68/SrH9vdPeFMrD1sLy2eeywE7ROTPdZpgntsL5oiSTZqz91pZm20p0OFbG+QRPMtC6nmRam1MacP79Z9OCR30dG6kg3OwhPDPLHyTezxnc2dxs/YGfoNgq2LCd773rOG7GVry16muKURv62Zgl/XRXtjOL0GYSuTyNn9y6SK07+nWVvsS57+RJ7xxc7NxgSqq3z6hwRpuIi6+W56q3P+aFse+eIWAaejhNRGE3dt//cTTaWb2N3SKqE9vz38/J0lGEEAxyaOx1nsOJIK6nqG90HeNozo3MYpZSGSGzuvmxtJbE7ztsJWv9u2YXWiUx71x52vnU7x0YjpGjeEb+gtavFsHUj+duffOSYv3N0G7PNA0B0aJUQDprMJAI4CWonQRwEcOHHyTazCB/R9sjmliKyFlk/7bhp+zDLNAlV9sIbdjtAWQWtzfQwzQcKAZiYWMHE3Cp+XHYZLzdN5CNTNzAncIBfV1xEoo2RlPz59sqkbF5qNY/vuTaTimhcbSdvyIQiHg7NP4/qGZNwBEOMfGkZjmCQPVdchG5NJ3vHHnbfkmNrWSkHrPe/cAJQbd1W7hxib5u89t4UyzSxOsp/7+In4WLrdL/+x1WWaTon27gOsBn/6Bjaw21u3f33avfGWdMe6zabmWUdD9nqL+Q7/iuZ5Krgsynv8Pnkt4hoRavp5WfNF9Nsetm3udjW924nLhRJjN3+nrXWRlvo8la0jQ7iy7aOtUxz4+wVXH/uiZ/QO9oDr51lvUALPTMkSB/SkZXPriXn0ZGbR8aBUkYue41QaSKV9TNIqzvE6IpXGLXsdZqLh1M7YQKV06ZRMWsW3sZGcrdvp3DjBlw+6wslIYQQg5enwzoYL0Ss7Pfl8tVdH+VvE//Fd8wXuaN2KV6zmqRwKQ3uuWSHVqA+EI2qHzmXX+X+kZDp4J+bz4lTyUW8KK0ZY9ZSr5JoMJIBmO19m7vyr+Era/9Gysx8fr3wKZakvMO+hjw++9TnWF3+/tN5/pR0MAwSWk48NroYHIxIhNxdG6iePI/yWedSvPbNE97an5W9jxtL3uHnmz9EZWcmpiMaIHGE+++TQKJ7hjaZb+7HRYRGknASwUsIj2rBQxi3CuMmjNFVYSarCv4ZWchAmpTwE7kr6Iy4+Gv469RkTeLVllf4WO5q/lB5PhC7HsB9WXtONmWLFlI3fhwOn5+RLy9j+Ovv4u7oxHQ6OLRoDnsvX0L2jj3xLmqfpbRmpi6jXXnYqWQIit62NVTElxqvY5FnLx9O2sj97XNpNmUIvXgZsAHriNNNxfSzqC+ZjLujnXHPP0PW3t20NRawdfm1mKYDw4gwadGjpGZWkb1nD9l79hDyeKgfM5baCRMoW7SI+tGjmfbQgzhCMuaaEEIIIfqGVxsn8vuD5/Oloa+zLVDIf1tmkh18j7LE62lxTiA9HH1c1cRBh2ME6SXp3JBwP//Zfhb1fns92sXAMUQ3kUiIjcax46nmGLX8Xn2aj2e9QwfJfKXpTp59p4Tk8tJj0vkyoz3hvC1nPiSI6N8KNq/AdDipnTCLiMvNkDVvAO9fJ10+ZB0/m/0wbiPCmNRqPrbsizR3BayNkASsB6oJuoo0/LxujKVSpR95f7f/6ICbxk2Ec42dLHLsZYpZzmZt97G6vi3N0cmV2Rt5qPUyypMWo8wgv478hFdcl3Fp5hZeYW68i9ijOjMzKD3n7GigOhBg1AtvMOz15bg73+/4Z4QjjHrpTbZd/xHqJ44BmuJX4L5KaxbqvYyhFnR0fq3tqjDepRqEFMsDo1kesHjqUACQSTvXOtdQbmbyvDnFcqjlUzFgA9aNI8ZTP3oKCc31THvoQZzBaAOppX4IpukADExT01I/hNTM98fNcgUCFGzZTMGWzRyaPZvSxedSXzKavB29N06LEEIIIYSV35ZdwLSsMr6d8yIdppvn2xSeSB2HvNdSFzkLjYOAkcUIZxnPpF1CIOLkn1vPjXexRRzkmcc+BeLRIUrMOkaa9TimaZ7aPodfb/kYG6Zch29ePoUb3ySpvpLWghG0FozEl5mPioTxtEiAYbBTQNGGd3CEglRNXUDT0NEkNe0npW4nSU2l3DHjcUKmg99vu5ivT36eS8fv5/9ct2OEgjhCNobAEv3SSF1PACcNRHsiOnWEVPxMUYfIVu1drzay6MDdNSbWZKOCzZGBEbCemVJGghGmxjkWR7iFzKY3aCooxtSKs9J2D/iA9e5LLqJ52DCGvvseQ1atIWVP9QnTFa1Yz75LzuPQWXNJDr/Uy6Xs+9LwMYZamvCSSIiZuowdFKDVwHkSQQw85zh2U6RaKHK0sNYcRjXpMct7wAasM/dvoy2vmOahY9i3+HxKXn8VRyRMWvYhDCOCaWoMwyQt+9Bxn424XFROm8ahOXPxNjaSvWd3HNZACCGEEOLkTAy+UXUVfyh8hJ/mPYVXhXio7T/UuxfQ5hyDx6zlPB7j35nfxhkO84XXbpHe1YPUVkchKeEA8yOlmF2TChtoKlQ6X3v40+yqLwJMSt58hLJ5l1E5revGhtYkNlZRtH45GWV7cERiN5mz6L8UULB1FSnVB2kcMZ6mEaNpzxmLEfbzrapW/jT0B3x98vNUhXL5Q+qdGO1Bhq18AcOM3aRPom9ZbQznXHMX15rr6cBF0uFe904wNTSTSJ1OYb/OoZ5kmnUi5TojvoWOobeax/BU/TS+lf1LmnUGryUs4ZXMCzgUzOY35TbGSe/ncrdup3nYMFKqqnH5Tz6OshGJkL6/jJZhxSQf7MUC9hMteNlMEVOoAOAtNVqC1aLPeycymiGqkUM6g2rOfCLMow3YgLUjEmbE8uepnlhH1ZQF+DKzGP/c06RSxaRFj9JSP4S07EPH9K4OeTxUzphJxcyZhL1e0ssOUPLaazjC0jgXQgghRN/j025uq/wovy54jB/kPY/XCHF/czMEXuDC5G38JO9pasKpfP6FL3CgNTfexRVx4lNu3nKWMD1STqr20aQS2e3Io0N5uoLVUYY2GbbyefzpOfhTs0ipLsUV8OFuj++EyqJvSq6vIrm+ivS6ZXSmD6UtZyx/zvwW3tZELvG8yM/bvgH7dzC0cj2JjfGfNFf0nGqVxuvGOAp1C4kEaSWBVuVlc2AIjSQRtjVdb/8VwcHX9l8DwM+zvw0p36YskMXHd3yKimDGcZMcDzT5m7dQPncOpYvPIWvP3m7TJlfVUj1jMuYhJ4aWOMsxlGItw9hLDgpoUjJ2suj76knh9+ElPZL3gA1YQ9fd/22rSS+rYfdFl7HxYzcw7vlnSKPimEB10JtI1dwZVE6fTsTjIXPvXoauXEFqVdXJMxdCCCGE6AMC2sWXK6/l/7N31+FxXGfDh39nFqUVk2UZZGaKMU4cZuY2adOmKaUpM33lvn3Lb7lNmrRJ2qShJmkYGgY7ppiZJBnEzAtzvj9GZkszlkZaafe5r0uXbO3ZmTOzz86c88yZMz8vfJyv579EigqjUXw+7zXeax/FFw+8j1pJVie9mPKwylsMWkMPI7YMbZJaX0lqfeUA1k4MZUqbhOpLCNWXYBov80D2FP6lJxFo3U9OpzyUOFlUqQyq1NF38VSRPHf1HExaHwhnkelt588HzmZ/OHFGkffE0Jqxr7/BpuuvpWLWTMaVvdlt2bTyKjAMIsFsAu3VA1jLIUIpGpBEtRCQ4Anrg3L37Gb2ww+w+Yqr2Xjt+xj3xqsM37COzrQ09s1dQOWMWZheL/nbtjHq3WWkVcuBUwghhBBDRxQPX6+4jh/pp/hc3usAPNs0g+9XXUFYJ0VzTzgltxeLfmSYMdJrd8S7GkLERQwPv9h3cbyrERd523eQsW8/JWcsofjFZXgikROWC1VUARBOyZWEtRCiR0nTg0mtr2POQw+w7ZLL2HXuBew69wJUzJpHLX/bFkYvfZfUennyuRBCCCGGphgG36m8imebZxJQEV5rnQwuPqlbCCEEBIwIP5z0BGubRvPQgVPjXR0xBGX6W7l1+us8sn0xB1pz4l0dVyhg3Guvs/ZDH6T0nMWMe+nEo6xDVbWoWIxIMHdgK3gCpuEjHMwn2HZgQNY3LNDIrcVvcm/pGVR0Zg3IOoUYyk4qYa0jBtEDPczAZDroFNUEHK3LcFCmdYR9GQBtHJwzK0rx8qfwty6mLbuAQGsTBVtXEWhtom0ktI309bicWSNLHa1vXeU4ZxVzYOuqMbZldIaDB5gYzuYe9LQ52fP9J5xhH0Od+c7mwFO1ftsyptd+v3zkzLccre+pP5xtW6ZhurPEwfiH2m3L1M62v1Vo5MhaR+urWjHctkyas/CnYXp85yj0NdrHcGe+/XemtWjg59rrKLTfd8Eq++0z2p19j2Mh+/3gaXW2H4xRbbZl2srT7JcTiW9yrfRyp6dFF+PcwSab6faflVHt7Pxqptkvq73I0aKY+sujnwLfMG40tVMmMPq1pfjarYfuVF5of7JOcfh8joiDO4ujaf07166OGHRWdt8W8mSF7RfS4ux75Wm0L9eedfy57pWOqcf9LTZ88M0fu2CBs1GYOxvsO7VtIxzs95iz44vR3H/Hf21ANNRzjKqwg3p2OjvOf/XZm+0LTXIzNtxrR2Zst1+Wk76ASnE2R2qs+MSjAY9aVq2z42x/8gaiZE/seZBNwxb774yK2sdZ7QJn+86b1Wm/vlPsywCwK8u2iHbwFVEOTwWeVvs4W/OB3x6xck1Kew2+aAc3jljBD+a8RNifAUox8/nP2i4rr6jRtkztvizbMn3i1ejc7o+ZEez7UADfe+EG2zJOPocJD9q3IQGMm+w/q3D2wJ7rjAZn7cYv3PKfQ/8O6AiXsYF8Wrhp5ts8xWxaVJCfv3ilo2WZPvud2t99+nCW6qbNXEFK0252X3Q2I95djb/t+D6tQpNaXUs4NQftYFuaJrrXrpv4rXWH/h0JpbL6x1+jacJ4Jtz7COMefQaAr25cedz7fDpKBM+hO5Q++czHHa1v1w13Hv6PGUG17EeZET4xbik6bQQYPiY8cpujZYXsT1Fkvxm0LeO0r1641FExSpwVO57Tg3QPzKCzbXHyPd3VMNJ+QQ7bkbFU+3qZ2Q4+UMBTaX88/tw3/33c35TWRz2w84fPXe9ofcFRLbZlHti4wNGy8PT9M45vdjIOlNYUbVjKhDf/w6jVrxJolXnVhBBCiL6qmzSOlV+9jR3XX8qbP/sWJecvwfQk9kOWhBBCJBGtSWmvxRftoD2YTdiXSrCziUBngzU3vHCNBkxP4qUqDiars2llKePwEeNK1pGmO+JdNdfkVLxFNBhgzwVndlsmVFFFJBC/EdYHk9XN44rJWbuJnR95H7tvuPyEZfNjzZwZ3smc6D6U7uUFkVgE1bIPzBhmSj6YMVTLfjCdJS2FOBlFuoGbzBUsNPeghvi5KfHOAkIMAIXGi4OR7S6pmDmNlbfdQunpCwmnpAzYeoUQwom6SeNY/cWPEaxrYP6v7iRj7362fuBq3v6fr9IwcgJDu6kkhBAi6WlNSnsdvmg77cEszPU+zLu9hDemEAi3EOyowzOAfYNEphVsuOk63v7a52jPcngL1hBwZLL6JaazQY3kGWYdSlqPCCbG9KT+jhqKVq2j7KzFR31+DW2j2F19Jg1to0irqCYSyEKrgR/YcGSyevb//p553/0Fha8tPWHSOj/WzKzofjqUj3yzlTmR/Rgnm7Q+mKzWpjWqekMAfW8arI6iWvZTGGhwb+NE0ivSDZxrbiWKh6m6grPNbXj00D03ScJaiF642VjGNz3PD0jSunFkERvffzVNI4rYcdmFvPWtL1AzaXy/r1cIIZxoz848lKxe+Is7yNu8g/m/+ivzfnM3RiTGniVXULbwgnhXUwghhOg1f7gJX7SNjkAG5no/qe+vJvDLJnwf6iC8MRV/pI1vj3ku3tVMCHsXL6Ry1jTCaSE23HRtvKvjmgvYQi4tvMR09ipr3upalcYzzCJAlH/OvxPDzSnn4mjCsy+jUWy9/nK0UjS0jWLlno+yo/J8Vu75KNGdflAGEf/AX5DY8LXbaZo4ltn/+3sKVqxFmZqZ/3cnw95czs6PvI/XWy8BIM3sYFZ0P80qyLu+MWz2FpKnW5karbBZwxG0RrV2JatDI2CtRt2wH/WrJvgosDrCPXPvBhnaIVyQrts519xKE0GeNGazQo1hNPWcaQ7dByFLwlqIXlivR/KUOZvYAHyFAs0t+Fvb0F7rCnTG/nKCjTKVjRBicPB2hgFN+r5yAk3NgDUtd/6GrRSutOYK9Lc2x6+CQgghRB+Zhg8NeKOdeJZ1QESjYkBE41nWiQa2tNk/E0bYO9iW0B7PoX8ngjpSMYBhNB01hUw+zfiJsaOlEDNBHpScUtfApGdeomr2NDZ86HpqW8dhag/gwdRe9mYswtdejTdsP6e729JK94Fh0DB98qE0cTgjnZbiERgdnRR5y6y/KS8RvAR1FD8x0k1r2pZWdZLPMjD8KEyIdcLS9qOOHWolbG8pRB6QLdzQiZc2/IQIk0Ubhdr6ftUq+2efDVYn9dBFIYRlnR49YOsKNjax4C/30J6dhb+tjbTKagA6C4fugUcIkTh8be0Uv/w2uy89l+aiYaQfqARg71mL2HnNReTs2UThpnfjXEshhBCi96K+VDq0JthRB6eY4FNoNPjAmB+jPSWXf1fNj3c1E0LBxi3k7NxN/ZhiJj/zUryr45qljMeLyTyshOgqXcwUKjiLHZSSw+fW30wiJS7HvPoOptfLjisuJPf67Rh/jmFqBQFFsLiR/N2PYsRhqoKJ9zxMLBig5PrLACh+4nlW/e83aR+Wz9wf/JpJD24CrIT1at8o5kdKWRLeDUCJJ4cST47zlSmFDg2H1nKM9irM+VmHjh3KB3pxkK9svMntTRRJKqx8vGhM5yJzExebmwFYrsaw1Ri6F1MlYS3EEJDS0EhKw8BfgRZCCCfGvPgmpecvYdeVFzDnjvupnDuDTR+6jvx1Wxix9eUE6n4JIYRIVhG/NVgkOKsOfY8BK0At0LSdnk/MG4xz7RKHAub97YF4V8N9SvGmngjAPMqYQgUhwpSSw3+ZRtj0xbmC7hv30hsA7Lj+QnyjWjG3eUgprufUF+6g5Kb4fGcUMOUv/wCg5PrLKLn+MoyOTub+4NfkbNh6VNlWI8Aa3yjGxOpoVX52efJAnWSrVhldSesKjGkN6Hs9qOUx9OIgeslIoo/KA8qFe1pVgBeM6eTTQgzFPnUSF1gGIUlYCyGEEKJP/K1th0ZZl51zGltvvILM3WXM/ss/qT07P97VEwlmmKeJ80NbeKhpwYBMzSWEEAcdTFqnzKlDz4HW0DBMjz++lRJDxxFJ66lUsJds/ss0Yipxz2WHktZXXEjK+DpO/fUd+FvagPhd5DmYtPZ0dNAyeiRjHn/uuGT1QU1GCuuNEX1cYVfSuq0cNbsVPT+ETh1+8slvIRxoUwFKOcmpawYpSVgLIYQQos/GvPgmuy8/n80fupbQgUrm/e7veMPheFdLJBzNd/OeZXHqHjq0j8ea58a7QkKIJBPxh4j4UgENCZxoFP2kK2n9FhNRaMwkiKFxL73BmFffBsCIDvw0ICeigEn3PDKAK1To1OGHH68oyWohbLl7dDQcPN3UdO+LGc527ym6gQb7MtufnuDa+tzkbbK/jSSWmhhPHAZI3+Ve2BpR+3i8980zXFtf1ib36p67rtW2TNtj7s1X1FLs2qKGhHDe4GhM9Uawyr04i4UGdj+YPnlKdm+ZWVH3lpVy8ucMf2sbp/zxXka+8S7zf/1X/K1tjt8bcHHGI29LfDsAZoODkXb5ne6trzTVtWUNtJUrJ570e05P2cXi1D00xwLcnv0Gacp6CFJuvoOHEXsS5/jicdD2ExbvXvdG8alc9767Q4G3wb2xTS2tAzvaS7t4KjjlX188/o9K9VuyOndkQ78s1ymd697FZiefw86bhu55rNeUQit1VLL6Gxc95dri49333/6J46chMKKxo5LVk+6qG8gqOfarGQtsy/z18rt7t3ClDv902fm+O3u3rBOIpNmXcTMfEW9GxwBvi4vtSKN+YKcA+v6l/3ZtWb6Ae31OO66OsPa02gdMLOTuwdNJ0jqc6eBM6STZDqxbPc5ROTtmhrMP2Z9u32DorLdviPtrnH3Ukax+TE5pUOGeP4uIg+cIdhQ6i6Gc9fafe/35Hdh1+XRVgH+8eqb9Cqfb1yt7o0H2Rvvvya4bU2zLpO6zX45a0kBjm/2y/A22RWgbadIw3b6cmR2xL9RLRieESnre7tYx9p+DYROHYMVqLOjOScnT5uxkGnVwfGwda79/jaCz73Fok/2xw+n3zUnSLLXBfr93FMS3gR2odvZZdea7WM9q+0785Nl7bcvsWDfKUUPKX2l/PohmONu+uiVFR/3fRx1Fu5bSPj1EO9YBvcnBadMMurc/i2cccFx2T29WoMGI2MSyg8/U0ar8zo5BsXL74/xgpCKKVUsn2Za76zqrM6e0ZmG4hDZ8bEspYF54L/8Yfw+7fPnc/s9P2d78GM5yFmd2bZW+MCKQUtHz8jsdTDcYSzUHvqPmEqeJxIZp9ucyJwMPQqUG1Nif73K227fN915gOJqT30kbFHp3DIp2eqnfYRMkXvtjh3ZSJjfsaHvNCmfHoCbcOVYpF689xdLsjwu+eg/z7vuSbbnMavv1RYfZf2+LMpoomNxivzCg1FGpo3mbFLmvdn/ErFloogP2O9notI+OrAn1tmUiL+dSvtg+06ai7sQ1wCnzd9mWWb1xrG2Z0eOrHK3v5y9eaVvG22I4Ss5EHcSsVmA6bEP0xsjMOn522b+OWKE+Kgn7jWc/cMKkdbzt+Ols2zKmV/OJ52f1WOb0eds4beGJpxA50mlfuc22TOtwAwcpEJrHOejjOugCOj0Hl5/tsG3+oLNiR1cCiNlUxGFy2K22kLJr2wPapwc8ae3kHPXTf91gWyacbTo6eUZ32x+LgxOb8Kba5ynbXZiWZGi2dIUQQgghRFIZEWsgpCPs9ObTZKRQ7slgVKyeFFOmnhFCCCHiwdAmp8d2MSHmLHkvhBBOScJaCCGEEEIMal4dY2y0ljojhRrDGou025uHiWJ8tCbOtRNCCCGSk0ZhojjF3Me4mIPbDIQQwiFJWAshhBBCiEEtqCP4MNEojK5HFnm0iYlButkR59oJIYQQyUkrxXrPSExgtLafAkYIIZyShLUQQgghhBjUWowgW70F5JptzIiUEzI7mRu25nZf7x8R59oJIYQQycmjTRZHdxPDYLVndLyrI4RIIK4+dFEIIYQQQoj+cMCbBcCUaBV54VbCeFjjH0mr4c5DLoUQQghx8ppUkI1GEc3K/gG3QgjhlCSshRBCCCHEkHDAm0VMGQR0lFojJMlqIYQQIo5iymCFd2y8qyGESECSsBZCCCGEEENGpScj3lUQQgghhBBC9CNX57COhUzbMp7WQTpttqkGdHVGk3vXCgLZ9g8bCudFXVtfvAUr3Iuh7Jftb1tSBZ2ura9+hv13xKm2kfbL0m9nuba+1H2D9LvbT7Rfu7asWKp7n7sTZofHtWUd+32L+DKoLL6KhoJFuLeHjlhfVXzjrDN/YD8rN02cvde1ZXmbBvZzMDrcW1/pxiLXliX6l/a5dxT5y4fusC3jb0ic85inbehui+qPk0cPWovdO66P+u/QPUf0hqr1x7sKg0IkOzag6zvQFN+Lcnkr3Du+NOzMti3jO7+2V8uen72bx0/7LRcO23DobyrqXp9+3ow9tmXKdhW4tr5omnvHl4E+zh7r55f9K74V6APDQQy9s3qya+sLlbv3uZsOuoDxjo2hTEUGNmfoJn+9e8f1jh0Dd446uaypR2NmdJ/4NJq8tklrnRN2tCpV52IDyRic30pHSev99vshkmnaXnlQprOkmfb2375SMfC19vwlb5tkHx9Ok/0NE+0PKGaKCVU9305segAHB39Pu/36hs+pgGn2y6rfPMy2jFbQOqrnz1RpoMT+gJJqXyXCWeBtsT/QRfE5WFrvmCma5pmRHsuk7rJff8E5+23LlG0a7lrS2vRpzEz7zs6ICdW2Zcq32DeMzRQT3Wb/PQk02hYh7y9LAdDAgUvOpewzN2MG/LRlTiDz5SrG/f1BFLDrt6faLqujwH5/zpu/075SXey7Eb0QU3Tm2NfTSYOwYIWzRk17vn25zun2n2fJjkJwELPhbPtzgeGwbx5Jta+7k/OK2+eefk1aezRmVg9toQb7z8pJ/IDzz8EJFXbwWTmIHzO752PwQUa9/bHY1+is8fyJx26zLaN9GjJ7jm3TYZxFc/ovOaVM8Lb1XMbJBWlfo4HhYP+Fs+yX5aTzqh320Zwsq2ByjaNlVZTk2hdyMB7DX28QcdC32nuB/f4MlRiESuyXVTer/xLbyrS/yGcGXUx8OUhaZ4xvsC3TsjHH0frMFPu6j5+1z7bMju0OzwMOBi15mw1H56mWMfZlrh213bbMv9fOpbE2zbZcb0VToW5293U1OpWjC9dRBwOijGaPbdLazI7AKfYDhHZf8PfD/wk3odqqAM2f592LTimAQCYTHvqUo890w6sTbctEM+z72AWTawhH3RuI5ihpHXNwQDb6NzG5ryWbr73zvu5X76At5JSTc/eI15ydpMqvcTAQrSbgKGm9bPkU+2UtclApANxrm9txOvivbXL/DXgMhsJMnVfSY5kta4tdW5+Zbr/zVIt941xFlaPvn5PzhdPv5/RpZbZltraNsS3jtK/lNP/RXppuW8Y7wqbB64BMCSKEEKJHndlZbPnqp6hZPI/sNRuZ9su/UHLT1ZTcfC0A4//+YJxrKIQQQgghEp7WqI46VGcd2puCTh2GaqvCaK/C1DGsIRZDdxSkEEKIwyRhLYQQoluVZ57K1i99glgwyKQ/3sOoJ56n0ZxI8DfV5B1YQclt13aV3CPdAyGEEEKIk5RGBy0EkESrDW2i2ipRkRa0P8MaVb26A700CKeAMbOW7099gh9tuRrt7synQggh4kAS1kIIIU5IA/svv4CU8iqm//QPhPYeoEFP4j2+h6m9GA9FyWMFDYsmk6XKQA/sHI9CCCGEEEOZgclpnp2siI2lgVC8qzO46RhE2zGDuRDIhtUdqBv2Q0SDT6HvT+PU0bsIecK0xOyfUySEEGJwk4S1EEKIE1LAzB//Bk9bO0bMSkbXMw0TL+DBBDIf3snoJ56l5Bdz41lVIYQQQoghx8Tgv7Hp/fIg64Rj+NAZxaC65ppd2g4RjYqBRqNX+7n+wOdolWS1EEIkBLlXRgghRLd8zS2HktUA2WzGIArEMIiSrTfhCTt7mK4QQgghhDiaRiHTgTikjngw2mkp1shqD+BTcFqqJKuFECKByAhrIYQQjmWp7czVP6KeaWSzmSxl/7R7IYQQQgghXDU/Bf3oCGuk9WkpMD8Fdsa7UkIIIdwiCWshhBAnJUttJwtJVAshhBBCiDia35WoFkIIkXCU1s5nzFJKVQOl/VcdMYQUa63zT+YNEj/iGBJDoq8khkRfSQyJvpD4EX0lMST6SmJI9MVJxw9IDImjyDFI9FW3MXRSCWshhBBCCCGEEEIIIYQQor/IQxeFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCWgghhBBCCCGEEEIIIcSgIAlrIYQQQgghhBBCCCGEEIOCJKyFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCWgghhBBCCCGEEEIIIcSgIAlrIYQQQgghhBBCCCGEEIOCJKyFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCWgghhBBCCCGEEEIIIcSgIAlrIYQQQgghhBBCCCGEEIOCJKyFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCWgghhBBCCCGEEEIIIcSgIAlrIYQQQgghhBBCCCGEEIOCJKyFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCWgghhBBCCCGEEEIIIcSgIAlrIYQQQgghhBBCCCGEEIOCJKyFEEIIIYQQQgghhBBCDAqSsBZCCCGEEEIIIYQQQggxKEjCuhtKqdeVUvqYv52tlNJKqR/EqVpiCJEYEn0h8SP6SmJI9JXEkOgriSHRFxI/oq8khkRfSQyJvpIY6r0hm7BWSk1RSv1BKbVRKdWolAorpQ4opZ5VSn1MKRWIdx1PRCl1d1dgaqXUhG7KeJRSX1JKrVdKtSul6pRSzymlThvo+iayRI0hpdRUpdQPlVJPKqXKjijrjUd9E1Uixo+yXNy1XWuVUvVKqQ6l1Dal1G+VUsPiVe9ElIgx1PX61Uqph5VSW7tiqF0ptUMp9aBSan486pyoEjWGTlA+TylV3lX+7YGoY7JI1BhSSv3giNdP9HNxPOqdaBI1fo4oV6iU+k1XO6i965z2nlLqZwNZ30SWqDFkc/w5+POheNQ90SRqDHWVGauUuqOrTd2mlKpUSi1TSn1SKeUf6DonqgSPoblKqUe7YiesrPzQn9UQ6dcPyQSWUup7wPexEu7LgPuAFmAYcDZwN3A7MKg6xkqpK4CPYdU1rZsyCngIuB7YBvwRyAHeD7yplLpOa/3kwNQ4cSVyDAEXAd8DYsAOoAMIDkgFk0QCx08AeB4IA28CLwMe4FzgC8CNSqkztNY7BqbGiSuBYwjgKmABsBI4gBVPE4BrgPcrpT6ptb57AKqb0BI8ho5150mUFQ4lSQzdB5Sc4O87Xa5W0kn0+FFKnQ48A6QCzwFPAClY57MbgW/2e2UTXILH0A+7+Xs68GUgCvzX/doll0SOIaXUAuA1rOPOC8CTQAZwBVa76Dql1MVaa32i9wtnEjyGLgcex8r7Pg1sB6YAnwKuUEqdrrUuG5ga986QS1grpb6NdQLYC9ygtV5+gjKXA18Z6Lr1RCmVD9wFPAwUAmd1U/RGrGT1UuA8rXVH1/vvAN4G7lJKvaq1bu7/WiemJIih57EOtuu11u1KqRKgeEAqmQQSPH5iwHeAP2ut6494rwH8GbgN+D+shpLopQSPIYDbD567jnn/TKwk9q+UUv/QWof7rbIJLgli6Mj3fBi4Fvg01nFIuCCJYuherfXr/V2vZJPo8aOUKsRKDjUCi7TW24953dfPVU14iR5DWusfdPP+27r++bTWuqI/6pgsEj2GgB8AIeAjWuv7jnj/V4EVwIXAGViDjEQvJHIMKaWCWMl2H3Cd1vrxI167CfgX1uDYKweizr01pKYEUUqNwfriRoBLTxRQAFrrZ4DjbvVTSi1SSv1bKVXRNRx+r1LqTqVUUX/Wu8tfu35/xqbc7V2/v3Nkh19rvRIrIPOxEtqiF5IhhrTW27TWy7XW7QNQp6SS6PGjtY5orX9yZLK66+8m8KOu/57dP9VLDokeQwAnSlZ3/X0DsAXIxDqXiV5Ihhg6SCk1Gvg98Desi7HCBckUQ8J9SRI/3wZygU8dm6wGq73kdsWSSZLEUHc+2fX7ThfqkrSSJIbGdf1+6sg/aq1bgVe6/ivt6V5Kghg6DWuU+Kojk9UAWusHgXXA5UqpQT2wcaiNsL4V6wrBQ1rrjT0V1Fp3Hvl/pdRHsT7YTqwv/V5gIvBxrOHwp/bXcHil1EeAq4Grtda1SqnuygWxAqsNeOsERZ4HPoR1e/49/VHXJJDQMST6XTLHz8HOWdSlaiWrpI0hpdQkYDJQA5S7Wb8kkxQxpKwC92KNcPwy1vRowh1JEUNdlihr7nwP1tQgr2ita/qjfkkkGeLnJqAeeFEpNQ04D2tqkF3AC1rrlv6oYxJJhhg60fvnAXOxjkUvuVy9ZJMMMbQJa/qGy4D7j1hGKlY+qA3rrmrRO4keQ4Vdv3d38/puYDaDPLc41BLWS7p+v9JjqWN0dZLvwDo5nKW13n/Ea+dhnTB+hzW/pqu6rlj8DrjfwdzT47Ea1Lu11idKCh2cN3aSi1VMNokeQ6J/JXP8fLTr9wt9r1VSS5oYUkqdj7W9fmAsh6eS+XjXqH3RO8kSQ1/EuqPjQq11k1JKEtbuSZYYAvjxMf/vVEr9EviezPvZawkdP0qpsUAe1hRWv8F6hseRapVSH9ZaP+d2PZNIQsdQDw6Orr5Ljj99lgwx9B2swYz3KqXeB2zGmsP6cqw83vVa6wNu1zOJJHoMHbw4P7ab1w+O4J/sRt36y5CaEgQY3vV730m+73asqydfODKgALTWr2BdFblCKZXe9yoepqx5Xw9O2v55B2/J7Prd2M3rB/+e1beaJbVEjyHRv5IyfpT10I/vA81YjSfRe8kUQ+djxc23sJ7P0AxcIxfe+izhY6hrROP/AndorV92sz4CSIIYwrrV9aNYHbIUrGd5fAJowDqP/cTNOiaZRI+fgq7fc7ESjJ/t+lsR8HWs/tpjSqmpbtYzySR6DJ1oGWlYI/ejwN/dq13SSvgY0lpvxXqI+VKsQR/fwKp/IdaI63fdrGMSSvQYegerzbNAKXXVMct6H9boaoBsF6vpuqE2wrq3Fnf9Pqsr8XKsAqyRzZOA1S6u90tYE6Bfpo+ZE1YMORJDoi+GbPx0XUV+GuvEfKPWepeL9RPODbkY0lp/E/imUirUVa+vAs8rpb6rtZZk0cAbEjGkrIeZ/RNr2pivu1gP0XdDIoYAtNZPHPOnMuBupdR7WJ38ryql/k+mBxlQQyV+Dg7o8gA/0lr/6YjXfqmsBzJ+GesukNsQA2moxNCJ3ASkA49redhiPA2ZGFJKnQL8B6jCerjiWqyBizcD/wNcrZRaoLXubrCj6B9DIoa01q1KqS9gTa/3uFLqKawZG6ZgjdJfC8wBBvVdr0MtYV0OTAVGnOT7crt+f82mXNpJ16gbXUmenwD3nMQtYwcPNpndvH7w7w19qFqyS/QYEv0rqeKnaxmvYc0de6PW+imbtwh7SRVDcOjhMGuAD3ZN6/BjpdRL2nqYsDh5iR5D3wJOAc6ReWL7TaLHULe01u8ppVYAp2N1Op/u6zKTUKLHT8MR/z72wsfBv30ZWNi32iW1RI+hEzk4HchfeywlnEroGFJKeYFHsB6quOiIixwtwM+UUsOwLpp9CevBgeLkJXQMAWit/6GU2os1Ov9s4FJgC/ARrMT6HKwLIoPWUJsS5O2u3+ed5PsOJYK11qqHnzdcrOs0IADcqpTSR/5gXRkB2NH1t6u7/r8LiAHjug5Sx5rY9fu4p1ULxxI9hkT/Spr46brV9XWseRxv0Fo/5mLdklnSxFA3XgDUEe8XJy/RY2guVoy8fkz5PV2vn971twYX65lsEj2G7FR3/Q65WM9kkujxs4vDD5huOMEyD45sS3Gxnskm0WPoKEqpOcB8rPOYPGzRHYkeQ1OACcCWbkbkv9b1e56L9Uw2iR5DAGitX9NaX6y1ztZaB7TWc7TW/wBmdRUZ1AOIhtoI63uwRt5cp5SaprXe3F1BpVRAH36a57tYX+YzgGf7v5qANQn737p57TKsuYceBZq6yqK17lBKLcWq5xkcPhAddEnX71ddrmsySegYEv0uKeJHKTUTeBnrro5rtdYDVedkkBQx1IODoxhO9GBh4Uyix9B/OfygmCOlAe8HKoFngDYX65lsEj2GutU15czcrv/u7nv1klJCx4/WOqyUegs4B5iBdcw50oyu33sQvZXQMXQCB6eOuVtrediiSxI9hgJdv/O6eV9+1+9w36uXtBI9hrqllMrCmhe9GqvdPXhprYfUD/Bt4OBIm/ndlLkYePWI/0/B+jJvByadoLwfOOOYv71u7Z6j/nZ217p/0MdteL1rORNO8NpNXa+9AwSP+PsCoBNryH5GvD+HofyT6DF0grIlXWW98d73ifCT6PGDdWtQDVYy6KJ47+9E/EnkGMJqYM/u5j0LsBpSUWBKvD+HofyTyDHUQ/kxXeXfjvf+T4SfRI4hrHliJ3dTvz91vWcLYMT7cxiqP4kcP12vXcPh/ljoiL9nARu7XvtwvD+HofyT6DF0RJkQ1ojMCFAY7/2eSD+JHENY7en6rtc+fsxrWV3nMA18Ot6fw1D+SeQY6not/QR/SwWe7HrPp+L9Gdj9DLUR1mit/7druozvAyu7RiSvwprPZxhwJtbUGauOeM9WpdRHsZ7Iu0kp9QJWgPmA0VhXR6qxgi/eHgKuBa4H1iilnsaaJ+f9WJO3f0Jr3RTH+g15iR5DSqk84FdH/Ongldm/dd02AvAzbT15WJykRI4fpVQ28ArWnNWvAIuVUotPUPS3WuuGgaxbIknkGMK6RXqtUmo9Vqd+H1bDaCpwbleZr8nxp28SPIbEAEjwGMoFtiilVmF16suxRqOdA4zFuih7k9Z6UD9oaDBL8PhBa/2EUuoe4FZgg1Lqeax+2OVYdwo9BtwfxyoOeYkeQ0e4EchAHrboukSOIa11p1Lqi1ijgO9SSt2I9TyYbOBKrHPau3Q/6lY4kMgx1OUWpdRXsJLa5VjtoyuA4cDvtNZ3xLFuzsQ7Y96HKwlTgT9gdYibsK5ylAPPAx8DAid4z0ysp2SWYo1Wrut6/53AuceUfZ04XY3FmqrlS8AGoB3r6tpzwGnx3u+J9JOoMcThUWg9/Zwd7/0/1H8SMX4cxo4GxsR7/yfCT4LGkA/4DtbtZfuADqzz2E7gH1gPjon7vk+Un0SMoR7KHzw+yQhriaEeYwgrOfR7rM58Rdc2tQDrgJ8BBfHe74nyk4jxc8TrCvg41vyerVh3nq0CPoOMzpcYchBDXWWWd5WRuxYlhk46hrASpo93bU+k61y2GvgmR9yNLz8SQyeKIeBUrDxiedc21XT9/5J473OnP6prQ4QQQgghhBBCCCGEEEKIuDLiXQEhhBBCCCGEEEIIIYQQAiRhLYQQQgghhBBCCCGEEGKQkIS1EEIIIYQQQgghhBBCiEHBezKFPekh7c3P6vZ1peyXkeoPO1pXR13Qtkwsxdn82552+4oZmRHbMtEWn7P12S8KsqOOlhXtsP+IAvX2DznvzHJ2bcLf7GyftjTur9Fa5zsq3MWTEdK+gqwey+iwfT3TQh2O1tfSah9DA87BdwSwps0fSE7q5XKdwnv39S6GejgGOaVjDjbYdPhhGQ52jNNluUTZHxIsDqqufQ4/eAf71FG9TmJXde7vRQylh7Q3L7v7Ag73XYaD41BzZ8DRsnRkYK8dhxzUva3J4fHTweelA/Y7VbU72wf6pFot9npzHPKmhrQvM6fb100HTQXlcxZoTs6JTr8zhoPml/Y4KBNwdkzwNjuoWJaztpDZbP/BOzm+aIdfNdPvrFyv4icj1bYtZEacfBAns9YE5nXywTv7kqiIfTmnMeRUr9pCaSHtzen+GOSU4Y/ZljFNhxvspF01wDGr7DcPcHhecVh3w0Ef0ExxELNR54HWq+NQMKT96d3HUCzF2XI87fZlnJwTnZ7bHX2mDs+JTr7Ljs7VHQ7bLw4O6942R4si5qCJpr3OgjZcevJ9euhqT+f20J52UaDMPtA6RzsMWgd9Mq+DuI46XJ2jtonDz8pJ3T2dDtbn8Dtipjprq4b3HOhdfyy/5/gJOcgbtrY562sJwGHfw9H5x2muwelxqKT749BJdf28+VmM/N/PdPu6x2t/Fpk3cq+jdW1+cKptmcYZzjo6mZvsNzPtsgrbMrVLCx2tL7TPvoznumpHy6remWtbZvyj9kem3dc4Sz6MfNVZ6+6tp79e6qjgEXwFWYz5xW09lgnvC9kuZ/GirY7Wt2z5FEflBpLpsKNvdA5sgtN0kJQ0HHTkTsaeL3z15GMoP4uRP729xzKGx35bOuvtvw+eNmcN0Fia/XfG0+Kgleoiw2Hyz0mjpnO4s+Osp9l+G72t9jEUc5goAtj1zS+fdAx587IZ/qPPdl+g3dlndf7cTbZl3iwd72hZ0f2pjsq5ZcGCHbZl1r482dGynHxeeox9D8y31dk+CGc7bSE506vjUGYOYz/25W5f7yiwr6O3yFmvNFZmf0502tFJ2W9/XIik2y8nMsbZReOcN+2Ps8Y1ztpCba/b94P8zfbLidjvTgBai53FWcnnehE/BVmM/dUneyzTVp5muxy3z8l2TIenMcNhktA1+fYnMkcXAABvhf0BzQzG/xjkzclhxFe/2Od1pxTbf2namh1eeG2yz0oa0YGNWW+Ls7ZQONs+aA0nFw+BlAr7bWyf5SAbVu08CdObGPKn5zDl2u7PYw3TncV51ib7/dLmoPscznW2Pl+D/fqcXnCMOUjGGYX2n5Wxw9mJJZxlv76Clc6+I3XT7MtF852MoIPSj37jpOMHwJubTeH3Pt/t68rBRSztZNAPMPn2tbZltn13jqNleVrtzwfZG+zjrH6ms5h10p8MFzj7rJz0J9NK7Nfn9MJr23wHxypg903/7+TPY/nZFP24+7wiwPyxZbbLWb1qwsmuOmmpYc7a77Fa+/OPx+GFulies8HKpbd8q9sYkilBhBBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwjoBaWDdjdfRnp0V76oIIYQQQgghhBBC9ErM52PvFeejj3lomgb2Xn4+pnL5ISdCiEFBEtYJqC03h7rxYyk9bVG8qyKEEEIIIYQQQgjRK5VnL2br5z7K1s/eeihprYFtt3+YrZ//KK3p0+NbQSFEv5BLUQkoVFvHGb/6PZ6ws0nOhRBCCCGEEEIIIQab4f99k9ZRwym58SoApvzxHrZ96kPsveZiRj/2HHrOxjjXUAjRHyRhnaC8nZKsFkIIIYQQQgghxNClgAl/fxiAkhuvon7mZFrHjGL0Y88x6c772f6XOXGtnxCif0jCWgghhBBCCCGEEEIMSscmrQ8mq1XPbxNCDGGSsBZCCJG0cr0tjAzUs651VLyrIoQQQgghhOjGwaT1yOdeJVhRLclqIRKcqw9djEU9tmVW73MvKZC50b18e8uzhbZlck+rcG19scfyXVvWrhsCtmXGPdHh2vribdnyKfGuQq8ZnUP3tGr6dLyrMKBiqaZ7y0qLubYsJ8wU9+oeKB/Y65qeAZ7N6FdjH+XeSfcwJlBj/SHFvc/qzOJdri1roM05f9uAri8ypW1A19efglX2TavogVTX1qei7p1XfM0OypQEXVuf+YR7baFwun0ZX6trq4u7gT4nGwN7GnOV4XOv8kZHcj2vPjW907Vlmd6BjdlomnttIdPv3rIcyXdvv/dG1ib34jzVQffZX+ve+gwX25FmRYp9mYnunViqFrj3HfFW+1xbVm9oj/22KLN37RcFpByTrJ58+9peLetE6mfaf9+zN7gXs/4q9z6rljH2dVcDfDjrT/Pm74x3FYYMXele+z0WHLggOrlMRNRAV3WfHB32rv0iyk+HZZWTbcvlXFRrW6Zxcw6eRvskefM4+x0aS4vRsDe3xzKeFg9k2y8rMK/Bvk67s2B7z+sDyF1vfyCvm6XZfZ190tp6lm7Poin91xDXEYOOqp476YaTBlp1wFHS2syM2pbJWea3LdM40VnjQTvsPDpJWptZEdsyiyaW2JZZvnaCkyphROzrpA3rx05/ngR1VBFt6DnWjXb7Y4J9CfA1OmtEeVscJKdSHTZADfcaqk6S1qZ9OxwAo91+G2N59jEby3Gwrsb+bWCPTa/hrjPuPvT/oBkhLdzJc7N/zzr/CD749GcdLefVpTNtyzjtnA90+mPlyonOCmY6+DJr++/JVZM32JZ58s0FhB2cXz923mu2ZR77/Xm2ZfokFMOzsKHbl1tLMhwtxknS2t9kv3/DOc4Ouu0j3Ds4qzoH504Hpx9vO7DCPmltLmixLZP5XMi2TN5HSu0rBWxbXeyoXG+YpkF7i815zME52XFCq9pJ+9AZt5LWpsOOjqPksIPD7Clj9jla3+rOsbZlvJmdjo7ZZrl7F6V6QzmIobYy+6s8SuNoBKOjFpOD8wWAmWnfnjCanHVhnSSt/QXttmVipfbHF4D24Q5i28F3MpYWg34c7GAGoGlC91+ejJ3KUdK6YbqzPrYdb73XUcxGsty8CGF/8BjznxjQc7u07FIvZrp9vXwO4oxdIeodjMuKZtv3cb11XrwuJkKPoxUq3H2MGGH3Lqbv/NU8R+U8Ll07MNoN2zaM08FBKZX2ZZqmRVExB/kBBzFrdBi0jO65nJOLCQCeve4lOI+VHujgzIk9J5vfendav61/MNA5zq6uOWlzG4X2x5dIUwCa7ZeVXmKfKWmZFiaWan9s9+3vexs0uYYJCCGEEEfwrY1R87cQwfciTI1U4lVDeBihEEIIIYQQQgiRACRhLYQQIimlv9fBzA8eoPD/muGjkLW6ne9P+U+8qyVOwlR1gC8YL1NIY7yrIoQQQgghhBDCJZKwFkIIkZQy323HCGtrGpsINK/yc33RShzdYy4GhenqAGmqk7GqOt5VEUIIIYQQQgjhkoF9mpYQQggxSDSemoLpV6iIRvsU4UVemiM+HM7GKQaBp8zZAEQdzUwvhBBCCCGEEGIokIS1EEKIpNQ8N8iGB4rIfLedxlNTKJ5RR1W9swfmicEhbPMwJCGEEEIIIYQQQ48krIU4gml4KFt4AekVpeSWbIl3dYQQ/ax5bpDmudZTsP2dMSo7MuNcIyGEEEIIIYQQIrnJHNYiSWiWZOzgtuFvkOFp77ZU+czTqB8zlbJTL2b/7DPQSqYGECJZ+HWUqk4ZYS2EEEIIIYQQQsSTqwnrylPtywx/x731ZU6rc21Znhb7+S9jaTHX1pc+rsG1ZeWsT7Kkan7nSRTWnJ25lSem/5n7p/6Nb41+nudm/o5F6bsBqFscPlSyJX8EVVPmkbtrA3nb11I1dT67l1xJ2p6AyxvgjuU7xtiWWTRnp2vrU6ZrixoSIpnuPXjP25Zk39E+MDMjcVmv0iY+TM4Yt9W1ZRpR+dyduurMla4t67rPv+LasnojNKZpQNfnrxu6Yw+iKe4tq/HSVtsyNfcWu7fCeKsenG0TJ4yOgY3ZNSUjXVtWtHHo7vfe0L08jSlMioLH9NPU0H2gsafY/vji6voc9Ev7U9ME9z6rY7fFVF7q8i6kNW3aob9Fs6Ourc9NJVfbfw6jn3Ox7uPdi7NoTnz3qekfut93M8W+02u0u3cey9js3qQHZtC+7iom/ZPBQNX5B3R9voyTyaH1LG3zwNX9pL4dKga+xu6/nJFM0zZpHUt1lvXqCNtXraMsHRwcDPNX2X8pm0cq7PL3HYXO6m48n2NbpuG0DsgN25Yr/uhe2zJrl05AhXveRu3wpHHgUocnt0ecFTuKCZ7Wnvexag7aLubcc9bBRLtSmq/kvMiISANpOkyn8rDHm0ub8jFe1fDQtL9S7s3g5q9/k2gsSsznY8vFFxJsbGTy86/giUQ4sLeaXeecx/bz38+4t54k0NpzEqJtuH2chbMdxlCD/bysgVEtrK8Y3mOZCXk1zJxRarusTavG2lfKox0lrWfO3WNfCHBW6mjBlAhTp+zrscy2taN7seQTi2S51NhyeJElsNk+e6MdtI/Cuc7iLBayvwinOpx1mrxB+0SzuT/Vvk7pMUf16i0NRE7wgL6gtvbZn9dc4KiHrvPsP1PPgQBGpzuNQj26+ztDDgoEnCX7O8rS+1qdwxwkIHzK/vNsiKRy/mnrbcvd95/zbMuEiyJwqsMLH391VuxIZtSgqTrU7euqw4PdMyANhyEezrH/LvvrDEdJ62jI/rMyAw7KpLv3/TS9mmiafTmvaf89Sn8jZJsAVzGo/NcY+3rN68eOfkShamySnob952B0GLDX/pzhpPM64LTCaHdwbnFwfPEH7T+rjsYgq7eNcVAxBzREG+yT1qnF/XjhyqMxs3s+xhn19u1IJ/ljFXF2DsudXgOAlxgXp23iQxnvMtZfy32Np/Ln+rPRKDqfy3e0rEi6fUe4Y5h7cR2ute97pJZ6HXWa2ybb9+38ZfbxE80w+zVprRWYPYSIMqFxsn2AOGmTTvrqe4f+HfP5WPPDr9AydiYtGXMILfUy6a5/ceBzpzipNr4W+3hsmuQsNr51ztO2ZX720pWUXuZOMjG2z74NbOZGoMg+hlJ22H9HOvNNR4nX3vIGohSM6X7wYO3GPPuFjOxwtC5d5d6FQtPB1yp1RLNtGb06E1rsvwAtY+0/A50bdvS4d91mH4uqw0B7ev7uetoMnDxgvj/jpyPmZVdTbr8t/1hOzmVOji9R+9OFVc7BRbis9V7AfoGtDq65R8P2ga3q/I4eUd820v5zNzOctZNjob7HkMxhLRKKQjPHU8Zl/vWMDtfTobzs9uVS40k7NL3HBqOI4kgdRdEm7vjMH/nxQzfx8oyb6cjMZNajD+KJWJ2AovVrSWmoZ8sVV7L9gpsY+/bTpNUciOfmCSH6SQDrxFspU4IIIYQQJyVVdXJ1+lpuyljJMG8z28MFvNQ6lVsy36XYW8f3a67AvbFdYigyfV7WffeL1M2ZzrTf/JXW4pGUXnspzWNGkV/7Jt6Is+RlfwnqMKOpYwfDZEpIIYQYJCRhLRKCwmSut4zLfesZ4Wmg0kxnly+PGk8Ijml0mMpgjz+PhlgqBZmN3PWF3/OVtrE8+WaYzP37aaororF2FJm5e8mmlEn/fZDdZ1zFznOuZ9Sql8ndszlOWymE6C9+bSWsqzrloYtCCCGEE7n+Zm4Z8zYfGvk2GZ4OVrUX85OaS3m3w7pzb33HCL6U8wp/Lbyfz4Zuo6o1K74VFnFhej2s+3+fp2bhHKb99m5GvvgGAOm7Stn8hY/REhvJqPeeJthcHZf6+XWUy9hAHq0U0cjretJx/UchhBADb+hOfCjEEc7zbeW24JsYSnN3xxK+13YVNd60Hhsb9Z5UPvKbL/NG2xn8KeOz/H3Up2hpGMaGpe+jZMsSNix9H011RQSbG5j08sN4wh2ULbqItixntzQKIYaOVG3dWVEhCWshhBDC1vBgPS+c9Qtun/AKqzqK+ciBW/h05Qd4t2McJl4ajYk83LyQL1fdwAhfPf938b3xrrKIk72XnU/1qfMY+/BTjHzhtUN/L3rlbeZ+5xdEghmULriWeM16PJ9S8milggwmU8lYauJUEyGEEEeShLVICLtiVhJ5TXQ0K6Lj0A5Du64lnduf/398u/knXDh7DYtG1WCaHsDANA0aa0cRTk1jz5IriKaEyC7ZQrCpth+3RAgx4LSmMNZEowrSGLGfY1AIIYRIZgqTn89+mIAR5Yq3vsw3q69lc7jo0Ot7vZew3f9R9novZWn7eJ5vmcHIDGk/J6uCd1cTqK5l38Xn0Dz28LNmWkcUsuUzHwE0ebtWOJrHtz/sxppvuZAmWvFTjgxeEEKIwUAS1iIh7DHzeTcyjgt8m8hV9g9KONKI91Zz15pr+WTDX7j5sn8T8HeCimEYJnqWZutFH6Itu4Did19gzLsvYJiD8AFGQohey9QdhHSYAx7poAghhBB2PjTmHU7P28H/br6Src1FR73WpMZS5T2NgFlHpfd0KjxLaNN+Qv74zlEs4ielsoYFX/8fjHCYVT/7Ns1jR1N16jyW//7HhLMyGb3ycXJL18StfhUqk7eYQBnZ/JepdCj7hxoKIYTofzKHtUgYj4fncoq3jOsDq7mz42zH71PAxJde4P7cm2kpSuW/f7+A11ecTXis5uF5t+CvbmTM0ucItjT0V9WFEHFUFG0gikGlJz3eVRFCCCEGtXGhSr4x5Rleq5rKQ3tPPeq1GH5KfNcRMGuZHv4De3zXss93KTX6H/g97+I1okRN6X4mo9TyKhZ8/X9Y+YvvsOwvPwUgY/tuZv/P76j9wJj4Vg7YrIrYTJF9QSGEOIJWHgCUjsW5JolpyIywzvO08KeRD3JrzlJChjxnWhyvQafyQngG87xlTDIqTuq93kiEaU8/ySOdN3L78D8x8sYy/t9Fv2Zr3hSeC57HaZmrIG4zqwkh+otXxygwW6jwpGOqIXNKFEIIIeLiO9Oeoj3m51vr3wfHTOKwz3sRnSqLsZHH8BBmXORR0mO7KVOLAAj5pA+XzA4mrYsff47Rjz/Pgq/8iJQqmS9aCDH0mMpDQ+EplJzycUrmfpLGgpmSLeoHQ+ISt0Lz86LHWZhawjlp27kt900ebpjP3RXnUR3OiHf1xCDyUmQaS3w7eH9gJQd0xkk94Tm1vo5JLz7Ppiuu4qMd93HfvWdwy6hHuPq0ZZx9wyY2V47kn++dzSs7ZhM1Pf24FUKIgVIYa8KDlulARNIxDR8doUJSmvfGbd5QMTgpTC4dtp41jaM50JET7+qIQWR4sJ4z8rfxhx0XUN15dB+syRhHlXcxw6Jvk65LADCIMSFyPx2mdQeTJzcEBwa61mIwSS2vYvJfH4h3NUSC00B7WjExXwh/Rx2+zjoMMxzvaokEoFE050+nbsSpxALppDSWopVBzdjzac6fTv6eV/BQHu9qDkppng5aYsGTes9JJay1ByKZ3c/fGwvZD4P3tDpL9F03ft2hf59pbGOxZw//ic6hnEzOMHbwsZx3+PCZ7/J4zVzuKj+T3R353S6rZrbPdn26qN2+UtUBR3VvHmN/bUXVOpsba031BNsyuZvsl1N7iqPVEUzvx5EPCsxAz/vG12A/wvHlpbN6fN0YZvCH2feTB0R8aT2WvfJnLx+7dEx9B506SMpH2qjF4CE1jylUMGfYXn56yf00X/Io6xnJJooIH/EVum/Pqdhp6XAWQ9Gt9hdiOvf2vG0AW7c5u6Cj/A6uB4adpTS2VA5zVK43Ojp8bN45oscybl1KML0Or5GmHnvc08wI7WeYr4kcXxvZ3lZygq1ke1rJ9raR47X+luVpI4qH+mgqddEQddEQreP81MdSaTBTrd+xVEojOVTFDn+OdVX201YYTc4O7U6Ox6aT2AAoCdkW0Sn287+rQP/eTlUbSeO+qiUHa8T/hP7DbvL4U835AEw+pdTRcrbuLbQtE5pa72hZDQ4+04IXU2zLmDe0OVpfxmT70UwdUWcx1LQry7bMI2vn25bRUWfHl7ln77Qts2b9WEfL6rWYwtvY/f7RTo8dDji5NppS5WxZha8cLtg0cjhrP3kjbcPyKVy5jhn/fAxvZ5ht37c/Z6SmOuvwRfc7uAjkMFMeVvaN28bJ9scXb4uzuyiM9n6820IBhk2MmPY7xgw6e56Gk22ZvHjPoX97ifGljJc5O7idNtPHva2n8Vz7TLYud/a9uvbCZbZl/v2GfXvJKcOw3w+elKijZQWC9rHdUeZs6qjOTvu+R6/FFEZ9z8v319t/7pF0+2PVhPllR/3/xtQVGErzXk7RUa9t2zCO/ZNuwNtZR3D7amp07lHvM4ZvgWxonHcaqmwDgZambtfZODdiW6+UTPv5sJ20kwFH3zen46MMr308RjMGwbNwbI5D0XRnbbFp39931P87M9KpnjOdondWYMSs7dz2i7m2y4mF7D9zgGFv2rdNnLZbf/nUVbZlxr5gf0zYfYPDNnebg/NKg7NleR2kLfr7XoZoxENVRffn+dQG++9Vh99Zvzhnnf2ycja1HPp3e3YWW6+6hJpxE48qE2hsIlRTS2p1TdfvWkI1NfhbWo9qjux8n4O+1jQHHwIQ3GDffu/AWV7IrcEFsVRnx6C00v5rC0U6fezbWdBjGZ+D78zfb/zT8e/TMWKoo+6c/fg/P2O7rFSbHLMGWvInsH/e6XRk5RCqPMCoVc+TeWAvGqidMJXSRWexb/oHyN29jsLNS/FEuz+GNMx21jYJ7rM/LsTq7GPIdNAPB/Bn259fowdSHS1r6XW/PvRvjxklp62WFn8a7f6j8wbDv9D9Mgb9COvRqpZzja2sN0ewWhcDiodjC8mhhby6Fm7IX8X781fxUv007jhwFmtbR9suUyS2Zytn8+H6d5iXU0rElwoneZu/oUxS1OHETwwPmxjBJooYQy1z2Mvp7GIuZbzBJHaSj3unEDGUZXja+fm4f3PJMVeROk0rMV0fC1EfTWVreyEN0VS8KtaVxG5lWko5ub4WMj1HnyQi2uCnNRfzn2aHV52EYwrNC+EZtGhnDeaBo/FgEnPt8osQFg3sPWMhW99/Bb6WNopffpvSc0+jpWgYp9zxT8BZ0kAkppDq5DuZzzLLv5+HWuczyVfJp9PfYElgJ19K/TClbXknvcws2pju2c+q2Bg66cckrhgAmgtStrAuPIKK2NGJqrrhZxH1ZTB810MY+vhOeHvYSiKGfG2suuhapj7zEL5OeQhjImnPzWbltz5DW2EBNbOnMuvP9x1KWgsxEEyPQemSxew+70yUNpn09Ivkbt9FW34urQV5tBbk0TIsn/JTZhELHG77B+sbmPnwY2SUV8ax9sIN6WYHM8IHCCsvW3zDaDP63sfTQNPwMZTPPI32nGGk1NUw8aX/kF2661AGSAF5O7eQVbabvfOXUDVtDo0jJzF8/Rtk7duW9Jmig8lqhSbiObmH2g7qhHUKYW7wrKKBVJ6KzWHUunrGrqxhz4I89s7O4Xcl5/PbfedzS+FSPjxsGRfnbGJ501h+ve8CVjSPi3f1Rdwofrz1Kp5c/FsCnU10BrMA8KzqxLOsk9jiALH5vTl4KUrIo4Q8CmjiLLZzMZvYST5vMMnVLRBDz4zQPv408V8UBRr5duOPeK1tAU3tUVra2zBj1XhjjbYnq6zMNjyYZHrayDbayPa08ZGsZXwv/znG+2v4Te15A7ItyUJj8HZkon3BAeJTUS7PW88ni95kmL+Jz2z7IMuaxse7WiJBRAN+Nt18LeUL55C3aRvFv3+Hproiprz5DLu+fh7Lvv05ctqeJtS5I95VFXGQZzTzw6ynGOFp4FeNF1C+OpOOtV52LBrGZYvX88zZv+L/tl7CfbvPwHTwCJxUOjnHs5XTPLvwKZNZxj7+HlkiSeshbJqvnJHeBh5qXHDU32v1JJpzZ5NZvZJgmzXfx+h3IGV9Lu2zaik7HVpjVrt7ytqXeGfGGWy/4GqmPP9vPDFnI8zE4NZWkMeKb32GaGoKo196g7ILzwJg1p/v69f1Nowcy755Sxj97mtkVO6zf4NIWPVjRrPl6ktpLSygYOMWJj/1Ah37M6lumkx2RikF6dsAMANeNNbdAK35ebTm57F38ULeu/VmZj70GLm7S+K6HaL3DiarI8qDV5vMCe9nhy+fao+zO6NOpCWviAOzTqe1YCT+lkbGv/Ycubu2ovThOzmaq4fTVDWKjIK9pOeXM3bpK2RUbmb/Keexd+Gl1I+ZQdHaVwm2OLvzNtEcmaxu2pxBYEUnarEmMs9Z4npQJ6yv8KwjjQ7uip1JwbpmPvKJt/GETWJ+g3vvsm7pro2m8X/7LuSOA2fx/vyVfHz4Wzw09S6+tecaHq5eGOctEPGysXkkEV8If7iZiC8VtUaT+v5qiGjwKdoezu9l0tpSRQb/Zi6nsJdF7GEEDbzin8yOcP9NhyEGr4tzNvC7CQ9RFcvnzLq3WNtUCCg6g8PRqVacGbFWUsJl5DS9jNds7nZZMQzqYmnUxdIgAmsqRvOl3Jf5YOYKCjxNfKLqIwOzUWJAzUsv4U+THmB4oIntbQXUR1K5f/rdfH77jTxbOzve1RNDXDg1naXfvpm2glwm/ucFcp7Yw8q9H8PUHoy3Y8yqe4jdXzuXquIbyGl8mczWFfGushhAOUYLv85+lBQV4XsNVxJe4+UnX/4PvkiMyD88/Py3F7Fkyh7+3/SnuHj4em559zY6Yt13NCYb5XzAu4IAEVabxew1c7jKu5aP+N7hzshZA7hlwk3nB7cQ1h7e6jw8XaGpPWziJrzhRrIqlgJWsnrFI7cTxo9/a5iF/IXYpdZFjry2A4x957/sPusSSpZcwPg3no/Ltgj3dGaksfw7n8f0eVnw0z+SWbKPlOo6tn3wGjwdnfh5p1/WWz1xOiWnXwhKsefMi5n5+L0Y/XwBxFSKrVdeRt72HRRs2dav6xLO7Z9zOhUzFxGsb2DOvQ+Sv3UHDc0jWb31Q5imB8OIMW/KP8lKty5qKCDY1EywqZncXXsYtmkLa29+P+tufj+zHvw3IBc/hpoUM9yVrPay3l8EwJRwJVMiVQROcNePE+UzFlMx41S87a2MXPUKubs3Emw8elnN1cPZ+uoNmDEPhifGlHMfJT2/nNSGSia89iC142ZSMe10dpz/IUaseYWcUgdz+SYQpc2jktWZH2i0bub0Qd3DuY6S1v04SV/fjVZ1bNYjOKCzGbuyBk/YxGOCJ2IyduXRc3C2mQHuqVzC+eu/wvrWkXxi+FtxqrUYLDoDmWhlkNpWjfedNohoVAyIaDzL+j6zlxcTP1E0Ci8xQkoe5JCsPlP0Ons6CphTt5HNNR4KKh9hWOXDjCr7HcP3/53cxudJ7dxFW2AcB/JupcNX5HjZMRQVUWvyxDxPK8jzhxNSjrf1ULL6ivWf4wd7rsSrTMYEa7t9T3tm7lHzswlxIjGvj91LriKckcbC/7uL8c+/Tl3bWEztATyY2kNrZQGLfnEHqe3bqMs4h7D35Kd+EEPXLN9+8jyt/LDxctZHRjFxbSveiMZjaryRGMXv1XHbyo/ygw3XMC+nhNPztve4vBBhUlSEJlJYHhvHRnMEbfjJoCPpb4sdylp1AL+KcV3qe4f+ZuLBIEzUn0ntiHOJGQFS1ucSxk8ML2F85GxM57czH6A97Gdp9oWULey6aKGlPZMITJ+PaEoQb3snvhZrSsWU2nowTcLpDucR74XqSTNJqa9hzNsvEk7LoD0zu9/WdZA2DEa9Kxd0B5uOTOvhwFOefJ78rdZdYvVNxZimBzAwTYP6puJu3x9obmHs62+jPR46suQh7EORBxMDTRSDGIoYBmFlTa3o1717PlI4ZI3MLtj2Hvk712OYx09x1FQ1CjN2OM6aqkYdek2hydu9npFrXkEbHjrTk+8h1kprlNbElAfP8hhE6MrHgX+Zs9zZoO7ptuPDixVgexbkEfMbxDwQ8xnsWXDizlS76eel+mlMSKkm0+PsAVQiMWnDQ1uqNZm/75RW8FkPDsWniC12PrpaYZJGB4U0MoFK5lDGEnZwM8uZTxk7yed+FrG2c5T9wkTCKfA1MTNtP/9uPI86nUtq65Yj5rPS+CPVZLStIb/xGYpq70PpCOW5N9OcMsN22V5ifD//Gb6c+wr/bZnCZypuROZLT0z/rZ/ON3ddy4SUau6Zei8/GPsU5Z0Z/L18yXFlNbB/zmlsuuoWtlz2AVpzen5oiUheWilKF11CR0Yuc/76ADk7rIfr5aTsxlAxIIahYuSk7MYTjZLX+ByGDlObeaFcGksiGYb18KjSaC6NeiQPzP4aYZ+fiOEh4vOxYc4IQPFI2SLCMQ/zc/b0uLz3zGLuCJ+JieKz/tf4XuAZAkT5Z3QxWs5hQ9Y9LafxUvtUPpy2nD/nPMAlKRuZ7ivjbH5KZtUKWrKns3/yR2hc5MFPGA8R/ES4/bp/keo3Obf2Zd6c+kFCNZVMfeYhxr/5Qrw3SbggpbaeBT/9I5FQCiu+83l2X34+6z5zC9k79jD7T/f223rDoXRCNZUEG+sAiKbYP/y7rzyxGOmVVTK6epApXvoSocoqNr7/GlqG5QOQnVGKYXS1cwyT7IzuH6puegx2nX82qTW1FL23dmAqLVzVYgTZ4iskpDtZ2FnGvM4y8sxWdntz2O3NtV/ACYxe8TKZ+3ZyYNbpNA4fc8IyGQV7MTwxUFacZRTsPer1qD/IgVlnEWiqZdgW+4dSJxrT8NCQkoXXjOKf23lEPg7CixNgSpB27SMFK/O+d3YO99615Kg5rHnvxO9b3WxdQTslrYzXG6cMVHXFIGR6fLSlFpB6ShX6HoisCRE9PQVzrhcjFmE4DQSJHPETJUiEdDpIo5N0OgjRedyVnTAeqkjnOWZQiVyJTWbnZG0F4JmOS1CBCP5wVbdl/dEaimrupSr7GmqyrsRUQTLbVnVTWvOjgqe4OG0zf61fwp31Z0pHP8E9WLmIDtPHbyc+DMDnt99Iu3n0ydxKQJ5HzaRZZJXtpDWvkC2XfoDCzasp5BkMZD5QcVj5zNNpGjGeEe+9St6WnYf+np1SxoKRd1PXPo6clN1kp5QB4DHbyW56g9qsi2kNTiWtY0u8qi4GUIbRQUwrys0xrNCfwTu9g6/93wcYviad5+ZcR2T6BljRTtj0sb5xFAtyd9suc7cu4DfhC7jCu44i1cibsYlUaGkvDWUmBr9pOp9tkWF8LO0dvpjxCgAxrShJ/xeb28ayMnAu7912OovTnqPgrVo+ec0DFF+/l8X1K6gthenr7idU2307SQxNWbvLWPiTP7DiO59n+41XkrVtF/N+eQfezv65+9RUBpHUNPytzfjarQFqkZTUflmXGPy8kU5O+fu/WPGZj7Hm1g+w4E9/I4t9zJvyT+qbisnOKD00HciJ7Fs4n7a8XGbf/7A8KHQIq/OE2EIh0yMVeIANviIaPSm9Xp7SJsXLnmfHee+j5LRLmfTyw/ibq48qk55fzpRzHz1qDuuDNLBv7oXE/EHGLn2i36csGqzC3iDNgQwyZjXR/o8g0fd8hBf7E2MO63b85KhW699miN+P+xKTpyxnqn9pj2mbda0jiWqDeemlkrAWRyWtA3NaCNACLdZrH1QVx5Xv1F5aCNBMkBJyaceP9a7DP2G8yEhXAXBu9lb2d2ayVp2BP1yJoueGjke3U1j3EBU5N9GYtpiMttWoE4xl/HjW21yctpnf1Z7DfY2n9Vf1xSDzRPVc9nVkUx1Jp6Tj6BEBpuFh95mX0TB6AoXrlzNi7TvEfAH2zT+TihkLqDfHMjryBOlmSXwqLwaVuuJpVE1ZQO7OdeTtXHfc69kpZYcS1UdKb1tDc2gOdZnnkdq5E0NHBqK6Io4yVDtNOpXl+nN4CLNI/ZGSGansnO5lky6mVS9geOqjBNqqWFk7no+Pf40UTyftsZ7vVuvEx7+j8wdoK8RAMDF4pn02z7bPYpiniXHeasZ6axjW2sqs9F1ckdo1XcJnrZ81kTmcv/s+wuXvMPGdurjWXfSvjLL9LP7ur9Aeg2B9I96Ovk+/2J1IKA2Uwt/adDhhHewpYX2wnS19t0SV0tjEKfc+yKrbbmHtrTex8M57+MaNd3OgOpunX1l0wvdooDU/j91nLyF3+07yduwa2EoL19V5QrxljEOh0S5Mm+iJRRn31pNsv+AD7DrzamY88QD+9qNncUjPLz8qUX1Q7bhZNBWNp2jd66Q01hz3ejJp84fwmFFCM9tonO8n4neWrIZBn7A+PML67fYb2BQ+k03hM5ngW8XFob92+74O08/m1uHMS+v+1g+RXEyPj9bQMLzRTpSOopWBVgbPtY2hAy8d+OjARyde9DHjqYNIZ12cmF9FWZK5k8er5xH2F5LWvNbR+xQmGW2rqMq+jvbAWFI7jx6tdm5oK5/OeZOnm2dyX+Pifqi5GMxWNo897m9Rn5+d51xFS+EoRq14jWFb1wDWqJIxy/5Lzp6tlJx/HjsCnyAvupwRkRfx0H+dRRE/+f4m6iMhotrTbZmW3CL2zj+PtMoyRq55vdsuulIarY9+VaHJbXiR8vxbaEg7nZzm112ruxicQoamwhyJwmSh+iOpypo736s6mc+dLNVfpnzi1YzY8iAr68Zy+8RXmJNdyrKaSXGuuYgXjaIilklFLJOlnRPYsc6aFi/k6WByWgWTsutJD0T5R9kZ0L4Sq2sqycJEF6qsti+ElSjsSzQcnFvW39qMJxrBiEROOMLaq2JcM+w9PlP8CpWdmXxi4y00RWUkdqLKOFDBrAf+zdpbbuSD39/IdUXWFAzNLam8vnwmAJFggPqxY6gbP5ba8WPpyMnGiESY+OIr8ay6cJNSrt6V7G9vZdxbT7LjvPex/YKrmPbso0eNls5Pb8TniXKg4fBAo46MXMpnnkV6xR5yd61xrS5DWXMgA0NrYsbJpaBdncPa09p95+mgWMj5pOft2k8KEepihazsuJRZgVe5IPVvlEamc0fDHxg/tfC45OJBq1uKmZO2Fw/O1qcOBO0L5bvX+Tc63fsS1c62L5O7JnEaid6m3oWtNrxE/CHCgUwi/nSivhAXZlZTQRYNhOjAf8J46tC+vlb5kLSgezHkabXfD7FUF29rGtQz3rvPiNp/ZxZl7yLkCfNCyyK04SPQeeCE5czO44+NqR07MGJttKQc/QWe7K/gx/lPsa5jBD+puZTeNOnNDPduOTLCA3vsUA3ufd96oyDY4tqymhrd6RTFPCG2XfQ+WguKGPvWcwzbugaPEePcSesI+a25ZzMq9jL9ofspiLxNjWcBmwOfp9GY7Gj5wzyNfDzzLQLq8MW5oHdgb1tTXvdmTD5lVs/z6/Y35eDY0RsBI8IPJz3OyjN+xNozv8e9s+/iU8WvUrx4D17jcFunJW8Eu8+4Cl9bM2OWPYPSB88DmtGjarjkorV89YvPcO9f/8J/Hvk1n77tJQryGwGY/MMmAIKR/aS1racxbRFhz9EPielocz4qwpaLE2WbPvuFRdMS6FZf0504iwQyUCqbGjOXhepPpKmjE05B1cQCdQfKb1A+6VpWNU7G1IoFNvNY9+T6s97ta7VPSiDo3rQEwdHNri1rKNi5evRJlW+NBXmvcQwPlZzCXdsW0Nnecei16vkDOzN+YJR75/NoZu8e2jVUOenTOzX5F0cPIAsH89g79TbKx15POJDTq/V1hqyHkftbrO+jt6ONaNcI64JlBl4V44bClbyy8Bf8csojtMf8nJJRysNz/kK+v8nxesoutj/fjXvUxTZ3u3udrVBZfDtubRPsj7vBKvfqWDfdesBn3vZd/GH/zdxa9CB37rqZ9duK+crH/0Pa+/NZcftHefMbX2LDjddRMXM6aVXVTHr2RU79418J1Rx+yPmER+z762ad8+dh2QlWDOxnpRLoISUffegzA7Ke1Poqipc9T2vBcHaddfFRzdenv/hjHv/cTw/93/R4KV1wKZ5IJ6NWv9htTz5zw8COHXbz+OIt6sWzApWiMSWLsPfkvjsntZcMf4yU4u4bap43MrHLarWMcdZZuP/1JWSM6WTJxJ08WHY7Og3q1m6nKdrKMN8/qR1+Lq9yC/4RleQ3P0dKdP9R718XHsGtnqXMyNlH1QvjbddXcVkYYj03/n0lDpLawLmXdDO59hEqOzIcLauqzf7pyhXrh1Fn8/w27aAjB9Be72wbe0vZfPzRDPc6k3P+/QXXluWEith3Hp0mkI2QfbmM8Q22ZTo6nSX/jE3ptmU6Rzobaa529+NDT2IKb33Phy1Hsa7tP6vimftty1yTsYr2mI83mi6ANAjWVmJEjq9fd52mzMh66oML8KR48ep2Mpb5+M1Vj9HQFuILT36S1vbjPxdjtHvfESeJbR11dnJz0v5vK7Rfn3+vH5rcawQeq7k1hbfendbn5QRq7feL9kAH9sfUUEf3r4VTMimfdy3RQIiRa58k2FnK6On7+cnih5iSc4CdDcO4/bWPs781l4w9Ecbeu5z8/FJ2n3kRu3I+TO7OLRQvfQ1fZ/uhZU7+wuZD//YQ4zuhZxnnqSE1GOHFsHUyeXO5s33kJGWmbc6tAMqjHSWt160eZ1vG9Ot+HchnRCD1QPcraCm2/46mFTvrMH9gwkoAsmjlarWW4aqJ9/QotEcxPXc/Z+dZD35qmRPgvdqxvNW6kKfTF7KvpYlR2x9nyuRtzMvbw/zc3cy9fQ85PquBWRMJsbJ5DO1Nfi6/eD0XX7yOJ+pO4W8rL8C3y5rvr8C3jLb5k6n3X8yIjU8c2qWjzzh+GpET2ZVhf15xytti/33zttp/6LkbrQcw2alY3H+dRxWzv/DupC1kZjk7J4fKuj+ehoPplM28nhz1G/bVBylfmkI5x9/hAZBb+DSVxdexffz72dzyW+bl7ya67/jv7CPLFzqqF0H7bTQ67D+Hjj327en0ifX40tpty/FSjm2R5gnOzsH6QO/nzXTFTPvEun+tg7Zfnnlo9LQbnCSt0zbZJwnbRrnX0c/aZJ8sbT2zFZw8tytiH7M3nf2ObZmHXzjDwcr6j4oovA32+3jbV8fYlpn8q5JDSeum0UWs/NZ1eFtjRH35HBj/IcY8/xqxsZsxHOQ/6qdYx/nGEVbsto1socNUKNpoywvRPNXkwet+y8RYNSHCNKgUlnuKqcpOp0EHWGCU8fppP+dd31g++eQnbdcXC5rsvs5mP6SYYDMdIABje2jsdYk67Ie3utgX6LWYwmjqed90FLhTz9pz7BPIl0zbBMAZ3u3c5F/JU53n8KnQP8hVtSxXi/jzhT/ksoZplG3dR1pNKSmNFdYFfS80TIMGDh+zVQzsbtRvL9RQbv95dRQ6OJ8HnOVpxk48ftqJY7XdM8K2TN10Z43kSH8+x1Rp8PS83U7zJrc8dbt9oUz7ZdVn2ZXYQc7et6gbfyY7AvXk7F/GkSMvamYpQFFdfBadmXmMXvU4eNrp7qYOTxgyttgfZzvybIvga7A/90Qnt+Hk0mCszP6Dj+WHIdu+HXrqK593sEaAb3X7yqCeEqQhah04Aln5ZJavJLojg5Yd0wlO3MuwyJN0jB5FTdrF7M/6CBkdq8ltfQ2Ptg5o77VZIwLmhsp4ASthrYFIaoj27FxiPj/ZJTvl5jQhRC9pFgX3sLRuAo0pxXgirXgjzYx+B1LW59I+q5ay03teQmZ4LfXBU2nyz6Qw/A6/u+CfZATa+PDTn6P2BMlqkVw60vMpm3sNKIPi1f8mo2Ufn5r9Xz4+/RUaOkN89uGvkFubylfmvcN99TPYs8c676VVVzDjiX9yYM4iDsxZREt+IdOffujQPI9HujbwHuM8NdSYIS71b+C18JSuOfrFYDGFci5RG9EoHjXn0r7Wz+iVdTy/YAb1c1LZtXIki/J2Mb9wL/+v8B/8P/5BS04Az2iTFK/VmNzTnM/LjVNZ2TyGVS3FlHTmcjCr/6v9F/DJwre4MX8l1138Hs/vncOdW85je1MRuaXLqB5/Nq2540mrlbkdE0kkEKJk8XXEfAEK9D42tU096vX2suG07x5Jyrh9pIwuJ9i2j7z9L1Iz6jLejJzDrZkP41NRIlqOF0IIe02jR7DyW5/FEw4z+dtP0Fw/gqarRrDngxfgCS8ip/w1Upuc9c2j/gyMSBuGaQ2ECEYauSHvJb57/s8YHas9nKhW6aAU2e+1krW8nY0LhzNtZgWnR3YxKb2c7c3D+3ejxYA6xVPK+30r2RAbwYvRQr6+65MMXxnjkQWn84XTHuLJ7Ku5puTrtEX7d4CeSFxZ5auJBLOpH3kqvo56pre/fei1HH8re1Nn0VQ4h5w9q0mrkemJ3TCoW5kNEetyRH5sL1Ur9lL5xxvQUQ/KG2PYZx8lrXA7qfUl1KaeRWPKAlr9k8lveZG08FbKI5mUR7KZkd7Gn866iPbsHNqzcokFDo80GfP2KxRuWhunrRNCDGWjvPWM8Dbyl+rz6AwNJ9BWTvE7sOKR2wnjx781zEL+0mPSOhirJBg9QKN/Dn/N/SazM8v4wn8/wrY6+6vjIrG1Zo9k3ylXYkQ6Gb36UeakbOBnl/6LiVkV/GfXfL7zn0+z+d6b0TGDoL+TF/52ES9OrefVLdYUM4ZpMvK9ZWTuK2XrZdez7aJrmPrsI3gih6+GT/fs5/LABl4NT+bdyHi+HXqOs/3beCk8PV6bLY7gJcaFahPzVBn7dSb/0aeQvraDmz62Ak/YJOY3ePBvC3lh/xwe1B+lJnQWxQdWcUX9X1iUu42oNlhdM47VtWOp6cwgMvrEo7vKI1n8cO8V/Kn8bD4RXM4Hx7/D5aPX8PL+Gfxm46W83DqT6jFnEKrbc8T0ImIoi/pTKDn1OqKBEGPe/Tc51zbTED48BKi9bDgH/nbdoTZ30ccewztjP6GmrUQr03l19FV82nM/M9L3s6apOI5bIkRiKFINVOoMYgk6/15T8UhWfuszeDo6mfLtJ1i/80OY2oPxtxjT3nuYHf9zDtXFV5HSvIec/S/ji/R8F1I0kI6vsxnQfGDsUj418acM91WzsX4kK7zFVHYlqgGy32tl8Yf2oMIa7Ves/ccIps2s4KFT/8THVn6cNQ1j+n8HiH43yajgI/6l7DbzubtzCWM21PKFzzyCJxIjdq+HJ++czbUL1/CLMx/g86/diqkT87sm+pcC8kteJRLIpGrcBVxT99Kh14oy21g96kL8rZUUbLe/k0Y4M6i/qXtj1mixL3n/h87tw9FRD2gDHTPo2GHdnmboMPmt/2Vkw9/RyqAi4xo0HmIqleWxM5gSrKR6ygxahhUdSlb7m62TYMWMU+KzYUKIIW+s13ra74UFGxkVqCLqSyNlfR5h/MTwEsZHyvqe7x9t9wwnpgL8LPtnXJW5nt+vuoRXS2cNRPXFIFcz/lRMb4CUxnKMWIRvL3iCiVkVfP6Nj/DtZR+gaudEdMwD2kNHOMCLyy7gm5f9m2MnBU6rOkDO7u205hfSMOro6TTO8VvTSVSb6TTpIGHt4RSvs+keRP+bm1LGPFVGiw7wqJ5PEymMXlmHJ2ximGBETEavrCPqS6FmzFmEanfi3biUF/fN4EfrruN/11/DiwdmU9PpbAqymmg6v95wOec8+x3W1Y7m/BEb+d4pj5FZuZFIajadqU7uhxdDQWPRZDrTc/F2tmKGQmgUI1PrD73evnvk4TZ31EP77pEAmIY1zdgUrzWt0LBgcs3nLER/8BGlWqcxRtXEuyr9Zsf1l6JiJgt/8ntaKwswtQfwYGoPkZ2pFO28n+wDr9GeNob6wjNtl2d6fHSGCvDPnMsP5zzGcF81uyNj+Prqm6g0Mg4lqwFyl7eiwhrDBBXRpK6IsMuTT6avnc9N+G8/brUYSBf5NuFTJs9EZhHBy6RVlXgiMTwmeKIm/pUxdpoFnDNqExOz7KfWEKI7SpsU7ngGX2cTwVGHp8xqmHAu2vAybOfzGDq5nnvQnwZ1wvq9xmJ+0fI1bs1/ms+dfz/KGwMjhvKYBCfuPapsTKViGiGy2legiOHR7dB5gFRdS/HS1yhcv4qc3dsJVZWjPR4y95Uy9q2X47RlQoih7u2OCfyx8WzmZpWysWA2X8n7G9XnjcZPGA8R/ERon1V73PsiKo1m3xQqUi6lNP1j/Crzu3wx9Hvuqz2Vu9aeP/AbIgaloo0vkrVvA80FE9h1xq38svFLAMwvsKZlSC3eh/LEQJl4vDEuO/0FnlqzkIPTPET9AWrHTWLH+VdQM2k6uTu3kF2y46h1PNCxiHWRkbw/uIqfpT1Ou/Zxf8epA7qdonsr28fwhjmRVMLcopZSRD1lC3KI+Q1iHjB9BmULctDKmpEuVL+nzw3k4Sn1/GrRA8zOLWN1zVi+u+b9NBTOxN9aS6A1cZMpySa7bAPDN7wCGkpOuYpfNX+Jy0et4fTCnQCkjNtntbmVifLGCEyooCFvEfsnfpwvjn+F/0n/Pk9UL+bl6qk2axJC2IngJYbBLl0Q76r0GyMSxd/cQmp1HTn+HRjKep6AoWLk+Heg0ARb94FSpLTaXzgv3P4s2fuXs82/gPPqXuaRlqsZ4dnHc+f/ktMjuxgZq8fTdUdQ7aIQ2q8wPaB9isz5bcyIlbOhcSQ/2HxNP2+5GCiPhudTb6ZyW+ANJhkVbJ8/jJjPQ8yjiHkNxp5aw2RPJXdvOJdt9UXxrq4Y4jyxTkZsfoR/7juPDzbcz5m1b7CiYTIjNj2Iv6PefgHCsUE9JYgn1sE3Wn5OsHUvP7roLgD+8PLNBCfuIzj28JWxmApSlX45/mg1Oa2vH/q7aUbx0cnwDcc/BFHTr89kEkIkOBODx1rn8q+1S/julCf532Hf4ebbpvJ9/9dpeV7RPquG0iUeOlMKaA3k0u4dQbt3FFEjEwClI/w59CFuT3uQ+2pP5WdVF+GVo5Lo4utoZvjml8nbvZyasQt4eMSnOa1lO5+f+kfeqD2FZcDoDz5GW+kIfnLdH5g2dT3fuO/nlM+cQf3ocTQXjgDDwNvRTtGadxm56p3joqteh/i/9gs4I7oDBeyIFVBuZg38xooT0iiWMoFSncuVah0fUst5c85EHvzbAkavtJLX++dko/ZbnXJt9H4MgsLkA/kr+NbsF0FpfrzmGu7feToVEy8ikprDiA2Po0igx8onOcOMkVu6npzS9TQXjOUXUz7J1aFn+dGCpzl90wN4gjso+thjtJWMIbowjcozLsf0Bvht4ON8Ie3vPHxgId/acg3m4B73IsSQkejfpUBjM3VTJwCQHShhQe4fqQtPJMe/g+xACZUU05o9DcwoqQ3bbJfnjbSRu3cZOfuWs9sT4Nuxs/m1by5Xj17F52a+wCmxfcyIHWCfkU3pnByW/XMsw99tZNj8ZopmN7PLyOOGpZ+TOfgTSIXO5JedF/HZwKt8NvAa952ymN/dcR6TV1Uw/tQqZs3fz7ORmfzmvcuQLJBwgyfaTvbOV3lrXzZalTC8fbVEVj8Y1EdpZUbAjPHdmi8SaK/gRxfdxZyZ7/HNzTccdYKpTruYmBFieMMjGEc8/d3UBp5untorwSSEcENFZxafWXcLZ+dt4QfTnubRT97K6lvn8krLaWhvEK+xFw8xfLqNgG7Cr5sI6CaKPJWckbbzULJajkriRHwdzQzf8ip5JSv46dgPctbsN/jp4gc5I+NhPKG9XHb+83xi/qN8sebnvHPVZwBIra2iaN1Kssp2k1ZdjtI9JRoVb0UmDczGiF7ZTzZ/16dzsdrE2cZ2qk9J4+U5Uymn6+KXabV7Do60PlnFgVp+NuZxTk3fwzuVk/juqvexvy2HhsIZNBXOIKfsXUIN8uCYRKSAjKo9+GN7+Gbd+3hi0Y/59oQH+HTBX2C2idIxtMdPWu02/pR7Ox/Ofo179i7hR9uvRCd4gk0I4R5/YzOR9DRMj4ERM8kOlJAdKDn0ukbRkjmF1ObdeMxOx8tV2sQbbQegLpzG33eezYy5u8nRbRSbdYw26xhr1lI/M4X0GR3EMFjuLabKyJBkdQJq0Kn8uuMCPhV4g1v97/DE3LmMmN/AdG8FT4Zn82J0BtLfEm6TEdX9a1AfqRXgibVjelP52Y7LaIkG+cqEFygMNnD7ultoQ9Hin0pLcAY5rW8QjFYc9f4YCo+SBwQJIfrf6zVTufjt8Xxy6ntckLueL2XdQUwbmFphAlEUpjaIHfH7jpoz+F31uUjjSdjxdbaQvXUZ36y5lscu+Bl/mPS/XF7wLF/Pm822yETuK7+KMdv+S1bZHgKtMq9sounEx5N6Nnt0LqepXdxkrKRde9lJAaWFI/gHbaBOLoGY4WnnfXmr+HLRy0S0h2+UXMt/Vp4OKDrShlE9/hxS60vILX23fzZKDCpbyjO5Z+eZ3D7xTp7fN5NXoxeitEnegaX8ZsqfuLpwNX8qOZdf7roEOWcJIU5GoNF6flQ4I51gfeNxr7enj8H0hUir39z3lSlFnQpRZ4TYqIcz0mxglFlPrUpjvXcEHcrX93WIQaudAH/sPJdb/Uu5zm/dZf9YeC6vRGUKKyGGokGdsAYwou3EPCmA4o97zmdfezY/n/4I/17wR27d/0l2p19CILKf7Lbjn8QZ0wYeJbewCiEGRofp5/ebTuX3HD0PcGBUS5xqJBJNaU0mP195JT889VF2pI+m2FvJp9/4OMP3PkfGHrlAm9gU6xnFZl3EGF3DZFXJRKq4Y9Hd/Nr8F6/6F/C6ZySvV0yjOZJy6F0+FWVcehXjc8qYklLB5NQKJqdUUuS3kgb/rZ/Kd8quoiqSgR9FzBvkwNTL8YRbGb71eZkKJIn8bsvFnD98I38c8X0uf7WZqOnhNwv+yUUjNvCLnZfw59Lz4l1FIcQQ5G+0LqR3ZmacMGHdkjUNI9pOSsseV9cbUV72ePLY48lzdblicIvg5a7wEiZEqzFR7DITd354IRLdSSWsVaOHwHOZ3b4eDfW5PodM+UMVAE1fasL0eQ79fyuj+M6MG/jut5/gyYl/4vL6i/lI/s8YNeH4E9y0SDnpZgcN77NPFnm2Z9iWiaY767SVt3e/jw7a9dR4R8uKBezLGA72e8znrO7exvhew1Bh+1E7RnGbo2XpPfY7xgy6l+DRDvaxEXE2KsnTZj9Srq3db1vG3JXmaH3m+HbbMkaNg2AEzED/JTcy09u46Jzj56Q/0ouvzrVdjvbb17HmuZHOKjXaPoY69zr7HDodLMsJT6vDkZZ59g9oS8ttdbSoltYs2zKBUvuY9fZzbl/FwNfY/f6JpjiLXyfXQk2HMzR0zrY/po3Iazj079cYzbntEzkrtIOt4WFsnJBJ3oQD7J2a42h9ta/MsC2jQs5iMW3s8R3PY7XssT8nZm5zFrONk+3rlba7d1NjOKU0GNHuX0+ptN+WVm3f5gB4+v6eE4QeI8a4s/awcKHBdWmPcMWCNwjHPCyvmkBDZ4jJWQcYm1GFz7D2WyTmYU/NMNaVTeCxquFsOjCaNWXjAEUBUDUPKsZdQtSfStGOhzFT2o+bWG3nfmcdP6+D41DMYZxFCyK2Zcw6+1Fz5ac7i7O0sv4bQay9mnBBDwEEaAfVVDFn29JWaH+wOu/sdYf+/W9jLl9NfYk/XHIPOaqVmd79PNS5gDt2n+doEpCbzlhmW+bB1093sCRnzBT7GIrGnB0TOkf0tTaH9XSM6DMNyqY9Gd7noHMw1b7t59uZYlsGIJJp/zkEahzG7EgH7el2+2U5iQ2AhukOHlZb76wNfMr0Etsy//nXGbZldEH/Xig0IpByoPt92F7kbN856bfB4RHWnVnpx70WSQnSnjGetPqNKOlejIkAAQAASURBVN3zep2cM/7fH291VKeLbl5tW+bVEvsp0xx914Co176PnbnF2bEqcHG1bZma7bmOltUnuvvPf/SMA7ZvL9vg7OGHRf+xP7+/vmXecX977QTlpl+x3XZZq1dNcFIt13ianR0by6rt2/mxc+1PPv5yZ3cZhHP7cSCMoTHSem7bBUvtzz9O+1pubYvT80q7s1PnwKoMOirm5KiuI85i1tvQ99zioB9h7W9ppWnU0QezDRtHc/NDP+V3t/6O13POYYMxnCqOPwFqhYwMEkIIkWAUv6i/kHuaTqNFB5Db85NXzPSwvHIS/2j6At8vu5nzmh7igpEbOG/ERsZlVLG9YTivHZjO9obh7N8wnLK6fGI9tO4bChfTkTGGvLKXCLRXDuCWiMFiu1nIa+HJnOO3Hnx2X8di3olOjHOthBBD2cER1uGM4y/WVi6cgzZ87kwHIoQQIqEMiYR1JC31qL+15Wbz3/M/TXPzZB7Pvp550TI2U0ip5+griRol3XghhBAJp1mn0BwdjJfvRTwoM4apfKyrHcO62jH8at0Vx5XJrOn5An79qHE0FJ5KWu0G0us29ldVxRDweHgu62Mj8WKyLjYq3tURQgxxgYNTgpxghPX+JQvwdtbhb6847jXhjI8o4/3VbA0Pj3dVhBDCVYP+Ed++ljYiaSGifuvWBQ1s+vB1oDUfzv0Ny31jqDLSmR6tYEK06tD7lNak6rCMsBZCCCFEQlM6RmvuWBqGzyTqS7V/wxE0UD1hGrvPvgR/WyW5+17tn0qKIaMTH5tiI1xJVmfQzkJjNxnYTz8hhEhMnkgEb2sbjeNGH9Uzbxg/hvqpE0mr3yyDzPrgR/lP84+ie7kotCneVRFCCFcN+oR13ibrlsTS85cAUDNjMrVTJzLpiRco8JYTUwarvaPYZ2QyKVZNUawBn46yIFJKodlMicfZnJ5CCCGEEENRbsm7aMND5eTz2XXaJyk95f1UTD6fmuJF1I+YQ+OwqdSPHkdT4QjasvPoDKUT8/lpyS9k8xU3seesiwk21DFsz1MY2sF8rkI41I6PHeYw2rB/hoEQInGNfvktqubPZtPHbkQrRcO40az6xu2kVNaQXrc+3tUb0vZErLvMq6LHj2AXQoihbNBPCZK9u4yCtZvYfdHZjHxrJduuu4TUyhpGvbUcvtVVSCk2eItIiUSYE90PQAzFem8R+zzZ8au8EEIIIUQ/y9m3hux9awiHcmnOm0B71kiaCqagPYcfrFMx9cTv9bW1MO6N58nduYWa459ZJESfRPBSP/i7G0KIfjbx0WdRWrPr6oupmzaRzswM/I3NLPzJ7yn9hP3DmUX3/tpwJn9tODPe1RBCCNcNiRbkpMdf4O0ffIm3fvQVoqFU5tx5P0bs6Cd0amXwnm8UcyL7SCXCWu8IGo2Tuy1WCCGEEGIoUkCgtZZAay2ULgestlHM68f0Bkgt9xP1B4gFgsT8AaL+AMo0yd+xEU+k5ye1CyGEEH2hgIn/fg5PR5jtN16Jr7mFhT/5PSl1DYAkrIUQQhxvSCSs0yqqGPnOKvadsZCU6lqGrd5wwnIR5WWlfwxoDUpmwhJCCCFE8lLaxBvpgEgHoVp5pocQQoj4GvfMyxS/+Aag8USi8a6OEEKIQaxPCeuDXZ+BSA1PeOolCtZvJqW6zn59kqwWQgghhBBCCCEGFbmrRwghhBO9fuhi1B9g5znXUT/m8KSI3lb796WV9G6VwcZmCtZtIf1A5aG//eGiy3q1rBPxTWqyLWN0uJcIH3/lLteW5WS/e9oG/fM1HTNL3ZvqxegYuvtF70yzLWOMb3FvhXmd7i1rCGgdbdoXGqRiIffq3tIcdG1ZTkTtw7pfedvdO857BvgrM6qwzrVleVoH9tjYONm9mG0bGd/vrs/BYTdY5d7+zdns3vbmr7Yvo6oDrq3PzTgzc5IrAaJjAzs44/zT3Hso2k1nv+PaspxoLXfvxGK0D912Y29EJrS7tqzOvIE9Nrv6WZkD+30LVsV38FXKAff23fYvjrEtM+Xnpa6tr2WMe3F27pjttmX8Ix10xB1qnOdewzFvUq1ry+qNso1FtmVGzzzg2vqyt7n3wOh583e6tiwntN+9O+A8qfZtofDwxGkvGQP8nHAt42IB8DYM3EQdJ7UmX0uUYW9WAaCVomyuomLqaUx8eBnezjDbf2DfIIw1OOvoVJ1VaFumdm6MT7/wEdtyRsRhZKX0fIJbvGiro8UsWz7FtsyIV02ysb8Nat/59g2GjJ0G/uaeyzSPc3byTt/Tf99C5TPxFrX1WCZSbp+MVqYidsC+nNfBXWbRNPv9Ygad7Ts3k9+x0fYdBH/QfgNj29Kd3QFR414Cwun+6o3G1lSeWzGnxzKGiyf9RE9aawcdMN3upanVZ1vO4+D7ZtovhkhRmP7M82oPRDK73zexkMOWj7I/fWqfw1istL8osH//cPv1ebWj77ubFzSm5lXZllm+N8O2zI1L3oWz7df36Eun2ZbRft2vSetYEBqndB8nTpKw0Sxnt0FXLPE4rJX99lY42CdOLm5nbjNgh33Mto6wLcLpFzhLgq58dJb9+kabtt+58Y90OFrf7uv78UKdVrbtBSeJNtOmzXpodQ7OiS8vtd+/Tj34+umuLUvnhm3LGIb99pmNfkdJa6+DZWkDlIN+RSzYf1PwGBFILe+5Dp059nWM4qzt19M58yAzYL+9RqdylLQ2HZw708c32pZpLM2yLQOAg4s/viZnbfxtz06wLdNRZL8PVEQdvpW5H5g+aO+hHr4GA1+Dg22eYdMBBULBMJV/7bkd0LAzG+Vge+36kQDRA6mOktYvvH2KbRkz0/5cbTQ6S6cY9faNYF+jQUeu/bIib+bblgnWQpaDevWaV6Nzu2+xqzo/ZZts2q4OLwR1ZtnHYtvl9oMPAVavsv+ODrTLlrznqNxzr9o/GTuWF8Huy2Q0eR3lQIzOfszORg2wGQDRUeCgji5emHRyDBrKnLSpALx77NvA0QwTT4t9HyVY2fcY6vUnrLRm6qNP05mVwe6Lzu5zRYQQQgghADzEuMKzlks86+nXXrtIeqZhEPX7410NIYQQQghAc51vFWd6t8W7IkLEXZ/Gcmft2UvR8jWUnL+Eke+sBBLn9gIhhBBCDDwfUT7qfZuxhnU7axQP/41Nj3OtRCJqz85ixW23Yvp8LPzz3YRq3ZtWRwghhBDiZM31lHK2bzumVpSauZSaefGukhBx0+cx9KNfW4rp89EwbrQb9RFCCCFEEstRrRSrw3MvTlXlcayNSGT1xaOJpqZa7dhiaccKIYQQIr5GG9bFc0PpQ/8WIln1ebbslqJhAGTsPYCLj3cTQgghRBKq1Jn8PbqEG7yradEBHoguineVRIIavnY9gZYW/M0tpFXZz8cuhBBCCNGfnonMptzMwsDk3dj4eFdHiLjqc8K6YexovG3thCprgJALVRJCCCFEMtuph/HTyCXg7LGxQvSKAnJ37o53NYQQQgghAGsqvOWxcfGuhhCDQp+nBGkYN5qsPWUoLQ9FEkIIIYRbJFkthBBCCCGEEMmoTwnrSDBAy/ACsnaXuVUfIYQQQgghhBBCCCGEEEmqTwnrxjGjwDAOJawn/cB+FmtPVmdfVnmU3Pc8ri3LiWXLp7i2rP3n9nlw+yFNE0zbMum73VtfvGnDvdH83hb7/WJ0DM59F+6wn9HHM7l5AGoiEplKiQ7o+nwH/AO6vmN5Wt07r6jIwI4QVtGhOyL5obdPdW1ZKhzf/RAL2Z+TvQ19npGtX8RS7eveONm+jFPv/HeWa8sKldmfq3e9L+ja+uLNaB+cbZPByMgMu7Ys5V74Jx0zMLB342YWN7i2rEjGwH7w2hffO5cjWe5tb2uHfbsua0K9a+vzFrW5tiyj0f5cbWa6106OZLq33ztyXVtUr+gcB8ddF/v0qc9kuLasgfbs23NdW5anxmdbxswY2L5dfzJT5KTslKp1r4/tbRq4NuhJ9ZhMv4f2MdmH/l89dzJoTcBspn1MNmWXeKCy52Wk7XG2cfUzHXT4mgz8tfbJhahbjYz8TpbtHmtbTDvoK/vrDarm2u+LQLX9ssK5Js3jet5GT6uBp9V+fQ3z3GvUHyvFF2FmUXmPZS6cucl2OT976UpHSes7PnDnUf/PNNsZEW2g1hOi2kjDVAZ/qzzTdjlNYWcd3C3v2sfG+IXO7kZo6rRfZ+XWfMIEeixjdCrw2u+rBQt22JYpb0u3LQNQuqfAUbneMDohtKfn73zL5IjtcjwtA3uxa6Bph+cQo6rn+AHnSVAnnfhYioOGqdIY/ZjMM8KQsr/7HdQ+wnSUtPaMabVf2bY06LTff9E0+52nHXyP3aQKnF1cXrlyom2ZQKN9QEZTNI++dJptOe233w/FMw7Yljloj+OSh3n9UfKLu39qe+22PLRdCBna1YsjTnja3GtcupW0Tt9t8N4D9klr5WBXdWaDr6HnbQyPiLDzVvvOnNGf13q1/UWVRO+AOe0sB3a7c4Eh5nc2QsdRQtVhgkX14yHbTNE0z+r5GJ252v783phvH2dOL4wYDs51WjnrIznRuC/TtkywoI3gcPtzdXifs2cwObkYGXOwqOyJ3Z8/DtJu7ahu+Fpg2LLuX28Z7uxzb3W47xpces7ViJwG2zKllbmQb9+GKR5Wa1tmz9bhYHOu9jgc2BRLi9mWMToMR0nrYSvtyxy4uRNHvfq/Oil0PG+zIvf17o8zdbMcHgQdHFPrnF7bLnPWVx1s0ncZvLlrvm05Pd7BMSjVhGjPMem0HzzQFxmP5aQ9X7K5yNGx2Uk/dfysfbZldq0fab8gh0yH3QBvm/35wHSQi9aGhjr7gk5yp94mw1HSumWSfV7Gdl19eXPTiCJC1dV4w/2X5BTJLUWHyaKNSjIwVe8729mxNmZF9qPQFJrNRFHUGGnM9u5lY3QEMQddGYVmnLea+f5S5vtL6NReftJ0Ge06viNChRBCCCGEEEIIIYRIFL1OWGuguaiI/K1bXayOSHZKawppZBT1jKKOPKyREbvJ4xU9pVdJ65xYKzMjB2hXPtb6R5KqwwyLNVMQa+broRdpNIMsj4zjnch4dsaGHfXeABEW+/cz31/CfH8pOZ42TA27ovnM8B3gWxnP86PGy4mS2CN2hRBCCCGEEEIIIYQYCL1OWMf8fnJ27iJn92436yOSnEJzCRsx0FSSwQrGoNBMpAo/UTo4+dHM6bqDNuVnrX8kEeUhrLw0GKls9+bzXt1YTvft5Gz/NsZ6avhB65VHvbfI08C3056nxfSzJjyala1jeC88mkadyrmBLVyXuoY01UGDdudWNyGEEEIIIYQQQgghklmvE9becJipzz7rZl2EwFQGz+pZ1JFKRB0Oz3V6JDEnk1ieQKknh72e7ONGZ2tl8F60mPeixaS0h8kyjn9IR0ksj282XMPWSCGxY0ZRv9o5lTc7J8noaiGEEEIIIYQQQgghXDI4H1MvklqlOv4pv71NVgOgFCY9T1bfjp/2E8xWr1Fsiozo9n2SrBZCCCGEEEIIIYQQwj3uPTJeCCGEEEIIIYQQQgghhOgDSVgLIYQQQgghhBBCCCGEGBSU1tp5YaWqgdL+q44YQoq11vkn8waJH3EMiSHRVxJDoq8khkRfSPyIvpIYEn0lMST64qTjBySGxFHkGCT6qtsYOqmEtRBCCCGEEEIIIYQQQgjRX2RKECGEEEIIIYQQQgghhBCDgiSshRBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwloIIYQQQgghhBBCCCHEoCAJayGEEEIIIYQQQgghhBCDgiSshRBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwloIIYQQQgghhBBCCCHEoCAJayGEEEIIIYQQQgghhBCDgiSshRBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwloIIYQQQgghhBBCCCHEoCAJayGEEEIIIYQQQgghhBCDgiSshRBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwloIIYQQQgghhBBCCCHEoCAJayGEEEIIIYQQQgghhBCDgiSshRBCCCGEEEIIIYQQQgwKkrAWQgghhBBCCCGEEEIIMShIwloIIYQQQgghhBBCCCHEoCAJayGEEEIIIYQQQgghhBCDgiSsu6GUel0ppY/529lKKa2U+kGcqiWGEIkh0RcSP6KvJIZEX0kMib6SGBJ9IfEj+kpiSPSVxJDoK4mh3huyCWul1BSl1B+UUhuVUo1KqbBS6oBS6lml1MeUUoFBUMcxXUHY3c9DPbz3FqXUCqVUS9f2va6Uunwg65/oEjWGlFIjlVL/Tyn1qFJqp1LK7Co7IR7bkKgSOH5OV0r9Qim1UilVrZTqVErtUUrdLTHkrgSOoTOVUv/s2q5apVRHVww9pZQ6Lx7bkagSNYZOsIxA1zZqpdS+gah3skjUGFJKfcTmPZ+Kx7YkmkSNnyPem6mU+pFSar2y+mRNXdt6p1LKN5DbkagSNYaUUiU279FKqe/GY3sSTaLGUNf7CpTVL9uolGpWVrt6tVLqa0qp9IHejkSV4DE0QSl1j1JqX9d2lSurnzZ+oLehN7zxrkBvKKW+B3wfK+G+DLgPaAGGAWcDdwO3A/PjVMVjrQP+c4K/bzxRYaXUr4CvAPuAuwA/cCPwtFLqc1rrP/ZTPZNGgsfQfOB/AA3sARqBrP6qWDJK8Ph5DMgHlgIPAFFgMfAx4Eal1AVa62X9VM+kkeAxdG7Xz3LgVaAVGA1cCVyhlPofrbV00voowWPoWP8LFLtaG5EsMfQksPYEf1/lQn2SWqLHj1JqCvASMAJ4GXge8AFjgPdh9dUi/VDPpJHgMfRbTtz/UsC3sfIwz7tUr6SVyDGklBqD1ZYuAF7HipcgcCHwC+BmpdSpWuv2fqprUkjwGJqP1RdLB14BHsRqT98IXKmUOltrvab/qtp3Qy5hrZT6NvBDYC9wg9Z6+QnKXI7ViBgs1mqtf+CkoFLqNKy67wIWaK3ru/7+S2A18Cul1DNa65J+qmvCS/QYwuqEnQms01o3KaVeB87qr4olmySIn98A/9RaHzjyj13b/RPgr8BMd6uXXJIghn52orJKqRHAe8C3lVJ/1lqXu1i/pJIEMXSIUups4EvAp4G/uFul5JVEMfQfrfW9/VCXpJbo8aOUSgWewurkn661fveY171AzPUaJpFEjyGt9W9P9Hel1EVYOZg1Wmu5cNYHiR5DwNewktU/0Fr/8OAflVIerItp5wI3AP9wu5LJIgli6G9Y57Eva61/c/CPSqklWBdB7lFKnaK11t28P+6G1JQgXVeZfoB1NfvSEwUUgNb6GeDiE7x/kVLq30qpiq7h8HuVdUtXUX/W+yQdvEXxJweT1QBdCeo/AQHg1jjUKyEkQwxprfdprd/SWjfFuy6JJkni5+fHJqu7/BxoB2YopXIHuFoJI0liqKObv+/HGrlvAOMGtFIJJBli6CClVAZwL/CK1vqOOFcnYSRTDAn3JUn8fAqYCHzr2GQ1gNY6Opg7+INdksRQdz7Z9fvOuNZiiEuSGDrYVn7qyD9qrWPAs13/zR/QGiWQRI8hpdQ4YBZQBfzuyNe01m8DzwCzgTMGvnbODbUR1rdi3Yr1kNa6x1tItdadR/5fKfVRrJGBnVhf+r1YDZGPY92ifKrWuqxfag1FSqnbgFygFlimtV7fTdlzu36/cILXnge+21Xm+67XMjkkQwyJ/pPM8aOxpgcBGVXUF0kbQ0qpAmARVv23uV/FpJFMMfR7IBtrSiLhnmSKoTlKqS9i3Ua9H3hNay3zoPdNMsTPB7DaPQ91JTUuwZreoQx4QWtd2091TBbJEEPHUUoNA67Amm7gX/1TxaSRDDG0CStRehlwaNoGpZSBdUwysaZ7EL2T6DFU2PW7RGttnuD13V2/zwPedL+a7hhqCeslXb9fOZk3KaUmAXcAJcBZXaO8Dr52HtYtFb8DrnGnmse5oOvnyDq9DtxyZCArpUJY86S1dHOr9I6u35P6qZ7JIKFjSPS7ZI6fG7BuKXpXa93gau2SS9LEkLLmTbscq60xEquTlgl8Tmtd00/1TAZJEUNKqWuAW4CPy3nOdUkRQ12+cMz/Y0qpu4Evdnc3iLCV0PGjrIcpzgaqgU9gzaF/ZJ+5VSn1ea313/upnskgoWOoBx/FSpDdq7Vudr96SSUZYugXWO3oHyulzsGaVs+PNYd1IVb7aFDPPzzIJXoMHexrFSul1AnuCjo4gn9yv9TSJUNqShBgeNfvkx0ZcTvWyeELRwYUgNb6FayrIlco95+02gb8GJiHNUIoG2su4dewJnB/pStJfVBm1+/GbpZ38O9ZLtczmSR6DIn+lZTxo5QaC/wBa4T1l12uY7JJphiaj3U30P/DSjz6gFu11jIPcd8kfAx1jUL7K/C81vpvLtdHJEEMYT10+nNYHbEQUIT1oLwS4DZAko29l+jxk4OVoM4Fftr13lFAHtboOQ3crZQ6F9FbiR5Dx1FKKaz4Aev8Jvom4WNIa10FnAo8gXWH/VeBz2Od1x7Behis6L2EjiGt9XasAa/DsOLmEGU9N+/yrv9mu1xPVw21Eda9tbjr91lKqQUneL0A8GCNXF7t1kq7DjLfO+bPbyqlLgTexro1+uMcM6eMGJQkhkRfDNn46ZrG4XmsOdI+o7Ve5lb9xEkZcjGkrTmH71BKBYGxWHOC/kMpdbrW+lPHlhf9bijF0F1YbdSPIwaTIRNDWus3gDeOKN8GPKqUehdYB9yklPq51nqdW/UUtoZK/Bwc0OUB7tRa/+iI9/1NWQ9k/D3wDeR2/IE2VGLoRM7HGtH4npaHLcbTkImhrumIngJSgEuBd4BU4Crg18BVSqnFWus9btVTODJkYgir7/U88FtlPTxyLdYF2GuBDcAcrKllBq2hlrAuB6ZiTZtxMg4+IOxrNuXSTrpGvaC1jnbdjrgIOJPDQXVwBHXmCd94+O8N/Ve7hJfoMST6V1LFT1ey+lWsK/lf0Fr/eSDql+CSKoa6ynYAW4AvKKUCwG1KqZe11v8eiLomoISOIaXUh7Gmj7lFn/gBsKLvEjqGbN6zVyn1HPDBrvdIwvrkJXr8HHmn6xMneOsTWAnrhf1bw4SW6DF0Igcftiijq92RDDF0LzATmH3EHMVN/H/27jtMsqJc/Pi3TqfpyTlszjnvwu6y5CQgQUAMoBLELCpeverV+zN7DdfsFVGQpAICooBKjsuysJHNeTbMTs6p86nfHz27bJo5Nbs90zPd7+d5+pndmeo61edU16nznjpVcGfPYJBfEH+S8abBKGsKSvk6pLV+USm1BPhGz9/OIT539VeIr+vxMPFFGYes4TYlyPKenxf0832HA8Faa9XH65U+c0mshp6fRw7b7yJecbKVUhUneM/knp87BrhsqSyl65AYcGlTf3raoJeBGcRHVv9qkMqV6tKmDvXi3z0/z01sUdJKqtehBT0/71NK6SNfPb8fecTv8getpKkl1evQQLxHvCOl64/Wupv4Alpw4kFCLT0//QNXrJSX0nXoWD0DQK5CFltMpJSuQz3TSZwDNOsTL6j3Us/PhQNctlSW0nXoEK31Oq31tVrrEq21V2s9TWv9c2BWT5JVg1bKkzDcAtb3ABHgWqXUjL4S9oziOmRlz8+zBqpgJ2FJz889x/z+0KNll5zgPZcek0b0XzrUITFw0qL+KKVGEX+UehrwSRlZnVBpUYf6cGgUQzTBZUknqV6H3gDu7uUF8akdDv3/qFXbhbFUr0NOFp/Ee8Q70qH+HJobdhbHO/Q7eQz/5KVDHTrSzcTnvH1Qy2KLiZLqdcjb8zNXKeXleCU9P8MDVqrUl+p1qFc9iwt/kPjnH9JPvA6rgLXWei/wLeJf4H8qpRadKJ1S6hLeGcUF8BviB+PnPat6Hpveq5RKeIVTSi1QSh23j3tWD729579/OubPv+v5+XWlVMER7xkHfIb4xdk9iS5rukiTOiQGSDrUH6XUWOBVYCJwi9ZaHl1MoDSpQyd8TFopNRH4r57//jOR5UwnqV6HtNYPa61vPdGrJ0nLEb8LJLq86SDV61DP3477TEopSyn1NeLzTzYCTye6rOkgHeoP8H/E5/X8qlKq5Ij3ZADf7/nvg4kua7pIkzp0KM2Riy3emeiypatUr0Na6ybi0+m5gf8+5j0ZxKd4AHgh0WVNF6leh3r+lqWUch3zOzfxaa0mAT/TWtcmuqyJNNzmsEZr/YOenfxNYJVSagWwmvgjNmXE52aZ3PO7Q+/ZppS6hfiK4JuVUk8Tn1bDA4whfnekgfhowkT6GTC5p4yHVh+dQ3yVV4D/1lqvOObzrVBK/Qz4IrBBKfUo8S/R+4mvWn1bz5dLnKRUr0MASql7j/jvoTL9SCl16K7+XVrr5Yh+S4P68zIwjvgiEeOUUt86Qb73Sjt08tKgDj2rlKoH1hF/rNpN/AbIJT3//rXW+rkElzOtpEEdEgMsDerQKqXUJuJzVB8kvg7MMuKjY7uBG7TW7QkuZ9pI9fqjtV6jlPo28G1gk1LqCSAIvKvnc60AfpzgcqaVVK9DRzifeGBordY6YQuwibSoQ58jPsDjG0qpi4i3O37iT92PBXYBP0pwOdNKGtSh84C7lFLP97wnm/j12ETiI6v/m6FOaz0sX8QnSP81sIn45PNh4hOn/xv4KOA7wXtmE5+8fh/xkcrNPe+/Ezj/mLQvx3fPUb87F9DAtwzL+FHgKWAv8UofAvYTn9z8LIf33kR8PpkuoIP44/mXJ3u/p9IrletQzzb6et2U7P0/3F+pWn8M6o4Gzk32/k+FVwrXoc/1vGcf8cDQofc8Arwr2fs9lV6pWof6yEsDVcne76n0StU6BPyEeN+5mnigsRvYRnxk1IRk7/dUeaVq/TnivdcQf+qsvacebQa+fqLPJS+pQ7289+GebX0i2fs6VV+pXIeIByQf6EkbBgI97dAPgPxk7/tUeaVqHQKmAI8RH0AUIr4Gw0vEF55Wyd7vJi/V80GEEEIIIYQQQgghhBBCiKQaVnNYCyGEEEIIIYQQQgghhEhdErAWQgghhBBCCCGEEEIIMSRIwFoIIYQQQgghhBBCCCHEkCABayGEEEIIIYQQQgghhBBDgrs/iV3ZWdpdWHhqW7QMF3m01altJ52Y7FLT3Wl4eMJVVY1a6xLDXAHw5ft1ZnlOn2m6u33OGSnDQprcjokN0XpmUCwVdU6jXYbbcxnsU8N9ZXljRumCu2v6XYeM2iCT+mHSvphWDZN0Q3VtW5P2OIFtsbITlhUAoYP9b4ec6pBpGVWGcz23Q4ZfwATtYitsls72GiQyrLMm+0t7nDNzeczajVjYudtiuh8AgrX9r0PFxcV63Lhx/XmLSFFr1qw5uTaoqO/z2Li8Bsd89rYVm21QD8F+jum1gEE6n/OuIlRgNj7H53duPELdJg0ouAzboUD9SZzHMrO0J7/vOqRNrvASef0wnBnsB39WyCirXHfQMU1dW55zRv3Y7+EDie8LDVkGbYKKmu08bdIsJLKfbJDMMqtmRtd3ni6zdraz7WC/6w+AKydLu4sLek8wVK+xB5vJNbbprjLoc6tI4q5xjb4jnFwb5PZnaW9O321QLMM5n/zsLqPtWQbxgeb2bMc0LoPrP4CY6TWgAZOYj6+u2zFNcGSm0fYyGpw3GCoyCyMnog71K2DtLiyk4itf6M9bjuc1iwZYgaE3+Nt0hyc6KOO4PYMTs3Yn9kZB5e3/sc8sw3dkludw7t3X9Znm7TUTHPOxMwx3sEE6q7VfX4E+2QbtkmXWxmF7nY+Xt9l5g9Fss31l50cc01itHqO8ssa1G6XbdNV3+l2H3IWFjPzSF/pMY1I/rG6Tg2X2nbF9zums0NDstNl+g32VwLbY1eWcl2k7C7D7q19MeB0yKSOAe5pzPQ/t6/sG3WGmwRsHWfvMyt411vm4G3V4AVfQOV14hHP7Ulhm1m407813TJO137yTuOVH/a9D48aNY/Xq1f19m0hBSqn+t0FFhVR85fN9prnjsj845nPLs7cabc8KDr3+tJ1j1hly+Z0vmsb9zjmfymsMBkMA42cfdM5r/SijvHL2mrWhG37V/zbIk1/IuE98sc804QKDdj5scP1g0B8d9gwCazMXVRpldWHJVsc0v3rqMsc0/dnvlZ//0sn1hf7j9t4TmA4OGmSxbOe2w1tndr0SzXH+jphcU7i6zdpYk+uF7N1m/ZeIc1yN8lUGUS7g1af+s9/1B8BdXEDFtz/b699NrhuHamwlkUyusZXhdYAOOMctvPXOaUziDGBWZ+Hk2iBvTiFT3tf3eax9ivOBv+rsVUbb81nO34e/vnCGY5qcyS1G2+vYk2+UzoS32fmLMvYn6xzT7PzSXKPtTb2j0Tmvm0uN8jKN2/VVh4ZeL1YIIYQQQgghhBBCCCFEWpKAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCDCVaMz7SSIb9zuPESmvGRJux9DB+PnqAtY0aQeOUSVQtWjBkl48QqenDmW8wlkZ6mxQ7hwDTqR7cQgkhRBrwE2aMajJKm08Xy6ydA1yiwRXN8LHrhquJeU88Fc/BC88i5vL3O9+aRXPoLsw//P9wdhZb3ncFUU/WyRa13xI3ga8QQgghhBDilPl1hNGxVkbHWtjpLqXOlcOsSA3FdhcBZTZHa7rRwM5LLqJ91EhULEb+/gNk1xusyijEKfKrMGdl7KSCdg6Sz+tMpIb8w38vpoOrWI8LmzxPN20Rs8WvhBBCOPuQZyXlVhvfD70bu48xuZNUHR90v4WFZoM9ig76H8QdihoXzmHP9VfTsGQBc/7n/8iqrj38t71XX8KOW68nr/4tCmtfM84z4s9gy/uvwh0MsujX91A/Zzq7LzufmNdDSWUrOc3bB+KjHEdGWAshhBBCCDGEBCwvb/nG0mFlMD1axxmhSorsLra5S2lwGS7ommYUMPuhRynZup1Zf/2bBKvFoAloL59uvoGXmEo+3byPNVzJeorpYCQtvJe1aBSPslCC1UIIkWBvxCZQqLqZafX2FIvmbGs7t7iX06Ez+E3kvJQJVgOUv76K+d/8X4LFRaz85bepPWsx8E6wuuy1NymoXd6vPD2BIIt+/UcimX5e++btbL/2Mgp27WXZd385aMFqkBHWQgghhBBCDDlB5WGdZxSjYq2MibawyVMhwWoHvs4uZj/8WELyylZBrsjcwBPdc+nSvoTkKVJXFBcbGMUWKpjHARayj+t5CxtFG37+znw6yEh2MYUQIuVstkfQZGdxtnsHG8Ojjvqbjwg3uN9ktnWQt2OjeCy2kHAKhkFLVm9g6W3f4O2vfoYNX/0MBy49j5a5Myh77U1m//gOdn9/dr/zzNt/kNN+eRd7LjmP0a+9RfHWQ1OplCa28H1IvSMlhBBCCCFEKlCKKncBVe6CZJck7Xwi9zUuy9zEKHcLP2l7V7KLI4aJKC5WM46NjGQB+ymgmxeZRhCZykcIIQaCxmJ5bBJXed5mhGqhWsf7TCWqnVs8r1Oq2vlndDav2ZOJP4+VmjIamzntKz9g503Xse+ayw4Hqy375Nc+ydtfzfzf/zmBpewfCVgLIYQQQgghRI/pnhouy9xETTSXSzK38EpwCm+Fxie7WGIYCeHhDSYmuxhCCJEW3oxN4BL3Js5y7eTh6OnMsg5yvedNYljcHT2L3XrwRgUnkxWLMfXuhxjzxHNkNDaj9PBegnrw57AOD99ps9UQXZRdu50roYqmzp0kK5i4OmTnRxOWl9H2XInLK1wYc0zj7kzkvookLK9hwU7cd8b2Dd8The0f3IYv2e1sLCtxBfCN7UhYXia6xiau7NozuHW2uS43YXl1jXFuG4UY7v548V3JLsJJszoS2BkyMP5voX6lt7D5fN6LNMSy+XTj9eyLFHJ73vNkqRDj51UNUCmHJhVOneuHU7F59eDerEj6ftfD97iHyxJ3vWJyzRnLTFzfq3Ni4vovtacld1yiyXVjsvv8Q4VO4DVnuNQ5tmElu31JoH+8etrhfwfwsjo2jgWu/VzpXs9Hvctp0Nn8NHRRwoLVHTuHz9Nu/oamo4LVk7/2dsLynnxPfcLyctLvlsxKRDsacG78fQ3OabRh6V3dzmkCI81aTKOGNebcCMRyzQKl+WXOAY+OPfmOQWtXtwUGjVOkImxUrpPR3e3j7TUTEpKXUdA6gYFtEwn5bhzKy/BEEs3uu0LOXlBplM/bu0Y7J3Jp7ALnzkfX3sQFnk7EKehvVDcs52CcFbAwemTINrhhZNgh+893/8MxzY/+fZVzRgafD0C7nNN5Gs0eYbUznD+kSTA4lj2wwcbMzBDzF+3u9e+bXphslE+gw3keSqvVbXQscie2Om9vTaFjmki+PehB63Cp8znDanGuQ7FMm6bqPMd0GU3Oga5Ink1ghFwFiaHJ0wnlr/d9bvnShk865tO8OAImN5aCpiXrW2aVWZ+qc7LBxXLAMgpaq0bnjv6ujzhvz9PgwQo4JuOZ6U/EtxtqwxVoJJZZxiNFz0HUj6uzmb+PeYBpf/m20cVT6dX7DVIBvzJLdiTthnDBqbdx2utcf7RhV9okvplhcG0HEC4c5BvlBl8jz7hOdjaUOKbbvG6cc2YG+93daXbddkpMPvgQ4+o0u9ll0t807Zu7uvuutwUbzep1Rotz/7bmbEX3KOeCeVuct5m3WxMsGMCbgzGF1Xrq09yYHAd3u/PnjeYOzX6f1ex1TDP/9F1Gea1bNckxjYpAzGGgVPa0FqPtdW0duOBsZlGA+Tdu6DPN68/Mccxn6cWbaA5nHf7/U9E5LMvezXnu7bwansz9waVEcPPayhmOeWUdcG5zO8fbtFfmO6YzCSGYNsEm58Sd/zPXMc24JyOMe9I5lrP9U8VG5QKD71wCbsbIlCBCCDFEjdQtjKOJNxlPVA3uiDQhhBAi7dhRrEAzttuP9vRcBLsz0L58rFArZ5TuYEX9lOSWUQghhBDHqbYL+GtwIW06k+WRSaTyfNXpYvjOzyGEEClshG7hEjYxi2ouZROWHpojB4a7sa5GzvVuS3YxhBBCDAFWsBmwsf3FoN650LUzCtCWh+8tfBi/q39TjAghhBBicPwzPJflkdReXDGdSMBaCCGGoDG04Cb+rFAZ7fhJsznEB4FC87O8R7jAJwFrIYQQoGIhQMGxixRpDUpR7m+j1N+elLIJIYQQQiTK3mVnsPPCC5JdjD5JwFoIIYagVYxjH4UEcPM80+lSvmQXKeVoFF9vfw8PBk5PdlGEEEIMAbHMclAuXF3VEO0ZSR2L4Oo8CLEIn3njZvZ1Os9lLIQQQggxlDVMn0r9jGnJLkafZA5rIYQYgmLK4mlmJbsYKW9btCLZRRBCCDFUuDzEskfg6qzG1VWN7S/GCjQBmlh2BS/VzEx2CYUQQgghTokGAvn5xHw+Ym43rqjzItbJICOshRBCCCGEEAIOB63BwtVdDxD/v9uf3HIJIYQQQiRAJCuTmC/+BHcwPz+5helDyo2w7sofjRWL4O+oTXZRhBApRisLjcLSsWQXRQghhBAD5VDQWttgWWB5kl0iIYQQQoiE6C4oOPzvQEE+WY2NSSxN74b1CGt1xKj1sD+fqllXUTX3vRyYdx2dRRP6lZf/4ODuCld74u4V5ExodUwTy7QTtj0xfGxcOz5xmcXSa6Vd23/0d8Z2eTk44/3sm/8xOoqmont534nowW5p7cQdq0jx4C726Op0Der2jjXrgp0Jy8vOH9xHqzyt71Q0j4pySekG7p5/F/ct+D3vH7mSPHf3oJanP1zdifuSeNqGdddGCCOFbw5uALV7VOL6kceeXwdapOQkz2MuD7h9RwWrt9z6fwkq1fCgjjlUOa4Av5tzL/fO+wO5/TynBEuG77VIZG/2oG4vmj1891W6aZmduGNV8Wp/ri761jYxva7b3O3Dt++37q1JCctLG3QNOrcVOCcaJt549uSmz8xxB5ibtw/6dUUP2ZWJq2d6kL+ie684unIEjwxYp8wIa4+NKgv2+udYs/OiYK6A2UEOljk3/rk7LGJuL3XTFtM0aT4qFqV842u0jZxM9YzLGfPmP8mr2U3bopDzBjudd4WvySyQEslzLvu7z1xrlFdtMNcxzZrVzo1c/qQWo+11dg/gwm5KY2f0vW+s4OA2AsogCGuFzVoTp8/WH3aB88WVspwbWNXkNQpae0c6X3TE9mY5pgGwvYnrbJ2I5TC42ei4GwR0p/5k7+F/xzweVv/npwhnlJB9sIb6SZehO8Yw456/0rUw3zGv7nKzOvSjZ650TGN7nPev0z46xNXm3O5ZEbOym9wUUy6Dsne4BjRoHYy62Vpf2uvfu5ozYaTz98/V7NwjLJtRD+XOZfL/JN8xTe1n2hzT3LfgXnx2hJJoJ8XRTjzYhJULG8VZxTv4/sxHabf8vBqdzE7KCPfRBbjnbxc5FxyYvWi/Y5q1laMd08wYXWO0va2d4xzTuEd1pd7jYyJlRDOgeXrffZ1ornN7Ov7xMAXbnbdXebVzezryJee22V8bcN4YkHWV8xOOG5ebXZxbEzsd01w5YZtjmn/tmIke63wDcc5vPuOYJprhmASA3RtGmSU8GQps96n3tayCsGOae5bee/jfGXaYWZEa/DoMKFac9z02ekcQUh6+8YWPOebVMdqsZZ558W7HNOtWT3RMY3rzMpxv0H8vCBPqdj7v501sdUzTvjvfMY2dGyXsfAl40lQUvM297x/Tmwum/U0nxWvN+pqtk53TmVyHw/E3Y07E5JpCW9A0zzkzy+Cac+LDASY+7LzN1qmZjmma5mkaFjnnxQMGaU5AeWzcI3q/foxWOV83etrNjrvLuali7MV7jfLa88o4xzSmdciIwfW6f2wH2xp6vzY5TDnnFcty/lK6ulx07Ml33p5v4K7pO7r8vPKGQ7DZoC/kqgiwYp9zrOOG85Yf/vcIWnm/+y0KVTcH7AJetqeyQ5dx/5vLHPMxOARxBrEGK5TAiLVB+zLq5RjRzHf6hJ2lhWDbWNEoXSWFh//mGdXlmFf4oGFcKOfUB28N22s6DTSPnUntzGVEfZkU7tvAWdWPsrR0Ew3VBfxOf4d9i9/NmLf+jWJTsosrhBimbJeL9Z+/hZapE5j72/spf3Md+y4+h53XvZvlP/ovRq5fTsmODaTXOAYxlHhVlItytjI1WEuuHUIDrS4/De5s2qz4nKuZOkxhtJvCWBdXWhuIaItdlLJVV7CbEqIkd2S7EGJ46S4qoGbuLDyBIGPeWJXs4ogBlmcHmBmuBmCDZyQKmBmpYV6oio3eEcktnBAprH76FGI+H2Ubt2DFZEpCIU6e5jRrL5dZG+nEx7OxGZxm7eXD7pUctPOpLszn+eYZkCZX9cH8fDI62nGFQjKHdaIF/RU0V5xPeXaIj0d/y6Xhv3HGnE0ULunkjXVLeHnLNH5rfY67/bfw6umXUdwcJavbeQSGEEIcSSvFhk9+iIZ5M5l590NkvNLMnvCFFD6xk2Vrf8jmj36A/UsvpHn8VMateI6MjtZkF1mkAE287lm679v4E70NXJe/hivzNpDvChDUbqo8+TS6sohY8dN71poQuSuDtC/JoGphAVU6n61dI5ihaphODdOtWkLaxXbKeV5PJ4TM0yrEcHVw4Tz8La0U7tk7IPmHM/3UzZlJzfzZtI15ZwRxVmMTRTv3DMg2RfKVRduYEq0nqDxs9IzAuz5G7soAO08vYcKsRuaFq5g9tpKNR4xyax4/gZo58yjfuIHCPbvS5PJfiMQ6uGg+W69+NwA7Lzmf0W+sZtRba5JcquFEky7BR9E3L1GudK1nrlXFDruMR2MLCeDldXsS89QBznFt5+4Z97G5cwS/PHAhzzbNQA/v2ZMdBfPyyWhtxRUO0V1UnOzi9GrYBayj7mxqJ3yAMa4D7CqeiMeKUd+Vy4oDU3ns1cu4/1ffQMdc+LwhnvvjhXy0cDQ7iq4kI7gXl937dCZCCHGsmiXzqV26kCkPP0H209WsavostnZhqRin8RsW/fD/2Papy6k67Ry2XfZB5j18R7KLLFLAgcWnU3nu2RRv286I9RvI37fvuDSzMg7y4Ni7sVE83zGdR1sX8Mmpr4B6p2OetSbE1OvrsCKaCo9i+1/K6Fro4yAFHNQFPM80xuhmZqga5qkqYlg8rU9uLjghRHIFc3PZfvmlAJz/7f8ZkG2svO1jhPLzsCIRJj39ImUbt7D64x9hz3lnScA6RWXZIaZF62lXGWz0jiBzXZg5NxzECmtsr2LrA2VMntXI/95yN5d9+9vEbBfN48az5aprsaIRWsZPZOzrrzJ61ZvJ/ihCDCuB/Dy2Xv1u8vYdYPzLy9n5rgvYffF5NE2ewKTXHkt28YY8NzG+m/8P9kaLubPz7GQXRyTZxdZm5lpVrIhN5Gl7FrrnRoaNxVo9lvXR0XTv9fG9iX/j99Pv57ZtH+SJxvlJLvXACuXkkndgP+5QiJZxOckuTq+GXcDaFe0kr3EVB4vn83LoHC7IeIkfvHoNL1XOoX71adgxN2iLcMTL0ysvYe8108js2oolwWohRD+5g/FJ0/J37KE5PBlbuwAXtobm8GQKfHsp3rWJmjmn4+vsSG5hRcponjAeKxKheeJE6mfNJKOllRzfGvLC6/HoeD27veQF2mJ+rt77SRqi8U7GJ9WrR+WTuzKIFdGoGFhoclcG6Vr4zjoFGot9FLNPF1NMJ4U4z1kmhBiafO3tzH7wEZQ9cHNOTnvyGXZddC5d5aVUnT6fUG42obxcyt+WqfdSVUB56FJefDq+tkPeygBWWKNsUBFN/psBPLOiLN82l5jtQgN7l51NRksL8/9yHzsuvoz9i8+geOcOQPpJQpjytbeTu7+KjhEV1MybTXdJMd6ODsa9ukIGDRu4IetN5nmrmOet4qXgFHZEDRaVESlrnR7DXH2AaVYNK+yJtHH0PPCldLCsfB0+K8YLzdN4tXVKkko6eHJqDtIydhyuaJTcGrO1hJJh2I1zV0BB3XLKdj/E9Xvv5M3IYn70rr8wf+JBskZWoVwxUDF83jAN80rx1VRR3PRPadeFEP2Wt3svAG0Tx1Ho3YmlYkAMS8Uo9O4EoH3EWMI5+ZTs2JC8goqUoYGOinJKtm3njF/9hhl/f4KMtjYa/BewK/d2DmRdz5zcKEuzKrmz6azDweoTaV+Sge1RaBfYHkX7kt5XC+vGix/nxSaFEEOTAkp27KJ4l/OCdSerdMt2lv7qTubd9xC+jk4OnHE6AONefWPAtimSy1YWWz3leLCZGqmjbXEGtldhu0B7FAULu4ni4uf/eA8ADVOn011Sytg3luOKRJj40vNYsSi7LriIgV2SW4jUYtmaWY/+A9vjpm7uLEasXc/SX9xJ8Y6Ba+NTxXR3DddlruGl4BSaY5l8PPs1kBYorR3UBdwXOwM/YT7qXk5+zyAdNzEusjbzSffLjPS18Jlt13PLlptpjZotKjiclW3eRDQzk1BuLqVbNie7OL0adiOsD/EGGyh66Slurf4KD531DX590Z1cVzAVrf7GrIwIX770Dm7N+F/GvvJPOhYkcKVXIUTa8LV34q9vonXSOMb7XuS0ot/QHJ5MoXcnBb69ADRMmYM72E3+/l3JLaxICcH8fKJ+P7nVNbiiUco2b6Fs8xb23+an1TufNu9cbi9+jgOxkfwm+GWyeRMXJ14+vWuhj+1/KTs8h/WRo6uPFcBLBW0D9bGEEClCaSjZtpPibTvpLCslu65eBoWkuC7Lxx53EZOijTTPzWLDn0eStzJAxmkRRsxuZ7OngrbuLGzLYv/SZWTV11G8I752kLe7i3HLX2X3BRfTUjuDwv1bkvxphBg+MptaOP+/f0AoNwd/q/TRTGSoMF/Oe4YGO4ffdJzHmb5d3J77Amf7dvJqKPVHzYreVelC7o0t4ybXCj7qXs5Lsamc7dpJkepijT2Gm9feQls00zmjFFGwb+/hfxfv2pG8gjgYdiOsj6TQuLdX8pm/3UhTJJ8/LfoauZ+bwt1f/QJNE/Nwv7YGy5bVdIUQJy9v917aJo4FoMC3l4k5zx0OVgfzc2kdPZGiXZulrREJ0V4Rf2Qxp6b2qN977RZKgy/ycftTLPa+xY9aP0G19zzqMi/rM7+uhT5qPpPXZ7AaIICnZ4S1jEARQjhTQI4Eq9PGQVc+zVYmE6MNROe5aP5kFuWz26m3sml0ZQNQN3M2wfwCxq547ah6Ub7xbXKqD1I952yiXn9yPoAQw5Rl2xKs7oePZS+nzGrnf9svotGu4F+BheyOFHNL9ut4iSa7eCLJqnUB90SX4SfM1e71APwxuoy/xxakVbAa4m3Lkt/+iqW//RWuyNB9ynZYB6wPaWt285lHPoIdtllXvIBiq4l/vDYJV3To7nghxPCQv2sfwaICgvm5x/3t4NlLwLIo2bExCSUTqahjRAVWNEpWQ8Nxf7Ow+XzxC+wNF/JKQ4Ti0Gu0eefR6Z58ytsNaA9uZeNBbrwIIYQ4hlJs95QRw2J6pIbpkVqiuNjpKQUg5nZzYPEZ5B6somBv5dFvBSY9/wy2x0v1HFn8TAgxME7zVnKZfxOPdS/kqfCHeE1/neX6q/yi4yrKXB1ck7ku2UUUQ0AN+fwqeiG/jpzPb6LnU6lLkl2kpPGEQrhDoWQXo0/9mxIkYqHrep8D09LO4yy022z0lqs04JjGN6n78L8bgM83XcODI+9mT7iYTTOz8M2MX/BbzdmOedkGQ0QieYmbWuSfyxeYJYwZFMzlvE9bdxWYbW8gWUCGQzAk4HLOR5nVIWVwUN2dzmlC5WZ3Y5XPOdBjtXiM8jJJ5x7Z7Zgmc6JzGoC2PfmOaVyG1V9FkzveyqR6eJudy1h3+XgA7KL4dAv73n86+QffmTdOK8W+d59FRtc+OmY297mUkAqb7RPtdS68FXLOy3R7sUzng+ptN/hOAla98+nE9jh/Pts3sCN87bCL4P7e530u2Gl2H7d9svO+q9tm1gGqyH/n322jR5DZWE8kN77A5yGh3V6uGrmGKRn1fG7th+iuySdHradt+kyqvVcyeud9zFlsVvYft4497ncFvi7Oy9rB7vZSGu0corlmX/h1qyc6pjFpi8MjzeoZlnP9mF5eZ5YXsNM4pRCJoV04fr+KJjc55rP7xjyj7V0ye71jmtf3O/dJD1zZ91Mah5zjcV7kfPzi/UZ57d4wyjHNP6udy256ThzzZPNxv9Mcvb5Z0w/Nbup1LR+4C2CPL0rFpMY+09Rud95+1irn0c43tn78qP9fWLSZu+bcC8AnNn6EZxpnA+AdPZ1wdjbz/vAXsve0Hr+t3a3kn7ealrGLyezYSmZb73VgzebxjuUiz7lvbnd7nfMBRr3gfL47eL5ZXu1Nzt8TO9e57L4DZts7WdoN4cLeP7c1yPeum6ebfUfdBpc1KoEzgdp+58xc3WZ9L3e7c7rqs8zmzQ2McC5X5oGBHZeoIxbR6t5HpGY0OB/TYJnZwYoYxJjqNxdx2xn3sLVzJLfW/oX27Cn423cT9pfx2+ivucTewHvz1/B/FRdQH3Y4fxpcr1hdieu3Bvb1fl1yVFYG14D+GucYQrdB/QHIHDNwC+V6/RFGzaztM03wgQrHfBoXmD2180BwsWMa5XHeL1Zb4mZUTmR8wCQeGM4xq7NTSo4fNHWszVVmbZWn+dT3V0qMsD5kd6SUJXu/wgeqP4YsnyuESAR/Sz0qFqOr6OiTZnv5WMJZeWS3vp2kkolUo5Wis6SM7PrjA64eFeXzk59hc9sI/lUzFwClY5TsfZaYJ4umUac2aq3Djt+MzlZD+y67EEIMlvqZU3jl21+mabJBADVNPN80kw+vv5UPrf/Y4WC1bfmovPBsijdvp2DPvl7fW1j1Jp5AC/UTL8C2DIM9QgjhSPO9GY+S5wlwfddjdPjHUXzgGcr2/p2KXQ9ixYJ8PnY/bsvmyxOfTnZhhRD9kFIBawA79T6SECKJLDuGv7WB7qLyo37fNHE27mAXmZ2y2KJIjEB+AbbXS3b98SMOrhv9FmOzmvjZ9svQPee54N4KAk+OJuu17XSUzOHFrjNOetudOh6wzlHOoyOFECLVdZaVsOEj1xHKz2XDje8jmGs2Ai4dvNYyleUt7yxe1lZ0GtGsTCY/+dzh37V2j2ZPw9m0do8+/DvLjlG6+wUi/nyaRzmPdhNCCBNXjVzPpWUb+e+u77G1awwjdz5ATssmxr4Os37l4Yx7/8SBrgJ+0X0711WsZlZOVbKLLIQwJNFdIYRwkNlUS3dhGRFf/LGjjtJRtI2YQNGezSgS+OyhSGudJWUAZDYd/ai32xXls5OfY03zOF5umAbEg9U1d76XlqeX0f29SbjWtfPpuh8Q1Sc3ai2o448Q5lgSsBZCpDfbslj3sRtwhSMs/O29xLxeNn7o2mQXa0iKuTLoKFxI2bqN5B6sAeLB6lWVt7Cz7kJWVd5yVNA6s+0A2Q3baBm5iHBGfpJKLYRIFXn+KN+a8Q9eD5/BXXuWUbHrITzhVsa8Dm/99VM8t+1DrHrooyx54CF+WvcR6mMlfHXai8kuthDCkASshRDCQcG+bWhlsfmKW9n87pvZdf51eAMdFO+U6UBE4vjbWsG22XvWecQ878xBZylNxHYxLquRcZnxYHZg9yh01AXaQsdc2Jv8KDSxfgasfUSY6znAp7JeJqxd7I8VJvIjCSHEsBPJzqS7pIjxLy6nePtuRr65ltbxY5JdrCHKQtlhmqZOomlqfE2D5q7x2Dq+DoOtXTR3xadU0UBb2Sy6Cidg2RFQMn2jEOLUuC1FVHuY6NrFfHv54YFE/g1FhPESw00YD5nr81iol5NrtWMjUxIJMVxIwFoIIRxkN9Uw5fmHyOhoJubNoGLD60z/1314A53JLppIITl1NUx57p+0l4/gzY9/jr1nnE3D5Gm0ZZdy41sfBzT3Lv49pb42/BOrUO4YWDZ4FNasIM+MvgGfFe57I1oz3V3Ndf5VfDvnH9xbcA/fyPknZa52ftRxCVUSsBZCGNP4rTDFng7GZjQyI7Oaya5aZruqWOSu5CzPDi70bOFCzxZcDPIqbqfA29GFikYJZ8cXFYp5PXi7zBaxTjeuWDcVlX8mo6WNNZ+6kQNnLKIwqxJLxYAYlopRmFVJODuTmmlXUj/pIjI6ahmz7gG8gZZkF18IMcw1dbm4ds0XiWg3j879ITNHxRc1DcxpwksYFxG8RPCeE+AvE77G/nAFt617T3ILLYQwlrhlLoUQIoVltjYw9Zk/g1IobbBarxAnoXjXDrxdXVQtPJ2a2fPR7vhpWsXCXFV3Jk+PfB93L72f6zz/SfgLL9HUdB7WrCAjXQ8xxlN9fIZao2JhrFgAKxpERYN8J3cvtlbsiRXzVHAOGyMj2RYtJ4zzyuJCCKGwubhwC58b9QIzs07Q7pyABl6IzBjYgiWI0pqM1nYCBfkAhLOy8HR2JbdQQ5g72s7iX/yet296P1s+eDXjSl5j0YP30NI1jsKsSiKL/Lx+w+eIZPsprnyZ/Op1yNhqIUSi7G/x876Vn+Te0+/jr9O/xS3+77ASi9O5A/+GIjgzxG9u+wFB28vNa66nLZqV7CILIQxJwFoIIQwpAAlWiwGWW3OQGU89jm1ZBAoK6Sopo352Gasz53NNy6M8VfQe7lj6IO+a+gyuUBcjtj+CO9IRD07b4Z4AdQgVi/9bEa+ztuUh5s3hp01L2RodQZf2JfmTCiGGE4XNpYWbuG3UC0zPqmV3oJgf738X7VE/XTEf3baXCaPqCeEhqD2EtJsgHr7gf55LfZt4OTKN2DB5uDOjpZVgQR4A4exMGWHtwB0MMf/3f2L7NZex98Kz6C4tYuaDj7Prsgs5cNZisg/WUr77cXzdTckuqhAiBdV1Z3L9ihv5/eKHeWDc1/i073s8q/z4LlP8bcGvyKWND6z6BAeDBckuqhCiHyRgLcQRbMuDNX4SgeYu/C37k10cIUQas2ybrKZGspoasfO3ALALxRfGfJTfzLqTtXkzeXjfacyYvpeZuVV426sPj1rTKLTLS8ybg3b5sN0ZYMVP+asj45P0iYQQw5GlbK4oWs9to15gSmY9u7pL+NzOD/BU41zsYwLQ51RsP+79T4XncHvm8yz27GFFZNJgFfuU+JtbaZ4Sn5M5kp2Fv7k1uQUaBizbZvqjT5FZ38i2a99N/f98HWybcc+/xuR/Psfe90qgSJjzqCgZrggdUX+yiyKGiZZwJjeu+CC/Of1xfj/ia3w953tc4nuUSe5d3LT242zvKAe3DDwSYiC4VIyYtiDBz1AldpiDMmgAdOI+QHN7ZsLysvIc5v0EbM8QbeBiafZgXQLrUDTnnWPqys7i0+dvY8u8y/nrWf+LZ/Y8ot4sfLWJu69jF0QSllf0oHP97w56E7a9WMYQrf8DpLsscXlp7+Duu0RuL1gyuPOOWqHktmftk+2kbt+JQvPM/sl8Z/N7mO6v5FvT/soFpZtpCmfzu13nE/GXEMoeRTh3LJHsEcT8Rdje7MPBalMLF+0aoE9wYrvXj05YXhvXSkBepL6SsrYB34albC6buIa/XfMTfj3lQQBu2/FBLn77izzROP+4YHVv3o6O5kCsgHd7N6DQjMhsH8hiH+dkzokZLW0E83KwLYtwVibenilBir6aXot15ezs/+cd++pKFtz5ADMe+geL/u8epv7jaaxojAkPNQ5ACXsXqXC+tjM18sXB7RuERiXuemE4sP3v7N8MV5gbJ7zKSxd9j9cu/g7nl23uV17epsSFN1zdznnFMhNXNyLZCcuK7tHJ7c8Gy5y3n1GXwFBUT3ygO5bBJ1dexxNNZ/D9nG9wlnc5t2/+MG82jTPPK+J8LWJnDc11GUKFzue7zOrh8aSTieK1g3vdaOdFE5bXYMcH6k9P3PZmzt971P8vKd3AG2d/l3sX/IF8T2KnUOt3JK6vWKHSmAWtDdi1zndT/WM76AoZBOQaDR57tpVjt9suiGDS9Fttzrs1u9KsoWif6twYqhznTs2H5rxltL0/v3SmUbqTElW4Gvs+Xtrgrqdt2nd2Ox8tK6SI5mqWjW3hexN/wVj3fp5sXMI5BRt5ffLVfLz4t7y6aRL5+zYcfqy+N4GRzg2mFU5co2p7NOH6vr8n2mcTanOu/y7Dr63tS42gdbjIrBMXLnJOowyOqZ0ZQxu0tq4u58pt0jF2dVtGJ0Fvq/P2otk24QLnbR55sdEbKzA0OkhO57HBDlp7P+U8B2xJ5Oi282mm8vqBL5ChwjTEcgBF/Z5ifrLnsoSUyV9tYTKmKTDC4IKkwfk7EsmBvSvHOKYzaatiWbYErcWQpWzntrBhj/PJx4qZjTrpijr3AWJnHh38dmFzWe4mPlH0KhN8TewMldDtL6I8x8v3y5fzfZb3mtd/1pxzwt8/F5nOLRkrOM1byU/efLdByaFwi/MnvPKzLzumuWflmWAwxqVx0TsjgGN5EbAsqs8ZSzTTTyRP07iogK4RClY45xUyCNacLN3iJvLX0j7TZBY7t7thgwHP4XwbFXXOq/K64mN+0ww00z4C2ufG/xYcFQGcr1lcnc59k48te8kxzR83nwETnbd3MNP5bOfutHAbrLMdGRt0TGM1OV+7Zh4Y4P6SBtVHUM7bZna9EipyPilfuOxtxzQfLXkVS9uURTuoiLbhwabd8oHW3Lnkbqrc+VS783j/q590LlSH2XocyuArqrRZ0NpEJM95g0pDNNc5L0+rc5ki+faABq2V3fcgE9unjYLWJtxdJu3ZOzGTIC6+sOEq/pQ/l0DMw8aO0dAz8DBvq3P7EixxLlOoOIbtM7gmS+C1jzaIgaiYc9Da9mmjkF1XbQLvoBwjHPBQtbm870QLEhd3sFqc2wWTa/pYcQQ71zloPfFe5xhe5TU+o+t1VeZ8XtF1GY5pMg9YdFY4JqN+3TjHNGvf+wuYCMqO4Q+24o0GiFluzvLtYNX536Ersxjb5eG0+7/ovEEHMiWISGtlvnb+a96rXJH3MpvDU7l27Zdo+kc5f9x0M++/6kn++pEb+P1pH+OrFV8lb+sKMjobkl1kIYQAoMPOoAPnDooQQpjwqijvyVvPRwtfZ7S3le3BUr5w8Dqe65jOG6ffc1x61+oQrjdCxJb6iC3qOzC+OjaOq+y3ucSzmZ9wGYl+ZPRIeXTTQYbxCPAT8XbFR4EHCuKRC3cokJCyCSGO5ifMiEgr5dF2PNi0WRkcdOej10PuygDRRRaj57SSqcP4rTABO3FPj4rUZWPxVuuEZBdDiJTliQTwB1tQ2ibgyyW60Yv39QCe+d3kzKun25+YacAkYJ3GMgmRT4Bq8pNdlCTQfHjUKv5z/L9wqxjfqv0sf9k0hhGvWbz1108RxsszWz7Eno7P8NVP38WZ41/luvxHqKkMU7L7dSw9NB8DEkIIIYToDxc2Hy5cyU0Fb1Dq6WRDYAQ/qnoXL3VORfcSWHatDpH5/gaIaPAouh8u6TNobWPxbGQGH/St4rS8Sla1DUwgYY46wNXWOvbqIh62TyeI2WjLY3m7OgDoLorPDyYB66GtgC6uVWtZp8ewhrHJLo4w4CXCJd5NnO/ZRmY0Qovlp9qTR6eVQfaaINNuqMMKa2yvoub+HMpnd/C3GXdw646PcNDk8QAhhBgiOktL2H/GYsa/9Cr+tsGdFi3RctwBMrub8EYDRC0P3ZnFqHWa7Pc39vQJIXafm6w5zdw+/V/8fOulnMoghaHxfLZIimLVSZ5Kz1XPR/ha+e7ERwDF4v3/4r4NE4jaFv4NRYTxEsNNGA+vPX8O33rzvczwbOfbOd+iZexCugsTN9eqEEIIIUQyLc6s5D9Ln6PU00ljNIvnO6ZTE8nr8z2uN0IQ0agYENHx/zvYGYsHf8/IH7g58i+wtqIUjLeamKGcp1vqjberAxWNUDvrdAB8HQM/Z7g4eXNUFSWqk4utLbiRQSXDwWJ3JZd7N5KpIuz2FLHDV0anFX9qLHdlECus49NORDTRVS6q3XlMz6zlpjKDOXmEEGII2XvWGdTOm8PB0xYkuyin7IrydfEpQJSLrqwSbJcX91F9Qoiu9WOj+PTU5xnhbzml7ckI6zRWpQtO6XHJ4aw6VMAP9lzBf014kh+W/4QbYr8me9+LBOY04d0WJozGSwRrUT03z3uDRruIb7Z+g7IdL5LVtC/ZxRdCCCGESIgV3RO4af9HOCtrF8uydvPF0hf4Ii/QGM3ija4JvN41EWXH0NY7E2jGlvrAo9DER1jHlvY9JYjC5nrfm3RrDw/XnD5gn+VJex5nW9tp0Vls0KNOOh8rFmXC8n/RWTKSjPZmsprrElhKkWhv6fHs0SW4sImSXgtjDlcropPwhqK827uBCZEmcu0gVe4Cwpab9iUZ2F6FFdHYHoU6TTMi2sbbnSO5o5d58oUQYqia8OIrjFu+Ak/X8B8s+mj1aXxj3rP4wp3kdNbR7S8gelSfEDzzu1Fo/t/691IdKDyl7UnAOo2la7D6kN8fOJuOgI/vz3iMJ0Z+hCsz/saWrNWczh34NxTRfaab79/2Z0rcLbxn2x1ENr5BQdR5BJEQQgghxPCheKt7PG91j+enDRdR7OpgWdZuzsjaw9KsPVyRtxE6IWZ5iLp9RN0ZxBb66H64xHgO64s8W5nkauCPwTOoDecP2CfZpUvZFet7QUJT+Qd2k39gd0LyEgMrgJcDnNpFsRhcMSxeiMxgRWQSX8n/F+XRdopiXdS6c6lekMe2P5eRuzKI+7QYo2a30WZlcP22j9FlOy8kK4QQQ0lmS2uyi5AwYdtDMCOfiNtPZrCF7O5GQjOz6Hy4CO/ybrzzu1HzNJ3+Eh7ce8Ypb08C1iKtPXxwCe1RPz+f/RdeLjqfi90v8votZ5ChgjxV/gFmeLZy64rPc3Bvo4zXEEIIIUTKa4zl8I/2efyjfR4KzRRfHQ9Oewh3NIg33Ikv3IkGYtN9xGb5sKwIRDW25cZFjNgxPaaRqoUrPG+zNjqGt2Ljk/OhhBBDUgAvBzyF1LlyGRVtoSLaTkm0k+q5ebhn21TEOmhyZbLbUyLBaiGEGCJibh8dWWVkhNrwhTvxTemCKRC1PHRlFqGtxISaJWAt0t6/6+bSGc3gjnn3sSJvEZfYz/C/uV/mLM9rfGHj9azaOyLZRRRCCCGEGHQaxfZQOWFfLmFfLmgbVyyMOxrsCWC3H7WUzq8zH6RNZ9Kss2jSWTTbWcx2VxHAy19Cp3MqC+8IIVJX2HKzx1tCrZ3LmEgLYyPxeU/rXDns9RSCkrZDCCGGFKUOj7b2RrrRShH05SW0vZaA9RDy3ukriNkWj29fkuyipJ3XmqbykdUf5+4Fd7OzfCYA39z6Hp6qnY/cyxfiEM3cvP1cUb6eVS0TeKZ+drILJIQQYjApi5g7g5g7gxCA1igdw7KjWHaUF9pHUaS6KLS6GG81stC1D4XmjtC5dJKR7NILIYa4bsvHNl852bEgYeUmrFwSrE4A2/ISzigio7sm2UURQqSYmNtHwD0wUbN+B6yV3ccJozTonEFD4j5IV1WOUbqMUV2OacJVWY5prDaz3aUizifVe2//+VH/L4+0MSLSDsDHL3qGOk8uAO/92xcc87L9znNRP/j0WY5pAPBps3QnQ4F2n3r+luni3zHn45A9/p1V33dQwC3VH+Y9uW9TFcnncfdssse30UmeWbnCietM2SbHIcN5R5SWmq1q37SzyChd0mlQDvt53FPO7VDlNYlrh5TBobICiZtQxtXt/H33tJnNT//Bq192TPOR/Ldw21Gyo0GyIwG8Ol7vbh77Gg2+PDo9fgAu/NuXnDeoh8AFhwYV7b0c7m6zMkZzbMc0VtDsOOzbZPAUR1/n3sMbTFz73T3S+fMBXHf2Ssc0j77ifBP2tNN2Gm1vXfVI50QHM43yEiIZtAW2v+/vV/Ze57aje7TZd/T1N6cbpXMyb//njdIVTG4+6v8WNplWmE77nWC1FTJrZ1tnOH/G+1882zGN6Rm4ea5zG2oXhI3ymvqzgFG6SqNUx5QhL0boyr77d4G9uY75uEc6L/6kDNvTSL7zsZoywSxQtmuj82KZf3j+AqO8TFjlzscqWus3yitntfNNmc5xzvUsd7/Z9/ukKdCe3svRVz/pSHZu1DHN64/Mc0zz7MwZRtvLW+11TNN9lvN1P0CsxvmYmnRbTa4DwKxvbnvM8vIaXN6N+dY7/bOOCWPZ+M0vEsnNYdn1n8YdeOda6WTaIIify2IZp1iHXGY7L5pt0Oc2iL+A2fcvlmWwvYBZH9/d5Vyu4iW1RnlV7Xe+Xs8v63BME1hvNt9/NHfg2iFlO+9Dp74SQPGUJqPttawrcUxjctzz1jm3QQCVVzvXs5LVRlnRsMj5vGLSrzLtN2ZXOtftxXd90SivmEHfwImMsB4CDgWrm1yZKGBkJH4WOhS0FoNnZ7iMnzRenOxiCJF0PiLMUNVUdDfhtyMABFxeGtxZdLt8lIbaKAnF26pDQWshhBDiSDbWUcHqdBXJyMATNBjYI4QQCaKB6ndfwPbP3oK7o5M53/zJUcFqIYQY6iRgnWRHBqsbN2aRvTJE+yIfI+eYjYwVQvQt6vUSKCogp6Yu2UUZBjSTVD3z1AGmqlo8yiasXTR7s+l0+4la8XFqvjVhAiu8WAttSqStEkIIIXoVKMhn1WdvYvTrqxn/4vJkF0cIkQaiGRlsu/1j1F50NoWrNzDrB7+ku6WcSt5DAVvIVzuSXUQhhHAkAeskKoh2MyLSTnNPsHryDY2oiEZ7FO33eRk5p42LSzfyrMwTK8RJW3vzh+isKGfe/X+hcM/eZBdnSJurDnC1az0Aq+2xrI2N4cK8HUfNHehbE6biA82oCGgPhO91UTK3jXl5+1jfNjZJJRdCCCGGHg2s+eSHifr9FO3YneziCCHSxPr/+Rqtc2cw4d6HGf+nv9EWm8Ra/h82biyiLNDfkaC1EGLIM5t8RwyIoOUmhiLTDpO7MoiKaFQMVETjXxklhmJvd3GyiynEsFaydTsFu/eQ0SojgZ3U61zqdXxtgBmqmnnWAbx2FPQ783D53wijIvS0VeB50yamLGqDZnO9CyGEEOlCAVl1jcS8HqIZsoy3EGJw5OzcA0A4Lxe0poUZ2LgBFzZuWjCbN1wIIZJJRlgnUcDysstXwqRQA4ULutGHFlrwgHWazU5fKTs6K5JaRiGGu/Gvvp7sIgwbNeTzu9g5TFCNzFUHWKD24w7YhC03HW4/ne4MAku95B/RVtmnQ42/kNpQfjKLLoQQQgxJs//8N978wq20TBxH4a69yS6OECINTPntfSjbZv/7riTm9zPiJ89j2VFswCJKAVuSXUQhhHAkAesk63L54kHreQ3oPwKrQJ8GO5eU0u2SkRhCiMFlY7FLl7JLl5JBhI9mvU5OJEBRuIPCcAeBGT7a/pRJ3uvd2Kcrqs8oImrJqUQIIYQ4EXcoxOKf/wF3OJzsoggh0oQCJv/uAdyd3ey55QPE/BnM/973aY1OlTmshRDDhkQZhoBDQeup8+thPmzzSbBaCJF8QTx0eDLp8GTisaNkRwLkRANkzgwRnWVR7S+UYLUQQgjhQILVQojBpoAJf3oMdyDAjs/cTMyfwZxv/gRXSNojIcTwIJGGIaLL5WOtf1T8P0cscCaEEENBxHLT4suhxZtNhh0holzELFeyiyWEEGII0yi61Ugy9UEU2vkNQgghEmrMY//C1R2k9sKzkl0UIXoVyizB192Q7GKIISaxiy7WZzinKQklbHNWLGFZ4R3VlbjMDFz3yBeO/6VSJxWstlo8jmmipZF+55sOOiudF4rLHj9EF+sLOgcLG+plIbyhQNmDu71IXuI2eH/r6Uf/QimCLm/KBqujmYkLqNgZg3zg7cTd7FSDHFdatWpywvJyj+xOWF5CDFWZB4b+uukaxT7P1WzP+BT7PVehibdRBZObk1yyk2fS504liWxPd28YlbC8BptVHhjU7dWekdzBS8HyxPVfuqY5X4NmbfYmbHuZr2UlLC+TvpBO4KGyEni5Xnv7GUf9f+S/X2TBl74zaKOrtdtg58WG5iA9V5fz+dX2J+470riyPGF5tdblOKbxzxt65+BAzkiqZn+I1vKF/Xpf446iASrRiXVMTNxxb+jfRz1lVihx3zdfS8KyctSvEdYqBp723j9oJM+GhsRMZRHLco5Ge3PDmIRMwlUGJy6DBjN7UqvB1qBrR75jGu3RvPfvn3dM5+5yLldkbBCnVLrNaxaIyYk6pzlZSjsGcKxgAi/ATHoQShsFrQebSYPiqnDuPOu9mbTUFztv0OdcN2yDNAAqPICdDwXa23c5Kq9xboNsg4bD02FWF2OZzicuFVGO31EAbdKgWQbHygWhQudy3f/i2Y5pVFjxAOc4l8vhuMQzS/7oOlcIcnf3fjRaZ8cIZzrn46t3PljhfJuYQYfWaLcYHPdEMynXo68sSci23O0W616Y6pguZnAey947NC+AhADArdGF7wQMFDYfK1vOg42n0RHzA9BN4oI3iWIalCl8946e9IqtX/wEze9eSP6GrTTNOY2Mf7Uw7Rd/YPcvl2ByUjRpg0z6jSbtMMCly9Y5ppngNxv99YdrLjFKx3qzZEfpcmGvyO87zQjnz6x3ZjumKV1YC7mdjulqtpY6pgGzoHVmjfMxDVQkLmigbeft6Xqz69uYwdgtk4pt+22qLzTaJPzVMN0RPJ1Q3sea5I2zLaIGfSGTz2K1uwmMdD5eVqtzWKJjkuFxr/GbpTPg9BFL3zTLp/70xPWTYz7nOqs0VH/lDMd0/PBRo232l9KAK/n9/mMZBdIxDO4Z9M0jeQbbKw5R0+Acj/A0GtwwVdDVVNhnEm1pyDD47iYwwHks78Euxn9txTtlUorYN0ZRd97ZlP/lbSqee5Xdv3C+xsios+isK3HenkGIKzDOeWCtbvTRbtAOFU9qckzTsLeQuqXO5bIizschmmPQxhrGaLRBCKRrrGFbnIA7ejIliBBCCCGEEEkwzV/Lf4x8jssKN/HhHTcfDloPZ1optn3hY1S/+wIqfvoimU/VkHFVPQe/cDHKtnGx2egm7lDnJkY5bVTQRhUF1JCf7CIJIYQQw06bPZms7+8np6WMLV/+FN6WIfqEuxh0ErAWQgghhBAiCTaFJvKBprt5qOijPDDlHj6w/VZCQ3CEdX/s+PRNHLziIsp/9jJ1Ty3Dxo31jyjl6jWqPn8JuQ3FFNa+kuxinpQMwiyhklG0UEIHrp4RkQHt5n6W0sHwv+EghBBCDJZWPYW1/D/smBvr11EyshrY8O0vUXbgr/iCMqd1uhv6E+AJIYQQQgiRgkLekTxjv5et4fHMyjzICM/wHlWkgfpzluBtbCbzX7XYuAEXNm4yn6zG09JGV17i5qwfbEV0MZ/9lKv2w8FqAL+KUozz1BlCCCGEeEcLM47qK2Q820DMn0Ewa/iueyASRwLWQgghhBBCJEFReAvPZp3GLN9uvlh5HXtCznMxDmUKmPazOwkXF9J15UgsokAMiyidV48mUpBH8cHnkl3Mk3aQAn7DefxJL+ZpPYM1egwb9Ej+rudSyfA+dkIIIcRgK2DL4b6CsmxabplD2UsryG1an+yiiSFApgQRQgghhBAiCco97Uz2VvHFyut4onlesouTECUr1zLq709T9blLmLLtj8S2+rBmxtj5mY8w+tGncE3dl+winpIIbmrJo5aht2i3EEIIMZzkqx0s0N/hwPhLqLt9GUWda5n5P7+m8n8XJbtoYgiQEdZCCCGEEEIkQWWomPM2fTFlgtWHTP7dA2TtPcDe715Nyfg17P3uVWTv3sukP/wl2UUTQgghxBCiZmjq71xKvt7OnG/9FCsaTXaRxBAhAWshhBBCCCGSpNv2JbsICecKh5n1vV8Syc1h5R9/RizLz6zv/xJXJJLsogkhhBBiCMnZVcnYR55k7td/iCsUTnZxxBCS0IC1p21w49/h9gSuou7Sjkk6d+UnbHMqohKWl2dfhvP28uSLf0I6ccdhsMVqnFeiV+O6E7Y9KzR899XJiOTYCctLe5zbl0SyYonLS3sHt+zJlr/RlbC8vK1yT9hUNDdx37fOcelVZ4UYDOokvlY5e/Yx6Q9/AmDyHfeTvbcKgEmfX5nIojlyBRLXFu8JpNc81fVrypNdhCFBlYYGdXtWAuvsySjemLhzsp2b2iMl6xcf/7uIP5OuwpNoKxJ4XZrsS9xkb39YaUzgTWuDc7Wyh97BsSJRJt31FzxdvccuNBBzHR3/CJYlrq0yoYoTdy4oGdecsLxM2Am8ps/aN3jnqH7NYa09muCI3kdGuDINTkh1zsFVABU12AkZMSLdHud0BsEiX5lzYC9SlUVnpfN8dTlTWxzTdOzJd0wDEDUImqmowqrvu6GLFUUg2/n4ZGQPXIdMxRTulr6rnDa4cWAcQDuZq6sTMP1yW2Hnxt80L1e3WSNgH8js8+/aBSTwvo5J0No9InFB8uMosN1970MranASNqhnVlgRy0zMSVAZ1A0AO8N5e5bJzacG36AHrf01znW2a5xBoUzOI6cg5ofWGb2XY+xTNnl7nPOpO805sG17zG7kmgRrY9nO+y7joMH5EIjkOW/P22TWBkVynOtGtMDgmCqzz1j6mnO3pf2KToLjnDcJwK8N0wmRKFGFaj71E7PJ9wUga49zuxAsdW4TPn/xv42298fb3n3U//20MOfxn8MYqL/tDAByrqhhJHWOeXU8UeGYpm2m834oXO/CZIzO03q+YxpjBu3sydIWRLP6TpNR7/x5TY67t8miablz0FoXG1yvxMz6QtrgvrEqCzrnY3jNaTc4B4tMLykCFc77wd3ufGwy55sHMk5mRvhINlSf3fvfPQZlBLDaDUIJJsExy2wHm7R7rk6zgQc5e5w/Y9t85z73pLuP7+O8/oVbCBYWcP43v3+47tQvdq6P8ess5/3lcq7+BAb4XpOywd3Z+z6M5tiOQWtl2EwaHXeTughYBtepardDAwtERprFTKxWs765SdDa9ifmvBLLMus/WIHEDeI5VvYMzZKH+r4+cJ+/8/C/tVJsvfl97L/0PKbe/xjjn4wv3rz9vycnLGidsdl5MGA41yyv9oDz9z1cnWXwbTdjEocy1TXWeX8uPn27UV5vVo47xdLIlCBCCCGEEEKIftMok+FcQgiRRoKFBQAECguTXBIhhj/bZbHhszex/9LzyKqqYftHrqXyiouSXSwxSCRgLYQQQghxEt74/Ub+510v88bvNya7KEIMKjcxrmY9H2YlWRgM9xNCiDQQc78zKrWjoiyJJRFi+PAS5RrXGnI5egR8zOth3Zc/Sc3Zi5n858dZ9h/fpfz1VRK0TiP9mhJECCGEEELEg9UXfGIiYabjfTbMC2xk6cdnJ7tYQgyKDCLkEsBNjBxCdGE2/YIQQqSymM9H6cbNNE2ZjDsgN/OEMFFAFxNVA6vVONr1O1OeRrKz6Bg9khl3/pkxz78GwJxf3QNA26SxZLA3YdNqiKFJAtZCCCGEEP308mNNhJlODDdhNC8/1sTSjye7VEIMjk4y+BNLAIjJA5tCCAGAt6ub2Y/8PdnFEGJYqSOPn0cvIsrR82ZnNLdy1u3fwhV+Zx09y7YPB613fn3ioJZTDD7pYQohhBBC9NO51xbhJYyLCF4inHttUbKLJMSgimFJsFoIIYQQp+zYYPUhRwarD7FsG8seuMWNxdAhI6yFEEIIIfpp6cdn8wIbefmxJs69tkimAxFCCCGEEEKIBJGAtRBCCCHESVj68dkyDYgQQgghhBBCJJjSWpsnVqoB2DdwxRHDyFitdUl/3iD1RxxD6pA4VVKHxKmSOiROhdQfcaqkDolTJXVInIp+1x+QOiSOIm2QOFW91qF+BayFEEIIIYQQQgghhBBCiIEiK6UIIYQQQgghhBBCCCGEGBIkYC2EEEIIIYQQQgghhBBiSJCAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCCCGEEEIIIYYECVgLIYQQQgghhBBCCCGEGBIkYC2EEEIIIYQQQgghhBBiSJCAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCCCGEEEIIIYYECVgLIYQQQgghhBBCCCGEGBIkYC2EEEIIIYQQQgghhBBiSJCAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCCCGEEEIIIYYECVgLIYQQQgghhBBCCCGEGBIkYC2EEEIIIYQQQgghhBBiSJCAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCCCGEEEIIIYYECVgLIYQQQgghhBBCCCGEGBIkYC2EEEIIIYQQQgghhBBiSJCAtRBCCCGEEEIIIYQQQoghQQLWQgghhBBCCCGEEEIIIYYECVgLIYQQQgghhBBCCCGEGBIkYN0LpdTLSil9zO/OVUpppdS3klQsMYxIHRKnQuqPOFVSh8SpkjokTpXUIXEqpP6IUyV1SJwqqUPiVEkdOnnDNmCtlJqmlPq1UmqTUqpNKRVWSlUrpf6plPqoUsqX7DIeopRyKaVuVUq9qpRqUUoFlFJ7lFIPK6Wm9PKeG5VSbymlOns+38tKqcsHu+ypLFXrkFJqlFLq60qpR5RSu5RSdk9jOClZ5U9FKVx/limlfqyUWqWUalBKhZRSlUqpu6QOJVYK16GzlVIP9HyuJqVUsKcOPaGUuiBZnyEVpWodOsF7fT2fUSulqgarzOkgVeuQUuqmnvrS2+uTyfocqSRV688R78lTSn1HKbVBxa/J2ns+651KKc9gf4ZUlKp1SCm116EN0kqp/07WZ0klqVqHetKXqvh12SalVIeK96vXKKW+rJTKScZnSEUpXocmKaXuUUpV9XyuGhW/TpuYjPL3lzvZBTgZSqn/B3yTeMD9DeA+oBMoA84F7gI+BSxKUhEPU0plA/8AzgfWEy9rEBgJnAVMAXYc857/Bf4DqAL+AHiBDwBPKqVu01r/ZrDKn6pSvA4tAr4HaKASaAPyB63AaSDF689jQAmwAvgzEAWWAh8FPqCUukhr/cZglT9VpXgdOr/n9SbwItAFjAGuBK5QSn1Pay0XaacoxevQsX4AjB3YUqafNKlD/+hJf6zVA1HOdJLq9UcpNQ14tifN88C/AQ8wDngf8Wu1yGCUP1WleB36BSe+/lLAfxGPw/x7oMqbLlK5DimlxhHvS5cCLxOvLxnAxcCPgQ8ppZZorQOD9RlSUYrXoUXEr8VygBeAB4n3pz8AXKmUOldrvW4QP0L/aa2H1Yt4A6+B/cDiXtJcDrx0itt5Ob57jvrduT3b/lY/8vlzz3s+0cvfPcf8/4ye9LuAgiN+Pw5oIl4hxyX7OAznVxrUoVHEG6zcI8sBTEr2vk+FVxrUn68AI/r43BuTfQyG+ysN6lBGL+lGAnVADKhI9nEYzq9Ur0Mn2J4NfLInj6pk7/9UeKV6HQJu6kl/U7L3dSq+0qD+ZBK/6G8BlpwgvRtQyT4Ow/mV6nWoj3ze1ZPP2mQfg+H+SvU6BPxfT/pvHvN7F/HgowY+kuzjMJxfaVCH3u5Jf/sxvz+T+KC09UP9XJb0AvTzQI8Dwj2vWQ5pfSf43WLgUaC2J48DwJ2cODhzypUKWNCT/qF+fMb7e95z8wn+9p2ev3072cdiuL7SoQ71Vg4kYC3159Q+uwvo7smvKNnHYri+0rkO9eT3eE9+y5J9LIbrK53qEJAL7AWe6/m/BKylDpl+xpuQgLXUn5OvP1/sec8nk72/U/GVDnWoj7weo4+Ak7ykDh3xnn/3vGf+Cf52qI36j2Qfi+H6SvU6BEzoSV8HWCf4+997/n52so9FX6/hNiXIzcQfxXpIa72pr4Ra69CR/1dK3QL8HggBTxCvUJOBW4k/orxEa70/weW9vufng0qpPOAKYDTxkdIvaq13neA95/f8fPoEf/s38N89ab6Z4LKmi3SoQ2LgpHP90cTvxEJ8hKw4OWlbh5RSpcQ7dyFge4LLmU7SqQ79CiggPiWRSJx0qkPzlFJfIP4Y9UHio6RkHvRTkw7153p6AgM9j+VfSnx6h/3A01rrpgSXMd2kQx06jlKqrOe9ncBfElzGdJMOdWgzcAnwbmDdEeW3iLdJNvHpHsTJSfU6VN7zc6/W2j5Bfnt6fl4AvJrgsibMcAtYn9nz84X+vKln8vHfER+lc47W+uARf7uA+PxkvwSuTkwxDzut5+dYYDdQdMTftFLqDuBzWutYT1myiD8y3am1rjlBfjt7fva5OJHoU0rXITHg0rn+XEd8/quVWuvWhJYyvaRNHeqZN+1y4n2NUcQ7VnnAbVrrxgSXM52kRR1SSl0N3AjcOgCd/nSXFnWox+eP+X9MKXUX8AWtdTDB5UwXKV1/VHwxxblAA/Ax4nPoH3nN3KWU+pzW+o8JLmc6Sek61IdbiAfI7tVadyS4jOkmHerQj4n3o7+rlDoPWEt8bbOLiQcjb9VDff7hoS3V69Cha62xSimle4ZVH2FCz8+pCS5nQlnJLkA/VfT87O/IiE8RPzl8/sgKBaC1foH4XZErVOJXWi3t+fkz4o8BTCce8LmQeCX7NPER04fk9fxs6yW/Q7/PT2Qh00yq1yExsNKy/iilxgO/Jj7C+osJLmO6Sac6tIj400BfJx549BCf7uqOBJcx3aR8HeoZhfZ74N9a67sTXB6RBnWI+KLTtxG/EMsCRhBfKG8v8AlAgo0nL9XrTyHxAHUR8D/Ad4mPYismPnpOA3cppc5HnKxUr0PHUUop4vUH4uc3cWpSvg5preuBJcSn0zsf+BLwOeLntb8SXwxWnLyUrkNa6x3EB7yWEa83hymlziB+MwTiTzIOWcNthPXJWtrz8xyl1Gkn+Hsp8flZpwBrErjdQzcEtgHvP+JuxwtKqfcSv0v2RaXUD7TW4QRuVySe1CFxKoZt/emZxuHfQAnwGa31GwksnzA37OqQ1vp3wO+UUhnAeOKL5t2vlFqmtf5kAssozAynOvQH4n3UWxFDybCpQ1rrV4BXjsijG3hEKbWS+CJEH1RK/Uhr/XYCyyn6Nlzqz6H0LuBOrfV3jsjrbqVUJvHpir6CPI4/2IZLHTqRC4mPaFyrtV6dwLKJ/hk2dahnOqInAD9wGfA68QVhrwJ+ClyllFqqta5MYDmFs2FTh4hfe/0b+IVS6nLiiyyOBq4BNgLziE8tM2QNt4B1DfE7CSP7+b5Dw+W/7JAuu98l6ltrz88nj31ESGv9tlKqEphI/DO9zTsjqPM4sUO/b+3l78JZqtchMbDSqv70BKtfJH4n//Na698muHzpKK3qUE+6ILAV+LxSygd8Qin1vNb60QSXNV2kdB1SSn2E+PQxN2qtqxNcFhGX0nWor4y01geUUv8CbgDOdkovTijV68+RT7o+foL8HicesD49weVMJ6leh07k4z0/ZXR1YqRDHboXmA3M1Vpv6PldO3Bnz2CQXxB/kvGmBJc1XaR8HdJav6iUWgJ8g3if5xzic1d/hfi6Hg8D9QkuZ0INtylBlvf8vKCf7zscCNZaqz5er/SZS/8dWlSqtZe/t/T89ANorbuIV5xspVTFCdJP7vm5I1EFTEMpXYfEgEub+tPTBr0MzCA+svpXCS5bukqbOtSLf/f8PPckyyNSvw4t6Pl5n1JKH/nq+f3II36Xn+CypotUr0NOGnp+Zp1sgdJcStcfrXU38QW0enuP9L1PXUrXoWP1DAC5CllsMZFSug71TCdxDtB8RLD6SC/1/FyYqAKmoZSuQ4dorddpra/VWpdorb1a62la658Ds3qSrEpwORNquAWs7wEiwLVKqRl9JewZxXXIyp6fZw1UwXpxaF6hWcf+oad8hwLQe4/406FHyy45QX6XHpNG9F861CExcNKi/iilRhF/lHoa8EkZWZ1QaVGH+nBoFEP01IqV1lK9Dr0B3N3LC+JTOxz6/1GrtgtjqV6HnCzu+bnn1IqVttKh/vT6niN+J4/hn7x0qENHupn4nLcPallsMVFSvQ55e37mKqW8x76H+FSNADIl6MlL9TrUKxVfXPiDxD//0H7iVWs9rF7AfxFf7KISWNRLmkuAF4/4/zTiX+YdwJQTpPcCZx3zu5fju+eo353bs+1vGZY1i/iI6TBw+jF/+15PXi8e8/szen6/Cyg44vfjgCYgCIxL9nEYzq9Ur0MnyOPlnnSTkr3vU+GV6vWH+MrDe4AYcFOy93cqvtKgDp3eS14TiS9sooGLkn0chvMr1etQH3lpoCrZ+z8VXqleh070mYgP1PlaT/oGIDfZx2G4vtKg/iwk3g/aCZQc8fsM4kEDDfy/ZB+H4fxK9Tp0xN9VTz3SwMJk7/dUeqV6HQK29Pz+u8f8PoP4CGsN/DjZx2E4v9KgDmUBrmN+5wbu6En/w2QfA6fXcJvDGq31D5RSbuLz9axSSq0AVhN/xKaM+Nwsk3t+d+g925RStxBfEXyzUupp4hXMA4whfnekgXjlS2RZu5RSNwFPAa8ppf5GvJItBs4kPl/MJ455zwql1M+ALwIblFKPEq/07ye+avVtWuu9iSxnukn1OgSglLr3iP8eKtOPlFKH7urfpbVejui3NKg/LxO/QbYGGKeU+tYJsr5X2qGTlwZ16FmlVD2wjvhj1W7iwepLev79a631c4ksZ7pJgzokBlga1KFVSqlNxOdxPEh8HZhlxEcmdQM3aK3bE1nOdJLq9UdrvUYp9W3g28AmpdQTxAcNvavnc60AfpzIcqabVK9DRzgfmER8scVELsCW9tKgDn0O+CfwDaXURcTbHT/xp+7HEh/g+KNEljPdpEEdOg+4Syn1PPFBQ9nEr8cmEh9Z/d+JLOOASHbE/GRfxCcT/zWwifjk82HiE6f/G/go4DvBe2YTn7x+H/HHSJt73n8ncP4xaV/mFO+CHPG+ucQrRENPOfcTv6sxoo/33ER8PpkuoIP44/mXJ3u/p9IrletQzzb6et2U7P0/3F+pWn8M6o4Gzk32/k+FVwrXoc8R70ztIx4YCvWkfwR4V7L3eyq9UrUO9ZGHRkZYSx0ya4d+QrzvXE080NgNbAN+A0xI9n5PlVeq1p8j3nMN8GrPZwsCm4Gvn+hzyUvqUC/vebhnW59I9r5O1Vcq1yFgDvBAT7owEOhph34A5Cd736fKK1XrEDAFeIz4AKIQ8XmuXyK+8LRK9n43eameDyKEEEIIIYQQQgghhBBCJNVwW3RRCCGEEEIIIYQQQgghRIqSgLUQQgghhBBCCCGEEEKIIUEC1kIIIYQQQgghhBBCCCGGBAlYCyGEEEIIIYQQQgghhBgS3P1J7MrJ0u6S/N4TRJ3j3y5f1GhbsVC/ipayLG/MMc3YzGbHNJWtJYkozmHhA1WNWut+ZepYf8CoDnk6zLYXyTdYUDSmnNMYJAHia7wmiCvknCbmNcjItOyWQeFN8zLZp5xCHSouOOXtuw3aoahtdj/PUs77zo6Z5TUhp8ExzZ6uYsc0uT6DCgS0d/od0+Rndxnl1dqd6ZhGRZ2PjXJu8g4L1p5EHcrO0u7Cwv685cQMvjLuoFlWMd+pFeUQK2y4vQznNMrsVG3ULmiP886alFtvtLndjWXO2+tH9+Gk2qHcLO3p41ymIwbfd9PzhUlz6jLMzKRtNjkX2GZtvGVQh2zDY+Uy+C5pg91um5w3++Gkz2NFp34ewz24x92k/Qaz45BIyjZIk2F4YulyOSaxM8z2uwqZ7a9QzUnUocws7cnv+zxm1A4afBTLZ7bv7IjzvsOgvxRPZ5DGoF77Wgy3Zzuni+SYVWzb5Hxu0uU2qNeHhA72vw65czO1pzS/17/bYYPjiVlfYVyxc9/W9DrVpP9Oi9mJJercbQW384FQYbO64Wtx/i7ljjfrc4cMTp5tnSYf8OTOY9DTF+qjDimDim56fWR6bZkoJv1p03OBZXAuUNlm7azbck4XCjp3dIxjKdlm6U6mDmXkZ+jsir430GFwnWo8/NbkcBmco6xw4vpCpu28KyfinKjJ45gk5pwEMOsrm16vK79ZwuDuml7rUL+iwu6SfEZ+7zO9J2h0PkvnT2ox2lbrLofOfJrwj3VuUX4390+OaW78x6fNNmjYmaz8/Jf2mWX4DndJPqN+0Ef9AXS9cx2qeNWsjAcvd/6CWO3OXwHb8KLQMglSGO7f7ErnvLpGOedlGrixMw0aE8OLFqvFLCJQ+YX/6H8dKi6g4tuf7Xv7rc6tcdHkJsc0ze1ZRmXy+ZxPIt3tBidc4P5z73BM84E3PuaY5oKJO4y299zKOY5prly22iivv6+b75jG0+RcIX3N5p3SLT/8Yv/rUGEhI7/0hV7/rg03b0WcE+ZvM8usfbzZNp1kVZula5/s3EPyNhlenBt0fsJlzheYD13yS6PtXXfXF523V2R+pX8y5zJPST5jfvTJXv8eqXG+SDSpPwDa4Pxj55rdXVCdBue7DOd95+o2vDhvdE4XKjY7VnnbnfOKGFybd4/uRxTIwEn1hYoKqPjm5/pM4zJoK2NlZneorBbnL6ntd94v7lazAJbtS+DdewNW0Llu+Ke1GuVlr8h3TNM1zWy/Z1Sa9YW2f6f/5zFPfiHjPt53WxguNKjrBkEg/4R2ozJ1VTtHNrTP7PunDIKEJn298Y+bHStXl3M/ruasHKO8OiYbXHsYBDxcXeZ3fnb910nUodJ8Jv2s9/5k195co3y8Lc7l/MON/+eY5sYnPmW0vYLJzoO0rEeKjPJqmmfQVhU7DwCxDpj18Sc+0uaY5qIH3jDKa0/AOTb49HLnfjmc3HkM4nVo7I8/0evfTQb0BNoNRlAAVtvgDmTM2udcr9tnGgQRgaxdzm2Ve6lZfKwku9Mxze6tIxzTjHzJrA9ac5ZRspOqQ9kV2Vxx/xV9pnnl9dmO+diG5xWTfrdJHzhzX+JuiLkDRllReG6N8/bucR7Q0zHK7LwSGGnQJ+wwvBaY3WqUbtNV3+m1DsmUIEIIIYQQQgghhBBCCCGGBAlYCyGEEEIIIYRIe62do6isXkZr56hkF0UIIYRIazJRdIooiHXh0zFqXTmg3nnkIccOYunBfTxTCHHy3DpGcbSTWnfuUd9lS9tURNrxqghhbTgJFeAixpXet3kmPBO/ijDdVc3y6JSBKLoQp8zSNgXRbprcWYfrv6Vt8qMBmt1m8zEKIYQQJxL2+6lavIiyjZvJajp+eonWzlGs2fZhbO3Cqo6xcNoD5GVX0TRuLpnNB/G3Nyah1KmjONZJp/IRtOL92PJoO02u9Du3dxcVUDdnJmNeW8mBZacz5rWVWPbxj+H7CTOZejYwCh8RyminnDYu9G6hWufzVGRuEkovBsMIdytfK30aNCilcaHJcEew0FjYWErjxuZX7eexI1Ke7OIKMWAkYJ0iSmKdlNmdlMQ62OUpIWB5ybGDzApXE1QeFDZaBtQLMeQVRzsZHWkl0w5T6S1CK4sMO8LEUAN+HeGM7D283DHVOL/xViMXebaw2L0HC41HxVgfHUMnZvPGncg4q5F2nUGzNlyNQwhDBdFuRoTb8NpRarx5KGBMsJlsO0S3leAV84QQQqSVmvlz2HvWGew950xyDxyk4u2NVKzagCcQX9m1pX0stnYBFrbWNAYmsv8Ti6mbPZPCyvX4N72U3A8wjLm0zcRIAxrFBu9ISuxOxkWb8en0W7eqZsEcdr/rPPaes5RIdhZZdfWUbNt1XLp5HGCZ2s1ivYc89c7qw3VWDgdj6bff0sl7ctdT7m7D1hY2ChuFpTQ2ipi2iGiLEG7OytglAWuR0iRgnSJ2eEppi/kZH21iQbiKalcu5bF2wsrNZm+FBKuFGCZq3fGFbkZFWvGFojS4sxkTbsFGscNX2q9gNcAuu4wfBi7lYxmv4iHGjwOXnFKw2kWMT3lfZrddyu/DZ590PkKcSJM7C68dpTjahSJ+gZtjhzjgzSfoMn+yQAghhDjW2BVvUr5hE3WzZ1Izbw7bL7+Ene+6kJIt26lYs4H8rn1Y1TFsrbEsm4O3ziMyK4eyLa9RvNtsEWpxYjFlsck7gtnhauaHq3BjU29ls8+dfoHXCc+9gq+tg12XnMeMvz5xwmA1wEom4NI2xXSyQY+iljxqyWVr0HlhPTG8/bb5XH7bfO5RvzNZdFGIVCMB61ShFHXuXJpdmUyKNDIq1ka38rDRO4KwksMsxLChFLWePILKw4RwI+PDzXRaXnZ7SwhbJ/dd3m8X8c3uq3BhEznFZn+yVU+GijLFqsVLlLCcRkQiKUWNNw+tFCWReMe8xptLqycryQUTQgiRCnydXYx54y1Gv/EWHRXl1M2YQe382dTNnYn3vR2UPrGNyPYMmt87HjVOsfDO+wmObkl2sVNCl+Vjo3cEs8I11Fk57PCUHDX9XbpQwKi31jLqrbV9ptMoljN5cAolhBBDkEQaUkxEudnqLSfXDtCtvESVK9lFEkKchFZ3JlutcnJjQerdOehT7NDb8RnPTrlcs1wHAfAomylWLZtsWZRIJJhS1HpyifScv5o8MvWMEEKIxFJAbk0tBbsOMOWfz9E4bTLVC+dS98EZaJeLou27mfWLx/F2dVMzOifZxU0ZXZaPN31j0zJQLYQQon8kYJ2i2i1/sosghDhFActLYEjN26uZZVWzOTaC8VYDs10HJWAtBoZSEqgWQggxKKyYTenm7ZRu3k44K5POshIKKvehZN36gSHBaiGEEAYSO7FxccgxSeuu9JunaqB98u0POaa576rfDkJJBkfN2Ynr5Ni5Ucc0VjSBnSqduLyyqpzzUs4fz1wovUbrF+Z2JSyvzNxAwvIy8cLuKQnL64nXFx3+90jVSoHVzduxUWyNVTDTVY0isVdzocLkXh0m8uK0ddrgfpauBE5pGC46frX6gXTF059PWF7epuSu2eCp6HZMY3sSVzes9sSNPbCCzvsulpm4uuFrTNyx8jjvdjIPpM56Hq66wb2ZGc2PDer2EimwLT9heWVtG0o3kQdeYE9uwvJSocH9/lVefXLHytvVTeGeo4PVFa91JKhUZmJZg3sOPlbWuPaE5fWx+z7jmOa+K+9I2Pbs65oSlheNPuftjU5cH/+5Dy9NWF6XnLkuYXmdDNvgmtefG3RMkwxdY52/f7mbE7euSvSNxMXHJk6vdkxz8LzUuRNnDfJ5pXts4oIr0UEeX5pTlbjzSjRn8M5R/bvKiVrQ0MdiXYZX+iZB65wJrY5p2mrMOlFWt3OgTVvOZTcNZNhu54Q5o8w6Ph2tmY5prFY3N+77VN+JYmaBUnsgO0haEYv03aiYNDkqoqhd6vx5Mnc5H/esg87Hqmm+Ngpa505ynt+ufXe+YxqAzvHOx8HTauHu6rtcF1y+xmh7/1oz1zGN1eWCLud9OupFs4vaSqNUx4gprNZT7yA07SxyTGPnmH2OYJ3ZAoYmdfv9f7/NKC8nKqp44aDzMVUGbdWdV9x1+N/jo43oGIzMbsZrR8iJhrg+dyVtlp8nOxf1kUsPg85rZo1zNqfEbfd5c9WOmXV8YkHn74LKjNJc5pyXVed8QaQNjhVAe4KmOvTXGO4Hg86Wr9a5qxHOt7ny77c7plMGgXQVVqjwwI3e0lGLcGPvH9wKK0y2bnJMi9Y759Q0TxsFrX0Nzsc0MDqKctjFJkFtgFCxwXlsVBcmLbq9x/lx/Ixmjdeha9WwyOx75OoewAsgW4FDv1R7zcpptTjvvZxdzp/F13Z0PQvkFVI9bwm51fso3rkZBYRzzb5T7ZMH90LYznCuZ1bQMgpaWwYPdUQnBIzO5wN500/7NMEJfQ8SMukr5U9tdkzTVJNLZ6PztYjb4DujPRoizudOV7dz2aMG1ytKmwatndPEsmNAxDGdq9P5833z0scc03z739cOaNDajlh01PZe4c+Ztw3KnfN5beUMxzRWwOLmh/sOWufshzznzRHeX+yYpmuMDfMS0w5NnnvAMc22XSOIFTvXjZ0fcT6P+Ros7v7LJY7pbIMTp9ImNfvkqW4La33vn2nSRXsc89i8bpxRe5qz2zlVx8TEfl9MgtYm3/czr1nvmGb54/OIrnSOj+3LdU5je7XjPrWzYhy8yCD2NYDB4I4uP6+8MavvRAbxOQArkpg+f84O57501xibYFkiA7/Oaaq3OF9MeqY6H6vQuLBJkbBanfeDXRAhbHCfJbLv1G96y5QgQgghjJTYnbSpDMLKTaOVjQ0U2520yRREQggx7NkuF9VzFlM7+zRQ0DxhGo2TZjLujRdw2c7BTSFE/5Xods62d7JZjWCbVZHs4gghhBBDhgSshRBCOPLpCHk6yE5XfHRLVLloVZmU2J3spiTJpRNCCHEquvOL2HX+lYTyCijatYXRq16hddQEqk47m81XfYjSbW9RvnVlsospREop0p1cZG/FQrNY78W2LXZYBo9mCSGEEGkgdSbzE0IIMWAUGg0U2V1Y2ibTDpGlQ1gJnsNaCCHE4KufPo9wVg5Tnn6UCa89jScYoGTXZmb97R7y9+2mbsZSgjmFyS6mECmlXLfhwaaF+LQro7U8ySCEEEIcIgFrIYQQjoLKyyb3CAp0gDPDe1gc2QfA2+6RSS6ZEEKIU2VFoyhtk1ez/6jfe0JBRq15DYDOklHJKJoQKWuLGsEeVUwxXbSRwXJrUrKLJIQQQgwZMiWIEEIII7Wu+MIJs6PxFajf8oyny3JeMFAIIcTQ5oqEsD1etFIoffSTM76ONjxd7XSWjKZ4z4YklVCI1KOVYjmTWKnGAxBRcmkuhBBCHCJnRSGEEMZqXbnUW/GV5W0lD+kIIUQqcIXjq8fHPF7c4dBRf1NAdsMB2ismoHv+L4RIDK0UEbkkF0IIIY4zbKINYZXHnoyP0Oqe1Wsaj4ry86kP8sPJj4DMqypOwLakQyjEqbKVJcFqIYRIIa5IPEgd8574qZnshgPEfH6CecWDWSwhhBApIKIz2GVfRKseneyiCCGGkcRGHPTAjLmwcbMv44N0uiezP+P9HPS+GxsXeRXth9O4VYzfTPszV5eu4wPlq/jUqJf7tQ1lO5c9kR+voyonYXnZ+VHnRK7UCeBrT/8/i1YW1TMuZvv5t7Fr2S0cnHUpzaPn0TitzDHwVrQucQc+d2JrwvKK5NuOaV54amHCtmdnxRKW13BgdbiSXYSTpt2J+75/4slbE5aXie6KQd3ccSyX8/fKlO4evjfIAhWJ2w8mvK2J645ob3LPd/Ygb79o/dHnqKg7k7oxl9M04nx0P8fC+g8411k7I3F1I1KVlbC8goXOn7VktYwN7s2RI6xPpKAyPrd1Z8nwCzYkss669/gTltdwUHTEtdapUpHB/f4l8rrN1Tm4fcJvXvrYoG7vWK+sn5awvGy/8/evY0zCNkfW/sT1J3a+7dzeTZtUnbDthUoS2AdN8ulu13MT4uXQcNBeyMv2N9imr+R1+z/YaV+M1oqZ8/cmbHs5u4fvQJozr16fsLyssPOBt7qG7zVusiWyfRlsvr0n7t+dDKvFk7C8nPT/alr1fiHmHdXl+Paw4cXJiC8Egfg46Y03v5/AspHM++39tEwax76LzyZ6cAQfnv898sduwsLmva41zLYO8lRsNmNVM18e929KR7exR5fy18fPdtxeJN/u66P1ixV1bihUVNG9K88x3Q0XLndM8+DLy4zKZRS0HsizW0w5Vm5lsO/8NWZl9LX2bNblpvKsy2kfMZ6iXRuJebx0lYykvTzeGdu/IEJObQ251dXxV001nkDgcD7NU9xk7XPeZjv5RuUyccN5zsf9gdeXESrtO4isPTb/XDfHMS9XwLnxdY/ohgLHZFRdmOmcCOBJs2T9NfJF585eyxTnpq97lJ2woLWda3BTCbDaExfgTFTQ2gopPvXoxxzT2ZnO2/MGHJMQmhSkYyDXcYxa0NjHvNu2MruTazl/3vzNFian2daZiblAMWk/waxuWAGLUL5zXtGKkGMaq9W5UzN2ltkFX+cDzpWjab4e2KC1Nrsg6DMLw/5u80znNOOfCJK3O/7vxskT2fKey4lmZKDdLrIOuJj+j3+itGbPtc7zzdteDQ438E/1sx8plhUj1pLhmM5lcFoJltt0TEhAoYBY5gDesLE0OsPhBrDJxaRhfy1kcN4u3B4hlNENgKfDRVZt5Lg0wZldeDtb6CgbTdG+db3mddeVvz/q/y4do8Tuot7KPjxA4FP3f9Ko7DGDJRLckzsc0+hNZoNEbINruVim3fc55FC67AG8yR9Tzu2qwUCc1l0GlQNIVGjDdMCJyffP6DxmGCA//4yNjmleeX4urm7nhjsyIuyY5vuPXOeYxgpD4kILJ6Kgjz5D2UqLbcudT0DZRc77+IwPrXVM8+pjCwg5XxZjG7QJWVXg3eh8rFpmO9ezz1/87+N+N4cDNJHNwZ6LohUtk1gyY49jXqtWTXZM87ELX3BMA/CH5y8wSjeQXCHI2937Psw+EKRx00y2X34JLRPGkVtVzYznnuTgovlsn30FdZVzyW19Fk/YuQ13dzuXJ5YBuTudj3vHeOe2I5EDf55f4Xwdjq2gxHmbsRzn60l3qxvlULXzdigG8/rkZNkGx8HbbHaGik12rkSdyrk/qg2v6VWH8/51Ok79YTKQEcBqdS6Xv9ogLhQEcG6Qg2c7f78dt3XKOQyw/eedQfWyRUx84lnK126kfO1GCnbtZdNN13FX2095T/bP+Yr/LmZbB3k6NpM37YmsYyxl7nbe51rNHdFzk/0RRBJFfRnsOvc9dBeWMebN5yne9U6nNJyZTdRTRkfFCNpHjKRq0WloV7zRm/zM01Rscu7ACiGEEMkWc7vYddH5VC05jezaOhbc+2fqZ0yj8vz4Dfvp//hnkksohjp3KH7zKZrR+wVIduMBWkdOPeHCjCdSEOtmeqSWDKKUWZls9IyQ6aSEEMNWMR2cxw408BbjeZPxyS7SkBRzu9l14bnsP2MJrkiYqU/8m5Fr1qG0pqByH7U7drH93ZfQPurDFO97kZymbckushBiiBrSAevmyePZ9v4rKXl7C5OefJ6W4FiaAxMoXLGHpVW/ZOeP3sv56gDzrAM8F53B63oyo99uZvyqRl46bSpXLVzPB1xvca91IRF7SH9UY1mEmGzV8bY9ut+P+qabUFYuu86/mnBmLhNee4r8qt1H/d3b3UlhbSul27cD8ZNrZ1kZe84+l33LzqR021ZcUbO7aANPk0mYboM7WUIIIdJHZ2kJm957FV1lpYx+4y0mPv8Snc3lWGtiVFSto+Yj8wHw8TxK1vcQvTgUsI75eu9nZDUeoHncHAJ5pWS21vWaztI2E6KNjIm10qU8VFqFjIs1MztSzUbPiISXXQghBsNMqomi2EUpi6lkBK1sViNo1Ymb3upomsVUEsbFOsYO0DYSRwMtYyeyb+n5hHNyqVj7NpOeexFvV3x0a1v7SFraxlLQvo/F+/7A2o9dTf3ES+nOH0/x3hdxxZyf2hNCpJchHcXd+sH3oLTN7Hv+SmtgDKuqP46tXVgqxmn8nh/m38yNnuX8oftWHo8t4D3bH+Kmjy3HFbaJeS3e+MNEzlm0k/eOf5MHdxtOmzHEXeNeyzSrlkjExWY9kM/ND3+VZ15G1JfJ5BcfI7vB+XFzVzRK3sGDjFv+Ghvf936aJk2mdNvWQSips9nqIIWqi5X2BEIM3pxBQgghhi6NYu2N1wMw74GHKNq1h7b2kazdcD227cK6L0YF8aB10cEGcpvWJ7fAYshSsfgUFjFP732M7MYDALSNmNJrwNrSNvPCB8nXAQ648tntLsZWFgHlYXq0jgnRxsQXXgghBsFEGgjjppp8RtHKaFq4LetFvtt5xYBsbxxNnG/FB1ZV2/nUYTBvShJ1lZSz8+L3oOwYcx94iOKd7wwWa2sfydqNN8T7JlaMBfyZEVsfoX7Cu+gsng7apmzPM0ksvRBiKBrSz+WNfWE5tsfD5g9dQ1NwIrZ2AS5s7aLWM4cft/+UXdGJvCfjcZZ4X2T8qkZcYRuXDa6Izcw11YS0i9dqE7dwRLK9FJvKXZEz2a1Lkl2UIS+UW0Bh5dYjgtWabINJdLMb6gGI+IfOwjrbdDkr7IkSrBZCCHEETdSfwYi16ynaFZ9Ds6V1DLbtAixs2yLzpVay6hroyp2U3KKKIa1t9CgAsmt7HzntDgco2L+ZxgnzCeYUHfd3hc30SC35OsBmTzk7PaWHpwCpdedRb2VTHuvApdJrEWchRGpYxTgyiXA+2+PrbDGCBwOnD9j2DpLPaj2WlXo8jWQP2HYSJbOpgdKtb6MtF9uuvIyGaVMO/62lbexRfZPmtrG0Viyis3AK7lA7eXXrk1ZuIcTQNaRHWI96fRVRv49tH7iK2Hs9WL+PYWtQbth3+zIyo538MnQNP8n8Obd6n+Pp02YR81oQsdEeRfHpXTxpz6Gq6/hO9XBVpQuTXYRhwbZcxLwZuEPvTLD//vnL+c/zH+ft6nE8s20+z22fR5jjg9JWNH4hZbuHztcjMrS/qkIIIZJAAe5AkOgRN1gL8vdjWTFsW2NZNgX5+4ns8rN/6SJs5cbSQ2WqKzGUNE+YgKeri5za2j7TlW9+lfay8RyceyETlj981OR0X1zyJGV2JzvdJdS5co97b50rhzK7k9NLdvNG/ZTj/i6EEEPZRkaxjXLyCPQEkBW7YmUDtr0Ibp7TMwYs/0Sz7Bjjlz9P8Y4t7FtyARuuv47irduZ+s9nKMjbd1TfpOGDU+kYPYKspu2U7H1BpgMRQpzQkI+CjXt+OdGMDHZ94F34yxqJbs8gclY2I9rW8IH8X5JpdfDX2CI+5FrJ6QsqufcPy5i2qobFSyrZP7eAVTFZDCEdxbzxi3dPMD6iOsMd4tYlz7G7sQy/O8R/nv84/3Hu31m3axIvrJ/Hqxtn0RmMv8eKxS/mbVei1kUXQgghBoYnECCS+U7AOj/vAF+4+Wts3jmfpvYoebkHie3ysH/ZEoLZo8nsqExiacVQpJWiecJ4inbtclwdxR0JUrH5VaoWXELz2DkU7dsAwA2zXuXGOa9wwJXPAVf+Cd/bbGURxeLyMWslYC2EGJYiuGkkJ9nFGNJy6qs5/Y67OXDG6ew592xW3vZJJrz0CvPUX6h2z6fh/VPomlNMyZ5nyWncLKtyCSF6NeQD1gATn3qeWIaPykvOxTe3lUX3/oHiLTvIvKIDgJ26nGftmVzi2kz9/FwqFrSDgsej82VhwjQV9WYC4A7GR1hfN+91CjM7+Y9/3MyG6vGML6zlkmnruGTyWr7yvke4/Zq/8ea2abywfi5vbJkBti0BayGEEEOepztweAorvy/EV25+hDPnx9df+Mu/z+GPf7+IvP0HUHaEQM54CViL47SPqCDq91O426xu5FdtpWX0DGpnLCO3djeXjljBl5f+g+crZ2NNC4I6cd/bVhYNVjYXjdrIt9a+N2UWRBdCCHE0y7YZu3wlpZu2sv3yS9h5yUVwSfxv2TW1zLrjcRqWBpNbSJG2itydzPDX8FrHJJB44ZA2LHqKCpjy6D+Z9Pdn0JbCHY4cl+Z1exLlqp3zXdsAeDI2h1YGasVeMdRFffGLd3ewG78nxI2nvcQbe6eyoTo+4r6yuZw7VlzKA3+7kGmjqrhg/nrOm/s2Z83aTHfIy8v2ctZPnUhVFbxhjSUqF1VCCCGGIE8gQDAvj4riJr7z6T8xpryRO/56GaPLG7j+0lcozm/np/dfTUbnfrpzxpE6k6SJRGmeMAFsm8JKs4C1AkZueIGd536YMYuz+J9Jf+bturF87cUb+NH0P/b53jpXDvO8BzmzbDsv1cxMQOmFEEIMVf7WNub+6WHqZ0yjZfxY3OEwE158FSsWo4HMZBdPpKERnhYemHgf43yNvNA5j68evJ6GkAtkqOuQlNAoXLDeudFRRWGjvA7+vK8F7+LF3r19wVG/fVzN4Wvlz9Aa8/Or+vPQPWtKhoudF3fJKO92TBOsM2tUrYhzVdflZncUH3r2TOe8MrRzmUrMtufzDOxCONph1yjnj0LE4CmscG78WIWKurlqwXIKMrv42Z530TH2mITXtLGaHFZzFj9pXsb87gNclLWVWZmVXDb9aZgOUSwaVRYN5FCvcmhU2cTU8aOvv/Gv9zkXzNA/f3u2Yxpruu2Yxr/XbJHGwAjnvNhhttiH5TE4iAOobpFzsxbNdf68OXvM1qRVBtPBtk8xa2pVqfP8bXbMuX0pL2kz2l7dNufFWxefvdUorw2POM+xFz6jwzGNqkrujUbtMqu/Jm1V1yizbRZNbnJME3zB+Vh1jzAru6fNuW5H8gzaBGD8qAbHNPvrRzqm2bdphNH27MXO5fIUJXfEjr/aef8atblAzrQWxzT1oTBLi97kV9/8HUppblx/K68XTIGQZseuQr649Bl8k7v5cNV8DuReTtiXjyfcesK8MmqdnywKFZmVvWS1c1vVuNDsSabsg851O3+3cz6tk8zadT2QS5LHFK72vs8JrpDzvlNmh4HAmOMHeRyroWASWc21dI20Ae8J07RPfad/aGFT7tvFjNjvuGvKN6kKFnDL7ptomeTiXKc+qfbT2uznPfPfYM2o0j6T1tfkO5ad3QZ9kwznJADRLOedarrffbkDOx+rU3/62vPedMzjb684LxZnew37dG7ndFMecF74HKDqAudjGix1PhCmZX9p92THNDrT7MBbrQZ90GzDSjSArAj4+2jvGxaZlTGW6XzduKW13DFNoMJse96RXY5puhI4Xccvn700YXmZ+MPzFxilGzWz77UGAGpbjl9HIJEiOZqaC/o6/sdeg+7GxW40sPvDFmCRVWh2vaK2O3+W9slm33e7wPmciO18DvblmLXxY37q3KFo+2/nOBRA4w7nIQfa4Do8nGsWlrUM+iIny/LGyBrX3mca17P5jvl0jjHbnq6LdwRG+xv50+kPkO2J8v3O/+ILmb/g+cnf4/aOn3NfwQ14uzvwdLfj7W7D29WOt6uN3NpKlI63UR2TzK7p3Z3Ox930XOBtcc4rXOCcl6vLrHMbzndOkzG30Sgv1+vFRun6klLDRsPaw7drLk92McQQcGhKkFzdwq1TXubV2mm83Tyuz/fYWKwJjmVNcCwbu77CBP0Gl7t+z63lr1OqO5hJNbM12CiayWSfVcR2Vdbro69CCCHEwNJ8Ov8evl/6S3Z3FfPx9TezP3Coc6j4deVF1IVy+f70x3jS91kuDpxGIHscnub1ySy0GEJirkwChWWUb3z9qN8X+jsYV1DPiNxmRuQ2UzS2mVEZzYzKaKHC14rHil8c1cVKuX77f9ISNQxsKsULXdO4NHsTPhUhpM1urAshhBBCnKxxOa38edHdeFw2l1b9iarKOv7p/xY/mXYff8z7KDfE7ua21h9S6Z9KV/FIbI8PgPz9Wxm9+mkZfZ0kKRWwFuKQmCcTZUf5yLgXKfB18avN7yKwv4JA5Sj846vwj6np9b2zt1Zx6ZafsGrORF6aPI0FrioAPDpKse6kVHdQrttZaO/Hr8Kst0ZL0FoIIcSg8qooXy/+F1flbuDx4Hv4+qrFBKLx4N/8yr0s2bmblZMn8lcW0xDO4f/mPMCKjCVc1XUXXc1JLrwYMgL++FRpuTV7AZhWUsVNC18kq9PPa6vP4dyJa1g6fyW1oVyqggWsbR9LVXAeVcFC9kVG8EzJN8FaTy5rT7yB1QFYEYAz/LAo/vTks13TuTZ3HWdl7uL5rumD8THFEBRzu9l25SVk1Tcy9vWVRk8uCSHEcBbxZ3DwtAWMWL0Ob7fZUyfi1I0tsXlwzp1oLK7a/iN8D21j9oYiAnMsPtJ6Ix8a/QZfnfRP3pxyMT9dcSWPb11MzJNBw+QF1E9bQlZTNUWVG5L9MdKSBKxFSop5/GRFmvjolJd5vW4Kb769hIP3XIuOuVCuGCNvfuyEQevZW6v43df+gjuqCXvcfPoH74eeJwUjyk2NyqeGfN7WmkX2PmboWsLazRZl9ji7EEIIcaoUmt9W/IVF/v38uPpDfNW6jwrX/XijTcyv3Muff3MnnmiUiNvNDZ/9BC8xgw+u/iR3LXyAF8d8kCurPkVdcGAfFxbDQzBzPFYkTHZnPT+7/G7OmbCZl1adxQW3Pksk4kG5Yky96q90X3TiR9Db89z4/COg9QQB69UB1HUHIaLBo9CPjIRFftYHR9MWy+CirK0SsB4kl7vWs8i1jx+FLyGAL9nFAWDjB6+hYcZUANrGjGLOXx6VEWxCiJSllWLtzdfTMXIEdbOnc/pv/4jScqduoOWOLOXRuZ8jYPu4fv3teJ5s5q2/foowXrzbwpzOHTywbBmr1szg2+c9xLfO+ytLR2/nP5/9CGVb3iCQX0b1nHPIbK4G6pP9cdLOQM7SJ0TyaBtlWbSFMzmteDcTWkHHXKAtdMxFoPLEk8su3LAfd9TGbcfwRiIs2rD/xPkrRajnfo9HD+y830IIIcSRLDQeFT/3nJ6xjklspXbC+whmjmTJzt14olHcWuOJRVmyczfRjCJmT8okx9WNInb4vUK4Iy3YHi+7zruODH+8Xqxct4xo1I3WLrRtUdDtZ3pWNTmuo0eDRd25xFyZWHYv88avCEBEo2LEg9YrAqBtvlXyFHmuIPXRxM01K/oWwc262BhcDJ3gSNT3TuA86jecaFwIIYYprRQxT3ydiJjXi5YntAdFuGQ8GQToDmq6O7rxbygijJcYbsJ48G+Izw3eGsiipqMAgDxffF5xBfHpQOwYjZMW9LYJMYBkhLVISd5AC42e2Vz76pf5zWl38cOrf8k5/3hPz2ghG//4qhO+78V5F/PRh95ER0LE3Bar54zhYrYdlcbSNvPtA0zVdexWxbxtGa6sJoQQQiRADItbDt7I+/JW8+n8V9hozeN/2z/P9yZ8ixcW1nHbM89DLErE5WbbOWfx2OLfcrp3FU80n8m3N1xIc8RsEV2R+vJbXqdoSyMHFl3IUnsji197lDP8q/B4IkSjGq8nwv9++H9ZOn8lAK3RTPZHKtgbG0elnsaW2B/YUtPAAfxw7PjYM/zxkdXER1izxIvqrOLS7BC/bT6be9rOGPwPnKaeic1KdhGOM/fPj1B12gJiPi8TXnxNRlcLIVKaZdss/OOfiGb4cIXCWHbyF2BNdRrYai3g/ft+waNjPsP9C3/Pl+Z/Fu+2MGE0XiIE5jSxIG8vv3jfX6jIaeHOVRfx+zUXc6hP4w4Hya/aQcvoaeR2vIhlh5P6mdKNBKxFSvIGWgBocI3io699nP+a+3deufc8/vzy1azw5dNZevwq0yFVwBNzb+OKn0ziPWt+y5o5Y9g4fdRRAesC3cXS2B7yCbBNlbHWGiPzV4u04ydMGBcxel9hXggxsGJYPNh2Oo9tXsJ/TXmSr1f8lBuyHua2d/2Wy31/5Ny3X6H4Qrhj2bfoiGXyqY238HTtjGQXWwxBedV7yHrmAQ4svICVkz/AxvyzKL/2eUJ7CimY08S3w7dSWPMhRmZ2MNZdxTjXXib49nCBawVZVgAWQm0ol5WtEyHUBm4/WB5Y5I9PA7IiAItdqKn1ELP5ct01vNw9NdkfWySZJxBk/Ksrkl0MIYQYNL6OTnwdnckuRtqw3RnY7gzeqJ/Cx5tv5g/z/8iPPv9bvoxCrSsnPLeRqz78DJ+Z8AI17QXc8vfPsr52/HH5FOzdRPP42XTlTyWneWMSPkn6koC1SEme7lYAwv4Cop11fGf9tVw77k2+/5lvkeGKcN/Os/ndtgsOp9co9nmuBTT1kyu5d9LRo36U1szU1cyyqwni5iVrCjVW/uB9ICGGCIXND3IeZ0+0mF8HLug1nVYWEV8W3mDHIJZOiPTTEM7l9k038PDBxXxn2uM8WXAlmy+fQfaVnYx17efJ+kV8e8u7aYrI9Auid+5QgHErnqJlzDSqFpzHvo9dAVpTqxRbAU+oAV/bQXzdB8kIHMQVbUehGe9vZGn+Lpbk72FZwU6sQPxCXCs3uP3o2X6Y7UIFGgAXOmc0L1dKsFoIIYQQAyviywPAHW5leftUPr3+Ru6Ydx//87k7+H9br+F/ZjzGvLwDPFa9kJ/+81q6IieeniqzpRZfexMdBbMkYD3IJGAtUpI32AraJuIvOPy7x/YuZnndVL448198fNqLvHf8m/y+40z+1jGfavdZdLrGMzb8KF7ddlReOTrA0tgeiulirypilTWWiJKvjkhPs9zVlFodlHo7eD5czdbY8QuOamD/wsvpKB3H+DceJaulevALKkSaWdkyiXevvJ1bxrzGp8a/SHc0g89s+jD/qp+b7KKJYUIBhfu3kd1QRUf5WELZ+WQ1VpPVVE3H9O4TvqMyUEJloIS/1CwFNHsu/z+IdqOiAYh2Y0XiNy21KwOdVQGW9J+EEEIIMfAOBaw9oVYAXmqcwWff/jC/n38vTy79Ba0RP599+0P8q24eOZHel/dTQOG+zdTMPpuwrxBvqHkQSi8gwYsuWmHnqRF0hydh28vwRRKWV7A203l7ZSfqrJ+kxsSt0G0Fnfe73ZA6i5lEs5wXjFHaxhNsJ3xEwBqgLpDPV1Zfz9XP387O9nK+WvwMD468h7lZMfJimymMrXsnDzTvz13FRZGt5BBkuTWRFa6JQyZYnb/V+esbGJG4ubGi2ek1z1bHhJP7vFGvn5bR07Ctd6bLyN0xuOvb1jbkJSyvN96cdtT/z/bsoNP20Whnc4P/TRTH76f6KUvoKJ+IFYtyYMFlRL1+4+15Rh0/Xc9gUglcjyqSN7jfmczqxE1P5Gkb3DqrDPoPpiJNyT3fmbS7/urE7d+8Ca2H/x3Rbu7cdx4LX/kWZ776tX4Hq0NFzmX3NSWu7MVrEnfcoxnOeeXvSp3zmB7Ar6g30ElR5WZGbHydvJpK3OEQBW+bTAGlwOUFXz46qwKdOx47Zwx2VgU6e9ThYPWb8x8duMKfsFiJa9gHcr8PRSbXdqZ2fNi8L5AIiSy7KutlYdEU5WtMXEXfV1nqmGb0jNqEbU/Plif7AMoL2pNdBEddzc7xF1OFbydwik7L+ZwR6khcLCfvu4nbDya6R6dOXyh7f99/j/ryAXCH3xmQ+HzDLD6w6lN8ev1HuGzFf/CvunlG28rfvxVsm86CxKwJ4e4c3A5FLCtxx7397eKE5eUk4ZE3o85Bk9cxSadBQDeWHTUpEq6oWQMWrspyTJOoauUfa3YyLV3w/9m76/g4jrvx45/ZYzGzmZntOGSHOWmShtqkjE/K+JTpaX9PU3jKbYpJuaEGGmayE2PMbMuyGE9w0uHO74+THTu2tWv5Tiedvu/XSy9burnZ2b252dnvzs60WaY52FhouVDJiil7bG3v+bWzbKUbLKtrBu2yEYyOKqJZ1ulyNu8nXJDHuK8fPz9eD/BV5nP9hjFc5Kzm0YKr2Rat4uHIHOp1PnkqwK3u15jmaOL5lun897YbaQnnDLi9d53/kmWZ/vzMCss0AP4ZNgIeDQa+hoFrZGBClICNwOu8mQct02xZN5Foho2LPhsn+UEzNLHM2MBpikPW+bRYty+mU9M51WJbQEZt/CI+6s6gbfwiOsbMQztceLoXU7n5MTyBdoouqOdw7XFgMttdxxLPQfZGinkhOJXDizqE/1Ruub3GM60/TyOqaGortkxnx/9cfs+R/7t0lKWxA+xXxbSobM4y9/Gx/OfZbxTT9ky87M2zptFy5XIq1mxk3Iuref1TH6Rl7IUsuvMvVJ9pHfDwvJxN4rqAx3N3Q+XzJ6+jje+wd1H6xXlPWqb56c7zbeXVttv6pO85y/rCI7YjB4eNG5h2Aulmvr0bwge3Hj/C/q0KZ7VapnHYbDead1kfK9Otkxq0ViYYwZO3vUYUIgOfLmzfAFSPFlim6VgegrxjP683e0dvtmFGh/WAAW+TdS8nWGraiv+1LrJOlFltkFltXWdbF9mos14bbWPAQfwZEAuOJJ7H4Li1Cd8qUmG9oI/ht9eFdwSs292uidb76woovI3WeU149AMJKRNga5WEaJ71eTprj71j1eu2MfDGZt2IHrK+pjgdVt/BB15capmHnRuTyvrwAhAusP7+qbBi3/U2jssYGwOEmqzbeGeXvau2aNg6r1iGCRnW++huta5rMRv52GnPTocRgpwDJ69EHdOUreOXvd86TdfiIIcaBj6XFRd1UzzF+pq3dXehZRoA8m18VjYGSHxi1vOWaX745JW2ilT+knXb0XCuvZhF7Rbr6wVt53roNBhBRc72k/crojb6rcaaHMB6kE1vqXV5giUaTOvjZ6cv5Oy2rtdGGMA6prXvJuu6mDe5A0zrbV63Yo1lGjttvyNgELLuXmJ6ktcXMkMOevcO/NkX9lhvv9ViXEY4IxdHpIdpdx07IrqDYjooJhvIJl5X61fmDZiXw+yloHof3aUzmfnyywMumlm/InFtuDnbxpznddY3PXIm+W1tr2tfnmUa02vSdsg6XW4C7psNj6GiQiRBRm0D/rkz0Zzs2lDxh95P8onw5fw890Zu9T7OFx1P8EZsDDMcDRho/hFaylc23nDSHISIB6oX0zFmLtpwkNOwi8z2GpqnnsOBM95B2Y7nGKsOsMx7gDO9+znDu59c482g6Kt9k/iR/0JazWPnl414vLROmUkoK4cxa1/BEbN3gy6Zxup2nGj2G0W0k8k0Gpln1lKj4r2enpIiNt92PTk1dVT8cSOtnVMY+6vVVH/yXPZdvAIHr6R4D5JEa2bQyHTdyGZVyT6KZTFWIYQQQog04tJRJtJKPbl0q6F9YkCIt1qw+SCz19Xx8qKpVM8buhGvI0nUnYsz1Gmd0KaS7VtpnzgF/9jxFFTvT1i+4uQkYC3SVsahemI+L6GiArytx88z1DljCuvDVzPN9TJbdSbf7ruKS1xbOde5h4NmIX8JL6dNZzHYYLWbKAtUDZt0FUEbd2DFyBIzvHQWL6dn2jy0Msht2EHhgTV4+hf8rOjezsrlXVxyziuscL+AW0Xxx3ysDk5kVd8k1oXGcXnmVj6Y8wp3l97Fz/zn8wjl9BSV0jh7Ee0TJqMd8Sa6L7+QaU89hJHioPVEsxU/PtrJBKVY7xjHJbHtzDQbiHo8vPH+W3BEokz8vxfYsPtWTO3AeChGYeVu9l23ksqeOjKjB1K6D4nm0RFW6N2MpYM+XJyndzOVZl5mcqqLJoQQQgghTlO27mM+h5hGE25iBHDzoJ5PpxraqRyEAPAR5qata5j1oXpUGGa76/jVnedxUILWx4l48vB1W8wbcgryDx7AFQjQNHOOBKyHiASsRdrK3lcNwL733cLMH/4addRjG4ExFWz6zhfIUu2c4/0LAL14+HdkEY9H5hDChT7NUdWTVTOLjINETYP1evxp5SWGn578uXQXLgLA29mIz1+PEYsAmusmv85nFz5KvjfAjsh0fhL4NFv7FIfCUWJHTSx0T89iVvVN4kv5j/Ol/MdZlbWUTSvfTTCvELSmat0rBIrK6Bg/ma7yMeTVpi7Yq7RJAQE68eHEJKoNsnWQKIoq3UHrjMkESoupWrWWQGMJpnYADkwNvuf88HaDTu9iMnvSK2A9iRbG0kE7GTyuZnOZ3kolfmbrulQXTQghhBBCnKZlHGAqzfTh5BUmcTb7mEstLzM11UUTo9BC4yCz19ejw4AJjohm9ro6CVifgDZc9OaMp3HuTEo3bx90dMdUBt1lE6mbPZOIz0dPaVlCyylOTgLWIm3lbtvNxLv+xf733ITpcjLr//0cwzQJjKlg/f99C4CrMu7Ao/qOeV+iRkPv1GXsitmYdEuMSDlt63CF2oioSfQUT6Bx1kUA3Kz/yP+U38NLobP5ZOvP2NVSzLic5yliM+oEs+DXxvL5R88Svlf4EIWZXUx//AGap8+hZepsahefDUDRnu3k1lUP5e4dRyuDVcYkzjL3cnlsKwHclNJNC1m87phAyeYdlK/bRO2ZS6jYuRHjrzFMDYZh0vC+OXg7OilSz6R0H5JhF6Xk0scsGninjs8tt4MyNqhxKS6ZEEIIIYQ4Xa8wGQVMoZmz2QfAFipTWygxar1uTqR0YSfL3fshAjGXYutiqY8nUrb3XlrHXszmd99E8dYdzLj/Ubxd9taS00AwtwR/1Qz8ldOJeTJw93RTtX4Npdu3JLfg4ggJWIu0pYCJf74PIxJl7wffiXY6mfCXe9l4x9cAWPjZb1Fwf3PStm8mbIlOMRwpTDJ69pFRW43eAaGsQgJFE/ivRb9lf3gcb9v6C/JqtjC+u4WiC+oHzKvHjC8zmOUN4mnqZsz6VVRtWE3H2In4/O14u/woneRFwGw4ZBTwKpM5x9xLFiHWG2PZrUrRSmGYJnP+9gBGJELd+xZT5tqM++UAdR+aj3NymMW/+BPN/zX8Vyw/VTHlYLWaxCFdgJcIXXhpVhYr7iVIqbOT5mg2WtoaIYQQQpwGrdSw6GsOR0Hl5mlmskeXMIFWaijAr5K7sKoQJxPFwQNzFrPtzkqq1rWzd3GpjK4+CU9fCxW7/o67diZ7LzmPVV/4GFP+8zRVr68/rr2Lun305pXRl19Ob34ZfXllmC4PKhYlu2k/+TVbqVx3QNrJISYBa5H2xv/jQYxwmN23v5fmFWfgbvez8LPfIutgLXZW9xXCigK8PW3McW7hnMzX+cG6qyjb/pzt9/fo+Ar12d43R/srrSk4uC/RRT1th4wC/qkW48Akoo49hSitmfWvh3GEI9TcthxuA4+/kyW/+BOZre2k8ymnVuUP6fZuyV/D18se48muGXyx/jpC2nrVcyGEEEKIo2lg33lX4OrrZdxrz6e6OMNatSqiGgkMiuFh17xyds0rT3Uxhj2FZvwLqyjZsoPtN1zNjhuuonHhHMasWkM4M5POcVX4x1XRV1QYf4Np4u1uIa9uJ76OBrKbDuCMBON5SbB6yKVv9ECIo4y9/zGcPb2E83Ioem1Df7BaiMS6ZdoqglEnD+xbekrve3OEdZ9FyuHBVMZJnyBQwPR/P47X30XU56Vizcb+YLVIlJvz1vL1ssfYHizjouwdFI/9M7fX3kIbQzOyWwghhBDpQQGOUJCmGfMo2bEJX6f02YQQ6SejrYNFv7mb+qUL2HXVJWy+7UYA3F3d5FUfIqd5OxkdDfg6mzBi0RSXVhwmAWsxalQ8+UKqi5B0LiNKxHTAaS4YKU5dpivI1RPX8Xj1AjpDp/aY4OGAdbZnZASsrShgwvOvproYaenmvLV8o/xRnu2exqdrb+C87F3cUfEAfx/3Bz6w/yMc6i1MdRGHVNhTSHfhXPKaXsMRS4/vjxBCCDGUqjason3iNGqWrWDaU/9OdXFGvPgYTAOFOWTbi7pzcIZ7hmybQoxECqhcs5GSLTvpy8/F1duH19+JAupX5qW4dOJEEhqwNvqs59E0fTYbUWU93L600m8rq9bdibmAv/isN2ylG+drs0zz+y1n2cqrNmzjMfNWj2WSF1tn29oezuQ95uDwxMie6B8wTff+PMt8tM0y7vvJGZZpZhtrbeVlx5+fO9cyTebETlt5RTbkWaZ59PY7jvndEwtT2tdB1HDQ7cqgx+nlu02X2treM6vmWqYpmdFiK6/mXUl8VM5UOAKOgdNYvQ4sWrzXMs36dZNtFWnVx34MgDvcQ0YwzIXzDnLewh8fkyaGRZ3VGt0Nalovjb7YgEldrdbNdiwzcZ3Vrz14k6105vutv5fZL1ufI7qmDLz/pyucBfVnn7wcNk49APy/R661TONps3fjqOhc6+/Ww3PuwhcOkBvqIujwMKu8k6cq/gBATzSPcX3t3HPhT/hk041sD1UMmJe/M8Nye85ar62ymx7rA9a2x/ocbObZG8kw5VOvHfl/z/gxrP/RB4jk5xLrKmLR576F29/Fvh8tt5XXYGkDogN8x7L3W9fzcL69ihbOtk5jdNibDsa0ce4Mllq3HVkH7M2ZHrFR9q6Z9j53V4d1ux6zrtYMh+neHd4YOVM6BkzTvcO675c5zW9re31brfOyc84Iu+3VWctzNOBtsvdBBIutt2lkRizT9M63TgNghqzPrxn77H3fgiUpDhoVhSyTmOXWZcx8yd4N+HCBdRptsw6pOp91IhtVKJpj7zMwc63bIWeLvc89lmG9zf9ce2wf0RcLUxHqoM2Vhd8VP963fu9ztrYHcNB2yjc52gPk/G31MX+b2JnBnv96N+G9QaJLrK8tAbptPNil2q2nX2zutHmtnm3dRzS6rdsggHCtdd3+6darLdNM++2BY373TxrP9ndfT7Agn/k//xMFu+LT+1W/d4KNUtmrs1O/tf3I/7Wh2PLx99GwcjkqEiG7upac/QfJ2dNFTm0DWY3NGLGTH7dqW1s8QUkzTAKLBhgocCjLMo9CG/1fsNePzKyxd17RhnXfXNuoQhHr3QPAWdFrmaY4s8dWXg//xzq2QbZ1Hcq22Wj4ZyRxAJyyjum0LrTOxtdg73OvuSLvBH8NxgtC/LW+cuv2JTDO3jExQtbp7J6j1DbryqYnBi3TuO+1N32lvsi6/+Cutned2DvwJaktMsJaiDRwOFgdUwYaKAx1kR/q5kb3Wl6ITKNZy1QBSaU1nnAPUcNFzDGIedGVQqPIccoIUXFiRwer/b58UG92hCJON22ZRYT8EX5X/lf+u/laXu6dksLSJl88WP0NjFiMGT/4Nbs+9l7W//hbLPzct1JdNCGEEMIWXyzM2GAbBpqKcHyUX4crNYv5jXnwCequuojdH303Jf57ZKTuKQrlZrPrpqupP3cZnnY/zmCQtV/6GNP/9gBjn345KdvUSrH19vfQsHI5Y//zLEYkQtekcTSetYTarHg9UtEYWY1N5NQ2kL//IBUbNielLEIIkQwSsE4qTS59FNFDNkF2UUof9u5YC2HX0cHqRl8BMWXgMSNkR3pZqXdxoXsH26LlPB+ZzpZYJXo4DDFLM85YCIcZJeC1v/Cec10I5+ow0eVuoos9aGVIwFqc0LVZG08YrHatD+NeHSa83E1kkZv31L+Dn5bew49L7+V/Wy/h/u5FKS55chwdrJ5y+130NZcyZfdf2Puz21j/f9+isPM/OCP2RqsIIYQQqXA4WB1TBvu9hZSFOykP23sSM9H8eiodkZlU3PEMe3/+Lrqc88lt3ZCSsow0psPg4MUr2HvdZZguJxMefppJDz2JNgw2f/Q2drz7BromjCEztgbDTNxThFoptv3Xu6g//ywm/eNBJt/znzdfA3qXzKGrqpyuqgq6qsppmjuT3qICCVgLIUYUCVgnyURauMlYd8zfztJ7+Y1eQQx7jyoJYcXQJqV9HZhKxYPVRrxuhRxuQg43v+g8h3Oce7jUvZVZzgaqY4V8r++KFJc6/bgivWgUEZedZ9Ljweqcm9ogosGl6PpXAUzTZDusH8ERo8sCTw1fKnqCsOE6LlhdcFMbRAAXtP+rkHZnFh9suJX/Lfk3Xyl+Aq8R5W+dy1K7Awlmupxs+OHXwVBM+chdbG++HRMnxt4oUz92F7t+/T6aiq6lcudfUl1UIYQQ4oQMbTI22IapFNXeIqKGg1pPAWOC7ZSHO1lctYd1tUPzpJRfT2UDX4+fS7dGyXzkIP7LlpPT9gZKyyhrKxs+8yFa580kf8deZv/+H2Q2vTnNxcL/+z17briC/VdfTFZzIVVb/jNATqem+uqLqLvwHMY/8PgxwWqIT3KQ0d5BRnsHZZvj04doIOqVgXNCiJFFhlomSQfHB646yCQmh1wkkIkiYjhxaBO3eewcjUqbzHMcYqHzIB4VJaDdbIqOSVFJ05tpOFFonDF7AWfn6jBENCoGRDRZL3ZgaJP7m9NzRKwYvLpoHgcjBbjMCFnhHtDx+d7cq8MQob8O9f8OBLWbzzbdwDM90/lkwbPM9xxKYekTT0WiZO85QCQ7i+a85Zg4AQcmTpryz0S7XXgCDakuphBCCHFSJoqQ4cSpTXxm/Pzt0jE8OkIUgzq7czonQAczjzmXBvxj8PQ2gASrbSnavBMVidI1vormhbMxHW8OTAsW5NE6ezoAGf66hG43Z38NKhKlfc50IhkDz/sezvDRPmUi/vFyHSiEGFlkhHWSdJDJ/zMvQ6EppYsYCj8ZxO95CpEgStHoy6esr4OSoJ9mbx4Rw0l2pJfsSB+3eZs5FMvnz8HlrIlOICxf+aQIubNxhwP4gp10Z3qOmV/4RKLL3eBSaDS4wFhs0u0r4Mk2m4ujilGjOZbDu+rfyxOTfkVWuAd3LIzfm0d4uRtc/SvRu4j/3i+GwbdarmSqp4n/V/pvbql9P34zNXNiJpoC5n7jh2z6zudp/tgy1KdiaBOUQ9Px3jlUPPoM7gp53FUIIcQwphQ13kLGBtuoCnXQbEYpiAZQGqp9hTR021jFMkHy2Y5BND5jtccgM6+GooMPyxWrTeOffIHiN7ay89br2PXOa6lduZwZf7kfFYvxxsffh3Y6WPij39I7P5DQ7RZu2cn8O37NG1/4KOu++RkWf/PHOHv7CBXk0TVxHF2LZ9NVWU53ZRnB/DwAsusaKN5pvfC8EEIMFxK9SjKNopHcVBdDpDGtjCNB69KgP/43IOD08suulewzi5EbJUmmFEFvLpl97bgjAcLugVfzjS720POPPDJf8sMSTfdZRUSd8pieOLE+7abTl0co4iYn2EVRbyv+ebm0/6vwmDms2fTmewLawxebruOuirv4ctETfKH5+tTtQII5wmHmfe0HbPrO52n/2XyM10OYyzxU7X2SaT/7A/t/aGMVdSGEECKFTGUcCVqXRrqJoTjgKyJsuIa0HHlqN9PG/oGdKz+Ip6KFxb/8JjXfkQEUpyKzqZVFP/otzfNnsvPW61j337fH/17XyIKf/J6shmaq509I+HZL1m06ErRe9X/fxPS4COfmxF80NRmtbeQdOET2q2vIqW0gu74x4WUQQohkkoC1EGngcNDaFwvjMqP0OH3EDAf7/CWpLtqoEXH6iDg8eENdRFwZaHXU9D9aY+gYrmgIZyyMKxbCMT2GOcOgK6OYmGNoL07EyBR0ZRAx3OQFOyjo6yAwK5PuhdknHdG/K1zG3Z3L+VD+K4zvaKU6UjTEJU6eI0Hr736R9vfNZcz9jzL1l3fJrTkhhBAjxuGgtVPH4muhGKm5NG/58DK849pZ/Mmv4+qWRYsHq+SN7RRt3c2h85bj7eikcNtunH3B5G5z3SYWfP+XHHjbpWQ0tZC9v4ac/TVkKRNnOJzUbQshRLJJwFqINKGVQa/Tm+pijF5K0efNJTvQjDfYScidiTMWxhkN4YyFMPrnAjSVIurwEHRlEnZlYBqyCKuwL+Zw0pZRRE6oi8xIAKcZwe/LP/YGyVH+2bmYd+W+xq25r/M/rem14KojHGb+F78LgDJNCVYLIYQYcUxlED7JOXyozP7OT4jkZuFp60hpOdKBEY0y7umXh3Sbxeu3ULx+yzF/05OqhrQMQgiRDAk9O5o+68UZjL7EbbJ199AtSAHw1KvzE5bXB+a8mrC8HOV9CctrtHnopSWWaa45d23CtheozklYXpf+/guWab5c9lTCtte8K31GZ9qxaPGpz/FmOtyEXZl4IgFyAs1kBP04Y2GiDg893jz8mSV0ZJXTnVFI0JOdtGC1I5C4dla7dcLysiNnT2oD+PrQ8QvmDlaoMEnHTim6vLn4vbm4Y2EKA604zCiPzfvjcUn9ZiaP9MzliqwtFDjsj5oyq5I7IuitDP/g7p8bponxlmD1pM+uTkyhBql7onVfKHtv4uq5ry5x33fTaV1neyYkbiGujJrEjZtwdVgf01hmLGHbS7XArrxUF2HQgqUjdzG33kkR60RpJHBuYufdHVJm4m5jxoqH9nP/65d/OKTbcwaD+Jpaj/w+6VOvDen2jQQ2zWZ24jKL5Fm3Vfs/lLipPjwtiTufq321CctrUIqtF6Jv25O4WE5gbOLOK8pGFXIl8EGEAy2JOw7Obus65J85cs/Bb9VXPrT7YroSd23n7BraG5UtF1p/J+2KjB+668RTu1JQA1/MGFFlK2hti7bRyVDaVtDa9FhXLCNkY3um4qmXF1gmc421bsFCrQOv5nuYDlpXZDMvAnkWHSmbfTZnQ/Lm0Y2FHHTvyx84kUpcI5C9z/rYeTo1r25YOmCaGf+1jXPO2G6Z18uvzbRVLjtB61hV1DJN+QsObv7vzw+YpnmpveNZssZmBVlTbJnEvDh5nXoVs27cJ5xz0DKf9esmJ6pI3LD77cf87lURJjmbKXd0sSVSQVMsB/Nbpbbyylps3ST3jklghyxs/bln1tmrG32l1ulyDlr3AOtXKoxo8sbKKreJY9zJL8Cj9RnoRuv22YhZl9H0mgTLrL+DQRvnsbP8Hzvh3xdlHuTX4/+GO9KNPyuTv87503Fp3GYUd1+Mf0z+Ay3uHK7892cstwf2zp12gqWBcTZ6/hkxsFG19/3Een5qd5uB22+d12CpGHjaT77fkVyTwLiBd6Zgs8Kz3vrYtc9N3PfdiNjoGNs8B9sJWtsJfhtRhaPXRrlsBJ7GPmPj4nimvT6O6UheGxSLGvjbBl7nwLB5o7DngI01UjJt1CEb7RmOxPXPtGHvIlPZqf6t1p9pLMPe92jiPdbpqq9y0mcj4J7A7uxxDHcMz5iBrzWyH8y2zKd1kXUhsyf60ZdYf7eWFTVZplnzynTLNGDvRrmzotcyTSRk7zLXaHNbJyoKoSusz2VFT1o/6XhV9LOWac47dzML37/JMh3Axt/YSnaMcGUm1R8786Sv2/3OJMqkf9kbfFVzqfUC0hdfsc5WXg9vnGeZJnOf9ZR9vdND7PhehWU6h8e6zuome0/K7v7WDFvpbFk/uLepkIFrz8n7y+F80zL+YPpMmussYgNAwS7rfkL2dfUwyzIZbT3WdajvoHX7aeZZX6sDlOdY3/Rr2lHCnjrrcl13pfWNpBfrJ1mm6VpbTMC6ytqLjw2SI2Qdq/HPsT7Gjl7DVn8ie691HQoVWe+vLghj5/RutlufVxzlfdiZFNRZZn0cQk3W9cfd4sQ/xXp7qtm6X6U0xHzWR8LRd/p1KLXPHwkhRJoJahfbIpU8E5xBUywXWfBSJNP6wDiu3fNRmiI5jA22kR85vmMcNpx0O7zkRwIonT6jKoQQQgiRnoK5ObROnWRrDJsQJ6Yx7IyGEEIMWzKHtRDiODGnk4PLzyNQVEYoM5u82gNMfOkpDDN9HqdOJdMwWP/+d4HWLPjzP2RRFHFa6sL53LDnw7yy4A7Kw524zShN7pxjFmNsc2WSEwuSF5UppIQQQoih0DppBv4xk5j40uPShz4FfXm5rPvwuwnl5JDZ1MK0R56g4ID1E5RCHFbi6OKnRf+i0tnJ2uA4vt1xBZ1m4qb9E0IMDRlhLYQ4TjAnn5Zpc+gtLCbm9dI2eQYxT/KmixltIpkZdFeU011ZQV9+XqqLI9JAj+nlkKeANmcmhdEA44JtOPSbF8deM/44mUvbe4RRCCGEEKens2oCUa+PiE8CZaeiu6KMUE58CsVAaTEtM6eluERipJnhaqDS2QnAEu9BJjhbLd4hhBiOZIS1EOI4me0tzL3nj4Szc/B0+vEEulF6aBffS2ee7h5Wfvt/ifq8uHtlxKtIEKVo8uQSdLgoD3Uysa+FWk8BXjNCebiTboeHFlfiFn4VQgghTkShGedoozpWyGieGm3ii48Bo/kIDE7x9l3MvP8RAkUF5NXUUrRzT6qLJEaYl4JT+Vb7FSzwHOL+ngUciFqvwySEGH4kYC2EOCFflx9flz/VxUhbhtYSrBZJ0enMIGi4GBNsZ0IwPqKk2+Gh1lOAVnLZLIQQIrmu8Gzmnb41/Kb3XF4Mj97RsXLGHRwFVGywt+ikECeiUTzbN4Nn+xK4QKUQYsjJlCBCCCFEmgkZLvb7imlxZdHozpFgtRBCiCHhI8zVnniw8Vbv6+Sq3hSXSAghhBAjkQSshRBCiDRkKoMWdw7triwJVgshhBgSl3u3kG2E+HngPDwqwnt8q1JdJCEsOVWM6RkNqS6GEEKIoyQ0YG06h3iOW524C3DTY6PsRuL2z1OUuKkADL/LOpFMP3xCoVzrOrTjV7OGoCSnrmGl9WrjJWskSDUcGN9oTnURBi1QeWzjoZXBwSVX0jJ5cVK2V/FCahsrZ0XiRoIZwaG9J3zVq7cP6fYSqteRsKzChWbC8hoMV6f1594+d5ielBPYr7Ijkf3GmgutFwYu3B5K2PZGnVji6oYa4q+oozdxbfH4R0bXwrXd+/NOKX22CnKFZwuvhyewKjKZB4ILOcN9gEXOapaevTM5hTwJlyeBn1Xr0C48/vxLc4d0e2+VyO+MHftu8iUsr6cePfX+qYHJL6b+nScX/IR3l715gyUwKWL53oydiasbqjSYsLxSzd1hXYeMvsTVs+4HKhKWl29ct2Uaw5+4mXVLZyTuOnFFxT7LNDlLWhK2vVSLZQxth0K1uxOWV6whce2eHeHixJ0Th/Jy4dS+aYaGjJMHyYwu6+zMbOsgGwDK+iLGl2uvUb916lrLNL9//jy0RZtZOsXe6rK5Xutg9J5NYxJ6t8AqaG33yzxmca2tdNZN4UnY+FwTpXuS9T6PnWV9J70r5GVLa7llupzd1p9o73k9lmkAqLO3mnjz0oGPp7sqgJ1m1fmi9fbqV6Q++K0NiGUMvM/td4+1zMc9xnpf7Aa99m2uskxj+kx4h3VeRt/QnnTt3Kib/uO6Y37fd9WFdFVMoatsEuMe3Ej+3moAdn260jKv+pXWx91unR20oIHakXXSl00X2Amd2jlRm77EfZ4ZGdaBtkB1Dlf++zMJ26YdfZXW+2iEbJztHBps9CFU2PrAaxeEC5J3rlExcA1wLRPJtg5ahwpMWhfYKKPDOo1h45gAuNttHDsnWM26Giy31+GteNb6c29abisr29+l6qsG7guZLg1Y90NVNHnnO0+rZtIfBy5D4zLrVtDOdw/AzLH+vOz03+3ezAu3WV+AlY1vs5VXi//kbfVhho3BJBG/x1b388CtNq499nrw2rjWj84JWCcaJN3rQG8aeAHd1kU26odpXc8zDynMgwWW6e787N0AeIJ+3OEIs/L7uLPoCdCaWMDFZ7KfY8GmL0OVjWu3Jq9lkmi9vX5yor7JvgYDbAQXYjdbXyvqPdbH08yL8Mz26bbKNhjx/vTQ9Dm9TTauj8bE2HOb9eduhO2V+dFXFlqmOXDjnfH/aI3qa0GFO9GGm29Neohvznkd3NlMvufDBMsG3uZ1K9bYKtN9mxdYJ+pzgNd6H11t1m12LDO5n692Qqj05OeyrH0OXD0Df/a9VaatmyOd06z3xcyO0VFjvbDi5fM2W6Z5bPMcsDp3hg2wMTCl/pD1990RcNiKkTzw4lLLNHaYOVEYG7ZMZ6dvMFgaMC0uuOzUjViGaast655ss2AWMsd32UrX12B9I8s5yV5cqO9gtnUiGwNAjKgimp2YdkEb9sbDxuzGfgcgU4IIIYSwpWtMBXuvvpiS9VvwtvvZ8v6bibltPOEhhBBCiLSmzBjucA8RVwamo79voBR9vnyUjvGFiidTW0AhTiTUEQ9We/LR2WPA4UX1NkFE5l4XQohUG5UB61I6OUftxsXoeqxPCCEGy3Q42PL+m3EFepn9p38x54//pLeshN3XXZbqogkhxIjWVV4m88yLEc8T6gQ0IU8ujnUh3D/vwrEuhOnwEHZn8c6iNSzOrE51MYV4U6gTI9iGdmWjt2bAz/3oHQVguFCBBqZn1ae6hEIIMaqNyoD1JNXCucYevFjPSyWEEAKiGV6cfUFm3X0v7kAvhTv2MvbZV8AwZIp8IYQYpGBONruuugxtjMouuUgjWhmE3VkYG2Jk3NSC5wedZNzUgmNdiJAnl02BSnIciVvDR4jTpcwI2pmB3p6DurEedUcb6qYG9M4CMByUe/2pLqIQQoxqyZuYZhh7TU/kjdgYehnaBTSEEGKkcncHWPr9Xx0zH+SMvz6QsPkhhRBiNPJ0dTP/L//EiJ3+PH9CpFLImweAe3UXRDQqBhqNY3WI2GIP1+35MImbVVqI06d9RaA1rO44ps7yWgS9ZBzPt85MdRGFEGJUG5UBaxNDgtVCCHGK3nqZKZedQghxehTg6pNRpyJ9xJZ7wKXigT+Xiv8OSK9BDEtKwZm+Y+osZ/rifxdCCJFSozJgLYQQQgghhBAisWKLPfT+qzg+snq5h9hiGSQkhrnFPvS9lbCqLx6sXuxLdYmEEEIgAWshhBBCCCGEEAkSWyyBajHCLJZAtRBCDDdKa/vLZSmlWoCDySuOGEHGaa2LT+UNUn/EW0gdEqdL6pA4XVKHxOmQ+iNOl9QhcbqkDonTccr1B6QOiWNIGyRO10nr0CkFrIUQQgghhBBCCCGEEEKIZDFSXQAhhBBCCCGEEEIIIYQQAiRgLYQQQgghhBBCCCGEEGKYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgLYQQQgghhBBCCCGEEGJYkIC1EEIIIYQQQgghhBBCiGFBAtZCCCGEEEIIIYQQQgghhgUJWAshhBBCCCGEEEIIIYQYFiRgfRJKqReUUvotf1uplNJKqW+mqFhiBJE6JE6H1B9xuqQOidMldUicLqlD4nRI/RGnS+qQOF1Sh8Tpkjo0eCM2YK2Umq6U+rlSaqtSqlMpFVZK1SulHlVKvV8p5RkGZbyrvxIO9PPsSd77bqXUGqVUT//+vaCUunKo9yGdpWsdUkpVKaW+opS6Vym1Vyll9qebnKr9SEdpXH/OUkrdoZRaq5RqUUqFlFIHlFK/lzqUWGlch85VSv2lf7/alFLB/jr0sFLqglTtSzpK1zp0gjw8/fuolVK1Q1X20SBd65BS6j0W6T+Sqv1JJ+laf456b65S6ttKqc0qfk3W1b+vdyqlXEO9L+koXeuQUqraxnu+lqp9SifpWof631ei4tdlW5VS3Srer16vlPq8Uio7FfuSjtK8Dk1WSv1JKVXbv18NKn6dNikV+3GqnKkuwGAopb4OfIN4wH01cDfQA5QCK4HfAx8FFqeoiIc9CFSf5LXbgInA4299QSn1Q+CzQC3wO8AN3Aw8opT6uNb6F8ko7GiS5nVoMfA/gAYOAJ1AXlJKN0qlef25HygGVgF/A6LAcuD9wM1KqYu01quTUdjRJM3r0Pn9P68DzwEBYCxwNXCVUup/tNZykXaa0rwOvdX3gHGJK5KAUVOHHgLeOMHf151uoUa7dK8/SqnpwFNAJfBMfxoXMB64kfi1WiTRhR1N0rwO/YQTX38p4MvE4zBW5z5hIZ3rkFJqPPG+dAnwQv/rXuBi4A7gVqXUGVrrvmQUeLRI8zq0mPi1WDbwLPAP4v3pm4GrlVIrtdYbk1TexNBaj6gf4g28BmqAZSdJcyXw/Glu54X44Tnmbyv7t/3N08w7D+gFQkDRW147s38be4H8o/4+HmgDgsD4VH8OI/lnFNShKuAcIOfocgCTU33s0+FnFNSfLwIVA+z3llR/BiP9ZxTUIe9J3lMJNAExoDzVn8NI/kn3OnSC7ZnAR/q3W5vq458OP+leh4D39G/jPak+1un4MwrqTwawG+gAzjjBe52ASvXnMJJ/0r0ODfCeS/q3vSHVn8FI/0n3OgT8sn8b33jL3x3Eg48aeFeqP4eR/DMK6tCm/m18+i1/P5v4oLQ3hvu5bERNCdJ/l+mbxO9mX661fv1E6bTW/wEuPcH7lyml7lNKNfYPhz/U/0hXRTLLfQK3AT7gAa1161teO/yI4ne11h2H/6i1ribeaHmA9w5FIdPRaKhDWutarfXLWuuuIS5T2hsl9ef7Wuv6E7zn+0AfMFspVTgEZUxLo6QOBU/0Bq11HfGR+wbxUQBiEEZDHTpMKZUD3AU8q7X+zRCWLa2NpjokEm+U1J+PAFOAL2mtX3vrG7XWUd1/1S9O3SipQyfzof5/70xOkUaHUVKHDveVHz76j1rrGPBo/6/FyS1e+kr3OqSUmgjMBZqBnx79Bq31K8B/gHnEBzoOWyNtSpD3En8U659a660DJdRah47+XSn1PuC3xO88PAwcIt4R+QDxR5TP0FrXJKXUx/tg/7+/PcFr5/f/+8QJXnsc+Fp/mm8koVyjwWioQyJ5RnP90cTvxEJ8hKwYnFFbh5RSJcAy4uXflYxCjRKjqQ79DMgnPiWRSJzRVIfmK6U+Rfwx6jrio6RkHvTTMxrqzzuI93v+2R/UuIz4KLYa4AmtddtQFDCNjYY6dBylVClwFfHpBv6erEKNEqOhDm0jHii9AjgybYNSyiDeJpnEp3sQg5Pudais/99qrbV5gvft7//3AuClZBQsEUZawPrs/n8HXJznrZRSU4HfEJ/zZUX/KK/Dr11AfH6ynwLXJqaYA5ZlOTAH2K21fv4tr2USf2S6R2vdcIK37+n/d2pyS5nW0roOiaQbzfXnBuLzX72mtfYno2yjxKipQ/3zpl1JvK9RRfwiLRf4uIyGPC2jog4ppa4F3g18YAg7/aPFqKhD/T75lt9jSqnfA5862dMgwlJa1x8VX0xxHtBCPBDwPY69Zg4opT6htf5jssuZxtK6Dg3gfcQDZHdprbuTVrjRYTTUoTuI96O/o5Q6D9hAfG2zi4kHIz+gh/v8w8Nbutehw9da45RS6gRPBR0ewT8tmWU8XSNqShCgvP/fUx0Z8VHiJ4dPHl2hALTWzxK/K3KVGpqVVg8/BvS7E7yW2/9v50nee/jveYks0CiT7nVIJNeorD9KqQnAz4mPsP5MMgo1ioymOrSY+NNAXyEeeHQB79Va/zqJZRsN0r4O9Y9C+y3wuNb6D0NQntEm7esQ8UWnP078QiwTqCC+UF418GFAgo2Dl+71p4B4gLoQ+H/Ad4AxQBHx0XMa+L1S6vwTvFfYk+516DhKKUW8/oA8IZsIaV+HtNbNwBnAv4k/Yf854BPEz2v3EF8MVgxeWtchrfVu4gNeS4nXmyOUUmcSvxkC8ScZh62RNsJ6sJb3/7tCKbXkBK+XEJ+8fiqwPlmFUErlEu8sh4nPyShGDqlD4nSM2PrTP43D48TnSLtda706WeUTAxpxdUjH5xz+jVLKC0wgPifon5VSZ2mtPzLQe0VSjKQ69DvifdQPnOR1kRojpg5prV8EXjzqT73AvUqp14gvQnSLUur7WutNySqnOM5IqT+HB3Q5gDu11t8+6rU/KKUyiE9X9EXkcfyhNlLq0IlcSHxE4wat9bokFU1YGzF1qH86ooeJz098OfAq8QVhrwF+BFyjlFqutT6QrHKKExoxdYj4tdfjwE+UUlcSX2RxDHAdsAWYT3xqmWFrpAWsG4AZxKfNOBWHFwj7vEW6rFMu0am5lXgj88+TPA59eAR17gleO/rv/gSXazRJ9zokkmtU1Z/+YPVzxO/kf1Jr/askl280GFV1CI4swrgD+KRSygN8WCn1jNb6viSWM52ldR1SSr2L+PQx79YnXgBWnL60rkMD0VofUko9BrwTOJd48FqcmnSvP0c/6frvE7z+b+IB66VJKNtoke516EQOj4SU0dWJMRrq0F3Ep3uYp7Xe3P+3LuDO/sEgPyH+JON7klrS9JX2dUhr/ZxS6gzgq8T7PCuIz139ReLrevyL+KKMw9ZImxLklf5/LzjF9x0JBGut1QA/Lw6Yy+k7PCH6CVcF1loHiFecLKVU+QmSTOn/d3cSyjZapHUdEkk3aupPfxv0AjCT+MjqnyWxXKPJqKlDJ/F4/78rT78oo1a616GF/f/erZTSR//0/73yqL/lJbWk6Svd65CVlv5/MxNQltEoreuP1rqX+AJacOJBQh39//oSW6xRJa3r0Fv1DwC5BllsMZHSug71TyexAmg/Klh9tMPzFS9KQtlGi7SuQ4dprTdqra/XWhdrrd1a6+la6/8DZvcnWZvUUp6mkRaw/hMQAa5XSs0cKGH/KK7DXuv/95xkFcyKUmoZ8QU8dmutXxgg6eFHyy49wWuXvSWNOHWjoQ6J5BkV9UcpVUX8UerpwEdkZHVCjYo6NIDDoxiiCSnU6JTudWg18IeT/EB8aofDv4dOlIGwlO51yMqy/n/3J6RQo89oqD+H54adfYLXDv9NHsMfvNFQh472XuJz3v5Dy2KLiZLudcjd/2+OUsp9gteL+/8NJ7h4o0m616GB3u8CbiG+/8P6idcRFbDWWlcD3yT+BX5UKbX4ROmUUpfy5igugF8Q/zD+r39Vz7emdyulkl3h7D4G9Jv+f7+ilDoyAXr/HEa3E784+1PCSzdKjJI6JJJkNNQfpdQ44CVgEvA+rbXUtwQaJXXohI9JK6UmAV/u//XRBJZrVEn3OqS1/pfW+gMn+ulP0nHU3/qSXN60lO51qL8sx+2TUspQSn2J+PyTrcATiS9e+hsN9Qf4JfF5Pf9bKXU4MET/Y/jf7f/1H4kv3ugwSuoQcNxii/KEbIKkex3SWrcRn07PCXzt6Nf626Gv9v/6bDIKOBqkex3qL0umUsrxlr85iU9rNRn4sda6MTlFTIyRNoc1Wuvv9R/kbwBrlVKrgHXEH7EpJT43y5T+vx1+z06l1PuIrwi+TSn1BPFpNVzAWOJ3R1qIjyZMOKVUDnAT8WDz3QOl1VqvUkr9GPgMsFkpdR/xL9FNxFet/nj/l0sMUrrXof70dx316+EyfV8pdfiu/u+11q8gTtkoqD8vAOOJLxIxXin1zROkuUvaocEbBXXoKaVUM7CR+GPVTuI3QC7t///PtdZPJ6Oco8UoqEMiyUZBHVqrlNpKfI7qOuLrwJxFfHRsL/BOrXVXMso5GqR7/dFar1dKfQv4FrBVKfUwEAQuIb5fq4A7klHO0SLd69BRziceGNqgtU7aAmyj0SioQ58gPsDjq0qpi4i3Oz7iT92PA/YC309GOUeLUVCHzgN+r5R6BqglPq/2pcSvy+7jLTdDhiWt9Yj8IT5B+s+BrcQnnw8Tnzj9ceD9gOcE75lDfPL6g8Q/4Pb+998JnP+WtC/ED88xf1sJaOCbp1jWj/a/7x+n8J73EJ9PJgB0E388/8pUH/d0+knnOtSfdqCf96T6+I/0n3StPzbqjgZWpvr4p8NPGtehTwD/6S9jb385a4B7gUtSfdzT6Sdd69AAeWigNtXHPZ1+0rUOAT8g3neuJx5o7AV2Eh8ZNTHVxz1dftK1/hz1nuuIP3XW1V+PtgFfOdF+yY/UoZO851/97/lwqo91uv6kcx0C5gJ/Id6PDgN9/e3Q94C8VB/7dPlJ1zoETAXuJz6AKER8DYbniS88rVJ93O38qP4dEUIIIYQQQgghhBBCCCFSakTNYS2EEEIIIYQQQgghhBAifUnAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAvOU0nsyMrUzoKCZJXlGMq0TqNdNheMjCnrNE4beUVt5APxNTsTsT2wVXZbx8pm0bGZLnyotlVrXWwzV8Bm/TFsHBe7O2MjK3e3dZpIpr3NuQLWacLZ9vKyRVnvoNtvL6twjo16FrOXl7bZqgyqDmVnamdxnkUqG/XDzvfK7v4m8LZfUbZ1hewIZ1imiYUctraXkRGyTNPb57GVl4rYSGPjmJr2NgckqR1yJPC8MlzZ2UWbx8Hptv5Qo8FT6moMyNb5zl71ByBck4Q65LJRyIi9hsPOd8bu/qqojbwS91FhhO0kspeXO8c6s2Cv215mCZSsvpDLa/1hRRL4vbLD7jnRTvtiu57ZyMtOm2CjuxTfnI36aPuc77RRMCB8oD45/WkbEtom2Dln2Dxv2mrn7XwONj935bbeoLZb9rB1OjvH1Pb3DQjVn3o75PRlanfOyetQzGZfzM6xM7qtPyy72/O2WR+YYKG9k6LTY/0FMG1cczpbbZ7PbdTrmCdx17hR68sFYHDnMYCioiI9fvz4U32bSEPr169P2XkskXKzei3T9NX7bOVlJ7Yy1Oz0LQFi3dYnKUe2vbyMPdaxBoBuOk5ah06pt+ssKKDyc586lbcMmtFn3fhHS+1cDYHRZb2busA6L9Vu82LItK6gpo3tARh+l3WakI3tWWcDgLYZpKj+xOcO2svxTXbqj5lto4cWtNcxMCLWx6Xyeev9bTjDXsen/DXrstedl7jGy/Ra93zG/9ve51lzifV3xN1pr+yhAnsXaYOqQ8V5VH3v9gHTmDZuLOke6y+Eq8Pe5x7Ntt5fO51UgPec/6Jlmvur51mm6d6fZ2t78xbtt0yzccsEW3l5G6yPl8vGDaLAeJsHCzjwycS3Q2aejcg7oDqt65DdIMlQUza+I9E8ex2R0gq/ZZrW3YXWGdm8EWnnfBe1cx7pd/C/Pp/wOqRKg5Z56CavrW25Oq3Pd5Fce98Zd7t1XmGb7bcdGYdsBCnsHQYmXnTAMs2ON8bZyyyBktEGAZROb7HMp2mnzWtDO98tG42Vs8tm38tG02G3nikb/Thnr3UaWzdPgKiNAQqxDJvfkWJ7F2kH3vGVpNQhO9xtNtqEQnv7a9o4Zxh+e5edtq5rPNZ11k79AVBjrIMUkR5714C+g9Z9AzvH1O73DWDP1z5zynXInVPAlFs+c9LXuyfa+9xdVdajdbwvWY/Wsbu9KXd3WabZ8+4cW3kVTmmzTNMTtI6kF//JXmTY1WP9HfFPtndSVDHr+t8+z14ndDDnMYDx48ezbt26wbxVpBmlVMrOY4l06dkbLdNs/Zb1dThA7QXDbyKLkmmtttJ1P19imSb7vGZbeWVfttdWumf0fSetQ8PvSAohhBBCCCGEEEIIIYQYlSRgLYQQQgghhBBCCCGEECLh/HoqB/Tb8Ouptt8jAWshhBimHMS41tiA7YkYhRBCCCGESGMaaJo9nZjTeeT3xnmzMI2REdrQwJoPvY833nHjiCmzEEIMhn/2dDrmzsCvp7KBr7OPm9nA120HraWFFEKIYWqyaqZEdZGFvbkwhRBCCCGESGddVRVseu8tVJ93FgCNC+aw+V030jR3ZopLZo/pcuFrbyfq8dBbOLwWnhNCiETRwO7/ejdvfPe/aSg+BxMn4MDESQf22msJWAshxDC1S5dzZ2wlPdhcmUwIIYQQQog0lltbT+kbWzlwwTn0lBaz+6qLyTlUR9mmbakumi2OSIQ59z3I4j/9hawWewuhCSHESKOAuV//Ae7OLho/dy6GigExDKLks91WHhKwFkIIIYQQQgghxIgw9ZGnQGvWfPz9hHJzmP7AYygtU+gJIYZW04yZ1M1fmOpiDFve1nYWfvbbOMf3Ynw3xNjcx1jIt8lTu229XwLWQgghhBBCCCGEGBF8/k4mPvsyUZ+PirUbyaupTXWRhBCjjAYOLj+Lg2edI/PRD8DX1MLCz38HY1oM9+WdtoPVAM4klksIMQwdXH4GXRWVzLn//lQXRQghhBBCCCFO2fjnX8XZ20f5xi2pLooQYhTqy88nlJsHQFdFJXm1h1JboGEs81A9Z3zgs7j9Xaf0vhF9G8DZ5E5YXqrdOi9dEE7Y9gwb27PL9Fg//mREEra51POaCcuq7jxlmab8tVjCtlf5fOIeVTOC1l/f6muP37/qc8+lffIkTrUk4dzR9ZhdJD9xn7se4pY2e6I/YXktmHMgYXnZkVmd2tOS4XclLC9t3bwMW07/EN/PVolrX5zdjoTlNRi6yXrOeVUaTNj2XJ2J+86424f2++dI3GFgxvyDictsBCid3jKk24vmJK7vNdT1zExclxtH74i+dDpl7rbE7a+ZF01YXnZoV+LOK66sxF0D2pHI79tgZO9P3OcePLc7adszYjHGrlqLq+/Nk8mUu48PhsQcPmKG55Tzz/JaL3re8t7eU873ZPL2Ju6kWLBpBHdChRimZn9j0zG/d4yfEP+Pab75/2GqeVdRwvLqfr5kUO871WA1JHiEtRGybhjtBFcBTJ+9E7XRlbhdsApaq5IQlFifuBz7fZZpwvkxCFiXfcKcOss0vRHrnnjTzmLLNACOYGpPboaNQIPdC51wgb06ZCdoDdZ51d9k3Zk1W+x1luzEbjJrDKzuORVtObZMR2cbzszC2x3vRLo7rI9BuNAknG9dMLtB+Wpbqd4ialgGgxw22qFoifVnZXQ5iWVaf+7KRjUbN7veOhFw13MrbKWzZNr7Hm9aP9EyjS4Io7Ks73hFs6y/l+acgGWakD/JC0xqIDbA8XHohAWtE91WWbIZIc+Y3GmZprsuGxWyLn/rDuvOj5llffPHYTfIbKNx1A5w9KUuqORrMKAhY8A0FS8GgD7LvGouy7RMk79LE1/WZGDNi2y0zQ7rNKbNIJB5lnU9i8bsfe67VltfBGiXtjwKptte2e2064NmaMzsgb8Tdvpsjl4DO0dP2YgRRrNsZGRoe0G0gdrXfoXT7S0y1tKYZ725HOvtGTbbA2+zdbpgib3KEesb/g+xhgut98XRa9gM0iduf+1cK9oJpIcLTVtBa3Vw4PYa4tdHdr5vTutmnVChdR903F8dgL2BE3tspTqWkRsl4/Kmk75u97oxUmt9jgKITBy4rqnSoI2zGDQvy7NMU/afg0z7Yfz8YzoMDl6ygr3XXoqrO8DS7/2CjNZ2AHZ9boxlXuNm15PlGfja/+DWCmovtC676bLuWxohA2wMKYrZ6Fe5W504eiVoLYRdj61eYJlm+m/9ZPBm0LXrkjFkNrXg7uqms3wsGdWHX8tLTiFPwrQxoDNnp5PeautAsz7Xuv8e2ZFL2wbrvFq/b+9cwhfuO+lLo2uYgBCjXDjzzY5lX35e6goihBDiGO0Tx9Mwf84pP/0ihBBCiGO1T5vIqu98nl03X0PBjr3EvB7WfPlj9BYVpLpoQog0EHM5aZ88gcIdeyjasZfuqnKCOdmpLlbakYC1EKNIb9GboyH78vNTWBIhhBAAEa+HN267kQ0fuJVtN17D9uuvkqC1EEIIMQhaKba8/2bWfOUTRD0eFv74dyz68e9Y8v1fHQlaB/NyUl1MIcQI1z5pPKbbRdGOPRTviC8i2DZjcopLlX4kYC3EKKJibz5C5u5N3JxrQgghBidQXETrjKlkNjWT1dBE05yZmK7hP52AEEIIMdxEMn00Lp0PQNVLr1O0ZQcAWYcayNtzgGBRAT1V5SksoRAiHRye5idQVkygJD71RczG1D/i1MgVkRCjSF5tLct+9WsckagErIUQYhjIO1THhOde5sD55wAw6anncUSGdnEyIYQQIh24e3o56yt3sOPW69h7/WU0LpvPjD/fT+3KM2hZMJup9zxC0dZdtF1qPYe1EEKcTMmWHRRv2cGuay8HIO9ADVWr1qW4VOlHAtZCjDK+zlNfnVUIIUTyTHzmRdAalGLsK6+lujhCCCHEiJXR2s6in/ye5gWz2H7b9az98scAmHrPI0z8z7MpLp0QIh0oYPbf/81L35xEzONm7t33YJjJXLV7dJKAtRBCCCFEEvUUjcPT3YorFDjh6wqY9OxLQ1soIYQQIo2VbNxGwbY9tM6bgbfdT96+g6kukhAijbh7+7jgC98B4n15kXgSsBZCCCGESJLOsqnUzbsCZ7CHsesewBtoS3WRhBBCiFHBGQ5TtnZTqoshhEhTEqhOroQuumh6rNe1N0Ij9yPVzZ6E5eXucCQsrwxX2DJN6fSWhG0v1cIFI/dRC6M4lLC8AmOtj0PrHHfCtuduG11rtJo5iZtD9uDWioTlZYth3RbbpdoTV4fs8OQFh3R7x4kl7hw15G2VStznnl3ZnbC87Ihlx6wT2aQSl9Wg9JW/+bmHMvNpmHUR3s4mAA4uvYG+nFLqV2QmbHsd0xLYr7JR/41I4rbndCTwc7dRLiM88vqgGkVX4XzqJ91CZ9FCtIr3H2MZQ9y+mIk7dm07ixKWlx2mL3HHyts8uvpCQ17PEiiR/daYN3HnVzsO3praE9lQXzfqJm/C8mq8clzC8rLTfx83uz5h2zM9ifu+hYtkLQwhEm3nh/JSXYRB65qeuDbBNaMzYXlZSfgIa6ugdbyjZ93pdfRZb6uvxGaZ7HRUbVykmT4T/NbBG51lvT3v2G5bB3/fIeudzMm3XjwvuCXf1vbCBUnsIDk1unDg4LrRZH1TIJoTo89GBzp7l/Ue945JXMfA7g2NRF4u2wlaB8ZaHwfTbf25Zx504Guw7vzXr7R5TP9tL9nRlNvENaZnwDSRWutAkNE19A+X2On0uqpOPF3A0UIN1vs3Y06NrTLtemOsZRpHrwG91hcS5njrRjvSkGGZRmlI3O28E+Rvgqvn5N/CyCQbJx/Au91nmcbTYa9MRsT6exUstfm9shG0DlTn2MrKzqW+e9zA30eA6L4s621NDECB9faiNTYCvY7kBhaU2f+9OIlJf2kFIOp28frn34GjL8LSO+5GOwzWfeJ91Cy4ngmrHqZtbq3ltiJZNvbFoWleap3M25SYemY3gNUXsHFO7LB3Q8xwWR8H7bT3uSsbxXcEkheUdPYoSl4Y+Bzk7Yifk/1VVew/7wICxSV4OjtprziP3owFjH/lJYJj99j6LHz11vsSzUncd8a0USbtNGmuz7NMV15lsxG10LzLXoA8WGjzONi4Zpg5uc5WVvbO1sdSMXD5B/5cYz7rffG2WO9HX4nGtPHdshMcdto7vdrq28asT8G226r82a2WaXrD9tqq6Bu51tt72bpP5T+3j5rbbAYXnrCX7GiOWsj93Mnbod1fygA7g2xarNv58pets6k7X0O7dV7ubuu62LJE0zndekHFcf+xPr7BQifB1QP331sWqoSNALRznQUQCVhfx4TKIoSLI6dbJCGSxrS44DNshKXMPHvt5IcXv2iZ5tGvnm+Zpu76CLu+YON61sbDlK5Oe9/3UKGNA2HjWtKIQc946/OiCrmst1frA7eNvrmN/ruV0TVMQAghhBAiyTSw/ZZr6CkrZu5d/8Ln7ySjrYOlP/4tvnY/+1Zci79yYqqLKYapUFYWOy+/ki033kLU42HGIw+x5A+/Zfb99+KIhNl55dXUT34HfZmVqS6qECINtMycyv6LVqS6GEIIMaxEPR6G9vka8VYyh7UQQgghRALVnrWEhqULmPSfZyjauQ9/7xjaeydQ0HuAJT/5Ha9/8f0cOOsqxq55isLqHakurhgmTMNB4+xFNMxdilYGY1evomrt6wSaS6htW0Zu+yEW1PyZ5hkz2Xf+OTROupmMzr3kN76MO9Se6uILIUao5jkzqD1rCTGXk8mPPZvq4gghRNK4iXKB2sE42nlMz6aGwhOma5k6nd0XX05ezUGmPP047j7rWQ1E4skIayGEEEKIBDENg13XX05WfROTnngBf+8Y1h58H3uaL2TtwffR21LE5OfvxxUMUHPGpUS8iZvPWoxsDfOWUbfobHLqG1h81x8Zt/pVAs0lbFl9I9U7z2bL6hvpbiundPs2qnb9kfzGV+jNmUTD5FvQ0qUXw0DM4aareCoNMy7l4MKbiTkTNzexSJ6Z9zxM/p4D7L/0PPwTrKeLE0KIkep8tZP5qhYvEW5Wa/Fy/JS1/qox7L74cjLaWumqqmL7NdeloKQCZIS1EEIIIUTCGKZJxZqNHDpnGc1zZxB4tghTOwAHpoa23ol0zC8jkpFN4b4tOIPWc9eL0aHgwC6aZswnmJuDEYvPy9jZNgbTdAAGpqnpbBtDTkE9SkeJurJBKbLbNqEYuYvjiZEt4smjO3cigaKJ9OZWguFARcNop5vevEqyW/eluojCQt2yhXRMGkfBrn3k1NbTwtAuuC2EEENlvy5igTqET0Wo03kEOXbO5qjHw56LLsPb6Wfuff+gecZs9q+8gN6CQqAxNYUexSRgLYQQQgiRQNPve5TOMZVsue16Zu38N0ZLDFODoWK03TSJjsmTKN2+hvLNryZ0IV4xsvn8bUx96gF2XfJ2tlx/A3Pv+Se5hYdwOKKgDRzOKFec+zh9Ri9bK99Fd+E8cptfJ7/xlVQXXaSJrtLJxFwejFgUZUaJZEdQZhTDjP+uzChKR4l48+nNnUhv3kQi3viKue6eVgoOrSerdT+eQCt7zrmdUFaxBKxHgL6CPIp27mX+H/6OIxIFCVgLIdLUbkrp0D7yVR/P6ulwVE9cA/vOu4hIRiZz7v07jkiEwr272L/ifFqnTMMhAeshJwFrIYQQQogEMqIx5v/+76z+79vZ/9nzWPitP9PRM4GWd06j44pJVGx8kdJdG1JdTDEMZbU2Muuhf7P12uvZdu31zL7vHn70tQ/S3VHFsnmruGj5CwD8Ut/Jlt7J7AjnstkYw+bOMewPlGDK1CBikIJZhRxadNWAacqMBm71/pV27eSPgfn4umvJaXqDnPoDuINdx6R19XUQyipKZpFFgkx+7Fm0YWCY8qSGECLdKX6jV8Sj028ZNtIybQatU6czdtXLZDc3AeDu7SWn7hCtU6ZR2vfi0Bd3lBsxAetgdhEtkxeTf2gbWa2HUl0cIYQQQoiT8nV0MvdP97D+9ndz4FPnEsnIoHtMObP/fB8ut/RjxMnlHaphxqOPsP2qa3DcMpVPzv40f372fL7978v4SuzzTJjdzdnhh1jqfJ3rK/bwrrGrAOiJetjSVcUb/nG80TmWjZ1jCZCX2p0RI0agsAqACav+iSMSwnQ4CRY5MAw4v3AT7yh/jgvy1+FU8aDmktZ/8IM9lwEKV/D4Z0W8Pa0Es0uHchfEIClASbBaCDFqHH/OCmbnsH/lhWTX11K1fs0xrxXt2cX+8y4i3FSEO9o6VIUUjICAtWk4aJmylJbJS8Bw0Fk1g4IDGynb8QoQTXXxhBBCCFuqclr5+JmPsqe1grs2nEfUHPanYHGainbuZfKjz7L3qosAWPDrv1CydSfN58ioQzGwwn17mfbk4/z3Lb+iI5LL318+jz0XX0rT5Lk0vrCKNRmLUCzCwGRiZjNzcw8xN+cQ83Nr+MD4F3AZ8eBTfU8+m1rGsaVlLJtaxrG9vYpwzGWx9aG3LGc/bZFM9vZJgDNVeguqcPV1keFvAGBcTjNXV73OtVXrKPF20xzM5vf7VnD/oSW8Z8LLfGTSs+S7evjq5rcDjuPy8/S00F0ylZjDjSN2/KJWYvhwOGL4vGF6Ar5UF0UIIU4ox9nLZaWbeaRxAb0xT0LzNrXBnosvAwVTn3ocpfUxrxfu3cP+FRcQ8M3A3f1yQrctBnZqV8tOE1USOunLX1r4uGUWd9xjb4VNTwcECsqpWXIRoZxC8qu3U771VZqnLqJ16kICReOo2vgkGR3W88h0LYhYpjH81p33wnEdtsrevd76QlRre7NWGm3Wc4j1dFincdq9ae6N2Uw4CFGFsrE/Vhy99h53DdqIB0y9s/2Y3zXQtHA2MbcLX5sfb7sflaFtPSJ38Errr5PNj93WPk58sMcyTc3FWba2Fy603r++cnuVyNuUvMeR3Y4oVfn+AdMcqM20zMfMtb7Z5fDY+y6oQ17r7Xm0ZRqATK/1BV0kZr1/fRF7wQhVGrRMEzPtVdqrpm2xTLO9rMwyTVN3tq3tDZZ2QCT35HXZqLP+PAGCJdbfhzPfFj8mDkwucm3javcmFJqLp2zi6qWvcVfoLA6ahaz/0zzrci+2/r7HTHvfvUh9hmUaZa/KEmywro+GjWbfDB0f7Dghh82CJdlAbXnDhceefHzRrUx/4iCm002srI2GsiJb5ycAs8C6/6Kj9r6jwQTFAX0FffYSbrL+Lts59wC4uq33MWpdrW23xdGs5I00NN3QPW7g/Vn2yTcAmGQ8xRXeZ/hC9/d58iNfAGCJ+wGWXnQ/bZFjv3t15FDHLB7Xs3B1RRnvaGOys5kzs/ZxVtYOLpsQzzOGooFcnmYmfSr+5fzxQ1dbl9tr75gYIevP6j1nHTvn9lTVyI3GWiI4+Ke5lIM6/gW56+mV1hu00SYYQXtto919tGNHdUXC8nor7YBI3sBlnTH/oGU+2zeNezNPoKeoksLADi5d+jo3Va5hSf4BoqbB860zuGfHUl5snU5Ux9vqr+2+jvZYJh+f9Ay5nl6+ft9tRGLH9oOznS20TgSiRfha6ym7udrW/u3YWWWZJlxk/Vn5Dtm7zG2j0DJN6fQWW3l1zbdO48+3bhuNQ8kNHE+Z0sFjT95z5HcVaIRYCJ1VBYaDyf/8iK18Sl+3/v4t/vK64/7mJEYUg8OjHGM/WmJre802krmr7C1kXH2Vdf+l4iXrfKI59tqNKdPqLNOccV61rby2dlm3L8Ue634jwO9spRIiwZwmRv7J44oAe8+/681fYmFUoB5lRvjenIfRmWXg8DDp3g/b2tyf/3nRgK+3jVtC16QxTHjpcQzdTTj7rf2GINmNtQQzZ5D/wlrL9Wf6rui0LFOwxt41b8Em62ukjtnW7ZAjYK8v5HBZx0DCLnv9aWf36ceFkj68K18HCOMkoOzfBTENF7Xzz6J18nxcvd1MfOkBcpriHa+qTS+SW7+fmiUXs++cmyjes5aSna9haHmMSZwerRTbb76a2rOXHvuCaeLp7sbb2YnX34m3qwuvv5Pc2joy2ttPnFmKhLIycfX2YpjDI6gjxGg3wWjhXZ7VjHF0sCE6lr+HljLeaONWz2t82fcoT0Rms8Ux88iIx4gng5YpC4h6fIzZ8Oxxd/jFyKMAd193qoshRhzN1a438Js+1kTLyFatTHe9yDLvA5bvjOBkT6yUPbFSejLiN+EydIhSuiili7nUcSWbeUjPI6xSO9q6inauN9bTQC4uYrzTeJ37zEXs1tY3OIV92aqPszz7yDaCZKkQmUaI2BwnOc4+cl19ZLvCZHm+T75qx2XEOBAo4n/3XM6/6xbTEs45QY6K/9t3Kf5IBl+b/jD5V/2Ozzz6Xnojb9709fnjQd6+vGKyWuuHaE/FYGh3TjwY1FMbD1on0VjVxkc8L1Jv5vLXyBn4tXXgeDQroAcThZ/TP04OYsRO8DSEEMNaJBC/qaYUpq8YFWxHdR9CZ5QkJPtgdgktE5aTf2AXhft2nDRdQfVuDp55IcG8Qnz+toRsW1hLWsDa0CZL9QFm04AJVOsitqoK4vfwT35PIpA3lubJFxL15lK0ZyPlW1+lyNXO1QvXkt3j5W/PXE+gMcL0jr9Qu3AFLVOX0V06gTHrn8DbLRVHDI7pdLD53TfQtHAOE558kapV6+grzKOvIJ+e8aUEc3MJ5ubiHzeOUHYWGAYqGmXOvfdTcKA61cVHA4eWL2H3FReRU9fAnL/fj6+zy/J9QojkyHQEucm9hgtcO+jUPn7Zt5KNsXFM3NxM+fpO/rjoLJYsqeYK9xZm3PwjvrL6AzydfzPt42agDQcohbuvh7Ltr6V6V4QQKTDbUcdERyv/CC3lql1/5TPrfsyexSVUzy0eVH69ysMBijlAMXU6j8vZypVs4WE9N8Elt6+Ibm52rKELH/+ILUOjeIfjdW401vGQOT9l5Uo3TmJ8O+9hprqaAYhogx7TS3t2Jp2RDDoiGeyLTqKJ6URaDvFK8zjW+icA6oRP24x9FXybC+mb28afOBd/JIPvz7qHO6/9NR9/+IP4g/Gn+1x9PThCfQRzB1dnxRDapNAvZ6Hmd6MW15HnCuCPJD6QPFa18VHPC4S0kzFGB1/0PMG/wkt4nWOHTmugbdJ0Qtk5VGxaOypv3huYnGPsYaWxE4C15gReMKfRy6lNhWBgMtdRywrXLgB+Ghx4pKkQw4bWEPaj+lrBcKN3FsBrEfQZJagZfozeJr474z6+tesawubgbr6bhpP6mZfhDPcyftWzA46czj+4h4NnnE/H2Kn4/KsHt0/ilCUlYG1ok6v0ZorpYRvlRDGYTiMTdStV5/2c97/8IQLR4x+7bhu7nPaxZ+DqbWfyc/8iq62ez579EDfNfYV1m5dw/u3PEom4cTijjLvyQaqMp8lp3EfdvAvZu+IdjFn3GLmN+5KxSyLNvfH+W2iZO4NpDzzG+GdfBSCjNT56OlRz7MgS0zDoy89j+9uuZssN17Pwz38lu7FpyMt8tL2XXkD1ijPJ319NV0U5r3/igyy+827AesoHIURiVXrb+deSX1Hm8vNCZBr/Di+kDzcTNzfzuf96CkckRszl4Ie/vJin5p/FhzKf5m+X/z++0e3h11tMSnatp3HWchpnLCOnfh8ZfnuPIgsh0seVrs20mFk0bszh4x957ki78fPfnD/ooPVhh1QhT+uZXMw2LmYHdySozKfCTYR3OF7HxOBvsWVHgjB/iS3nJmMN1zo28nz5LP7TsCAFpUsvt2a+xlRXM//beQmvhSYS6b/8O3pKkJaqy+jLGseY3b8Z8IJ97Kuw5p6PEsaNe2eYpfyaf5+1mGh1Jj+8/E/8/vpfcvM/PkfUdKAAb3cHfXkyZ/+wtq4PdUMdRDS4gD+GuGvx77h29SfQJG6av0LVw0c9L9Cr3fwifD4OTG5zr+a9nlXoFRn89sXLgHiwes+FV9MxfjIAEV8m41c/n7ByjAQGJh9wvMwYo4MtZiV92sUyYz8LjBrujS1mK/amHJpsNPFB78vkG710mBm8FJmK1eBBIYYLFWxDhTrQrkz09jzUTfX97ZRC31MBs3t5R9VrzMqu5e1rP35kyqpT0TLxTMKZBYzZeB/O8MBxE1ewj+ymWjrGTqViswSsh0rSJpv1EiGIky2qkg1qLPuID9kv9p581KfpiM+lZ8RCOMPxORJzvL24HDGeWHUR4YibmOkkGnXSUxd/XMkR6sOIRdCGgXbIAlZicAKlxeTtP3gkWD0QwzTxdPfgiETjj6YMg3oX8cYv9Lz+TtyBADGnC+2QR76ESAWPEaXE08W2WCV/D59BH/Fz27T1TTgiMRwmGBGN+fos/qf7LuY0v8HDzRfwnZxv8PaW3+AJdFK58XlQ0FkxKcV7I4QYepqQdpKnejlz/b4j7YYjajJlXXNCttBBBjEMXClawNyBJpsg23TFMY+6h3HyrDkTgAqvvbVjxMAmOlvZHynk5dDUI8Hqt4o5M3BGuizDWL7NhYRxE8NJGBe+zYVMyGjmxrmv4HKYREwnDhWf/7Jl8jwCRRV4O1sTvEcioVb1QUSjYkAEWAseI5LwkKYDEwcmURxEtUFEOwjreH30uY5dwyXie3NRgoh39C0EaaAxVHy603Llp1L5MRQoNE7sT4PqVPFjDuBVEfKM3qSUV4jkOPxkhQGrj26nNKzuQyuDmFb4HBEMBvcUhjacYJo4IvbWZ4nHHSXGMpSSEmkzlcGTzOIqvYmb9Tr6cOEjwg7KeMfTnzjh6GqAogMv4u1uoHnS+ey66FbKt67i688oHtq+lHOnbsXjDhMKA4Yms6qOpmln0Dx1Ga6+bia+ci+Z7TI/mhicso1b2X/xuYSyMvH0DLxYR6CwkG3XXUNfQQEz//0QuXXWi2gk2/SHH8d0OWlYOA8Vi7H4t3eT3dBExxx7iy4KIRJnf28JP913MZ+d8gTLnPt5PToRgF0LS4m43JiRGBGXmxfnn8uZnrvpeaCL76sLmXfzZr55wT+54e+fpycMnm4/wTx5lFqI0Ufxm9BKbvc8x6IzqzF/Z0BUE3Ma7Fl87JyNLqJUOvyMMdqpcnQQwUFdLJ/aWD4NZu4Jc3frKJexlQgOnmHmUOzQcfpws1uXMlvV8TQzMY8aQ7PM2E9IO/jnoTNSUrZ00xjLYYpr4Bsdhhkm5rLuM/bNbcO9M0wYjZsIKy56gc+c+VdCERd3vPg27t1yFv78MTRPX0RX5WRy6vZRteG5RO2KSIYzffERi/SPsF7m5La1Hz7mO5kIzTqHO8Mr+LD7Rf7H9xAAIe3k7+Gl/OyZNxd+VcC0Jx5gz4VXATDutRcSWo6RIIqD30ZXsNioZrmxnywV5LnYdF4zJx4ZBGHHzlg5X+h9O9McjSx1HsBJDBldLUYK7S1CKwdGsA3mu49qpxRqQQAVDPFw03y+vP3tR25+nari/avoLplM4/SLKNr+jwGnHzIdTrrKxlK0b+tgd0kMQtKGhvpVBk8zk4v0dhSax9Us6lT+SYPVEG8+s1t34+uspb3yfOrnnYu/cjKhtU+xob6d8Vc+gP/QONyT/NRfdw69hRXkHdpOxebncUTDJ81XCCtl6zez/9KVNC2YxdiX15w0XePsWey+9GIckQhz/nUvBdXWq7APBcPUzLrvYaY8/ixaKbzd9laGFkIkx68PnM/VEzfwTs9r7I2V0KazeGjGbTzyo69x1eZ7aF4cZez8B1BKsz42jyBuvvb0Ldz19p/zxRX/5mtPvwOfv4XeQll4TIjRqA83vwydz+1zn6PyTx2sWz2ObQsryV3Qx2XGZgqdAcY42ikzujD6JxqOaAMH+sjvMa3o0l46yKSdDNrJpINMlnGAbII8zLxTWhQ90TbqscwwGpmmGtmh44+459LLLFXP63oCXdEMixyEHY2xXHKMIJkqRECf+PM2YmEcBlxTtgGPESEQ8xCIeeiNxP8NROP/tpzrZhm/ZuxOJ++45kG1w7pLAADic0lEQVQueccL3FO7lF8/fgXV+fNpWbmYQFEFjlAfpdteo3TH6xim/RGhIgUW+9D/LES92ArLnOhzxtB6z4kW2jx9+8wS7gyv4HrXBiI4+Gv4DFp0Nm8NojojYWY8fn9SyjBSmBisMSeyxpyAAvQgA80mBjtiFeyI2ZtGRIhhQynwFmAabtTcRviTgd7gRS0Mwpwwpq+YT255J6dzE8YRDVK6+wXqZ19B08wFlG3bcNK0XeVj0E4XubX7B709ceqSOpdBo8rlL5yBQqOV/bu0zkgv41f/B/+YadQuOI9dF99K+dZXKWYjziXFHFpwCUqbjFn7KHn1u5O4B2K0yKpvIrOhicZFc08YsI45ney5+CIa588l92ANMx96BE/P8AoKK43l6HAxEJnTTSSOicEfgmfzjYxHeL/3ZW7v/iprwrcwfu5a9i31o9Txlx7bmsbxh3UX8uGlT/HC/ln83b8E/9hpRF2pCygJIVLn6KD1sgXVLKMaAFNDk5nDoVgBqyOTOBTL51CsgEYzBwcm5UYnlQ4/VY4O5nkPUUCA8bQeM17yJSbToPJSsVtH7NMldGovC1TNkYD1cmMfGnjNnJjSsqWThlh8pH25o5O90ZITplniWc9Py3/AnLHbLPMzz1cYSrOpcwzXvP4pXnVcRs+KxYRyCnD3dFK54XkKDmzFEUvNdDPi1KnZQZjhRmdVgpHcqQ73mSXcEboU6XfbpQY52YEQacKdhTbGoBbUY8wPoA0nOqMKnF4S0YZkN+8mq2U6dQvPIu/gPrw9nSdM5x87CSMSIqu59rS3KexL/uS7Sg3qjqAC8g/tIqv5EIcWXUD9vBXUz1sBQFbzIcaueQJHbHgFDMXIpYCy9VvYd/n5BPNy8PrfnGs9UFjA9mvfRqC4iLGvrmL8S69gjMLVqtPZ3MxD/HbqX7iz/lz+1HR2qosj0kSrzuZvoWV8wPsKSx2dbDb2sML7W5Q6efvx+7UXcc747XzlvPt45okLaOBsgrlFOJGFF4UYjQ4HrauMDgpUgHozj0adQ0P4xNN9mBjUmIXUmIUQgUZfPJ2hTfLopYBeYigOkPqF8DSKTXoM56g95NBLFAcLVA2bdRXdjL55a5PlcMC67AQB60xHkM9NfoJ3jXmVOrOSD73xHrZ1V5LpCJHpCJHlCJHhCJPpjP9++N+9fZX8Nfo+OisWEXNl4mtvYtzqR8mr3TPgI9VieNIZZaBjSQ9WH0uC1UIIm5wedPYYtNagDEjgPNIKKN39HAeWvIuDZ17I1KfuP6510oB/zERy6g/KU0NDLKGTU/2/DZdZpvnCjQ+cUp6uUC8TVj3C2Ncfp3j3Bso3v8ykF+/H3deDI4GzgJh5Ecs0HXsKEra92LYEPmpl4zsTzU6fzqOKJq6Ds/ddb16wla/fAoZB44LZR/5Wv2QeG97zLsJZmcz9571MfPHl0wpWDxCnOmX732Y91+DYp+SmjpUZGfX8efofKXL18NVxj3J2zh4AYqHEnQiN0NB2ymu2lScsL2UMbdtRmt09pNt7K9OTuP19btUcngifyT191/PNrG/xocyv4FQDn2uipoNvP3sjud5ePjHxrwD02ZzH2mEkrgOlh/o6suXk04WNNAEbT916E7gGmXIO7Xc0XJtpncgmd1viuqHOXutKO9RtcaL04WaPWcrrsYkc0gVEcFLkPrUnqkxl0K6y2KtKOKCK44/angIjmLjP6q7nVhz5/0ZzLADz1SGWGgdwKZPVZmIXmzW9x7eNV1Zu4N0TXoJRMHaxyYxfc5Q7jh01dn7Rdp5c/kPeNeZVft96LTNbt/Nk63zqg/nsCZTxRtc4XumYytMts3mwYRF/qz2TX9Zdw1d7/5ef5/+W9rJzcfc1U7bvHqY+83fyD+0eMFjd+M/xydzN4/SNSdwI76adQ7uehOkb4oCIUscEq/fe/JuEZb3mjsWWaZZ9dm3Cthc+lLj1e+rPtU5T+UziziuvtY1PWF4tIVnHSKQZwwkO1zHB6n033JmQrF2hHsase5muynG0TT5+bY9AUSmRjCzyD+5LyPYAvGMHd80bc7npLSg95fdFsxJ3XnFXDd1T/ad2GzVqoJtP/miyuyrAD7deNGAWkQNZ4LPuHAbKj238PZGdeJp3AtB7OBYz3V4wzqi3ngPPdGpMi4u+8sn2rjBNl3Wa3Ln28nJOOvEjCUfr7bV+XDwacBKzcd5yNdtfyOFUKRMcgYEveFw2PlIVBTt35ZWN72Tevhg90/L7f4uR2dxE3dkLyW/aw4EV59M0ey6enlpKah6le1YP3bMG+MrEbHRYHNpW0Dp/p3WizkmK6isG/lBjGRo7F2OZNdYXolGbg52CpcnrZIcDbg6uHTNgGqeNG1mfveQxAPJ0gKvZTAzFAyzgAnbw+xl38wAL+O7dt9gqUyTbOo27A+zUWT/5lmlmzLeeN31PSzH1/hOPvjuabrDxodrsh7+YM9kyTde+PHuZJZMGFR5gpwzQNu5VOLutvzOZNT7+M+FLvOgOcG7Bc3wg/AK3/enTBCPHttmd84/9jq6hkgfqFvPOOc/y3cZtNI8txrfL+iZnLMPedy+RITs77SwlQcskZsQBURsH3sZFvLM9uSPEtDFwMMHdYRCyuL8dLIvZ2pazyfqcfKJg3GDZvVERqrMOWucubbdM0+m3N0exa7x1HYquy8PVPfAOZCy31/dqa0nO/K0Qrz9W59NVv7EO8HTajOluCM+wTGPmJq4OeRut28ZZV+5mS1flkd9XZu9ioaMGByZrwuN5vmd6/AWHdf/FzLcecPLceT998xetyQ/3kB+JX2zdvugZ/O54X+rCBz5nmZfRZzdwP5QjVY8X1W+Ws1t76Yj5KHV0EdUG+UaAj2a/yIqSPezpKOPW597F875r6JmZTUWzB2f4zfrga41/BoGCEppmLqZj7FRAU1C9i9Lt68jwx79TGbc0WJapdlsZnW+MtUzn7bDRJ51hfbFs7M60dU2WN7nDMk2+r9c6I+wFtsfNrrdMc3BrRVKD1ls6ipl8z4dP+nr5jGbKZzVZ5tPaZb3OhumCx55YOmAa14xOeHvXgGkATL91v9XZ7Ca610bn3MbxVRoazrHOys7N0FDMuk2ob8vlQHOhZbrcZ6zPwa5ejfW3UojUUGEDR83A3+dL3v5uy3wOfsrEVW7dPn/owpeP+d1BjCxCdPJmP/SBL0bpGDudQ0tWULJtH+7eN/NtnDEBTBMz5wD+6dZ9k/E/s47PHXibvbhb8Rr/Mb9vvvV6GhfM5qzv/5LM5vg52D/Lut+qDYhmW7d7ep910DDm1bYuKKNZpz8oILHL/woxwhXt3klPWTlrPvhfNM2eS9Xa1yjffw/OqIxUTjc5uo8r2YKJ4hHm4X4jRu1v8zE2ai5hOz5nKNVFFCOYaTjZfeHbiPgyKX7qRb718M2MKWjlsjEHqN+yhJ6WgUfB/2j3ZcRMB/+b9d+EfUM7sksIIYbSs6Hp8UUBjTAP9i1I3oa0pijURX4kQLfTR7fTS0G4h5xw+q//0RDLo8Lh52LvNn5X+BeWe/bzsw2XccMjn2FTy3iM/sXrTcebF9Aa6KyYwK4Lb2Dn5bfSWTGB0h3rmfPgH5iw6okjwWohhBBiKCTimSgXUW5gPe9mFQW8GeNRwJSnnyTmdLHvvAuOeU/7xMnk1NfhiFkPoEim7vKS+GwAhsG+S1amtCxDRQLWQhylaM8uAEy3m5kP3ce41a/IUhdpKEsHuZLNGGgeZQ6+NyJc8d7NzPlpHY73mRRsDPDtM//FaHhUWCSeRtE47Qp6C0uY+MKjZLU2sr5mMt/820f5zv/+hPo3zmTXU28fMGjdFMrldwdWckPOf1iYvfuUFi4WQoiRZG14AgD1sVz2xE79MVc7lNaUBv3kRPvocGXS4smhxZNLwOGhKNxNVqQvKdsdLlrNTOa56/hs7jMciBbx0bZ3cufmi4iY8VGfRiw+Ut10ujENBx2Vs9h/1rvYe/61hLLzqFr/InP//TuqNr6Mu1cGcQghhBhaNcuX8MJXP8uhZdZPoZ2MgxjX8AaldBHDYCW7OPp6P6OjnbGvr6Z12nTaJsYfZQtmZxMoKaFw3+CnA4l6PNQtmIfpOL0pR/dedj7OUJgxr6yhceEcuiuS02caTlL7vJoQw4y3u4szf/ZDol4vrmBq76CJ5JlKE9mE2MAYOlQm89fU4AibGCaYEU3PWjeXf+gN/nfNtbQFbTxWKMRRIr48AgUTcfX24Ii8+bj63Y/fSCjsRmsHBiZnFzVRPnsdDzln0hU9fmqEN3omA09xre8hfmNMwBFL4MINQggxTERxcEP7R5K6DW8sRGYsRNBw0eHOOjKHd5snm4zeEHnh9A7C3htYxERnK/f1LuKJvlnotzzL6+qLT8ew/6xbcYT7iLl9eLqaGf/q4xRU70JpWWRKCCFEaoQyM9l9xcU4+4LsuuoSSrbuwBM49aejyuhkjOogqg3cKsYY3YGbKGHenD+qau0aWqdOY9ellzPzkQepWbYctKZw3x7a5w2u/C3TptBTXkZnewf5B2sGlYdpGLRNn4yvtZ2MlrZ4vjOmkl1vPX3TSCYBayHeQoEEq9PcFiopo5OFHCKqHdQvySXmNiBigguyl4T50borJVgtBsXd10H5jodoq1rJrstuoGD/TsasfYnM0nq00igVw+GIcc2KR7nirGf4qmmwum0yTzTN5Zmm2bSGs5lZ0sXP593Nlsgs/rB9AY5Yc6p3SwghRqw+hwe/K5O8SIDyYAdN3jyU1pT1daBRtHqt130YyXZHy3h/28nnA/V1NVOx6XG6SyejlUHBwY1kth8io1WeNBNCCJFaoZz4vMq5NbW0TZuMdg7uydM68nlQz2cBNQS0hx2UHxOsBjBMk5kPPsCWG25myw03AzDt8Ufx+f3A4EZIl27ZRtmWbTDAwsRWDNNkzl/vZ9N7b2bXtZeRv7easS+/Puj8RgoJWAshRp2IcvKEns1KdrOUarYtKOfRP85hydpqKpd08saCKv549/mpLqYYwbLa91Ox9iANcxbTMGcp/jGTqNj0GlPVA/Q0VJBTVsu3X7qEe/bNZtm5O7msdCPfK76P/5l1P9WRSia6a9kXGc+71n6YSGcTjoQulSiEEKOMUrR7sgkbTopDnYwNtGCgMVE0+vIJOpK36PhIkdewk7yGnakuhhBCCHGMSGb8SVRXX3z6LhUbbOBXcYBiDjDw+kDe7m7m3PtPussrcETCFBw4MMjtxRmnEag+WunmHSz+xR/RyiC3pg5nOP2fvpWAtRBiVDKVwXN6GgHczKeWWQsaYAHsoIzXmZDq4ok0YMSiVL7xGkV7t1OzdCW1i8+BhSa5ddX4PZMIZ+awJiOTPysFnZrZga1c772f6933crf/7fxuy1w6eyLWGxJCCGFLj8tHxHBQ3teOBglWCyGEEMNcuD9g7eyLPwWvzORPU+Xt7sbbvSvp2zlVBfsOproIQ0oC1mLUMJRJSUYnjYH8VBdFDBdK8ToT6dVulnGA/RTxMlOOzG15NA34K2cRc2dQcHAjhhkdIGMNMiJW9PP0dDHluYfprBxP6+SZBIrKcPd0kVtXjTvQRbigG2e4C3+4i7sj+fxZvz/VRRZCiLQVcripzuxfqOgE53shhBBCDB+RjP4R1sGhC1iL4UEC1mJUKPB288Pz/szSin387o0L+MWGS4np01ulVaSPLaqKLbrypBeuEXcmDbMvoqc4PvK6o2oOZTtfILtl/zHpfI4Qn5z5BDeOf43Pr3snzzbMTnrZ4yRAPhLk1lWTW1d93N9b5w95UYQQYnSTQLUQYpjTKPwZy9E4yO1bh0P3pbpIQqREODMTFTNxhOJTYEjAevRIaMA6ttt6gTK7/cNojo1KWJ9hLzMbjKh1wZp2DjzXzWHlCxst05ja3oGYnNdmmWavv9Ayjb/eOg1AtCR58+BoA2KZA3+u0SzrfLIO2Jtkf+HNWwGY6GjmY77nyVZBNkbG8MH5z3Lu7K38um8lT9dPt8xn7K99trZXc3nivk6ZjQON3o1rn229vVi+dT4AAefICN5rA0zvwHXI9Frn87s7rrFMU1wfn4qhefo0Dpx7MabTyeSnniaztZU9F13IoYXXULB3L7On/J0M1cY81yE+mfMs5Y4uWmJZ/PSMu/mK/21sjVSye904W/tnxxWlW4753afD3MIaXmEyu1UZAHfsvNxWXna+SVkT/bby6uywbo+/cumDlmm+98TbbG1v0BRo9+nPIxbNts6jdZG9vMzsmGUa3WP9HVUJXBvLdNnLLLuy2zJNKGyjraqz8cUFojbatGhWajux4Xzr7Rshe30Aw8aMMHbaPLs8rdatQrjQ3vH111gvYmdE7B2H7l7rOuTIta6zek2Rre0ZNj7DwbLTF+qYaX1crM6FR9KFhzYwGyyzLtf6dZNt5ZU1odMyTVerdcfxwgc+Z2t72Oibe1vtZRUsSeJx14A5cP6Rb5dZZtN3jfVn1Vdhr0jt26y3Z/TZ67+bNrrTZoN1n8O0cy0JRKLW59eWR8bYyuv/Pna3ZZpP/+c2yzTutsEtKGaXMsEROPk2GraW2ssoLzFtZazG3iLndo6K3bZRO6zPGcpGfMCuxo4cyzRTPtlw5P8Rn5fNH3sP7QvnANDlWMbYp19i/KPPEplpfeI/dLHNgv3NZjohEkhFwHsK68lHMjNw9fUeCSYqM37tFKvJtPX+X+6/zDKNeaGdtsPe9dGBt1lPNZZ50F47v+e91m2HnXYve7e9WNVHP/iwZZqfbjvPVl6RWnufz0BkhLVIaytcu7jNuxq/zuA7gSupMQtZHtnHe3yv8u3Mh+jLcPJKr70LJzG6RDwe9l50Ec2zZpJdX8/0Rx8jo70dgEV33U3dooUcPOtstvBRfp11GzdlPEltNI/Pd1xPTbSAH+TfxzdyH+HzHW9nN4kLWL/VVJrwEmUBNezWpSNu1FiBDuDHh6mSe3EmhBBCCDGUJsWaKTW7We8cS0i5Ul0cMUIEykrY8LkP01tazMw//JP8nXvZ/7ZLOHDlhRy8ZCVl2zdTuX4tnkAg1UUVYkiEMzNwBXrRRvx6UUZYDzGtUxZjkIC1SEtuR4T3el9hpXs3m6OV/KZvBWWbu7hy/SZ2LCrnm/Ou5nbf89w55m/8tu1sftF6HjFb9+3FaNBVPpaDb7uESEYG419+mbGrX0NpTWdHBZ3tY8gtOMSYteu4Tt/DZ25+gBKjjR/1fJz7A1PIVXsB+Kr/bfwo/16+m/cg233jqe2z95TDKdGa6TQSwaCQXirxU8fImKPd0CbL9X5m0EgteTzNDGJqZIz0F0IIIYQYyNRYIzNiTQCcFdnHq65JErQWllrmzWTTx9+LisVY8r2foTbFaA7PYeyPX2Ty2MfY97ZLqD9nKQ1z5lO6fStV69bg7e5KdbGFSKpwZgbuYwLWCXysVAxotq7jDPazSVexnnFDPshMInQiLX135T9Y6d7N46FZ/Lj3Iso2d/HF2x/nujs38MXbHydjU5hvB67i0a7ZfKjwFb5a+miqiyyGCX/lBPZc+HZMl4v5f/0b41atPhKs3rz2Jg7sOYfNa29idlUHP3jnnZg6zPvaP8t/93yf1frjVOtzAWgxs/mq/xp8KsKvFt6VlLIWEKCQADsoxwRm0GD5nuHiXL2HGTRSTy5V+Fmu91u/SQghhBCnrKe0hINnLrP5MLM4XRWmnxmxJuqMXF51TiSTEEui1akulhjm/JPHs/4LH8Xd2c3yr9yB2hRjbfsn2NNzJWvbP0G4JpO5v/kLi+/+A8W7d9I4dz7r3/1+OiurUl10IZIq6vMSzMulYcEcVCwmKzcNkTG6nXPZgwaWcJBL2TrkZZCAtUhLa+onY2rFbGc9JUY3M9Y34IyYOEyNM2oyY30DYx1tLPTVEDYdrO0dn+oii2HC19mOr72FqNfLvgsvoLMiPoFjZ/sYTNMBGJimwZpNZ9LWlU2Jo4fxbicaFxk0kUf1kbwmOVvwGRG2dtqb+/BU9eCljQzmUocBHCQJo7iTpEHlYgIVxOcobVLW83MJIYQQ4tT52juoXLdRLvKHSDdeIhjkm71MiLVhAO3q9OfyFOnN29qOr6WNYGE+3eOraA9PwcQBODBxxH83DDorq+isjF9bZDfW4+20nu9fiJFs7KuvE3W76SvIp2rNhlQXZ9Tw46MXFx5ixFDUUDDkZZApQURaunfHmXgXdvNfvhf4RuYjPLx0LtE/GhA1iToN8pb18uWMx6iL5PHOmvexPWRzVRmR9jw9ncx47K/0FE6n+pxzeOO2WynesZOi+3di7IthmhrDMGmaUsi8ho382PUlvpX9/7jOcw8/7TqLBjMPgDmuWj6d8wybwpV8Y9t1SSlrWDl5WM+nmG5MFLVq6E8ig7VLldGFlwrdSZfyskfZXOBHCCGEEKfEEbGxgqtImG7DyyrnJFZE95ChO9lvFLHdUZ7qYolhzuvv4oyv/5ANn/sIGz/9QcaZz2M8FsMEDGKwQPHqh79CoLKMrKZGJj/3NHk11XIjSqS9yvWbKNu0De0wcITCqS7OqNGtfDyoF5BJiD5ctCvrha4TTQLWIm1ti1XyjcDVfDzjOW45Yx0v/nYKna/7mL68kYsW72BtZDwfO3gTPab1SstidFFaU755CyU7dnJo2VIOLV1K639PpnD6HmI7PAQuKqbmjDPJamzif7suZn+4i9uzX+BXhX/n9z1nsylcxddyH6Uhlsv/dF5BRCevqe1TbmpG0MjqozWoPBpUXqqLIYQQQgiRUH4jgyddMwEI4hxxi2KL1PB09bD0f37Kpo+9h4Ofv4Cy/HUYa6P4b5jAnguvJqu2gen/eYjCfXskUC1GFUc0CtFUl2L08asM/GSkbPsSsBZprVVn8z+BK3i3dxUrlu6BpRDRBn/pO4NnIjMkWC0G5IhEGP/Kq5S/sYkD555D09vnAJBdX8/Ue5+kYP9+Mr5Ux4uhaWyNVPLp7Gf4WPYLAPhNH9/wX02PljomhBBCCDHaBGWRRTEIjnCEBf/3e3bedh0HP3A+fAB8TS3M+eXdVLy6lsCy8akuohBCDAkJWIu0F8HJ74PnsCdWildF2BUto9osSnWxxAji6elh+mOPM+GllzEdDrydnceNamgzs/hq5zVc4dtClgrxRngMjWZuSsorhBBCCCGEGJmU1sz48/1UPbeKYFEBhVt2YMTMVBdLCCGGVEIXXYxlWDeiSpanBsBI4IGYnNdmmSZvhnWakaJnwmBO1ooXI9N4Mjz7mGD14vJDlu9s+WjfILaXfGOesX4mxtEu96QGq6fi+GPn6enBd4Jg9ZsUj/bN5V+9S9gVLTvy16mLDyaljCfzhRWPJSyvnn15CcvLji9f+uCQbi+d6AQ+G2pEhvZBU8f4QMLy0t5YwvIaCZzdievKhQutz6/utsRtz3Qlri8Uy7H+3CNZ6dMJNYKjb930y7O38JeqP3J7wfPM8tSjsPd5mtmJaxN6q9KnDg010zfEwbYEnhT1Sn/C8rLDTlucTI6gTDYBYDqH9vu+7+dlx/0tu7aB4je2nXKwesxTiSqVEMPXxAeGZ5zGjsC4oW3nu6cmbj6VT856PmF5WTm1aJYGFT75CUy7ta2gta1NFVhPpq7a3bbyMvOsPxzDn7jAXt2eYss0s2bX2Mpr3eqplmkcfdadine/7VkYa729Pzx9vp1iJY3dOH5gvHU9e3G79bEzuux97jWX20pmydll7wKzYbl1usJtJqVrBj5gjWeB0e2w3qCdTr3ND6dkjb1O7gFbqU6d6bYuZ/s8Oxkp2udY1w9dc3zn8q1UuxsS1On94ZNX2kpnp6Zph3WZ3H6D0Bv5lunUZOsOw4/+ar34ZHROAEf5yO18HM3Vae/7PhyXwtIKVNT6u9xTk2OZxtFrfRyMMNhoqTBtBKNdB5M7DY8yB94nO0HYzKl+W9vqbLZe3MSwGaD3Zlj3q/q6vQTzBk7jOei2VbeD5Tb6Xt6ovZBjp3V/z4gotEUl8rbaOz9l701xMNiwd74wBuiTp0rGIetjFzuzy1Ze35314JH/l5mdLI7WEMTJXF8dHy58hT6cbJtUyW5dygFdROwkrchdz62wtT07/Zyzlu2wldWGB2bZ2+YguAJQtnrgslZfM7RTUdjtRtoJWifqEj7eTlkXrMtGO+voNcDGtccv3nWDZRp1nXWZYvlRggm80fJW2oBY5sn3R5WEbM2PrJs9lmns3FSNZtv71O3UM7ffXvsdGmd9Tsx+w/rcY+eaFCBabz0HbNHUNtr+ZP10ZnOLjfNruxtD1qYTw5Tpsf7u7Btvtz9vfe7WNq7D7cQQEt3vshO0ttWG2tiWmR+he571eeXvX7rCMk3hZ6qZXtJsmW7bnkk2SjYwGX4pRJoIZWZTfdYKivbspPDA3lQXRwghhBDitBWZ3SyMHqJDZfCacwIGJqVmN6VmF3NULYuNg4S1g326mF26jD26hD6sA2lCJFvU4yaYl0tWU0uqiyKEEEKMOBKwHsUuVNuZphr5o3k2fdgbrS6Gp56iEnZceT1RXwYd4yfjeOzf5NUO7TQUQgghhBCJlGv2sSR6kB7lYY1zPDFlEMOg1pFPrSOfzb1jGK/amKoamaaamGE0AvCf2Fw26HEpLr0YzaIeN+s++C56SkqY+eB/qNiwOdVFEkIIIUaU0TcBnuinWWYcIE/1UUBPqgsjTlNXxRiivvijZtrhoKtyTIpLJIQQQghxevJ1L040vbiJnWCSAhODgPbQqrOp1W9OXzVetQ5lMYU4TjA3l56yUjAULdOmpLo4QgghxIgjI6xHLcX3Y5cCELU1c6gYzso3r0dpk/p5i8lpqKNq7apUF0kIIYQQ4rRUGwU4iTEj1sSZ0f2sd47FpyMU6gAFZoCLHDvwqvjsjX7tY7NZSY0uYKuuSnHJxWiX1dzCgj/9De1wknfQ3tpFQgghhHiTBKxHMQlUpw8FlG/ZSNmWjbYWSRFCCCGEGPaUYq+jhB7lYUH0EBdGdh15qUt52KorqTELqNEFdGG9qJkQQ6lwX3WqiyCEEEKMWBKwFiKNSLBaCCGEEOmm0cjlJZeXbB1Eo2hXGUSUk42R8akumhBCCCGESIJROYd1jqOXtxVuxEEs1UURQgghhBgFNFMyGlGYqS6IGKECykOjkUuTkUNEyZgbIYQQQoh0ltCAtQoP7fhOXRA+5fd4VIQ/Tr2bn0z6Fz+YeN+RCyczL5ro4g1o29axCcsr5tOWae5+8IKEbS+dmDlD+7lHcxJ3od42y/rrW/bqsb9roL3sbJrGXYNpuE9tg3qUjd82rL9Xdg2mrRouwnlDG1xybskc0u0lUyR35AbmVOKqvy3mKTZHA4mMCyYus0EwItZtZWB3XsK2ZwYTN72XL9v62IXGDa49+8SYZ3hm4Y/5zqQHiZ+NwAwmLuhouqwrbbBoiCu2OCHHqpwh3d57zn8xYXm9+vqMhOU12gx1NzKR5+BYxtCezx0dqb0ho5s9Ccsrmm197JzdiQtJJLLf2j3f+nyXWZ24srfuLkxYXuYIvvYQYrgy3SO3H2l0uBKWV9uPxycsLyundjY0IJZ18pOAkcCAtWq3cfVqs+ez/+I/9KfXqN5GVKQH7criuqKNXFuxD+0rYcJjHySWOfCI6/cve8XW9v78+ErrRON62dVYYpnM1i46NNFs6y/PH549zzKN6Rm5AZa3MrqG5+ibRAatG88a+PVJn3qNSffG/6+BXR9/H51zlwHgr72YBV/+Ls7ePvb95AzLbXmbDexMOtK82GZD/jd7yY7h0JY3GRL6udsIWqsWG516x/A8ubkrA5Zp/m/BPcf8bmiT8bE2ugwvrUb2kb9/7JH3WuYVKrJZ9xt89tINghEFT8vJLy5CxfbKaKdtVjqBF8ymjQ3avMlSNLXNMo3DsFfujtWllmnC+dZ5mV572zParPsGsQyTUEnybkZqB0RyT95fcJf0Wa4QEW7MoKsm13JbymnjM/XF0DHrC+a8zD7LNFPzWizTvPzaTFv1+sCVv3vzl1AnRl8z2nBxW/lrvHPCbvAWMvmeD0Ov9WeqbcTkVV4Yq6PlqPMSthEr7StNYl/IZaJKLW4M1Fm3gZ6JXQkqEARrsi3TmHbqImCc22GZpsufAT3W586Pv/oO6+3ZuQCz034CRdNbLdO07i60FbQ2ZyYvWBTNgJYFVt95G+2ujZs8dm7AAei8iGUaZWjL7yiA7rbxmXptPCXr0ITyrZO5Gqzrot1z1L4bvZZp3G3WxzRcaGJ0J2+tIV9GiDkLD5z09fo/TASs9yWcbb0v3ZNNy6B10QaFnWuM1oXWNejGlast0wDU9eVZpnn19RkExg/dtXHeDoPojmLLdJ4K67zCE4LowlACSiVEahhB676t3ba5YLN1+9I+1zqfW1a+ap0I+McLFkEawLTZxNu56adt3DdTEYXRat3nrl9p3c6abk3t1vHW26w6/UFEo2pKEBVsQ0V6ML2F6MxytCcfFe5CBVvBVhdKiJHpcLC69trLGHvPw8z9xg/omjaJjd//CtGM5AUHRXrJMoMsjxxgeqyZxZEaymKJC5gIIdJUuAfV14x2ZqCzx6Fd2RjBdgh1prpkQgghhBBCDNoio5qzjd1IPDE5Rk/AOtSJCnWg3TmwxQs/a0dvzUC781AhP58e8/Sgsi2km2mqIcGFFSJx3hqsLvn16wReqmDi5/91JGh9ytODiNFFa8bF2jgrsh+vjrDRWYVf+ZgfPSRBayHEyUX7UL2N4PCiM8thfRD9Bxd6iwfV18zFJVtSXUIhhBBCnIbVv93C/7vkBVb/Vs7pYnQ529jNdc6NXObcxmWOLUjQOvGG55wJyaCj8dE927JRN9ZDRINLoe+pgFkmE3ytKEz0Kcbwq5SfuaqWXboMO48yCTHUtMtJb1X5kWD1Br6OiRPjjSgTP/8v6j93AbEuD4Ypc52JkyuLddFmZLLZWUlYOWkxslgcOUimlscNhRAnYUbAcKEzK2B9CHVD3ZH+F3e7qfD6U11CIYQQQgzS6t9u4YIPTyLMDNxPhXmWLSz/0JxUF0uIIaApVd1sjlXSg4di1YOBxpSYYEKNnoC1txCtNazugIhGxUCjYXUQvbiET+2++ZSD1QCbdRU7JFgthjEjEmX+V76Pikap5m2YOAFHfHbDN2D5ez/NgR8uTm0hxfCmFOtdY4ligIq3dVHl4HXXeLQaPQ/qCCFOkTsH7cqOtxur+o7pf+k3srir7JxUl1AIIYQQg/TC/W2EmUEMJ2E0L9zfxvIPpbpUQgwFxQOxhaj+ILUDjTmKJrAYKqPriCoFZ/riI6sdxEf4nOkDpQZduTSKMIlbcVOIZDCiURSQz3YMokAMg2j892jyFicT6SOqHEeC1YdJsFoIYelwu3Fc/ysjpcUSQgghxOlZeX0hbsI4iOAmwsrrC1NdJCGGjOZwHFERG2Wh1aEyekZYH7bYh763Mj7S50wfLJYF58Tokad2s1B/mw5mks928tTuVBdJCCHEaHCi/tf+VBdKCCGEEIO1/ENzeJYtvHB/GyuvL5TpQIQQCTX6AtYQv0iSQLUYpfLUbvKQQLUQQoghJv0vIYQQIq0s/9AcmQZECJEUSmv7K1kqpVqAg8krjhhBxmmti0/lDVJ/xFtIHRKnS+qQOF1Sh8TpkPojTpfUIXG6pA6J03HK9QekDoljSBskTtdJ69ApBayFEEIIIYQQQgghhBBCiGSRmcGFEEIIIYQQQgghhBBCDAsSsBZCCCGEEEIIIYQQQggxLEjAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAsSsBZCCCGEEEIIIYQQQggxLEjAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAsSsBZCCCGEEEIIIYQQQggxLEjAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAsSsBZCCCGEEEIIIYQQQggxLEjAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAsSsBZCCCGEEEIIIYQQQggxLEjAWgghhBBCCCGEEEIIIcSwIAFrIYQQQgghhBBCCCGEEMOCBKyFEEIIIYQQQgghhBBCDAsSsD4JpdQLSin9lr+tVEpppdQ3U1QsMYJIHRKnQ+qPOF1Sh8TpkjokTpfUIXE6pP6I0yV1SJwuqUPidEkdGrwRG7BWSk1XSv1cKbVVKdWplAorpeqVUo8qpd6vlPKkuowASimPUup2pdQapVSrUqpHKbVDKfUzpdS4Ad737v739PTv3wtKqSuHsuzpLl3rkFKqSin1FaXUvUqpvUops78xnJyK8qerNK4/Zyml7lBKrVVKtSilQkqpA0qp30sdSqw0rkPnKqX+0r9fbUqpYH8delgpdUEq9iFdpWsdOsn7t/afy2qHosyjRbrWIaXUe/rry8l+PpKK/Ug36Vp/jnpfrlLq20qpzf3v6erf1zuVUq6h3Id0la51SClVbdEGaaXU11KxL+kmXetQ/3tKVPy6bKtSqlvF+9XrlVKfV0plD/U+pKs0r0OTlVJ/UkrV9u9Xg4pfp00a6vIPhjPVBRgMpdTXgW8QD7ivBu7m/7N31+FxXOfix79nFrRiJsvMdswQxw45zGkY2pTSlPm2t/wr3MJtb5nTNm1TTJMG2nCDDoOZ2ZZlyZItxtXSnN8fu3YMsuZIXmm1u+/nefaRvXv2zJmZd8/MvDNzBrqAcmA5cBfwYWBRgpoIgFLKDTwLnAlsA+4BAsBi4OPAu5RSy7TWW4773g+AzwC1wO8AL3AL8IhS6uNa618M31ykphSPoUXAtwAN7AXagYJhbHbKS/H4eQAoBV4F/gaEgaXA+4BblFIXaa1fG765SE0pHkPnx15vAM8B3cBY4GrgKqXUt7TWcpB2ilI8ho73HcAxsS0GJk1i6N/Auj7eXzU0rU0fqR4/SqnpwFNAFfAM8ATgAcYDNxE9VgsNz1ykphSPoZ/Q9/GXAr5ENA/zxNC1Oj2kcgwppcYT3ZcuA1YQjRcfcDHwf8BtSqkztNb+4ZuT1JPiMbSI6LFYbuy79xDdn74FuFoptVxrvXZYZ2SgtNZJ9SLawWugBlhykjJXAs+f4nRWRBfPMe8tj03764Z13Bgr/wxgHffZN2Kf/eG495fF3t8FFB71/nigGegFxid6PSTzKw1iaDRwNpB3dDuAyYle9qnwSoP4+Twwqp/53pjodZDsrzSIId9J6qoCDgIRoDLR6yGZX6keQ31MzwY+FCtbm+jlnwqvVI8h4D2x99+T6GWdiq80iJ8sYAfQCpzRR51uQCV6PSTzK9VjqJ+6LomVX5PodZDsr1SPIeCXsfe/dtz7LqLJRw28K9HrIZlfaRBD62Pvf/q4988ielHaupG+LUuqIUFiZ5m+TvRs9uVa6zf6Kqe1fhS4tI/vL1FK3a+UaohdDr8/dkvXqCFq8sTY38e01vZxn/079rf0uPcP36L4ba116+E3tdbVRDutDOC9cW5n2kiHGNJa12qtX9JadwxRm9JWmsTP97TWB/qo63uAH5illCqObzPTR5rEUG9fFWmt64heuW8dVa8YoHSIoaPamgfcDTyrtb5zaJqXftIphkT8pUn8fAiYAnxRa/368RVqrcM6dtQvBi5NYuhkPhD7+5tTblUaS5MYOvydh49+U2sdAR47yXeEoVSPIaXURGAOcAj46dGFtdYvA48Cc4le6DhiJVXCmmii1gM8oLXe1F9BrXXg6P8rpW4HXgEuA54nepvOKuAOYJVSauwQtHdz7O9lSqnjl/Xh8aifOe7982N/n+yjvieOKyMGLh1iSAyddI4fTfRMLESvkBWDk7YxpJQqA5YQvX1te3yal5bSKYZ+BhQSHZJIxE86xdA8pdSnlFJfUEq9Uyk1egjal27SIX7eTnS/5x9KqfFKqQ8rpb6olHqHnLSPi3SIoRMopcqBq4gON/D3+DUvLaVDDB3+zhVHvxn7/mVE7z57Lp6NTDOpHkMVsb/VfSS4AfbE/o7o5wsl2xjWZ8X+PjuQLymlpgJ3AtXAubGrvA5/dgHR8cl+Clwbn2Ye8RjwIHAdsFEp9QwQBBYSnZefE71q+nBbsoneMt2lta7vo76dsb9T49zOdJLSMSSGXDrHz41Ex796XWvdFud2ppO0iSEVHTftSqL7GqOJHqTlAx/XWjfFuZ3pJC1iSCl1LfBu4A6tdU2c25Tu0iKGYj553P8jSqm7gE+d7G4Q4Sil40dFH6Y4F2gE3k90DP2jj5m7lVKf0Fr/Ic7tTCcpHUP9uJ1oguxurXVnnNuYbtIhhv6P6H70N5VS5wFriD7b7GKiycg79Egff3hkS/UYOnysNU4ppfq4K+jwFdvT4tzOuEq2hHVl7O9AnxD/YaIbh08eHVAAWutnlVIPE30QVG48Nx5aa62UuoHoIO5fAWYe9fGzwN+11uGj3suP/W0/SZWH3y+IVxvTUKrHkBhaaRk/SqkJRDeCYeC/4tW+NJVOMbQo9r3DOoH3aq3/Eq/2pamUj6HYVWi/BZ7QWv8+Xm0RR6R8DBF96PTHiR441hLdxz4L+F/gg0Ae0atoxcClevwUET1GLiYaL/8D/IHosGjXEL2S7i6lVLXWWq5uHJxUj6ETKKUU0asvIbp9E6cm5WNIa31IKXUG0f7nWt66y14Dv0Pusj5VKR1DWusdSqmdRIe3+gRHDQuilFrGW1dlF8arjUMh2RLWg7U09vdcpdTiPj4vIzp4/VRgdbwmqpTyAX8meqvAR4mOLdND9MmePwNeVErdqLX+98lrESOExJA4FUkbP7FhHJ4gOibWR7XWr8WrfWJAki6GdHTM4TtjdUwgOibon5VSZ2qtP3R8eTHkkimGfkd0H/UOxEiSNDGktX4BeOGoanqAfyqlXif6EKJblVLf01qvj1c7haNkiZ/Dt1q7gN9orf/nqOp+r5TKin3v88jt+MMtWWKoLxcSvaJxjdZ6VbzaJgYsaWJIRcdYfhjIBC4nOgRFFvA24IfA25RSS7XWe+PVTmEkaWKI6LHXE8BPlFJXEn3I4hhiV2kD84gOLTNiJVvCuh6YQXTYjIE4PNbYfzuUyxlwi/r3BaK30X9Sa330gxWeiJ0dWUf0TMfhoDp8BXU+fTv8flt8m5lWUj2GxNBKq/iJJaufI3qr0Ce11r+Kc/vSUVrFEBx5CONW4JNKqQzgg0qpZ7TW98e5rekipWNIKfUuosPHvFv3/QBYcepSOob6o7Xer5R6HHgHcA7R5LUYmFSPn6PvdH2oj/oeIpocOD3O7UwnqR5DfTn8sEW5ujo+0iGG7gZmA3O11hti73UAv4klL39C9Grb98S5reki5WNIa/1c7Cr9rxDd5zmX6NjVnwfqgHuJPpRxxEq2hy6+HPs70IHBjySCtdaqn9cL/dYycIcvs3/++A9iV3S0Eh1Tpjj2XjfRwMlRSlUe/x2il/MD7IhzO9NJSseQGHJpEz+xPmgF0duNPqq1/lmc25au0iaGTuLww4OXn3rT0laqx9CC2N8/KaX00a/Y+1VHvVcQ57ami1SPISeNsb/ZcWhbOkrp+NFa9wD7Y0Xa+qivNfY3M77NTCspHUPHi10A8jbkYYvxlNIxpJTKJZpcbDkqWX20w/UsjHM700lKx9BRn63VWl+vtS7VWnu11tO11j8GZsWKrIxzO+Mq2RLWfwRCwPVKqZn9FYxdxXXY67G/Zw9Vw07icBtKj/8g1r7c2H+DR310+NayS/uo77LjyoiBS4cYEkMnLeJHKTWa6K3U04EPabmyOp7SIob6cfgqBhl7f/BSPYZeA35/khdEb388/P9jntoujKV6DDlZEvu75xTbla7SIX4Ojw07ixMdfk9uwx+8dIiho72X6Ji392h52GK8pHoMeWN/85RS3uO/c1Q9kgMYvFSPoZNS0YcL30p0/kf0Ha9JlbDWWlcDXyf6A35MKbWor3JKqUt56yougF8QXRk/VtGneh5f3quUGoqAeyn290vHBTlE58MNrDxuw3Vn7O+XlVJHBkCPjWH0UaIHZ38cgramhTSJITFE0iF+lFLjgBeBScDtWmu5dTGO0iSG+rxNWik1CfhS7L+PxbmdaSPVY0hrfa/W+o6+XrHvtB71nn8I2pvyUj2GYm05YZ6UUpZS6otEx59sAp4cgramvHSIH+CXRMf1/IJS6khyIHYb/rdj/71nCNqaFtIkhg636eiHLf7m+M/F4KR6DGmtm4kOp+cG/t9xbfQRHeIBog/bE4OQ6jEUa0u2Usp1XPvcRIe1mgz8SGvdMARtjZtkG8MarfV3Ygv5a8BKpdSrwCqit9iUEx2bZUrsvcPf2aaUup3oE1Y3K6WeJDqshgcYS/TsSCPRqwnj6dtEx2G8ANgWm66f6MDop8f+/cnj5u9VpdSPgP8CNiil7if6I7qZ6FOrPx77cYlBSvUYAlBK3X3Ufw+36XtKqcMd2F1a65cRA5YG8bMCGE/0IRHjlVJf76Peu6UfGrw0iKGnlFKHgLVEb6t2Ez0Bcmns3z/XWj8d53amlTSIITHE0iCGViqlNhEdo7qO6HNgziR6dWwP8A6tdUec25k2Uj1+tNarlVLfAL4BbFJKPQz0ApfE5utV4P/i3M60kuoxdJTziSaG1mit4/YANpEWMfQJohd4fEUpdRHRfieT6F3344BdwPfi3M60kgYxdB5wl1LqGaCW6LjalxI9Lruf406GjEha66R8ER0g/efAJqKDzweJDpz+BPA+IKOP78wmOnj9PqJXKrfEvv8b4Pzjyq6ILp5j3lsOaODrA2hnKfADomfIemPt3Ef0Kunp/XzvPUTHk+kGOonenn9lopd7Kr1SOYZi0+jv9Z5EL/9kf6Vq/BjEjgaWJ3r5p8IrhWPoE8CjsTI9sXbWAP8ELkn0ck+lV6rGUD/1aKA20cs9lV6pGkPA94nuOx+Ile8BthG9Mmpiopd7qrxSNX6O+t51RO8664h9bzPw5b7mS14SQyf53r2xaX0w0cs6VV+pHEPAHOAvRPejg0STkpuB7wAFiV72qfJK1RgCpgIPEL2AKEB0nOvniT54WiV6uZu8VGxGhBBCCCGEEEIIIYQQQoiESqoxrIUQQgghhBBCCCGEEEKkLklYCyGEEEIIIYQQQgghhBgRJGEthBBCCCGEEEIIIYQQYkSQhLUQQgghhBBCCCGEEEKIEcE9kMKunGztLioaqrYcy+RZkGrIWzE4Bm1395hV5QrYjmXCWc7nHSI+s+l5O8wewtnVXtektS41qzXKlZOt3YX9x4/HYLno4rDR9MIhl2MZFXAOosLCLqPptXTmGJUzkZ3d61imp8N5paqI2fSUyWo3fD6raawF99cOLoac+iDLoKH28HYeyixk0QPqkfvhNlxZBsUsv9mysgxiLZzpXMa0bwToaR6iGDJwWuEhxzKbW8tOeTpDwfI6ryyrzbn/BAhnOZcxWaem/Yb2Om8TCZufix9MP1RSUqLHjx8/kK+IFLV69eoBx4+vwKdzKvvfX+jsNfhBRMz6Zt+hkGOZ3jKPYxll8NMD0CbbH23W9pKcTscyze25zpMz7RJcBm03XO4en/NyB+jeeXBw27Hiwv4LGS7jVGYZ7nvZzuFvvD9tBQ2m53UuYxyzDNH+tMm+NBjtT3vbnesKZ5vFqx2v/eREMFikRsdjDCw+nAwmfsA5hpTB/lqJz+wYu7Ejz7mQ22wjpQxCTZv084a/kdNymxzLbGk2O16IW7duepxouL0bTAx58jO1ryK/3zKhbufOuSC/22h6rZ3ZRuUcGa53FXZedqa/Y5PtiknfoXPNNmTaJMnaa9Z4o31CILjv5LnFAXX77qIiqj77qYF8ZdCMVrLpj22YqaBz20vWm9WVv9O5I2+a77yz3jbDrBMf/YxZuZce+dw+o4JHcRcWUfWZT/dbpmyVcz32bc4dP8Chhv47QQDfXue9xmuuf8VoevetWGpUzsTixTsdy6x9bppjGU+H2fTczvlx4x3/9mlmMbT3k58deAwZ9EF2pvP0rR6DZJzpXqMBb4tZpx4sMswIONDFBls2QIec25Wz2eDICshocy7TOtt5/orXme+NrfrjZ4Ykhky8cuMvHMuc9s+PnfJ0hkLmOOckUPaDBgcHQNNC599JyWrnddo6w2y9R8b5nQsdMsx+A3s/NfAYGj9+PKtWGWysRMpTSg04fnIqc7jiT2/rt8wLW6c61mO1m+3CT/tZg2OZbZ+qcCzj6jHbjoWKnRO1ymDbA/D+s1c4lvnjoxc4ljHZLwCw85x3dKwOs+VeOcP5pCbAqxf/38C3Y8WFVH75k/2WsQwPJlNZRpPZMvBXOh/Eu7vM6srd67wt6xznXI9pzMLQ7E/bhokNq9N5f3rMk851HVpocNYACJTGZz85IQySf65ew32h7Pgth8HEDzjHkGe0cyLxPdNfN5rWb59z7uetkoBRXcpyXnahTudjH1em2YHxS+f9xrHM3L/2358fZnLCxuTwNVJqdpxotZgdAw5mX9pXkc/CX93Wb5naVVWO9Vx36atG07v/hTOMyjmJZJn99jytzn1jJNMs15C9z3n7Y3LhWOTcdqPphSMGF8Pucs4/AoRLzU7e77v98yeNIdmbEUIIIYQQQgghhBBCCDEiSMJaCCGEOEXWql7cP2/DWmVwu4IQQgghhBAi7VirAnh+3o61yuyqcCHSmSSsk8S2qy9l10XL6S4txnZZHFgwh83XX5noZqWlXPyMUq3k00OlasN4cGchUoAGOkvH0VUyNtFNSThlh7DCfqxVvXhvOoj7/9rw3nQQa1UvVqibvIEMyC2EEEMonJHB3ovPRccG8OwpLaZu2cIEt2pgsglwqdqY6GYIIYQYAgV0c77aypnsJA+DIeCSgdZ4ettAR4eSsFYF8N10CM//tUf/vtZKWYbZUA1CpKNkfnRB2tAK/EWFNE2dxN4LzsHVGyDiyyC74RChTPOxOkV8vNv9KhrFLl3GOdYOvh26gh4yEt0sIYZFxOOj5vTrAJj52I9H7LNvh4OnpxnLDhJ+NRdCGhUBjcZ6pRv3lE4+Pfk/fGPbtYluphBCUH/6XLbfdCXd5SVM+M8KVn72Q0Q8bsrWbk5004xNVQeZpBrJ1EH8mI2tKYQQIjlMpIklqhoUhG0XbzAx0U06ZVYkgCfQgTvkpze7FNdrvcccM3hf7uRd573MD7ZdkeimCjEiScI6CSgN8+++h0BuDg1zT6NzVAUV6zZRvGN3LFlk9qAKER/r7DFc6d5Ise5ipy6XZLVIK2FfzpF/hzLz8PoNn+yZgkKZRWR0HUAtCIBHodHgUbgW+EFZ/HT3xYluohBCADD6pTfpLSpk91UXcmDpQlyBIIt/+Bs8/uQZxmitHstaLXf3CCFEKlrDOBrsPLIIsovyRDcnLmy3j97sMnzdjWR2NRA8Pf/IMYPyQHhpBj/adlmimynEiCUJ6ySS0dnFuJffSHQz0t56ewyX641kqRBrI3LgJNJLKPOtpwIHcorSOmGtXV7CGfl4ZrcT/HshaqVGLYrgntlJILOUtlB2opsohBAAKGDyv/+Dsm3qli1k/i//RF5tfaKbJYQQQhxxgMJENyHubLcPf04Fvp5GvNNbifzZi/u1IOGlGQTOLMOullF6hTgZSVgLMUCdZLJLlzGOFrbYlYlujhDDKuQ7KmGdW0xuY3XiGjMChDMKcIV6cM/sILi4jIyuBiLuLGx3VqKbJoQQx1DA5EeeZvIjTye6KUIIIUTa0C4P/pwKMnqacM/uJbwgi0BmMah0HlxRCGeSsBZiEB4MLyBXBQjJT0ikmVBmLtgRXOEggZyiRDcn8ZQimFlMRncDGV0NAAQzi2QHVAghhBBikMLeLMIZOfg6DyW6KULEh7IIZJUSigSwXRlyrCCEgaS+/0CFk/dH3jQ3fnWVrO10LFOwNalX9TGsv5bEra7eCUHHMv964MwT3msjm/06scm6+edvdywTyovf9Ox0y83r+PUvwSI7bnWZUM3xexhV12nH/kZCvhw8vV1kdDYNScK6eZ6Oe51DTbt9RLx5KDShzCKwoj+WzTf+IsEtG7zu64Z3qJfCrXFc72XJMyavEINl54eHdXqRrPhtx7RneLeJlj9++8B23vAudzF4gZL4xVk4J3ljdlDT73TFra79lzrXVbY6dMz/e3NKqD79HVQvvpWO8mlxa8tIF/El3z7wyYRqnYfFu3vbGXGbnt0Uv2dKeXKd8wMR/yAPjJXCdvuOSVavv+2ng6urDyaHr67G1Hlo8YNPLhvW6bl64tc3u/zDm8t0vZAfv7omO+cf4yWuKSjb7dzJejrMNoAmO8YFmy3AeUW3znauSxnsh5jmr9y9zgWzGiBgEDM73uV8W3nJGgsr1P+y75igcHc6/8AiQ/j8QOW1cY/p7rdM21jnGDpn7G6j6T230TmxbWdogsX9r/y5C/ewvTM+D34of92s3EqmmBXM7b/t8xeZLavVmyY4T2qHGzsJnu9pspNvZ0Ycy1Q9bbZBalji/HvXXm2UtLYLQ45lrFazlWCStLZCzm2fdH838NaO24HpWWQfbCfn4CEa5s6i8uUuFFC/NOekdRzm7nJepqFcm6b5hjvsfzQrdjQrCJl1J2+Hv8rsoHT64x8+5v9uFWFuzn5Wd47j8HbJV+cxeiRuqMBgmrbzurK9Zm2PrHPe+PSW2HSfbrAeLOcyvTe0O5bp2psPGEyv0XAjpVLnoE+kls6eTF5YPaPfMiZ9s6ntn6hwLGOyDwxg+5wLZu927vV6K8wm+Oi3z3Nu01V+xzKfXWA2BMoP/nOlYxnf2E4ocK6rcaXzch80rVCB/rendoHB/kSb87qyAmaxGMl07nNN48yIyTYxO4J/jPNETfYbvaO7MXkGXKed61jGZPMUzxNEgxWvpHV2tUXL9P6X8ei/bGf8yui/m2ZPZ+dnb8DT6SenqYEDMy+l9OkDVL66it2fdE5eh/OG+SIRw/46km3QLpfGdt6dpmCDcwqnY8rQLgdXRoScCSffv+vam++YtFZhxV3VFzpOSxnkmAD0Ied9RJOaVFA5Jsm0V0O3829k9j8/4Ty9sgCMcb7YItLtvN5V2Lk/mzKtzrEMwM4hfPBlqNtD3ZtV/ZaxDbYrGc2KR+43SFqXxu/3YJK0Njn5pLTZdtHkAsTAuIBjGc+BDNjqfAw4cek+xzI7142FDOd5zN106smjdLtmUgghxCnoLcgjr/YA2YeaCGf6CObmkNHZlehmJVxYu1jdOT7RzRBCCOFEa2ZRRwZhVjNObssWYoSoO2cJmz78LrLr6ln0nV/g7u5h9Zc+xvpP3k401Sj7m0IIkU5SZ5wIIYQQQ0oDgbw8fG0dZDc2AdBdGr8heoQQQoihZGmbK9jIOexiCdWcxa5EN0kIAVRffj4bP/5eCrftZMlXf4CvpQ13IMjC//0lhdt2s+ETt9NVPDnRzRRCCDGMJGEthBDCjAK330/jjKnsvOxCsDXuXhkvWAghRHLIJEQVrUf+P4aWBLZGCHHYnmsvpWjTNhZ9+xd4et7at3T3Blj4v78gb+9+Dk06H9uK3/jaQgghRjZJWAshhDCiNMy550H8xYX4CwuY9+d/kHegIdHNEkIIIYx0qwweYCGHyKGWAh5ndqKbJETa00AoN5uCHXuxwic+2NTdG2Dan+8n4s2mo1x+s0IIkS5kDGshhBDGCqtrWHznH/F29ZDZ5vwwPSGEEGIkaVY53M+iRDdDCBET8WWgXS48nd0nLVO0dRe+9lpaRy8ir2EjlnZ+gLoQQojkJldYCyGEGJD82npJVgshhBBCiFMWyskGwNPd02+5ov1vEM7IpbNsxnA0SwghRIJJwloIIYRIYxFXBu1l09GoRDdFCCHECKcB2+r/Jt1CTzdLCnbHSgvRv1BOFuCcsM5qqyGjs4HW0Ytln0UIIdJAXBPWVth5wxHKi9/tO22n2XGrSxssCRXHfa6eivjV1bTAeTnk7U2dHcYXaybFrS4r4Byz61dPjNv0Dp4Rt6qMrF0Vv2XVOfXEMeVMdBVMJ+zJiVs7hkvdRfHrX1QweXeqd9+QPazT83Qm9jxqZl38pt9bFYpbXSas4MDbbisXdbOupmHGZRyccv6R1IKvaXjXQ84EuWJfiHThaxje/uUHay6KW129NblxqysZ2BnHHj+E3VnUzXw7exd+gr3zP0rNrPdQN+0GGkdfTs7oydw6fS9/Pf1uVp7zdf6x6Nd8acqjHE5amxxrxZPVHb+H8wVrh3dfyNWTOteUdY933p8+cO10ADxdJx8SBEARvco6lFlAZ+m0Psu4O4Z32WlPHI+xI/E7XsjbmdgYMtmv0+6RmZ/QXud2xfPYTh/KiF9dbuff287tVXGbXqIFikdmDJnQw5weCI0KxK2uKfNq4laXk7iOYZ27y7lj7Frmxy5yruvSqVuO+X8efk5376XGLmKnXY5G0RnywRLnul5bcZpjGTvT+cedU23W8XcZbJhz91hog6VvchJAhRStDndGVb5q42vtvwzAgXMNfzn3mxU7mg5ZhOuy+i1jkiyaeOUe6v15juXC5c7JIqvNeSVEsmzWbB3vWM50t3hYk9a2Yu2bkx2LWZZZZ9891jm2J33q9SP/rrv8fPZ+9gqqHn6KST/53THl9hpN8ViujIjjDlBHTb5jPVZuNDYUNpN9jSzIruG0zAPs6i3j2Y7p1AULsQMu6q5wnl+rI37dqNXqiVtdJq48f6VjmYdfWcTOd/T/uwVQdhwT/EO472F7wV918rZGss1OquZvdl5XXeNtQgUG2wODbWfHVOd6lG22zRjzjVeBaAph85c+gb9gNMVvrKV5yXxKH1nP+HsfZvdPzsAyWBQRg21n117n32TBFosC58kZneytWuE3qClqMP2QEKfE0pDp8OPqde5fJt3f/5WIh+2+OdOonBPTBFrE51wmNMXsN3rwDIOD+EazA/0f/OdKxzImia7MQ8Au5z6t8IDZtmSnUakTOW0ndY/zvomd53whQsEq75F/B7Ly2H/2dYQzcijb+jq228uUojouK3mBKwufZr53AwAbQ7P4TveXqbAaeP+4uwh4Pfyg9nzyVxkEB9A5yXm7ol0GCSUNlt95nXrancu4AsAh55MV4dHO6z13l/MRQ2Bp19A+aMptQ0k/yYum+CXQwDlpbbVGp9e5qJTI5JPvx4RzNRmh3Xj9jbSMO53M3q0nXGdt+8z2R00uWjLhNrzQQkWc13s4JwK2c7s6psRvn3uwImGLjuaTn8jJ3OPFKYo8iw2SE5jtR8abU9LaNjzwN9mXzpvUZlRXt8v5d5md5ZyU7F1VxP6Gsc4TrBi6ceKVL4JnRv/H9BHDE8SBUuftgavSeb9DbXc+Mek6rcOoTT3NzsfOpvtVoXyDY8kC5/nraMomWOacH9u12jk2cvYpTNZOKA7n+Ef8Qxc9hLnAvY2LPZvxqeiOVZOdzWvhSTwbnk6zTq8rHYRIFnWXn8/Wz36Y4jfWMvWXdye6OQDkuHqZm1fDoordLMiuYX7WfvLcvQB0R7xku4J8nUfZ5i/nmZaZPNs6g3Vdo9EyepJIQXveezMNF57NpLv+zvh7/sWmL3+SXR98J5kNhxLdNCGEECOIP6+YPWdfh3a5uXjdT7ml6jHOm7CRsQXN2Fqxpmss3zl4GU+0zWN3eAIRVw69vsuxqxQfq/wd3a5S/rZqsQziIPoU9kZPZriDvY5lFZB/8A0ax19JT/4UstsHe9pHCCHESDeCE9aaxa5q3uZZR5HVw7rwGB4NzWaU1cYy9x6u8m7gCs8GtoRH8WJoKitD4wkbX+MqhBhKRyerx33lX9SEr6CQLRSoHcPWhixXgFm5tUzOPsTMnAMsyN/HtJx6XEpja8WO3jIeblvAKv8UVvVMYW+okinWNi7K28T5+dv40KgX+FjV8zQGc3iubTrPts7ghbapBPTwXgUtxFA4cOly9r7zBkY99iyFf9tMNW+j6n+fore0mM1f/DjlNQ/g6zmQ6GbGhVbgLyggq7Ut0U0RYsh0Vpaz5boryT7YxMwHH8GK410vIr11F1ey98xr8NldfL/tdmZVNvPCG8t5vKGCRl+YFXtnsXv2W1f+eWlmwdY1nLHtTzw2ax6+y2/i82X30HPNWO59ehoZ3W2JmxkxIkW80fhxHZWwLosorLYiiqqqsQpb2NtcTgvRxHZ2+07aeltoK19CVvtOOREihBApasQmrJe5dnNbxhvU2EX8qXcZO+1yAA5EClkVmUCR6mKBquFs704+4lnBC8Gp3OU/O8GtFkIECgvY+tkPk7tjD+O+8i/Whb+EjRuLMAv0/wxb0vofC37NnLxaADrCPta2j+WJ/VfzamAJr7nPpdEzk7C7ADxA7E6zplAD+xrv5veNZ5EbDnBuwQ4uKtzCZUWbuLlsFf84tIgv7LlhWNovxFCxPW62fuoDZBxqovLHL7CGr0Z/o+Ews772Ezbe9xmaqy6gaudfEt3UuGicMZ1NN13HGT/7NVktZrefCpFMtIK177mVYE4OnaMqKdxbTdXq9YlulkgBGqg+4yq0Uvw9fBWlEVh++/MEQ16UK8Kktz1AdkU98NZt6At27uNv3/s9nnCYj//7Od4Rvp2SK5fyjcrv8e/z30A/8krC5keMTLY7mpII+7JxdbVTFlGsuPeDBINevN4gz/7hAirH7ub8VV8AQKHJP/QmTWMvlaushRAihY3Y+9xPcx2gyc7me72XHklWH61F5/BQYAGf6byJ14MTmO+uQcmTqIVIOG9bO8Wvr6Fr/BgOFZyBjRtwYeOmlZnD0gaXijAj5wD/PLCIxW9+n8o9Gzjfv47Pev/Fg7lf5JB3Dt5QA0Udz1Da+i/KWu6nsOM5gp4K2nLOAqA9ksXDzfP4+K63c8XGjwNQ01s8LO0XYihZoTDj/vkIgbISdp7xzmN+ozuWvhttWeQ3Oo9vniyKdu9l1n0PkinJapGilIbJTz6HKxAkv6aW0m2SvBHxoYDivRuZ4tvLlZPe4If/up1gyAvaQkdcdNWNPuE7Z2zbiyccxm1rPOEwZ2yrJo9mDkQqqa/3njgRkfaKd2/BFehl97lXYbtcTHaFCAa9RGw3vYEMfvPoOxhd2IzirTtHclq34vE30VJ5NraSu6yFECIVjdArrDWTXYfYEhmFdrjJR6PYEB7NGd69VFmt1Jo80VEIMWSU1pz23V/wxm//j0MfOx3r62FswCJMIVucvh4Xo32teCybN9omsSPzbHpyJ5HTtpmMnjoyeurw5hw8sWcJQMhdQlvOMrICO/AEGo98dGHhVgCeaJk1LO0XYqhN+v09oBTVt16LeiOCDkfAo+i9tIzTvvsLeq50fihHsnAHApRt2ZboZggxpEat3UDlug1D+tBakZ7Kt7zGF+e8gF9nsqm4EuWKoCOgXBFyqmpPKP/69AmE3G4Ihwm53TTOz+bsvB18tv17FG5Zk4A5ECNdRncH4195gt3nX8ucSyPcGniIO//ySSLaAssmr7IGt2WT5+mlPRR9mJlCU3xgBQ2TbqCrcCZ5LRsTPBdCCCHibUQmrMdnNJOrAuyKlBmV3xquBGCGu57aoCSshUg0b0cns7/5Y1b/+Bvk37GN4rvWD+sY1hOyosnmPT2lRHJycYU6KT7w1JHPT3YarKjjafwZE2jMv4rKrj+hiD4d+bKiTWztrmBvb+lQN12IYaGASXf9He6A6p9cC+uAOTanPfILKp95id1XnpHgFgohBkqS1WIojM1v5Maih/l564fYee1FjOl6iuDOfHKqamPDgRxrzZRxvOPz7+OMbXt5ffoE3rf8DVrtAu7fdib5PW8mYA5EMiio28voTa/wpeV3onp6mXzJ/bTXjyW3spb8yjoAijxdRxLWAL6uGjz+JjqLZ0vCWgghUtCIHBJkcXY1ALtts+RQk86l0c5hhrthCFslhBiIgs07mHzX32l7xyxc1wWG9YGLE7KaAKjuKSHsycUd6jT6nksHKGl/jJCnlLaCMwEo9XSyKHcfT8rV1SLFHE5aj1/7APnzth9JVgshhBCH3b7wWUK2iwefmoQVCdNw4zKKz9jQZ7L6sDVTxvGrq5bTNjuLywrW8avuD5G1ZfMwtloko4/yI6a6d/KZ4E9RUyNUzl1JTlk9rT3ZABR7u44pr4Dclo0EsyoI+koS0GIhhBBDaUQmrBdl76NLZ9Cg84y/szVcyXRXvYxjnWRKvGaJRJGcxt73CKUvvYH2DO/NHBOyGukI+WgJZRPxRK+wNpUV2ENOzzo68pcQ8FZySdFmLKVlOBCRkhQw+Q//YPHHvyLJaiGEEMcYldvCldNW8eDmM+hothj/2iOEMnPYcuUHaBk3E9vqf+zgOyrfJEAGfzh0Dp7e7mFqtUhG2d5ePrD0KVbWTuGJjgvZfe5VRDzRMc9be3IAKPKeGEM5rVvBjtBZJPvpQgiRauKaRQoYPI8s59VMxzKnv2Mf9eQz3tfSb7m777/4yL+rJvZwzlk76XihiB1to44pF5oYdpymq8c5d9850XYsAzD2P87lDi4yO1cw7ZeNjmU6ZzmfUW443exhFJEs52U1WLMLG3nzpt8cNbEQqqsGvAVoXxEoxWm/+rBjPf4vV5zwXsTjIZSViSsQwB0IorSmcJbzg106xzu3WwX7H0f9MO11PlkSyY4Y1ZW7zeNYpntur2OZjF0+o+lZ8zocy/TW5BrVVfelZcf8vzjwKmryie/z7fuN6jtaJOCia29+v2XKpjYztfgA++1CSie1UuPJIS/nIGWTmo+UaV/Z/90b5a5X6F04kebCK7gs59vs7ixjz74xuPsYTMT2Of/ePW1mv/dQgXNddr7zbzRvvdlDjR5hkfP0DGPW0+K8ObEznH8jvoNDfB7V0v3+Dl2dZpvFrvHO6yqn2mxeOic716UMNj9Z+82mt/NXSxzLWEGjqnB1OW9b7DznmG1ZYtbPWp3O09t7XYZRXQC8YF5UiHhQlsad1f8Y8Z7dzn34zveYxbnldy5T9bxz31x7vtk+8B1XPd/Hu5qjB+O6e4vZkEMmW5+MJud+zz8lYDS9YIFzmXCe8/4ZgL/c8CFwD5gVG6iisW2OZVpq+9+fAvj82+8DC9ZNLuf0SeuAdcyJbOL5wIfYv/gSGk9fygz38+g1B3GHjr36tcLXxg3Fb/C77vcR2bWX3nPNLh6wm5yPFa0e5+Xr8pttVzwGzbINj5itgHM8do91/i1p/xBf6BGxsDtP3s8UT+n/GPyw5r2FjmUqJzc5ljn73N1c4tpEkbuLv3rGcEPw+9zb9TU633kGV2b/lFIVbc/Ml+vY958Tj3uDH9xE84xpTPn1fex6v9mQotoTn4vcwtmG9VjO5TKazfoNbVAsWGW4IzdIhVk93DD/5GPSP5zrfAIh4HBMNxC5E9uMynVvdY7ZjKkGx8W7zS6sVCHnfqhjd4FRXVbAua4pZ9Y5lllZYbbcZ8zYb1Run1GpY9lBl2Nuwdvi3J/2TjCL8wy38x6FbfBTznrcbL0HLzDY+co16zv0Qed8TufBHMcy/332Eye85yOIC003b+1T/uC1S52n5zbrqzztp35cPyLGsG4bNYWu8nGUb32NSquesfnNPG9PG1Adqw5OAmDGbJvX9i+kqHq1w+Mak4/tdrHz6os4cPp8irfuour1NRTt2JPoZg2e5QZPDirQAjqMzjTbwThe4/SpbH3b5YSys4+85woEsCIhrFAAVziIKxTECgXI6GqnYstrWBGzJJw4dYn4HY71tLKht4oQOWjlJkO3D+j7rkiQ0r1PE5xxLktKdvPbneeRmDkRQgghkpOLCGepXSxS1byiJ/O6nohsS5NHZUYbZ7p38XJ4Mm36rX3sYtd+rs/8MgciM9kcuoi1oatglia7dSf5jWvJ6K5HAe+avBILm9/uuwhXpDph8yFGvnx6OMe1g7WRMdTqIsZ4tnJ+5t08638vd3f8kKuyfgYZj5OX13cSqOrlN2lYPJeD804DnC/2EiJd+AjysZzneap3JhvCYxLdHDGCFNPF1azHQ4QVTGUHJ14UOhIkPGHdVjWFmtMvB2XRVjWFcxq/BUAtJ579GrWulTErW9i/uIgD8976POLysL78cvaE/8rplXv4buY5RNw+Sne9kjK7xZ2jytlw+810dowi80/NHDxnFgf+ayG+ljZKdm+jdPsWslrNzoaPGKt70a+6YWEu6rQO0DYeK0zI8DKGcIaXHZddTP2CueQeqGfSMy8Q8XoIZ2QQ9mXQXZGF7ckg4vEScXsJZebQPnoK/sJSJrz8MJYtSetU5FVhKlztPBaeTVDlc8bm17hh9V/ZMjuTjTNGn/R7/ppK/NWjyRxfS+bYerI6argu+AvcKsLDbecP4xwIIYQQyW0UrVxpbaBUdXFI53KBtY3xuplH7LmJbpow9MHRK1BongyeeKWkUlDl3kKVewsddilP7r2FzuJZdBdNJ6O7gWntT/OO0S9yb8+NdOw/MDLHoBQjxsXuLSjgyfBbsXbN9r9xx5t/5Q8z/4u/zvwWd2b/iNyivu+WKNmyE19zK7VnnU5+4LFharUQI987st5giXcvU9wH+XT7zfToAdyFKFJWJW1cyUaCuGgih4vZShVtvMSURDftBAlNWHcXVVKz+DKyWhqoWvccB+YuZ/r0LiLaopnsY8qOWtfKze9biStoE/Fa3Pv7xQD4c8vYv/BalNfDPn8l52U8TcH+dTRPPB1XqJfifasTMWtx1ThrGms/dBvW2iDqS2H8kQKshyNMvvAp2q8aS+3C06ldfAa59XXMePQhPL3OQ0Uk3Co/6sY6CGnwKOy/5WPNbOcnZ/2Jj774PsevhzJ9vPnB2+ktyGf8Cy8zYcVLWJFjb7FrnpV1wveax89k/+KLqVlyKeNfkx2aVFTlbsNSUBcq4LStjfzpCxfgDfUS9rj46P/e2mfS2l9TSe3d16MjLpQrwuj3PIB3Sj03+e5lT3g8z5V+gDENf06ZE2BCCCHEyQSyc9h87Q0U7KtmwssvoPTAbp1fqKq5RG2mAx/3RBazh1IWqBouVFu4w3qJhz2z2R8qGqLWi3godHdza+WbbItU0KKz+y2bZzVSXPcihfWvUVRRwNsnvMEHJ9yNW0X4VfWlWHZzv98X6W2su5mFVjUr7Qm0xo7/x65v5gMfeBFXKMJ1npf44M++S3tpAaGzxlG/Zi4VqzYc0y8pralcuZ69F59D9qacE4anESIdTXQd4lLfZjaEqpjjqeN63xr+4l+a6GaJBCunnbexnk58/Ju5dOPldKpZxD7K6eDH6mIC2mz4s+GQ4BPeCqU1waw8mibNJZBdwKbwLBSa29TrlPDWoGJjVrbgCtpYNlghmzErWw5XwdVZj7KxZDbn5b7GhpYJqNiVs9pKjfP5ttuN7XLhWhlGRyzAha1d6I0WRdt34/FHb4+KeDNImlstX/VDSKMiRJPWr4fRgNdlNoa2VgrtcqE0WOEIGB5MRbw+UAqtkmQ5iQFriWTRZWfwttz1nLl+Fd5QELetcYciLNhQ0+d3/NWj0REXaAsdceGvHs2CMW2cU7qN3/vvwBXqJml+W0IIIcQpqJ83n57iEg4sWMTWK99GxD2wA5dsgigFr+tJ7KEMUKzRY6mhmEyCeCy5w22ks1Hs8xdzmrueL2U+zkxXHZzkwfYKzTkl27hr/p2snPtuPpn7a55umseZW//CgZqBDckm0k9Yu+gmg0VWNZe4NuEiwqRVjbhCEVw2uMIR/mfLtxnlqueNzoWs/+BtvPTN/6b2zEXYruix/qG5M6lZvpSM9k7QZuPtC5HqbCx6tZs5nui41v4RlIQUiTORJhSaB5hPFz40Fm8wkReZQgndTMocWcMqJfQK6+yWA0x64T72nXElreNnk91Uy/Mr8/lgxgf58dV/5J3qNZ7X01nHGPYvLiLitdAhG9tjsX9xEXMa9vHZhb9gUckedvSM523tD/Aw18I4RdG+NRTvXZnI2TtG69ix5DY04A4O/AEI5es2M//Ov7J+2a3wsIKgjXLD3v8+G3tBBvn7axj13H8orN6TPCm1ZZngUWg0eMCa3412Z/PxF99r9HVvj58lv/wd26+8hD0XnMuhmdMp37QZKxwhlJVJKDOT7spcwl4f4YxMIl4fYW8m2u0mf/8Oxr3x5BDPoEiUdjuLHzZfyNdKH2PX0lJC97jRIQh5vDy84A4aXIWonHYyuhtRsZ3azPG1KFcEHQHltuk9r4qvz/4nu0Pj+cuGmYxqfiB5fltCCCHEINkuFw0zZ1O0ayeFNdXsXn4BG6+/icKWh3BFDB4iBLykJ1OlW7lQbeGgzmM/RSxS1UxSjTxtz2BPoP8HH4vEaw9ncdnqT/GV0x/lKu96PpX5LDsi5fwrMI9ddjkAmQQ507OLcz3bKT+9k8ZALr/cdSH31CzlYCAf2J/oK6NEEjgQKeAHwUu40r2eC9zbmGXV8dLiKUQ8LghHwKMYs6SNZ8Iz2PrRZubN/zN7rjifTe+9mV1XXYQ7EKSrsoz8fbXM/8WfqHl7/3cECJEuqiMl/L+Oa1jo2Ue39vJkwPlBmOJYWllH8gWpIpsA3Xjp5dgH77YRHZ0g0zW0D2wdqISPYZ3VdpBpT92N7fbgCvaigDeZyt16GZerjVxsbWGcbubJebO49/eLGbOyhdbF2Syav4/b1Bs0+XP4xus3cP/OJfR6mygvfwFvTyvZTdUjJsHUXlXFxhtvJqOjgylP/YeifdUDrqN8/RaWtN7Jqm/cTmh3NnpOhIqeLYz/1ktY+SMrqIwsykTfNwr1YhNqQQB9ei46q5zeyMmfWH08T28vs+7/NyXbd7J3+dnsvig6zrCK2Lj9fiy7F3egF293B+7Wg7gCvWR0tVG8d9OAb28VyeWx7tmcnbWLa85ex7e+fzk5a3N4dv4lvHDaZQSsYpgPKhLC11lPZvsBMgvqqHj/47Q2LaL37Ao+svgeZrq38r43PoC3uTrRsyOEEEIMi6bJUwhnZVG5cR2FNfvwdnex/bIr6S28lfLqB/AEna+Y1Vg8ZC/gPdYrXG+t5gl7FheqrezQ5bypJwzDXIh4iODitfAk3gyP5yz3Tq70buRzWf9hT6SEHu1liusQGSrMrkgp/7v2ap5smENIJ/zQUiQhP17+GV7M+sgYrves4bpFa9h4VxWlq7oYtaSdZ2bP4KnITJSGijUbKV+zkabZ09l9xQV0jSqnYuV6Zt99H65QGJCEtRCHVUdKqI6UJLoZI5KbCGFcJ/3cn1tB7ezryW3cQdmu57B0atwdlkOAbk4cyzwcO8WcaY2s3OKI2Kuw7AhW8NgA6CGD+/VCFutqzlE7eI96hafnzSR7fpCz2EUEi1+tv5g/bF5OT9gHgCfQTVHN2kTMQr+aJ01GRSJYoRCbbriR8k0byW17CVek7wdHnEx+TR1nPvgTgnm5eDZ2k9kaPWjozE/STmiBB6aE0BkFaF9J9Akug1CxcQvlm7bgLyjA4/fjDgRQuu8xrEW6UPxv86XM9dVy27lv8J4p7yHEDuYEf0iQXA7tnY0/rwp/3ihaxp4OyoLZgNbMaH6Gr+b8D8/Un8YLB6cnekaEEEKIYdMwZx6+tlYKavYBULxnN7MeuI9N119H/aS3U179IBn+g4719OLhPnsRt1uvcINrDR3axyP2HGR4reQTwcUL4em8Fp7MeZ5tLPdsp9zq4M3weFaEprHfLubZenmYpjh1O3QFPwpexKXuTZy5aDcsgmfC0WT10X2HAko3bqNk47boEJGRiPQsYshoLK4v2Ehb2OKl7ilyYi4FfKRkBR8vXUFTOJsDoXzqQgUcsMqo7S7iQE8hNYFRvDblFpQdoaNiFsHMQkZtfQQwu9NsJMsmQBM5J7wfiiXvs6zQcDepXyP816ZYyQT260KuVuu5wVqD1rCB0byiJ/OL9ZcmuoFGmidNpqCmhtP+/RD7li5j/+LTaQ5NoHzHM+S07B1QXb72Tnztnc4Fk4HLg84bC9apj6ekNGS1tp16m0TKaLez+FbT5fy4/J98peRx/qfpSiJYeOkkt2knuU07AbBdHvy5lQRyyshureaHs3+IS0X41uZrEjsDQgghxBDwWUF67RPvaOsuLqFj1GjGv7TimORPXkM9lbvv4eCE62iYeDOlNY+Q1em8/9pCDv+0F1Kl2tini0+4/VQklyBu/hOaxVOh07DQRGTADzEEAnj4d3g+b0Qm0K0z6MTHyU50KUBFUuOqR5E4GrBdPkIZ+YR9+XRm+AhahQStIkJWIWPcjXyz7GsAtEd8/KdzJve3LGVN63i09INJZ0rGQT5U8iKvd4+nJlhElaeN6RkHOX/yDjKOeZ7aN2kLZlMfLKG2YDIHq0oJTOygrdlDc08uzd25NHXn0dSdR1fg5P3UyKLJJsi+Pq+wjiasfak8JEiw0Mbb2v+PNlAMGQN8WHQDBdytl1Gg/dgomsgF4D23PcXdf714sM09RiTLxtXTf9uVDXqAfVJPYSH+oiKq1qzGikSY8PJLlOzcyfZLL6Vu9jXkNWyhbPcKXOGBXW19tNxNTXTO6v8q64o3IzScfvJbHhJmEMnquuVZVK3oicvkc6uhc3z/ZZSt0FZ8hhBxdbuIZMdnxyp7vY/uub39lglM7iVjl++Y9947bQWzi2v4zKu3DWgj6xvbSW9N7qDamiiv+Cfzh7Zl3F7wKksy9/Js93Se6p7JSxQfmXcrEiK7rYbsthqWlW3nsjHr+emmS6lvLaaPvnxQQgU2nrbh26HpmBskb318EgPxjFkTveU2voOJ2/mL5IZxdcZn09g13ianevjmpWeMTdb++EzP9mqs4DDueCkNOhl29IQYGTJr3PjHmj2o+jALm2/PvJ+bR79Jnb+AjR1j2NgxmgP7R7O9bjS75sxDhcOUb9l0wncnPNmCdfE9+MdfwJjJo1nQsZIZeg21/kIerF/EyQ7U9lHCPn3sPup7Zr7O3VvOGFDbT0Xmzgz8Uwa/n300uyCE1ZY+D656as0sLl5wbDxoFIO5njVcnYN7fFe8muYokqlx+eOzXbHCYA/jZV6qxYsuSlzSoLmmkOKxrXGpq35XCZWTm/ot89LBSZxdvvuY9xp0waCmN/XX9ez4cOWgvjsolgY7PnEWyrfxtMdnP85b5yVYlbgYunryJh7e1f+Yye6qHsJ18bkjunNPAbkT2wb0HY2iddQS2ssXYLuPPV522V147Raywvu43HsPAB9u/xXnu+7nyryXuGnpGvb3FPHwgQX8q24Be7rLB912y29hZ8ZnnOS1r0xh/pk7+y2zePZuVm6cFJfpJZpvr5feCeZxbmHzzcqH6Yz4+HTdjbRF3hpCSG/KoTiji8xpEyku9zKn+UkmsoMSXwfF2dVMydlJxeyD+NSJ+xO7m8r50YpreH3fNPPGaxU9/hkmP3jpMr509iN4ifQ5JEgolhvJMhgSxM6NYHUOT24xrpvebIMD8855AXoNhq/73eYzHcuEurwwxfmSdVccF6Yy6EuydrUc+ffBi04DoOq51UeG8Mja1UL+vnqqzz6TfWctpTd7DNMee5LSHbtOqGvvrc6dn22w32yFwd1/bhMAV/3Q7Y1tbC1l8n0f7L9QiVlnvecGn3MhnOtacvp2xzKvrzTreDwdzvEfzrVxdTvHY9GlBxzL1G6uQLX0n5T8xmX/hCVv/T9P+7nK3oiFpmBcB7ut6IOPvvbEjY7T08VBKHbuwLLXxinLO0iNu4qP+f83uY7XSqbxtoo1XFm6kRvz1tB6w4Osi4xhrT2WA7oAULiI8BnPUzTpHOqnZJORYbaj3rU336hcqMA5Hk1OiGXtdE5E95ZqusY5bwBtt3MZb5nfaEMRNohrU73lQ/hwC1v1+xuMZNlEcpwT9EVrnZdK+zSbrvHO81K40XnFt852rqfiZTDp93rGOB9YZdabHTD1jHKenpXhvDztFrN+Q4Wd2+5tk8S3GLl0yCJyKLPfMnapWR9o+Z1/p69e/8PYhDV5ve1khf343ZkU5fZyYdYWLi3fCFOiRXaH72ZD+zT2Xuxme3MV2Z5exhU0Mi6/iVGjDjHB10SpN5ZwPCoHvax8J1/afR0B7eF3b57j2KZxDypGGcxfjcE1KeP+3XLM/7VS1J6xgJKtO8ls6wBg+39nGaVXp/zK+QTArlvNkivuIbxr2ApB5oH+132rKnSsx9PtHD+uqZ28WOOc2HCN63YsE2jLINzqvP+e0eS8fXXN6HAso9flOZYB6Kly3heyKs0ulLEDzm33Zjofu4bqs6B1CO9IUBrtPnk/4+py07qj+KSfH2YZJlsObnN+0Or9BmX0J52nFW2Sc7s8o51jNrLL+UKdslW20fQOnu7cC2XVm+2/dI8z3Ea0D91xfWtHNg89vcS5YD+01yx+TK5nyN9hwc4ix3JjdkSPZXvzctl69VW0V42heMcOCmpqyWxrxdfWRm9ZD1bkre3B+cufpy0ni3t2nc+doz7Iac/cw5ev+CkLfDV8eNIzfHTyM9Tahay2x7I+MoYu3urn2kLO24xnXp3jPINAONtgnzusWL1qsnM5g+ltWz/WoNQgKbAz+l//waL4xflHl7wAwBxqmUsdTzGTd0xddUyZX2y4it35yziYfxFFO1ayfu8c4K11E/Zm07L0QrQqZJn7Hua5nqLI1UOx1cXFhVv45Q2/4Y3AeP7QfRbVIef+c+f6MUbzZyJzv/My2PyRX0MkAJ2wNKubpd7aYwvYEeiAvDabzL39JxgDhjm7QMXALqzoywgfEiT5HZozg7yauiPJ6sOsSISJK16kdNt2tl59BRtvuZHyjZuZ+uTTePzJPzaOGJkW2fsIY9FJBvP1fmp0ISGV+t3AM02n8UzTaWS7ermodDMfmLGCc1w7OM+9nYN2LuvssWQQoszq5K7Q2f0+gEEIIYRIKkclq3s2ZRJZ7Sa41EtooRelbb5yz7VMmBpmyrg2zsh4gWuXNvLa2jNYsXI5p5dtZ9KYbewJl/BM6wyqe0vY4y9jXebVbMq4jC95Psv/K/0VE32NfGD7u2gMmSUJh8rui89l9+UXkHPgIEt+/BvcwcGPxWhbFq0TxlG4txrLlod1CyFEKjg0bRo7LrsUbSmmP/wIFZu3HPN5sPjYk0ULKveytn4CY1Y/RSC7kK0LrueZ0JustceRQy/zXTXMt2p4m3s9b3Ovp8YuZKtdyVa7kjYySY6hIlJfLr2cwR72UcQOyk743J9XycEp55PVUk3J3lei7+2vpKd6NFnja8kcU88y189Yb7+dx0MfYX34dOZaf8OtQjzin8tVmeu5OXMVvyj8O/d3L+QfPYvo1SNsKDQ7lkC2YvmfVX541Q/LMmFh9OKhzFQeEkQcK5iTTevEcUx6/LmTlsltOMiiu+5m31nLqD57GZ0V5Sz6/Z9wB0dWoIjEmupp4NKszfyu42z8g+z4qnQrVbSzSo3loMrlcnszs/UB1qghPHs6wnRHfPyrYSGuKRGyCDDHqmW+q4ZL3JsB2BipYps9jLcRCiGEEENJa/ICbyWrM9/phxDggZZ7iwkt9PJG3VT+OvU2qNZMWfE3XM35bLz3NiJhF5bLZsJ1DxC+tObYalt34S1cy1cLfsnWA5P5XfkXeHj2z7lj23vY3FOVkFltnDGF3ZeeR+GualonjmXzLdcw58//HFRdtqXYeOt1HJo1g4p1m5h130PDeeeuEEKIOLMtF9svu5T6eXPJPXCAmf9+hMy2tn6/U5zZwbiCRu7fcgZWJMz41x9m1/JbebDrC7wz94tgwUuRqbwUmUqZ6mCWVccMq56LXFu4xL2FVncWGyNVvB6ayC578MOGiFOlOZftKDQrmMrxJxHaI0XUzbwST6CTUVsfR6Hx769k/5+uR0dcKFeEMe9+AJfazXzrz+TqA2y1r6YrUsYS1534VAcP+RfwQmAa78p6jVtzVnJR5hZ+03kOLwamJmaW+2LH7npVLljlR91YByENHoW+bxR6CmS6R1YeUkaJH0K9BXlgWQQK8096o5AGgtnZFFZXU75pCz2lJbRMNBgzRaSVO/Je5oactSzIqHEufBJjdXSIi1aVhR8vvbgZq1scvpW6esjgdXsSvw6dxzcDV/LP0ELuDy9MdLOEEEKIuLG0TVbIT9hyE1nlghCoCBAC72vRgxLbk0FvXjGucBCtLBr2TCUSdoN2YUdcdNeOPqFeBeS1r8EV7uR+66M83jKPyowO7hj10vDO4FH2n7kYLIvJTzxLTsMhGubPIpTV//ArJ9NdVsahWTMAaJg3i55i51vNhRBCjFx1886nfu4cxr76GvP/8jfHZDVAZW70+Lk3HL1gzOvvZMyqJ2mzK9kROnZIlEM6j+ciM/hl6Hy+FbyS+0KLAM05np18yPdCvGdHDEAGYcbRQivZ9PTxAOj1gbOIZOSQX7/xyLPleqpHoyMu0BY64qKnOrovpBRMVCsoUTtoZyy1evGRelrsbH7SdSGfarmJFjubLxc8wRxP7QnTS5zYUB7Kil5ZHdKxfUINr43MUR7kCushlFtbz4T/vMDeS84lmJPNqNfX4C8uxF9SRHdVGf7CAnoL8rHdb62Ggup9lOzof6B8kX6+1XoFAF324MeHXqtGU6o7ucjeBkQH1n/BGkFn/BKonSzesFPj4RNCCCHEYbbloiMjl7xAJ96FQfDERlv1QHBp9KDNFQpQte45WhcsZfzyAi7KfZBfrVpIKOzB7Q5z4/J/oUrqOBTMoz5UTLV7HoeyFuDPnMAi95vcnXMrp2Xu41+N8/hm9ZUJm9fpDz1B5+hKVn78fQDM/Me/8fb4gYE/1Cun4SATnnuJ+gVzqHpzDdlN6XuCXwghkl1b1VRaJsxi7CuvMvFF8xOrmw6NZcPBsXx48X94Yud8OoNZuMLRk71Z6uRj6buJMMe1n0LLz55ICX8JLD3leRCDF8DDc0znfLZxOZt4nFlEjhoC9IzMJ3m05nqaxi/D19VIdus+ssbXolwRdASUK0LW+GjiuVOXszryXjoYzQS1ggnqxROmtzVUyWdabuR3JX/hI7kr+GjLrcdML2FcsVxSpDc6DIhHoYleYc3pCgW8cdB5DPThJAnrIaSAqf96EoC9l5zLobkzAXD3+PG1t5N9qJGSHTvJbG3D19pGZmsbmW1tKC33HIpjddiDu0LoaL3Ky1PWDC6yt5JFkOes6TQq54eJCCGEECJ59XhzAMib3Ungz16Cq70El2UQme/CF/LzuTMfYm75j5lecgB3eQSmwZmjt/PG2qVcfuZTLF904sF9p53DwXAhEzy1HArm8r5t7+bZ1pnDPWvHyGpuZfHP/0DjzKl4evyMWr1h0HUpYPLTK5j89Iq4tU8IIcTwC2blsn/BBWQ11zP+5VcG+G3F91+5hr9c9zNeft9X2N5UyabeGbyadYBKzxt0E6abjKNKa8507eIS1yYA/hFYzPOhaWgZ2CDhthId9rOvpLVXBana9DD7595I3WlXMWbDA2SOqWfMux84Moa1b0w91faZbLavx0WA0607qbA2nXR6Qdzc2XkOXy94lKsyN/Av//xhmc9+uTLQgAr3oheVoP9ZdWQMazWzAx20WN04MdGtPIYkrIfY4aT1uOdfJZCfQ1ZTC56eXoKViX0ojUhPvcrLI1bsabdKHgAhhBBCpIOjk9YZs4NElB9Xd3Qsw+umv86mxrH8cd15POe5nP+UvRvLtY+ccTX8Tl+PriulwtvEGHYzPryaMZGtjLJqqfB28FxwPD+vvYDOyKmfWI+HrOZWxr30RqKbIYQQYgTQSrFv8WWgFGNXPoFl2wOuY8PB8Vxzz+e5atpKphYfYFnFBq7PeOsZZR3axwGdT71dwCTrEGOtVrZGKngovIDqUEk8Z0ecoqOT1lewkSeYRSiWEnVFgoze+BA1826idtY1jF13H5lj6skcU0/E7ePA1CvpsqdQqrYy3/oLvn6usD/stcBEVgXG8a6c11kRmEqbnT2k8+dIWeDyQTg2/MeizOhLa+ioB08WIXtkpYhHVmtSlAJ87R342p2DWoghJ4lqIYQQIu30eHPQWHgjARTQ7com6PJwyU++QNiOXmWkAWvOfponzad50nxcAT/5NTtp823B37ufnfiA+bGXEEIIMXIdnHY6PSVVjH3zCTK62wddz962cn72RnTIq5pFl1E43uYL+R+i0mqnUrUzSrUx2bWDXrz8LbSE9fZojn+wnxgZDietz2M7N7Gax5hFG9FEsjvUw5gND1Iz/2Zq51zH2LX3EsrMo376pYQ9Wcy0HmSSeh5l/BRmxa86z+U3xX/lfTmv8MOOi4dorgbA7YNAO2g7msAGiARQOoLtSXBCvQ+SsBZCCCGEECIN+L1Z+I8b0/lwshqih9ejNjxHye7VBLMLyGncj9I27XNDw9xSIYQQYvC6i0dxcOYZFO7bSuH+bXGrN5BTgFYN7NLl7IqUH3nfhY0GbBn+Y8TbSiXt+LiUzdzEap5mxpHPPIEORm94kJp5N7HnjOgzMTw9LYzb9A8mL3nthLoWe/eSpYK8GJiK7uMkRV2kkAd6FnBL9ir+3TOPXeGyoZsxA9qViUUbOhIAd/TuOBXqij7fxJ3iCevu8c63WFhtHqO67MYTn955Ql2ekTnW8/YPO9/64W0168iChc7L1M6NOJaZ+Hez21+qrzJbP4NhBSC7uv/5NomheNr0zxmOZbz5ZnV95KbHHMv8eMWlRnV1/GuUY5mM852v2P/aEzcaTc8udD4QtZqdf5MAzfMNf5d3mxUbKGUQQg+8dHpc6ok3k2n2TA46lrE6DLv2nLBjkeAhs9u8TXo0y+9cSruHtl/3dkLV8yefRuNcs2XXtqzXsYwy/M20zo5PsHWPMt1Bdp6ev9KsTSYXGHi3O8dQ9gGjydE6y7ldgZKRuW8gBIAVgsyG/n+r/nKDfb8s530/gGUPfMaxjLewr3fb8YbaCRZE/+dqMesbPZ3OV5Ttv8DsN2ryTJcd7ytwLKMjzts6gJr/dp6e3WVWV+8QXhNke8A/qv8YMembI1kGcbY3x6hN2uCYzPRxU+Ec53aF9xu0q8AsznL3GFwFucfsID5s8HxPV8D5AerhoT4esjSuzJPHsrve7HgwnOe8jN1dzvsmJuscIHe88xWy3dsLjOoK1TqvU2WwT3rgMrO+2FvnvEy7x5ktB6fjaRj6Y2qVYeOe2HXSz02WrymXwfFDxYqmY/4fzMpk++cvJrOplQW/+Cfu3gAA7bOLHOty+0/+mQaC2QWEQrtY3TLGsa69G6scy5iaO6fasUxvxHnbU93svAwAIjuH7llXVgCy9/S/VQgbhJBtdqjFj566os/3f5jRxq/n3c0V+Ztov/Ie/t69JJZ03kulbmKfPhsXQWZkP4R7cZBNdZVHvpvv6uHrVY9ydV70eRnnWDv4yv63sTNQzifmPn/MdFrJJoCLTxQ/x5PMAuCnOMcPANp5G+Ve1OZY5iN1SwDIxc/3sx/goeYyng5Hnz3ylcxH6dFl/Kh+GcF8537P6h2+kzJy+kcIIYQQQgghhBBCJDUNbLrtegJ5ucy9+94jyep4CGdkEvH6yKIxbnWKxKkPFHDTyo9yf90i3p69kv+X/yjZKhovhaqaedZfmG3di1sde8HYebnbeHLaz7isYBM/rr+Az9Vcy6SMRh6Z9ks+U/E0Lo49kRXEzSaqmMIhcunnjMgw6CSTQ3Yuk1zRGC5SXYy22tgQHp3Qdp2MJKyFGCIVtHMTKxlHc6KbIoQQQgghhBBCpLR9559J4+wZTPvXk+TX1PVbtrOpkrrNp9PZVNlvucMCuQUAZNLUf8ERIksFWODdR65KbJJ0JAvaHj63+WZ+1XkuC701/LjwPsa4Wvosm2P18t0xD3LXxL/SHM7h2h0f5heHzuOB1oVcvO1TPNw6l4+Uv8BtvMHY43JA6xiDBuazfxjmqn+7I6VMdB0CNHNc0d/IhogkrIVIG17CXMNaKungKtZTxMlvmRJCCCGEEEIIIcTg+QsL2HH1JRTu3MvYF04cb/honU2VbH3uRvZvOJOtz91olLTurBgHkBRXWM/17Oehsjv538J/8Zviv+LFbEir9KR4zD+HL7VdQ5YV4EeF9zHL89bJDgubC31beXLaz7iucC2/Ongu1+38EFt734qZlkg2n9t/Pe/YdTsauJZ1XMGGI3mgLnzUUshpHMBlMDzjUNptl5KnAky2DjHfXUODncshnZfQNp2MJKyFGAIhXBwi+qNvJYsufAlukRBCCCGEEEIIkZq8XV3k1dTROmkc+89e0m/ZjoNjsCMuwMK2LToO9j+mcOOUOdTPWUr+/l1JcYX1gUgBkdj4x3WRQoLGTxJIX5tDVXyy5Raa7By+UfAwszx1nO7dy8+L7uHTec9wKJzLDTs/yA8bLiKo+x4v/PXuifyNJbzKRMbQwm28wSVsZjF7GUcLNRQR6ePhjMNpTXgsjXYOn818mmmug7wSnpzQ9vRn6J4IIkQa0ygeZi5ubGyi4xYJIYQQQgghhBAi/lyhMIt//gfWv+dmtt50Na2TxjPjn4/g7e45oWxe+X4sVwTb1liWTV5530M1aKBx6jxqF51Hfu1uJrzyGOrmIZ6ROGi0c7ni0MfJU346tQ8SnCRNFs12Dl9svY7/LXyQ7xU+CEBduIDvtF/G76uXYbIcI7hYyQQ2MpqF7GMu+5mOzW5KeIJZRnUMpR4y+Hnv+fxP1sOEtMWK0LSEtqc/kkUTYoiEcRGWM5lCCCGEEEIIIcSQc4VCzPv939l70bnsuvx8mmZMYdJ/nmfsi68fUy63pJ4Z5/+TjoNjyCvfT25J/TGfa6CzYiwH5iyjp6Qymqx++VEsO7HDOQyERtGusxLdjKTTprP4Yut1zPQeoMDy8x//TCK4GGiiuRcPrzCZtYxhLC3soBx7hAxycUjn8ZHut4+Y9pyMJKyFEEIIIYQQQgghRNKzbJtJ/3me8vWb2X7NpWy/9nJqzlrC6HWvULR355G0Y25J/QmJaoDOstEcmLOM7rIqPN0djH3jaYr3bEZpPbwzIhKmTWfxaiA+Q2X0kME2zB7sOZxGerIaJGEthBBCCCGEEEIIIVJITsMhFt75Z5qmT2b7tZez86Krya2vZdzrK8hpPHhC+c7yUdQsOZPOirF4eroYs/JZindvxrIjCWi9EGLkp9T7oULJOw5PsDB+t5JYnc7DTux5e1Kv6iHTPc55PXjb4ze9Ty9/Mm51ZTzn/CTXjDFdcZueXRiKW13JQCfxT8bOi+NToHOG94nSKpzYfr10ffx2SHVxMG51meicmDy3KB6ve1SiWyBEcrF6hnfIMU9X/Ppmb9vw9vNWe/yuz/HlBOJWVzLQniS+mtCVvG3PqU7sTmh4oj9+deU475u4u+I3v9nT2uJWl3Y7x5CrNX79i7sjjsshwTHkGd09rNPb9c6Sfj8v2baLpd/7BRNefIre/EI2XXsbu867jEB2LgBdpRVsvew6Nr/tVnrzihm9egWnPfwHSndu6DNZ3XZP/w9oTBSfy/m4bXxxyzC0ZHhYw3uoxfTKE09yDNYnL34ibnWZeKVuYtzq0sO4fR2xV1hntDjvzPaWmx2c2wY7W5ZB8jur1qzj7xlt1i6TpLVtsKGcfK/zL3XP9RlUX+V8cJNZP3QbN+2CUG7/ZVR5r3M9B31G0zNJsFqtHsekde4eC59Bv/6rf17hWCaUb3bjRSjbuUzBbpvsv+f0W6b+bIOJAe+Z/5pjmT8/d45RXXoIj0NVGLzN/S/BYLHB78+gj7WCZjMSz4M5k2Wn3M7zp7Uyin/V7nEsY2dGIMNgmhHn/iWS5VxP5cuORY7YY170CNsFgbyTx1DTQg0YzG/I+ZesutxGJz60yUkBg+lZfmvYk9ZjTzvxNsrj1Ww2uwUuWORcZupvju2Me/NzaVgwmzEvr8QVisZ88w/Mf5N7jUsKER92hqZnXP+/ectvti/m6nbud62A84bFZNvj6oUMg7p6K4a3Dypd5dymQ4s1qsP5kCdokNi2vWb9SzwTT31yWGnacm6nMpgV00RieAQmtu1Ms1jsnGSwfTWIfYCcfc7lugzyXOHyoc3CqF4L787Mk34eLLQJ5xnsCxmEhworwlkO8WEQrwBde/Mdy3jaLKMER8jktxxRjv2jXWB2YYfL4FyXf4xZXd3jncu4Oy3cnUN4XB9RBLoyTv55WEFO/xeBuLrMTrzaPudYdPVY7H5H/0lrgFErN1C2ZRt1C0+nbv4iWiZMIedgAx1VY3D7exj38guQvw7LE6Z9Zv91tW6sMmq/k9GnNRiV29XsPH8ZHucYamnuP39wRNnQXayWV9TNhbe82W+Zf7++0LEe30EXLuf0EbbXuW/eum6cc0WGfvrUZY5lbJ8NBrGtAs6/484253HKS0vbWX3IeQM0b+kuxzKrd5gtK8t76heCjdiEtTg1tmUl1QMBhoNHhRmX0cyu3vJEN0UIIcQp6s3PY+Wn3kdPWQmH5sxgwZ1/wR0Y5ksthBBCCCFE0nCHgox7/WXKN29g39Kz6aysYuxrL1G5fg3uUIgD5ybvXfxCpJokvuldnEx3STEvf+bjbL7uqkQ3ZcRQ2Px+yp95ZvZPuLW0/7N5AvLw8w7rdYqI35AiQggRL8HsTFZ+6n0EcnOY9PhztE0ax6qPvZeIW87DCyGEEEKI/vk6O5j21GMs+tNvGbPqDdyh9Br+UohkIAnrFHRg/hxCOdk0zJ1NINtgbIk0kG0FOSd/JwBn5+1McGtGvmLVRQN5lKnORDdFCCFO4C8uoqeshNy6BqpeWUVmcysdY0YRzJVtnhBCCCGEEEIkO7kUKQUFc98alyji9cDwPvNgROqyfVyx+WN4VYTdvaWJbs6It1eXslfLchJCjEz5NXWc9tcH2Xzbdbz47c9hBUMs+M1fyGxtpyfRjRNCCCGEEEIIcUokYZ2CgjnHJawFAJt74vNgBCGEEIk3+rXVKNumu6KUks07KNpVnegmCSGEEEIIIYSIA0lYp6BATjZWKITt8WB7vIlujhBCCDEkqt5Ym+gmCCGEEEIIIYSIMxnDOgUFc3LIbGkDIOKRK6yFEEIIIYQQQgghhBDJIakT1r6D8Wu+7dGOZXpG23GbXjztuvmtq6htyyKUnUVmayvw1pAgEx8IJKRt8XD8mlHlvXGr2y50fhpw58T4rXdPe/xitm2Sc12VL8Vtcrzr/BfjV1kSsL3OfcJIpVT82m75XXGry0T9WcM6uROUrFZxq0vnhONWlwk7c2Ruo4Zb8Wfjtw6FEFERX6JbMHhlK+PXJ1jB9OpfwjnJu12x/HE8TswY3n1C98HE3iHrbY3fstNug2Vnx+93FSqIY8y6nNtutcXvhvXM/fGrK5yb2N+uMljvkZxI3KYXyYrf/I56YXh/77WbK+JWVyDkHENFxV1xm16i9ZbHL4aGm9U7vKnYxsb8uNW1cOq+uNXlZEC9oq8pwpQ/dpz082BZlmMd+y4zu+K3t9y50zFOKBlsbFSvhXbYVo5+1gac2xXMc16s4TyzTtV3yDlZNOapt56qGMrLBiCzOZqwti03KmSz+5ZMo+l1TwsalRuMwsIurrn+lX7LrL+s8pj/H1w4m03vfzvjn3ieiQ8/jdKamtsmGk3Pj3OsZdY7dxT+StsoaZ07sc2xTNe2QpTBwY5/lFl8+Ef1//mMefsoMKjnz8+d41jGdmsw2Pn44gWPGEwRPmRU6ljunBDFZzX0W6bjSeeNfvc4s+WrDU5kmVBlZieMivOddyAWlu13LLP60Bij6YVfd36wZvs0G1e3cz9U/rrz9Jqu9TuWmVzeCHOd6wLgPsNyx+vnJ6hvbqLYoIqW9hzHMvpQhllzOpy3GZUvOsdi3QVmJ1+tkHMfZFIPQP2rzs8GyG1yrqd9odm2Z8cHixzLuCr9kDr74iLFuPyK/E39/+a7DR654TK8DiGUb7A/bZiMcz7FD5Fs54PH/zrzKaPp/fofVziWaVzkPH/uLgtPp3O/Fxzt3A9ZbW6jpPVQJjitEPga+2+Dihjsa1aa7QsZJa0NpofhBSd22Hmfw33QeR/fztBmSWuDZKl2ayKZzuu0Y2p81nskO2K2TAdJuyCUc/K2qrAyWnbhQucT8yo7fMLFRye0p8csJWHSJtutCZQYJLEMLirQQedYdPVYWJ3O5XKWNTqWadlagqvLuS6jkwAMcdI6orBa+/kdGlw8o4uC6CLndaVazE7gmCSt665z3pKp5uE/YRS3pLWtcDraqjztIFUVrY5V1VWXxKdNfWjryuaRlxb1W8Y0nRssik+cG134Y9gvm+wnnLt0k1FdL7w2y7HMzPF1jmW2vzaB1nrnY//GyjzHMlabx2j9eEef+kWzp3Qar37BbLoqy8mtqye3th43vf3lAcQwCObEEtYtx15hnYwOLpzNuk+8D093DztvuorWaZOY8+u/JLpZYoB8OkQvblDSOwghhBDiRC5sIij6PaMohBBCCCHSxiklrNvHjWb/mYvRruiZQFcgQM6hQ+Q0HCTn4EHyDtST3dwcl4YKM8Hc6FV/WbErrJN1DOvDyeq86hoWffdXNJyxgK3vuoFXvvN5KnY8RXar81kkkXg5uperWM9uyniTCYlujhBCxNVrv93IigeaWX59MUs/MDvRzREiKZXTwZWsp40sHmYuIXkmvBBCCCFE2julPcLpDz3B1IefoquyjI6qStqmjKarvJz6uXOwvV5Ktm1n1kP/ilNThQlPVzeVq9eTc7CRytXryW5MzhMGPWUlR5LVHn8vY55/lfzd+1j3idvpzS+XhHWSyIzdQLyHobulSAghEuG1327kgg9OIsgMvE8FeZaNkrQWYhAK6EGjyCKIl7AkrIUQQgghxKnvEVqRCHm19eTV1lO2dxsAWin8hYVoGQJg2OXX1ZP/QHQM4dMeMBtLeCSa8MTzjHvqRazIW+Na5dXUsezL36PuxtEJbJkYiEaVy716MbZK6ue7CiHECVY80EyQGURwE0Sz4oFmln4g0a0SIvlsp4JdlKJR2Mn9PHghhBBCCBEnQ7JXqLQmq6VFhgMRp+ToZPVh7kBQRjdMMpKsFkKkouXXF+MliIsQXkIsv97kcZ1CiL5EcEmyWgghhBBCHCH33AkhhBBCDNDSD8zmWWQMayGEEEIIIYSIN0lYCyGEEEIMwtIPzJZhQIQQQgghhBAizpTW2rywUo3AvqFrjkgi47TWpQP5gsSPOI7EkDhVEkPiVEkMiVMh8SNOlcSQOFUSQ+JUDDh+QGJIHEP6IHGqThpDA0pYCyGEEEIIIYQQQgghhBBDRZ5uIoQQQgghhBBCCCGEEGJEkIS1EEIIIYQQQgghhBBCiBFBEtZCCCGEEEIIIYQQQgghRgRJWAshhBBCCCGEEEIIIYQYESRhLYQQQgghhBBCCCGEEGJEkIS1EEIIIYQQQgghhBBCiBFBEtZCCCGEEEIIIYQQQgghRgRJWAshhBBCCCGEEEIIIYQYESRhLYQQQgghhBBCCCGEEGJEkIS1EEIIIYQQQgghhBBCiBFBEtZCCCGEEEIIIYQQQgghRgRJWAshhBBCCCGEEEIIIYQYESRhLYQQQgghhBBCCCGEEGJEkIS1EEIIIYQQQgghhBBCiBFBEtZCCCGEEEIIIYQQQgghRgRJWAshhBBCCCGEEEIIIYQYESRhLYQQQgghhBBCCCGEEGJEkIS1EEIIIYQQQgghhBBCiBFBEtZCCCGEEEIIIYQQQgghRgRJWAshhBBCCCGEEEIIIYQYESRhLYQQQgghhBBCCCGEEGJEkIT1SSilViil9HHvLVdKaaXU1xPULJFEJIbEqZD4EadKYkicKokhcaokhsSpkPgRp0piSJwqiSFxqiSGBi9pE9ZKqelKqZ8rpTYppdqVUkGl1AGl1GNKqfcppTIS3UYApVSuUurbSqltSqlepVSrUuo/SqkL+vmOSyn1aaXUBqWUXynVopR6XCm1bDjbnupSNYaUUjOUUt9QSv1bKVUT6wi1Uso93G1PZakYPyrq0th8rYuV7VVKbVdK/UQpVZ6IeUhVqRhDsfLXKKXujZVvjW3Hdiql7lFKLRru9qeyVI2hPr5fopSqj23LXh7q9qaTVI0hpdTXj9r/6et16XDPQypK1fg56nsVSqkfx/aD/LHvrVFKfXe42p7qUjWGHPqfw693Dvd8pKJUjaHYdyYope6MfadHKXVQKfWaUuoDSinvcLY/laV4DC1QSv0zFjtBFc0P/UolyXF9UiawlFJfBb5GNOH+GvAnoAsoB5YDdwEfBhJ6YKyUKgReBmYCm4E7gRzgbcAzSqk7tNa/P+47CvgHcAOwHfgFUATcDLyolLpea/3v4ZuL1JTKMQRcAnwViAA7gV7AN2yNTgMpHD8ZwBNAEHgReAZwAecDnwRuUUqdrbXeOXxzkZpSOIaIfbYYWAkcIBpPk4FrgZuVUh/QWt81TLOQslI8ho73m9h3RBylSQz9Caju4/1dQ9DUtJLq8aOUOhN4FMgCHgceAjKJbs9uAb4wLDOQwlI8hr5xkupygf8CwsDTQ9Pi9JHKMaSUWgw8T7TfeRL4N5AHXEV0v+h6pdSlWutjrtwVA5PiMXQl8CDRvO8jwA5gOvAh4Cql1Jla65rhm4tB0Fon1Qv4EqCBGmDJScpcCTx/itNZEV08x7y3PDbtrxvW8dNY+QcA91Hvl8Xa3wOMPu47t8a+8wrgO+r9xUAAOATkJno9JPMrDWJoGrAEyIz9vzpWh3sw8yGv9IkfwAN8GSg8rh6L6EZRA48keh0k+yuVYyj2me8kdc0megKtDfAmej0k8yvVY+i4778r9v0Px/6+nOjlnwqvVI8h4Oux7yxP9LJOxVcaxE8F0ER0H3pqH3V6Er0Okv2V6jHUT10fjNX1YKLXQbK/Uj2GgMdi33n3ce9nE01YauCcRK+HZH6lcgwRvWCxIfad646r63DO8eFErwPH+U50Awa4oscTvVIrCMxyKJvRx3tLgPtjKy4I7Cd6dmrUEAVVTaz8aX189qnYZ1897v0XY++f18d3/hz77L2JXhfJ+kqHGOqjXDWSsJb4GWT8HFV+VKx8Z6LXQzK/0jmGYt9ZG/tOVaLXRbK+0imGgLFET3DcFZtvSVhLDBnFEJKwlvg5tfj5Wez9SxO9vFPxlQ4x1E9dq2PlL0n0ekjmVzrEELA19n5hH9853Eddn+h1kayvVI8hondIa2DlSepbB9jAuESvi/5eyTaG9XuJXgH4gNZ6U38FtdaBo/+vlLqd6FXLlxG9teInwCrgDmCVUmrsELS3IvZ3Tx+fHX7vyHgzSikfsIzo2ZGX+vjOE7G/58ergWkopWNIDLl0jp9Q7G/4lFok0jaGlFJTid4B0gTUn3rT0lZaxFBsiLS7gXait0+L+EmLGIo5Syn1WaXU55VSNyulSuLfvLSTDvFzK9AK/EcpNVMp9fFYDN2glJLhiU5dOsTQCZRSC4EFRC8meiouLUtf6RBDm2N/rzj6TaVUFtF8UA/RISzE4KR6DPVX/vD7ihGeW0y2MazPiv19diBfih0k30l043Cu1rruqM8uILrB+CnR8TXjqQmoBCYAW477bGLs77Sj3ptEdLzYPVrrvpJCh8eNnRrPRqaZVI8hMbTSOX5uj/19Mg7tSmdpE0NKqQuJzq839v2rYh/dobW249zOdJIuMfQpolefXKy17lBKFcW5XeksXWII4JvH/T+glPo+0auQdPyamFZSOn6UUhOAEqLPYfgx0Wd4HK1ZKfUurfXjcW5nOknpGOrHB2J/fyf9zylLhxj6CtGLGe9WSt0U+14e0SEq3MANWusDcW5nOkn1GGqK/Z1wkvqSIpeUbFdYV8b+1g7wex8mevbkk0cHFIDW+lngYaKDjueeehOP8Vjs7zeUUq7DbyqlSoFPx/5beFT5/Njf9pPUd/j9gng1MA2legyJoZWW8RN76MfXgE6iO09i8NIphi4kGjdfJPqAqk7gWi0PDj5VKR9DSqmZwHeAO7XWz8S5PSINYghYT/RE60SiD6waB7yf6BAzXwG+Hec2ppNUj5+y2N8FRBOMH4u9Nwr4HNHjtQeUUjPi3M50kuoxdILYlfm3Er1T8Q9xbl86SvkY0lpvI/ocs1eJXvTx+Vj7K4C/Aq/HuY3pJtVj6BWi+zyLlVJvO7qi2AmQuX18Z8RJtiusB2tp7O+5scTL8cqIXtk8lei4UvHyVeAS4AZgnVLqWaKD5L8NqCM6NqNcZZYcJIbEqUja+ImdRX6E6Ib5Fq317ji2T5hLuhjSWn8B+IJSKjvWrs8CTyil/p/WWpJFwy8pYkgp5QH+QnTYmM/FsR3i1CVFDAForR86ro4a4C6l1BqiB/mfVUr9SGvdhBguyRI/hy/ocgH/o7X+5VGffV8pVUF0mKJPEX2Anhg+yRJDfbkVyCX6sMWGOLZNDEzSxJBSaj7wL+AQcDbRMYcLgNuAbwHXKKUWa61PdrGjGBpJEUNa626l1CeJDq/3oFLqYaIjNkwnepX+OmAeIzyXlGwJ63pgBlA1wO8Vx/7+t0O5uI5JprWujwXx/yMaFB8hemn+vURvE9hJtAM67HBnk0/fDr/fFs92pplUjyExtNIqfmLJ6ueBIqLJ6ofj2b40lVYxFKujm+jDFt8RG9bhm0qpp7TWK+PZ1jSS6jH0RWA+0YdPd8WzLeKIVI+h/upao5R6EziT6EHnI/Fsa5pI9fhpO+rfx5/4OPzefwGnx7OdaSbVY6gvh4cD+W0825bGUjqGlFJu4D6gFFhy1EmOLuC7SqlyoifNPk30IcNi4FI6hmLf+bNSaj/Rq/OXA5cTfZjne4gm1ucd/52RJtmGBHk59negD5k7kgjWWqt+Xi/Esa0AaK0Paq0/prUer7X2aq1Haa0/TvQMCETHRztsNxABJsY6qeNNif3dEe92ppFUjyExtNImfmK3uq4gOo7jjVrrB+LdtjSVNjF0Ek8SfcDHufFuZxpJ9RhaQDRGViil9OEXsDf2+Zmx99ri3c40kuox5KQx9jc7vq1MG6keP7t56wHTbX1U1xr7mxnvdqaRVI+hYyil5gGLiG7H5GGL8ZHqMTQdmAxs1X1fkf987O/CeLczjaR6DB3+zvNa60u11oVa6wyt9Tyt9Z+BOSf7zkiSbAnrPwIh4PrY+IYnpZTKOOq/h8f3OXuoGjYI74r9/fvhN7TWvUTHKMqi77ZeFvv73NA2LaWldAyJIZcW8aOUmk00WV0EXKdlzOF4SosY6sfhqxj6erCwMJPqMfQ08Ps+XvfGPj8Y+/+fh6mNqSjVY+ikYkPOLIj9d8+QtCj1pXT8aK2DwEux/87q4zuH39vbx2fCTErHUB8ODx1zl9bysMU4SfUYOtzmkpN8pzT2NzgkLUoPqR5DJ6WUKiA6Lnoj0f3ukUtrnVQv4EvA4SttFp2kzKXAc0f9fzrRH/MOYGof5b3A2ce9tyK6eI55b3ls2l83bKsF5PTx/juJjhXzCmAd99mtsWm8AviOen8xECB6yX5eotdDMr9SPYb6KFsdm6Y70cs+FV6pHj9Ebw1qAnqASxK9vFPxlcoxRHQHe+5J6loMdBBNVk9P9HpI5lcqx1A/9YyPTfflRC//VHilcgwRHSd22kna98vYtLeaxJ280i9+Yp9dy1vHY9lHvV8AbIp99q5Er4dkfqV6DB1VJpvoFZkhoCLRyz2VXqkcQ0T3p1tj07jjuO8UxLZhGvhIotdDMr9SOYZin+X2UT4L+Hds2h9K9DpweiXbGNZorb8TGy7ja8BKpdSrwCqi4/mUA+cQHTpj1VHf2aaUup3oE3k3K6WeJBpgHqKXz59N9OzC9Dg3Nws4qJR6mujtZTZvjZm3leht9scPcv4P4Dqig6mvVUo9QnScnJuJDt7+fq11R5zbmVZSPYaUUiXAD4566/CZ2d/HbqsG+K6OPnlYDFAqx49SqhB4luiV1c8CS5VSS0+oFX6itW6Lc1vTRirHENFbpNcppTYQPaivjdUxAzg/Vua/pf85NSkeQ2IYpHgMFQNblVKrYp/XE70a7TxgAtGTsrdK3A1eiscPWuuHlFJ/BN4LbFRKPUH0OOxKoncKPQD8Nc7tTCupHkNHuQXIQx62GHepHENa64BS6lNErwL+nVLqFqLPgykEria6TXud6B1nYpBSOYZi3q2U+gzRhHk90f2jq4BK4Kda6zvj3Mb4S3TGfLAvoge/Pyd6QNxB9CxHPfAE8D4go4/vzCb6lMx9RK9Wbol9/zfA+ceVXcGpnwXxEO1EtgPdsdc6omdysvr5npvoAPobAT/Rs2uPA8sSvdxT6ZWqMcRbV6H191qe6OWf7K9UjB/D2NHA+EQv/1R4pWgMeYCvEL29rBboJbod20V0CIcliV7uqfRKxRjqp57D/ZNcYS0x5NQP5QE/I3ow3xCbpy5gPfBdoCzRyz1VXqkYP0d9TwF3EB3fs5vonWergI8iV+dLDBlux4A3YtOSuxYlhgbTD50DPBibnxDRbdlq4AscdTe+vCSGTvKdM4jmEetj89QU+/9liV7mpi8VmxEhhBBCCCGEEEIIIYQQIqGS7aGLQgghhBBCCCGEEEIIIVKUJKyFEEIIIYQQQgghhBBCjAiSsBZCCCGEEEIIIYQQQggxIkjCWgghhBBCCCGEEEIIIcSI4B5IYVdOtnYXFZ3SBGcXNhqV2+YvcCwT6vWcUluO5go4l4lkxG1yeDvNygVzncu4u53LRHxm09Mus3LB/bVNWutSs9JRnvxM7avI779ef/zWqRGXwUNHI2ro23E8k0mqOD4w1WQeTReD2zYqFtx7YMAx5C3I1JkVef2W6e3xOtajws7T0gPqHZOUwbpSAbPzmkbLyyRkDeMHBhdD8diOJb049i++gxHHMr2lw/tjsoLmZXsPDnxb5srN1u7iwpMXsOPXnyrnxYs2vPRAGfy0tFFsmE3PhMn8gWH/YhCzLr9Z402XaW/DIOInO1t7Cvvvg0ynHy+uDOcVEQkY7iCadB2mMWQZVGbwe8toM+vPQtnOddmmu6km+5dAsLpuaGLIMwL3bw23Kyrk3C6TPsG0f/F0O7crmGe2rEymaYWcy5get8HgjslcOdnaXdxPDMXxEGO4mWzrwKyfjec22KTfswyOTwDsOO5WDSZ+AEpKSvT48ePj1xCRtFavXp2w4zGTHB7EMY9n2De6ep3LmO5PmOTnMtqdGxYwXNxWr3Nn5TlokIAEAuOyjMoF9518X2hA3Z27qIiqz35qIF85wZs3/cao3DmbrnEsc2BL+Sm15Wg51c5bm67xpltA55VctcKsrrrznOsqXeVcpnWa2Y5WONesXXs/+dl9RgWP4qvIZ+Gvbuu3TM3myoFWe0rsPOc9A6sjfnsFRskAQLudOx2TgxHTnLar3bkn1Iadqio36KGBPbd+ecAxlFmRx7Lf3tJvme3rxjrW4212/r0Hi80Tp0mr1Hkr79mVaVRVoMx5r94KGPwADNp02N63DzyG4rEdS3a2Qf9Cpln8z/h+m2OZ7R8qdixj2jea9GnZ+8yzfZt+9F8Dj6HiQiq++omTfu7qcu5PjdYB4O40qMtwXbl6nJdLxGfQLpMkoiF3p9m6ChY79y/a67wcCjaYbchC2UbF2PqdgcePp7CI0Z/4r37L2L74bX9Mflu549sdy3Tu6/+Cg8OsoEmy0SyG7FyD7YrBb2TCv8zOYjUscc4S+ivN1o3J/iXAvvd+YXAx9PH+Yyhc4TzPVvvwnkw0jWtfvXO7goXOdXnazfqX8lXO66r2ArO6TKaZfcC5nrYZ5n3AYI7J3MVFVH7+kyf93Aon4GKdOLH8ZuvKZNvp7orTdhOIZDiXyzxo1nZ/ucEFJ4YhVP2JgccPwPjx41m1atVgvipSjFIqYcdjubvNfjOdk5x/ELZBYtgyOKEKULDNuVyPYdorlOPcd4x70nmbv/sWs2WVu815X7nyh68a1bXjK6cblat5/+dOGkMyJIgQQgghhBBCCCGEEEKIEWFkJKxX+eFnLdG/QgghhBBCCCGEEEIIIUa0Nj2Vvfoa2vTUuNabuIR1qBvCvbDKj7qxDvV/zagb644krQusbj6Z/yxeDAb6EkIIIUTCaKXYc9HZhDOiY8jXLZlPd6nzUCBCCJEI7aOraJoyiVBGHB9QI4QQQgiR4rrGjWbPu27AtqLp5DY9lTV8ld3cwhq+St3Y8zm0bFFcppWYhLXWKH8jqrsOXumCkI4+1CCk4VU/hLr4S/ndXJ2zntMy6hPSRCGEEEKYaR83mp1XX8zqj7ybfcuXsvHdN7L34nMS3SwhhOjT6tvfxYZbb6JtvPNzL4QQQgghRNShc85gz3tuZvVPvoG/vIRWZmLjBlzYuNl27vvY9f53oOOQbk5MwlopdPYoQKHmdoJHRZ9+6VGoBX6s7nqaItnccfCdrA3IjqQQQggxkhVU72fO3f+kddI4tt50FSWbtjPz3ocT3SwhhDiBVm89DCni8SawJUIIIYQQyWXiX+5n1rd+SteEsbzxux+g51tYhIEIeC08EztZ8LlvoTj1h4gP7+Ohj+byorOrUPNq4W4Xek0makEPzOpBZxTygdrbCCWweUIIIYQwV7l6AyoSoWXaJKY98DhWOJLoJgkhxAlCWZlH/h3xehLYEiGEEEKI5FPx3Mvkbd3Bpi9/kj0/upXCP2+gLTIdz8Q2Tv/Vl/E1NgOTTnk6ic0IuzPQOZWouQew5nailRudPRrcmZKsFkIIIZJMxbrNVKzbnOhmCCHESQVyco78WxLWQgghhBADl1V/iEWf/Cp73nMT1bddQ2bDIRZ++uuxZHV8JD4r7M5CZ1dC2I/2FYJyJbpFQgghhBBCiBQUPDphLUOCCCGEEEIMihWJMPn391Dx3Ct4m1vwdnTFt/641mZg8n0fPPFNTzY6s2TAyepRMw/GqVXQNd55fJWc6vgtrrrl8aurcZF2LFO43blMOrI6nM/Z2HnhuE1PxXE1qJByLKOdiwxgevGrKxl4mxMzxP9IE5rsH94JNmYM7/RE3/zDG//x7Bu7x536eGmnIpLjPBSKFY5f52zFcV25eg3aZcev7eHc+K0rFXReDm1z0mxDFke549rjVpeKY/yb2HvNsUnpYE72kX8P9ArrzHrZNxgsq3d4l10oP379y+hnh3e7UrA1sXFmu5P3uNHOjN+6Cuc412W03TTkL49f27V0VSINdE4a3r7Z9sSvb8yqj1tVRib9I37Lqv4zy054L2dvTdyT1TDQK6xdGrvg5Mk7X07AsQp/SyYTHn2/YzmTZJyn3YVJijuSZbBytKJrnEMAmh5RG5SzXbD/Qud59DU6b22CRbZj0to9qsexHgAOZJmVG4Sg38O+LZX9lonnIYzJjnGoOASR/qfq6o7vVf8mYWQS/5Fs56RIVpFZsrHHlelcyJDr0NAlHHt7vGxfd+oPYu0td152rh4LFXReD5Pud+6YD56Ra9SuzonDu9EtLOh2LNO6vZhQrnPQWoE4/nqTIGmdVWvQN+eb1ZXZ6FwmnrHhMkhwao+GTue+b/sHShzLRHKcT/r93zn/POG9HN0LQJfyHXnvyw++3bEu22cPbdLaVrg6T777pF3a8UBR2WZJa5P9F9Ndk0imycYnfjvi7g7nOAuMChkl+ItXOicV22bYEHSOWZPfUt6OoTvS11Y0RvtTvNY5Nprnm60r3yHneenSzp2Vp93C5Fpkl8FuR2+F2e/TMuiDPO3O81eywaa3+K3Wd5dF51dFwgRzfUc+81catCuiHPcbweyCiMHSlnPfYLUYJOJdzjFkeuGDaddhsm8eLIxf/22StO4pMeg3xis8BudsIj7nBdE2w7mM76CF7+AQZhx1fE+cjjTDmbS2C81OhLoOOfeg4YIwPeOct4kq7BwbGYfkrnWR+iLZEdrmGBzXG+RzLINH70RyIkQM0iZtMw2mZ3gSN6veua+uudi5f3H1KnwHnKfXM8as/9z9kzMcy8z8Vu2Rf9tuFxvfdyvjnn6Rgj01x5SrOf6LR5Fzb0IIEUcdoyrYfP1VtI8eleimCJG0RtmtXBLZwsWRLRTr+J+tF0Kkr1BWFq5gAI/fj+2RMayFEEIIIYaK7Xax9uO3U790IV1VFQP6buLHsBZCiBSggerlZ7L7ouVol4sDC+cx+s3VTP/344lumhBJZYLdxGK7mhay8BLhnMhOnndNo00N3R1AQoj0EczKxu33o7RNxC0JayGEEEKIoaCBtR97L41zZ3LaH+9l9EtvDuj7coW1EEKcoojbxaZbrmXXpRdQtmkbZ333p1StXEPtGYtoGzsm0c0TIqlU6HYUsN8q4pDKxUuEIu08fI0QQpjI6OokkF9Ab0ERGZ0diW6OEEIIIURKsr0eWqdMwNveQcnGbQP+viSshRDiFASzs1h9x7tomDebyU88y+x7HiCzrZ3JTz0PQPs4SVgLMRBvWuOpVQXMs2uZpJvYocrYo5zHyhZCCBPjXnuJqlWvU755A2PfeDnRzRFCCCGESEmuYIhFP/gNtsfDys9/BH9RwYC+LwlrIYQYpKCviDc/8j46qyqY87d/MuGFV448ONTb3UNWYzNt40YntI1CJJuIcvGqNYmXrUm8YE1hrTUGVOo+HEoIMbyU1ox74xUmrXgayx7ehx0LIYQQQqSTgr01LPr+nQRzczhw5qIBfVfGsBZCiEHw547h4KSrcPvDLPrtn8nfX3dCmfya/TRNm0LFTpB0mxDmtFLUqcJEN0MIIYQQQgghxCko2FvDsq/+gMymlgF9T66w7keJtxO3iiS6GUKIEaajZBb1U67DFeri9F/+vs9kNUBB9X5COdkEswuGt4GnRCe6AUIIIYQQQgghhEgRWU0tA76IL64J696uDMcymUX+uE0vlH9iMtlWLmzlGnhl6tgkzTkl23jxnG9x98Lf4rVC0Td1/K6RtOKYB/e2OK/G8IGs+E0whXianZ8OH8kemSctXN3Ocd7TkjkMLUlNkawTbxPWQPPos2kafzGZnfup2vYPMtvaT1pHwb5aANytyXGl6GLfXp4Z+xOuzll/5L3Cac0JbFFy8548NEY8FRreewI+9+KNcavL6k3suXgVcV52Oo5NjOOuSZwrc5ZxwHkbbKpga3pdg1G8dnjXVSg/fkNn+BqGd101zYnj9FzpdVJXpdfsnlRu9fAuiN5yGaomWVit8duOudvid/N7oGxkHr8KEU8m+ZC4Tq8rftOzfcPbz0d8yblBH1ivGFFYDh1p0KCjNVnNixfvdCxT+6MpwFsrurOsgu2XXo12WYx/ZQUlO7ahgM4xzjuq6z7367f+E+pCdTeA5WJZ8S62Xv4tdFYF0//wEUxu7A/nOgefCitcYcdi5O11DqyWK3oczzyEW30Em52TlwU7h+4gQtng7u6//kiGwQ/J8GDB3WPSKHDX9r+jESw060zsPOcVanWY/eRsgx9J2STnRGLjzmJ6e3Icy+WPd86sdVbnOzcKwCBZM1jKa+MZ3d1vmYlfOPbz3vxc2iaNo3zNpiO/3m2fKHOclqvn2FjVQNOEi+ksPY28g+sp2fc8Ck3Ed/J16utsxe33s++KcZS0bXWcpifDOYbiefLpu9MfPPJvpW2WhvaSpUN8rfQx3lnxOrtdJXyn+gry5vR9BfnRat9wHqs7Ms75hKXd7nUscyrGFzTy26t/c+T/Sms8RAiq6Hp878MfNKqna5xBv+Ax6zty9w3v6FzaY9CHlgTMKmtyPlFtGexMetot/t8/3u5YLmzQH8fzhHDfE9DYWSefiNXjck5aG2aB4pks8rY4983B4vjtPIfznOuyXaD8zvHROtO5rrzdFrl7+t/H6JxoNn9tMxKbLGqeH78VHyg1WA8GB01Wr2WUtA4Z7irES8EO52XVuFhTf7ZBZQb9ntdnsPMOBGuzjcoNhhUGX2P/sR4ocV5XJifOXA777YeFRzkvO9chs+270TYqjnqLnfvG7jE2JneglU9tcq7rP877oCxvg/HOxQZNA3Y/822ZrQOTi3qUwb5Q9mbnfQmA7gnO03N3msWsbXLMaaI0YHYFoMHk7ErTugx2dFq9BAvkxIcYoXQ0H9ZvEbfzj8b2aFRweE+CmyStbYPtmBVSRvtf3WOd2+Q76LwMImbdLLbBcs+qM0vcb/18ldlEP3Lyj5LmcpQ85efDWc9zhmc3qo8e/+CM2Wy67maUtsno7GDnRVew+W030lNYNLAJBTtR3fXg8qJzxmL7SlChLpT/EOl4q3xPQRmdpWMS3QwhBqW7rITXv/gx1n3onWx+5/XY1uC7vM6Kefxi8vdYkzuDSzp/32c/dDylIb+2joB35D94cVyklWwdYp17NLVWPhMjzcwOH8CD2cF5spoaPsj8wH4y7FCimyKEEEIIIYQQQgiSJGGdSYAv5TzO8owdfDrnGb6T+yBz3PsBsC0Xu5dfxO7zLya/rpY59/2V2Q/cw8QVT9NdUsb6m99Fw/QzsV0GV7AFO1E9DeDyoXOqwHKBrxCdUYgKdvCJmU8O8ZyOLD0FZew5+3rq5p2HVvLIOJFcOqsqeONzH8J2uxmz4jVqzz6dtR9+JxHvwG/d68kfy9dPu493Zf6Fce793HfWz/n23Hsp8Jx4tXd7exXVNUtpb4+eUczbX0fIU0pE+U55noZKhg4xMdLEQSuHJlcOW90V7HSVUmF38sPi+8mz4jeU00hT5yrAhc28YK0krYUQQgghhBBCiBEgKRLW1/jWMcHdxPe7LuEX3edRZHXz5dzHmVJRx4F5Czl42hyqVr3OjEcfxBPoRWlNxeYNzP/7HyjZsZXGqafTMOOs/iei7WiyWlno7FFw1DjY2leMdvn42IynmZBzaIjnduTYv/AiIh4v419/FKXT7+pykdw2vudGgnm5LPjFHznt7/9i7LOv0Dh3JtUXOvQFfZg0NYePZN/JXbvPY/kzX+F3u5Zz/ZiVPLr8+5w2ad+Rcu3tVazd8Hb27D2XtRveTnt7Fd7uaFI75CmO27zF2+hIGy40+12xsbaVYp+riINWLrMzDnBH7suJbeAQ6rJ8bPVU4CPM5HBjopsjhBBCCCGEEEKkvaRIWO+MlAOg0ByIFJClgmwPl1PdWI7t8YBtM/aNV05Iqnr9fia8/DxojSvocIWgsiCjCHU4ca2PGk8m0IaK9PL4/nns6yqJ9+yNWGXbVwFQO+98ucJaJJ2JTzyPikTY8o5r2X/WYmrPPp2shkZGvb52wHXZTQ0ArGYpPZEMvrflaq578VMEbA8/+q+7uO78VwFNa/tYbNsFWNi2RZN/MnvOX4432EBGsD6+MxhH9VY+QVzMDDXg1WGK7G7OCO2l3O5kTWAM93UtSnQTh4xHh5kYbiKCotZVkOjmCCGEEEIIIYQQaS8pEtZrQmNpsrO5OXMln835D+12Jj/ouoRQxI0r0AuWRcTb94M8ukvLQSmyWhscp6Mzi7EzyyDcg+qqBTsMva1YvU1oTw6fWfkO7ORYZHFRWLudsSv/Q379brnCWiSdijWbWPDLP9ExbjSb33UDubX1nPF/vyKzpW3AdTVWN+K3M5hS3kNn0VQAtnSM5poX/os3Nk3lozc9xlfuuJeK0l1YVgSIYFk2rW8bR8TroaT1YRQj98EnPZaXtZ7RZBDm3OAuFob2Y2nNOncVn2m+gdpIYaKbOGQmhxrJ1CE2eUbR7orfAy2FEEIIIcTgydGnEEKkN4OBnRPPxuLZwAxuzoxe8fvfHTfQoTMBcPf2AhDO8OEOBk/4bmd5JQCZbc4JawAy8tGWC9XdgNWxFwDtyUFnVRDRZk/DTCWF+7cluglCDFrppu0s++ZP0ZYiu/4Q7uDgxii2tYtt7ZUs9L7Oock/ptW/lOy2Pfhbd/PV39zGLRe+xO3XPMXfv/tlPvLtbrbtmUvojEz2X3YGUx5/itDc5jjPWfx1WJms91RRZPcQwsU+VyFaWUBq312xy1PKAV1Au5WZ6KYIIYQQQqQ923JRP+si/PlljFv5EJ7ezkQ3SQghRAIkzeXCTwdm8tOuC/hW5xXURN4aC9YdCADRhHVfusoq8Ha14g4FzCfmyUHnVKHdWWhvPjqrAmRIDCGSUt7+A+Tvqxt0svqwLe2jmO9dT0n1M7iDnbSVz+fAzJt56TOf4mu+7/LBB75Cbraf+3/weW5919+oe+9CinbtYfTKVXGak6HXbOWw011Gtbs4lqxOfSHllmS1SEtaKSLukfswWCEGQwMNp82nNzc/0U1Ja6O9rXxlzKOUuiXRKAYm4vZSs/AavGOKmZW7m+olNxDy5SS6WUIIIRIgaTISnTqTV0OT2Rgefcz77t7o2NRh30kS1uUV5ldXH1NxZjRpnVUmyWohBFvaq8jz+JnVtYJR2x9k/No7Kdv1GIV7qjk0czq/P/t/mNu5gY2B0/jWLb/nIveTzPj3oyi5n1EM0C3zX+SHV/+e3IyeRDdFpKCIO4PmsYvYc8bt7DrrQzRNWIpO8Tspkp1teekomoNteYZlegvyqvnzrLt4e+XrJNtN+Y3T51BzxnnsvOBqbCv97owcCbKsAHdN+RN3VLzC/TPuZGzGyL/LTIwMYW8W+06/gfFl7azLPY3V5Uv4QvGPqTn9OkIZ2YlunhBCiGE24CFBdD/HNKNecN6pPXCu2UHRhoZKxzJl3RF8bdEDeo0Xd3fkmM8DOTkEc3LJO3SQ3uK+anjL5Hs+5Di9PMNnpmWvdV4OXaPMzhU0z3auqyDX4YGSQGuD2RWEHVOGbpxdbUEkq//6Vcg5PkxHZumtiDiWydntXFnYZ7au7ELnddXf7+dolnPTadlQ6ljGLjG7qrhnq/MYxR7DC5SDY04cmidetK0I+vs/YN/+sTLHepRBmFcsOPYH3+CJnhRbNn8jL/inxd7dR2nm49jaRZOeQr01h4v8j7Mueyk/KfkoX/rClWgUavVE5wkCYfoei3+gfAfNYvb9z9zuWMbqMvvB2fnOQWs1ZTiXMZra4FW3lfLehz940s8zxnQZ1RPY73y1j6fFbBP7ky/9MvoPrRkXbmVspBWAR6Z8k43eSiLKxTv/47yNsgJxTDoarCtTJidtwnlm2x6TvnGoufyK/M0nX7ftCw3u6Oox3P0ymN9RK8zWu7W5iZorL+TAecuI+DIo3LiVjLYOGs4+A1pzmPOj39Hw7vGO9fSMMlsJrl7nX7MVx2So33mTiG24/+DuSWwCf8qXNhz5dzjTx5pvfJa20VOItI9lwTd/hNvfy/bvzzaqa/asfY5lziiKDoGXSZDz1DbmW/sJaYtzinZw26TXeEzP5h81Zg/fvXz0Fscyf3v+LKO6cqqdY6hwXdORfwdys6m99UyyDjXRU1ZK05gFTPv3kwRzzR6Y3lvsvK/sMr1hcwgfiWC7IVDSf5/ptL9tqnCj2VZ57vnbAVBoPup7nqnuQ9zTu5grvRt4ZNYv+JH/Iv7WsNyoroyxzldl99bkGtVlomuG8w6up8HsZFHHS877oL1jDPq96jyj6Q2aAqyTt8PTbrbe3R3O5dwG5979VTYhbz4NE65nSfYGHim4klBE8VjDHP6n4n+Y513PHWf9lLwtT+IOdfdbVyTTbLticixgInOD2TG2v9y5XZlbze566i1zbrztTq6TjSLNKNAOMZq137l/6Rlj9kO2fc7lvE3O++bBKrM8h9XuXJedYfYbzd3pvPPaOdu5XTO+03rCe10VpUQyvOTvqzvy3r4byh3r6i037EDj0A0N+RjWmqEdAfXIGNZ9XGHdWVEBgK9rEFdYCyHEUfaGSghrxVTPoaMS1lGWilCmtlHGNrQF//TP4nO5j3KmdxcvB6ckqMUiqWjNxHAzVZF26l25tFrZTA81MCtYzybvqES3TiQpDfz/9u47vqvqfvz4697PyvzkE7ITwgiETYCwxAUK7qLirlqt1lG12m+rdthWrXb8Wndt62q1FieWOhC17gnIEsJOGIGQvT4Zn/353Pv7I0qlAvcCN/kk5P18PHwIyeGc87mfe885933PPcdbOIS6klK81w9FDUfI+3gZgxa9i7uyCoCMNRvZdO2lLH3gDnJ2vE1Sm8mn86LbfRWsbhtZxKBX/0PVt+aw+s4fU3rn/RaXpDNeqWa2solEIizVivhUH85kZSezlHJylTbWOAvYHDaeTBJPW84+jZjDQelj89k562gqTzyGzI1bAFmWoqfMda5lsmMXzwen8nZkLGXRgdyc9DY/S3qLbRkFLGuWMZH4plBCNvVDz+FbiW/wfPol1AY9XL7qaqqD6azyfsptIxfxSV455yv/wL9+NfaovIEmhBCHw5edybKfXE8swcn4p18i//M18a7SPnXrZLZAmocvLr2SbTPndNsLhV8FrCP7Cljn5aHEYrh8Dd1UujgSxezOPvYCrOgJYexURjIY4ag/YDpFgWXhQnZEM7gk6XPsZqZIiv5N1ymONlIQa2O3LY36slQSHwuzc106qXqIseFaEtXue3NBHHlidjt1Y0tY++3vsnnuufgysxj+7Mscf9UtjHv4KdyVVXijw9geOp2Ut2qY/tPfokRj7Jx8Pi2FE6UP7AW+Hqwe9vN/4/xLO0W3vUzbqOGsvvPHli0PUmhr4VJ1GWeqa2klib9rx/K+PpqsNZ0oj8Nbq8diR+Op/H9yoXsFvXWJkObiodROm8TQdz8muaGJEa+8SVJjM+u/cx5Rh3VvjIj9m2TfyTzXGj6LDOPtyBgA6vQ0fus/nWYtmSenP8FpeWvjXEvR2/gGFFI77AKuTHqShRkXsqUzlwuW34DtvQGMfCST958/jstWXkMeVSwpOJnxEz3E7LL3iBBCHKpwUiKrfnA5ihbDs20nZVdeROXsY+JdrX3qtoB1JCGBDWdfQDg5lfrxE6k8dla3lKNGoyjRKIH0vZc00FQV7+DBJDc2omoSMBLmBFMy2DL7GqpKv9VLb8lEPH0RGsSUhJ3k2775Ss3X6SjM988g19bObNemHqqd6KuGR5vIjXWw055OU1ky4y+tZch9LQy6zMvOdem49SB/HvNMvKsp+gjNZqPs/O+wY+ZJqJEIw999g9L5TzBswSJcbV0zTb3RYazw30JFaB4r/LeglTuY8eNfk9JcSf3IE6gfMSu+H6Kf04E1v7xpT7B6+4oz2Ro5hx3L5+4JWjcWnHXY45SZri38Kf0FsulgsTaep7WjacBNwZpWLrlqGTMf3sJJV21k8erxLAsM5ScZ73BbxpsHVUYuXi6zLSGN7p0Ruen8uSQ2NlP0zkcA2MMRSp5+iZA7ldqS47q1bAED1RauTviE7bFMng7O4Ovv13r1ZH7vP42ytkIemjyf2Tnr41dR0av4PflUlZ7N91yP8njGTXzSPIJLV36flA9TWL7gOt7ZfCnLF1xHzevDOWvpTez2pfNq7sUcW6rI3gtCCHGI1l1xAYGMdEofmc+Uh54kZ9U6Nl8wl50nHB3vqn1DtwWsvYOGEk51M3rRQjLLN9Ewejx6N2xeqACZ5eXUl5RQMWcOmqoSczjYMG8eHfn55JaVGeYhxFfqxsxEtzvoyCumcfj0eFdH9DLPdEwnqtu4Nu0Tw7RfRAqpiqYzxWm8fqgQAA49RtqyAGpYR9FAieikft61YKoij9DEQbCFu86btN07GbB9K6q291pzLbGRaNgBGxp2WmIjcfj8pDR1rWWs2Xpmcz+xf7qigq7ja8nf67vyteSDrluyIbiKjoJOEDuNegpfBRkHr2jGFtZQNVAjGrkr2qiJpAHgOMiFXxXg1djEbm3DdCDsTiV9xy5skeien7urqknwthFJlM3aulO+u5mbE98hqDv5c+AEIvtYcdKPiyuXXQNAaXplD9dQ9HZftQ9ONYpN0UgsyyCMkxh2wjhILMvApUaxf7mRhSo7mgshxKH7chwZTkkm5nISTum946RuC1i35xVgC4Vw11aTXrmdmMuFf4C5TU8O1qjFixm4fDm1paWsvvxyVn33u7QOHUrxW2+Rv2ZNt5QpjjydmYPwZQ0mZ+OHpO3eROOIGXRmDop3tUQv0qyl8ELnFGYnbWGMs8YgtUJFNJth9gZ66yvUonfYas9kty2N/Fg7A6b40ZxK1+ZwDsiY7KdFTeK6jZfFu5qij1BjMUa/8TJZm9dTUzqdNRdfQdPwkXu1QgNsW1CJAjFUogywbaH6hKOpGzWb5Kbt5G1+L17VF3QFeSf+5iHcWyupvWk6iqoBMRRVo+7GaaSV7yBr96uHPb/wg9AobvPOQwEuU5cyU9mCisbOqRnEnCoxG2gOleLpDVyUtopn2qZxd9PpB1VGLR7aSMJL990MKUDG5gqaRg3fa3JMx8A8AhkDSKve1m1l93fpiR389ZzHsCsx7g2cRKu+/+85zelHVXR2+TN6sIaiN0vy1lC4+hX+FrqOy5seY4qnkn9Ne5iEKbtwEsZGBCcRhh+7lldm/ImMhABn1C3go1XyIF8IIQ7VhL+/gHtnNV9cfxnv3387bUWFlDz5AoM/WBLvqn1DtwWsO/ILSK2rQdF1Umu7dp1szy/olrIUXafoww8ZsXgx/qwsgunpjH35ZfJkdrUwSQfqRx2H09/K9xMe4ehdz+LqaGb3pNOJOK3biVz0fc91TKM5lsQNaR9iFIjeGssmXQ2Q62rrkbqJPkpR2OHIZKs9E/eEEMGnbPh+6ER9Ehomp7DJkUtIkxmvwjxHIMDw9//DuIXP4fD7qTj5W6z4zU/oGDwQAI99G1OT7qXY9TJTk+4lMGsA62+8kuSWXQwsex1FP7hZtMJ6Dn+A0tvvJc1Zif6AQuoJVegPKHjsOyi9415UzZp17TdG83lCO451+kCOVbfyXXUJwYkO/vbEHD7/QREdTyaQP7GN3zSdxgMtc9C6d/ubQ5a5sZywO5WOgtw9P6ufOA4lFiOtemsca3bkSnIEeXjeE2SltPGQfw412n+XZ+zQMlkdnsf68Klsi86gNjaaPE8EQALWYi/JLVXkbXuRZwMXc2rzG2Ql+Hjilns497u/5eRRz3DXTdfy8M0PUhabyLTq99i0phF7NBDvagshRJ9lD4WZ/PBTZK3bTMruWqbf81iv3XTxm+9sWSDqcuHPyCKzfDMAro52nB3tdOQVkBLqvs02cjdsIKu8HHQdWzRq/A+E+FJbwSiCadn81X8e1x29kNZgMpd/6GDx2J9RX3wGBRtfQtFlLXQBAd3Jk+3HcGv6OxyfUMEm9v8gbls0C4Bx7t3UNXp6qIair6q1pxFU7IybWAcTocbmZps905JX/0X/lFpfy/iFz9IwejxVpTNY8sCdDHrzfYY/9zIe3zY89m3UT5/Euh9fQ/rmCrLr35Z9P3qRr4LWq++6hbbbh5O2qYLS2+/FHghaWk4YB6/rE6iIZXO6uo4r1M94aewFjC5dRqIS5nltGi93TLK0TKtlbqoAoGnMCNy7a9GBuknjGFCxA3vY2uMlwGGLct+ZTzEiq4Yfv3YlHbO77rt0HcqjM1kRvogoCXv9myuKnwRgydAfsSsvB3ukE1vEh6d+NQmdtT3+GUTv4Qo2krf1eT4dei4z9KW85T6J+T/93Z7fP9h5E7c1/YzsTa9KsFoIISzg9AeY/Od/xLsahrolYN2e2xXA+WpmtQK4a6tpzx9I8g66dYsEWyRiWV4xmws1FpZXjo5wmmqjYcQx3KrexXVFC3l9aymTc7cz/4Q/cPFyN28U/4imwceTVflBvKsqeonXfSWcl7Ka69I+5kftFxDDts90ldFMYrrCePdu3m0c18O1FH1Rqy2Zz9XB6EAE22EHq7/alEj6sf5L0XVyNpYx+InX2HrJPHaddiJ1x06jeP5CXK1trL31OtxbKym9+yFqrir+2r/UOXXQWq4e9x5Lakfwp7WnEdG6ZdgoDsDhDzD5V/eg2W2o0Zjlweqv20IeGyPDOEpv4dLE56iMDebhyJnY7AfeaLg3cHX4cO+qpnHMCIre/ojO/Bz82ZkMee9T9tNFi0OkKhp3n/os0wdV8Ku3vs2nO8YwgTL8mofPwldQHSshT93Asa4ncSp+/LoHv57G+PY1RN0q3rpWEhw6UUcygdRCAqmFFK7/J/Zo927MKXo3R6SdvG0vsGPI2UzV1/BC6FsUOmr5RfBeXmk/mbztCyRYLYTodmkOH8fnbmZ23nqmZ27jwY2n8WLljHhXq9+y9L2+mpldN8Yd+QUosRgpDXV7fpdaW004JZWM1dYtr9BwtXWdlt2/d1AgmJxP1dirqRt+DprSdYPWPsy6G/6UGutmMHk3GL9al17cYll58aZErHvk0TksRsuQiZwz4A3+mH0H7+wYz20fX8x3F99AZziB56fdxkn1/6A9ZyIdGaMOuzzdY90DFS3B+JVtR5N1ywj0txUJajbm7Pd3MVQebTueQkcrJ7s27jddGDu7YgM4prC8O6q4X8Ec617n11L612zLUFWKZXlF0g7tewgrdiKK/aCD1Zpr7z4qZkukpvhSqkdcRtSedEh1EQcvbZXLOFGSdW+B1cwyNzZxdvoY89gzzLj51yTV1LPhxitYffv/kbKrmsm/vh97IMigh9cBMDl7Gy+c+hD3H/9PPC4f3xv7Af886c/kJ7eQVGNd9E+JWtefR1ONrzent3cuZ2HEHgji7PDtFaweees6y8uJ6naeaL+bM72v8uPgdRzV/AmPd/wKTVc5Z5B1b0hecsKnluX1dZkby2kbUkgkMYG6ieNA08gu20jOJ02WlREzcXkfSZqn7t1WKWj87MSFnDxiLfd/dCaLN01FB7ZHj+KVwN3UxUYy3TmfkxPuI1ltwaEESVPryLNtYUbucmr86aRXLSFn+xsUbHmJgs0L0G1OGoae0qsfq0ZyrRu/mxKL75tVhzp+2ZeoieFHQl1X22yLBcjd/hKdbT5mB1Yyor2aV9pPJnf7AmwmH2jYAj177AJ51h2rYKZ1V4FqYf8qRG+VVGXNuK4woZnLh33EP4/7C0vPuIP7pj7LlMztNIZSuXPSv5iVuwEAZ7XTkvIA1FDPXqObbks3TmRSQn3PjacPeqrMgTblLf5512DWN2su7vIdpC1aved3uZtb2TFzDlUnFJDi3WxYTqDTeERoa3Sye45xnXW7cUcy4lcb9vzZO3IYK399Nq7WToIDCunUT2TSb//EtttH0j7CuCNpH2F88nk2qdhMjH1sYXMncscXB97QctbJayBrt2E+b39eYqq87hJLNP6uzHbAZgLbmprA+BIf/0y7jM9birhx28WEB0IF6Vz4xfU8O+VR/j3m+8yt8fDR0DNIaG/E5W/eZ172OuMG7H8DSofD3mHcUIQHhk290WAm+N2VzjiN6u3GGXhRBaX58DsKV5PxsQtlagcMWr9ENmdPKePqjCVcVVANyr6DOIo/gtvXjOaOYPR+idpu3bEzE7RWgsbHQU+JoXmMg2uK0ziwrVYbn0Bmz8XuoqXGCHgTDdOZ6abVoGoquHH5a9dZUt6w/1u2589hj5tV995BVEkDXaclaS6lN/8aV6uXbQ8eZZhXcqW5gUjMRJsQzDVxLprs62ImgpLdPQDU7BA4QJer6OCqPPAXH0021xfETDww0m061acY51V39vA9f/bwEo7WsfhdRaQnv8uOe7vejLty9BLOdNxHib2aVi2RZ0JHsVwZwoTQbi7O/JzXzv4D/6/1VD4JFu+vmD121hk/TLftSgQT371uMz5eqol8wh5z7UssoftCZ0oM7J0Hvr4qfmduLKaaGEdurMk1TBP9XldEaf2l57D7+JFM+us/2bQmlZypn1B29cU8//CVBMea27hw/q5jDNOYvUY7hhp/X/4iz54/p7TVotts1BxfQu20EtJ2VxHLdrD5u+mA8bXkaDF+GBNNMXcOHeh+6bDpgHbgY6iEjNtwW0bIMI3TFSFw6pd5onF77mLOS1/FY03H8kR2KdHTItQnnUFHaCwuXw15VW/SEPbSwNhv5PXTordp8rsZ/qz3az/1knLMm2w6fy7OXSMZ/MnnlP/URMdiJRP3C6m5nWBi6e3UZ92GaRqTjb8bRYNufSdZAc2+/5NUjSqWBa0dbSoxg2GV0wvJO786LhopOxfRUHwUKAoDKtfiCAUBlWCWcXm2INh9JvqDAdaMJ9SQQsTEnrKay7i8pGpzD4S1VOP2zFXVz2Yaib5HP/D15S80vmY8w1sxExn4UfG7/1O2TiY+BuqtFOqteOiaCKurTnCkoTlSyExzkYmO0unksaOfRE8ZSNHimyBo3cQNM21M0ETfk7TF+CgEs3S2fD/bMF36/ufi7aHoOkn1xnVvsSC0aHloPOZw0DayCM/GvWcUpuzcjd3nJ5jcPRsvWsVbPJSVd/4YV4uXUTfOJ+fG1TQ7x7HmZzeg7ycgJfquwYPSWJhxIdv9OVyz5grCmoNBn8HIRzKwv5fOt1dcR2PQzaKCi5hpf5/a0XOJ2ax7sib6MoXfb5mLosdQgl97XXplAP7U0vV/QLe5yHD4KHB641NN0e98FawO5Ocw/IfPkHvlJ/hbslh93x2E0j3xrp7oBRQgJbCBbO8ibFqALHs7vyl8hdsS3qDYVs9r4QncHZzL57EiBpc1k/VEB89+Pp1GLZW7BiziRvf7OJC9Qo4kVcdOZffx0yl6431y1nRN4shbsZaMjeWUn30qUbuJiEycuWtrsAeDVJdOJZCRSWZFz77ddCRT0Lgz93Uu+jJY/WDjbDocI9jhvp4OxyjSaz8hb9sLOMJegD1j6UGf/TeP3GwvdQ3fnOFV+NkKsjZsofzMk+nMNRGRFEc8RdfJKV9KzpYlOEK+eFdHCHEEcesBTtY2cZq2gbF6DUEcrFAGoaUORncPRk/MBHtC15uuq0LoTybBGhXFV0OBq/cvkXaksXwqZPvwIegOB+n/E7BWNJ20zVtpH9N7A9btRYNYdefNONs6GHHrAsrqvo9WZ0f5YZSmhybgL0whu/I1FOI7A1BYIy81xIKiW2iLJXPFyivoiCYy6DNYvuA6wjhxbg4zjUf4Tsf1PH38IyzOPIvTvW+wsvhk8ja/3q1rsYu+YX3HQHRHKoS84EqD1VGU86shooNDQX+pACZ2zRQal1xNddi6V3GE2JewO3WvYPXW8kvRsKPcEsN/b1fQOsO/yPSrteLIpqJxY94HXJX9KU41ysfRYv4TGUfnl5ulDSlr5Mbvv48tEiPmsPHXR2dRMK6V81NWM85Zwx2tc6mLpcX5U4jD1TZ4IBu/fTYZG8opfvXtPT9XgDHPvsJnd/6IlvwTyN71evwqaYKi63h2VdI0omsJt8ytFXGu0ZFC5668RZzn+YJHm47jgcaTqU86gzbXJFzROgr981Ea/9un7Gss3XJ8EI/bT22D5xu5K8DY519hyU9vYO13zieTp1FMzIgXQgghTNN1xus1jNeriaLyuTKESiWD8JfL/062/c8SuisDe93X8yT8Y/zfOPeLH9Bu9NqIsIzlM6wjaV1rVLcPH7LXz8PuFIJZGWi9eB3NXafPJpqSRPGzL+NryUfDDtjQYwoJ/2nE7x5GOPHAS2+IvuO0gRXk2upZ3DmHmmjX6xGJZRmEcRLDThgHiWUZNATdvFI1nSRbiP9LehDfgCI0ez9bxFDsl57Q9Z6O4quFJT6I6Cgxujq3JX6Ids0Mcdu7b6MsIb7SeOxUfEWDyH/zfWLlCf/tx3Qb7gXb8Q0ZiC/NeDkH0T+MSqzjh3nvk2wL85Od57IwMmVPsBqgeGUDtkgMmwa2qEbRyib+2j6Td/2jGOFsYG5SWRxrL6xSffRkdIedwk8+R9H3XiYgqbEZ985qfGnD0frAm4YZ27qWLklsbcHpl5mZVsh3eDnP8wXvdYzkocYTCdgLaXNNAl3HHV6PI+bdK/2+xtIXFCwHYOfufc+gjia4cHZ00lmQS9gus6yFEEJYKx0/E/Xd1OPmNXUC5WrOnmD1Pi0J7HVfr3+RRHFyAydmmFgzQ1jG8oB11vIvyHv3U7Z/+2y2X3gm0BWsXvnbnxHIySKr6k2ri7RM8bP/Jrmqhg03XI59uB+VKBBDsUPwlCzS6pfhDDTEu5rCIs9sGcVLLXP4fvoz3DPjA0jLJVDSjJMwNiI4iaBPbuSBE1/l5rGLeDt0Ejfv+jmFZS9iixqv+yf6CZsDPTkXYiGUib6umdU2wKGglIZQgy38u3ESLzdNindNRT+Q9/bHZC5Zye55pxE5LuW//Ziq0fad0WQsW01Ky/p4V1P0EhsD+dyw/SJqw24eGPIS33Z+Tgr/fbhWMSWbmMNGzKYQs6tsn5LJzWnvMCdpM58Fi3i2c1ocay+sMnzRu6RU11J25YU0jyja63c7TpmJd/gQBtR+jKr3/lmvWVs2Mf3Rv1Dy4vPxrsoRoyaSzrsdo5iRvJ08extJ0UoKOp8nMbqTxqQ5bPP8iJa844k6uiYt/e9YOntGOT8d8TpLVoxg+eq9H5jqisKuY6ex9NbrCXrSGD//X7iidfH4mEIIIY5gXhIJYSOgOAgqJtZ4Pzpx7/v6qTG8kUTebf7mHg2i+1i+JIii6Yx76AlQYOtl5xFJTaFlwmj8BblMuusBWi7sxg3ZDpOrtY2pv7qHFXffSvk9FzDy1hepzjyW9vOLKNqwCG1UuSwDcQQJa3Z+uvIUNg/P4BdDF1Bcup1L0n/HVPVxEtcMIGO2lz9e9yBZaiM/r/0Zz68ZjdO3jN4/v0j0OEcKelIeSkktPO1E/yIZpTSIMs6H7vJw87bz0a1/PijEN6jRKCV33kfZnTez666zGHT7qwQac2n8wXQyOlZTcse9VN4zOd7VFL3Im97xfNQ+Ys/SIBMSq1gUmcCS6DAqS7J4+NETKV7ZQPUUD3OnljHM1sj8juk81XE0uoyKjgjOTh9T73+CFTdfy+obr2Dyn55kQMUOmkcNo3zeqeSuWEuCa7VxRr2Aous4A7LkkdV+X38Ki4v+wk9y3uZH1ReQGiknNVJOwJZPS8IM2jIn05ZZSrJ3C6HZK5nGIySWZWArreEPN/2F6mA69z5yFqHUVDpzs+jMzcaXm4V30EA6CvPJ2FTBuBdeIaGtg/I5PbzpohBCiCOerqjsVtIZqHtRdB1dMRjDTknsWt5zSQCOsqOOqOepypPoNLPjvLBMt0SPFU1n3INPALBzXtfW0qW//CMZazbQcuGE7ijSMl8PWm/682UAFC1YxPBnX6bibnmacuRReGrrVLZ503hwwnN8OOxyLrrxBWY5/8NPku9ha3gIV6/4FVvrUnDSHO/Kit7MmYJOLkpJHWpJGAAtIRMS0iVYLXrU/watATKWdQWrbZFInGsneiO/5uIP1afS5HZzvnMFFzlXMMO2jQWRqVSWZBGdYONq18ekKCHuajmDD4Ij411lYTFXh4+p9z3O8luuZdWNVzBu/kI2XnQmKXWNjPvnv9h2tSfeVRRxVBNJ5/Hm47gp6wMWtG5jqX8YAImxGgp8C+msW0p7ZikdA8bjSx9DS95OUjoq+Nfwh0lzhjizegFrfnEckeT/Lg1p9/lJqWtkzAuvMnDZKnn8JYQQoltVKekM05vIoZ06TOzBMiURpiSi+GrRIypPVR/b/ZUUe+m26c5fBa2HvtS1QUtKVU13FWW5r4LWNbNmYAuGKHzzAxlEHeE+bhrBuUuv57HJ83l/wGwAnqmZye83nUykVRbVFyY5U9HRIeJHtyeByx3vGol+6qug9a5zTweg8N9vSrBaGKrT03g4NJvJtp3Mc3zBza7/0EkCyYRo0xN5IHiSBKuPYK6OTqbe/zjLb76WtVdfDMD0ex7FHgrHuWaiN/h789GclbaGX+a+wdnbryPytdtIR6SdjNoP8dQvpSOjhPbMSfww70NmpqzmqpZHKAuPJWftBlLqGkipbSSlvgFne6fcXwkhhOgxNaQRRaVQb6VOMblpeCwMkU5wpdMe7b378R2punV9DkXT+1Sg+utcrW0MffmteFdD9KAd/mzOXXo949y7calRPmwaDXTzRSKOPE43ulMC1SL+1GiUIS++Fu9qiD5HYVVsCBtiBZzmKGOqvZKtWjZPh46mA3mAe6RLaOtg2n2P0Vo8FJe3nZS6xnhXSfQSYd3B7+tP49HC5/h85P9jobeUJDVMkhomIStGsi1Msi1Ekj1Esi1MlquDF2qO5r31PvJ5kREL2uL9EYQQQvRjMcVGDWkU6i2s0AeD0bIggBJsARR0l6fb69eX6YqKomuW53twsTgdiO3/S6343UTjAgvM7dgdrTZ+eqE5dMM0AAPfMz5w5T283EfLeHMb16hRa+Ye7PreIHPlfc+S4g6ZVZ8XQDFxeugZe88aasfGEgZ3netf/i4WdZkqT7ebOx9N5WXiMAyYYrwBaO3udFPlae6oYRp7g9NcXiavy+6Sudr44DWVWteYFi281jCNauE+Va4m4+VFzJw/AFpJp2GacL25AJXiMj6HtATrO7GDpoDm2v85qnSaW6XezDE2+3kPVJ+vqCHjArc9eJSp8szwDTH5XWWa2IC2ybgN9Yw1t+RSy7YBptJ1J90GEc/+j8/w5wKGeWy7yNx15SkzHqZ5p5nbBNixzbjMdxNH7PX31xmLgvblWtVd56DzA5MP5IYbn0OxJJPXiInL0hkxvkZSd5hbnimpwVw/Vmkq1d50G0RTDD63ZvxZUnaaa+j1SuPx9K55+0rTQKQQOsfndpW3w1RxdBRZ1867Woy/r+YxJr7TRHPXyJjjKg3TbPpomKm8wpnduEGlAqgHPkcdHcbHJRYzbptHTa7e6+/1ePhr5yyuTf6IszxrCegOgrqDVnsSfs1JjebGH3bi15zUed38vfUYHPlda4rvuN3kbeduc+NuqyjJxuOX8FqPqbwaphi3Ha4m43yC2d08ltYPfM+VWGuurfTnG1/vkTTjNMF8k9eLiWbPZnIcZ4aZ8Vk0yeR3ZaJdj6SYy0rxGX/GA41ThOgVzARrDDTXmhuT/jZ4+p4/r0/L5w8FL/Pa1gmsCw7c8/Pf7aM+gx3NLB72Z55uOYp7Np2CzUTfChBLNr7+VBPjVgDNaXyc/EOM29CkSnN9cHOpcV4j/9ax1981m40lt1xPckMjE55egKp1fX7N7jFV5oHI5NF+rG7CWLxFgxjx2tuosd6/87sQonspaIx0NbA5lIOpuwIhhCmd2Zkktrb1yWVZZA1+IcTXvRMawzuhMXv9bENtbpxqI4QQQpj3YccIorrKSe5NewWs96bjUGJcm/kxEd3GU81H92gd+5rqqZPwZ2fiz85k/bfnMf65f6Po1jx4lYB1P1UzZQLrLjkHVBV/xgAmPvWCBK2F6Nd0fpX7BpdmLOeZ5mncXXe6BKqEsEBTcRFrLr8Iz87dlD75DGpMZj0JIYQQQgjR09q0JJb7hnBN5qcMczWS/OXSVklq6Gt/DuNQusbr81um0RRLjXOtey9NVdlx4rGkVVaRvWEzFWechCMQZNS/F1uSvwSs+6H2gXmsu+QcPDt3k7V+CxVzT6J87kmMekXW7BaivzrFvZFLM5bj1xxcmrGcHeFM5rdYt8SEEP1RzG5n/UXzAAXv0EFUHn80RR98Gu9qCSGEEEII0S/dVXcGt+a8Tb6jDZ/mxBtLpCaShk/rWtLKrznxaS68sURea5sQ7+r2ao1jRxLMSKfo3Y/JX7mGxtEjqDpmGp7KXdipOuz8JWDdDyW0eElqbsU7eCBthfmgaQzYWhnvagkh4mhTMJe6iJtcRztN0WRW+82tey+E2D81GsVTWUXT6K61oT2Vhz9wE0IIIYQQQhyaynAmN1RdvNfPFAvW1O6P3LtrcbW1s/HCs9h07hnodjvuXbtJ21mNr+jw85eAdT/k9AeY+vDfWXrzdYTTUin5x4tkr98c72oJIeJoVziD87dfTZotSGssicaovPokxOFSgJLnFtKZkwWAu6YuvhUSQgghhBBCCAsktnqZ8sg/qDh9DoEBHoa98xFZ6zejAL4iz2HnLwHrfiqhrYOZd94LsGcXTyFE/1YfTaM+mhbvaghxRFFjMQlUCyGEEEIIIY44yY3NTHz6xW7JWwLW/ZgEqoUQQgghhBBCCCGEEL2JGu8KCCGEEEIIIYQQQgghhBBgdcDaxITd6O5ky4qzcl30gvd7draxGlV6tLzy73l6tLy+Qml2GqbRckI9UJODV1+eaZgmb2CrZeVFs8OW5dXfaLaeLc/KttGZE7Ausz5Ad1p38PSebeb7tNaKAZblpcf5UfzWixMN0wx7wbrryrPcZVle2nq3YZrwCe2WlWelcJrxOC5k3WkWd52De3ZzoJjxcMm0nm4bkzcd2jVSpU3lneivqdfG7vnZ6JnbrKpWn7B2lQU7Jn1J1/pupxguCvZoeQkN8T1WgTzr7ovNXO82n3UD5VhKzLK8zFAtLC6SauFxl2mJoh+wsu0wwzmsw7K8NEfPjuP8Q6KW5bXlqp7b6+qglgSxBcGzZf+9jneMuUY2Wp1kmMbVZNzKBgrM9RBVJxv3lM6cgOHBCDcY34QCqBFzgwyrgtaejcbHyjtGMxW07o+dm1HQWunhhwtgLuCoBlWa1mYbZuQwUZ7mMi5QS9SIphs3dEqwG08iBTT7gevaVGpNUarZz5HQsw+7PMfWG6ZJuctcJ7LLnmKYJpKmmXuy2WRN0MzMuXhYdFBDveum2VVvPNiKeKw7zxxtxt9oxETwDzD1vSfWGpcXzNTxbswwTKeYGNy5CjsN0xwOJQqu5v1/pmCmRsUlBx4vJNaruJqMy2ofbqYz0FG9xi29YuIrDadrUGXcLoSG9/BDfhPDPc2hE04/cMKM1eZubBqnmGyH5ptLdrBcLcZtVChTo3OoNe2llmbctw953lxenUOtW23Q5jdO49lufC42lai4dhq3VcHru25EdWDHBXPZetl5qMEQy21XMfG3D5O1ci0VvysBE0ElJRzffiaWZM016mhT2fj+cMN0URN9Rk+Pq5RscxNOlN0Jhmli7hihHOPrJKHW+Pz3FRk3aL1hnGImaG3lBImeDjxZRVfNHQczfbCZ8VlXoSbSKP3zvl70P2bajnCH8dhWG2A8OU/1OsDE5Caz8UAznG3GeQ1caNzf7ZiXRDjduO7p642PZ9tIjYrLjSe5DHz38IPkh9WMaapqqr0UQggRX3UlY9h5zPR4V0MIIYTotTSbjY03XsHWy84j7/3POO6qW0it3M2aX9xI45QJ8a6eEEIIIcQBRV0utp94HL7Mvv9q4SEHrDVVZftxZ1E98Xgr6yOEEMJi/gHpbJw3l4rT5lAzaXy8qyOEEEL0OrqisOaXN1F9yiyGvvAa4+5/HJe3ncm//OOeoHUgZVC8qymEEEIIsU+BdA/Lb7iS7XNmsvKay/FlGb/B2psdcsBa0SHgyaIze6CV9RFCCGGxQHoamqPrNdWOvNw410YIIYTofaKJCXjHjMDe6SP3k8/56iVch89P1vI16A4HwaSCuNZRCCGEEGJ/2gYV4M/MIHd1GZGUZFqKhsS7SoflMALWGsM+epmiTxdZWR8hhBAWy9hWyZTH/sGkp56j+K13410dIYQQotdx+ANM+dnvsYXCrPjjL2guGQ3AjnNOY9sl88j9aBmehmVxrqUQQgghxL5lbirHFgpRV1oCQNbmijjX6PAc1hrWSd5GnH7rdsoUQgjRPTxV1WRs24Gqyc4DQgghxL64d+xi+s13kdDYzOpf38KSh++m4sqLyP1oGePuewxFdu8RQgghRC9lD0fIXbMegKTGZhLa2uNco8Mje8cKIYQQQgghBJDQ1MLUn/4Oz8ZyOocO2hOsVjUt3lUTQgghhDigghVfAJD3RVmca3L47PGugBBCCCGEEEL0Fg6fn8l33Nv1F02XYLUQQggh+gR3TR1zbvtNvKthCUtnWHs29uyE7cRqm2V5hesTDdM4swOWlWcl7xjjQXRPfzdHEt3eO1//1BJM3DzpinEak9RA/zqHTB3fXqrzduuWanK09ez3roasO2fFoevp7z2hybrvPVSVYllehyKhyfjYBXIsbF80646ds7XvtvNqxPg4NJfGeqAmPcNl4jyzUuW3e7Q4S2WWHdr1pkZjXf99LVhdfFvfn610MCJp1rVVPT2u0htcluVla7funtMMzdU77z3ENykWntZWXm+yepEQ1tM8kXhX4ZANfdlvWV5pW3puDHpQM6wdGWFyLq7c7+/rXhhC2uYDV751YtRUWaFMc3WyKrhhz/cbNuzRmiRTEf4fn7zYMM39b59hrl7txiVG3Zph0FrPCJsqT7fwxvd/KTGwdxz488QSjXvXWIa5hsLW6DBMozuNy9McOjiM09k7jAezZgfrZs5rM2liSdaOVswErWPJ3RgQ0EGNHvhzax7jNqYgr8UwTe36nK7v3oB7mNcwjU01972H3zNu+Ooz3YZptFYXmAguJNUYpwmaDKxlrTQ+H305xmn8hVq3Bq0VDdTg/s9jXTV3zZhpO8yKeIyPsZk2XGl2miove5XxNVJ9onUDkUCedTdg58xcbpjm3x9N69agte6AYM7+27nknTaSdx/4+AXyNEKZPRu8Caf3bHmaiYe9STXmgkCKiW4/UKCZClq3jjdxHLpxLKSGIanqwOeHP9/E2MREXwegmhibqG3GtwMJdSoNpcblOVuN08TG+IwTAT638TgulGmcxhY0931W/K7EME1XINH4+9Ft3RctUmLg8B74HDLTr5hlVRBNVyCWaJyXme8rmmqcjxpWTAWtFROnhxpWUJuNrxMz7azda3xNRjKilo/hv04NQ9IB+ikzbVBXRsbpbH4T9w5J5s4xM/2K08TxBQgPNB5X2euN2xfNpfd40Fox8fXEUo6cB7TiyGMLQer2A7cNvjzjfDQTfQpgqq1yf2HcX3QO7fkJbWbuF3yFxpNv644BM+MXf65xp5izIkpqlWEydp1i8n5y0f5/1Xen0vQxyYSQR51CCCGEEEIIIYQQQgixfxKw7gElVHEFSziBLUjQWgghhBBCCCGEEH3d0sfX8ftTPmTp4+viXRUhxBFGNl3sAWkEaCWJFEKo6GjIGq1CCCGEEEIIIYTom5Y+vo7Z1w4jzGicb4d5j3XMuGZ8vKslhDhCSMC6B3xCMQo6CqDJpHYhhBBCCCGEEEL0YR8ubCbMaGLYCaPz4cJmZlwT71oJIY4UEj3tEQo6qgSrhRBCCCGEEEII0efNOjcDJ2FsRHASYda5GfGukhDiCCIzrIUQQgghhBBCCCGEaTOuGc97rOPDhc3MOjdDlgMRQlhKAtZCCCGEEEIIIYQQ4qDMuGa8LAMihOgWiq7r5hMrSiOws/uqI/qQwbquZx3MP5DzR/wPOYfE4ZJzSBwuOYfE4ZDzRxwuOYfE4ZJzSByOgz5/QM4hsRdpg8Th2u85dFABayGEEEIIIYQQQgghhBCiu8gugEIIIYQQQgghhBBCCCF6BQlYCyGEEEIIIYQQQgghhOgVJGAthBBCCCGEEEIIIYQQoleQgLUQQgghhBBCCCGEEEKIXkEC1kIIIYQQQgghhBBCCCF6BQlYCyGEEEIIIYQQQgghhOgVJGAthBBCCCGEEEIIIYQQoleQgLUQQgghhBBCCCGEEEKIXkEC1kIIIYQQQgghhBBCCCF6hf8P5a/R0PTo9JcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig_title = \"Receptive fields\" # The title of the figure.\n", + "cell_idx_lst = np.arange(100) # list or np.array. The cell numbers to be plotted.\n", + "polarity = 'both' # 'ON', 'OFF', or 'both'. The polarity of the RFs to be plotted.\n", + "num_cols = 10 # int. The number of columns of the subplots.\n", + "label_peak = True # bool. If True, the pixel with max response will be labeled. The ON peaks are labeled with red dots and OFF peaks with blue dots.\n", + "contour_levels = [0.6] # list or array-like. The contour levels to be plotted. Examples: [], [0.5], [0.6, 0.8].\n", + "fig = LSN_data.plot_RFs(fig_title, cell_idx_lst, polarity, num_cols, label_peak, contour_levels)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.9" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d944b42c081ab30567867626f319dee2ae659ae5 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Thu, 30 Jul 2020 20:09:57 +0200 Subject: [PATCH 44/68] Replaced _is_trial with issubclass(). --- oscopetools/read_data/dataset_objects.py | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 78dcf8a..7efa855 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -710,7 +710,6 @@ def plot( fluo_mean = self.trial_mean().data[0, 0, :] fluo_std = self.trial_std().data[0, 0, :] - if fill_mean_pm_std: ax.fill_between( self.time_vec, @@ -720,7 +719,6 @@ def plot( alpha=alpha * 0.6, **pltargs, ) - ax.plot(self.time_vec, fluo_mean, alpha=alpha, **pltargs) if highlight_non_baseline: stim_start = self.time_vec[0] + self._baseline_duration @@ -826,12 +824,11 @@ def __init__( ): super().__init__(timestep_width) self.data = pd.DataFrame(tracked_attributes) - self._is_trial = False @property def num_timesteps(self): """Number of timesteps in EyeTracking dataset.""" - if self._is_trial: + if issubclass(type(self), TrialDataset): if self._within_trial: return 1 else: @@ -842,7 +839,7 @@ def num_timesteps(self): def get_frame_range(self, start: int, stop: int = None): window = self.copy() if stop is not None: - if self._is_trial: + if issubclass(type(self), TrialDataset): if not self._within_trial: window.data = window.data.applymap( lambda x: x[start:stop] @@ -850,7 +847,7 @@ def get_frame_range(self, start: int, stop: int = None): else: window.data = window.data.iloc[start:stop, :].copy() else: - if self._is_trial: + if issubclass(type(self), TrialDataset): if not self._within_trial: window.data = window.data.applymap( lambda x: x[start : start + 1] @@ -1018,7 +1015,6 @@ def plot( ) if robust_range_: - # Set limits based on approx. data range, excluding outliers ax.set_ylim( robust_range( self.data[self._y_pos_name], @@ -1031,10 +1027,6 @@ def plot( half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, ) ) - else: - # Set limits to a 180 deg standard range - ax.set_xlim(-90.0, 90.0) - ax.set_ylim(-90.0, 90.0) else: raise NotImplementedError( @@ -1058,7 +1050,6 @@ def __init__(self, eye_tracking_df, trial_num, timestep_width): super().__init__(eye_tracking_df, timestep_width) - self._is_trial = True self._baseline_duration = 0 self._both_ends_baseline = False self._trial_num = np.asarray(trial_num) From 26d9000fac10e810026ea2a50d9c661c5050e38b Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Thu, 30 Jul 2020 20:31:48 +0200 Subject: [PATCH 45/68] Replaced_is_trial with issubclass(). --- oscopetools/read_data/dataset_objects.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/oscopetools/read_data/dataset_objects.py b/oscopetools/read_data/dataset_objects.py index 7efa855..24390a8 100644 --- a/oscopetools/read_data/dataset_objects.py +++ b/oscopetools/read_data/dataset_objects.py @@ -710,6 +710,7 @@ def plot( fluo_mean = self.trial_mean().data[0, 0, :] fluo_std = self.trial_std().data[0, 0, :] + if fill_mean_pm_std: ax.fill_between( self.time_vec, @@ -719,6 +720,7 @@ def plot( alpha=alpha * 0.6, **pltargs, ) + ax.plot(self.time_vec, fluo_mean, alpha=alpha, **pltargs) if highlight_non_baseline: stim_start = self.time_vec[0] + self._baseline_duration @@ -1015,6 +1017,7 @@ def plot( ) if robust_range_: + # Set limits based on approx. data range, excluding outliers ax.set_ylim( robust_range( self.data[self._y_pos_name], @@ -1027,6 +1030,10 @@ def plot( half_width=ROBUST_PLOT_RANGE_DEFAULT_HALF_WIDTH, ) ) + else: + # Set limits to a 180 deg standard range + ax.set_xlim(-90.0, 90.0) + ax.set_ylim(-90.0, 90.0) else: raise NotImplementedError( From aac88a9512de802eb61f194a8e827ccc0810492a Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Tue, 4 May 2021 19:19:47 +0200 Subject: [PATCH 46/68] Added greedy pixelwise RF --- oscopetools/LSN_analysis.py | 556 +++++++++++++++++++++++++---- oscopetools/greedy_pixelwise_rf.py | 253 +++++++++++++ 2 files changed, 736 insertions(+), 73 deletions(-) create mode 100644 oscopetools/greedy_pixelwise_rf.py diff --git a/oscopetools/LSN_analysis.py b/oscopetools/LSN_analysis.py index c82a20e..aa40943 100644 --- a/oscopetools/LSN_analysis.py +++ b/oscopetools/LSN_analysis.py @@ -10,8 +10,12 @@ import matplotlib.pyplot as plt from oscopetools import read_data as rd from .adjust_stim import * +from .chi_square_lsn import chi_square_RFs +from .greedy_pixelwise_rf import get_receptive_field_greedy from enum import Enum -import warnings +import warnings, sys, os + +sys.__stdout__ = sys.stdout class LSN_analysis: @@ -19,10 +23,13 @@ class LSN_analysis: _OFF_stim_value = 0 _background_stim_value = 127 _yx_ref = None # The reference y- and x-positions used for correcting the LSN stimulus array. - _stim_size = ( - 10 # The side length of the stimulus in degree (same unit as eye pos). + _stim_size_deg = ( + 9.3 # The side length of the stimulus in degree (same unit as eye pos). ) _frame_rate_Hz = 30 # The frame rate of fluorescent responses in Hz. + _CS_center_diameter_deg = ( + 30 # The diameter in degrees of the center-surround stimulus' center. + ) def __init__( self, @@ -30,9 +37,15 @@ def __init__( LSN_stim_path, num_baseline_frames=None, use_dff_z_score=False, + correct_LSN=False, + use_only_valid_eye_pos=False, + use_only_positive_responses=False, + RF_type="Greedy pixelwise RF", + RF_loc_thresh=0.8, + verbose=True, ): """To analyze the locally-sparse-noise-stimulated cell responses. - + Parameters ---------- datafile_path : str @@ -43,21 +56,36 @@ def __init__( The number of baseline frames before the start and after the end of a trial. use_dff_z_score : bool If True, the cell responses will be converted to z-score before analysis. - + correct_LSN : bool + If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN stimulus will be used. + The stimulus wlll remain unchanged for those frames without valid eye positions. + use_only_valid_eye_pos : bool + If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used. + use_only_positive_responses : bool + If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses. + RF_type : str + "Greedy pixelwise RF" or "Trial averaged RF". The type of RFs to be computed. + RF_loc_thresh : float + The threshold for deciding whether the RF is located within the center or surround or not. + verbose : bool + If True, the parameters used will be printed. + """ self.datafile_path = datafile_path self.LSN_stim_path = LSN_stim_path self.num_baseline_frames = num_baseline_frames - if (self.num_baseline_frames is None) or ( - self.num_baseline_frames < 0 - ): + if (self.num_baseline_frames is None) or (self.num_baseline_frames < 0): self.num_baseline_frames = 0 self.is_use_dff_z_score = use_dff_z_score - self.is_use_corrected_LSN = False - self.is_use_valid_eye_pos = False - self.is_use_positive_fluo = False + self.is_use_corrected_LSN = correct_LSN + self.is_use_valid_eye_pos = use_only_valid_eye_pos + self.is_use_positive_fluo = use_only_positive_responses + self.RF_type = RF_type + self.RF_loc_thresh = RF_loc_thresh + self._verbose = verbose self.dff_fluo = rd.get_dff_traces(self.datafile_path) self.num_cells = self.dff_fluo.num_cells + self.cell_ids = np.array(rd.get_roi_table(datafile_path).cell_id).tolist() self.LSN_stim_table = rd.get_stimulus_table( self.datafile_path, "locally_sparse_noise" ) @@ -79,21 +107,23 @@ def __init__( self.LSN_stim_table, self.eye_tracking, self._yx_ref, - self._stim_size, + self._stim_size_deg, self._background_stim_value, ) - self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] - self._trial_mask = self.valid_eye_pos + self._all_trial_mask = np.array([True] * self.LSN_stim_table.shape[0]) + self._update_params() + self._get_CS_center_info() self._update_responses() def __str__(self): return ( - "Analyzing file: {}\n" + "\nAnalyzing file: {}\n" "ON LSN stimulus value: {}\n" "OFF LSN stimulus value: {}\n" "Background LSN value: {}\n" "LSN stimulus size: {} degree\n" "Number of cells: {}\n" + "Current RF type: {}\n" "Use DF/F z-score: {}\n" "Use corrected LSN: {}\n" "Use only valid eye positions: {}\n" @@ -103,8 +133,9 @@ def __str__(self): self._ON_stim_value, self._OFF_stim_value, self._background_stim_value, - self._stim_size, + self._stim_size_deg, self.num_cells, + self.RF_type, self.is_use_dff_z_score, self.is_use_corrected_LSN, self.is_use_valid_eye_pos, @@ -123,12 +154,16 @@ def correct_LSN_by_eye_pos(self, value=True): if bool(value) else "LSN stim is already original." ) - if value: - self.LSN_stim = self._corrected_LSN_stim - else: - self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] - self._update_responses() - self.is_use_corrected_LSN = bool(value) + try: + self.is_use_corrected_LSN = bool(value) + self._update_responses() + except: + print( + "Failed to change correct_LSN_by_eye_pos to {}! \nRecomputing the responses with correct_LSN_by_eye_pos({})...".format( + value, bool(1 - value) + ) + ) + self.correct_LSN_by_eye_pos(bool(1 - value)) def use_valid_eye_pos(self, value=True): """ @@ -141,12 +176,16 @@ def use_valid_eye_pos(self, value=True): if bool(value) else "All eye positions are used." ) - if value: - self._trial_mask = self.valid_eye_pos - else: - self._trial_mask = np.array([True] * self.LSN_stim_table.shape[0]) - self._update_responses() - self.is_use_valid_eye_pos = bool(value) + try: + self.is_use_valid_eye_pos = bool(value) + self._update_responses() + except: + print( + "Failed to change use_valid_eye_pos to {}! \nRecomputing the responses with use_valid_eye_pos({})...".format( + value, bool(1 - value) + ) + ) + self.use_valid_eye_pos(bool(1 - value)) def use_positive_fluo(self, value=True): """ @@ -159,10 +198,19 @@ def use_positive_fluo(self, value=True): if bool(value) else "Both positive and negative responses are already used." ) - self.is_use_positive_fluo = bool(value) - self._update_responses() + try: + self.is_use_positive_fluo = bool(value) + self._update_responses() + except: + print( + "Failed to change use_positive_fluo to {}! \nRecomputing the responses with use_positive_fluo({})...".format( + value, bool(1 - value) + ) + ) + self.use_positive_fluo(bool(1 - value)) def _update_responses(self): + self._update_params() self.ON_avg_responses = self._compute_avg_pixel_response( self.trial_fluo.get_trials(self._trial_mask), self.LSN_stim[self._trial_mask], @@ -173,7 +221,29 @@ def _update_responses(self): self.LSN_stim[self._trial_mask], self._OFF_stim_value, ) - self.get_RFs() + if self.RF_type.upper() == "TRIAL AVERAGED RF": + self.get_trial_avg_RFs() + elif self.RF_type.upper() == "GREEDY PIXELWISE RF": + self.get_greedy_RFs() + else: + print( + "Please choose either 'Trial averaged RF' or 'Greedy pixelwise RF' for RF_type." + ) + if self._is_CS_session: + self.get_RF_loc_masks(self.RF_loc_thresh) + if self._verbose: + print(self) + + def _update_params(self): + if self.is_use_corrected_LSN: + self.LSN_stim = self._corrected_LSN_stim + else: + self.LSN_stim = self._full_LSN_stim[self.LSN_stim_table.Frame] + + if self.is_use_valid_eye_pos: + self._trial_mask = self.valid_eye_pos + else: + self._trial_mask = self._all_trial_mask def _compute_avg_pixel_response(self, trial_response, LSN_stim, target): """ @@ -185,7 +255,7 @@ def _compute_avg_pixel_response(self, trial_response, LSN_stim, target): LSN stimulus array, shape = (num_frame, ylen, xlen). target : int The target value (value of interest) in the stimulus array. - + Returns ------- avg_responses : 4d np.array @@ -207,18 +277,160 @@ def _compute_avg_pixel_response(self, trial_response, LSN_stim, target): for y in range(LSN_stim.shape[1]): for x in range(LSN_stim.shape[2]): avg_responses[:, y, x, :] = ( - response.get_trials(LSN_stim[:, y, x] == target) - .trial_mean() - .data + response.get_trials(LSN_stim[:, y, x] == target).trial_mean().data ) return avg_responses - def _compute_p_values(self): - raise NotImplementedError + def _get_chi_square_pvals(self, frame_shift, num_shuffles=1000): + """To do the Chi-square test on the DF/F responses to LSN stimuli. + + Parameters + ---------- + frame_shift : int + The frame shift of the window to account for the delay in calcium responses for the Chi-square test. + Default is 3. + + Creates + ------- + chi_square_pvals : array-like, 3D + The p-values from the Chi-square test for each cell. Shape = (num_cells, ylen, xlen). + """ + assert ( + abs(frame_shift) <= self.num_baseline_frames + ), "Please use frame_shift with absolute value smaller or equal to num_baseline_frames!" + if self.is_use_positive_fluo: + trial_dff = ( + self.trial_fluo.get_trials(self._trial_mask).positive_part().data + ) + else: + trial_dff = self.trial_fluo.get_trials(self._trial_mask).data + stim_trial = trial_dff[ + :, + :, + self.num_baseline_frames + + frame_shift : -self.num_baseline_frames + + frame_shift, + ] + responses = stim_trial.mean(2) + LSN_template = self.LSN_stim[self._trial_mask] + self._allow_print(False) + self.chi_square_pvals = chi_square_RFs(responses, LSN_template, num_shuffles) + self._allow_print(True) + + @staticmethod + def _remove_non_significant(RF, p_values, significant_lvl=0.05): + """To remove the non-significant part of the RF. + + Parameters + ---------- + RF : array-like, 2D + The receptive field computed by greedy pixelwise approach. + p_values : array-like, 2D + The p-values from Chi-square test. + significant_lvl : float + The significant level of the Chi-square p-values. + + Returns + ------- + RF : array-like, 2D + The receptive field with non-significant parts removed. + """ + RF = RF.copy() + non_sig_mask = p_values > significant_lvl + RF[non_sig_mask] = 0 + return RF + + @staticmethod + def _normalize_RF(RF): + """To normalize the receptive field to range from 0 to 1. + + Parameters + ---------- + RF : array-like + The receptive field to be normalized. + + Returns + ------- + RF : array-like + The normalized RF. + """ + if np.nanmin(RF) == np.nanmax(RF): + return np.zeros(RF.shape) + RF /= np.nanmax(abs(RF)) + return RF + + def get_greedy_RFs( + self, + frame_shift=3, + alpha=0.05, + sweep_response_type="mean", + chisq_significant_lvl=0.05, + norm_RF=False, + ): + """To compute the receptive fields using greedy pixelwise approach. + + Parameters + ---------- + frame_shift : int + The frame shift of the window to account for the delay in calcium responses for the Chi-square test. + Default is 3. + alpha : float + The significance threshold for a pixel to be included in the RF map. + This number will be corrected for multiple comparisons (number of pixels). + sweep_response_type : str + Choice of 'mean' for mean_sweep_events or 'binary' to make boolean calls of + whether any events occurred within the sweep window. + chisq_significant_lvl : float + The significance threshold of the Chi-square test p-values for the RF pixels to be included. + norm_RF : bool + If True, the computed RFs will be normalized to their corresponding max value. + + Creates + ------- + ON_RFs, OFF_RFs : array-like, 3D + The ON/OFF receptive subfields. Shape = (num_cells, ylen, xlen). + """ + self._get_chi_square_pvals(frame_shift) + self.ON_RFs = [] + self.OFF_RFs = [] + stimulus_table = self.LSN_stim_table.astype(int) + stimulus_table.columns = ["start", "end", "frame"] + stimulus_table = stimulus_table[self._trial_mask] + stimulus_table["start"] = stimulus_table["start"] + frame_shift + stimulus_table["end"] = stimulus_table["end"] + frame_shift + LSN_template = self.LSN_stim[self._trial_mask] + all_L0_events = ( + self.dff_fluo.positive_part().data + if self.is_use_positive_fluo + else self.dff_fluo.data + ) - def get_RFs(self, threshold=0, window_start=None, window_len=None): + for idx in range(self.num_cells): + RF_ON, RF_OFF = get_receptive_field_greedy( + all_L0_events[idx], + stimulus_table, + LSN_template, + alpha, + sweep_response_type, + ) + RF_ON = self._remove_non_significant( + RF_ON, self.chi_square_pvals[idx], chisq_significant_lvl + ) + RF_OFF = self._remove_non_significant( + RF_OFF, self.chi_square_pvals[idx], chisq_significant_lvl + ) + self.ON_RFs.append(self._normalize_RF(RF_ON) if norm_RF else RF_ON) + self.OFF_RFs.append(self._normalize_RF(RF_OFF) if norm_RF else RF_OFF) + self.ON_RFs, self.OFF_RFs = np.array(self.ON_RFs), -np.array(self.OFF_RFs) + self._integration_window_start = self.num_baseline_frames + frame_shift + self._integration_window_len = ( + self.ON_avg_responses.shape[-1] - 2 * self.num_baseline_frames + ) + self.RF_type = "Greedy pixelwise RF" + + def get_trial_avg_RFs(self, threshold=0, window_start=None, window_len=None): """To get the ON and OFF RFs and the position of their max response. - + Parameters ---------- threshold : int or float @@ -227,7 +439,7 @@ def get_RFs(self, threshold=0, window_start=None, window_len=None): The start frame index (within a trial) of the integration window for computing the RFs. window_len : int The length of the integration window in frames for computing the RFs. - + Creates ------- ON_RFs : 3d np.array @@ -242,9 +454,7 @@ def get_RFs(self, threshold=0, window_start=None, window_len=None): if window_start is None: window_start = self.num_baseline_frames if window_len is None: - window_len = ( - self.ON_avg_responses.shape[-1] - 2 * self.num_baseline_frames - ) + window_len = self.ON_avg_responses.shape[-1] - 2 * self.num_baseline_frames if window_start + window_len > self.ON_avg_responses.shape[-1]: warnings.warn( "The integration window [{}:{}] is shifted beyond the trial of length {}!".format( @@ -268,24 +478,35 @@ def get_RFs(self, threshold=0, window_start=None, window_len=None): self._integration_window_start, self._integration_window_len, ) - ON_cell_peak_idx = self.ON_RFs.reshape( - self.ON_RFs.shape[0], -1 - ).argmax(1) - OFF_cell_peak_idx = self.OFF_RFs.reshape( - self.OFF_RFs.shape[0], -1 - ).argmin(1) + self.RF_type = "Trial averaged RF" + + def _get_RF_peaks_yx(self): + """To get the yx coordinates of max response of the ON and OFF RFs. + + Creates + ------- + ON_RF_peaks_yx : 2d np.array + The yx-indices of the peak ON responses of each cell, shape = (num_cells, 2). + OFF_RF_peaks_yx : 2d np.array + The yx-indices of the peak OFF responses of each cell, shape = (num_cells, 2). + """ + ON_cell_peak_idx = self.ON_RFs.reshape(self.ON_RFs.shape[0], -1).argmax(1) + OFF_cell_peak_idx = self.OFF_RFs.reshape(self.OFF_RFs.shape[0], -1).argmin(1) self.ON_RF_peaks_yx = np.column_stack( np.unravel_index(ON_cell_peak_idx, self.ON_RFs[0, :, :].shape) - ) + ).astype(float) self.OFF_RF_peaks_yx = np.column_stack( np.unravel_index(OFF_cell_peak_idx, self.OFF_RFs[0, :, :].shape) - ) + ).astype(float) + for i in range(self.num_cells): + if self.location_mask_dict["No_ON"][i]: + self.ON_RF_peaks_yx[i] = [np.nan, np.nan] + if self.location_mask_dict["No_OFF"][i]: + self.OFF_RF_peaks_yx[i] = [np.nan, np.nan] - def _compute_RF_subfield( - self, polarity, threshold, window_start, window_len - ): + def _compute_RF_subfield(self, polarity, threshold, window_start, window_len): """To compute the ON or OFF subfield given a threshold. - + Parameters ---------- polarity : str @@ -296,7 +517,7 @@ def _compute_RF_subfield( The start index (within a trial) of the integration window for computing the RFs. window_len : int The length of the integration window in frames for computing the RFs. - + Returns ------- RFs : 3d np.array @@ -321,6 +542,171 @@ def _compute_RF_subfield( RFs *= pol return RFs + def _compute_center_overlap(self, RF_arr, RF_thresh=0, bin_num=1000): + """Compute the fraction of overlap between ON/OFF receptive subfields and center. + + Parameters + ---------- + RF_arr : array-like, 2D + The receptive field. Shape = (ylen, xlen). + RF_thresh : float + The threshold of RF, the RF values below the threshold will not be considered. Default is 0. + bin_num : int + The number of binning for an LSN pixel when computing the overlapping indices. + Higher bin_num gives higher precision but will take longer computational time. + + Returns + ------- + overlapping_index : float + The overlapping index (fraction) of the RF with the stimulus center. + """ + RF = abs(np.array(RF_arr).copy()) + RF[RF < RF_thresh] = 0 + RF_ys, RF_xs = np.where(RF > 0) + total_overlap = 0 + for i, RFy in enumerate(RF_ys): + RFx = RF_xs[i] + tmp_ys = np.arange(RFy - 0.5, RFy + 0.5, 1 / bin_num) + tmp_xs = np.arange(RFx - 0.5, RFx + 0.5, 1 / bin_num) + xs, ys = np.meshgrid(tmp_xs, tmp_ys) + tmp_xys = np.vstack((xs.flatten(), ys.flatten())).T + distances = np.linalg.norm(tmp_xys - self.CS_center_pos_xy_pix, axis=1) + within_center = distances <= self.CS_center_radius_pix + overlap_fraction = within_center.sum() / bin_num ** 2 + total_overlap += overlap_fraction * RF[RFy, RFx] + overlapping_index = total_overlap / RF.sum() + return overlapping_index + + def _get_center_overlap(self, RF_thresh=0, bin_num=1000): + """To compute the overlapping index for ON/OFF RFs with inner/outer centers. + + Parameters + ---------- + RF_thresh : float or int + The threshold of RFs to be considered. Default is 0. + bin_num : int + The number of binning for an LSN pixel when computing the overlapping indices. + Higher bin_num gives higher precision but will take longer computational time. + + Creates + ------- + ON_overlap_idx, OFF_overlap_idx : list + List containing overlapping indices for the ON and OFF RFs with the CS center. + """ + overlapping_idx_ONOFF = [] + for RFs in [self.ON_RFs, self.OFF_RFs]: + sublst = [] + for RF in RFs: + overlap_idx = self._compute_center_overlap(RF, RF_thresh, bin_num) + sublst.append(overlap_idx) + overlapping_idx_ONOFF.append(sublst) + self.ON_overlap_idx, self.OFF_overlap_idx = np.array(overlapping_idx_ONOFF) + + def _get_CS_center_shift(self): + """ + Creates + ------- + _center_shift_xy_deg, center_shift_xy_pix : array-like, 1D + The x- and y-shifts of the CS center relative to the center of the monitor in degrees and LSN pixels. + """ + self._allow_print(False) + stim_table = rd.get_stimulus_table(self.datafile_path, "center_surround") + self._allow_print(True) + center_xs = np.array(stim_table.Center_x) + center_ys = np.array(stim_table.Center_y) + is_same_x = center_xs.min() == center_xs.max() + is_same_y = center_ys.min() == center_ys.max() + all_same = is_same_x & is_same_y + if all_same: + self._center_shift_xy_deg = np.array([center_xs[0], center_ys[0]]) + self._center_shift_xy_pix = self._center_shift_xy_deg / self._stim_size_deg + else: + raise ValueError( + "The center is not fixed at one location for this session: {}".format( + self.datafile_path + ) + ) + + def _get_CS_center_info(self): + """ + Creates + ------- + CS_center_pos_xy_pix : array-like, 1D + The x- and y-coordinates of the CS center in LSN pixels (origin at bottom-left). + CS_center_radius_pix : float + The radius of the CS center in LSN pixels. + """ + try: + self._get_CS_center_shift() + self.monitor_center_pix_xy = ( + np.array(self.LSN_stim.shape[-2:][::-1]) / 2 - 0.5 + ) + self.CS_center_pos_xy_pix = ( + self.monitor_center_pix_xy + self._center_shift_xy_pix + ) + CS_center_radius_deg = self._CS_center_diameter_deg / 2 + self.CS_center_radius_pix = CS_center_radius_deg / self._stim_size_deg + self._is_CS_session = True + except KeyError: + self._allow_print(True) + print("This is not a center-surround session!") + self._is_CS_session = False + + def get_RF_loc_masks(self, loc_thresh=0.8, RF_thresh=0, bin_num=1000): + """To get the boolean masks of RF locations based on their overlapping index with the centers. + + Parameters + ---------- + loc_thresh : float + The threshold for deciding whether the RF is located within the center or surround or not. + RF_thresh : float or int + The threshold of RFs to be considered. Default is 0. + bin_num : int + The number of binning for an LSN pixel when computing the overlapping indices. + Higher bin_num gives higher precision but will take longer computational time. + + Creates + ------- + location_mask_dict : dict + Dictionary containing masks for different conditions. + """ + self._get_center_overlap(RF_thresh, bin_num) + self.RF_loc_thresh = loc_thresh + ON_center = self.ON_overlap_idx >= self.RF_loc_thresh + ON_surround = self.ON_overlap_idx <= 1 - self.RF_loc_thresh + ON_border = (self.ON_overlap_idx > 1 - self.RF_loc_thresh) & ~ON_center + No_ON = ~(ON_center | ON_surround | ON_border) + OFF_center = self.OFF_overlap_idx >= self.RF_loc_thresh + OFF_surround = self.OFF_overlap_idx <= 1 - self.RF_loc_thresh + OFF_border = (self.OFF_overlap_idx > 1 - self.RF_loc_thresh) & ~OFF_center + No_OFF = ~(OFF_center | OFF_surround | OFF_border) + both_center = ON_center & OFF_center + both_surround = ON_surround & OFF_surround + both_border = ON_border & OFF_border + No_RF = No_ON & No_OFF + ON_center_alone = ON_center & No_OFF + OFF_center_alone = OFF_center & No_ON + ON_center_OFF_surround = ON_center & OFF_surround + OFF_center_ON_surround = OFF_center & ON_surround + + self.location_mask_dict = {} + self.location_mask_dict["ON_center"] = ON_center + self.location_mask_dict["ON_surround"] = ON_surround + self.location_mask_dict["ON_border"] = ON_border + self.location_mask_dict["No_ON"] = No_ON + self.location_mask_dict["OFF_center"] = OFF_center + self.location_mask_dict["OFF_surround"] = OFF_surround + self.location_mask_dict["OFF_border"] = OFF_border + self.location_mask_dict["No_OFF"] = No_OFF + self.location_mask_dict["both_center"] = both_center + self.location_mask_dict["both_surround"] = both_surround + self.location_mask_dict["both_border"] = both_border + self.location_mask_dict["No_RF"] = No_RF + self.location_mask_dict["ON_center_alone"] = ON_center_alone + self.location_mask_dict["OFF_center_alone"] = OFF_center_alone + self.location_mask_dict["ON_center_OFF_surround"] = ON_center_OFF_surround + self.location_mask_dict["OFF_center_ON_surround"] = OFF_center_ON_surround + def plot_RFs( self, title, @@ -328,10 +714,11 @@ def plot_RFs( polarity="both", num_cols=5, label_peak=True, + show_CS_center=True, contour_levels=[], ): """To plot the RFs. - + Parameters ---------- title : str @@ -347,6 +734,14 @@ def plot_RFs( contour_levels : array-like The contour levels to be plotted. """ + if label_peak: + self._get_RF_peaks_yx() + ON_RFs = [ + self._normalize_RF(self.ON_RFs[i].copy()) for i in range(self.num_cells) + ] + OFF_RFs = [ + self._normalize_RF(self.OFF_RFs[i].copy()) for i in range(self.num_cells) + ] polarity = ReceptiveFieldPolarity.from_(polarity) figsize_x = num_cols * 2 num_rows = np.ceil(len(cell_idx_lst) / num_cols).astype(int) @@ -356,9 +751,7 @@ def plot_RFs( * 1.5 ) figsize_y = figsize_x * figsize_factor - fig, axes = plt.subplots( - num_rows, num_cols, figsize=(figsize_x, figsize_y) - ) + fig, axes = plt.subplots(num_rows, num_cols, figsize=(figsize_x, figsize_y)) axes = axes.flatten() fig.tight_layout() fig.subplots_adjust( @@ -374,7 +767,7 @@ def plot_RFs( if i < len(cell_idx_lst) and cell_idx_lst[i] < self.num_cells: idx = cell_idx_lst[i] if polarity == ReceptiveFieldPolarity.ON: - pcol = ax.pcolormesh(self.ON_RFs[idx]) + pcol = ax.pcolormesh(ON_RFs[idx], cmap="coolwarm") if label_peak: ax.plot( self.ON_RF_peaks_yx[idx, 1] + 0.5, @@ -382,7 +775,7 @@ def plot_RFs( ".r", ) if polarity == ReceptiveFieldPolarity.OFF: - pcol = ax.pcolormesh(self.OFF_RFs[idx]) + pcol = ax.pcolormesh(OFF_RFs[idx], cmap="coolwarm") if label_peak: ax.plot( self.OFF_RF_peaks_yx[idx, 1] + 0.5, @@ -391,7 +784,7 @@ def plot_RFs( ) if polarity == ReceptiveFieldPolarity.BOTH: pcol = ax.pcolormesh( - self.ON_RFs[idx] + self.OFF_RFs[idx] + ON_RFs[idx] + OFF_RFs[idx], cmap="coolwarm" ) # plus because OFF_RFs are already negative. if label_peak: ax.plot( @@ -409,18 +802,27 @@ def plot_RFs( pcol.set_clim([-1, 1]) ax.set_xticks([]) ax.set_yticks([]) - ax.set_title("Cell {}".format(idx), y=0.99) + ax.set_title("Cell {}".format(self.cell_ids[idx]), y=0.99) + # ax.set_ylim(ax.get_ylim()[::-1]) + if show_CS_center: + CS_center = plt.Circle( + self.CS_center_pos_xy_pix + 0.5, + self.CS_center_radius_pix, + color="k", + fill=False, + ) + ax.add_patch(CS_center) if contour_levels: if polarity != ReceptiveFieldPolarity.ON: ax.contour( - -self.OFF_RFs[idx], + -OFF_RFs[idx], contour_levels, colors="deepskyblue", origin="lower", ) if polarity != ReceptiveFieldPolarity.OFF: ax.contour( - self.ON_RFs[idx], + ON_RFs[idx], contour_levels, colors="gold", origin="lower", @@ -433,7 +835,7 @@ def plot_pixel_avg_dff_traces( self, polarity, cell_idx, num_std=2, ax=None, **pltargs ): """To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell. - + Parameters ---------- polarity : str @@ -472,10 +874,12 @@ def plot_pixel_avg_dff_traces( .positive_part() ) else: - single_cell_data = self.trial_fluo.get_trials( - self._trial_mask - ).get_cells(cell_idx) - stimulus_highlighted = False # Add a flag so we can avoid highlighting the stimulus multiple times + single_cell_data = self.trial_fluo.get_trials(self._trial_mask).get_cells( + cell_idx + ) + stimulus_highlighted = ( + False # Add a flag so we can avoid highlighting the stimulus multiple times + ) for y in range(self.LSN_stim.shape[1]): for x in range(self.LSN_stim.shape[2]): trial_mean = single_cell_data.get_trials( @@ -502,8 +906,7 @@ def plot_pixel_avg_dff_traces( ) integration_end_sec = ( integration_start_sec - + (self._integration_window_len - 1) - * self.trial_fluo.timestep_width + + (self._integration_window_len - 1) * self.trial_fluo.timestep_width ) ax.axvspan( integration_start_sec, @@ -530,6 +933,13 @@ def plot_pixel_avg_dff_traces( def save_data(self, save_path): raise NotImplementedError + @staticmethod + def _allow_print(allowed=True): + if allowed: + sys.stdout = sys.__stdout__ + else: + sys.stdout = open(os.devnull, "w") + class ReceptiveFieldPolarity(Enum): ON = 1 diff --git a/oscopetools/greedy_pixelwise_rf.py b/oscopetools/greedy_pixelwise_rf.py new file mode 100644 index 0000000..f03104e --- /dev/null +++ b/oscopetools/greedy_pixelwise_rf.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +""" +Created on Wed May 27 22:20:46 2020 + +@author: danielm +""" + +import numpy as np +from statsmodels.sandbox.stats.multicomp import multipletests + +def get_receptive_field_greedy(L0_events, + stimulus_table, + LSN_template, + alpha=0.05, + sweep_response_type='mean'): + # INPUTS: + # + # LO_events: 1D numpy array with shape (num_2p_imaging_frames_in_session,) + # that is the timeseries of detected L0 events for the entire + # imaging session for a single ROI (e.g. cell/soma). + # stimulus_table: pandas DataFrame that contains 'start' and 'end' columns + # that indicate the imaging frames that bound the presentation + # of each stimulus frame (i.e. one frame of LSN pixels, NOT one + # monitor refresh cycle). + # + # LSN_template: 3D numpy array with shape (num_stim_frames,num_y_pixels,num_x_pixels) + # where each stimulus frame contains the locally sparse noise stimulus + # on a single trials (i.e. one row of 'stimulus_table'). + # + # alpha: the significance threshold for a pixel to be included in the RF map. + # This number will be corrected for multiple comparisons (number of pixels). + # + # sweep_response_type: Choice of 'mean' for mean_sweep_events or 'binary' to + # make boolean calls of whether any events occurred + # within the sweep window. + # + # OUTPUTS: + # + # receptive_field_on, receptive_field_off: 2D numpy arrays of the stimulus triggered + # average ('STA') receptive fields, after masking to show only + # responses for pixels that are determined to be significant + # by bootstrapping. + + # determine the type of calculation for sweep responses + if sweep_response_type == 'mean': + sweep_events = get_mean_sweep_events(L0_events,stimulus_table) + else: #to stay consistent with Nic's original analysis + sweep_events = binarize_sweep_events(L0_events,stimulus_table) + + # calculate p-values for each pixel to determine if the response is significant + pvalues_on, pvalues_off = greedy_pixelwise_pvals(sweep_events, + stimulus_table, + LSN_template, + alpha=alpha) + mask_on = pvals_to_mask(pvalues_on,alpha=alpha) + mask_off = pvals_to_mask(pvalues_off,alpha=alpha) + + A = get_design_matrix(stimulus_table,LSN_template) + + STA_on, STA_off = calc_STA(A,sweep_events,LSN_template) + + # apply mask to get only the significant pixels of the STA + receptive_field_on = STA_on * mask_on + receptive_field_off = STA_off * mask_off + + return receptive_field_on, receptive_field_off + +def calc_STA(A,sweep_events,LSN_template): + + (num_frames,num_y_pixels,num_x_pixels) = np.shape(LSN_template) + number_of_pixels = A.shape[0] // 2 + + STA = A.dot(sweep_events) + STA_on = STA[:number_of_pixels].reshape(num_y_pixels,num_x_pixels) + STA_off = STA[number_of_pixels:].reshape(num_y_pixels,num_x_pixels) + + return STA_on, STA_off + +def pvals_to_mask(pixelwise_pvals,alpha=0.05): + return pixelwise_pvals < alpha + +def greedy_pixelwise_pvals(sweep_events, + stimulus_table, + LSN_template, + alpha=0.05): + + # INPUTS: + # + # sweep_events: 1D numpy array with shape (num_sweeps,) that has the response + # on each sweep. + # + # stimulus_table: pandas DataFrame that contains 'start' and 'end' columns + # that indicate the imaging frames that bound the presentation + # of each stimulus frame (i.e. one frame of LSN pixels, NOT one + # monitor refresh cycle). + # + # LSN_template: 3D numpy array with shape (num_stim_frames,num_y_pixels,num_x_pixels) + # where each stimulus frame contains the locally sparse noise stimulus + # on a single trials (i.e. one row of 'stimulus_table'). + # + # OUTPUTS: + # + # fdr_corrected_pvalues_on, fdr_corrected_pvalues_off: 2D numpy arrays + # containing the p-values for each pixel location after + # correction for multiple comparisons. + + (num_stim_frames,num_y_pixels,num_x_pixels) = np.shape(LSN_template) + number_of_pixels = num_y_pixels * num_x_pixels + + # compute p-values for each pixel by comparing the number of sweeps with + # an event against a null distribution obtained by shuffling. + pvalues = events_to_pvalues_no_fdr_correction(sweep_events,stimulus_table,LSN_template) + + # correct the p-values for the multiple comparisons that were performed across + # all pixels, default is Holm-Sidak: + fdr_corrected_pvalues = multipletests(pvalues, alpha=alpha)[1] + + # convert to 2D pixel arrays, split by On/Off pixels + fdr_corrected_pvalues_on = fdr_corrected_pvalues[:number_of_pixels].reshape(num_y_pixels,num_x_pixels) + fdr_corrected_pvalues_off = fdr_corrected_pvalues[number_of_pixels:].reshape(num_y_pixels,num_x_pixels) + + return fdr_corrected_pvalues_on, fdr_corrected_pvalues_off + +def events_to_pvalues_no_fdr_correction(sweep_events, + stimulus_table, + LSN_template, + number_of_shuffles=20000, + seed=1): + + # get stimulus design matrix: + A = get_design_matrix(stimulus_table,LSN_template) + + # initialize random seed for reproducibility: + np.random.seed(seed) + + # generate null distribution of pixel responses by shuffling with replacement + shuffled_STAs = get_shuffled_pixelwise_responses(sweep_events, A, number_of_shuffles=number_of_shuffles) + + # p-values are the fraction of times the shuffled response to each pixel is greater than the + # actual observed response to that pixel. + actual_STA = A.dot(sweep_events) + p_values = np.mean(actual_STA.reshape(A.shape[0],1) <= shuffled_STAs,axis=1) + + return p_values + +def get_design_matrix(stimulus_table,LSN_template,GRAY_VALUE=127): + + # construct the design matrix + # + # OUTPUTS: + # + # A: 2D numpy array with size (num_pixels, num_sweeps) where each element is + # True if the pixel was active during that sweep. + + (num_stim_frames,num_y_pixels,num_x_pixels) = np.shape(LSN_template) + num_sweeps = len(stimulus_table) + num_pixels = num_y_pixels * num_x_pixels + + sweep_stim_frames = stimulus_table['frame'].values.astype(np.int) + + # check that the inputs are complete + assert np.max(sweep_stim_frames) <= num_stim_frames + + A = np.zeros((2*num_pixels, num_sweeps)) + for i_sweep,sweep_frame in enumerate(sweep_stim_frames): + A[:num_pixels, i_sweep] = (LSN_template[sweep_frame,:,:].flatten() > GRAY_VALUE).astype(float) + A[num_pixels:, i_sweep] = (LSN_template[sweep_frame,:,:].flatten() < GRAY_VALUE).astype(float) + + return A + +def binarize_sweep_events(L0_events,stimulus_table): + + # INPUTS: + # + # LO_events: 1D numpy array with shape (num_2p_imaging_frames_in_session,) + # that is the timeseries of detected L0 events for the entire + # imaging session for a single ROI (e.g. cell/soma). + # + # stimulus_table: pandas DataFrame that contains 'start' and 'end' columns + # that indicate the imaging frames that bound the presentation + # of each stimulus frame (i.e. one frame of LSN pixels, NOT one + # monitor refresh cycle). + # + # OUTPUTS: + # + # sweep_has_event: 1D numpy array of type bool with shape (num_sweeps,) + # that has a binary call for each sweep of whether or not + # the ROI had any events during the sweep. + + num_imaging_frames = len(L0_events) + last_imaging_frame_during_stim = np.max(stimulus_table['end'].values) + + assert last_imaging_frame_during_stim <= num_imaging_frames + + num_sweeps = len(stimulus_table) + sweep_has_event = np.zeros(num_sweeps, dtype=np.bool) + for i_sweep, (start_frame, end_frame) in enumerate(zip(stimulus_table['start'].values, stimulus_table['end'].values)): + + if L0_events[start_frame:end_frame].max() > 0: + sweep_has_event[i_sweep] = True + + return sweep_has_event + +def get_mean_sweep_events(L0_events,stimulus_table): + + # INPUTS: + # + # LO_events: 1D numpy array with shape (num_2p_imaging_frames_in_session,) + # that is the timeseries of detected L0 events for the entire + # imaging session for a single ROI (e.g. cell/soma). + # + # stimulus_table: pandas DataFrame that contains 'start' and 'end' columns + # that indicate the imaging frames that bound the presentation + # of each stimulus frame (i.e. one frame of LSN pixels, NOT one + # monitor refresh cycle). + # + # OUTPUTS: + # + # mean_sweep_events: 1D numpy array of type float with shape (num_sweeps,) + # that has the mean event size for each sweep for the ROI. + + num_imaging_frames = len(L0_events) + last_imaging_frame_during_stim = np.max(stimulus_table['end'].values) + + assert last_imaging_frame_during_stim <= num_imaging_frames + + num_sweeps = len(stimulus_table) + mean_sweep_events = np.zeros(num_sweeps, dtype=np.float) + for i_sweep, (start_frame, end_frame) in enumerate(zip(stimulus_table['start'].values, stimulus_table['end'].values)): + mean_sweep_events[i_sweep] = L0_events[start_frame:end_frame].mean() + + return mean_sweep_events + +def get_shuffled_pixelwise_responses(sweep_events,A,number_of_shuffles=5000): + + # OUTPUTS: + # + # shuffled_STAs: 2D numpy array with shape (num_pixels,num_shuffles) + # where each column is an STA generated from bootstrap resampling the sweep + # responses, with replacement. + + num_sweeps = len(sweep_events) + + shuffled_STAs = np.zeros((A.shape[0],number_of_shuffles)) + for i_shuffle in range(number_of_shuffles): + + shuffled_sweeps = np.random.choice(num_sweeps, size=(num_sweeps,), replace=True) + shuffled_events = sweep_events[shuffled_sweeps] + + shuffled_STAs[:,i_shuffle] = A.dot(shuffled_events) + + return shuffled_STAs From df971138a3ca9f5da7f6d41eda708d9579024dbf Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Tue, 4 May 2021 19:21:42 +0200 Subject: [PATCH 47/68] Modified get_metadata --- oscopetools/read_data/factories.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/oscopetools/read_data/factories.py b/oscopetools/read_data/factories.py index f08e036..dbfc0ef 100644 --- a/oscopetools/read_data/factories.py +++ b/oscopetools/read_data/factories.py @@ -104,12 +104,16 @@ def get_max_projection(file_path): def get_metadata(file_path): - import ast + import ast, datetime f = h5py.File(file_path, 'r') md = f.get('meta_data')[...].tolist() f.close() - meta_data = ast.literal_eval(md) + try: + meta_data = ast.literal_eval(md) + except: + dict_str = md.decode("UTF-8") + meta_data = eval(dict_str) return meta_data From 2c34809f916f1ce284b7ec7a6bca0ebde5de420e Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Tue, 4 May 2021 19:24:11 +0200 Subject: [PATCH 48/68] Added greedy pixelwise RF --- analysis/compute_and_plot_RFs.ipynb | 606 ++++++++++++++++++++++------ 1 file changed, 491 insertions(+), 115 deletions(-) diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb index 6e4ec29..95136ae 100644 --- a/analysis/compute_and_plot_RFs.ipynb +++ b/analysis/compute_and_plot_RFs.ipynb @@ -5,38 +5,17 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:25:28.028408Z", - "start_time": "2020-07-30T04:25:27.174293Z" + "end_time": "2021-05-04T17:10:51.084430Z", + "start_time": "2021-05-04T17:10:50.376025Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/kailun/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", "from oscopetools.LSN_analysis import LSN_analysis\n", - "import warnings\n", + "import os, warnings\n", "warnings.filterwarnings('ignore')\n", "%matplotlib inline" ] @@ -46,16 +25,16 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:25:28.651599Z", - "start_time": "2020-07-30T04:25:28.646742Z" + "end_time": "2020-12-04T13:29:40.104254Z", + "start_time": "2020-12-04T13:29:40.098296Z" } }, "outputs": [], "source": [ - "mpl.rcParams['figure.figsize'] = [15,10]\n", + "mpl.rcParams['figure.figsize'] = [8,5] #[15,10]\n", "mpl.rcParams['font.size'] = 20\n", "mpl.rcParams['figure.titlesize'] = 'x-large'\n", - "mpl.rcParams['axes.titlesize'] = 'medium'\n", + "mpl.rcParams['axes.titlesize'] = 'xx-small' #'medium'\n", "mpl.rcParams['axes.labelsize'] = 'small'\n", "mpl.rcParams['legend.fontsize'] = 'xx-small'\n", "mpl.rcParams['xtick.labelsize'] = 'xx-small'\n", @@ -66,57 +45,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## To initialize the analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2020-07-30T04:25:36.015226Z", - "start_time": "2020-07-30T04:25:31.134480Z" - } - }, - "outputs": [], - "source": [ - "# The path to the data file.\n", - "datafile_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround_976474801_data.h5'\n", - "# The path to the LSN stimulus npy file.\n", - "LSN_stim_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/openscope_surround-master/stimulus/sparse_noise_8x14.npy'\n", - "num_baseline_frames = 3 # int or None. The number of baseline frames before the start and after the end of a trial.\n", - "use_dff_z_score = False # True or False. If True, the cell responses will be converted to z-score before analysis.\n", - "\n", - "LSN_data = LSN_analysis(datafile_path, LSN_stim_path, num_baseline_frames, use_dff_z_score)" + "# Analyze single session" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## To get an overview of the data." + "## 1. To initialize the analysis\n", + "\n", + "**NOTE:** For more consistency in computing RFs using greedy pixelwise approach, please change the `number_of_shuffles` of the function `events_to_pvalues_no_fdr_correction` to 20000 or higher in `greedy_pixelwise_rf.py`." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:25:40.882536Z", - "start_time": "2020-07-30T04:25:40.878063Z" - } + "end_time": "2021-05-04T17:12:27.030614Z", + "start_time": "2021-05-04T17:10:56.022181Z" + }, + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround_976474801_data.h5\n", + "\n", + "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/new_data/Soma Data/Center_Surround/Center_Surround_1010436210_data.h5\n", "ON LSN stimulus value: 255\n", "OFF LSN stimulus value: 0\n", "Background LSN value: 127\n", - "LSN stimulus size: 10 degree\n", - "Number of cells: 240\n", + "LSN stimulus size: 9.3 degree\n", + "Number of cells: 14\n", + "Current RF type: Greedy pixelwise RF\n", "Use DF/F z-score: False\n", "Use corrected LSN: False\n", "Use only valid eye positions: False\n", @@ -125,32 +88,84 @@ } ], "source": [ - "print(LSN_data)" + "CS_dir = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/new_data/Soma Data/Center_Surround'\n", + "file= 'Center_Surround_1010436210_data.h5'\n", + "\n", + "# The path to the data file.\n", + "datafile_path = os.path.join(CS_dir, file)\n", + "# The path to the LSN stimulus npy file.\n", + "LSN_stim_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/openscope_surround-master/stimulus/sparse_noise_8x14.npy'\n", + "num_baseline_frames = 35 # int or None. The number of baseline frames before the start and after the end of a trial.\n", + "use_dff_z_score = False # True or False. If True, the cell responses will be converted to z-score before analysis.\n", + "correct_LSN = False # If True, the LSN stimulus corrected by eye positions will be used.\n", + "use_only_valid_eye_pos = False # Use False for greedy pixelwise RF.\n", + "use_only_positive_responses = False # If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses.\n", + "RF_type = \"Greedy pixelwise RF\" # \"Greedy pixelwise RF\" or \"Trial averaged RF\". The type of RFs to be computed.\n", + "RF_loc_thresh = 0.8 # The threshold for deciding whether the RF is located within the center or surround or not.\n", + "\n", + "LSN_data = LSN_analysis(datafile_path, LSN_stim_path, num_baseline_frames, use_dff_z_score, correct_LSN, \n", + " use_only_valid_eye_pos, use_only_positive_responses, RF_type, RF_loc_thresh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Changing parameters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Different conditions for computing ON-OFF responses and RFs\n", + "### 2.1 Different conditions for computing ON-OFF responses and RFs\n", "\n", "- Other variables (RFs, ON/OFF responses, etc.) will be automatically updated.\n", - "- The RF arrays for RF plotting will also be automatically updated with default RF parameters:\n", + "- If using trial averaged RF, the RF array will be automatically updated with default RF parameters:\n", " - threshold = 0\n", " - window_start = None (the start frame of the stimulus will be used)\n", - " - window_len = None (the stimulus trial length in frames will be used)" + " - window_len = None (the stimulus trial length in frames will be used)\n", + "- If using greedy pixelwise RF, the RF array will be automatically updated with default RF parameters:\n", + " - frame_shift = 3\n", + " - alpha = 0.05\n", + " - sweep_response_type = 'mean'\n", + " - chisq_significant_lvl = 0.05\n", + " - norm_RF = False\n", + "- The overlapping index and RF location masks will be updated with:\n", + " - loc_thresh = LSN_data.RF_loc_thresh\n", + " - RF_thresh = 0\n", + " - bin_num = 1000" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T03:58:17.524670Z", - "start_time": "2020-07-30T03:58:17.286905Z" + "end_time": "2021-04-28T18:52:25.838910Z", + "start_time": "2021-04-28T18:51:17.363356Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround/Center_Surround_986765043_data.h5\n", + "ON LSN stimulus value: 255\n", + "OFF LSN stimulus value: 0\n", + "Background LSN value: 127\n", + "LSN stimulus size: 9.3 degree\n", + "Number of cells: 41\n", + "Current RF type: Greedy pixelwise RF\n", + "Use DF/F z-score: False\n", + "Use corrected LSN: True\n", + "Use only valid eye positions: False\n", + "Use only positive fluorescence responses: False\n" + ] + } + ], "source": [ "# If True, the LSN stimulus corrected by eye positions will be used. \n", "# Otherwise, the original LSN stimulus will be used.\n", @@ -160,14 +175,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T03:44:49.129003Z", - "start_time": "2020-07-30T03:44:48.718561Z" - } + "end_time": "2021-04-28T18:53:34.045341Z", + "start_time": "2021-04-28T18:52:26.288125Z" + }, + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Failed to change use_valid_eye_pos to True! \n", + "Recomputing the responses with use_valid_eye_pos(False)...\n", + "\n", + "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround/Center_Surround_986765043_data.h5\n", + "ON LSN stimulus value: 255\n", + "OFF LSN stimulus value: 0\n", + "Background LSN value: 127\n", + "LSN stimulus size: 9.3 degree\n", + "Number of cells: 41\n", + "Current RF type: Greedy pixelwise RF\n", + "Use DF/F z-score: False\n", + "Use corrected LSN: True\n", + "Use only valid eye positions: False\n", + "Use only positive fluorescence responses: False\n" + ] + } + ], "source": [ "# If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used.\n", "use_only_valid_eye_pos = True\n", @@ -176,14 +213,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T03:44:46.396178Z", - "start_time": "2020-07-30T03:44:45.990706Z" + "end_time": "2021-04-28T18:54:43.267779Z", + "start_time": "2021-04-28T18:53:34.466998Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analyzing file: /home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/Multiplex/Center_Surround/Center_Surround_986765043_data.h5\n", + "ON LSN stimulus value: 255\n", + "OFF LSN stimulus value: 0\n", + "Background LSN value: 127\n", + "LSN stimulus size: 9.3 degree\n", + "Number of cells: 41\n", + "Current RF type: Greedy pixelwise RF\n", + "Use DF/F z-score: False\n", + "Use corrected LSN: True\n", + "Use only valid eye positions: False\n", + "Use only positive fluorescence responses: True\n" + ] + } + ], "source": [ "# If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses.\n", "use_only_positive_responses = True\n", @@ -194,16 +250,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## RF plotting" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting parameters\n", + "### 2.2 Different RF types\n", "\n", - "- The RFs are computed during initialization with default parameters. \n", + "- The RFs were computed during initialization with default parameters. \n", + "\n", + "#### 2.2.1 Trial averaged RF\n", "- The threshold and integration window for RFs can be changed.\n", "- To compute the RFs by using different thresholds (default = 0) and different integration windows by adjusting:\n", " - window_start:\n", @@ -214,26 +265,166 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:26:34.676148Z", - "start_time": "2020-07-30T04:26:34.669444Z" + "end_time": "2021-04-29T20:48:58.119426Z", + "start_time": "2021-04-29T20:48:58.114767Z" } }, "outputs": [], "source": [ "threshold = 0. # int or float, range = [0, 1]. The threshold for the RF, anything below the threshold will be set to 0.\n", - "window_start = 5 # int or None. The start index (within a trial) of the integration window for computing the RFs.\n", - "window_len = 7 # int or None. The length of the integration window in frames for computing the RFs.\n", - "LSN_data.get_RFs(threshold, window_start, window_len)" + "window_start = num_baseline_frames + 3 # int or None. The start index (within a trial) of the integration window for computing the RFs.\n", + "window_len = 7 * 3 # int or None. The length of the integration window in frames for computing the RFs.\n", + "LSN_data.get_trial_avg_RFs(threshold, window_start, window_len)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.2.2 Greedy pixelwise RF\n", + "\n", + "- frame_shift: The frame shift of the window to account for the delay in calcium responses for the Chi-square test. Default is 3.\n", + "- alpha: The significance threshold for a pixel to be included in the RF map. This number will be corrected for multiple comparisons (number of pixels).\n", + "- sweep_response_type: Choice of 'mean' for mean_sweep_events or 'binary' to make boolean calls of whether any events occurred within the sweep window.\n", + "- chisq_significant_lvl: The significance threshold of the Chi-square test p-values for the RF pixels to be included.\n", + "- norm_RF: If True, the computed RFs will be normalized to their corresponding max value." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-28T21:05:43.323504Z", + "start_time": "2021-04-28T21:04:56.163404Z" + } + }, + "outputs": [], + "source": [ + "frame_shift = 3 # int\n", + "alpha = 0.05 # float\n", + "sweep_response_type = 'mean' # str\n", + "chisq_significant_lvl = 0.05 # float\n", + "norm_RF = False # bool\n", + "LSN_data.get_greedy_RFs(frame_shift, alpha, sweep_response_type, chisq_significant_lvl, norm_RF)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Using different location thresholds\n", + "\n", + "To get the boolean masks of RF locations based on their overlapping index with the centers. This has to be recomputed if changed the RF type in section 2.2 but is auto-recomputed if changed conditions in section 2.1 with deefault parameters.\n", + "- loc_thresh ($\\vartheta$): The threshold for deciding whether the RF is located within the center or surround or not.\n", + "- RF_thresh: The threshold of RFs to be considered. Default is 0.\n", + "- bin_num ($n$): The number of binning for an LSN pixel when computing the overlapping indices. Higher bin_num gives higher precision but will take longer computational time." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$ S_i^{P} (\\vec x_c, r_c) = \\frac {\\sum_{\\vec x} R(\\vec x, \\vec x_c, r_c) \\Psi_i^P(\\vec x)} {\\sum_{\\vec x} \\Psi_i^P(\\vec x)}, P \\in \\{ \\text{ON}, \\text{OFF} \\} $$\n", + "\n", + "\\begin{split}\n", + "R(\\vec x, \\vec x_c, r_c) &= \n", + "\\begin{cases}\n", + "1, & \\text{if } \\left\\Vert \\vec x - \\vec x_c \\right\\Vert_2 \\leq r_c \\\\\n", + "0, & \\text{otherwise}\n", + "\\end{cases}\n", + "\\end{split}\n", + "\n", + "$$ \\vec x \\in \\left\\{ \n", + " \\begin{bmatrix}\n", + " -0.5 + \\frac{i}{n} \\\\\n", + " -0.5 + \\frac{j}{n}\n", + " \\end{bmatrix}\n", + " \\Bigg| \\forall i \\in \\left[ 0 .. 14n \\right], \\forall j \\in \\left[ 0 .. 8n \\right] , n \\in \\mathbb{Z}^+\n", + "\\right\\} $$\n", + "\n", + "$$ \\vec x_c = \n", + " \\begin{bmatrix}\n", + " 6.5 \\\\\n", + " 3.5\n", + " \\end{bmatrix} +\n", + " \\begin{bmatrix}\n", + " x_{\\text{shift}} \\\\\n", + " y_{\\text{shift}}\n", + " \\end{bmatrix} $$\n", + "\n", + "$$ r_c: \\text{The radius of the CS center in LSN pixels} $$\n", + "\n", + "$$ n: \\text{The number of bins per LSN pixel} $$\n", + "\n", + "$$ x_{\\text{shift}}, y_{\\text{shift}}: \\text{The x- and y-shifts of the CS center in LSN pixels} $$\n", + "\n", + "$$ \\Psi_i^P(\\vec x): \\text{ON or OFF receptive subfield of } i \\text{th cell} $$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell.\n", + "\\begin{split}\n", + "G_i^P &= \n", + "\\begin{cases}\n", + "\\text{Center}, & \\text{if } S_i^P \\geq \\vartheta \\\\\n", + "\\text{Surround}, & \\text{if } S_i^P \\leq 1 - \\vartheta \\\\\n", + "\\text{Border}, & \\text{if } 1 - \\vartheta < S_i^P < \\vartheta \\\\\n", + "\\text{No } P \\text{ subfield}, & \\text{otherwise}\n", + "\\end{cases}\n", + "\\end{split}\n", + "\n", + "\\begin{split}\n", + "G_i &= \n", + "\\begin{cases}\n", + "\\text{Both center}, & \\text{if } S_i^{\\text{ON}} \\geq \\vartheta \\text{ and } S_i^{\\text{OFF}} \\geq \\vartheta \\\\\n", + "\\text{Both surround}, & \\text{if } S_i^{\\text{ON}} \\leq 1 - \\vartheta \\text{ and } S_i^{\\text{OFF}} \\leq 1 - \\vartheta \\\\\n", + "\\text{Both border}, & \\text{if } 1 - \\vartheta < S_i^{\\text{ON}} < \\vartheta \\text{ and } 1 - \\vartheta < S_i^{\\text{OFF}} < \\vartheta \\\\\n", + "\\text{ON center alone}, & \\text{if } S_i^{\\text{ON}} \\geq \\vartheta \\text{ and no OFF subfield} \\\\\n", + "\\text{OFF center alone}, & \\text{if } S_i^{\\text{OFF}} \\geq \\vartheta \\text{ and no ON subfield} \\\\\n", + "\\text{ON center OFF surround}, & \\text{if } S_i^{\\text{ON}} \\geq \\vartheta \\text{ and } S_i^{\\text{OFF}} \\leq 1 - \\vartheta \\\\\n", + "\\text{OFF center ON surround}, & \\text{if } S_i^{\\text{OFF}} \\geq \\vartheta \\text{ and } S_i^{\\text{ON}} \\leq 1 - \\vartheta \\\\\n", + "\\text{No RF}, & \\text{otherwise}\n", + "\\end{cases}\n", + "\\end{split}\n", + "\n", + "$$ \\vartheta: \\text{The overlapping threshold for determining whether a receptive subfield is within the CS center or not} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T14:26:33.803769Z", + "start_time": "2021-04-30T14:26:31.116209Z" + } + }, + "outputs": [], + "source": [ + "loc_thresh = 0.8 # float\n", + "RF_thresh = 0 # float or int\n", + "bin_num = 1000 # int\n", + "LSN_data.get_RF_loc_masks(loc_thresh, RF_thresh, bin_num)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Plotting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1 To plot the trial-averaged responses within pixels (all pixels of the LSN stimulus) for a cell.\n", "\n", "- To visualize the integration window of the RF (blue) relative to the stimulus (gray).\n", "- Each line plot is the average ON or OFF response of the selected cell on a square pixel of the LSN stimulus.\n", @@ -242,18 +433,32 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:26:44.643252Z", - "start_time": "2020-07-30T04:26:43.646534Z" + "end_time": "2021-05-04T16:19:08.396114Z", + "start_time": "2021-05-04T16:19:08.392295Z" + } + }, + "outputs": [], + "source": [ + "idx = iter(range(LSN_data.num_cells))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-04T16:19:10.040290Z", + "start_time": "2021-05-04T16:19:09.094028Z" }, "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4YAAAJsCAYAAACh271dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3xkZ3n3/889fUZ9V6tdbS/e6ra2FxuwDaaZXkIJEAjkoYUA4UcCBFIecArdBIcngHESaqgxJTY2xRhs3O317rpt8TbtSlp1aaTp9f79cWa0klZ9JI3K9/167WulmTPn3GpzznWu+74uY61FREREREREli5XuQcgIiIiIiIi5aXAUEREREREZIlTYCgiIiIiIrLEKTAUERERERFZ4hQYioiIiIiILHEKDEVERERERJY4BYYiIjKvGWM2GmOsMcZT+PwuY8y7ZnD/PzDGvGam9idjM8b8pTHmc+Ueh4iInEuBoYiIzAljzJ8YY/YaY6LGmDZjzC+NMVfN8DEuMMb82hjTbYyZsFGvMeYi4GLgf4c8ttYY8z1jTI8xJmaMedgY84oRr7OF56KFf+HC49cYY/JDHo8aY26dya9xgfsP4C3GmIZyD0RERIZTYCgiIrPOGPPXwA3Ap4GVwHrgq8CrZ/hQGeDHwDsnuf2fA9+z1trCOJcB9wJp4HygHvgS8H1jzOtHvPZia21l4V/tkMfPDHm80lr7yskMxBjjnuSYFyxrbRL4JfC2co9FRESGU2AoIiKzyhhTA/wT8H5r7U+ttTFrbcZae6u19qOFbVzGmI8bY44XMnU/LgRpU2KtPWKt/S/gqUm+5KXA3UM+/ysgCrzTWtturU1Ya38AfAr4ojHGTHVMYzHGfMsY8zVjzO3GmBjwPGPMamPMT4wxXcaYk8aYDw7Z/vJCxnXAGNNhjPnXwuPFqbbvMcacKWRjPzLkdX5jzA2F584UPvYXnrvGGNNijPmwMaaz8Nr/M+S1LzPGHDTGRIwxrSP2+wpjzAFjTNgYc38h+1p87mOF7SPGmCPGmBcM+dLvAl4+U99HERGZGQoMRURktj0LCAA/G2ebvwReAzwXWA30AV+ZzUEZYyqATcCRIQ+/CPiJtTY/YvMf42Q5t83wMP4EJ+isAu4HbgUeA9YALwA+ZIx5cWHbfwP+zVpbDWwpjGmo5wFbgWuBjxljXlh4/O+BZwK7cabNXg78w5DXrQJqCsd8J/AVY0xd4bn/Av7cWlsFXAD8DsAYcwnwDZyM63Lg68AthSB0O/AB4BmF170YaBpyvEOFcYiIyDyiwFBERGbbcqDbWpsdZ5v3An9vrW2x1qaA64DXFwvOzJLawv+RIY/VA22jbNs25PmifYVsWdgY8+Uhj68e8njYGPPH44zhf6219xUC0QuBFdbaf7LWpq21J3DW5L2psG0GOM8YU2+tjVprHxyxr38sZGOfAL4JvLnw+FuAf7LWdlpru4B/BP50yOsyhecz1trbcTKm24c8t8sYU22t7bPW7is8/h7g69bah6y1OWvtt4EUTgCaA/yF13mttU3W2uNDjhfBCURFRGQeUWAoIiKzrQeonyDI2wD8rBhM4WSVcjjrEWdLuPB/1ZDHuoHGUbZtHPJ80aXW2trCvw8OefzMkMdrrbUjM3tDNQ/5eAMjgkrg7zj7PXgnTsbysDHmkZEFcUbs6xRO5pXC/6fGeA6gZ0TQHgcqCx+/DngZcMoYc7cx5llDxvrhEWNdB6y21h4DPoQT3HcaY35ojBl6vCqgf9TvhoiIlI0CQxERmW0P4GSTXjPONs3AS0cEVAFrbetsDcpaGwOOM3x66G+B1xpjRp4f/7gwxqdnehhDPm4GTo74HlRZa19WGO9Ra+2bgQbgc8DNhemwReuGfLweOFP4+AxOIDfac+MPztpHrLWvLhzz55ydvtoMfGrEWEOF9ZhYa79vrb2qcFxbGG/RTpzpsiIiMo8oMBQRkVllre0HPoGzdu01xpiQMcZrjHmpMebzhc1uBD5ljNkAYIxZYYyZcsVS4wgAvsLngWKhlTHcjrOusehLONMc/8sYs6rw+jfjrNP7aLF66Sx5GIgUCrcEjTFu47TfeAaAMeatxpgVhWmn4cJrhq6F/L+F7+35wP8BflR4/AfAPxS+p/U4P4v/nmgwxhifMeYtxpgaa20GGBhyvP8A3muMuaLwPa8wxrzcGFNljNlujHl+4fueBBIjxvlcnMqkIiIyjygwFBGRWWet/SLw1zhFT7pwMk4fwMlCgVNY5RbgN8aYCPAgcMU0DrUBJxApViVNMLy4zEg34fTVM4Vx9gBX4RTLOYgzDfavgT+11v5ozL3MAGttDngFTpGYkzjTVv+Ts+vxXgI8ZYyJ4ny/3mStTQzZxd3AMeBO4Hpr7W8Kj/8LsBd4HHgC2Fd4bDL+FGgyxgzgrAN9S2Gse4F3A/+OUyjoGPBnhdf4gc8Wxt+Ok238W3ACdZypqd+e5PFFRGSOmNm9+SkiIjK/GWO+D/zYWvvzco9lOowxG3ECSe8EBX7Kzhjzl8A6a+3flHssIiIynAJDERGRBWwhBYYiIjJ/aSqpiIiIiIjIEqeMoYiIiIiIyBKnjKGIiIiIiMgSp8BQRGQRMcZcbYwZrwrn0G3/zBhz72yPab4xxjQZY15Y7nEsZsaYXxpj3j7O898yxoxZGdUYEzXGbJ6Fcf2dMeY/Z2A/1hhz3kyMSURkvlBgKCIyzxUukov/8saYxJDP3zJ0W2vtPdba7eUa60JXCFjSxphI4d+TxpjPGGNqhmzzZ8aY3Iify7+P2M8RY8y2Ifsbuu0bxzj2ogk2rLUvtdZ+G6Z3A8JaW2mtPTEL4/q0tfZdM71fEZHFQIGhiMg8V7hIrrTWVgKngVcOeex7xe2MMZ7yjXL6jDHuco9hhM9ba6uAFTiN4p8J3GeMqRiyzQNDfy7W2g8UnzDGbAHc1tqnh+xv6LbT6oe4UH++IiKyMCgwFBFZoIwx1xhjWowxHzPGtAPfLD42ZJuPG2OOF7JfB40xfzSF/b/cGLPfGDNgjGk2xlw35LlfGmM+MGL7x4wxry18vMMYc4cxpreQPfvjIdt9yxjzNWPM7caYGPC88Y5VeM3bjDGnjDE9xpj/O3Q6qDHGNeTr7DHG/NgYs2zIa/90yGv/frJfv7U2aa19BHgVsBwnSJyMlwO3T/Y4hTH+ofDhY8Ws4hg/3zpjzC+MMV3GmL7Cx2uH7GeZMeabxpgzhed/PuS5VxhjDhhjwsaY+40xFw157mPGmNbC78kRY8wLRhnjpsJrXYXP/8MY0znk+e8aYz5U+PguY8y7jDE7gRuBZxW+rvCQXdYZY24rHPOhQkBd3Ndg9rTw+/KVsbYdMcaNhde+p/A9aDPGfGTI89cZY/678PEbjTEnjTHVhc9faoxpN8asKHz+DmPMocL38dfGmA3j/xRFRBY2BYYiIgvbKmAZsAF4zyjPHweuBmqAfwT+2xjTOMl9x4C3AbU4wc5fGGNeU3juB8CbixsaY3YVxnCbcTJrdwDfBxqANwFfLWxT9CfAp4Aq4N7xjlV43VeBtwCNha9lzZB9/SXwGuC5wGqgD/jKkNd+DfjTwnPLgbVMgbU2Uvh6rp7kS14G3DbFYzyn8OHFI7KKI3++LuCbhc/XAwlg6DTW7wIh4Hyc7/2XAIwxlwDfAP4c53vwdeAWY4zfGLMd+ADwjEKm9MVA0yhjPAkMAJcUHnoOEC0Ef+B8/+8e8ZpDwHs5m2GtHfL0m3B+J+uAYzi/D2OZyrYAzwO2AtcCHzOjrCktfI/vB75sjFkO/BfwLmttlzHm1cDfAa/FyRzfg/M7LyKyaCkwFBFZ2PLAJ621KWttYuST1tr/sdaesdbmCxfCR4HLJ7Nja+1d1tonCq99HOfC+LmFp38G7B6SRXkL8FNrbQp4BdBkrf2mtTZrrd0P/AR4w5Dd/6+19r7CvpMTHOv1wK3W2nuttWngE8DQXkvvBf7eWttSOP51wOuNM/Xy9cAvrLV/KDz3fwvfs6k6gxOgFT2zkD0r/nsmgDEmBDwDuGvIth8Zsl33FI877Odrre2x1v7EWhsvBKyfovB9KgT8LwXea63ts9ZmrLXFQO09wNettQ9Za3OF9X8pnGmyOcAP7DLGeK21Tdba42OM527gucaYVYXPby58vgmoBh6bwtf2M2vtw9baLPA9YPcMbQvwj9bamLX2CZxA+s1jbPd+4Pk4P69brbW/KDz+XuAz1tpDhWN+muG/7yIii44CQxGRha3LWpsc68nCFMzi9MEwcAFQP8p2f2fOFke5sfDYFcaY3xemLfbjXCzXw2AW7TacTA44F97F9Y4bgCuGBk44geOqIYdsHnH8MY+Fk+kb3N5aGwd6hrx8A/CzIcc6hBPsrBzltbERr52sNUDvkM8ftNbWDvn3YOHxFwD3F4LQouuHbHfO934Cw36+xpiQMebrxpkaOwD8Aag1zjrNdUCvtbZvlP1sAD484meyDlhtrT0GfAgnoO40xvzQGLN6jPHcDVyDky38A05A9dzCv3ustVMJutuHfBwHKmdoWxj++3UK5/fgHNbaMPA/OH8XXxzy1Abg34Z8r3oBw/BMtYjIoqLAUERkYbNjPVHIbvwHzjTB5YVpfE/iXOAO34lTrbFYHOW9hYe/D9wCrLPW1uCsFRv62h8AbzbGPAsIAL8vPN4M3D0icKq01v7FOOMe71htDJn+aYwJ4kyHLGoGXjrieAFrbWvhteuGvDY04rUTMsZUAi/EmU44kZcxxfWFExj5ffowsB24wlpbjROggfO9agaWGWNqR9lPM/CpEd+jkLX2BwDW2u9ba6/CCYgs8LkxxnM3zpTaawof3wtcySjTSMf5GubCuiEfr8fJ+J7DGLMbeAfO7/KXhzzVDPz5iO9X0Fp7/2wNWESk3BQYiogsXhU4F+VdAMaY/4OTGZmsKpwMVNIYcznOusChbscJJP4J+NGQbNEvgG3GKfriLfx7xpC1aFM91s3AK40xzzbG+HAyW0MD1BuBTxWn+RljVhTWiBVf+wpjzFWF1/4Tkzz3FdbfXQb8HGfd4jcn8bKXMsX1hUN0ABP17qvCWVcYNk6BnU8Wn7DWtgG/xFnPWVf4vhcDx/8A3lvIzBpjTIVxCv5UGWO2G2Oeb4zxA8nC/kfN/FlrjxaefytO8D9QGPfrGDsw7ADWFr7/c+X/FrKr5+MUDTqnEqwxJgD8N85awv8DrDHGvK/w9I3A3xZejzGmxhjzhpH7EBFZTBQYiogsUtbagzjT4x7AuTi/ELhvCrt4H/BPxpgIzrq+H4/Yfwr4KU427ftDHo/gFP14E06mph0nA+WfzrGstU/hFJj5IU4GMAp04qyRA/g3nGzjbwqvfxC4Yshr318YXxtOgDdYtXUMf1PYTw/wHeBR4NmFaahjMsZcAESttacn2P9YrgO+XZi++MdjbHMDEAS6cb7OX414/k+BDHAY53v0IQBr7V7g3TiFavpwCrj8WeE1fuCzhX224xSt+dtxxnk30GOtbR7yuQH2jbH974CngPZprLGcrrtxvsY7caby/maUbT4DNFtrv1b4XX4r8C/GmK3W2p/h/M7+sDBl90mcoF9EZNEy1pZjhoeIiMj0FKZ2hoGt1qmUOS8YY/4GqLfW/k25x7JUGWM2AicBb6FojIiITJIyhiIiMu8ZY15ZmBpYAVwPPMEoLRXKrInJTTcVERGZdxQYiojIQvBqnGmpZ3D6073JzrMpL9baH1unb5+IiMiCo6mkIiIiIiIiS5wyhiIiIiIiIkucAkMREREREZElzlPuAcyl+vp6u3HjxnIPQ0REyiyZTJLL5eb8uDmXm+EtGOeIMXjc7nIclqBn7o8rIiJje/TRR7uttStGPr6kAsONGzeyd+/ecg9DRETK7JFHHqG6unrOj9tCAB9zv7Y/lUqxevXqOT9uPJNlT2PdnB9XRETGZow5NdrjmkoqIiIiIiKyxCkwFBERERERWeIUGIqIiIiIiCxxS2qNoYiIiIjIfJbJZGhpaSGZTJZ7KLLABQIB1q5di9frndT2CgxFREREROaJlpYWqqqq2LhxI8aUoYqxLArWWnp6emhpaWHTpk2Teo2mkoqIiIiIzBPJZJLly5crKJSSGGNYvnz5lDLPCgxFREREROYRBYUyE6b6e6TAUEREREREhvnUpz7F+eefz0UXXcTu3bt56KGHuOGGG4jH44PbvOxlLyMcDs/I8SorK2dkPzJ9WmMoIiIiIjJPHTx4kFgsNmP7q6ioYNeuXeNu88ADD/CLX/yCffv24ff76e7uJp1O88Y3vpG3vvWthEIhAG6//fYZG5eUnzKGIiIiIiLzVCwWo7q6esb+TSbIbGtro76+Hr/fD0B9fT0333wzZ86c4XnPex7Pe97zANi4cSPd3d00NTWxY8cO/uzP/oxt27bxlre8hd/+9rdceeWVbN26lYcffhiA6667juuvv37wOBdccAFNTU3Djn3XXXfxile8YvDzD3zgA3zrW98C4OMf/zi7du3ioosu4iMf+Ugp31YZhQJDEREREREZdO2119Lc3My2bdt43/vex913380HP/hBVq9eze9//3t+//vfn/OaY8eO8eEPf5jDhw9z+PBhvv/973Pvvfdy/fXX8+lPf7rkMfX09PCzn/2Mp556iscff5x/+Id/KHmfMpwCQxERERERGVRZWcmjjz7KTTfdxIoVK3jjG984mLUby6ZNm7jwwgtxuVycf/75vOAFL8AYw4UXXnhOVnA6ampqCAQCvPOd7+SnP/3p4HRWmTlaYygiIiIiIsO43W6uueYarrnmGi688EK+/e1vj7t9cdopgMvlGvzc5XKRzWYB8Hg85PP5we1Ga6Uw1jYej4eHH36YO++8k5tvvpl///d/53e/+930v0A5hzKGIiIiIiIy6MiRIxw9enTw8wMHDrBhwwaqqqqIRCLT3u/GjRvZt28fAPv27ePkyZPnbLNhwwYOHjxIKpUiHA5z5513AhCNRunv7+dlL3sZX/rSl3jsscemPQ4ZnTKGIiIiIiIyKBqN8pd/+ZeEw2E8Hg/nnXceN910Ez/4wQ94yUteMrjWcKpe97rX8Z3vfIfzzz+fK664gm3btp2zzbp16/jjP/5jLrjgAjZt2sQll1wCQCQS4dWvfjXJZBJrLf/6r/9a8tcpwxlrbbnHMGf27Nlj9+7dW+5hiIhImT3yyCNUV1fP+XFbCOBj7s+7qVSK1atXz/lx45ksexrr5vy4IgvZoUOH2Llz5+Dn5WhXIYvHyN8nAGPMo9baPSO3VcZQRERERGSeUhAnc0VrDEVERERERJY4BYYiIiIiIiJLnAJDERERERGRJU6BoYiIiIiIyBKnwFBERERERGSJU2AoIiIiZXN/X5R3PnmSbH7ptM8Sme/cbje7d+/mggsu4JWvfCXhcBiApqYmgsEgu3fvHvyXTqeHvXbv3r188IMfHHf/4XCYr371q7M1/GHuuusu7r///sHPb7zxRr7zne/MybGf/exnT2n7u+66i1e84hWzNJqJqV2FiIiIlM0vu8Pc1tXPA+EoVy+rKvdwROadp7oHSGRyM7a/oNfN+fXj93ENBoMcOHAAgLe//e185Stf4e///u8B2LJly+Bzo9mzZw979pzTIm+YYmD4vve9b0pjH0s2m8XjGT2sueuuu6isrBwM0t773vfOyDEnY2hAuhAoYygiIiJlczyeAuAXXeHyDkRknkpkcoS8nhn7N9Ug81nPehatra2T3n5o1uu6667jHe94B9dccw2bN2/my1/+MgAf//jHOX78OLt37+ajH/0oAF/4whd4xjOewUUXXcQnP/nJwf398z//M9u3b+eqq67izW9+M9dffz0A11xzDR/60IfYs2cP//Zv/8att97KFVdcwSWXXMILX/hCOjo6aGpq4sYbb+RLX/oSu3fv5p577uG6664b3MeBAwd45jOfyUUXXcQf/dEf0dfXN7jvj33sY1x++eVs27aNe+6555yv8/3vfz+33HILAH/0R3/EO97xDgC+8Y1vDAbRlZWVg9+Ta665hte//vXs2LGDt7zlLVjrzJL41a9+xY4dO7j00kv56U9/Orj/3t5eXvOa13DRRRfxzGc+k8cffxyACy+8kHA4jLWW5cuXD2Y/3/a2t3HHHXdM+uc0GgWGIiIiUjYnEk5g+MvufvJW00lF5pNcLsedd97Jq171qsHHigHd7t27ef/73z/hPg4fPsyvf/1rHn74Yf7xH/+RTCbDZz/72cHM4xe+8AV+85vfcPToUR5++GEOHDjAo48+yh/+8AceeeQRfvKTn/DYY4/xy1/+kr179w7bdzqdZu/evXz4wx/mqquu4sEHH2T//v286U1v4vOf/zwbN27kve99L3/1V3/FgQMHuPrqq4e9/m1vexuf+9znePzxx7nwwgv5x3/8x8HnstksDz/8MDfccMOwx4uuvvrqwYCxtbWVgwcPAnDPPffwnOc855zt9+/fzw033MDBgwc5ceIE9913H8lkkne/+93ceuutPProo7S3tw9u/8lPfpJLLrmExx9/nE9/+tO87W1vA+DKK6/kvvvu46mnnmLz5s2DY3jggQemPHV1JE0lFRERkbJI5/M0J9NsCfo5nkixtz/G5bWV5R6WyJKXSCTYvXs3ra2t7Ny5kxe96EWDz000lXSkl7/85fj9fvx+Pw0NDXR0dJyzzW9+8xt+85vfcMkllwAQjUY5evQokUiEV7/61QQCAQKBAK985SuHve6Nb3zj4MctLS288Y1vpK2tjXQ6zaZNm8YdV39/P+FwmOc+97mAM2X2DW94w+Dzr33tawG47LLLaGpqOuf1V1999WCgt2vXLvr6+mhra+OBBx4YzIwOdfnll7N27VoAdu/eTVNTE5WVlWzatImtW7cC8Na3vpWbbroJgHvvvZef/OQnADz/+c+np6eHgYEBrr76av7whz+wYcMG/uIv/oKbbrqJ1tZW6urqqKioGPdrnogyhiIiIlIWp5NpchbeubYenzHc1tVf7iGJCGfXGJ46dQprLV/5ylemvS+/3z/4sdvtJpvNnrONtZa//du/5cCBAxw4cIBjx47xzne+c8J9Dw2E/vIv/5IPfOADPPHEE3z9618nmUxOe8xDxz3WmNesWUM4HOZXv/oVz3nOc7j66qv58Y9/TGVlJVVV566Xnsz3YTKe85zncM8993DPPfdwzTXXsGLFCm6++eZzsqHTocBQREREyuJEYX3hxVUhnrusitu6w4PrbkSk/EKhEF/+8pf54he/OO1AZjRVVVVEIpHBz1/84hfzjW98g2g0CjhTMzs7O7nyyiu59dZbSSaTRKNRfvGLX4y5z/7+ftasWQPAt7/97TGPVVRTU0NdXd3gVMzvfve7g9nDyXrmM5/JDTfcMBgYXn/99VMK0Hbs2EFTUxPHjx8H4Ac/+MHgc1dffTXf+973AGeNYn19PdXV1axbt47u7m6OHj3K5s2bueqqq7j++utHnb46VQoMRUREpCyKhWc2h/y8fEUNLckMj0cTZR6ViAx1ySWXcNFFFw0LWkq1fPlyrrzySi644AI++tGPcu211/Inf/InPOtZz+LCCy/k9a9/PZFIhGc84xm86lWv4qKLLuKlL30pF154ITU1NaPu87rrruMNb3gDl112GfX19YOPv/KVr+RnP/vZYPGZob797W/z0Y9+lIsuuogDBw7wiU98Ykpfx9VXX002m+W8887j0ksvpbe3d0qBYSAQ4KabbuLlL385l156KQ0NDcO+nkcffZSLLrqIj3/848OC3SuuuIJt27YNjqG1tZWrrrpqSmMfjVlKd+b27NljRy5aFRGRpeeRRx6hunr8cu2zoYUAPub+vJtKpVi9evWcHzeeybKnsW7M5//mSDO/6Apz8KoL6c1kufC+J3n/ugb+bsvcj1Vkvjh06BA7d+4c/Lwc7Srmk2g0SmVlJfF4nOc85zncdNNNXHrppeUe1oIx8vcJwBjzqLX2nJ4iKj4jIiIiZXE8nmJz0Fl3s8zr4craSm7r6udvNzdijCnz6ETmh4UUxM2G97znPRw8eJBkMsnb3/52BYWzSIGhiIiIlMWJRIqr6s5WIX35ilo+9nQLh2NJdlYGyzgyEZkvvv/975d7CEuG1hiKiIjInIvlcrSlMmwJnq3U99L6GgyoOqmISBkoMBQREZE515RIA7A5FBh8rMHv5YqaCm7vCpdpVCIiS5cCQxEREZlzgxVJg75hj79sRQ0HY0lOFp4XEZG5ocBQRERE5tyJuNN8etOQqaQAL1tRC8AvlDUUEZlTCgxFRERkzp1IpGj0e6nwuIc9vjbgY3dVSOsMRUTmmAJDERERmXMnhrSqGOnlK2o4EInTkkzP8ahERJYuBYYiIiIy504kUmwOjRUY1gLwS2UNRcrGGMNb3/rWwc+z2SwrVqzgFa94RRlHdVZzczPPe97z2LVrF+effz7/9m//NunXhsNhvvrVr475/HXXXcf1118/E8NcUNTHUEREROZUXyZLbyY3ZsZwc8jPzooAt3WFefe6FXM8OpH55YH4A0TykRnbX5WrimeFnjXhdhUVFTz55JMkEgmCwSB33HEHa9asmbFxTOSuu+7iW9/6Ft/61rdGfd7j8fDFL36RSy+9lEgkwmWXXcaLXvQidu3aNeG+i4Hh+973vhke9cKmjKGIiIjMqWLF0S1jZAzByRo+1B+jM5WZq2GJzEuRfIRqd/WM/ZtKkPmyl72M2267DYAf/OAHvPnNbx587r//+7+5/PLL2b17N3/+539OLpcD4DWveQ2XXXYZ559/PjfddBMATU1N7Ny5k3e/+92cf/75XHvttSQSiZK+L42NjVx66aUAVFVVsXPnTlpbW8/ZLhaL8fKXv5yLL76YCy64gB/96Ed8/OMf5/jx4+zevZuPfvSjAHzqU59i27ZtXHXVVRw5cqSksS1UCgxFRERkTh1PFFpVjBsY1mCBX3ZrOqlIubzpTW/ihz/8Iclkkscff5wrrrgCgEOHDvGjH/2I++67jwMHDuB2u/ne974HwDe+8Q0effRR9u7dy5e//GV6enoAOHr0KO9///t56qmnqK2t5Sc/+cmox7ziiivYvXs373rXu7jlllvYvXs3u3fv5te//vWY42xqamL//v2D4xvqV7/6FatXr+axxx7jySef5CUveQmf/exn2bJlCwcOHOALX/gCjz76KD/84Q85cOAAt99+O4888kip37oFSVNJRUREZE6diKdwAesDvjG32VERYEvQz+1d/bx9Tf3cDU5EBl100UU0NTXxgx/8gJe97GWDj9955508+uijPOMZzwAgkUjQ0NAAwJe//GV+9rOfAc46wKNHj7Jq1So2bdrE7t27Abjssstoamoa9ZgPPfQQMPFU0qJoNMrrXvc6brjhBqqrq895/sILL+TDH/4wH/vYx3jFK17B1VdfTV9f37Bt7rnnHv7oj/6IUCgEwKte9arxvzGLlAJDERERmVPHEynWB334XGNPXDLG8LIVNXytuZO+TJY6ry5ZRMrhVa96FR/5yEe46667BrN/1lre/va385nPfGbYtnfddRe//e1veeCBBwiFQlxzzTUkk07PUr//7AwBt9td8lRSgEwmw+te9zre8pa38NrXvnbUbbZt28a+ffu4/fbb+Yd/+Ade8IIX8La3va3kYy9GmkoqIiIic+rkOK0qhnr5ilqyFn6t6aQiZfOOd7yDT37yk1x44YWDj73gBS/g5ptvprOzE4De3l5OnTpFf38/dXV1hEIhDh8+zIMPPjjt415zzTXjZguttbzzne9k586d/PVf//WY2505c4ZQKMRb3/pWPvrRj7Jv3z6qqqqIRM6utXzOc57Dz3/+cxKJBJFIhFtvvXXa417IdPtNRERE5oy1luOJFM+srZhw24urgqwNeLmtq583NS6fg9GJyEhr167lgx/84LDHdu3axb/8y79w7bXXks/n8Xq9fOUrX+ElL3kJN954Izt37mT79u0885nPnPLxrrjiClKp1DmPf+5zn+PFL37x4Of33Xcf3/3ud7nwwgsHp6h++tOfHjblFeCJJ57gox/9KC6XC6/Xy9e+9jWWL1/OlVdeyQUXXMBLX/pSvvCFL/DGN76Riy++mIaGhsEpskuNsdaWewxzZs+ePXbv3r3lHoaIiJTZI488MupalNnWQgAfc3/eTaVSrF69es6PG89k2dNYN+yx9lSG3fc/xae3ruEdayduRfHJo618s7Wbp666gCqPe7aGKjJvHDp0iJ07dw5+Xq52FbI4jPx9AjDGPGqt3TNyW2UMRUREZM4cjzvrjbaEApPa/uUravh6Sxd39gzwmpV1E79AZJFRECdzRWsMRUREZM6cTKSB8VtVDLWnpoIGn4dfdIVncVQiIqLAUERERObM8XgSv8uwxu+d1PYuY3hpfQ139kSI5/KzPDoRkaVLgaGIiIjMmROJFBuDflzGTPo1r1hRSyKf567egVkcmcj8sZRqgMjsmervkQJDERERmTMn4im2TKJVxVDPqq1kmdfN7V1qWyGLXyAQoKenR8GhlMRaS09PD4HA5NZzg4rPiIiIyBzJWUtTIs2L62um9DqPy/Di+hp+0Rkmk7d4XZPPNoosNGvXrqWlpYWurq5yD0UWuEAgwNq1aye9vQJDERERmRMtyTQZayfV3H6kK2sr+UFbLycSKbZXTP4OuMhC4/V62bRpU7mHIUuQppKKiIjInDged5pWT7Yi6VA7CsHg4VhiRsckIiIOBYYiIiIyJ04knMBwyzQCw/NCAVzA4WhyhkclIiKgwFBERETmyIl4iiq3i3rv1FeyBNwuNof8HIkpMBQRmQ1lDQyNMS8xxhwxxhwzxnx8lOf/2hhz0BjzuDHmTmPMhiHPvd0Yc7Tw7+1zO3IRERGZqhPxFJtCfswUWlUMtb0iwGEFhiIis6JsgaExxg18BXgpsAt4szFm14jN9gN7rLUXATcDny+8dhnwSeAK4HLgk8aYurkau4iIiEzd8cTUW1UMtaMiwMlEioQa3YuIzLhyZgwvB45Za09Ya9PAD4FXD93AWvt7a2288OmDQLHe6ouBO6y1vdbaPuAO4CVzNG4RERGZomQuT0syPa3CM0U7KoJY4GhcWUMRkZlWzsBwDdA85POWwmNjeSfwy2m+VkRERMroVDKNBbaEpt9q4mxlUgWGIiIzbUH0MTTGvBXYAzx3Gq99D/AegPXr18/wyERERGQyThSyfJtKmEq6KejHZ4wqk4qIzIJyZgxbgXVDPl9beGwYY8wLgb8HXmWtTU3ltQDW2pustXustXtWrFgxIwMXERGRqRnsYRj0TXsfHpdha4VfvQxFRGZBOQPDR4CtxphNxhgf8CbglqEbGGMuAb6OExR2Dnnq18C1xpi6QtGZawuPiYiIyDx0IpGi3uuhZhqtKobaURFUywoRkVlQtsDQWpsFPoAT0B0CfmytfcoY80/GmFcVNvsCUAn8jzHmgDHmlsJre4F/xgkuHwH+qfCYiIiIzEMn4qlpNbYfaUdFgNZUhoFsbgZGJSIiRWVdY2itvR24fcRjnxjy8QvHee03gG/M3uhERERkppxIpHj+suqS97O9UIDm6ViSPTUVJe9PREQcZW1wLyIiIotfJJujM52dsYwhqDKpiMhMU2AoIiIis+pEolB4ZgYCw7UBHxVulwrQiIjMMAWGIiIiMqtODlYkLT0wdBnD9oqAWlaIiMwwBYYiIiIyq4qtKjbOQGAIznRSTSUVEZlZCgxFRERkVp1IpFjj9xJ0z8xlx46KAN2ZLF3pzIzsT0REFBiKiIjILDs+Q60qinZUBAHUz1BEZAYpMBQREZFZY63lZCLFphmaRgqqTCoiMhsUGIqIiMis6cnk6M/mZjRjuMLnYZnXrYyhiMgMUmAoIiIis+ZE3AneNocCM7ZPo8qkIiIzToGhiIiIzJrjhR6GW2ZwKinA9oogh2MJrLUzul8RkaVKgaGIiIjMmpPxFB4D6wK+Gd3vjooAkVyeMylVJhURmQkKDEVERGTWHE+k2BDw43GZGd2vCtCIiMwsBYYiIiIya07EU2yewcIzRdsVGIqIzCgFhiIiIjIr8oVWFbMRGNZ5PazyeTkcS8z4vkVEliIFhiIiIjIrerI5knnL5hkuPFO0oyLAEVUmFRGZEQoMRUREZFa0pp3CMDPZw3Co7ZUBno4nyakyqYhIyRQYioiIyKw4k84CzGrGMJm3nEqkZ2X/IiJLiQJDERERmRWt6QxBl4tVfu+s7H9HRRBA6wxFRGaAAkMRERGZFWfSWTYFfbjMzLaqKNpW4WQiVZlURKR0CgxFRERkVrSmM7NSkbSowu1mQ8CnwFBEZAYoMBQREZEZl7WW9kyWLaHArB5nR2WAw6pMKiJSMgWGIiIiMuPa0hnyzF7hmaIdFUFOJJKk8vlZPY6IyGKnwFBERERmXGvKaVUxm1NJwalMmrVwIp6a1eOIiCx2CgxFRERkxjUXAsNNs54xdKaqap2hiEhpFBiKiIjIjDuaTLHM46be55nV42wJ+fEYBYYiIqVSYCgiIiIz7nA8xdaAb9aP43O52BwMqJehiEiJFBiKiIjIjIrmcrSkM3MSGIIqk4qIzAQFhiIiIjKjnk44hWC2BmZ3fWHRjooAp5JpYrncnBxPRGQxUmAoIiIiM+pwoULo1uAcZQwLBWiejqkyqYjIdCkwFBERkRl1JJGi0eeh2u2ek+PtqAgCaJ2hiEgJFBiKiIjIjDqSSLEjGJiz420I+gi4jCqTioiUQIGhiIiIzJjeTJbOTJbts9y/cCi3MWwLBTiiAjQiItOmwFBERERmzJFC4ZkdobkLDAG2VwaUMRQRKYECQxEREZkxRxIpXMDWOcwYgrPOsD2dIZzJzulxRUQWCwWGIiIiMmMOx5Ns8PsIuub2EqNYmfSIsoYiItOiwFBERERmhLWWw4kU2+d4GimcDQw1nVREZHoUGIqIiMiMaM9kGcjl57TwTNFqv5cqt0uBoYjINCkwFBERkRlxpNDYfkcZAkNjDDsqguplKCIyTQoMRUREZEYcTiTxGtgcmPvAEGBHZYAjsSTW2rIcX0RkIVNgKCIiIjPiSCLF5oAfr8uU5fjbKwL0ZnJ0pVWZVERkqhQYioiISMly1vJ0IlWWaaRFKkAjIjJ9CgxFRESkZM2pDIm8LUtF0qLtg4Gh1hmKiEyVAkMREREp2ZGEk6XbEQyUbQwrfF6Wez3KGIqITIMCQxERESnZ4XiKoMuwzu8t6zh2VAQUGIqITIMCQxERESnZ4USKbUE/blOewjNFOyqcyqR5VSYVEZkSBYYiIiJSkkzeciKZKktj+5G2VwSI5fK0pjLlHoqIyIKiwFBERERKciKZImPLu76waGuhAM1RTScVEZkSBYYiIiJSksOJFEBZK5IWbQ0VAsO4AkMRkalQYCgiIiIlOZJIUe12scrrKfdQqPd5WOZ1czSWKvdQREQWFAWGIiIiUpIjcaexvSlz4ZmiraGAMoYiIlOkwFBERESmLZHPcyqVZnuo/OsLixQYiohMnQJDERERmbajiRR5YMc8qEhatLXCT28mR3c6W+6hiIgsGAoMRUREZNoOxwuFZ+ZTYKgCNCIiU6bAUERERKbtSCJFg9fDsnlQeKZILStERKZOgaGIiIhM2+FEcl5lCwHW+L0EXS5lDEVEpkCBoYiIiExLfzZHWzo77wJDlzFsDfnVskJEZAoUGIqIiMi0PF1obL9jHjS2H2lrhSqTiohMhQJDERERmZbDhcBw2zzLGAJsDflpTWWIZXPlHoqIyIKgwFBERESm5Ug8yVqfl0q3u9xDOcdgAZq4ppOKiEyGAkMRERGZliOJ1LycRgpqWSEiMlUKDEVERGTKujJZerK5eVd4pmhT0I/HqGWFiMhkKTAUERGRKTtcyMTtCAbKPJLReV2GTUG/ppKKiEySAkMRERGZsiOJFG7gvKCv3EMZ09aQKpOKiEyWAkMRERGZsiOJFJsCPvyu+XspsbUiwMlEinQ+X+6hiIjMe/P33VxERETmJWstR+Kpebu+sGhryE/OwslEutxDERGZ9xQYioiIyJS0pjNE83m2h+bn+sKiYsuKY5pOKiIyIQWGIiIiMiVHCo3td8zzjOF5hVYaqkwqIjIxBYYiIiIyJYfjKXzGsDEwfwvPAFS43azxe1WZVERkEhQYioiIyJQcSaQ4L+jDY0y5hzKhbRUBZQxFRCZBgaGIiIhMWs5ajiZS87Z/4UhOy4oUeWvLPRQRkXlNgaGIiIhMWlMyTcraeb++sGhrhZ9EPk9rKlPuoYiIzGsKDEVERGTSDhcKz2wPLYzA8LxC5VRNJxURGZ8CQxEREZm0BwZiLPe4WePzlnsok7K1GBiqZYWIyLgUGIqIiMikhLM5HorEeUFtJa4FUHgGoN7nYZnXzdGYKpOKiIxHgaGIiIhMyu/CUXLAtXVV5R7KlDgFaJQxFBEZjwJDERERmZQ7whG2BHxsDiyM9YVFCgxFRCamwFBEREQmdDqZ5kgixbW1CytbCE5l0t5Mju50ttxDERGZtxQYioiIyITuCEdwAc+vrSz3UKZMBWhERCZW1sDQGPMSY8wRY8wxY8zHR3n+OcaYfcaYrDHm9SOeyxljDhT+3TJ3oxYREVla8tZyRzjKnsogy72ecg9nyrZWqGWFiMhEyvbuboxxA18BXgS0AI8YY26x1h4cstlp4M+Aj4yyi4S1dvdsj1NERGSpezyWpDOT5d2rlpV7KNOyxu8l6HIpYygiMo5y3va7HDhmrT0BYIz5IfBqYDAwtNY2FZ7Ll2OAIiIiAr8JRwi6DFdWV5R7KNPiMoatIb9aVoiIjKOcU0nXAM1DPm8pPDZZAWPMXmPMg8aY18zoyERERASAZD7PH/qjPLemkoBr4ZYm2FqhyqQiIuNZuO/wsMFauwf4E+AGY8yW0TYyxrynEEDu7erqmtsRioiILHD3DcSI5y0vWoDVSIfaGvLTmsoQy+bKPRQRkXmpnIFhK7BuyOdrC49NirW2tfD/CeAu4JIxtrvJWrvHWrtnxYoV0x+tiIjIEnRHX5QGr4eLCwVcFqrBAjRxTScVERlNOQPDR4CtxphNxhgf8CZgUtVFjTF1xhh/4eN64EqGrE0UERGR0vVmsuyNxnlhbSUuY8o9nJKoZYWIyPjKFhhaa7PAB4BfA4eAH1trnzLG/JMx5lUAxphnGGNagDcAXzfGPFV4+U5grzHmMeD3wGdHVDMVERGREt3ZHyUPC34aKcCmoB+PUcsKEZGxlLUZkbX2duD2EY99YsjHj+BMMR35uvuBC2d9gCIiIkvYHX0Rtgf9bAj4yj2Uknldhk1Bv6aSioiMYSEXnxEREZFZciKZ4lgyvSiyhUVbQ6pMKiIyFgWGIiIico47+qK4gefXVpZ7KDNma0WAk4kU6bzaI4uIjKTAUERERIbJWctvwxEurwpR63GXezgzZmvIT87CyUS63EMREZl3FBiKiIjIMPujCXqyOa6tWzzTSGFIywoVoBEROYcCQxERERnmN+EIFS4Xz6oKlXsoM+q8kB9QywoRkdEoMBQREZFBiVyee/tjPK+2Ep9rcV0mVLjdrPF7VZlURGQUi+sdX0REREpyz0CMpLW8aBEVnRlqW0WAY5pKKiJyDgWGIiIiMuiOcIRGr4cLQoFyD2VWOC0rUuStLfdQRETmFQWGIiIiAkBXJsu+aIIX1VVhjCn3cGbF1go/iXye1lSm3EMREZlXFBiKiIgIAHeGI1hYVE3tR9oaUmVSEZHRKDAUERERrLX8pi/C+aEAa/zecg9n1gwGhqpMKiIyjAJDERER4VgyTVMqs2iLzhQt93lY5nVzNKbKpCIiQykwFBEREf7QH8UFXFOzuANDgG2hgDKGIiIjKDAUERERjiZSbAz4qPa4yz2UWbe1QoGhiMhICgxFRESWOGstR5Nptgb95R7KnNga8tObydGdzpZ7KCIi84YCQxERkSWuJ5ujL5tja8BX7qHMCRWgERE5lwJDERGRJe5YwinEsmQyhhVqWSEiMpICQxERkSXuaCKFAbYElkZguMbvJeR2KWMoIjKEAkMREZEl7mgyzRqfEywtBcYYzgv51bJCRGSIpXEGEBERkTEdS6SWzDTSIrWsEBEZToGhiIjIEjaQzdGeyXJecGkUninaGgrQmsoQzebKPRQRkXlBgaGIiMgSdixZKDyzRNYXFu2odArQHFYBGhERQIGhiIjIknY0kQaWTkXSol2VQQAORhNlHomIyPygwFBERGQJO5ZIscLrpsbjLvdQ5tRav5dqj4unFBiKiAAKDEVERJa0Y8nUkptGCk5l0l0VQQ5pKqmICKDAUEREZMlK5POcTmU4b4lNIy3aWRnkYDRB3tpyD0VEpOwUGIqIiCxRJxJpLEtvfWHR+ZVBork8zcl0uYciIlJ2CgxFRESWqKNLtCJp0a4KpzKpCtCIiCgwFBERWbKOJVLUuF2s8C6twjNF2ysDGOBgVOsMRUQUGIqIiCxRRxMpzgv6McaUeyhlUeF2syno52BMGUMREQWGIiIiS1AmbzmZSi/ZaaRFuyoDmkoqIoICQxERkSXpVCpN1i7dwjNFuyqDNCXSxLK5cg9FRKSsFBiKiIgsQUcTTuGZ84K+Mo+kvM6vDGKBw+pnKCJLnAJDERGRJehoMkXQZVjj85Z7KGW1s1CZ9ClNJxWRJU6BoYiIyBJ0LJHmvIAf1xItPFO0LuCjyu3ioDKGIrLEKTAUERFZYnLWcizpVCRd6owx7KoMqgCNiCx5CgxFRESWmNZ0hmTesnWJry8sKgaG1tpyD0VEpGwUGIqIiCwxxcIzS71VRdGuygDRXJ7mZLrcQxERKRsFhiIiIkvMsUQar4ENAWUMAc6vCAJwMKp1hiKydCkwFBERWWKOJVNsCvjxLPHCM0XbKwIY4GBM6wxFZOlSYCgiIrKEWGs5mkhxnrKFgyo8bjYGfWpZISJLmgJDERGRJaQzk2Ugl2erKpIOs6syyKE5mEoaz+WJZHOzfhwRkanylHsAIiIiMneOJpwCKwoMh9tVEeT2rn5iuRwVbve09tGbyXImmeZMKkN7KkNbKkN7+uzHbakM/dkcAZdh37PPZ5lXl2EiMn/oHUlERGQJOZZM4QI2ayrpMOdXBrHAkWiSS2sqpvz6/+3s48+fOjXsMQM0+Dys8nvZFPTzrNpKUvk832/r5UgsybNqK2dm8CIiM0CBoYiIyBJyNJFind9LwKXVJEPtrAwA8FQsMa3A8CftfTT6vfzzeWto9Htp9Htp8HnxuIYX+DmVSPH9tl5OxlMKDEVkXlFgKCIisoQcTaTYXRks9zDmnfUBH5Vu17RaVsRyOf7QF+Gtq5fziobacbddG/DhM4bjhV6SIiLzhW4XioiILBF92Szd2Zwa24/CGMOuyiAHp1GZ9O7eCMm85SX1NRNu6zaGDUEfJ+IKDEVkflFgKCIiskQcKxSeOU+FZ0ZVDAyttVN63S+7+6n1uHlmzeSmhm4J+TmhjKGIzDMKDEVERJaIo4VgZGtQhWdGs6siQCSXpzmZnvRrsnnLb7sHeOHy6nPWE45lczBAUyJFbooBqIjIbFJgKCIiskQcS6Zo9HqonGY7hsXu/MLay0Oxya8zfKg/Sl82x0tXTDyNtGhLyE8qb2mdQgAqIjLbFBiKiIgsEUcTafUvHMeOigAGeGoK6wx/1d1PwGW4ZlnVpF+zqfAz0HRSEZlPFBiKiIgsAbFcntZ0RusLx1HhcbMx6Jt0ARprLb/s7ufquioqppCF3RIqBIYqQCMi84gCQxERkSXgWNIJQs5TY/txOQVoJjeV9GAsSUsyw0snUY10qAafhwq3SxlDEZlXFBiKiIgsAccKQcg2ZQzHtasiyMlEilguN+G2v+zqxwAvqq+e0jGMMWwO+jmujKGIzCMKDEVERJaAY4k0yzxulnk95R7KvLarMoAFjkwia/ir7n6eUVPBCp93ysfZHPJzUhlDEZlHFBiKiIgsAUeTKRWemYRdhcqkByeoTNqcTPNkNDGppvaj2Rz0czqRJp3PT+v1IiIzTYGhiIjIIpe2lqZkWusLJ2FdwEel2zVhZdJfd/cDTD8wDPnJA6cSalkhIvODAkMREZFFrjlnyYMyhpPgMoZdlUEOTRAY/rKrn22hAJtD0/ueblHLChGZZxQYioiILHKnss50RQWGk7OzIsDBWAJr7ajP92WyPNgfnVJT+5E2qWWFiMwzCgxFREQWuVPZPJUuF6tUeGZSzq8MMpDN05LKjPr8b3sGyNnpTyMFqPN6WOZ1K2MoIvOGAkMREZFFrimX57ygD2NMuYeyIAwWoBljOumvuvtp9Hu5uCpY0nHUskJE5hMFhiIiIotYzlpOZ62mkU7BzooAMHpgmMjl+V1PhGuXV+MqMdBWywoRmU8UGIqIiCxirdk8GWBrQIHhZFV43GwM+katTHpPX4REPl/S+sKiLcEAbakMsWyu5H2JiJRKgaGIiMgidjLjBB3nKWM4Jbsqghwapcn9r7r7qXK7eHZtZcnHKBagUdZQROYDBYYiIiKLWHM2hwdY5/eWeygLyq7KICcSKWK5s9m8nLX8unuAFyyvxucq/RJqSyEwPK7AUETmAQWGIiIii1h3Ls9yl8GtwjNTsqsygAWOxM5mDR/tj9GTyZZUjXSojUEfACdVgEZE5gEFhiIiIotYVzZPvVtB4VSdP1iZ9Gxg+MvufrzG8ILl1TNyjAq3m0a/VxlDEZkXFBiKiIgsYsWMoUzNuoCPCrdrsDKptZZfdfdzVV0lVR73jB1nc9CvJvciMi8oMBQREVmkstbSl7cKDKfBZQy7KoKDgeHT8RQnE+kZm0ZatEUtK0RknlBgKCIiskj15vJYoF6B4bTsrAxwMJZwsoVd/QC8eIYDw81BP72ZHL2Z7IzuV0RkqhQYioiILFJdOQugjOE0nV8ZZCCbpyWV4Zfd/VxSFWLVDFd33VxsWaHppCJSZgoMRUREFqnuXB5AxWemaVehAM3vegY4EInPSFP7kTarZYWIzBMKDEVERBapYmC4TBnDadlZEQDg/53uAJjx9YUA6wM+3EYZQxEpPwWGIiIii1R3Lk+Ny+BTD8NpqfS42RDw0ZLMsCXoZ2shuzeTfC4X6wI+ZQxFpOwUGIqIiCxS3bk89W6d6ktR7Gf44voazCwF2GpZISLzgc4WIiIii1SXAsOS7ax0ppPOxvrCoi0hPycSKay1s3YMEZGJeMo9ABEREZl51lq6c3l2z3AVzaXmTxqXE3C5uKw6NGvH2BwKEM/l6UhnZ7zqqYjIZOk2ooiIyCIUtZaUhRWqSFqSNQEff7lhJa5ZXKe5OVioTBpPztoxREQmUtbA0BjzEmPMEWPMMWPMx0d5/jnGmH3GmKwx5vUjnnu7MeZo4d/b527UIiIi89/ZVhW6BzzfFVtWnFABGhEpo7KdLYwxbuArwEuBXcCbjTG7Rmx2Gvgz4PsjXrsM+CRwBXA58EljTN1sj1lERGSh6M4669UUGM5/a/xe/C6jAjQiUlblPFtcDhyz1p6w1qaBHwKvHrqBtbbJWvs4kB/x2hcDd1hre621fcAdwEvmYtAiIiILgTKGC4fLGDYG/coYikhZlfNssQZoHvJ5S+Gx2X6tiIjIoteVy+MFqtXcfkHYopYVIlJmi/42ojHmPcaYvcaYvV1dXeUejoiIyJwo9jCcrd57MrM2h/w0JdLk1LJCRMqknIFhK7BuyOdrC4/N6GuttTdZa/dYa/esWLFiWgMVERFZaNTcfmHZHPSTsZaWZLrcQxGRJaqcZ4xHgK3GmE3GGB/wJuCWSb7218C1xpi6QtGZawuPiYiICIXA0KPAcKEoViY9rumkIlImZTtjWGuzwAdwArpDwI+ttU8ZY/7JGPMqAGPMM4wxLcAbgK8bY54qvLYX+Gec4PIR4J8Kj4mIiCx5GWvpy1tWKGO4YGxRywoRKTNPOQ9urb0duH3EY58Y8vEjONNER3vtN4BvzOoARUREFqDewYqkWl+4UNR7PVS5XSpAIyJlo1uJIiIii4xaVSw8xhg2hVSZVETKR2cMERGRRaY7p+b2C9GWoJ/jmkoqImWiM4aIiMgi01XIGC5XYLigbA75aUmmSeXz5R6KiCxBOmOIiIgsMt25PLUug089DBeUzUE/FmhKqGWFiMw9BYYiIiKLjHoYLkybQwEATsSTZR6JiCxFOmuIiIgsMgoMF6bNQR+gXoYiUh46a4iIiCwi1lq6FBguSDVeD/VeDydVgEZEykBnDRERkUUkkrekrSqSLlSbQ35lDEWkLHTWEBERWUSKPQxXqLn9grQ56OeEMoYiUgYKDEVERBYRNbdf2LaE/HSms0SzuXIPRUSWGJ01REREFhE1t1/YNgX9AMoaisic01lDRERkEenK5fEZqHJpKulCtCVUCAy1zlBE5pgCQxERkUWk2KrCqLn9grSxkDFUARoRmWsKDEVERBaR7lyeFZpGumAF3S7W+L1qWSEic05nDhERkUVEze0XPrWsEJFy0JlDRERkkchYSzhvFRgucMWWFdbacg9FRJYQnTlEREQWCbWqWBy2hPz0Z3P0ZtSyQkTmjs4cIiIii8TZwFCFZxYytawQkXJQYCgiIrJIFANDFZ9Z2LaEAgAcjyfLPBIRWUrGPXMYYzxzNRAREREpTXfOYoBlCgwXtHUBHx6jXoYiMrcmOnM8XPzAGPP/ZnksIiIiUoKuXJ5al8GrHoYLmtdlWB/wayqpiMypiQLDoWeWK2dzICIiIlKa7qxaVSwWm0N+ZQxFZE5NdPZQnWQREZEFQj0MF48tQT8nEynyalkhInNkojWEO4wxj+NkDrcUPqbwubXWXjSroxMREZFJsdbSncuzJ+At91BkBmwO+UnkLc3JNBsKVUpFRGbTRIHhzjkZhYiIiJRkIG/JoIqki8WemgoAHgzHFBiKyJyY6OxxE/BaIGitPTXy3xyMT0RERCZBze0Xl50VAZZ53dwfjpZ7KCKyREx09ng70AdcZ4zZZ4z5mjHm1caYijkYm4iIiEzSYGDomV5F0ntafsWH7noTvcmumRyWTJPLGJ5VW8l94Ui5hyIiS8S4gaG1tt1a+y1r7ZuAPcB3gMuA3xhjfmuM+Zu5GKSIiIiMr9SM4dHwU7TFTvPFR/+WdE7VMOeDZ9dW0pLMcEptK0RkDkz67GGtzVtrH7DWfsJaeyXwJqB19oYmIiIik9WVs/gNVE6zh2E41YPfHeBY+CD/+eQXsKqGWXbPrq0E4D5NJxWROTBuYGiM+c2Qj/926HPW2m5r7fdma2AiIiIyecVWFWaagWF/qo8tNbt4/dZ3cHfL7fyq6eYZHqFM1Y6KAMu9Hu7vU2AoIrNvoozhiiEfv2E2ByIiIiLTV2oPw3Cqh9rAMl639R3sWXk13zn0ZZ7sfnQGRyhTZYzh2bWV3B+OKoMrIrNODe5FREQWgVIDw/50LzW+ZbiMi/df/AkaK9Zxw75/oDPeNoOjlKm6sq6SM6kMTYl0uYciIovcRGeQzcaYW4wxtw75ePDfXAxQRERExpeylv68nXYPw1QuSSIbp9a/DICQt4KPXPZZcjbHFx/9OKlcciaHK1OgdYYiMlcmanD/6iEfXz+bAxEREZHp6S2xIml/qheAmkJgCLC6cj0fvOQ6PvfIR7nx8U/zwd3/OO31izJ9W0N+Gnwe7g9Heevq5eUejogsYuMGhtbau4sfG2NWFB5TgyMREZF5pKvEwDCc6gGg1j888Lik4dm8afuf84MjN7Kxehuv3vLW0gYqU1ZcZ3hfXwRrrYJzEZk1E1UlNcaYTxpjuoEjwNPGmC5jzCfmZngiIvNX4vHHie/dW+5hiAzpYTjdiqTnZgyLXr3lT3lW4wv4weGvcaDzwekPUqbtyrpKOtJZjqufoYjMooluLf4VcBXwDGvtMmttHXAFcKUx5q9mfXQiIvNYx2c/R/s//0u5hyFCdzaPAZZNO2PoBIa1owSGxhjee9Hfsa5qC1/e/0naYy2lDFWmYXCdodpWiMgsmugM8qfAm621J4sPWGtPAG8F3jabAxMRme/SJ0+SOXOm3MMQoTtnqXMZvCU0tzcYqn11oz4f8AT56J7P4jIuvrD3YySysVKGK1O0Oehnlc/L/SpAIyKzaKLA0Gut7R75YGGdoXd2hiQiMv/l+vvJ9fWRj0TIRSLlHo4scSW3qkj1UemrweMau/RAQ2g1/9+l/8yZ2Gm+cuBf1FdvDhljuLJO/QxFZHZNdBYZr2mOGuqIyJKVPnVq8OPMGfV5k/Lqmonm9qNMIx3pwvo9vGn7e3ik424e73542seTqbuytpKudJan41pnKCKzY6KzyMXGmIFR/kWAC+digCIi89HwwLC1jCORpS5vLT0lZwyd5vaT8bKNb2R5YCU/fvo/lb2aQ8+uK64z1AwFEZkd455FrLVua231KP+qrLWaSioiS1b6ZNPgx5k2ZQylfAbylgxQ7yklY9g7qYwhgNft47Vb386x8FMc6Hpg2seUqdkQ8LHGr3WGIjJ7pn8WERFZwtKnTuFdvRq8XrIKDKWMiq0qVkwzY2itpT/dO2qrirFcs/YVNARXL+is4aOn+vizbz5MpvD9m++MMTy7sM4wv0C/5yIyvykwFBGZhnRTE75Nm/CuWkWmVZVJpXy6S2xun8zFSeWS5zS3H4/H5eG1W/+ME/2H2dtxz7SOW24PnujhriNddEYWzpq9K2sr6c3kOBJLlnsoIrIIKTAUEZkiay3pU6fwbdyId/XqJTOVNJdLks0u/PVNBzoPcGfvneUexozpKrG5/Xg9DMfznDUvYWVoDf9z9L/I24WRdRsqkswCEI4vnFp6g/0MNZ1URGaBAkMRkRH2//oXPHrb/475fK6nh3w06gSGjY1Lppfh0WOfYd/+t5Z7GCX70ZEf8cP2H5LNZ8s9lBnRncsTMFAxzR6G/YXAcCpTSQHcLg+v3/oOTg0c5ZH2u6d17HKKJDMAhOOZMo9k8tYH/awL+Lhfje5FZBYoMBQRGWH/r37BU3f/dszn001NAPg2bsC7ejXZzk5sZuFcXE5XPH6caPQQ+fzCmXo3ms54JzlytCUXR6a3O2epd7swJTS3B6Y0lbToqjXXsrpiPT9++j/J29y0jl8uA4MZw4X1t3tlbSUPaJ2hiMwCBYYiMm91fPZzdP7rl+b0mJl0inDbGZLRse/IF1tVOFNJG8FaMh0dczXEskmnu7E2Rzx+auKN57HOeCcAzYnmMo9kZnTn8tMuPANOc3uYesYQwGXcvH7bO2mJnuSBtt9NewzlUMwY9i2gqaQAV9ZV0pfNcTCaKPdQZA60pdI87+HDNCUW9g25+S5v8/z3wf+mL9lX7qGUlQJDEZm3Ir/9LdG77prTY/a2NGNtnmR07LV06aYm8HrxNjY6lUlhSUwnTae7AYjHT5R5JNNnraUj7gTxp+OnyzyamTETze0NLqp9NdN6/bMaX8Dayk3c/PR/LaisYXGNYX9iYWUMtc5waTkwEOdQLKk2JbPsie4n+Nwjn+O2E7eVeyhlpcBQROYlm82SaWub84Cru9nJhmVSSbJjTA9NN53Ct24dxuPB09gIsOhbVuTzGTIZ505qLH68zKOZvlgmRiLrZFoWQ2CYylsieTtuYNjzxKMc/++vjdlWoj/VS7W/FpdxT2sMLuPij7e9izOx09zXese09lEOgxnD2MLKGK4J+NgY9ClQWCJaU87v6cm4MoazaX/HfgBORxb+eaEUCgxFZF7KtLdDLkc+GiUXmbtKmMXAEBgza5huasK3YQMA3kJguNgzhulMz+DH8djCzRgWp5G6cdOSaCnzaErXnZ+4VUXfoceInjpGNjn61EOnuf3U1xcO9YxVz2VD9VZuPvoNcgukqE8xY9i3wNYYwtl1hjmtM1z0ziSdGxfH42pRMpse7XwUUGCowFBE5qVM89n1X5kzc5eN6z7dNPjxaIGhzedJnz6Nb+NGAFyBAO7ly+d0jOWQTnUBYIybWPxYmUczfcVppFtDW2lPtpNa4IV0urMTB4axNudvKTUQHvX5cKpnyq0qRnIZF2/Y+k7a4y38ofVXJe1rrpydSrqwMoYAV9ZVMZDN86TWGS56p9udm1nHupf22rfZlLd5DnQeAKAlsvBvGJZCgaHMS9baMac9ydKQHhYYts7ZcbtPN5HwVACjB4bZ9nZsKjWYMQSWRMuK4vrCqqoLicdPLNi/z2LG8PzK88mTpzUxd79bs6HY3H6s4jO5VJJUr/OzS/WHR92mP91Lja+0wBBgz8qr2Vyzg58c/ea8bwWSy1uiqYWbMRxcZ6i2FYteMWPYZI0q0c6Sk/0nCafCNIQaaI20zvv3r9mkwFDmFZu3HLzvDN/4yL3s+/XCrnwopck0n71rN1cN5BPRCNG+Xpr9zvTQ/nD/OdsMrUhatBSa3BcDw7raK8jl4qRS7WUe0fR0JZzM5/kV5wPQHF/YlUm7cnkMUDdGc/t4eysULiZHyxhaawtTSUsPDI0x/PG2d9GVaOOull+UvL/ZVAwKYWE1uC9a5feyJejXOsMloM0a3LksaeMaXG84GmstA7ffjs3OTFCTzOX5v0db6Ekv/iDp0Q5nGumrtryKrM3SFlvc5/PxKDCU8f3mH+DEXXNyqL72GD//0n5+/93DJGMZOk4OzMlxZX5KtzTjXbcO4/VOWNjl5kdb+MmjpU//KE4jbQk4lUY7unrPHdeQHoZFxYzhQs2iTUY67QRUtXWXAwu3MmlHrIMqXxVrA2vxGM+CL0DTncuzzGXwjNHDMN5+9u9itMAwno2SzWem1apiNLtXPIvzas/np0e/TSY3fwOugUIlUp/HteD6GBZdWVfJg+Eo2fzifd9Z6nLW0un2sKPJKfg1XgGaxP4DtP71h4n8/vczcuxHB2L8R0s3d/Yu/mux/Z37qQ/W8+zVzwageWBh3zAshQLDRcRaS88PD5M4cu7F7LTEe+H+/wePfntm9jeGXCbPw7ee4If/8jA9rVGe96c72HDBcgZ6tNB6Kcs0t+Bbvx5PYyOZ1vGnaX73gSa+dX9TyccsBoZnCoFhb2/4nG3STacwwSCehobBx7xrVmOTSXLhc7dfLFLpbjyeKqoqnUzbQq1M2hnvZGVoJR7jYU1wzYLvZVhsbj+WeFsLnlAFxu0eNTAspbn9aIpZw55kB3eevpVkZu7bV6SzeToj458/IsksxubZGsoTTmQW5E2dZ9dWEs3leTwan9H92nSa6N13z+g+ZXo60xlyxsWlh58E4Pg4vQyznc766fTJphk5djE72ZKcvzd4Zsq+jn1c0nAJG6qdG75LuQCNAsNFJNefInGgi+ShGQoM2x4r/H9gZvY3itan+/jhvzzMI7c1seWSBv7kumey68rVVNcHiSgwXNIyLS141611snETZAz7Exk6Bkr/fek+fQp3IESft5YcrtGnkjY14Vu/HuM6+/ZZbFkxUQC7kKXTXfh8K/D56vF4qojFFm5g2BBygvp1wXULfippdy5PvWecwjPtLYRWrcVTUT3qGsNSmtuP5aL6y9lRdzHffWg/7/3GXlLZ8YPDgYEnOPL0dSUHZ9lcnh8/0szzv3gXz/38XeP2J4wkMzyveT+f+uE/4E8liKQW3nS52VpnOPCbO2j+8/eSOnFyRve7VOTTaXr+6xvYdOkBVWuhpcrOpuME0ylOjFOZNNPZjXvFLlKFWS2lKq5tXOyBYXusnTOxM1y28jJWBFcQcAcUGMrikGl1Tg65/hmqstf+uPN/7wlInnuBXIpkLMPvvnOIn//rfvK5PK/8y4u59p3nE6r2AVC1PEA6kSU1x1N8/uvek9xztGtOjynnykUi5MJhfOvWTWr9XjiRoTuaIlfilKru5lO4l68GY0i5/ET7z51Ckz51atj6QuBsk/u2xRwY9uDz1WOMIRTaQnwBZwxXBFcAsC60jq50F/HszGZc5kreWnrGaW6fz+VIdLQRalyHt7KK1MC5VQ3PZgxnLjA0xvCGbe8iEllGNJnjZHds3O07On9BS8t3B6crT1Uub/nZ/hZe+K938zc/eZx83pLI5DjcNvYUuEgyy+aBM/jTSdZEuwjHFt500ga/l62hmV9nWHwfy3brXDgdsXvvpfMLXyD24IMl76s15QRlDX09rOls5/g4U0kz7XFCV36IbGe+5OMCtPY77w2tfR0zsr/5al/HPgAuabgEYwxrq9ZqKqksDuliYDgwQ3d3ihnDkR+XwFrL0w+38/3rHuTwg+1ccu163vSJK1h//vBpTNXLAwBzPp30hjue5kePLN03hPki0+Ksi/KuXYe3sZFsZyd2jGbz+bxlIJEhb6EnOv2bItZauptPkalZCUDKEzinKqnNZkm3tAyrSApnA8PF3OTeyRjWA1AR2rwgexnm8jm6k92DGcP1wfUAC7afYX/ekmXsiqTJ7nZsLkuocQ2eyipSA+fe4CsGhjOZMQS4oP4yAnnn7+Qjd3yRTz34Kb536Hvcf+Z+2mPtw7KD8XiTM97k1G6s5POW2x5v48U3/IG/+tFjBH0e/uNte7j5L5x1Qkc6xu5/GkllaIg7gXJjrIfwAmxZAU7biof6Y2RmcJ1hrtspNJXrVXuE6Si2Wsq0l16g60whY9gQ6Wdt+xlOjNOeJBdOFv6fmZscrXHnhllLcuHdNJmKfZ37qPBWsL1uOwDrq9Yv6Yyhp9wDWMqstbSkMgRchhU+b8n7G8wYDsxQxrDtMVj/LDj9AJw5AJueU/Iuf/utgzz9UAcNG6t51f+3nfq1VaNuV1UIDCM9SVasG32bmRZLZYmksvTGFuYFwmJSbFXhXbuGfGQA8nkyHZ341q45Z9toOkvxmqgzkqKhOjCtY0a6u0gn4kSDK1ju8mF9ITLx4XfiM62tkM2ekzF019ZiAoElMJX0KgBCFefR1v5TstkIHs/c/H3OhJ5kD3mbZ2VoJURgfcgJDJsTzWyr2lbm0U1dsVXFWBnDeJsT8FY0rqP/xNMMtJ5b6bk/1YfbuKn0Vs/4+FzZVUCO/kiQ207cQiRzNlALeoJsrN7IpppNePofZ63bxQWpM9Swe8L9Wmu542AH/3rH0xxuj3BeQyVffculvOT8VbhcBmstNUEvh9rGCQyTWeoTfVicwHAhtqwAp9H9t1q7eSwSZ09NxYzsM9vlZApzYQWG05EuVNTOdnSWvK/WWIJAMkn9hvWs62zjnnSWdD6Pz3Xu33wumsUVApvzkotGcVdWlnTsMxnnxNpqfVhrMWMUuFro9nXuY/eK3bhdbgDWV6/n3tZ7yds8LrP08mcKDMsons/zjAcO8rFNq/irjatK3l/6TJRjrnYaojU05vKYcQoSTCgVgZ7jcNEbIdw8I+sMM6kcTz/UwarN1fzRRy7D5Rr7TaZ6eRBgTtcZthfWqPVEFRiWW7FVhW/dOvL9TpYj23Zm1MCwf8gFnVNwomZax+wqFJ7p9taxwufHFQiRSw6fina2IunGYY8bYxZ1y4pcLkU2G8Hvc6ZgVoQ2AxCLn6Cm+uJyDm1Kij0MG0INEIEV/hX4Xf4FW5l0osAw1taCy+slsLwBT0UVmViUfDaLy3P21B9O9VDjXzbjF0CxVJaBhLO28ILqF/HVN3+MnmQPJ/tPnv03cJIDXQdoi0YAP1d0PcXKhpeNuc+7jnTymdsP4fO4eaK1n43LQ9zwxt288uLVuIecT4wx7FhVxeH28aeSdlav4ZPPehd/evDXC7JlBcCzhqwznLnAsJAx7FsagaG1luNdMc5rKC2QKhrMGHaUnjFsjURp6OshdOEFrD3WTA44nUxzXujcG6A2CYTAFawlfeoUwfPPL+3YOTe+fJqky0d3JjsjCYz5pj/Vz7G+Y7x4w4sHH1tXtY50Pk1nvJNVFaVfmy80Sy8Unkcq3G42BHwcipUe/OQGUqQjSe7yPcUT7lPkIiXe/Wx/ErDQeDGs3u1kDMeRTLaRy409xQGg/URhGpMx4waFAP4KD16/m4Ge8fc5kzr6C4GhMoZll25pxlVTg7u6+mxhlzEayA8tMNFRQra8WJG0mRpWVgfwhipxpYevPTvbw3DDyJcv6ib3xR6GvkJgGAptASC+wArQdMSdtTINFc5UUpdxsTa4dsFWJu2aRMYwuHINxuXCW+lkBFOR4dNJ+1Mz09x+pNa+s+/dRzoiGGOoD9bzjFXP4I+3/zEfu/xj3PjCG/nfl3+L961IYTHsbz8w7j7/9Y6nOdIRpTOS5POvv4jf/vVzec0la4YFhUU7VlXxdHuE/BhTLKMDMQ4t30jEV0HemAXbsqLe52FHRWBG1xlmC1NJs0skMHzoZC8v/Ne7eaJlZmopFGe8zEjGMJGmoa+HwIUXsbbLCTRPjLHO0GadjJcJ1g3exJyugWyOCG4uiRwGoGWBTrWeyIHOA1gsl668dPCx9dXOTJLTAwvzhmGpFBiW2Y7KAIejpQeG6dYoMeO8WfS4oqVPJy0Wnmm8GBp3Q+9xSI5+99VayyN7X0PTqa+Nu8uWw85JJpeZeGG0MYaq5YGyZAz74ukxLyaWqqdjSU6NUyZ7qsIdcQa6xw76M80t+NauBZyAC8Zucj80MOwsJTBsPkVV/QraEtBQ5SdQVYU3kxi2Fird1ISruhp3Xd05r1/MGcN0phgYOmsMg8F1GOMhNs96GeZyOZLJsd8zuuLOFLmG4NlWI+tD6xdkxnAgl+f2WIpGt4uKUQIjay3x9hZCq5wsu6cYGI5oWTG0uX02lx+WgS/FmSGBYVN3jHR29Pf9ROIUG3x5XFgO9Y8doOfzloNnnHPQx16ygz/esw7POLNidjRWE0vnaOkb/X0m19nJ4TrnAjDqC9K3QDOG4Ewnfbg/Sjo/M0VHBqeSLpE1hocKRYoOjVOsaLJsPj+4Rj47A2sM23J5VvT1ENi5g7W9zvvwaAVobD4POFlEV6Bu8CbmdLUWKpFe3u9cC7YUCtEsNvs69+Fxebiw/sLBx9ZXFQLDJbrOUIFhme2sCHIikSRV4ht6pjVKxDgnwD4TJRsu8SK+7TGoaICqVU7GEM4GiyNksxHS6e7BAgJj6TzlvOlOttJo9fLAnBafKQaGubwdt8z5UvTrv/sEt3/hSzO2v9u/9jh3fe/wmM87rSrWAeAKBHAvW0bmzOhB19A7/R0T9C4bT/fpJurXbaArkmJldYDK6mq8Nkt3/9msYbqpCd+GDaOutfCubiTX00N+nMBkoUqnnAvFYmDocnkJBjfMu8qkv/vd77jxxhvJj/F+2hnvxG3cLPNU4s44GZZ1wXWEM+Fh69/mu5y13NAXZyBn+VBdaNRt0uFecskEFY3O35G30lkLmuoffrHfn+4dLDxzy74zvPu/HiGZLr334NDAMG/hVM/olUnjiVP4XNDoghOpsS/MHz3VN9jI/XjXxNmxHaucr/fQGNNJ0+3ttFY5NwjaQ8sZ6B+/cupMSqRz/OHpmav4eXVdFYm85ZEZ+BryiQT5aKFewRLJGDYVquaemKB67mRku7qw6TTG5yPTWVrGMJ3P042Lhr4ePCtXsryygpp0kpOj3KTNhcMYv/M7b0LLSg4MzxR6GF5RDAz7FudNz30d+zh/+fkEPGen5q4MrcTr8iowlPLYUREga8eeGjBZ6dYoiWrnYihjcvR2dJc2sLbHnGwhOBlDGHM6aSrlvGFMVGo83OFcYMfC6Un1q6paPre9DItTSWHmppM+etv/8quv3sDD/3szRx95gJ7WZnLZhdUvK5HLs/vBe9j8wH0zsr9wZ5y+9jjhztHv5NtcjkxrK751awcf865ePeFU0rqQd9oZw1w2Q++ZFkIr15K30FDtp6bWWavY0n72Tmm66dxWFUPHCGNnNhey4t92MTAEqKjYMu96GXZ0dBAOh2lpGb3KaEe8g/pgPe4/fJ5d974PGF6AZqH4cSTJE+ks76wJstk3eqmAWKHwTGiV83c0mDEc0sswb/P0p3oHm9s3dceIprI82Vr6lLqTXc5FdvEWytNjVAiNx5vI5wyNSTenMlmy+dHfH3/0iHORdnn0cY5MIrOzbaVzkXykffTj9hR6/1WaPCdqVpM/0zrhPmfKzY8287ZvPExz78y0SbmqrhKvMfyut/SbG9meHk6shA+9x01/tMTriAXiZI/zczjZXfp03OL6wuDFF5Pv7yefmP5ymLZUBmsMKwbCuGtr8TSuYn1fz6gZw2xXNyZQA1iM20fmdGnZymLGcGeqncpsjJbIzLYsmw+S2SRP9jw5bBopgNvlZk3lmpJbVlhrSUZntpXMXFBgWGbbK5y7FKWuM8yciRKvOHtC7egsoe9MJgldh6HxIufzyhVQvWbMAjSplPMGNFFgmIg4bzS5bJ7kJHpGzXUvwzP9Z9/AZ6oy6SO33Myhe+/inu9/i1uu/xTf+uu/4Mtvex3f+NCf8/Mv/DN/+N43eeL3v6H1yCGyY7RjKLcjPX3U94dZ1ln6tBiA0085gVa0L0U+d25mp9iawrt23eBj4zW5LwaGW1dWFYrPTF3fmVbyuRyu5U5w11AVYFldLQBtXc5486kUmba2c1pVFBXXQi7GlhVn1xiebSsTCm0hkThFPj9/fm8HBpyA4fDh0bPRnfFOpyJp+xME4mdwJ3pYF3J+zxbKdNK9yQw/jaZ4fsjHCyr8Y24Xb28BYwiudH6nPRVOYY2hU0mjmQFyNkeN35kaXbw5duBUmFIVszDP3ubcTHjwxOhT0aKR46QHvKyKeUlbw5GeJ0fd7t5jPXhslj1dD9DcMvHfWIXfw4bloTEL0HSnLC6b51WbKjhdvRI7h+uDjxeC5mOTyHxORqXHzeU1FdzZU/pUyGxnF0fXGM4sNzTnF+f0wZGKv6tN3aUH6sWKpME9lwGQ7Zj+tVgxa9eYzzoFzlauYk1HGydGyRhmOjtx+atxVTmX9ZmO8LSPWzy22+ZYWdvAmlQXran58z4/U57sfpJsPsulDZee89z66tJbViSjEb7yzjex/1e3lrSfuabAsMy2hPx4DBwepzfNRHLRNLn+NDFvhlDImVbU1VfCnb7Og5DPns0YgvPxGBnDZCEwTKXGDgwzySy5rMUbcBZHxyYx1bVq2dz2MmzuG8C4nRN1b6z09XTWWhKRAfa84jV84Js/5i2f+lde+v6/5hmvej316zcQbm9j3+3/y29u/DI//MRHufO/vlryMYtyuQT5/MwEtyeOOevIKmNRcv2l3zU89aRzsWHzlmjfud/noa0qiryrncBwtExzfyKDz+1iw7LQtDOGXc3OtJtMtTO1bGW1nxUrnIvlri5nOlXm9GmwduKM4TwqQBP+5Um6v3Ow5P2k0t14vXW4XL7BxypCm7E2S2IeZdqGBoaj/a50xjudiqSFtWz+8DGWeZcRcocWRMawI5vj//XF2OR1886a4LjbxtuaCdSvxO1zfmYut6fQ5D48uE1/qhdgMGPYWZhOv/9UaVMIrbV0Ff4W33CFk7F8pGn0fcajJ0kN+NiQcwob7T3zh3O2SaSztA8kWZ9ux02eSFcnsdTEMy92rKri8BgtKzpNgLXRLq44fw1Zl4d4X3gyX9qMOF3IFBazqjPhBcurORxLDmZ6pivb3UV/yMnzDqRLDzTnu3Q2T0tfHJeBkz2xkusLZJpPg8tF6JJLnM9LKEBzpvCzXO1xLtW9jatYc/okbakMsdzw6d7ZNudv2dfoXAParJdcODztY7ck06zK9uMJ1rLWRmnJuae9r/lqX+fZxvYjra9aT3OkeVKz28YSbnduYFWvaJhgy/lFgWGZ+VwutoQCHC4hY1jsXxi1cerr66lxV9AV7R33Nff2RegY6w7Q0MIzRY27oeeY08ZihFTSCQxzuSi53Oh33Fqfdi4KGtY703tGCwhGqq4/28twLrQPJHEFnIv66Waehkon4uRzOYJV1fhDIVadt41dz3k+V73pT3nVX/8df/bFr/LB7/6Ed/7bf7D+wt00H3yi5GMW7d//pxw58skZ2VfniZODHw+cKu0OWiaVo/VImOVrnezFaAVohraqKPKuXo2Nx0c90fUn0lQHvaysDtAVTZGbxom9+3QTLreb/sJaq4bqAKtWOBfLvb3OMVPFVhVjZAy9K1eCMWOuhSyH9KkB0s2lTy8rNre//3++x88+/08AhCoKlUlHW2fY/Ag8cXPJx52KVCpFMpmkrq6O3t5eurrOvVHVFe9iRXCF04IHJzA0xiyIAjQpa7m+N47B8OG6EL4JeorF21upaFw77DF/de2wJvfhIYFhLm/pjqYJet2c7IrRV8KsiYFElnQuT3XQy9plISr9Hk71nHtusNaSyrSS6vexZcVuqlyW/WceOWe7Ww4478sbB44BUJ0d4GjnZNYZVtPUEyMxYs1kPm85E6hhU7KXC7Y6N3Qic9jEu7je8uQMrGkrev5y59z6+3Gmk3Y2neDWf/0MmdTY57dsdzcDha4XEXempKmQC0FLX5y8hUvX15HO5ofNHJqOdHML3lWrBme8ZEtoWVHMGK4OODd3PKsaWdvmTHluGlElNNvlBPH+zc4NTVewtAI0Z1IZ1qS7IVjHWneeFjMzrTzmk32d+ziv9jxq/GdbXCWe6iGfzrGuah2JbILuxPSTLOEO51qgdmVjyWOdSwoM54GdFaUFhukzzglyIBmlpqaGFcE6ulPhMbfPWcufPHaCrzaPcSer7TEI1EDtkAvg1bsBC+3nBi/FqaTOx6Pvs+WIExhuvNCZVjSpjOHyuQsMc3lLf9ziLgSGp/pKn0ITL1yABavH7qvncrmpXdXIxosvpb+jnfiQ9T/Tlc1G6B84QLj/0ZL3BRA9dTaT0neyqaR9tR7pI5fNc+FznWzgaNngdEszuFyD1Uhh/Gma/YkMtSEvDdV+cnk7rWnA3aebqGtcQ1fMuYBcUemnqsZZk9Ufdn6OmXFaVQAYrxdPQ8O8yhjmImnysQy2xLvg6XQ3Pl89p598nNOPH8Dm88N6GZ7jgf8Ht/01lHC3daqK2cI9e/YA504njWfiRDIRGnxVkHEuyP3ho4BTgKY5Udrd4dlkreU/wwlOZXN8sC7ESs/4d+8z8Sjp/r7B9YVF/uraYcVnihnDGn8dvYWbKtfsdDJ3B0rIGp4JOxfX6wv9aLc2VJLI5M6ZiZFOd2NJkR7wsua8Z7LRn+OpvnNvNPz8gHMxvCHhBO/V2QhHxulRWLRjVRV5C0c7hwdLJ3tiJDwBNpgEm+or8efS9DM3PdryeUtzoTDPiRlY01a0PRRgjd/L78aYTprLZvjlv3+Rpx+6j44Tx8bcT7ari/4K56ZDNLj4C9A0FYL05+1wsjqlTifNNDfjXbcO70pnf5kSppK2pjJUJuJUL3OCPW/jKtYWgo2R6wyzhSy0b5NzQ9OUHBimWZ1oh2Ata4N+wp5Koom5K9A023L5HI91PjZsGmm6JULPdw8SP9A52LKiOTL9mSTh9jYwhpqGhdULUYHhPLCjIsDpZJpYdnqV4DItUVzLAwxEItTW1rKiejkDNj5m2fbudJa0tZweqy9N22Ow6iIYekd6nAI0ydTZi/XUGOsMu047J8CGUDeYyQWGgQovnjnqZdgdTWGtweUNgytBc7j0k2GicKEarK6ecNvVW3cAcObokZKP299/ALAkEk3kcqVNibXWYlpbSBWmo8VOl5ZVOfVkDx6/m22Xr8K4zKhBf6a5BW9jI8br5ZbOML/sCuNtHLuwS38iQ03QS0OVcyOhY2DqNxK6m09Rv34jHZEkyyp8+DwuAoUqjrFIoZpuUxPu5ctxV1WNuZ+5allx6L672fuLn427jbWW/EAa8habLK3gUTFj2N/RRjaTJhruxeOpwu9bSTw2ykVmtBOS/RCbucqLEykGhmvWrGHt2rUcOnRo2PPF5vYr8877Wt648Yedsa8PrSeajRLOhOdsvFPx23iauxJpXlfp59LAxAFMvJBVCE2YMXRugNX6lw/2AH3mefVUBTzsL2Gd4dHC9M2djc5737PPcy5W//fA8JsmiURhCncsxLrtz2SDN097JkJfcvj77+Ot/dTkYyzzWSrqllGXj3CkfRIZw8LxR04nffRk4esmwzM/cyfrMgN0+aunNdtgqtoHkqSzeTwuM2NTSdP5PA/3x3jB8mru7ouM2rbi4Z/fTHdhynxPy9gXu7nubgaqnYJGkeDi72V4shAIPm97Q+Hz0oL1dEsL3nVrcVVU4KqqKqmXYWs8SUNPN54Vzs0az6pVrOlyAs0T8eHnudyAcz3nrvXjqvSW1Mswby1nkhnWxFsgUMvaKufmdnPnyQleuXA83fc00Ux0WOGZ5GHnRlmuLzUjLSvCHW1ULavH4/NNvPE8osBwHthR4dxVPTLNrGH6TJR0g4t8Pk9NTQ0Ny503uI7W0acwtKed6QnN8VGmnOSy0PHU8GmkAFUroapx1AI0qVQHwaDzRzRWAZr+rgQul+H1P3qSLFmikwgMjTFUT9DLMBdJk5+B0urthaILW5Yvx7hjtA2Ufic3UQgoglUTB4YNm7fgcrtpOzp2CweA1tYf0N1z17jb9A/sB8DaHPES+8x1pLMs62znfy5+GbdsvZLU6enfPbPWcurJHtbtqMPrd1NZ6x99KumQVhXXn2zn30934l1TCAxbz83GheOFwLDaKcTRFZlaMJyKxxno6mTF+o10DqRoqHL24wsGscZFMur8nWTGqUhaNFdN7h/7ze08cPMPCr2rRmcTWWyhZ2guWto0uXS6B497GdE+58RZXDsRqtg8esawGBB2P13Scaeiv7D+taamhh07dtDW1jb4GJwNDBtyTpAcXXYRvoGTkM+yLjh/C9AcS2f5Rn+Ci/0eXl8VmPgFOOsLgXMzhjW1pCLhwcxof6oXj8tLyFM5uL6wsTbAxetr2X+qb8wM6sOROJ841T7m88V+g5dsdDIdLyhkY+44ODx7Ek80AeB1raRyWQNr884lyeNdZ1sjtfTGiaVynJdqZs2OXdSubKSB2JhVTodavyxE0Ovm8IjKpA8/3U4okyDt8tIZSdFo0rRWNdAXmf2bkMUM1WUb6jjTnzxnmut0/KwjzKv3H+OCyiCxnBMkDtXTcpoHf/oj1jzj2cTOu4j2001j7ivb1c1ApfNziAbMou9l2NQdoyrgYWdjFUGvu6SWFfl4nFx3N77CNFLPyobSppLGk6zo6xkMDL2rVhFMp1iZzXB8RAGafNz5PXJXenHX+nHXriLdNL2MYU/GSR6sTnU6GcM6J+PV2jN3lXsnq7v79+TzU78BXlxfODRjmCwsecr1p2isbMRt3CU1uQ+3t1G7cmFlC0GB4bywo9I52U9nOmkuliHXlyJR61wA1tTUsKrR+UVsOzX6H3FrzLlYOp0c5STY/TRkk+cGhuBkDUfJGKZS7VRXORVM02NMJU1E0gQCec6EltPjMvSO09x8qKoJehl2fu0x+m8rvcn26T7nQuayNefh8cZnpCrp2cBw7KmkRV6fnxUbNtP29NiBYT6f4umj/8Lp0/817r4G+vfjdjuLRGKx0i7MD0YTrO7q5FerLuMXm67EjnOneSJ9bXEivUk2XOBkD6rrAwx0jzaVtAXfurXkreVUMkVnOou7rg7j94+bMVxZPb2MYfEuev36DXRGkjQU9mOMwfqCZOLOhULqVNOY6wuLvGtWk2lvHzdgmwn9XR2kE3F6WsY+aeUiZ3+H8yUEhtlsjFwuRj59tgJmce1EKLSFePz4uQFCtBAYdpWeAZ+sYsawqqqKHTucDPzQ6aSdCee9aUXS+XmGVz4LVz6DL3LqbGXSxPwKDAdyeb7YF6PObfj/6kK4J1hXWBRvb8VXXYu3Yvi6IH91LTabHfydLja3N8YMFm5aUeXnkg119ETTNPeO/j79q74B7h2I0TfGLJdilcdthV6C21c5N8cONIeH/a4k4qeweUMotA5jDGtsBS7gsa7HBrf5zoNNAGzoO8zanRdQ07CSqkzknGBvNG6XYdvKynMqkz7eHGZbXzNNHmd8ywMuEh4/Bw82TbjPUp0urLW8ppChahqjv+NUHCtkj5Z7PU7bip6z35t8Psevv/5lfMEgKy7aQ97ro3WUG2xF2a4u+gPO+1c0CLkZmD0znzX1xDivLsTDt55ky7LQ4O/uaJLJJL/97W/JjFFBPF1ok+MttFryNqwsrfhMOktDXw/eBud3xb1sGcbnY308wskRU0ltxoBNYdwu3NV+XBXLpz2VtKWw3nZtqsPJGDZsch4fGL92xVyLRp/mscffRXvH1Kt+7uvYR2NFI42VzjKVXCwzuB4/15/C6/KyunJ1aVNJO9qoXbWw1heCAsN5YX3AR9DlmlZgmCmsL4yHnLvgtbW11K1cjs966Ggb/U7VqYjzZjGQ959T2Yq2wgl5VaFVxX+8APZ+0/l49W4ncEydzaZlszGy2QEqK3dijHfUqaSpeIZ8zhLwOhcZAwbOnJlcRq562dgZw3w6R643SeJgb8lrgw52OEH0RY3rqQhYBhKlX9hPJWMI0Lh1O+3Hj5If+TMpCPfvI59PjpsFtDZP/8ABGla8GGO8REsNDAdiLOvrpdcdoD1Qh7uEbFixGmkxMKyqD54zTbh4x9W7dh1tqQypvKWrkOEeq2VFMTBcUekELp1TzBh2F+6e16/bQOdAipVVZwMgV6ACUnFSAxFyXd0TZgw9jY2QyZDtmr3+X9lMhmiv8708M06GOdd/NjDMlXCjo9iqIhM/u66tv3AXvCK0mWw2MriNs2ESUoVM3RxmDAcGBqioqMDj8VBfX099ff3wwLA4lTQWBm+IgeW7AfD3HaPGW0ONt4bm+PQuAmx7O3bv3lK/hGFy1vLlcJxwzvLhugqqXJM/XcfbmodlC12pHIHuDP7qWuBsk/v+dC81PqfgUudAktqQF7/XzSUbnO1Gq05qreWJwrmqPTP6FOXuSIqA10XI70xJrPB7qAt5iadzPHXmbJAWT5wiE/NTtXwlAEGznNVuOywwvPNQJy6bozHVzrpdF1LTsBJ3YoDeSJye6MR/6ztWVXO4PTJ4jkikcxzrz7Cj7zRHcW6gBSqdSo6PH5r9yrSneuN43YYrC9NrZ6IAzalC9crOTJYrair4Xe/Z7/GBX99O29OHed7b381AzDlW3zjVpRO9XUS9zjloqawx3Gl87L29iQtcvnF/HgcPHuTee+/l1BgBV7GHoW+9M4PKs2rVtNtVxHN5+ixOc/tCxtAYg2fVKtb3dp3TssLmfOByzpXuGh/GU0n61KlpXRudSRWqoaa6IFjLyspqvPksLfOsEFEs5qwRj8emlhyw1rK/c/+waaSpY31gwV3nHzx3rq+afsuKdCJOvD9MzQIrPAMKDOcFlzFsrwhwODb1P7piYBh1OW8SNTU1eGr9LLOVdHSPPq2zOXr2DlbLyHWG7Y+DJwj1WyEdg9a9cLJQPrzxYkYWoEmlnDc9X8c6gtkto2YMmw86d5ncOCejtE2TiWYIxye+WK1aHhyzl2GuMB01H0mTaR9/wXh8//5xp/gd6+kGclzSeB61IQ+J1OhNo6ciERnA7fHgC45fVr5o9bYdZFLJwQzWSL29ToP5VKqdbHb0wDoeP0E2O0Bt7eWEQpuIRUu7MG9ubqXXV43FkHF5iURS2PT0goxTT3azfE0llXVORq56eYB4f5rskKlUxTuuvnVrOVk48SXzlkguP2qT+1zeEklmqQl68XlcLKvwTStj6A0EqVi2gq5oanBKKoC3opJALknnQecENGHGsNCyIts2fJzR++5j4I47JhxLPp8nN8aNgaKBrs7Boi5nxskw5wbS5PqayLY/UVLGMJ1xgr5k2LlZ4q+ooK8wlbSi4jwAYvEh6wyHriuc46mkNTVns/M7duygqamJeNx5b+iMd1LhraBi4AyPey7im/sGsMaNv98pdlIsQDMd9qc/w37+CzNavObmSJLHUlneURNkyxhN7EeTz6RJdHcMW19Y/VSUDXf04Q86GbJiy4rwkOb2nQOpwWz5qtogjbWBUQvQnEln6SlkCovLEoay1hJP51heuFFTLHxUXG9499Nnfz8S8VMk+zxULXeKkvn9jWwMZHmi+wmy+SzWWpq646y1/fgDARo2bSkUcrBUZaMcmcR00h2NVfTG0nQVgsgnz/STx7C97zTtAWeqa7qqBnc+x9Ez4Qn3V6rTPXHW1QZZGXS+LzMRGB4MO7/j3znQwjaXZ7BtxUBXJ/f+4NtsvPhSdl79PHp6nBtKCQvJ2LnnEJvP0xc/mxWKBs2MrDFsDSd4//f2TarFyFxKZ/O09iVY6XJueq3KumjuS5DOjn5j+ORJZ41d8T3lnP0Ntlpy/vY8KxvIdnVhs1P/utsKwdnQqaTgTCdd09ZKbyZHb+HGTD6dxnhCGL/zO+Wu8QNe8okMuZ6pF9IrtjxZneyEYB0uY1idH6BlnrUyjMcLP4/E1DKjLZEWuhJdw6eRHunDFfIQ3LWcXH8Kay1rq9bSPDC9omThws3TOmUMZbp2VASm1eQ+3RrFvSzAQDxCKBQi8uNjpFujLMtX0jXQTX6UKW1nEmdPCKdiI9402h6DVReCyw2RQsaxt3A3pliApu3s3dxUqg3ybrI/r6Ly+AtHzRi2Hg0DkC9cYG7tPkLAGr59z8QLmYuVSUebTpobsk4xeWTsKQ7WWprf+xd0fOazY27T3BfB5Y2woXo9KyqDZDN+0tnS3gUTA/34/QFST0/u4rixUICmbYwCNL2992KMc4FYfEMcqb/fWV9YU3MJlRXbSs4Y9jU10VJZP/h5c+WKaa2hSyWytB3rH8wWAlTXOwFzpPfszzZTnIqzdi2nhty06Ehl8KxuJDMi4BooNLevCToFORqq/FPPGDY3Ub9uPX2JLLm8HZySChCsqiKQT9H7tBM8TLzGcPQiOd1f/Rqdn//ChGO59dZb+f73vz/uNv2d7YWxVY879TgXSZE6fCuJR75Opis84bHHkk45f7exnhRef4DG87bTPziV1KlMOuyObaxwcyhQC13j//51nY5w4sDMFKgZGBigekihp507d2Kt5ehRJ6gf2sNwb/o8KqKtRCo2DVYmXR9aT3O8mbydxmyBri5IpWCMC8apeiKV4eZoimuCPl4YmlrhgnjHGbB2WGDoiWUxFioGnL+Ts4FhD7WFFi0d/clhN0V2b6jj8eZ+srnh34/Hh9zAbE+fe8F7olBQZUN9iOb729n/pSfJ5fKcv7oaA/zukHMz0VpLPN5EasBLVb1z4VtZuYFN/jyJbIJj4WP8/nAnOWvZnjzJmu07cXs8gz3BqrMDPD2J6aTbC9NZiwVo9p92Ap0NA+3EvAEaawI0u6tZF+ngZGT2A5emnhg7g/3c9NV/Z12Va/D7VYrWVAqTG+B4LMl/3+KcP/7xwePcfuOXAXjRuz+AMWYwMMz5Q6MWoMmFwwz4z34PIiHXjKwxvPtIF7c90cbBtvnVF/F0r9Oqoto6l8IV0Ry5vKW5b/TWKsXAMBYb/WeWaW7BVVmJu7YWAO/KVZDPk51GcHamMJ2zIdyHe9mywcc9q1ay+pTzflucTprr6cH4a3CHnADXU+P8HZtg7bSmk7amMgTJsyzb77yPA2tMhlYbmLNK0w/96MukJ6iCWrwOShTWKk/Wo51OxfZiYGjzluTTffi31eGuDWAzeWwiy/qq9UQyEcLjVPkfS3G5hTKGMm07KgJ0pbN0j3KiHU+mNYpvdYVzt7y6hsSTPaSOhlnuqSaTyxIe0ffNWktHOkc1zknyxMCQC9h83skGNhamkQ4GhiedN4PqRqhcOawATSrVji++Epc1ZKJVo2YMuwvztqMR5wJwXdj5Y/7pfaeIT/D1jtfLMNvnPOaq9JJ6euyTV6a1lXx/P7GHHsKOkY3piqQJ+tNEbzvF1swywM3RnpZxxzaRxMAAnr4w3V/92qS2r2lYSbC6ZtQCNJlMH5HIk6xY8WKAMaeT9vfvw+OpJhTaTEXlNpLJFrLZ6V14pPN5cs3NHGw4e4F5umrl4F3RqWg51Es+b9lw4dnAcLSgvzgVx7tu3WDGEKAzncHb2Eiuq5v8kIxlfyEwrA0VAsPqwGARjcmw1tJ9ulCRtPC6hiFTSSurq/HnksSPO7+zvvXrRt1PkXe1cxIYGTxnWlrItLSQH6NScNHp06dpaWkZ9w5lf6dzYb187Xp6z7SQiI5+cZzrT2PT/ZBLE7v3N+MedzzFaaIDHXFqVq6iZmUj4fY2rLX4/atwu0PEhvYyLK4v3HAlDLQMm3o+0qO/OsXvvntozOenYmRg2NjYSFVV1WB10o54hxMYhpsJ20pcBg65tg1WJl0XXEcyn6Q7NY1pwMWeiTM07e6hRIaggXfVBjGTXFdYFG933reG9jB0F6bGV3Q7p/xUf5i8zTGQClPjX+Y0pI+kCHrd3LLPmVZ/yYZaEukcR0ZU9HwinqTa7aLa7Rp1KumjJ52bdDtWVtF8/9P4Kg8Q60uxtaEKC+w7HSYcT5PJ9JHLR0n1+6ha7gSGNcu3stHvjPXxrsf50V7n/WBd9xOs3XmBs02DM+10lYlzpGNyvQyBwXWGB5rDNGRjpNxe6qv8XLahjvZomsZYD6fykyvuM5ajR4/yxS9+kcQYU+6stZzuibOMMLlcji01pVfBHMjmyCX2s7z1/2PzWvj8i3fgS+e5q6WF1icP0L7tBTzZ7yIajZFIJAgEAlifn45T595czHZ1D7aqAKcq6UxMJW0pBFrFIm/zRXE9oT9VKNLVk8JYRl1n2N3dTTTq/KzGCgzTLU6riuLfrKfQsiLbPvqynnQizsP/e/OofSVbCxnDRnLgcvGLzjA5a/GuaqTxaSf4LxagyXR1YQI1uGuc319XtXMzyRWoG7UAjc3nOfrw/eTGyGS2JtOsNmkMQLAWgLV+Ny3++rPXhbPosftu484Dbdzyn58Zd7vidVA8PrUps/s791Pjr2FzrXNjM3MmSj6aIbCtDneN873L9qcHW1ZMZzppsUDbQuthCAoM541iAZojU5hOmk9myfYk8a6pJBwOU1Ph3BnNhpPUVxTuAo+Y355MnqE3X8GuQAq3zXIqFj77ZN9JSA2cLTwTLbwBpPohXrjjNaIATTLVjj/iXIBUDYzerqK/O4nLY+gpVEqrKUw1y8Vz/ODh8YOM8XoZ5sIpcEHo0gZSTQPkx5imkiqsM8oPDJA8eHDUbQbibpZVuog+2MaGiLPe5Kmu0gpRxHu78abSZNon177AGEPj1u2jtqzo7XsAsDTWvAFwj14JEqciaU31boxxUVmxDRgxzW8KjsVTrOxo4/iyVfhyKQK5hBMYTqNlxakne/CHPKzadPbCvbrQ4ywypBBRurkFV0UF7tpaTiZSeAsn2K50Fu9qp/fh0F6G/VPMGHZefz0dnzl7son19ZKMRqhft3GwmmnDkIxhbW0NgXyKzOlTeBobcU0wLdhdVYWrqmpYk/t8Ok2205n+Od7d22w2S29vL6lUaswLDzibMSxOOW4fI8OcG0hjC2v94vffNu1pjk6lYUP4TB81DauoW9VIKh4jGY1gjCEU2jz8RkUxY7jxKuf/nqNj7jvalyQVG32q+FQkk0lSqdSwqaQul4sdO3Zw7Ngx0uk0XfEuGvzLINFLLO+c/B9Lr8Yb78CVHiitAE13IZicocAwnLcsc7vwTzEoBIi3teAOBPHVnr0J4046N8QCzSlcXh+pgTAD6X4seWr9ywnHM6SzeToGktz4u+O0hxNcvL4Wlzl3neETsSS7bT+bBo7R3ddyTgbhUGEN4booVK6+g7VXfZlwVx/nrXQK4VjgnqPdg60q0gNeqgsZw+WrLmCZ21Jt/DzW9RgPn+wjZFNU5BKs3XUhAJXLluNye1jvS06ql+GyCh8rq/2DxWr2nw6zbeAMnaE6zl9dw4blIdr6k9SmovS7A3RGph+8tLW1EYlEODPGrIq+eIZIKosvXVjv6ouWPJX0dCKFO9uGIcuZaCtvfMZ6Xr+6hmRDNekVG7kts5E/+c+HePO/O1PZN523DYyhuencc0i2u4v+0NnP4z5Lpq/0giMthb6N02klNJuKhX9sLItxGXLpPMvyZtSfSTFb6Ha7x80Y+taevSHjXencxBirl+Gd37iRe77/LU498dg5zxWb2zf6vTzcH+NdTzVxV28Eb+MqGjvbcHM2Y5hp68G43LiXOWtmBzOGlctHbVlx+L67ueWLn+bgPb8bdVxnUhnWUPgaCxnDtRWVtPvqSU8wC2QmHD/0BGm/n7b2sQv3WGuJxU/gcgXI5xOk05Mv8rOvYx+XrLgEl3FCoGShz3ZgWx3uWud7l+s/27JiZAEam8vTe/PTZLrGniES7mgjWF2DPxQac5v5SoHhPLGz0LJitAI01lr2738bHZ2/HPZ4utW5e+VdXUl/fz9VAefEm+tLsaLOmf7XPuJO1UDkMfpYRmOvn2Wmj+ahlUlHFp4ZemeoOJ109W7oPuKsP8TJGAYjzl0Xby5EJtNLPj/8Ii8ZzRAKGvoy4MZSU6gOuHt5Jf/xhxOkRqlsl+3tJZ9MjtvLMNeXxF3tJ7B9GeQtqWOjL6hPHjrMwGtyJHbnid3/wDnPR9IRMukQa0MVkLM05JyLxqPdpd0Zi/f24svlybZPfvH56q076BslC9Tbey9udyWZH3rxZ1eOmjHMZiPEYseorrkEgIpiYDjNdYYHowkauk7R66tlVSDPskwfJ2sayTRPLZM62KZi1zJc7rNvORU1Ptwe17DKpMVWFcYYmhIpLq5y/i6KGUMYPk0zPEpg2BVJkR+jH9n+w8d48oFHBj8vFp5ZsX7DqBnD2tpafDaDu7V59Mb2f/gC/Pa6YQ+NbFmRaW0dvHhOHz+3eXdRX9/Z9gA940w9Ko7ZCcxcYxagyfYnsYkBXNUN5LpbiD/8yKjbTSSV7sLrXUZ/Rxe1K1cOTo0pTpWpCJ1HLDbKGsMNz3b+H+dCojiNuL9r/Btij9/5a3711RvGfL5YkbR6RM/QHTt2kM1mOXb8mBMYuvzkMWQLp74j8VoA/OFjgy0rplqAxsZiUMwQzVBg2J/PUzuJYjOdkTQPnhj+vhdrayG0as2wTKM7kSfvMbjjOQKVNaQGwsOa2xez7MlCe5O9J/uoCng5b2XVsH6GvZksrekMVww8wfrYKbpiYTb+9LX4u8/ecCtW3cwe6CVQF8a4LP09ZzivwTk/Bbwufn+kc3BdkJMxdM5X1XVbMAbWmwD7Og7QF0+z1fTi8ftZtcVZz+pyuamuX0E9MZ7uiE7qhsf2VdUcbovQ3p+krT/Jjs7jdAXruGRdLRuWVZDNW0I4NxYPtk5/umO033nfbm0dvSL4qUIgYlLO70uNq5u+eIa+EopDnUqmceWcMSczffRlcyzb+wfSXj8XffCveOgfruVLb7yYVYUpojc96bxndoxSLTPb1cXAkOtYa2Bg5HKTaShmDCcKDHtao9z57YNkUqW38JiMpp4YNQEvsb4Ua7bVArDZ7R21ZcXJkyepra2lvr5+1DWGNp93zl9DZpV4VjkV4kfrZXjkgXs5+AcnMBvoPPda40wyQ208RsWyZbQWgsTWZBrPqlV4cznWuc5mDLMdYQC8K50bY8Wsl7dhwzk3I621PFLogXt870Ojfl9ak2lW5yLg9oHXOQevrV2BNS7auqZX6XQq+grr8xKJ7Jh/3+lMD7lclGV1znkmHm8ac3/5eIa2zzxE6mQ/PYkemgaahvcvfLoP79pK3JW+wvpMJzBcU7UGg6F5YPg5IdMeJ763g8RjYy+DCLcvzIqkUObA0BjzEmPMEWPMMWPMx0d53m+M+VHh+YeMMRsLj280xiSMMQcK/26c88HPsAafhzqPe9RehsnkGXr77qO9fXhD62LhmWydi0wmQ7XHuVuUDScJ/P/s/Xe0ZdlZ3gv/5go75332yady6KzuVkstJIGQAAkRDCIZ43gvHjYO+F6DscH3s30/38HgXtuy4drYGDDZAksgUAulVmx1tzpXdXflqpPzznmvvOb3x1wn1TnVUguMxDeYPXpU1Tlrr7XXWnO+833e8Dz5FHlShzKGrc4r9ESByqbBeDhgy90Xkd5+FTQTxu9W/+7vy3Tt7zOUIWxfBsCxt4n3lCHUQ3X9/QyFw56DDCWFpEMnnqEQE2Qj8dxvPlZmu2fzRxcPb6LLP/SXafzif35NLUO/46AX48SP5xAxHfvm0ZFN68Y1hu8Mcd+RZvjsYWB4uXYLwgSn4sqolhz1TFbaf7IN0RoOMP0Av9H4ipvPd/oM92eBpJS0Wk9RSL+ZoOkRG00dCQy7vVcAST6ngGEyOYemJV6zz/Cxxx7jC1/4wpG/u1pvIoMhA7PAqYk8JbfNWnYC53WWkjbWBox67oH+QgChiUiOZF/GcH2N2Nys6uewXN6QTRHXBFXX31emeeeM4UQugR9KWrcRGzVcn398fZW/+Vd/jP/7u38Ir6Y26vquVMWJXYHvyj5gmIyARrq2cTTxzMsfgCsH1+XtIvfe+t78dhbuzJ5Wr+9tMq8JDPdJVBSmpu5IQBNU66rX7M3vRcTTtH/vd+94ztcartvANEr4rkN+Ymq3mX6/lqHjbO2VLA/qEMvC+D0g9DsS0AR+yCgSZT5KtmT/WLzwPNee+vwdGXvvBAxPnDhBPB7nwrUL+NJnPBT0SSNUkRR9qZyeeGeetJFmLDb2+glo9r032p3X99k7jG4gyWtfPlv4sUsN/vMT67tkGTIMsaqbB/ULpUS3A/pzal4njAxOr3NQ3L6r5n4/6mt6aVnZ0oeOF7ix1dslDXk1kkV4S+slpgxYTc1itBc59T++nYkv/gs0p0uj75A0NNyOR25Wre1+p0ouYTKZS1DJxHniRp3hcAWkQAQFYkmFRgwjS+iZzMqQ9cEqQh9y92ie6XN3oxvm7i3lxidIO10Gjs9G58tX2dw9mWW+NuDFFXVf91ZvUksVeOh4kbmSurYZiVBfWvzqWCQBuuvq/BvLRwfPVlsjdEL8qHQxHqi5s/QnkKxYsVy0UM1/Lejw0rPPoH/moxgy5EUtQcLUed9Ds/zwA0WE0Fi0UwigMzh8zaChSkn3z7yO9adRSqre0XbvztUc9bU+f/TvL3L9me3d9pP/2WO5MeJMMYlnB3zE+QBGXOO0bh4qJQ3DkKWlJU6ePEk6nT4yY+jXakjXJTa3Bwz1YhFhmoe0DPutBp/5lf/E5JlzmPHEbnvA/rHhuLuMpLUIGG45HmYENo95DotRxtCPypGNSUWmJEwdLWWgl6YPAcO1K69SX14kUyqz8urLh8pY3TCk5vrMeC1IFiEKMM3mVVZ/vfPVy298pcOKqstCkWS9f/Ra2ulrL4+9U/37NfoM3a0hQdfFXe9zsaZ4GB4aV35SOPJwV3skzqlnp2diIBQwjOtxJtOTh0pJ/chn8bbvvG471a0/l2Wk8DUEhkIIHfhF4L3APcBfEULcc9thPwq0pZRngP8A/D/7frcgpXww+v/H/ky+9P/EISJm0muDww7SjhZdp/MCUu5jcNwYoOfj9H0VvcpoUZmbL9ESBqUgcwgYrnTVYqo4ggnfZTtI7/1y6xUFCo3IMe5XITsNQjuYMYTdPkPb2cYcqskvZAbkQZH7tStqoxzTW3RjacYycZLT4xjSZdwwuHc6xy89sUiwL8MjfR9vfR1nXmUhsuXEAYKSnRF0HIxCAmFoxM8UsG8cLchsrVxDmhIxmcV66cKhPq+Lm6pE5LShnMrcSDlBm92vPnIcBgGu7xHzAwiCL9t83mh8nl7vVSbPnI2yQHvA0LKWse0Nso4yZGZnnNFoCXkbSYYinhHk8w8CIIRGOn32jhlDKSVXrlzhwoULRz637uc+gSc0OkaWyY0FSl6bkZGguvn6erBWLjdAwLF7yod+tx/0Synx1tYxZ+doeD6jIORkKk4lZlBzPRV9FeIAAc0uMEztZQxhLzIdSMlvbDR423PX+NB2i8m+xcb0SZyo76yxuky6WCKZzVHr25TSMeLGnixDIpPB9APi9ugw8YzdU+uit6n6c6NhTh+RMQS0VAp36c7AsBGVI2qa9prAcNRpI6JsUm5snO35G4ThQcAkQ4nfVOtQTExhnngb/U9/ZhcQv57hug2Igj6F8UlyUY/XXsbwtPpeVtSzNKxBpgJGDEqnVIXBEWPYcVRdIdB9jZIcgH6zQRgEdOtHO+37xe33D13XOXfuHK8uKcH0Cd+lhyq5DxDERcBQz+32Gc4mZ1+/yH1jbz3IPyXNt04Ykte/PDBc7zhIoB6xztrNGqHnHiCe0VyJ60uqUhJUEiTDJE53f8awtJsxbA4UUH9ltYPnhzx0vEgole4fqDLShBA8VHuaCVPHQ+P5H/4c7fv+OqVLv0nut74bL5BkfUhPJNFj6hqjqO/0bFRO2hy6XN5oEbppMqWJA/ckwjwzRP3jiRXK1SvMRf2FOyNfGYeBOvdXInR/11QWNwj54s06piY41d2glixy/4wqJQUY5EpMDptcWfrqyZBGkT7k5tbRpaTLjRE5zYYIemmemi9LdyCg8et1Gr/0X19TF3V+YCF89QxMt8mV3/5lpqem+IZils+19p5Ns9mkWCxg6DpCM7GlwLkt8+XXG/RyBmKfa9hz+38iXVbbC3bL+6t36DGsr/b5yH+4SBAFOKz+nw395VJjyOmUah1omJvEJkMq7uFS0mq1im3bnDx5klQqdSQw3O2Pn90DhkIIjPHxA1qGMgz51H/5BXzf4zv+4U+SH5+gWz9slzdtl0qjhlGpUI3Yf7d39kHg2LDHoqXYM4MoOGKW0livvIKUEj0fR8uUcVdXD7y/F//4D0nlC3zr3/77+K7D6uWDZazbjocEZpz6bhkpwGxS7a3rR7DZ/mkPz1Ubgx/P8mL1aBmgneB4qfhWhIhhje6cyQwiHyPoe7xUfYmEnuDe8r0A2PMdkKjKM0DoAj0Xe03JCr+xAwyP3rd8z6PfbFAoF+D/OaECyH+OxtcyY/hmYF5KuSildIHfA77ntmO+B/jN6O+/D3yLeL2d+H+Oxl2ZJNeH1iEnfSfj4/s9BoO97IC3MdjtLwTIyL1MB4agFGZot9s4TiTrEPq7UhUVO2RqJGnJPCOnqUrdtl7dI54BlTEsHIP87B4wzE5BurJbduoOWxhOEcEIiKF7Js4+AprNiJG05G7QTWQpF9KYM9PE3R6jjsM/eOcZlhpDPnl5L6K20+zuRWWwR2kZykAS9Byu1y3Wr7dInC8SdBz820rSgn4fx1KOuZMeIF0X68KFA8dcralNfNpTzy8f2dDa4KvX7LGjUtC4rrKjd2o+3xnXb/wLXr3099FNwdix4wcIaHZkKpKb53GufBhtqUcYOtj2bQyd3Quk02cwItFm4DWZSfv9Po7j0Ov1DpEUjbodxp//PMmRRigEUzdfpeiq97LQ815Xv9rK5Sbjx3OkcofZFbNjyd1skV+vIx0Hc252t3fiZDLOeMyk7vhosRjG2NgB0NWNMoNCs+g63d3+wFrf4UJ3yHtfvMlP31zn/kySx09X+J6VIa1UnM51BVYaqyuMzalMYLXn7AJLKSVhKElksqSjaO2hjGH1ivozcA9INJjT04S9HkFEVOBtrINpknzkjV82Y5jL5SiXy3cEhoNWkzAImDipwFg8mcK1rEMMg+HQQ1oKLL28oWHOfSP4Pt0/+IMjz/tH1Tb/ceVo0OW6DaSrnmt+YhIzFidTKu9qGR5iJh3UIK1IFxg7B42jewz3B3u+XMaw31Tgq3MHh3u/uP3t4+6776brq2dRsYd0hQKP1SBLXjjcDI/tAsNjqWNsWBsE8nWUsu1oVsZi8KfA4OhIiSX5sqWkUkqmY1/kp9/0H6j11ToYbe0Qz+zLWlgBN52Q668McI9nSXqJKGOogFUhXqLWc0jFdFw/5I0nitheyOWNLndP54gbGheXOwBcGlrckzRIDbeYTKpgwaZIs/2On2Xphz7OhdgbAXgDr3DPQx0CT+0FlqXWx5nxDI0IfH5p2cDrJ3bLSHeGoVeYjTlIqZFNLaIhmb3nNmA4Pok36GGEHje2v7yjen5CBf1eWulwd04jFga00kVK6RiTuQQxXaOWHeN0d4OrXyZI8Vpj6KjP9q0B/f5hwLrSGnIs0hw2DI/QddC1O0tWdB97jPrP//xrMlvPD2y0aH7PbF8l6HV494/9I76lnOfG0GY9kh5oNpuMjY1x12SOAUnCRJLG+kFn2q/X6RVMKobPP56UJISkHw8Jj7iXr3Rs7oAWXVA9on+zutzjIz9/kVjC4Lt+XPEbWIOvvrT2Kx2OH7DZtZg21b7Uj7eQlRHxQUCtY2Ptk1Ha6S88ceLEHTOG7tqe1NL+YUxOHtj/L37yo6y8epFv/ut/m+LUDLnK+B1KSV3GW02M8Qq1iKRv2/HQCwVEIsGxZo1REFJ1fcKB+r2zdI3lv/zDDD7/BfRcDIws0rJUjzvQXF9l6eKLPPju7+TEGx4mlkwx/8LBctKdstUZe2uXeAZgOq6Cr+t/AskR6XnU3v/+15RACcIAidqH/ViCF9fvDAw1LUYyOUcyOfeaGUMvyvCFA5eLtYvcX7kfU1f3syNTEZvb2zv0fJwgqqKYy80dKiXdAYZ+00J6h/eKbm0bpKSYjYPVBuNPRmr1Zz2+lsBwBtj/tNejnx15jJTSB7rATtrhpBDiohDiCSHEN/7P/rJ/FuOudIJ+EO42He+M4eAmuq4ire3O8wCEjo/fsHYZSQHS3j5gKCUlqT6zkzUcDm/RlCo6OuZIproGUugsdhZU1mPU2JOkANVjmJ1UUf8dYCjELgFNEDiITgKBIK4pJzk5TNMf7TmYjXW1aaeai3TTRcrZBLHZWWKjJoO2zXvuneTUWJpf/Pz8LtjwW8ph2TGm2XISZ3SQoCLoOchA8sq1Nq98bp3EWVUGYN/GTurcuEFQjD5j2mAYDJ85WE662FTXy1TVphVDEDdCuqMAP/zqjOAgcppzZ1Wfn/cafYZSBrhuDcfZYm3t15XQ/fzN3Shfq/UUicQM8mYab/VpuKRA42gfE+SOsP1OGenOSGfO4bo1PO+wId5furh8W4P6Ex/+ILrvk4hEzae3lij7HQDWYoWvWBvJGrhsL/UOlZHujFw5gT30cG1/V6oiNjvLUiRVoYChyhgCGNNTh8hnEqbGzzz1U7zvI+/DRW2A//HmJt9x4RY11+eX7jnOhx48zal+l2lPOQHLq5uEYUBzY3UXGNb79i6w/L2/+8/5wI/+FMn9wPD2jOH2q3t/7+2VuxhRL+TO93TX1zGnp4ifOYu7tHRHZtxGo0GlUnlNYHjzORUkOPGGh0nlC4TRmrldtiLoOoS2sgt1N4lIj5N69C20/8cHjyxr/o2NBr+wUt09386QUuK6dSVuLwS5MQX4CpNTu1qGqdRxhND3mEmHdZUxBKicg+YCBIevOYiAYSJtvmaPoe+6WD11L+3tOwPDTCaDruuHfnf69GmcWEQsNGzTNNU2UyWHIUJ+2fk2Yp0FkCHHUsfwpMe2/ZX3F8tGAzQNjh+HP4WMYTeShyh8mYxh1/I5lp3nbHGJZvR8RtvrCN0gUZncPU63Azq+REqwp9Mk9TS+NaI9qhPT4iT01K64PcB77p/E0AUvLbUxDY375/K8vNpmEAQs2C4PCuUUV7JqTe9oGdqV+/j03N8H4M36FR66/CPIMAqOuGo+nx3PYnkBd09leWmzwqit7RLP7IxkcoaqnCa0p0illjDMGJNnzh84ZidrfTrhfEUENKfH0+hC9fjdZ6p5NygoQKppgtlSkmqmzOnOBqu2YPBVOr+WZ1OMsutHEdCsNkdMxdRcn5yK4zopZvLaHYGhc1MFVY5iltw9p+0SC9S8S482GbzlnUydOc+7ygoMf67ZIwxDms0m5XKZB2bzLDpp0HRW5w8Sk/lRKenZRMBx0+JsIvgTi9yvRWWk907n2e7aB4KK20tdHvv5i8RTBt/7kw8xcVx9Z6v/Px8YrrVGSAljEQFJP97CKrYQEsYDsUtMAwoYjo2NkcvlyCTjuK6L5x3007z1NdC03V74QcSabk6M40Wloo21Fb74gd/g1MNv4oFv/XZABTm69eqB59L3A/qhVBqG4+NU95WSCiGUluGm2nMWRjahAzJ0cRdUAMG6eFH1ykUkWzvz58U//iMMM8Yb3v0d6IbJyQffyOKF5w9kFDd3NAyHa8hEjlvzP4fntUnoGuM4rJPc5Zh4vcO+fp3mr/wq/c985o7HbA428cwkZsQ+vrB0NGv1yFommTyBEDqp5HGs1+gxDCIg5/Zsrreu75aRKpmKFvGzRcS+0v0DwDA7R9tp03P37IzfsFTSX4JXPRxI2mmzyCejvT53O7T5+h5/XslntoBjUsqHgJ8APiCEyB11oBDi7wghXhRCvLjfEf56HHenlVN6OwFNf3AD08gRi43Taavojrc1BAnmbJZOp4NpmpiW2GVUkn5IKTwIDHs9RTwDUHEksx31+8Xe5mHiGYBBdQ8YNveRZkw/CPXruMMV4gMVHYtrykmOD9OsNfbwfr9poRsCf3mJbixFOR3DnJkl7rQZNC10TfBj7zjN1a3ervDxDugI2m1C295jJt2XYQjaDp6EMJA01vsYpQRGJXlIz9C+foOgqAxuKF2SD77hEAHNZkcZuULboxqVZ+ZjgsBPsjX4yhhFbx+9qwoo5x9SBuj2HoP9w3UbSBmgiTjLK7/ExJlpnNGQ1uY6YejTaj9DIfkWws4Q6fTRV5WB2s9MOhot4fs98nnVUH19fZO1emOXmXQwOJy12dpU88IgOAAM+80G1z7zCRpjs7RjBQCmh03yvoUpvYiZ9Cvrw1q72gLJHYHhrmRFwz5QirNsOWjAbMJkPGZSjSKmSuT+IDAsJE0uNS5Rsxr82MXfBuCFWo+/N1fhqUfv4nsniggh8LYbTLsqg7va9ehsbxF4HmPHTgB7GUPp+5x79nGOX3o2yhi6BELg7XO2gYPAsLsHDHdE7ncym976BvrkDEzNIV13t7R0/wjDkEajwdjYGOVymVardaQG6dJFpb/U6vbww5BRp00ymzvUZxj0XGQEDC0jiyMh953fj7+9zeCJJw6d9+bIZhCEB7QjAYJgoLLTPUmmVMaI+rAKE1O7WoaaFieRmGM0jGzE7RnD0FOMx7eNflttvNNnC/ReAxgOWnsgub11NKnH7eL2+0c8HicxlkBIQbm3TVMbw5Ma42UVMbrEGV70jmMONvcIaF5Pn2GjAeUylEp/KuQz3VDycO8K33bz117zuLW2Qz6mbEHfioJ/W+skx6fQ9gFkMQroBsoGWpkY8biKjLeGVQrxMkIIaj2HZEytjROVNPfN5nkxkp148HiR9ZbFlxp9JPAmV831cl7Z/v2SFVeW1Zzzz/8D6ve+b/fnUtYJ/HC3lPRsJcFiZ4Z6LbkrVbEzsrlTPF1/C4F1DCu+zcS5cximeeCYfEUBw3Np7yuSrIgbOrPFFH4oOWPVCYQG+zKVx0sp+tKgEq2Za1+F3l4YhljSZSYsIzgaGK60RhS0PrHYkEL+OK6bYjrTO5LsBNhtp3CXj9atDaSk7vtoUmX07LTkyjcoSaOzqTizCZPPtXr0+31836dcLnPfZIqloADA+srygfP5jQbdZEhBV/PlRCxkkAD/T5AJ3yGeeePxIo4f7pb/by10eewXXiaRjfG9P/EwuXISBxtiIcPenxIwDAO4+fiR2ntLDfW9El6Ipzk4xogFQz3nyWAPrAdBwMbyPG/PrsN/ew9vf+L7GaN5iIDGXV3DnJpCxGJszXf4zZ/5EvXVPsbEJH61hue6fPw/vZ9YMsW7/+4/2iWHyo9P4FoW9r4SzR2pip0ew91S0gggGlOTTC8pe7toOUhfRwiX4fJlmj/m0V94ET0fR7qAZuCurDDstLn25Oe495u/hVRO2crTjzzKqNtha/7Gvmura0z3V3A1n9XVX90lPpwxYCMxcdAfjIb/FfAo7LTUvJYW8kLjJk4iyXhLrUW9Zh/ph41Gi6RSp/AbFsnkcUbWnSUr/KjibNTpEciAN46rygZva0jY93b7C3fGDjCUUh7JTOo3LOIn1TM8qs9wV6rCjOZI/i+A4Vc6NoD9omCz0c+OPEYoZe880JRSOlLKJoCU8iVgATh31EWklL8spXxESvlIpVI56pCvm3E+AobX9pUwhqHPaDSP7Wyi62nanReQMtxlJI1FjKSFQgE59DHKCbSUgbR9MiSIG7EDwLCnTaEDRVcy01Ob9PKwGTm5Aiajkh1noKQrdoCh3YFRBLqmHgQZYG8/S3wwg8RFmurV6YMCtY76u5QSZ+STypoMNjYZCJPcwEOky8SdDqOBTxhKvvehGabyCf7zF5Sx2b8J+dvbu1qG+8vN/I6NFdmAQcvBHnokzpdwlrqE+0pAnBvXCSaMnadJ8q1vwr56lSAqnWzZLYa2ScKQ5KXkolDGrWSaSD/DSv+rY+DqRaLaxUfehIjHXzNj6AzVNYwtCEObMP8UAJu3rtPvv0oQDMgMH0BGJADaADQ3foCAZr+wvZSSH3r5Fj/85EvoujJqwyPKSZfn10lKmxNyi+Xl5V2j+uyHfw8pQ7xkic30GAkNik6fpO2S93usZifw1r6yPqyVy02SWZPxY4dL/GBP5L7XsFQpjhCYM9MsWw6ziRgxTWM8ZtLyfLxQYk4pYped79q1PJJxeDCt8Y3Hvo9q/gfAkHxLUuNfnZkhs69f0NtsM2UrsLUVy1C7ocBU5dgJwlBSHzhM5OLYly+TckcUhy1MI0bK8WgnMtSs2zJ9W6/uZdi7e6ZrFxhGGUNvfZ3aMMVLL6trO4uHy0l7vR6e55E0s5gyRRAEu5UAO0NKyXYUEX75+lXcfo/G2jJT5+46xEwa9F18u4tnpJGayTCUJO5/FGNykvYHDpLQNFyfVlQOc/m28ukdIqlRy6MwsQeMCxNTDDtt3IjVOJ0+rTKGgQ9WCzI7wDDK9BxBQDNo2SQyJqWZNIO2vdtfdPvot6JSTSFov0Yp6e3EM/uHnteJB3G01gpVWWQoY4wV1JwsiyH/0P1x+tUFZpOzioXu9TCTNuowNgal4p8K+UwnlPxQ9VO89dovofl3LrHd6Djk4hEbpV1XgvHb6wf6CwG8psvOzPVsn9iU2gc7Vp1CpGFY7dkYmiIdGc8leOREidXmiFrP5qHjyml6otZDBx7uXUUi0IrHKRr6bsYQ9rJDd3/DKaoP/vDuz3OpVQZth7MRM2kmZiHRuN4/vytuvzMKY+e42ryLcDSHrweI8wd7EGFPy3DWtFmoDfCCL98Dt0NQNbW5QCORo1LYo988Xk4zsH0SnnreVzaOZrh+rTEaKicwJxMUZJrNjYNzdeT61PsOiWBAUjjkLn8QKTUmYpssNQaHmJRlEOBELMbu0vKR19x2PALpEAh1/6OMznKoAIcQgm8p5XiyPWAr6oO1LItbn/kAFiZISb1xsDLBq9fomj75CBiejIf0k4LgT5AJX29bmLrggbgKjlZ7DpvzHT76/75MKhfjfT/xMNmS2uOfWH+CrmiyUf9T0sq7+hH4wA/C5oVDv9ohmHH6ffrxFghYDzdI5mJM+REwrN9k9OH/nR/3fpEHl/4LdNcRMmSW7UPlpN6a0jAEWI/kDzq1EcbEONK2efa3fpX68iLv+bF/RLqwB0RyFWUre/sIaHbF7XfIZ6LAaMcPsIIQc2KS0sIt4ppgYeQAcYQR0JIv4Dwg6QZX0LLK79GyFdyVFV7+1B8TBAEPf8f37l7n5IOPoOn6AXbSDdulaOikR1VcXVmOfl8FumdTCdbjE4fseafT4ed+7ud2S27vNILItzsqOLozVm+8SqjrTI4MRBhSsjOH+gzD0MOy1kiIObb/3YvIK0nC0MZxD/tZUspdshjZ89GExhvGVcnyDmHhYWAYQ7pK5H4uGwULo3LScOQRjnwS54tgaEf2GXaqW8SSKZJeQ3F0ZCYPHfP1PIwvf8j/tPECcFYIcRIFAH8Y+JHbjnkM+JvAM8APAJ+TUkohRAVoSSkDIcQp4Cxw5+adaAzDIY8Pvnqh5z+LUTTLfL67yLlBlMGzttGlMhKjsI/wO3y6/htML58kndH5rPYF1tprmBmTwXYHazokltPodrbJaBqZRIIbmzeIDWJonadpGH+LohOgAVO2Mv63hk1qa58mVZrmS+7T4EKqvcXbgUtmAz+e4iHg2Y3fpTd1lni+xzuAxa0/JjP4ZqTYoprNkbTAsPO0Rms8Pngctw5SGohEjZ6uDH/s1Qa1RI+400FK+OT2pzFy8E2PBvyPx23+87VP8uDW0+ws02eW/pjRPecAgxe2Xmb+jPrOY1UDGe45/Z+8+QUqc4LjT8V59urnGZxRG+XEledw371XInD1fptJKfnSE7+M9S0PMl+fR3p5ckiEELxCwLcDad1H2mkerz/OKP/6e07sJfX+Lo6vMTeeZW39ZV65w9zLXfotbtoa99Y7BA98O43aR0lNnuOFq59le9pGIOgvFUgQZaWEjl7TWC+/yGp0TtH8KEJP8nQ4T3/lMo3kMVqJNL/+8Y9y/0ySa53PcrUwfuC6a5trTNDkDPPMd2f56MZH0TyHG59/nO0HH2R2vskzhVOMG0MEkLEdyk6D1ewU1xa+QG9wWNOvtHqJwIjRnT6PDGHxsk76bsmnR58+8t6DJIDBC5svc3r5eeLjeT7jPcErwyK5mOTxweM0ZAJJjg93PstcqUvRcfjs2ocJS1mW+j62NuCbsz4j+TTJ6Yd5zGjyzMoNfnNjgan8HivY2NZ1KvZb0UPJ9vg0F178YxCCi4WbDGoLBKGkGVvi5c89TgHQpeTxm48x6XrUEiUuVp/irqSKpYnA41vqV1l5+Ds5Vr/GWuMpbg4UnT6JkFld4+by0/RqaWbbbZpTKdYHGU4Cl699kv4jByPi7TW1YV59oUowFGDA4+uPUzT3Nixnu60kKmIGsquOdy2LTsGh/dI6H99+DCPSQ63UDWJ2ByemwFI7lLzSeRW+92Hyv/RxPnf1d/CPqflwvW9CtOIea10hntrn8PRuoQPN7S5aJdy1n52CKtn9xNIfkpwbQxgaYrTI52sf4p3AVaPB+uBx9OSIbwFubvwxy7MHsz4bdQ2ZF6xlFpBS5xNrnyF2ROyuvaFAb+LYGJubC4dsuJSSVreFedy8o33f1rdJBgm0UZ2GHmMoY2RPdtC3dWbiFje7Y/zMyz5/44EbFJIFLnmXOJ89f+S5bh/nmpuM7prFmXCY6PW4lLiANI/eWt1Q0ApNCsadexgXgyznXeWwNPgMvez0kcddHxg8OKaAoRNusxg+hT8cYJ+QLGf3HOFCN8POVr8wukTllAMXoWlvU8pO8oL7JJYLQ9knl4Wb5lPkTwFPwGPLz/PoA5BNw2V7wGxJwNbTDHNjXDKfJxerMO8NuSyu05wHR4IuoFp8gW77OTKA6Ur05BafX3+K1FlJLgPL/RWyZoybw9NcTy2xPtgDl327RseZYdJLMwReLi5TvP2d6xIRMwjdZdxgig+sfZqpsdcuve0E6hr68mVqqSIi096dL6N0gBuEDM0EeXfIp1evMf2GO+tvHjXsNbVutKLJWCfH8voyn+p/ajcztF6VgATHJauNOMYmXwKy3ML2zvHBrccp5ffuwVirMxURpdUWX+HyEXP7es9Ei+ShxvyAlmFRt2w+3nscQ1MajsOgwH/feAUdmJ+/RhgE3G26SBnSHlm7z0DYLmP2AFczdjOGx2Ih82nJq1tPMRx8deW1L9Z8ygmLmSf/FfB/8omLXyL2CQMjD6Ufc/iS+QREybIn20+im6fZatf+VHy1e6/9JjPAK1uPUc0fBMFPbgekk9BotujHW4RuiU17HW3G4twth3c+/9fgiWukhcY1TtP/nh+if+o+vuUX/hrlsM2TzScp5vbs8/TaAtY33c+NweNs3NQAjYv1V5nKVxkDrn30Dym++2EWzndZ2HdvVkZVSn1x9VPkx5Ub+/leAsgx1mnxqdhFuv4UUwmfLdvg99uf52x5RK5WpRJzea6zyv9qZhjGB3QLKsjsZUdcan2BOeYI5o6xfvM5XrgBuTec5MXcFRhc2b1+8uwUr7zwOay/pOzMy8M8WVMDp0dNKqC10X2GtcHjBIkkG4kJbm3+Mkv7NIlbKy2CIODxy49zsnLyju8ju/UsBaC2dpUrd3i/CwsXEJwmb1ZID9u4yRwfWf8I8Yl9rVLWNrr02R54nAK4lYJH4Iv134fCwRyR0YdznvJVYq7ObG6Gp52nwYETV2OIScFnxRd25yBALq4zS4wnt79Ar6TW4Oean0OraCQ2BKdIcCl7g8qYyWBjlecHB0uylzYuoY2n2Wg+jzdV4LmVD1EaP7pq6utxfM2AoZTSF0L8Q+BTgA78mpTyihDiXwMvSikfA/4b8NtCiHmghQKPAN8E/GshhAeEwI9JKb+sCmtAQE6/c1T5z3qErs+Ff/5fmPq2NzPznkcBOJGCLStOLuov8Z3r7BA8C085AcnBKunqWfwpQU7P4fZcSlMljHkNLWNAIEk0JEEWSkaOxcYWGWliWZv0EpNUAggTEPcgJ0c0vDj52gr9uft2n0820pjSczOEGTWhy70uzOagkMVL5Un0t4gNZoiLVxmU8iRrEHezmME6GS1Lc9EHPEqxJp24ihQX0UhYZWJeRM7ST5Mu6rz3jZKPP9nm01/S+IbOnpOQqdnEHs2ixSy0dpycrkrZUn2fmrnnXIntBPrbDULDp7iYRDuvgx9gLmwTlPYxRp7II9MJsi8sY777m+j0O0ivTNE1QIMk21gcpyRMZJChN+p9VXPGqnVB1yjmJxATY8Tr/aPPIyXZ5Rf5TS1OJmPwLxJvxtefZ/YbW6w/U8fobUP6BNmlPKOUkgi5NHM/c2sX8E9UyUTnHA2W0TJnSRgFrq5uEWoaIRpXaoK7p8eJW1WS+64f+iGeM6KiNTmJyv65Gy6j5y6gaRovPfIu3vb8L/LhY29hJhhwuXQCJ5SMOU1uZM7jb1hH3k/vgzUMPSD3T97EYC0gHDmM3Rsnpx9tamRWosUttE6c+EYHZibI6TlqtsHbx9R6nYorMOYFWWIzqiQjX3MJKjlsp0MoHMZFC1uHe4+Pc2VcsNTw+KUnf4mffMdPMltQGZRkT0cHJm1JtTSGd6lJYqJIIVmi01UtzNP5FIkvzWPF4iRdB22hT9rx6RaTuMMkOV1tTqnmAlrg40/eg5t7iexg3zzRQU6WSVQHiKpavUM5hicyBIUcqeUW4rZn1+oo8yWraXCBcaDLgWe8eVn1WiTGCrTqHovT93P/5iVGV6Ls1nKP3BsU2EsNfVynixtJsNSDkLutBMPv+zbkr36K0h++iP0Typy2HBVgSXoum1aC3L4yRD/wcACn7jF+X4WslkMC2uQMa4DRdMmdyOGlT+BKn8JAZSb0zKT67qkcbqZMsV2ndds9r3UtEmWNwrhBFQeznSY3ebhHsBfZg9Ldp9n81HNkwhTaPuDl2R6hF5LL5e64VofekJKRRCDxQoOhjLG4GuOhQpLywOMn9N/nZ/t/jU89JZnKTdHoN0iGhwMfh0YYYtZ7yG8qI4rKTqZbAUHl6Az5480cX+im+b9O1rkTjdrITzAeAcNir4+dP1ogud70yc9EbJRBjzACJsmpaWLh3me81t6zMoZx/PPKmR36I04mSljdJGDheYJKXpAkxfGypJgbMb+o8c43JDl33ObpWIy3pBzynRqD4jSpUZNxs8KyZZIkw8qTLuBSzAlSIo3hqYCaMTqDFr9JohGQu6vAXKVLtWVy39g1Ltr3UyilSO17b8+tqvV6f3+dVxydhjE88r0mxgrEXXWNViPB+f2O4xFjMGoDIalGm1u5E5QzCXK66gc8XnaBPtvpMU511tnYuvt12/2wpda6MZug0s5yy94iNoqRzKl5NOg6JBlBKMiGQ3KRJ1rUVJCn30lxorQXPDGWlLMZ3HUMc6VOTsty+6TpezpaoPbqnqYRIpHhCDfIUzIljxbAEJLrdpoHTB2/pgJS7zRDVl0DTYuR9hPo8Rii26AbkZTndQlaEiO0MCckya6P/lX6Tp1el5n4kAmvzZynYXzMJF4WnPv7CczcwftxHAdh9skN86/5/GudgF//+JB/8L4MmeSdC9/GVtWeOb6xiHXvew/8rtXuMVXSELd0BsUuM/0x/trwFc5X/4gX/e8nbY1Yfcf/yqfmK/S8OG+7621kgVF+mrF2i5pt7H3HkY3eGmDMTpMVWZwVlaHSh3HMMVWynE0nOfYj34muHyRhS43HmAe0lrt7vqFnIKSkjEdfqPafcxnBlg1OkFElq6FkTvNZswxEIk8QW8M7qWxlUIHk1jYwhzZ9HP2VTxNMljj23rcfeq7jb7yHpf/+OGbDJzlRouuZTJrqPGHkfYrRJlmRYiYVx9FMgu7owHnafTWHh+tHr9Wdkeio88W22nc8TjTUMbnkLNn+KnaywHLz5QPH++48DpAZqIoo+w0qAFx5uoPzHVkw9uZVrBtCVDMhEDyYe4CcnkPYkuS6T//t2u6+vvuZgvpMfpAmPpUln8jTG6o9PtVRv3tmQ+c9ZZ3ssjx0L369T/rYBHJ4i1848z7GVjf51qk7A+avt/E17TGUUn5cSnlOSnlaSvmz0c/+ZQQKkVLaUsoflFKekVK+WUq5GP38D6SU90ZSFQ9LKT/6tbyPr3ZoMQOvP8Jp7pWtHE9J1ixB1BJCuFvSJCB0IVYi6FzHqIM3JfBdH8/ySKYTaB6EGfALAr2LAoZhlsANGG7eAiRtWWDMlwRp8AswEdg0wjya1WA4cWb3e8T6US14poxdmEIiSLSj0hgh1LGDEaZTIqUtIsdyQEjcT5Mx+2zUAwaLCpAVvTW6MQUMg5OfoH3PBZJR6YvXVTeaiAm+/dEEF295rDRBZpVjo1VbCCGIlQRue6/UxuiCZUgQYGRgtBGCIXBOCBLz6tzaahXheISZvUhn6FXx33gXxnMqYrbR3UD3xiiHail8kz1JKEPSowAZpKj2vwrNHj/A7wzQNcErKyG9XAGtenQpTn7pJWpywDAUVA2Dx179KObM95Aq1dC1BcL+PKZ5H/oIen6LEMHvH38UYxuk30X6I/W/tYGWVe/vem1PK6p6/ATNzTjBcO1A/X3rik2oBYzTpEKTmKlRv7FF/UuXmXjXI9zS8lTqNbbNPJPDJj/76N/kd899O8WIxGajcXTGw77nBTrHF8Bz6F4NQIPc+cPO/s7YebdOS6Jt1AlnK/R9GASCybj6vkVT/dnxBOGUcr7FlpqfQ0sSCnW/8bCHlJKJYpKUPo2hGbz/C+9nraPWkDZUm8VEELJVyDNs9UjPKiDV7qs5U8YmdnWRxx9VfFb+5RWMMKQfj9Pq7wUYUlUV2e0WTrOt34dX9/CHEhkt3HCyhLbVRNtQQMlOqu/tTU6iLR/ulxg2hxhxE2mbiNBENwyGrYOlSu1X5xGGjlbM81TprTybekSde7sFQtCf3+tz1PognR5OLMdQSHoStCHISgHvnQ9jfuQpiEgGlvshpu8x19xmcXDQUZOesk2eZZCoFPlvKwY/cyVGoqLAhRXNay0Z9VD0VSmRl96LpFvlOZLNw6XHblsSKwriZbX2nObR5YBOq4eRTpCeGwcpseudA7+3I6bDRPbOzG8dq8NkMomPjiYlQxnjmasGiXwC07WZ0hr85dgX+fwrAr//AA2r8RURT+mdAcIP6KZOUO2dBcBo3pnBcds16Ac6w/DO2a2+rzFutfBtjfQd7I+Ukn5vhC7UOszFu7RW1Lsypw+yfFo9yES+aDAEOZ0iFGAJm0wsS6un5uzQkowVooy4ENxzQufmaoAfSIrH4qAJyp5LqrPJ0vSQxPzPMmZ6tDwNpy5ZXVfvb3o8OofXRoRZYv053JjO2PKXAJgdM9hoJ7mnuICtJ1mzU6oMNgJ5T11T9uLsYJ4pv8DiEf2poICh1usiBKzVDtojv/0y1iv/HBm9w6Ed0uqFCBmS73eopQqk4nvvYLyovvNWuszpziZrDXXfr2f47Ygh+VSCsVA5it2tvb292g7Ja2qulumSQ82TtFCf22oevAd9QZXbee98I1pviOgc7qXcdgSZvjrOjcgztKBDNdLiTehwby7kGlly+Qy9kTrHjOvS8dJIM0ZvSWWFtHqHbgpAUtAlekn1q6crId5tJaevZ9Q7ATNaE8+d5fuHMbwUnPsHh0EhQMfuYJsDNOswg/X+8eJ1l4u3PC4t3lnWwrB6xPvK/iabh1tCtlsBM3kN3Y0RZ8THep/lRzp1MjPqPfyY+3+z9sYfYGvbp3xc2e9QSuqJacZo4+7TytU2VNYvnK1gVyVBVAHu9SXLT6rqoWNvvhc9cfi+jHQCPZU4YNcaLpSsAXo5Szu6xdNptb6arkBOKLA44/TZ9nUCM4GdfhUZA+kb+OMgdso6ixOYtQ6Zk1Pkzu3v3lKj9KCyW62Lqjy07gjGo3m6oZn8e/F/UJcFpLVJJabWRPM21tjehtqretUenn3ndyIi+RRRa4N32L5KKdH66hq55DTZkUuoJan2qnSsvecjbbWHJpsThGmb0TeOAwYMqoz9boDw9vmKLejpkv+UhFcTcHdS3W9iUSIk2GcOz8Mgmpt61Go8nhmnFjH6G02JFPBfnh7xsuWjD0Eb7pNbC0KcRofkRJE1qfN74m9QTZy44zP5ehx/Xsln/v9mxHJpvN6eA3gsFeJJwbatJmYQ9Z+JrNJc0RKThL1rIEPcKYEd6U+l4ioqGWQEQR4FElOCsqtCgN0N5Ry3ggRjTkiYEvhFwaQT0mSMYUo/AAzNgdoI3EwZacRws2N7wBAYTp6FkXL+DLGCMV4B3cb0U+TjPW6uelibypCl2hu0I7IAffpJ2ue+RDLKILndvQX1njcnSMTgD9wThJNlwkIGUVWR83hJ4LT2HEe9IxlpChSmj2kKGKIWudkCvSXRb6wikch4CJFGoXTq+I/ejb5WQ2w22Ohs4QVxJkwY4nJfPIGBRsH2QepsdV5/r4m2so0rBGYizi99ZMDFXloZwiPIRKZe/DAXTPXuHrZtPttbpZ5+ACkKzL5tGwhIddS7H/SatBJZLpRPozXUBhPaW4SDBUCiZc8ShiGb+/DEcmUKyykhwhGhtZdUr7+iLF6FJhowlgppLNXR4ibat76N0A/w+h6e0NH6QzrxLF0jS2kHGA4Ogz3NGWFk6+jpNuLqKr1rAZkTGkbqtUu84iUNr+ag1dqEMxW2ork/lYiAYbQZtT2BnFQborat5ufACokbaiMS0odgRDEj6A8FP/mOn8LUTd7/hfez2l5Fd0zC0GZclzTiOpbnk7oNGE7N30QLQz73prfST6YxF9S6sRLm7jEA6eo8gRnnxicqfPzS3+UPrv4zXvn/WFz4JxYX/9mIZrVAcLNB/b9vRp9XzrpVmEJb2jpEhjBoDkgkUojov1gseQAYBrZL5/oKMgxx43HaZgEnkqeJj6t12L22vPcueiG63WMYz9HQQywp0aPNy/2hd6H1hpiPK4bjpXZAYTRgbNCl7Wt09u350usiEQS2TnyswPObGjcGGnU9iZFJYtciYJhQEdswkobx0oXdc1jlORLNtQP3HFiS0IZYQWDkQJjgNI92xN12n1gpR3JSOWdW9TaCqcgGJnJHA0PXdxm6Q+aSMXqoANWQGKEUiEyS0A1YNY/z/xW/yqmJgFcu3Y9nl2mMvrxep1FT9qFpnaC+OINEoLfvDAz1TZu3X1+j5d05WNL3BeYFi8VPVkj1ju5N7gwgoe0RpBSSfepbNsZYHm2f8yklDEeQSYNISMIhCE0jyMSQAnJGjlZPzeuBBeXCnktw9ykD24WljQA/IjUz1us0igEjs4OQPmM0CKRg4xnYjspjJyOgr7ktdL+I4WbxTJhpfB6AmYqO7ZtMxroIGfLqUsinb36an/7YT+N4LosbAQYe+ijgeHKa2qBG3zn8TOOVAk6zy1RJOwQMg+5lwtEKMsq8zm9EveOhhSFDaskiqYTAH0k6l3zGC/uAYXeDIBRs1F+HZAngRrpnP7f4fsyCiUDQ3d4HDFsBlZiaqxPUSWEhCNFDg5jhHwKG2vwG4fQYwd2KNVlbOdx3t23DsfrVg58Lu7v+A8AbCyENM0VZn6Iv1PUtHI5LlW1pLqjzimaXXkqQFBDTQE+foB3GKJdCnMbRxH2BJal+wUOGd1i7nqQzkBx3+jze+Wf09IAbbwgxs0fvCV2ri2UOiLlJeqM7r6OFTfU+FzbuHLzJrl/e/Xuie/DZub6k2Q13q1FOBk10JN81O83a930/ALmRzuZShzAIKR1X+86lRY+Pr01QooO3rx9bW98BhuMMV9R60hMwWLrG5qsLSCDFnQMNiUoBp9HZ/XfDEVR6bcKxAi1XPasz+4BhOKFs/ky/jY/GdkJg5W6AC8PlB/DHBfr1JcIYBDKJJiXH33Q3R6m9JSpFUrPjtC7exApgGAgmGBKg8bP5/42XeJir3EcwXKYSBWvrjoR9Osq9tdaufW+t3bl4L2wqmyVCqXyi28bAGWD6cWKuS0xPknMkoaaTCBLc2id7FFqbYGRJ1lxmg79CYeklRHKcweka8UVJ+QMBItJCNFqSZzI6c1se10PJKVOtp8StkDAB7uwRwDALUoAeBc0OAMOWxEpDmFjnuUiX06zuvVun1UUGIYlKkVtxte+fKab58zT+Ahh+jYeZz+B19wHDpJpgKyM1WcPhsvr3x1Q0VegpZDjAzWziTQmsbkT+EKXCw7TKGIJiKh4bKkeoX23jx6YZBBqVkeQDyce4nL7FdM+kQYVBSmc4cXr3e8SGLUIjRhBXE9ouTh8AhoOJs+Cp6JOpreDnKxBz0bwUhvBZ2ezitiXCAH1tm+6Yar7NxgYEwSr6ZBoRBvj7FlQmqfFtjyR42jzGemUaOVlC21ZGJlbScFvRsVKid8EOJbG8RnJGw65KQk/inFFTOrEQot1cIyjoIEBLq01QOk38RxXQMp67wmglgxSCCT1kiIMhBCaCcRlp3DQNgvD1OQj6zVU8Q0fPpZm1N1lK5BF+gLjNYUzWlyksvcRFLUFKk/xQt09SSj5w8YMYMz9IPOcjpUZm5Qx+EYKtBvVkgUBotDwF4sPRJsFgHhDomTP0tnu04mmMSB6g7ulk7nsTAKvPPaueQSjprKjIcYVIy8xpEUiNsXc+wrpIM95qsp1Sm2Hdj2MQ8k9e/BA5v48e+qyJHFjO/ttBa26gx0cYiR7dCyNG65L83Xd2gHdGvCR2M2vhbGXXqdkBhoWouqrjgcylkck42nYLP5A4HhRjez2g0utSzGoEIaT0MX7qnT9F3Ijz/ifej/BNQiwmTAlWA4QgHQHNHdBXePkqdiLBlVNn2RifIBMJE7sJ/UDGMF1bZFQ5xWhLUhpr8K7cf2TuezSm32tSeasBx8rErA5Jq0Ggx/DMNFKGDBPjKvrfOsh6OGwOMUkhDDDzAiNMMWrv3Vf32jIEIYSSISZ9I4sMBX4uT+bYBGiC/uIGYSSFoTeHaKFPM1lmJCRhAFp0uuCN5wlOThP7kHLUN12DktWnPFBO7NJob1uQXhcZpgBBr1imFmnrvdQSJMZL2DU1f4SZATNH6CgHyUvkwVffxSofw3BHmIM9h8HtqHcbKwqEEMTLAqdxtOPktHrEizkSUZTc3r4NGH6ZjGHH7gAwLUK6kbj9UCrw5JnqM8PCLAnh8+OPrBI3wV7/66y2v3y1gBE5N26YBilwY1n01p0d2ntfXuC+7Qu0hncOloS2w+9r38Q/fuTHSR+hbwZQbUEurdawj0Eh0aXR8jFnDjZphn3wAkjmQKQUMARwympRVXo5Wl3JDkfT2L4et/PHdTQNri4FrPsGpuURX7/MzdNpNE05PJVQBU42lzW2owDOTvZNeG10p4ju5kBAMbiCOWgyW1EXa3bLTIs2F+ddnl56GsuzeGW5iRfAWX0ZEByPGAEXm4cpBBJjeYKRzYlSwFrtIECQtpqH0usAML/uI4C7hJo79ShjWH/aZ+HXXNw1ST4t2EqXORMRSS1tv76eOm/gIpFs2BtcrqxQ1DL09rGbVtshk7EBEFKhhgaksPDCChPpNtut2zKGixsEp2YQUZDlKGC4ORKMDw9mw8x9GUOAB7PqPlL9vYDBUGvzrVoeJHQ31TPSGl26aSgY6j2KWJEGOSazIUHz6IqXxvM+6x/xGK0dne1vdNXPxwYhAXFezm1Sd+5MFNSxO8ikj4bOyvadCaB2AOEOQDxqZNcuIVHPwew3DwSmqq0ACWQCtYedk5vMiwobpsFAdJF5mPI1bt3sIoSgNKtsz3otYDGcRic8ADb3gGGFwVKAnobE1JDe/GdIn5lBlnJHVg15gxGXfv5DmPkMdmMviNBwBePNBrKSp+2pe1iufomkJmm5gjAKks02VOBoJa3hFteJ39IZDU4ikwFidQU/4+NFVSDlfOaOz6r00Dl6N9fYjiQ2JsM+v3Dsr3HJvB+Appgg3AcMN80ysd5esMAZ2uijPoQhmy/MH75ANKzNLnakH6htHc5Cb/W3MESKpONSM1rkfHVsKSxxs7ZHeBNaW2jJKRLNNTQ8sutX0RKTeIkqre/Tia9Ixn4nQNgSoyW5lYx84lFIxk2BlCQWJPZpAdpBW7yy7RMAQWYPGFYyFbp2F8d3MJpQTwxJn/xPPO+r4KpZ25tbdvSeU4U4N1InEDLk3omjWwu+XsdfAMOv8TBSadzuXonIXFIikKxaAhm6EEU8OwsGvpuBiIhmMHGdIAdWTwHDDBG7Y0Lg7pRoaBDzdNKFFIOWTzelFnl+ZPNB/RP8v6NfYaKr44o4q6VZgsTe5I0NmriZ8m5Pw+3AcDh5FuHMEQgbnQa9jd8kNPtImcHwJY3tBoENZg70pU26yTF0JCnDQroN7DfliblduH6w7OA73pJElyF/WHqYcKKEFjlesZIgsMC3JNoINB8cD8yCIDWtQQjWVohfAr8IiXmJfnMN725lDPW8AoPS6xCemiYcyxN+6RUmtlS5zLSvMwwjFi8hOBUJrN5dexPbr5MhTb+xhmvqBNksDxkb6GPqXOK2jWHyxT/E02MsB1AxQm4lx/nHrTY36ze5GMQIA4GUEFsNsE8KYvUmvXiKMbfBs+b9qmx+4zph/xYiOYMwUjSXm7RTWUIhSPkKCSyV1Xvvb9ygvlBntBbi+ENMDTIMkVIwWFPvNn76JMsjjdlGlc20cv5u5GY5l1+kbG7hGzFy3oDV7ASsH3Scw6rayPV4j/qimku5e748MIyVBfFeBAynx3YzhhMRMDQ1yOiStitAqHJSbavBMCJPmjSreNG7k16XQlaZtfYgpJKp8E+++Z+QNJJoIo2rjRhLS8qR05+OIt2dQUg2AfFnL3Pl3D2EDmxUJsh1O4S6RmDKvYyhlKRqC/QrZ3DbksL0iLtTn2PuwQ5T7zaZ/Z4Y2W8ZR0hJKVvDzZeRUa9GV6rMuba0V07qWi7uyEVYKZLTGuljGmKUwOpaBBG4ar86j4jkBBp+nFCo59ovT+J2Box/w30QStY+8iT4EtFWTka/dB/HfR09FITRJocQuD/4TozLi4wur9DXYxxLQ8VWgGZpH2iRbofAi6MlYlzzVXl3xpO82NBJjBd2M4YAWmIaL2gTGHFi//mjpH/05wAFDIED5aQ7ZeGxorpWfEzDvUMpqdvqESvlMDNJjHTy6IyhgHjm6B6znRKkCWtEQ1cZ4h1gOIxIsbSIJTC9vcTfeo8kdMf49HPjhO4QrDtL1hj1qNTWVtd24gWM20D/zggdSNkWCImzdudyq0S/xW/MvJcrY6doVo8OSlWbklxBre81jlGId2k7sUNlpP529HyLoKUkQZQ1tstq/kzWVcYwE7Uk7s8YJmKC0zM6V5YCFoYGk3g8OKFo64Opv4XUM0z4ygncTglG0eur7AOGplVSwBDwY1C+/kVmiiqztt4a43yyy3Jzg82esj/P3lB24I3yBmiS2fgEutB3gaGUKgAIEB8rAHAsPqDaCnH2lY9JR61v6ar3M7/hM1PRmY6qJlTGUKO9qr709mc9xos6fTNFORgSx2d563VmDEcOgeaCgMvxy1S8LN3t7m4Jf7UVkI80IDOoP7MMcNwcE4mNgxlDz0db2kKfPMf4RycR+ekjgWHVESTDJto+0JOR9QMZw6I9pDQckO4pG1TKhgy1HjOkmPAzjCIBetHo0k2LXUbSwE8xMCdJGyDoHHnP/aht405BnXonKnV2o74xsX0gwHb76FgD+sfvRQLr20fvu0M7ZLsVYuiwuOkfYnPdGbn1y/h6DAnooU+8s+e/bEfVR5qlbN7D2nVuZVSwtWt3Sc5pTAUaKysWuakcRlzZ3q1mwIJUJC3p3t75tI0aMpNE5tIMlkPSxwSD5U8gQ59zf+d7kRPFIzNkSx97nt7LN/BsD6fRQUqlN9pwBePVbcKxAmuDIciAD1/8ddKaRdMVkEkiUwnmokqwWr5GkBkhFou4A7XHBDkXp7+KFigbp6/fWa6t9NA5kJLlGwpoWo7P+0/8Td7qPUFMDtjS5giHy2QMSAuf9cQkydZe64IX+GiOje44NBZqB7Kp+4do9bkV9fxrm4crMrZ724RGmrQbspTYICfVdz8RP8HN+h4wlPY2ujlFzFX3lGyuIBITSLvK6D5o/YBObENS+e0AoyGpRsshPgyhG2JWQe+DfeYgBGp0A376v3Z5+pJLkBMHSkkB6v06RktyA5W97GauYMflgYyhFb3nfDLgZvIUFVknE//yftDX0/gLYPg1HG43pL8Yx9mnYRTXYTIhWR1phNYWIJFagdDVcQdpQruO7pYZTdwAIbB6FkITpAPl6PzUcoyP2NEkjOxvNp9g2E/TSyiWvdBWm2bD6LNgKPa6pdxBinNz0MTNlLj5X/+I5ovXsYszmFYX3VYg1smUMKxZHGMbIcAOt/D1NoHMkXBCYn21EaRzNmJo09fz5Axnt3feOy2IOx28hkdsfW+jKGY1vnXzAp81TtKYmNrNGMYjB9JtSfQo2+DYklhekJpV09jalCAE9hmN+JJUmbuT6llomfOAQHp9EAL/0XuIPX+DfFdtBjPEcKIsoZSSqWhpBGGK649dx38dgsfajVXcRAxHxDCEJBEP8XV9F+QCGKMOlSuf5YMz30w3gKKhc6lwlu/vDziTqvD45Q+i6RJNC+lMfhJrNqQw6OLFBbP2Jh8dvxujDrI6T9CfR4/6C+srTTrpLDohD/evYSB5vl8AI0+hPOTSxy9Rf9kiMEYUMiECuDE6Ratho+uCTrXP8khwd1cBQ11IaukSw6mP8t/eo+EnU+Tos5ad4EsfWz9w32FHbSpCkwy8GGZekJx67TJSUBnDhLWTMRxn29YoxyTxfdapEJO7kdNwsozYajGM9EpmjHXmO6qxO3RVxhD2soCVTIWf+oZ/hB4vsOGuIYwGlVYVgSATgYx2P+SsbKFtNnju7vvRey5bYxMkbQsnnyHmO7sld/HuNoYzpJm6F0Lw9KihvrcHlGXUC6mt17FiZWTQRwiNjheVVO8DhsNISFm2kpzLP8U9iceRPRXoGbVHSClpvzpPako5/U17j6CilR3HrraY/e63A7Dx8WfwVrsEERiSZpaUjII7+8q23e96KzIRY/2PXwbgzHiMsUKcvG8fyhj6I4NEpcC1uk7acznZvszlkQYTYzjNHmEEXrXUNK4Y4qbz6BdvoV9bgTDEKqnKgmRrLwPgttWzjEXVDfGSwGnKQzpUoevj9UfESyrQkJwsYVcPRpqtvkUik0DTjt7OdoDh1KhHLaZKXicG67yj8SRdL4ZmaMRMg4FMoG+ucvecTmnmKba2p/jE/7jK8r/7/SPPCypjGMRj+IPIBhUn75gx7N4wCLUoy751Z91G/UaDVkKRBl3rlI7UYKu2oFhU82aZUxTNDl0zdzhjuKGer1GRBzKGdkb9fHY9R6sniZvq3ye6gtMfEiSiqXzPSZ0NW8cKBd+QuUSpWOf0ko1VOk+YPEbZUmWMtdm9Z18pahB6iGCAs32C+c1TSAl1bZrylc+TMepkzAEbvTJ3j9kYuVd2P3ttXdnI8WGTVMVCtgbMFmZZiHTTmi8EvPp/WgSOJFEpADCpK33F9aj0U0pJuAMMvTZSSubXfc7MGOQj2YV6UmUMe+shgYDetZBTcQ2EYFAqc9Jrsfw6M4aO7eLo6r2uygUqYQ7f8Rl1RviBpNENSfiOYnhGBQaK9LBHcSZSVWrtvb5Gba2G8APqyRgCjSvf9BDcBgztAORgiDRsdCAR7Vlxb+VAxtDqjHjvaoc+IwwZcK5/kb4wgD4PBJPYUcmd1uzSLcV2GUlf/bk/ZBAomyOKh7XaZCgZLKpnbt8RGEbrPDRJGAMmRZ129+jnans23di9PDn2EBtlnfptAaCdsbiprvmWe2M43tH97pprkd6eRwt9+hHBUGZrrxRxJzsbDkYEwqWi1dgq3wNAx+pSOq2TkYJ2U+z2FwJstQIWpbIh6f6eDdfWVX+8PwKnJkHcxGmtYqa+mcREkXC8iFbrHPqenUtqXgcysnXdIX1fsRePNxtsxSyeXL2CHvYRSOIMVWmpEIQTJYrrm2Q8j6D0MgDO0nHcgQIxQUViL71KIpZTVTard5bMypyYwixkWIvYsX/bOcm0XefN9n8ndGss+yXC4QpShozFJOvxCZJNZc89x0NqoHkOpmsSmAkWfvewgH2nH5AaDVgoKl9THAEMtzqbuPEU6UCno/fRE0l032fKr7DZ26Tv9BWngtfF8CfRhTpHqrGKlpiE0EW6bax7NJo/pGNuS5p9ATtzXEJ/Q+7yUNinD/onW80QiQoABPmDpaQA3UYLzYEF/SYySGKkF9kwQsx9MXK71kYzDbJiwKJ5gongq+Cp+BqPvwCGX8Nh5gTJiQyha9F4dq8s73hSsjoShEO18IJQGSKrmUDa2ySbZ7HT15FSYndtEtkEehTlX9c1Lns6YRxEFJTOJixsO0s7ko0chcqgnWpleT71WQA29tHiA8QGLZxYjvozl9n45LPYRRUlS3TUZ6XXIzaYxRVVLCNBqAl8s0koc8SdkPEI6xXialH0SJOND3FdFQHyyzZxp4MlJfnHwz3nx/H4waufIUTw8cR5RH8EI5tYaQcYhhhdJezrO6rsLlYSaHEO9Bky6KE1ungzahPSk5MgdGSgNjj/zfcQ642IO6pBu4IghWAYSIYh5KISlGuZNby2x8sfeZnwK9DKQqreRlfTcPyIDEBAq1w6AAwnLn4MLfD4pcJdABTjKdYqDxACf88sMyNUpLu3nqJ18mNcX71APPQZy/S5T1uhnswjOmnCoAbBEC1zlsALWG06BJpO3oWT/RwSyStdDZGapTRh47s+y9euEMRHFJMqcv9cc5qU7lM+OUZ7rc3KSONsu8pWdox0pGPkGUNWSiEYMQpBh1qqyMKFOl+4uE9b0tpz2PXkgMyMf2RPw+0jVtZI2k3CWAxZzrFl7xHP7IyiKensAMOpEtp2k3aUoiiYPa5vnMEbGjijLsWMMmudfZHpsZGJiOfoxgZ8evX3GGtWkfEsxg21xtoDySORNtPT9zxIyvVplscRQFBIowce3Z6HlJJUVW3mLf0UABuX1efi/b2I7A5JjlZrM9RL6K56No5ZJEzE0Zb2lWU3VbDFtAXV+iVurq2g+3vA0Nps4DR7xIpZENBz9qKPzVQJrz/CiLJpMpTc+u8fw7G6uGYWXdsDkda+BnmyKbzv+AaqmwrE3HM8Q2Ysw1i/w+L+jKHXxe0L4pUirw41sqMFVuVj+AiWxk+AlLu9MVpymkALsLN59OUthOcjmj28TAk/ljqYMexI0NgloIiPCUIX/Nv4NZyOCtlmdYvStSdITJQOZQydvkM8e2dGyh1gONtvsqlNYkuDRzsv8UD/MsPVOolCArdvs2LOUeyq+XD+9BrJ/E0+2XmEResYQe9oJ9WodxlNzdFJ6CxMmlj5cfQ7ZAwHVw0CQ9l5s300MPRC2KqlmRo0iPsul8ITxJzDTnm1JckmB3ihQc0fJ6Z5OIk4sZmDGcNgUyOjQZhTwDDYAYYR4epYM0u7G6JpEDPhxE2N3LLg/O8IKi8oYBgWVdDxbcFvETaTiFYRNJ0weYyEs0LGCmhEmcZkHDJJlS0EqG2dZa1fwB+VWJPnyW7fIF69ynRmm5pX5viUSbzwCgkUedHA7ZIyArzaiOz0CLe1yanyKZZbywRhwGAhIBiBtRnuAsN8oObwbjmpP2CH/UO6XartkL4lOTOrk2q36JtJLDNBUoDZkbxwNg4xOFVV66qRL3O6vc7KdkB4B8Hso4bl2Qx0dd1tv0plHwFNo6uIb/QgxIxAYTuepUQH15JMpGqEUlCLAiZaRDwToO4xnbmX/+v0NeqDPRtTdQQzWytYMVUW+XBqDKREczeo7ssYDltD3lEPaYkeBaNPkS6B1JD6FzjGDDEtjTdyEI0O3byxmzH0+jrDGoxCCGYPZ7itLUkQlac7jaP3xnonwNAkYZAhkbSYoE13xJHEPl27S2iowFkro9O+wzpajMpHv+0R5UscVU6a3biqnrcM2IqPEQLp7T0R9+1mQDYpCHoBwuwgBHQnleh5rdche0LNZ9PLUD62Dxg2Q04dh47MkLP3HH5to044M85wOURKSe/Wc2ilCTTzfgIbwvEionbQhoSej7sZZehGQfQcOzSinsLxdpMPV59AM8c4Yeq87do4yVFVZQyBcKKIVm0zO7AoJC9gbMHIOYnvKhvgzRj4G7dI6hnCuYkDGWcZWLirH0L6yiAITVB68BxbHQeQNGWCX7r2r2n1Bb/6c/+et33hZQhspF2lktRYT06RiAJ9g0jHLx5oaL02CEH15WU6Vw+SRr10oUcs9CmdHaORyOEuH85g9ja3CEyTTJigrw8Z5GJkBgOyI/Wub9VvRQkTMEeT6KLOS/E4emcT3VT3LW31TO3zGs33abxQ1CkMQ/opjVBAdzsgMS9xJyG8rde1Wbf5qRc/gLy1TpBVJI5ISSWjAm5uJGa/bXaJrb0DodtctpoYNdXmAQoYxisFZK/FFhPkanmOwMBf1+MvgOHXcAghyL9J7dAr/6NLf14Zh2MpyaYt8LoqGutYU5x49xowBELiwwlC0UdaG1g9i2Q+iT6EfgzO9kMafcU4qjlqoqbjagF2u+pabW2JuG/wnhcKxKIejJoo7BoJAHPQYhCVIPQX1unrBQASbbVhae0uhpdFsIET15EYuPEBITkSdkDJNwiRFEJ1fNdIkEl06HQm8f04frJD3O1gawbxNUnyatTX0O4xNWpxzvS54qnFqG23iJci5sKWRO9KrGgfiuUFQlPlpKMo8+icEAR9lc3yixYgwMyCFt91GLw33w3AROcKOpICgrwQ9KWkHUgMIAkMTcHo7hGNpQZXPnXlUEbj0DttdJGdAYGUuL4k8FMIP0G1Mo63rsCB8F0mLn6Upbk30ZPbxIQkmywyVjrJ9ViM+7cW+MaxMXqB4OKFMlLz2b6uBF7P5rd5V0oxqnatcYKsCwPQs2dor7dpR7IgD/Sq3NNVDeSjQNA15hDeFqffdBZbtAmlR9kcsTIs0hjCW8ZWGJvLY3Ut7N6I2UaNzcIEfgDnW0sMwxHdRIgQARMjZXgnEj6/8sdDrixHFNnBXo+EkegR3/fv1xrxkiBpN/GKYyAE245gKnHQ0SiaEJH+IafG0Np9rm2p66bNEfmXu6x8fprRoLNXSroPGBrrfYSmk5+usDG6RKVVxS5Mot9Y3T32vvUb2NMVNscnKYQ+w4raaIKUWgeG79AfSdLVBaTQ6Hkqimh3t1TJ776MYRj1wwnHw06MMRllPBBCMZPeljEUmsbxxDNc4wxVSmRkJHPRGtJ+VZXraYZOrJDFcvfkB5qmyizZtTa5c3OY6QTthSWavSX62YMMdCNX7jbkAzg/9C5Wx6cwA5/m4Co34jcodtts2kJlI6REel2cdshweoYGGrpznZg9jwiHPGXEd68NIBIqeDRImDB0CIWu+kiEwC7P7UaYIWIkzQvqvZBb6x7xsWh93+ZguhFZwczmC5z++PtJjhdwW30CZ89RtfoWyeydpSXaVpuYHqPUrdPyMzhOQNFV39m8fIVEIYHdsWnn5zgVrNIdSCYzExgTH6AQdvn4xHu4drVz5LmNWofh2AyfejjFh96awcqUMY7IGIYO+EshCOXExodHa6Pe2IJtinzP8pOc66zxqn6a9OC2km0p2WwLcmYP10kQDqKenYxEyx6UtvDqgrwu8JISLQXhSGV6rJiP6QncwGdgK16ssYJGZlPQPu7TOwmzX9D4xs/p6JU4cdemrPU4sRiyGKj3HJjHEMKnLG06aMRMlS0UQuwCw95QzU+nN82mrubj2I1nmE5v09DKNDIjMFqM6t+AQEMYfR7KtSCE9NSIoL/N6fJpHN9hs7eJta3m72g9xEgn0ZNxYqMeprHHTBruc9il12F+XT3zck6n1G9TS6kgqB6Zp+UJE/mwSXoDcoFgKz3G6e0lLFfuArUvO6RkJIfYusMxz6OKQ0IY6EKjt92j2grICqVJm9LUhWtjx8gxQEoYT6l9aaecVJ9fR2oC065wxQq4e3SSbjLGv378X/Ol5S8hpaRqC2a3lumbECCYSJVJSonvdRgEgh3ZwVFjyH12mq7WJUjqFCI21JWJAQKD+8Jxmjc3EI0unYygoIfYnoHwJeF6lyVHQx6XhM5BJsodfyU+duf+4FonZDxhMwqL5N0VJkQbiaAzOPxcO1aHQFc2t53RCYfaASbKnbGw6XMu0cb+jd+hrI2OJKDJrl1GRkHJulnCEybJ2zKGk2Ud0YuR1pq0zDHM8VlkEKM+6JCaUdIfaT9FYaYAgO1K8mKRHz//MzSMAuUg8vbDEG2jQThXYbASEAZLDAYjuhNz+LE+fl8ix4to3eEuEzRA5+oKIiKkCyKGTrvRoWZHlS7tJmMnzlDKneH80hJnl5KML1yn7SkMIidKaNUWJ/tdpmPXiV/RGKYnyZ1P4VkF7BkDo1dDIJAnTh3IGLorv4e38Uf47Qu7Pys9dI7ViROA4O95z/Lg8Bos+ByvNvn7H/pDkr+jE3YWqMQl64m9jGFnWfmN7yx9DzMyidAEVMZY+I2PE7h7dvraBeX/nLi3SDVVwls93GMoN9T7zpOlpw+p5yHb7xMOJaZuKmBoR20v3UnW4lv8rekJPpRJkoxyK6G9B4DDvOCFskFpEGDGBJtFnW5LEluVh8pIAcSri7xr/QJv+fTHCHKKxFE4kIqlyMQzOFsqctkdTFGuK96Mm8lNNF8Q/7TS27VrLZITJRYHFmlH411PZbj1wusrS/9aj78Ahl/D4fgOv3XzdwEw8iMWft3BroUcS4WECNy+6qsIRz0KJweUzihDJALlkAW961hdi0QuQdgK0QL4nWdH/MjLLl5OoEU4Lx1T52nf2kIPAraMJaZ6SbAC/mrz7RDa3PDHFdMTqgzDcEf0IwIcJGwtR7qDUZ+hsR0RPshFvLjPk+uPYidGgEHCTlPwUnQ1SaK9BbE4bU2QNduMhgWGwyKhv0U8GBBInWFZkv9MoHqjWn1ELMMDXooFK65YMast9DRosZ1SUhhFUU0zKkVLzmpYmyEylMiYwBUKGAYZC/QEQmgIIwmhyvr0BwX6mSKnamuUYhoSyArBQLepeyECwZs0g7gYY72wzum3nmbj0gYLX1p4zXeq31jFNdSykkFIpXkXY403U6v8ZVaXx/AHkrFrXyA2bPPBkz+A7ixwIhZy7wWXd13a4uVEnHJ9hVmtx6IX56mTAwarJ3EjkHM8XeVN8VuU3SaXnRNgQnwphkhO05xv0EmrKPW/WfgZ3tNVc0sgWZDHIHRIezEMRx1T8Oo835ghYQgeKGwxkVeb01SnSalWZSteZCQNHrKuE0YMZL4cMR4RO2TSGhMlnf/wwb4qvRBDwqhZ3Eh08Zt37qM68MwSgqTTwMmNYQVKlmKHeGZn7JSSSqmkIAAWIwKduLDJjzpY7Tiu1SFmCNIJQXuf86FXVYamcGKacZElbQ1oj82g31wjDAIGPY/jyzdZe1D1Y1a0kHRK3YtvqIxJInBo90PStQWs8hyjmuSeBDyUeQsdo0R8XzM+yThhRoEVK1Gm0txzSuzSJPryQWAYN5M00x2+m8/wvXyaY7lr6FpsFximZsfxekPMcgErjJOJyldbmgoE2NUW2dMzeP0RhclZBsNNutkTAKRGVUIZ0g7lrk0AGE2NMz93grnaFp+7+Wk+2/ks+WEDiWB5JMBXvS3uQGOlopx6x30Zug9Rtha46udpZr19khUKMAx1yfzp9/HiG/8pIiIVssrHDgLDjiRWEHzgMyP+3e/1iZfVOr7dwXQiwqaSV0X3HfKpqHQtir5LKbF79i4jae0pj8XfOEiK1LW6FONZ9NBn4JuYkeaWn84z1ZgnkdTxRh7uxBwFMWRjvsVEZgKh2XzX9sdIBja//OJJnnj1cFWnUe9QrxxjftLEMwXd7NiRpaSjmzohe05hzBseRVLMc5ckycDhu/vPcHdnmRuxOczOwcj6jWWJlzXJiw5GV6J31bNLJy2Gewl8whEEAwUM3ZREJCVICC0YmR4JV2c5oYC340IlLYgNBH/g/THzf8ln9T0hqW0BOQPZdLEm/gon7BpX7UkGI8lgQZWETWQ6DKOe1x3imUatgTcqcCuf5GOPpLA7syxlPebj91BZvMZUuoWjJbhgbaIJg2HrXmSQQTN6PCDWQBOkJ0dIr8WpkioTX6gvYG+rh7YTBEyMKTbH2Yq+Cwx3+gvRYki3w611n7gJlhsybnVoRlIqWsSCu10w6L0xhhDwiGOwlixxOsqGfKXlpJoFDgGO7vCOgaKzX6xsUYhl6W512W6F5CNG0GRMrf3BzLldyYpipgDsA4YLmzjHxhn2x5h3QvqBxr/95N3MpSb59ed/nV959ldYHYyY21qmZyoGxWyqRDkIcEMLZEAtKidNb+qEUjAUcCV3HB11T5t3PURMvMw9/jTtxboqJU1K8rok6Au+7fIy8fk6y44OE5LuPmAFMFgIiZUE2TPaHaVm6p2Q6VifYVgirbWYEHul+7ePjt0hMHaAoUbSy7DSXjl03MKGz5vbLzBY2OBRefPIjGFu/TJOXjnutXgZgSRdnYeISG6rFVLOB6SsPBNii43SPeQzGtLP0R710ExB3/Qo+nG0aD/fbgXcm1Hzwk4nqNDCsTxErY3wfMKZCoPFABk8jxwbZztXxDX7eH1JGDFH768aqj53FSkEQSyBjABUq17lg1cUKdh4u8X3vut/oeNrjG+qAHuiWyOQgq6n9kHR7PFAeAVdC0hc1rArU2RPaXiDCk7eJz7qIX0HJudUT5/nE/Su4VdVqae09kDU6ORJNifmiAceP9p7nL6pEdtSc/b33/ntFJ/Ryf3kHzDuW/T0NH5HAbvmVfWOsqQYj02QzuXQpqawa23W/uhJdV+9gNaSCog4N1P00kXM7YNpNMd3SES9n1mjyEAfsp6zyfb7jKyAU6VT3KzfjL6zRqI+zkJSPc9PpNOkel0QBnIfMNSb8HxJozAKSeiClXGThMcdZSpSt5YBuH/xEmFUibC/z1BrhvjCp147y5ieYDwzxXJa6QtnfuHTxP/tB7CrbRLjRW45BvlhxHY+cehSX9fjL4Dh13DEjThGTtW/T32rh9Dg1i87zEUeg+bWQJjEUzewWjGG1QRIsIpLiFgRr3MNr+9yvj1BZhESAWyXBe/Z8uknldZfkAjR4jfRjQBvu0XBc1mJbzLd0rFNg+/r30fCb3HdH8cZqOxJLGIP7HQCEpMlEpUC9VeWcDPlXQKaHRamkn4NJy64WLuPrYicIm7nMUc5tvUQ1quI3CRtLSQX6zMa5Rn0C4SjdcyMMtKNRzWMDmSeC9FaPfTK3dyLgQssFWYQ2we1DI2uJKos4De+OORTz9sqwufuUd779hoiUQBNR0RZFWFkAAnBiJXPN9ieKnOmsca4DGlIiSYEfblA1VPf680YmLJItV/lzNvPMH3fNPNPzbN+6WBv3f6h31zDiwTCDQl6mEIPawR6nJr+KK/8K4vLHypy2XgfvyvvxfPqnIoH3P14lTd87ItcSBZxkhL8AZXM26gXHB5fDvDq6tkmMx5Zw+YUXb4oFaGO2UiguYLuK02sZIlY4DDtrlH0leEum5LnbUXRbK+tkUmqzTdZW2bbzjKe0TE0yZjXQsZNpjt13KaFHZUh3pXcizTaokve66LLgE0nxj/9K1kE8G9+t4dvDLF6KsubTFdpt0qE/ldQiiUlSauBlSgfkqrYGSVT4oQCO2SXka1RVVmXYTONhsQf6XhDtVEUsxrt/t45jKZyHuRMlrenHwJgc2waMbKxbtU421gh5ji8ct/9CC9kPAHHPbUj2IH6TonQptUPSVUXGE6cYbTpcjMWcDF1kqYxcYClDUBGLHB2okSxt4LuW4DHMDmpemdHatMdNAekvCGLYpYpqsywTSVzDT1IMmwO6N1co/jAaexGhyCfpW9kGUv56Kagg1oIVrVF9oxy1GeP30/c8+nlTpCw6pRa1xR1frAnWQFQX6yzNDPHifVVzl8IeKB/FidUm9zSUNtldPQtnflUhZIbQriI45b4geo0oZ7nk29P04qYM0WsiBZILOHSLpxlkJlltBjR45fniA2a6FFZ5I6G4Vo1oDuUOAkJ4rBkhRuVk00MVVnSmFRz2op6jz3bI/TDXUbS+tM+7VeDXYISUBnDkqF+LwNJul/HTWRwxmcwZMBgUTnqVlGVM3rLa0xkJkjZOgW3zw9ufpgzsS0+9EXBBz6nWD7VgT56q8+zp84R6mqONNJFBQxvQ5CjazpuOipv1DSkZjFsH3RM+kPJ/GLIt64+TzE/4F5rGV8zqG7vAd3BSPKhz0lkMU6BDum6i9lWX6gQ77JPEneXeKagC7yUREup7xQOYSQcko7OWlq9j4ElmY56NC/FbtB12jQfgCd+sIYTMwlbAaPPnMOUHktykhvLPu0nJwiDGDmtQWhouJ7KGL70bIPWF7+E1TjLlWNxLpxO0O6f4bjR59cG30B60CcR9bG+XGtzz8S9aDJJ4GYRRp9Mc53MiUl0U6IlQ5ybA9JamkvPXCeMsPUOC2a8UsCud5gbN3ZLSXcyhlr6FNLrMr/hcWbGYGkzoGK16UVEQ35NYsUF/aSgldTIvkHnAVdnwxznRG8bTUhWtr+ySL9s+oRoOLqD4Sn7dL2wQiXM0qv2qLZ8SlH/oRmLqlnm3rArcm+YU2TMAVuRuLe2sM7GPRN0PfWcugwo5h/gp7Pfxffe971cWL/A51/6l0gW6ejqmFSmwlyUeTK81V0CmvFmmrZQdnHTrPA7vE9dP5Zm2biOSZ7cKohmj57pU9AlWkugS8nJ7SFLbtQ/u7WXXZKhpL8QkD2jES9r+H0I7MO2vt4JmKWBFeYx84IJXTnb3cZhTcau1SU01P7RzkLSy7LcWj5wTGcQEjYaFLcXQAjmmjdZ2Q7w9u0zwnfJbF5T5HmAkx8nJn1inkWitYHrSVq9kFSsT9LPMqFv0p+5l2JGIwwy9OwuruUy1IdM+NpuS8JWM+BUUtn4IKOTwmb5enWXkTSYqtBfWMMfbbJ58jx/9NA7WKto+PuA4X4Cmt7VJYJUFsdMIRyH/oTGrwwfo+ZItDCg2OsQlIv0PMhvR1myvrJ7SrKihJCS47FX8T0DfdlEv2ucWFGoPsNSgJCSsLuOKE8gghCxsYWz8KuI+BgIY5f13gvh3y8nQcDc9jKxYZ1XEzEmWxIrZvKLP/Q3+cBfmcJY6DL3Xz8IQC2IoTtD+pvr6KEgjkExPkkcg1HXYextb2Djk88wWNnmuWsuOVe98/ZGGjM3RqbbVkzb0aj2q+TtiOAsVuGEOMZSuke2P0AC51LnWOus4Y3WEIkKZlNnxVD265VEnEH1FiIxTmjv+SsbHbClQAshK2Bl3KBiaAQmuHOHgWFpZYWemSJEIJ5+DgAj6s1PGknGrQKDtE2TPIWxBPdO3sVG4QIhkvCtb4cPfo7Q80kaOvNakXxUIrxi/gX5zF+M1zFyZWW8pBxx+kfjeD3J6AM2+WCILh0ws8SSfWqvjrH0yWMgDYaVl9BSx9FuarzPfZTTCyVcHS5Maqx9p04ihKAHmgv22DboFobfIyUlpbjGULeYaYEUAtOvcnpkYuljfGZJLYQdDcNmzWbijUPG31Khc3UZKze5BwwbBr7Zo0gVJ6Zxo32GeasAgBiVwclS0yWr1RA/OY0VamRjA0YjlTFEuujTatEMcwLrrCD3ZIi23cOYuJd7UQvpxuzDaLdpGepdySiqpnth3ePKsqeYSdmLJFNfR8vPoYUGIq42G2GqTJndaLNVu8HWxATxwOOB+irDSGNIP36VINEllJIHQx3CLM1hk1CG3Pft91E+XubKJ6/g/lqV7JNHNL3fWMWONIaEngGhUW68QLtygfG132TuoSbt4QRPrP8N/saHHd45/1c52T1PrBqSvrXKxeQpWlFPzxtG383JboVn5xrobR/P0OiOq+fyhnHJqq0cWTG0yfz2kJbfp1HOc8reQENi0qVsdxB+yAvWjlzHOnrZRTM04m4XNzTIG8rbilW3GY2VmWvXqQoVsLi3d4P1xN4m3k0N0JCMySFrMstkXvATfzlLrR1iJyyMVAcpBdZEjSA0Ga58ecdKtPvovsNQH9t1ZiZvzxhGIvdtd0/kXo8IjgabGezZ09izZwg6UQQ+qx0oV9Ijdjx/OsV5qZ7b4sQ0CB3v1WXeWLtBqGk8eeo+RN+jkNE41VUbjIyEjBOBjdNsEx80GI2fQjbhjzSfP9J1mmGBWP+2nolkJImQiKOHHgm7hQhd+poqQdWXtgi8QLGPBgMSOFznNJ/kHWTkGpqVZFDvI4OQ/D0ncdt9LCNBz8gxXhAkkxqeC2Yph73dInNyCjSB3eqQCiXD9DTZ/hpZaw0hFKjenzHcWGzSyeQ43q7xvq138hNbf5164ipJ6bM0Envi9iODm2GGe9pDBBD6OU6s6ggk3fwDfDh8Ej/0Me0BKSvA1lyGaZU9bG0o0hirrDKOieYaMpR4XYlRELskENvdEDMvDmUenFYPMx3HiBDB1FBlLezIJuyXqnBaIfa2yorZa3tgqmN1GBMGDiama5FxugTZAmEiRStRxr66CFLSkgX12hprFBNlCiMVGIlJh+9zP8m3PyJ55prgFz6sdASNRg8hJc/NTCGi/pJ2MoPm+Wj7WPlCB6wFnf64ugcjaxPoDr31g47Js5clYQjfM/808ZLHfa4Cwys1Zez8QPI7nwyxbAgLMYqyTawdYLZUtiGf6NLaRzDkR1R8O6WkIgKGwRCG4Yiko9PU+tG5YdbTcDWPhcQa7VETpM/N7kvqO7cdrq2re9rUJrl60SfoaATGLPS6CEe9x+7zV0n91m8yadYY1e6ik1Z2ue4dY8Kskiu+FR+N9KZ6Fv1BhreeeJRzcwbSzxI3O/T6IYPiLM8/930su9/C5c/cJNfP4UUEP26sgxXJEyn9ty5zFRUIGlgh0qkhzDxaYgLHGrC8HXBmxmBzuU/GsxkUVMXBaCNku6CDEHQ8wey7DUwEaW2WWOgzG7O/4oyhHwE6KRx+fbxPPgi4FrvFuJUj8AI6tQFjulp8MUMFO+TcG8hGGUM3GGcyXWOzPgLHQ1utUh8r0I568VqxOsb4vRgrDb7znu/kn73rnyF8+MSb6wRRyWQ6P8k5Vz1X075G1RH4tsecXWKgq4CPkBLQMPCxezZ/OHU3Gk3u7ReQfsBA98nrEr0TkRHVRqy4GjKEcLAnQ2Btq/7C9EkY+DUk8nBQx5N0h5JjbgPQEJN5kseU7dWf/cwBHTyAzqi7lzFM6xTD/KGM4eKmzxu7F8kkKrx75u/x3tR7+be+QeJDPvlPB2SeDih+sYrjPoTjn6UtzqAnxnc/n9m+STUKpJh+B4CsXodz9+9mDIdul9ZqC9/sE0ewuRBlGZsBE2kVdPCyai10ry/uituPYmN4/ecQ6Sx1oQJRzazA68tdQXqtroChXW/jd3qMsmWGegq8EY89uIIf+pyffjtjzgiRTdHVTNWm0FTBq+xA2buWK5ATRSSSXOEa7lqWTmqK9AkTIyfxBhX0jE8YkwTtJURa7ZnuxoeR9jZh8Zv58M330GmrrN1vrxksjjQ0oFCvovUavJyIM9WS+FGg+w/vmWX7p3TGu+oebvZm4folAumTJYlAUIpNovUcpJTk3/owZibF/K/9Mc9cdjgVV4Fcz8yiZ8voYYi7uQeUt/pbpP0Uuu+TNIv8pa1vZCKokItaomaNWTXPBqto8UnM1ohlE9JC2cdnG7eUzve+LOgLQ0lhqN7fdOMmW3mYMAWdtDwkUwEwtbXGs/c9zBPHHkL/9BNqrkYZw9qgxow7gW54DGIp8sfy3DV+F44+ZFO4yDMP0PyJHwag+MuPcVk7SS7iQSiVD13q63r8BTD8Go9SRZU7uN0BmRM6J38kxmg55EdeaCKlgNDHG8bQ10ykY5KuvwHdyVJ56hs4c/HvYKDx8jeNCIDYmKB4THCxoFOI6HPbCcX4ZgYhGdcmEbE7zBgqi+a7W5zv5xDGGJ/aWKY1ahGLgGGn7VGYeYXCqW2kH9AJMyQiyudYO42TUgvQCpM4QZyrfZUvt4cqc1HXQ66LEr2Ccgoz5hDLyjAYRsDpmDKubiek+206woXkSz308fuoFGuMIbg+ef6QlqHRAUsAMfAEbG9bJKYEaIqUANdDrG/D2ASh5u6WuImIYOfmJ7cJjBFPnG0TILhv66YqsZISOXYLM9XGFwHH0Ei5KQIZ0Bw10XSNh973EJlCmidrr+K80D2UGdBvruJEzIAi0kwrd6IMY6zPm7X/yg8f/6c0f8Dk5uQWJ1r3I5/93/nSm36WeuF+8r1xNksxEl6M9EqRv7T5RjwjpBLews6Z3DxXQAJvu8dg6KXxHZ2g4NO9cgkpoBZLcGakMr86Lc4ON+nbEkuksGSZeH6DQB+RrWQREZukF9NwwwSx1ja1eIq0a7NcUs/s4e6LtGLKOYp5GtWCemdFbchapoKotbn7uMmPfYcgHR+ixxyEkEyUL5A7/iXWX7qzptvO2NlYB7LMpnV0xjDCyrQ9kJUCoSZIWBYJ3WZUS+BnCvjZIm6UhSlkxIFyJX0gkDIgzGmE1T5ePM5qIUuQn4Rrqzxcu8nw/Emuk0b0PfJpwWyrhq9pJCMClHjokIyIZwaVM2Qcky0kTSHp+ePE9/UYqgmgSpR1r031Le9hphRCCB1frXlteWtXxL4rMtyf7XCZu3iBBxn5IbqfxPdCRDpJrJABCQ0SeJrJsQmTTFpDOAF6pYRVbaPHY6TnJujUNxCBj5Mogn2D1smo90pKiFjWAj9goa6cyNJ0nHJYZswvMjR7lO1OlDGMeqGMCVrSYKqn7IL08mw7AXcnQ+Lxt7AWb/PBlz+IOeyQHgU4CR+pGQjp0xhNI6XcJ1mxphylAEam5BhN3missdkIjuxVclo9Zot7IK9Yu46ZS+8S0OwXt+9e3QtChP9NlTBJKelYHcZDSY8sRlRGGuSULdjKnyA+6qGP+gwHkk68zKlglc2GxoyjSvbrBQe36fJdb4Ef/XbJZgv+zQdhZcGiXiixWEhzXwQMOqYqH95fTmrd0iEQ9LIuEiiIDRASe2Ov1NoPJM9ekZyI95kZNoiPhZTSHhWrza2eCmg99kXJ0ibMToBW1MiIPvP6MS4nTzAiRSHZP5gx3BLE4qAlQersAsNwCEN/SNLR6btDdmLZxwcaL9Pg3df/Nq1hE6P6MW5642Q0l1NFyVNRaXXemyOxLACJzJ/AaduIobIRMysv0547T+GRGazGeboptQabsoyIOWQWnqFVNPlfzE+CcAnsSZYXz3C+aCP8DLrRxanM4EqdbGHIVOESp87mePRNjxJ3on7aRHVXnig+ViB0PWYz6vmv1QJCu4aIjyNiBVZaWYIQTs8aDBbU/O0XigipyFPqecGY26LrCVKTOsuJgDN+Bj+R4lTYYXnrKwOGQSRbssM6O+n7rISrVAL17rx2nxw2QvMZM038RAazncQVEkGIbaWZSNXYbim7IEKJFc7uEIvT01yEmSS+rOb4yfJJ7qt+K/c09vqNHU3neAQkk85VRUBz3SFJnK62iWlC0emg6y4xXJx2H//UPbjaU2TCU1jlMQxNktbBaAnCTJK8JfGkwGoKYuxlYgZRf2HH3mD+lUv4xvBQf3A90jCctiPnf3oM49hJTHx6jT7Tz37wwPFbIweESdoeMUwYJMIUy83FA339yzdbnBvMc3zybRTNLIH0mQl9squSzHMhhc+EpJ6cpOn9S5zlH2Vo/TxveeFduOEpbC1GevvWnizISH0vXe+hzZ0gbgp0mcUKerRWWxhJ9U5b83vAsJBRz8DJKj9K215FW68jdY3qqk3or5B55A2MYgoYdlM6bi8kHC8Ae5JVrahvfCM5TSvTQfcDxvws33f1LDZZxgddZEWJ2+f7bfCVnctGGaidjKE/JRHJHqlXJdtj06SPaQwWb+wyk3rnsgTdZTQzh3ssxBUvYIx/M1e3x/jY0nv4jZffy0styWNbBu+q+ARCIzfsYg46vGrEmGuAsUOqohW5Ubb5/7H3n1GWZWl5J/7bx19v44bNiEifWVVZvrqq2lU7GuimhRcCSSCEEwySBiT9/5KQNMwwIBBCQsjgBi8aQUNDdbdoQ5uqri5vsjIrvYkMH3Hjenf82Xs+nFuZIJi19A2xVu8vuTJW3BvHvPvdr3ne58n9y68F4FLzMPp/+ChYWYoqyzDsYukO2ZaL0ASD1pgjf+sr2d8ecW074e5pMh1aeYSVZkoHb9yxqf3hPqbKkgl8NJGmJsWkQDFObbwYFzE0DSPqoot5DFrctExO5RucwuTpsHtbskJNiw6vaRrLvRDHa7P41M/w3U8/TUYTNP+C7nbSG5MVIb2Ti7zw0COIXlrw0IeKm+2btMdt5sMZJr30mktHqpyYOQEIbpkd2JVMltLChrPUYN1eZm4yRhgeS+q5P/f3/ldeX04M/xKXjBOyPUmkS8bdNNCp3G+w+DUm9Y087QtfC/GQ5rkKC9aAojVDZes9HH7uX1Pce4jNxjP8vvUCT1Vtcgk06gpHh08fMch54CcTtsMvkIQaC+98CCNJyA7TZG515QQAXtxj3oNIK5AIi4+c+8htIWrf0BFCYdgeZjFHu6uwJj0038XqV/DMdIOMvLS7dGUyTQynnazISrhUXWHQSFlVs6YGaLiTMgoNbSkNuKODgHhGMHlIw9oRaE6R+vjD3K3FXMlUEc03E0OB8EDzwU8UyZRvojdSaIYgMydwdyTa2i4iTghOAppEs2fpvHqVOEg/0OluY1DgfH2D65VDrLaukRGCiQSzuEfsu/gqQUNw0ks/czBKg37DNnji8APoaJzz1zD/NAO0F6BtNPGnbHlmmGYzueMl8uMxatZgbutlWg9+Dc9Usjx/8kk++9YfpXLvLwCCvdlHeaAVMykaVDoe9qZEn0yY21llxusicyFuRrE3a7MwF9LQu7SCGvGswvXP4+dzhGgcd9MqqxAxD41u4Rs6RV2xFx/Cqe3ijsbk63ncaXduV6/wTOsEn/18m7s/+3EAbtYPIZTk1HaPuQdSGOpcx2arEeNbDgVc9nM14o30ubx7cT19PloyTfxNFh79NRRP8if/3yzZALfF7T2rxu5YUDIVmf8BeXG7YxgJMA165Qp26JI13ZTBc1o1H/VTW0uhpPJ2UKEHBioegyZwt1uomTpS09i+626cK2sc72/TffgeQiXSxDCvUdhtMsgVKPe6CKUoGwGV7nRe1z6Co2n0UYyBkV/DCCa3oZIASZhS0//Og7+KXH2YxXwDNBPXnEHpOtqtvdtSFY7yObyk0SZNWK6yijE9EHMn0m4hQGvK6ruylKWcFxBKZL16u4NWOLZEb7iHb6ZFib7ZZHvSQ489BIJoGrx1N7t0rHTfJmeyaJm0or3k1RHuGhuuIA7S/bm5kM5dWuO0wCHjEjdIeFRL6GbmOLa7zBdufIErN79I1o1JchG5ufOszn+EQBRxtyR+eR6pGWS6W0RTuZmeVJw0Wtyj77O376ci9/9DxzDsjTicnSakgD04INMo/4Udw8EbEbbfBSUJL/YxP/Ec43BMLGNmo5CO2cAc9ehbZZSVJn1uvo6rORj9Nn7fZ1Jb5pTY4vKGou4Kys6E5Zl9oqFCRjEPHIN/9I1gGfDT5xb4hce+ASUETwzSavjQMYh1B713JzGcXNbRCxJf+ISGwbE/TueFZPtOV/H8DcXYhbcPLoGhULN5olqRU90NLrkNnn9D8uJFxbseFIwtk8K00/f58sMYoUePCrX88M8khklTI5+BMDOlap/y0gTjEC/2yEqLeDhhSuLLal/jWmKx0r8b2huYzU9wRX+AY3nBXYcNbrgFdvVZFueq5CMBCMabFfq9DMJNE6j4/e/j8X/6QQgj/OEs3XxqwyPHJJI5gu5VrrtViowx7V20aJU/eFrSvrLLSeUR6gGZG2d5x/e8g3sea7N46ArGZMjx2eNU3XlULiSy+um7277DTNoQbzKTJmnH0GkgzDJrg7QgUcxqFAepzehFwbfzAiKBf3Tws7z04t8gdNNA/3pdklGCnePv4+hoj95Y0R9LjKai8mR8m3nwf1zxblowCvU3Z+8V+7JHBhNd1zHdIVkVYlgTFjBIVIXGL8b07CxZPCb9kLmSR8+1kVenhcRJWpwjt4sbZFEyxO6n/kEpqG/u8ng/d/safulLv4Jlpv83wpvs+eBckihiOrqiVDJ4wHiVxx7/CAiJ3x9zdNHgM9EIiCnc98RtRlKnpyHvWoXVZYRS9LoamcwYJdP3PJrOF7bW03giMdw/V9R5U8OwGqcFqGRlgaB2iAY9tnLHOPTMb1DYeuP27zenrvNQd5p8WVVG4YSed6erlLz4EkJAhVU8qXjWe4lP7/8WP3EiYOdHDHb+mUH22L+nOPOvcer/hc3Kk8QiYRR/LWvOItm9a7c1DJNx6t+aTgG09MBx9CKSgP2NfWYP6wRCEUxRSO12gJ3t4nVW8TOCGI0Zb5dk4wA1V6P14ksgLESjgpdJ44ax4+D1PMhlUDnn9oxh59VrSNPmejamU91AIPiW4B0Yey7tMCWekfVU3H62lRbjC5U58p5AqIRuJJBzVfx70mc+++KEzdlFMocEu599jnCc2kl0Xz1NDEON/rdLRGhhrXwbm3vpO3m9dYZf+tKA5YzkKxrp+zrhj9GTkLXYpOCBo8foMkEZdS56OoVcE0Mo+kdLOGdbYJgUlEPXS/dAOdQozZfobnapPXKa3ROPAbAU9ol1B2yTIEnPm+7VO8XU/dE+mp7Dju7MYi/HFWyjiBVFBIOAe2pL6CSY4TxCNNkwTOYL87w9P89lHboyCypChT3COOZCweZYLyAzlcP6mrX0LNluJSTBn7XX5kvrjArpuelXcnSOH0aFI/SB4uOXPs4iczjKYri/iy5iTui/Q1aOWSotsZHZIDeCcG+A0DX6P/43CHSHI+4Bptml0v4ylPTL639yCU0QffYanp3cTgwBZt9jkDn6Op3LH6R/6110L5e4u5zhidmvIde9G794i+1vfIErlZdIhOTyIDU6e0r9vn5YY2DBIGzj1EY4wyPkV9IuhTPYoxYWKd59Al0mDKIh81MWrLcUi7yy9Qrjg+vEwkBNuzYq7FB94AR7W2nwk906QEssEj0NcNbHC7zVuEVGTGey5Dya4bKaaXGlukrrcNpBszUdp+iglE5MDVkdYERjoumA8/BdGlomdWiO9hr3WXvsajrDaYXPrggyU4sNIoWrpdc9iXWkVGQXU2bSN5kmJyfTA8YcI5NikwABAABJREFUVrj6C3/IwcspHMMwAgZLY4rmIc7OHKfS26CIYihjNneO4/uKYaQTobg7TKEcB3+KGbB60+KQOcOu1sO6cqeirN/YRihFUMylZDYTCK0uk7cdZ+bggGMz20QYbNz7NVweJuCvcSgb4WTPkvd2CXJV7o33EJqg0RoTBtfoHmzitB+nPhBcL0k0UWZ3zkFXQ06XNlkbrRAtaORuXCdeSQOJNxNDgLtHO6Br1KOIq9oKwuoSTkLKWUk3yACK4VaP17slTBXyzP3vRFeKrWIDIeD+5gbDwlQMu+vgOTDK5ynIIVJo7N9MI1FteOdvJv4MxCZq4zgrh/6E8s1/za/ecIn+VMz/hZbGs530Zb7ZMfScOnsTwbz954OvyjQx7IeCfV+wW5lBxoqs5kG2gIhCjFGPgb/EeGeHcl4jkTCaah1qiY3E41c/MWK4cUBuOX1W1xcXKK9voqHYfChNgLRRRMGIERv7HFRSyEsmiinrAXPjNYJiA3eUwzf+1BxbUE5toN/k9Z3X+blnfo5RN7WZk1sGi8EMRZknsSOUphM3ZtBv7dK7nMIFl8MQLeiSYJDB4xpHKE9nkaylefxWP/07Uw3DxcUs1XzaMfQrNeKJRzT2KBxdJJER/WJanAnNhEQqcqN0TwTTef/WWoteoYghFBO7h5gmiX/92gpefIFQCXY8UFKwuXCCaiwZGel+r2cq3EDyVi+1/Xz4CKeqJzh7+TPkvAQENO77CM6DTyFkTO9sApqOX1kg09m8LW6/HyZUxQQhYLzbvTOr9KcO7KA7ZEk/YMOZ52bmEKAoFI3bM4b+yEdoAtOyGN2UzLTPYecSxkvHyPz4bzC8lkqJzPkub6jj6N6Eg8wchhFgOwMKuU1u1MuYwy7jrTbuzCGOabvc2PDJujpvLd3i+/Ut8kZIONUhW6zDP/nrcErv8ZxzitLZLnOmh5lMGDsiFbnvpImKDMC7oZM9laB7IbEmmG22p3aWJoZKKZ49p5ipwNuuvUymEjIpzRLOVDnV3WRX1vjYFxNOrcD73gJtzaI0FRwf+QXm+zv0qFLNDOgM3vTZkHSgaKbzhXCnYzgep0lQTsvCeIxlCQQwLwWmm0doEfepl+nqh2jJMsdzMXdN9WA/a7+DxtcY1KedqYPPdNhvzyAmMYYleM8HllLY8m6ZUUYQmWliOMxo+G6JTHmBV88d5lknC04TXdb453+rQFb0OXXFBqljrJYwMjbCrmHlI7xml5XKClVvjjC7z9/X/wvClLjbCruedhEtd0jOEWw3fVTQwZAzZK8WWOuvUi9KMjdf53vz/53DX3XAj/ET/E3OArBVdcjKgHpvHYCkIdjSE7aqb+XIfvqzjf2Y7AVJ7nWF+f+hEd4dpAWjiZGeZRORsnJv2vsUnAI1JuhCIbNdZsIE5VYQwMgsUmSEN/CYq6WFRO/iNl5GR3dnOJF5me/O/zBi4uAHV7D0ZVCKziik0d4lyN5xqqHwmWjpPlbJmOaoRXnLxNBe50DUqGRiGtYumiZJLPBGEUcWDD4VHUNor5IrvpUG6fuyerC95JD83Q+R9aE10NB0hXQ3b88XWise5sU13vX5L6Ab/T/fMZxqGGZV6ufFfAWvtsSs6LFjHcIvz3P8Yz+BMUltuTfVYv76T/9xatv2lGRsO+3+B/0Rje2L9BZOUZQW/USBPEMuGjO4sglCoAxJ8eB5vKNlCuHT/EHtKp8qP4sr38mOeYzcwU0O2iGFrMAeSjQimrVDrDdH/MDP3cSaFua6gy4zh2v0HYXeSfdoYdRECIU3eBSEYGhkWRV7hDcPiGbK+AfXyB16kN7OgKiUdorHTobJMN1vslFFO+gjw5jRtU3ifIlepoNrp/GNoVvIRNEOBI3WAapephcK5lo7oFv4K6vI6jKPbFzEX28ycmMmd+uY+1n0gWBtdQn/YB9v5wAl0o5cdCyLGh4wTv6IeEFSeHYRYeTYPLCoZ9ocKa0zuhDxvQsBg6kc1H0vvc6WoVPsT3UxDZ/6eEA+d5hLvg7uOnVL0ToyS3RGEOsa+Uij+tSvksiIopalslBmuD8kiRJulk4yE7Xh8hahVaD6gI6npe82vHVnQ+0N94isLGZyB/mxHM4ji0XywxFud8I95bQjpw9naFqbhJpgtrzII3Pp2X2+mSbRyt/nCze3mBgah1zITA++YukYPeXjJTBZ/1N7R8L5l7YY51NegPnA49zb3oUad5A3W1zcv8gHZ96f2ml/wInKTcr+50l6Zzk9e4qN3CUEAm0vwiqbXNn8aHqdkxxWc0z2y4nhl9f/7ArHPsWxgW8l+P07mj1CCBYf/DWyjUvsv/KtLGZrKPEj2IZDpPfYfuiniasBYbKAabl8kP+MQiJTm2bRjrjsXqThLFPI5ikMT5GYBSRgun1W3TqZf/NhTnR7dP0Jc9Pg+ViuQj1T4mDnPC4ZsvNp1UsFbaoPnKA7SYNSZzO9VkNPD8MXxvdywmgzq7eRSEI5Q7awxf1scJCtcGs+LVUb0sIpOJiOSRg1SIwuTtAnmhKDyJxAVObQ5Rq66POweBmAG/YxUAqrKshMceGBp+hLiTAGSBHSGyZkFtPAUlzYRDkW7kI6V2HezKGimN6U1rpIjovVlyhbhzk7cxyhGWTRGAmX7e0zBJZFoAQHSB7E4IFM5nZiqPcU1j5Uj9WIRIJ76c57ezMhdQ0DdB07NBmVr3Iptpjv73NGv8oL3t28ElUg2ECqiKNmiN0VmE5CmClTz+6SKKgMIkbRZ0ETDDNLVCeKtbLOF+M5hgWD7Lk2J2cvszNeQOUSipM22OnBempyC1+kHZHjUzIWZzNkXV/Gm3Z3Z6Ntdr0iIKBS5h3LBf7G4fO8fP/bKY48DjIVKkaMhmKYUWRkjpmpfIiXNShNK3A708qjGt7R5Wt4sygRsNBfZO+lv8NJrvLu1o/wH9/YpROmYr6/smby39bSIETbPiCplJC6xf5fwEgKkDfAECkz6Us9jYNKjVBZmElEnC9iT8bk3DESmzd+4WM40/t+kzhAI0tsBJx9rYmWRBRX03vZqzSwfZ+J6XBx5TgChRhHDF98A323zd60210SgrwIWfbXmTSO4B8kTLQ717mDyX8ul/ih536O//zsf2azu0F5SrDxHU+XyKl0D6hcehD61Tm0W/u0bnUQSBLnHYz6KQztfnGFGJPA2AalEMUiQauPMHRGgY5QkkZFp1EUiFgxKKVBgN/sUprO8PRKK+jBiPBNDx+nbHqTboJSitbNFpNalXlH4dy4U5R6eD2H5abJ1C3fJvRM1qtLPNRPOLD6KGmQX/4DtpAcakvqImRt+STfOvc1HNIdslOok13aR+Ul1eEFemejKZw0lax4MzHcG0ywRPp+9H4Xu57u7XA6qyTDGDEZUqPDy8V7uJA/jkSjYnlEwwmxF+APfey8zfimQiUatd5F7EWT8eJxVMbG+4WUmXd+MmStk76DnlNldfUs9973GXIkXL07lYLRDpr8crfHTUuDgybGyKSheWgC7inuE+7fCWJyDvwt/Tzxap7gwOOXxp+itPfPGGUgsMvovdQvvAkjzZ5OsPwAkUicIECio8ce0ofNfdg+gLfdDYub22SqEYPqMu78HCd7qU9ZzI75G+/X6I8EccmmPiWWet/mDQ71NulToWQMmKp7TOcLBWWRzhcCCB2EA0M//aW8mUf3XDBTHVdXCpxIo37Pk5TNPhdr3wPA8VzCUkOjrg15OrmXeglq09jtvHgbo6CAMQmxi9PgR8V4zUX+VDOLUVbgT2ZYODqHNRvwEbtMxmzi+TqrcwbZaEC93yETH4OjUw1Qu45uJgTtJpawqHhzdKx1KmKIlR+mHcN6GSCdM2zoDPotQJFbK7H46mW228u8xX2Fb3npX/Ce6jniUOfnM3+bX4i+k0TAZxdTUfNDvRTaN1PWeMmJCUWBYj/1p+v7Cea0G2Yc/MUdw+50Xq1vhOhK0ZwyWV6rbaKrPGWRFgHGuX3Kg4BEq6AAIeepMiAYByzOpfcirm1w894GSZBjKXseWwRU9V26+k00p4qxHbF7dQddSqQ1nX9W6VmdxHfkSub3dnB8A017nkAaeFv7GNM5L8tyCWPI6hK32OCSvg0U+BsH9wFwMRPz/z/xBrsPz5MLBFuT9H6iwRX8/VQPM5ZbPP7c88weHFCYbPyFHUNDSLQkgxAJRg788gKzokfX1bj+dT+C4Y859omfApkwFmkAc9+NVKara9l83fOK9VufQynJ2ideQlcJ2qFHyWvQjxXSWEDqJtXdq3iBInuwhhG6jGePY4cTLpo+H6s8hcDEDt6KEQckl86Rk10WvRJ5vcMksvnEx8/R7ZUZ9tMCuq/7VFeq+GXITWAwkhyaqpg7S6eJ3DITx+KQdoC132LgR4BO6cEzuD2XwEzfw9jO4rlvJoZlxEGXwdUNVJwQlyqETpPYSn83SRSTTI4EQWN3FzVToheRJoazK3SDmKgyw4Mbayw+9zLP/uqzPL3/LTxz9UN85v1fAU7I5Wdu8tqj72c3UyYO82wVp8RBo0/itpfZu1GlHShuDRtkCwHfefeHEQl89ukxvdfXASgec3jDspjv3nmfy3tbGPY8rVhjv3uNuqXYNGZQJ6akeIMOQiWEox2q5iy20FFKsX61w82m4tHjGvowJLLy1N5iIHULN1OA3Q5KKaSUdLsHhLaDoSSxFvCHSyaarOIXcxSGQyadCau51M7jvQKb2bRQWWz/Phkn4F4/4JVWeg/Sb/LSzpSJPBA4QQtlOOi1Y3itCyBgNJ0dVQr+y5rJws11epU0LigkLq8tn0EywWzH5O08j+ceBmBXxZyuppqYKhpwqnGKW056vlrNMVamwxWmRWYvw2tn5jl/7338VVpfTgz/EpddzJINs/iWJB7e0bVSMkYXLvNv/QVkLiSyvhVFHkv7HKN4ghFL7I0vESSzOPaEk+bLHJz6beIcKCk58uRHOdh9GgSUd96FMzjMcKIzyORxAp/D/SL6Tov53pimGzA77Rj2tRm+6ej95P0xTQXZpenJLkNKJ2oMtbQKZu2lAWzBuE6oG7jT6k9RC3BFREyZQmablcll0CdcmgYivi9IMhI7b+P6VZQaYMV9olEaEApfoTtzZM2XeT4zx6L4NDpwtXoMxh52VSOrCZRShC7siQHqkRbi+Bp7uy7ZxWll8tIWydE5lD7tcN4so4TAzaZBc32hw95kl6y2wJXqKqJ0CCEEA5FiWRJb4ksYo1hF56v1CtF4HYDMpSmd8iNp5arV7aJP57a0q1uofAZvEqB0A4WD1CIGrTEnjvQwiXl+fA9P72lkw9SxnLADCgeCniUIyKCWXTY9m0AZ6NoblO8/STwdYC45ko839+hJDS+8yYmZi+xN4bvxrGLmxi1MFXHE3WYtexKARS+9p6NrMVscwnXTCvv88CrtIEdkSFrzDZRTxSKgEXao7LTpiyzLcoAyDfpxgO3nqfrpdwZ2RL23g6Yk2/3URGK3h1KgRRnybgPdiHFOmIzWH8Xt/RPKRszfcX+E3379FT7d1BgrwXYkOHgjRttpoQ7NEOnQQ2Puf9AwhHROvGSmM4Yv9TRG9SKeyKCFGmg6Dxj38nXFb8NKEvxcne4ffAoglaxQCs0ssm1J8uP0gs1aHaEUg2J6EOxW57kV6BSVREjQN/cQSrFzKIXR5qQir1wOyV3c2WP46z49/c7B+Tsrl/nFcpFVM88PvO0H+KnH/zn6lHHNNu/MAVm2C3rIJDeHtrmPFxsUZIS5XKU30RBIjHyWFbbpmjlEFOONI/xWH7tewo90ciLA0AX1qV7jvpPuP6/ZJWuXMbHwsotk3Vu3tbxcI4V8DbqSSXeC1/foZQocyiga1+5AGg27xrc8tYOmYm4FRXb8eYZmhoebCV2jTzYQDIMLJEqxu5/wUCFiY/EocSfkfXNnML3kz4zdzvgvEg4E7qbEqy3j9HYJewmaDaMp42jsZKhGfaZSqbfhpEFvyKHsAKEUL/cPcWW3hI5kVqadf7/ZxR/5KYz0UoKmIop1H2fBwO9puD/+ffSmBYLFYYukPyays+SMmEKxjWP75OIClY2voF3MYfbaPBf3+KbFeVqHfx19bJJ30sD7TLlJuHeH1ADg+coyyfEC7wktJtYVhOwxNHfwstXbHcM3YaRiISEXeFheiABizSA2PJIDwbPnFY4Fb3WamHGMUw3p1o/Qm1viWH8bQ8WcaERkbMF+B2TFojBOCzNHWwMKwYi+LFPQ+oxdRRCq24ykVZl2DP2uS+f8HlpOMvHTa8s5RezQJQYW0LhoSjK1G1RPfoabzQe5Jg9ja4rlTIIuY54Qr/PiZJmoqzDEVDsxM52XdWPIpnYuogFe6zheIUUTiFgyySQEwwUKGY/Fr+jyYtHgLSpNerdbCcZ4ek3hKmophXO9OYekwg7efowuDdbsLWIga+7j7Uo008QsZKfMpDrRJA3eF6/dQIs+xV5S59jMmB8t/hM+cv79rF8/zW9pH8SRJdpZwWkv7djf3b9MJGG+qrNmSDR9TKf+VmYKcGs/xmilRm3+BYlh7EeMhSQSEVJIHp/EjHSNXCLZsj5H7GXQRfq5QWaInQxJtDICqIyPU2JEHEbMzaUohszGLrcOHUEhKFlpwFk29ujm0gJO9tUx/aubSCGQU6bTcpyezXGUBs6aZvKupkQhGegpmqO7OcB20jMxk0mftzvwqBxp8EJkIsQWD7XfDcCBnhYWLjYvYls52pogGYDff4PRzQSlJCsf+0Oybvp9zqT158hnWn3JnOPiyiq2EyA0gTJtZhyftm/hNo6y/t7vp7z+GtVn/yuRXqG42+HvP/4PcYY+vYLONz2b4Wt/eoR68r/R/eKr3Mgd5fCkkp7XiaJT2kXWjnJscpObWwHF7QsAhMU6EbBPhx37gC37HAuju1FKZzHaQfN3KftVCvoB3Reu0rucXvtk1CDxFomciGKjiDEn0BFsX4pZmjKSZlcc/N4Kfh5m6ZDzR3QHI3T7DLI41Z/V0qLC2MkQhOkZrGaraAc9eudvojSNsLGE7mxxppMmxIEfM8qn53Oj3ULWy/Q8mG3vMS4WaUYZ8lfP8lLD5kuPv4Mz78lx+PCrLLV3sP0AQ8V09l2OD7uE6nVGvSVaVtrBttYN/nH9/+B7v++f8d0v27S8OjeLp5jJd/i6u87ywsWQi8+m/if79x/jrG2zOkWXhEOTDz7zRUKR2tgbrU2Koz679gy9OC2cGkH6d/TOGnWrwcJvfAwh4Or59Eve9zWHsWXCKOPw4ie+QGQMCYo1KsMurYGk7baZmRZiTGFwuerz43c7/IcTNn7WpjAa4Y8DqiqNzfRmls1M+t0NM2Y4foavmris+wMOYhN/vMGWnOH4KCH2Fabf4sJdH0RoOsWrT1E3O4xupOfMk3s6T7V17r9xg+F09tyUPgdDyWjJwtbLfIv+MNm+SSJD1m2Tu2tp8VRFfY7Vj9C02kRaSC6aIXPoOJ9UX00mCtHjhEeDj9J//eqf8xv/K68vJ4Z/iSvxFJo+h9QEDCOu/6LP3p9EjC68iABaVpW5xpMUpwGoJw7oJT0cmUUMrhOMBLYzYRidob/8OTzv46z9189gXLjMf3/0HXilA0o77yDTP0pvLOjkS5R9g8P9DINvjBGLEeFEUrUVmlJ0xCz3ZARL6NzKJOj1P+XoZZ/8mVNMEgu9axA5bfLJgLGdZ0akwVNBePSIMDAp2xt8/KHzFE78GGe7r4CI+XX9Zf5d4xS/cvQ4N9004DacEWEw7USuKYTQMbVX+YeNDL9VMTimSS4XZtH2O+g5yJrgoUDClYWn8ItPEFcX2d/3ySxqoBTmrS3iw+X0upVOvldH1pcJp2QwWuNCyqKoZoh0Azl/PwAHKiCfOSDRAwKpeJMaIte5mw9oFwg2P0Ky+yUGxy4jiz1y5Ty7Whfn6rTrcW2T5MQywWCM0g3cbFpNi7yIbHXErWSJiAxvjDQqyVVm83UKOuT2FbtZG8MeEx9SdA9qXLAc5uwu8oGHqIzTAOsBUURK+MzQoLu0R8UZEk0FpN1lk0NnL7Dq7eKokFv1B9NnqhLmoxGnu5JkMs/ELaPpivD6GonSuLnk8uz8y/hGWgR4UO5S7BwQYjDfPiBp1Oj3R2TiPE5wAifQCLU+TuQxm4zY8dPOZBwOUNLAmsxjhumznyzMM2teY/jGPKX7fgwtu8p3Jf+e4a3fRagEpQle/FgCt1qpOPDsFLL6F3QMIYWTtgPBpaFGWFWMzCx2qCBJOKkfQSC4V54gEAVq8+k1rD1zDdEaI8wMz2VCamEaXN0ITGpSYU8lI7y8xborKMYxGT0mM9XJGy7MMXEyWAkUowE6imH9CNaeZF1TrGo7HBPbHO7fzW/eHPLjxWM8sPgA1t6U5ERoeLX52/dQ1DU05TLSGqjpvJLwZ8kuaXSiHBUG7JeO8ihnCXUHoUzGBxP8Vg9RreBLm5IZ8nubGl8apIH4rlZMReSbXYwx5FSZxJohM76juTl0mqAUk1FE62aLWGi0MVnKSOab6ffIeIQoL/CBV2Icb4v1uM7laeXzoW6MM+gRGzGhHnFicpn1bsyjczqxaXFhoFGJYybxDCoxbyeHJS4jhKL7eoJXW0YoSXLgYZYFujtCCsX18gUyIqY5hVy9GWCG3SGHsn0+u3+MxrnrmDfajCOLxeksi7efJoZ23mFwKabau4J84CjOrIaKwD1xmtYTaTFDXjKx3SGjQoO6eUA220/fhzOC8Rzt3Gm0JOIDrcf50YMeR8Y22URiOxK/b1C0A+rNK7efp1LwxZW7uKvZ5K7QQ3PSpHHsX8Ivz6L3Rn8GRjrwFIaUZCce0hBImZDoHt0teOOm4pG7BJW1NFHKVCPG+Rn+29YKtow5EW2xPx0XuNbRwNaZSaYEYVEBUAyiIoaIyZku3WEqVSGyinwkCDKS3adu0Hlth451jrGX+hPLKJNNXPxQsSAE+zIhueeTfHrtK7l55Zu4NtY4ko3RBWQH+7xLe51xbLH5hmTm4DUefvXfcEgbI5DIEMIpOY2a9PF7y4ytEUJKMm7IIKsRDBbJDVtcibMEBnzAT+93bdMjN/VxRa9KMGWaEnZafLPyEcNraSLTzO1x0zIpabdQScqOac+kWoaHGgYFIw0WHW/Ea8k96Xc+VON3eg8w445Rc1VcX1GPBHt5jWNBinQ4ObnFIILFGQ0EjEtdJvlFlvSY3b0YY9pUN1t/3jeNL1xhImwC3We1ey/3XPy3WHGG+TjmFpv44SvT35TkJ0U04aHCCkkGstFqKlmhBLo9z7yxT7HXx9dS7cacltpVSd9n7BRIeus4axrRjU2a9Xmk7qMBjTA9B4bCppwk5ESWd3fqCHWRW3Ea7H7DiU0cJ01ScrnUP726HXDkkIMIQq7YL6IlxyhvHcK3T/CdL/0km9ea5BqzjDIC66aGmKwxupGwMHqKxVsbXH74fqQQZEY9gr78M/JErb5kUbSZyApW+U6oWckLJtLCCxQH9301rbvew+7Tn8eSdQrNISMzR645ppfX+fR3PkisoPJ//gkPXt1kyz7MfDstevQTxajQxtZP48iArRevU9h6A780i5bEnHVsEiL0ROfT5c/jJFl6vJuT+jaFkyZmVCPSfOZ+5Hu4XitRkns4iUdw8FXIqobQBIXD6XU3ryY0cgfEYYn/sNPB7y8TlCJ0FFYuxrVMjOzDjEc9zKxFV9OxkphE0xmYYdoVa5QR7QG9c9dJMnnaGYszez2+6yOpPwvckFFhmhj2OqiZMv5ODy2TRwnBhXgOAVijJmuZKvXKJQ7Vr/LIU69y5twNfveR9/Hqqsmzs89iMubKjQdY9IbEDUX+0hL/srvJj/7Sv+cbR+lc51caL6OR8NX1P+Jof5tzYpWqoTD9Hc45NkdaCpnWTXnk1gV6kcFctsilSYh18yY9p0yLowDk924Q5bIkvXWE4VBf71FttSlevMQ3T85R1xVm6NGc11hZepbe0kvEuSoNt8f1rZj94T6zozReqpgZdpzUlzy5ZHJtZobCKN3/QW/IQDmUhjk2zCF1qchoECc9nlApJP71sECnd5VOdoFH2hF+AE1do3Xk3YyV5HfqyzR2n8XdlLx6IPjNTYNv3WpSmHQZ5jOAQAjFaOTz4swBwnR44lkPo6tIvBZ78w7LxbRgI/0m4sq/ZtGO2LaaFPUGk7l78IXFqnuAY23xbTzJI8nFP+c3/ldeX04M/xKXnhFoTh+hwIoh6MXs/nHE4FwKpfAuvZsPTD7BSTs9WG64x2mPNwkXH2Wc1fHHEcKOKag8hd3HCfZ/j+bTL5FZnefVe99Ka+lljKiIEaWVp26uSD52mI9MJu+VuI9JakMfmYloRIq2fgjl7zATxTQNnT1z5/a1qqBN7cGT9AIHRiWC/DZ2KNlKJJZQ7GoSR0gm0sTSoGpu8t6bisru+9C9E2TNMXnn+0jMBQZWnf/c+Gv8Ht8GdZ8osZGxwr4hEWrCrjXC0xJ2TZ17cLlqmLDZRwhB3hYMgVZui95seshJK89BJ8TICAqZPrrnEq+kjkUYKWTHr9YRo9TLTUQaVBEXyQNJ7TgqCfHDJnPli+j6AF+BhWCIojA4iS0U8c4f0V76JfaP/BT/6pd3eTXOs68PMK/GkEj069skJw8Rjz2MRBDad3DlB7LA1fYKFCzGCmL3OsfKacKgDQT71TzZxpRSfP0oL2az1G2Xjlmh4fUB8LUqufFhNjwLNzdGkGXFnSWWOpMjDqfeuMDx0ToAg7lTSGwQkkf2+9gJGD1Jf9Igm/d5+VaaJO+Xffp2nyvZtHvzoL9JMk5T4rzuMvBrDCZDMlEBzVigMjIZ2WkQN6dP2JpWEWMmCBTWZIEgSH92kFgsWm8wOrCRSYnSmR+BmffwIf6I/5/8CbJqTPsQ6O0unlNnOJXi+IugpAAVS7HnCyQCWdhibGXJypisF2MIk89knkHvNxFKsFw8BcDm2Q1u/PonkSrhJREzE7UZGAVe35kwi6Kxngb7oTniINCw/ZjFbEh+NJXoKGfZmZnD9CPsIP3ZXv4w2bHOmqb4j+bP8cvWz1AKT2EkNeypZIW2m/4bG3nIpwxxNzJ9ZmURFbm0RZZJLgdCkEQNckuCpqxiK49PNlc4qtbJJBOUruMNXfx2n6hcYqTnqeUkH7uZcC5IE7quq2HXinjNLvoIbGZAaGjRnxIvFhF64uFLQWutRbTQQCGYMTwWxiWUkoS5EbpVBU3jrrVbbMgFrpinKScxS5OIe69Loums54Pus6yPPO4pKsw45DwlzEmfrr+C0COEP+3eF33KhS691xO8aspOHHZjZA6qwsUTIZMg7TrsbxygZ+4khl6zy81RjfP9eS4tp0H+jVGNaph2hbz9TpoYannCHtRabxA/eAKnkQaOflPRuWeOUqBx+Va619q5OUqVPtoUBmzZE6Th0CgqpGkhNls8oYr83YOIWZG+7+7VPEGscdy7Q9d/K7DYK9d5eK/DXjH9uVI6KrjMOFdD7wz/DIy0N0xh7BVnm/Xvd3AmLlL3ef6mREl4/IzAvrpJYJuY+YQXt0t88SDtmN3trrPWzyGl4nw3TZoeLOyDC7/61jX+4IldutM996aWYbwvsOoKIQTbkyZB16V0coZYueQHETW/hmZUECi8ABakRnXu8zzfPcFHbn6AoVthNzA4nkvhVrn+Du/Q3kAIxd61iFr3MsXRBpnumHo+La64tkGsINyMQBkMbEUlisgpySBjEo4aGHs7vDaWOIHGmfI8OTxefWGb4jQxLI98tpOp7djp/Zv5iMl6+jd6mSbnbJuGSn3lm3BSv512DGcyHVAGJn1eNc6gi5i62CaIoDLuIedqCFdhJ4L9is6ymyaGy/5+KlkxM03Aizq236Xc17C6qSC2NP7ijqF+8TVcsiRawNx4GWSWmckCGaW47GS4phpIBSYx9wwKU79QofsNOlLN3ha598cx904h3/ZkmZIucGT6XErWFr6cI94/jznKUtjpMmnUGekqlQmIS+jkWCfG8kyWW0UWohlK5hfZLZ3CylnktSamNUX7FFP/9OxWwMKcgTVx+bXyJuAxd+vdxNYSlnSYf+UB8qUqo4wgf01gJGO4epnj55/kYLbBhaPHmeRy5MYjFNFtGDikUNJlucdEVokLNv/PR28w8SWVUmrD3WECQnD18e/mk/5xhJghM5p2ILsTejkNjt/ND3+XzhtHitQnHj/xxV9l0dtmRECgwEs8VDCHb2SILlykuH2B0aEzWIMmT2czgM6RXYdPlq4TG226yddzRltDJeuESZWuobOtbRLGDdzaDU7EZ0nc4+wNUpKvxpLOWCjCbUkx38SN67ykP8YoXMLNpnZqFWPcyglyKyW6W10yqzNEQiCitEs0yAqiSYKaqeDqGv5BjzhfYoMB8900CNcVxCMXt56eFY1eB1kvI7Z2CWuzBJjsqBKhMCi0AtxEMOldJrNRRSQJk1yKHDrQBuxn9wlPgwDOn30nt86cQtsbcncxwxNnX2J+K+2qfsfJEDOJ0ejzD90XiKSGvDJk3FtjwzRZ6CjU9B6z3SGLezscm7mPm4GGsb2JEhptaxZLGdgbr/KHj76TYJja762H3kNuqY5byPHtn/8w8Xf+CmY0wjvpsbBwjfL8OUKryqzX4/pmyP5on4qXJoZ1u8KenUUMQrKR5LfuvZf8NDGc9DyU0SAXO6zrAcsARh6tcIKcFXNfIjg7lki/S6LpPNgLUQqatsNjGLwhfH7j9FfxL+YeYF0FfORFwWmZ8NhnrpFoGol5R8JCRJu8Hqfv0HnuFupKF9Hfp7TSQxMKpSAZXUOGXU7NP8h1e5uSNcNlqwZKcXqyScVOzwbr6PE/5zf+V15fTgz/EpeMFYZjo0/nNZa/y+feH1WUllM9wbsHN8mJMRP5EJGM2PDP0B7vIzOr+DKDRMcRIbp+lZm1v0sQnEIlaUD4zeKjjOc+Q2R3kCKmGwp608FaO5ceDvG8YnYwIZAj5j1JW8whRpuYSYg+yOJFLZIodeIqaGOdmuOWZaPiOYL8DpYv8eIlxsriYDq0nkiwhaCubXAiiHlE3YfnzlN0JJszD/GE/Cx/e/JDlIav86T4Rj5y/AkQgmggyV4NcfTXuVxOmeT2dIP74108AfsX0+/P6oJBInl29aNEVjofIs0i7V4aeFWN9KAPF2JAQ2Rr7NHijdo19iwfmegESYRAEPhZZtAQxTnkaI+50UUyZg8rMfGkoozgNWJmJsf4SG9K1b71boy5f8bGcJn1SQaJZLDRR19rIryA6MQhpB9gxzaJMaXZV4oN8yjBgU3k2BTdNcJ4wuF8GszpfditF8nNXUb5Bgvnhjyz8L0IAVtrPRbCfvo8ggzdoE4zEYQiQTNXOS0sDtw6kwZkfY+HrqfVQDW/TKKXEUQc2woIDNjb8fDcIrbVphOkHcJBPu32fr6wDsDhWzc4yKXQRD2viGp1XMbkzTxCGMwNbdqF1Ek3TJ+dbI24NyY2XISeIMZzXA1TONP+rV0a1W1QgvGNBKEZ+Mvfxa/wfdwl3uB7+C9cr6cJ5e6VMt3cn08MF577MIvP/lcgZSbtR4KKqXCtLULdpBB5zE//3tMzVS61n6JgKba8PfKAvXoX+5eu8cX9j7DuZ6hHXcZWkfU9RcNSrKxdwLdMJvYUvjaKmLF8CqMRgWWRTQJ2GrNkRy6EAX2VY0fWKCYmkiZnxBaHRRPH6NKlgjWVrBDbbyaGDrZVxtXh9VLMcjBLx97joO4yLKbv30iyDOWQviqilGTXtWlHBc4kF1BGgpQJUZDQ03P4eoa5MkwsDeVMGR9dSWY2ZSbVRgp9SqDgTZkrhaZhRjp62Eei09voES6niVJmtEGFKpHmER3OIbJVeseP8rY31hmLAtcyp3nAjzk/eRal3SEFUMaEuPc8mREcH+xxqTCP4fY4KGVSglhjyvxX1aiLW0R9RXucQrmDoY5nKGramHu6D/O1V7+XLjDe6WDXNIK2JOiN2P7DL7DjlXhkcY8vzLyLnlnm0mQOXVM4RYfJfg8ZS0Q/fY617kWSB06QmU2PNf9A0vP7FDIFtiolEivD2MhTKN9hjrUtF2WazHk7uOU5rEGHnfwKrvRoTKHlwcBgvZ3nqNWEfto6erFnYUYhpzoRO+VrGIkg4x5Bt2/xpfICRm90G0ZqH5KMR2mxpXbvJs7pAaVRlxjB68OE04ehVhJkL99iMFciCTRqH3mBH7z0R4is4PRoA0+avHBRMXIsRBiT9d+gaQh2qgPGuZhRkL7rsj2g01ckLYFdhZiEte0NnHqOxmPLzDceICHhnXvvxPNNRkZq9wXdZ+7Uk9zspwHMeUuhEBzPTQmG+ruUxYTDs4JxW5HxUmKv6qBLOZcmbTJr0osE/oYOQtLJFahZgoIuCSyDWBi4nmRzPGF1L4f3jq/nuNimHViIqY5std/mup8mhMIsgdCx8jHeviJT8KlIl8t2lkWuodlpYmjXUy3DpbqgkW1juHU064DXxRGWcwdYgx66THD6feK5GuXp4G2zorPkpedFORnjjieU86kPumlUWN7+HOWxw8o0TGqGEr0HIrrjn5I4Id+8SqwyxLrPjJf6zkOjBUIhiJFcM6soBBqKvzl+FgB3pUxwTCMy6rdF7sftMaeCFsOMQdadY9bwsFX6bMvWPqE7Tzg5j0CwaK+gFW26uo4EtEShxT5X4jaWb/C2+CEUkqz+PD2jRqGWo51Lg944NigUOqAUxsTjBZmhMBjQsly84jMo/23MWalvmRseobx1iHFWYK4JiOHky/+VRNO4+o1fheW4qLmIwnhEYnj40znD4E0Nw2SXSVJjHHf41vn/g0vnrlOaSeOQcbOHkoqrv/EZ+jmTca6O8FN7E8OAQU7DvBETG4IvHs9y7fstrq+cpmzYmAfXqbfPYUdZtivX6NaOc7h7AdMdMFy6B3XzKk9nswhxhJmejauDa30GJ17hmLI42k8hxN1ckReu3wJlgpawc/J1NKPHzf276V3eYKFusKdLMn2BXWjSJbXNG8lR3MybpH8xYeZtGAs+wSRANFIb+Eo7LTqOnSyDrTFytkqrMJ0nLJTZS1rM9qd+KIyRE5dJrY4ZR5TGI1S9RHV/G2U5rCUVvsU5j5spU+iT6q7GBs5GCj/WiiUEirGeFhK+2Gxyz8nnKBZbvDZzP+dOHOLNgfO1UZ6iNSRzkMX2FcoUzPzbb8U8nme04fOp9QIoRXmkUJFGXFMoAe95+TkW595GgiC20s78xHDIJBqohPPHTrNjjEmSgCx5bhy+B6VpXP2n38vu8jE0pdBnptDnXIexrGHKhOb1LnvDPUpxASElhQpcR8d+ocUTl/e5UK9yaeVYum+GUNSOoJCsG7CoKbTMItahb2LiSL5q0GMvCAmSAEMmHLm2mSJl8ovMojFxOnzbrY+iUPxeUTK53OeDLw8p9DYZ5/MIAcsrKTFVPXOe0fR5apkqGVEgyjZ576kXUAomkzIqEcTZf8BdK+/hlr1DRs9xaVABIVgYjakYKSri4Fqfv0rry4nhX+ZSEPWzWFH6GvZ2N5DDz6BbHqDxiPw0V/wGtq6BGOKrIq7KEQ1G+H7qXE+P15F6l6jSYzJ4KwBeK+Frk9/G0Id0Vz+Jpgw09wKj6exWUEoP9XhBUZl4eP0t5seKtqxgjtINX5nMUjF1mrGOik0ubT7DP//cv+JGuQ6YhNltnEjiJwVuJjUaYeokpQRLKIrxiGgRcg0ThaBrVrHjiG8Vv8VpbYIx/Fm+W/w8QTY9CH79NZ1WYmHxKtcr6dzKnmlw95G0unVrJ4tzXeIoeD7/GvvFNSI9HQZWRon2JD2QCkHa5Qwqbqojp5W4rm5yuXyV51afQ0Yp+clMrsZgoJhB4BgO0eiApdEVNE2RuHO4BLcTw0pgcbM3i9N5G4NDX2ArSFAIml6VGI1dujjPpA6gNzuDiGOcKEOie6BACMVmr0LdTQPNWjsVjV60ptWpgY5T6JObvQTdRe5Zu8FrhfuJ0bi2JzkqO0gTNscWYdAgFpKBFAinTE3rszeZJSnHRLrO3VeuMxYZ8o0ykVVF4JLfz3J9wUIPQwhN8rkWlhEBimEuZsab4bKzy+uZBtXNbXbzdQQKPasR3l/HN1zMQZ5YC5npmwzzaZCb04Ykms7BlSbY6c/80RyvBaltuj2f7GELXYSMrk91hfo6nxfv52nxHu7hDbLNNJHyZ+vsBwInkOTFncCrcf5TLD372zjdbYoGRAruK/jEhfR3St6YI2qBXSvm8lQrL7Y38UVEQZOoYZUnjn0De/4OY69IIRoSWxn6/SIzWsCpm5dpVVfoldLPJr2Qsh5QHA4JGlUyrQN2ZuYoDobIIOaSXKG3ryjqgreol29f5328Qi/OYQ/ThFCstwnNAkpoZM0iLVOwY+fJKIdJtYOfC+jX0gROVjP8l48OQAgaWswoMTlws7zNOMub9UtpOexPiSWcZITSbbDSPTcZJzizVbz9LtpAIUURJX1GGRCaTt1axI4NfH0bhMDwCoyrVTQUlXOvITIVsEYU5DmE0LDzdZYO0rmksVnknr0h19svcXNxfPt+24uLzA/P419uck/cZZgpsBYUmcy7yMgGE3AhrmnUexcQOnQuGExyC4SBQxj3+BDPkY07hNLk2/kMteEGZgXc3Rbnf+zXiEYeX3foIpklm0azxc3sYfbG+XQuMw+T1nRGcd8hRwezYaHqJYy8QM+B35S0Rn3MrsEwYxEXyxDFFPMT4mlXyrZdNF0n3DkgqDRQQvDFW1X2Ipu8mSbCt9Qcu9s5DE2R/cQfEsWSl8c5Hn/jLJrKs5s7T6Nr0xjn0YwJT5c8wn6MfzOFkQoB3ngKt69NO0BJk1tJFQ/BW89oiDAms97ECXxufGKWd736Rb7qxvPEeZtT3XUAPvWcQhQ71Dv/N33bQ04E3/Dsg+iJwPPTSv1MfkCrCUhBpgCX9G3CIKTxlmWEEGTKOa7kt+jn+zB0iWcX0JDohz+L0EL2xnNoAnaSGM2LOJyddgx7u/jZMqePWpiRQXbaaauN9smo1C5UVqcdavjbOeziFnu1WeazkippcjPKaEycWR6/JDnSKTE5dj9H7A5DlfoLhaDWO2ArTgsIQmgIq4ZdVUQDk1Kuw/cMhvzjTosZ0caZe1OyooRKJJY/YTXXxZ7MoMUtLoazHM+1MaM+i8kQIRV+rUpj+u5VZYQj72hkWq1NLFMgBHR9jbnkMgtJyGF0JIpdTyIA408xk3bWO9TYQ08cfD2g6qdJQcOdZd9Ik6uBvYeGIsCik3kHANWDP6B061X81RxZlT7j0cGI5cmQS6tH0ZTOvDUtcuZrlMQBwWgWP7tBEg5YyB7D0WNauoZCsa5vExkJg6rBvXaPh8b3MDGuMhITxq6iVNTo59IuWJKYaJpCCMVdkx0+29bxrSyBHrB57GnA5j1GFi87pJ3bZuncQ0S6gdoXFP9QJ9ft8vJbHsE8Mke1uoO+4JKfjEkM7zYzaXsqVbGgOoQqh0rSuCLYfIXcbJpcDZtddj/9Iv03bhLXZ0h0AxVONfMiDakJ+rdCNCnoH9IpnBrR+4YqWmGOYNzk3gu/xHwvYXP+PEnhFCuZFB47XLyH3Y2rbJgGVVXnvkfSF7Zuf55AxITJB3jUTfdjrzHD5a30XF7RdwnMDkbpZTw5z8d+6WXMXou2LSnEAoRkTZ/HVh5r2Tn8qIIvNIySBHsJ30z//mU/RWocI51DGzkZhnsjZKNMq5hFN0wKyw18bZvFfjqKkQsC9H6PnnAoD3sI4OwvP0kl9CAK6cY2tibRMxkKgYfWDelSIzNNDI2ZHDU9QTElycvcIF/f4J4zn2O2nnD5rrt4+dxVglqJtWiWldwe+R/5ZeyRAAERPSYrBQplnSfXPkRtYKPFAm2YEB6TxKsF3vvys5hqASsSeLPTOW8Rk4mmc5WVFTZn6/jjHSpWgxc2LRQwKORo5lK/59TSjnAtN2SUSYvT4Xqb3X6LLHkc30MW+mxMSckKozaHJhG/9PV/EyuJ8bwiNXmCjrGJq2nMaRFaZh69dDdu7RBfORojgIue4LHBAVHGwIg9glL6nHJRSOtwnX/77H/kG9ZfoudF/HzPQ4gN1mdSv1Ot7IJIsKXPyVoaK6tTKwhhMHxsj6I9pO816HaXEBpc+tknqXdMNp30meS9tNiWG+vU9B3G0sE6doy/SuvLieFf4tJMgZEvkAnSAG/v1hrxXkqaYSYGukp4vr1AVmRxRA9TuFjO3bjrZwmmHZ+innayvOpZJuupA5ShxjNRyihn+jWUSHh0c4WJ7iJFQjx1oMoCWYXkxlnmfUlPZjGnjlnMLDGvZThQIfsqxnd3eXTlUU5Z70s/62wigCEFbiR17lUdFAqkwBIC21ckdcVrHR10gWdleGL3BQqMaRgSO7Z5o/UGfzfz0wBs9wTf/PYc/091hT0nIRflSJRJxbpGWSZctnPUPpwgk5BPLjxJxV0lzlXIyrSC3506klx/C9ep4/YFqITYs7lS6iGICLRtwikl80K+QncoOYSGg8Y4iSlv9dGDhMX1W4QiQFdwnvSAe+vofpZe+w5MeYSNy1PxbDT8QoYdo4dxdhNl6HSlnjJbijyJ4SOUQqHRys2Q29zDDEMy3mUsUSQvh8gQ9guznOAcZraH7C1jRREnLv1bzuVOsDYu0HA7aFlJVy8xF5SpBBX2I4EyEnyjS8+tkS9OuLUwT32tQ1OrUC1oxE4FGKAih6uLJscX0iQ8lxtgZUBYIT/0RzHf8XQBBfx2qUS+3WE3V6dsJRhCsSEzIBRHOs9wcv0PWBxUCU1FaGh0himc64+f/9xtm+6OZnnBs0Cl0iLe0nEWzEuMrqYH8Ss9jXwsucppsrjc5aVV1Y9+aJVuUacykfSnQuVa5GMPDhBKsvSl3yKVShPMiD3ydhrklCd9Zp1DDMoJYkrCYgZtMqUMpu3TyijmkuM8sfLd1JIAXUl0XUMpg7nLF3CikM2lR1hbXMaMXSb9mGIyodrrEZ5cRkx8dioz6EpheJKLchl/RxJrivdqr9JXOXZllbeq1/D8ItaoDUrCVhvPqZFoYFlltnrnENvpver5EC22GczMYvshv5MkVKazj4djGycY0/KylDSP1almW+JkaU91Mff66WGlIVE6JN0Qo1El8QKi9oTQKqNFTXxTxzEK5I0yujBoZVNYS2mSp21mmHMUuXPXEZkqbtTnlfU00SodhPizCiElS809zHOfQZkGt+Zdpgox7B8NCXWDCx/7JPdn0sD/84W7EAv7hJ10flibQFhTWNv7FE/r9M4ldDIneDj3e/yg+7/xGC8ySNLDeCUe8ff5dR7q/ATs/hoqkTyx2mQ267LmLOIrk5u5IwDcHFepm0O8gYeQOuG+Tq15juTBE7ftMNPQmOxJmsMuh5s6IIgLVcxoRDk/wJtkMEOJZbtk9BhfmZTsmLBQxd2e0A0ccnZMHGlczq1g7pk0vTyn3df44st9hpi89+VnOZhs08uPmO83mOunnWs/d4v/vvQeVJzCSAGi4SQlFnpT567Q4XIyS1XGHAsnLP7730WTisL+GHNF8JMP/00AhnaB2X6XEmMifY9y/0fRox1WIsnqmqA40ZjvlgmSFPI0Wx7RmSLlHTPidWOd4lyZ3EI6u6TlYWwNuHVsi36mQqaQ4Sutq8zOPs+la19HqAQPHU7tLLs+wJ5GCPn+DpPSAqcP68z6Pmbs4zkO+ckWKgwpOmMwNDqeINivoZfWGOSyZHe2WHnm0wCMsopBdon3n4VlbQah6SzM5wiUiafZCKHIBD5BUGY4HfAWdg27KJBBlqqxwd1SkFOKkabIlCd4uxKrVk6fe7tPxWljj/PcTBq4icmx8ghLG3JfJrXtSaVCIxEkeVhM9qZ+PF25zjqQalSOPYVYrHDSfZ2jSqOFSuUR+LNzhs3LuwRGD1vajPQAJ0znIov+LANdw5KQtdpTmVVBSx6d3leLk7//LwlO9zHIIJCMO2PmegO2Z+8CFOVsOnt2s7GKqXwcGeA2SsT755jNHmE+6NOd6u91zfT+RlbIkaDOcrBATTzH0/YcMpZUnYDJlBzozflf3YiYae/RCDr83vu/nkjzkLUdlHaFirqfXH6fG2eexfEL3L/7PmJNkP+CzuhhjebRVYSWchzEdYUZxmiie5uZ9GAqVTE7TbyFlSYs1cIFcqN0zzfXe2z8/uepPniSTC/9/ThJ72esZyCSDLIVqkOTZsPi2d1HOVrYQiC4UUqfY2MUs168iDOeoZHzmCiH7Wt9zjvpPrvHlKzWA4RSnLV0ns64uPIdHHZT6KU72yHwZhAkfDNfQhgTNGcX02nxfOFh3vh3v0tQSq/N763yun2CdxvP4xY8gt4KbkbHTOt7HHS7OCWH5yepn11kG1P6jO0so9aIuFKgk89gS4FZK6E52yx1INA1nChBi2OGmTy1fpfY0BmXZjAMkyiKKOrphtBtg2I8Qt8Y07dPYUx1lo2axUw0Ro/Twrhj7+K2D6NpkvNywgOvnWU3DPjs29/JVjjP4WybL87eg8qmPrXTuoLUNN71hIEXF9D3P4BCoY0V8ZwivN9hsX2A97nXWGhlaJpboBSx8shNugTZEh96wWB39mHi/iZla5aNjg75PDtv7GD5UwhzYYJSgpwdsL+Yxqv1SY+tAxBkyUQuUaZLazp/v6Hgh69GbM3OcW1mCc8rkB8vseGk/q5hhGiZNOkLj3yQupSc9mPOujqPTXYZH57HCbrIXArRnev1uXDqQfbLGb7n9d/jB/b6HM7o5Lc32KynKBonM8I3RxSiAifqZRQSltLPi9dH6JqieXCYKMwghMI+VOLmf/gDPNI9eCQQCCURE4cZrUU7LpCbysX9VVlfTgz/kpfTqJD1U2fY270KSVp9LXdGbC1Vcd1ZNGHwQw+s8Cvvz/Mb73+Y/2D/bX4l9108ffw+/tOjP8ofJd/EHxRDnjVmuXz0DIFlM7t3E6kE5e13Ix2dR5sWOX+IIQTCuQMJcxcF+uYN5nyFRBCFU7rrxWUcQuYmK+Qm85wyK3z7w99OtfogComYahhuU2CkHN5hXCFUCiU1hBCYURYyih7DFLIiJI+4rxJK0LSE0/3TrLkj1vU0IP7+ixs82BvzUw/9Lf4kUbx7992c6Z6hP2pyOh5xUdfxj8FHa59jaPdYGn4raILTSQrNCXMBoRdi724zzi8R9FJSBr8HG7k7Zj4SYArFnF2g7yuOTbdAx9AxBoL9rfvJypso5eMrSQfJQFe8e/QWdGXhHP6H7E7mEaSHxUBP6DAk3thGrs7T306jsmFxmUT3mSGtlEqhce2rnmCm1cI192C8hAo7iKFgY24JZ1rpG22ljvruDZdnjAYJOvrYIyg79M0yb5cT7u/cz3ZgI4Mm+1oPwjq6JhksCPReQmtSpvbHMUlYRqeHRsSNeYuFXJqcZbN9ZALFYcxbrilOrDXJiRM8ZUeY7pjdwgwLToQVBLSmprK4MWB+71WWBun1BZbiqJMeSlEwPRmlxr85WcU/LhFhkYoVMmycYNF6A+9Awx0ozg00auOETif9zBHtOolh8LxVY2vGoDxOWP/tEHdH4nR3ECjc2jL1y08RTYWPk2CTXJA66tp4gKNnOepu87OXz4MuMbyQpfuWMAKXAyMh0tvMaUV+Tq9hZebIBP30sy+/SqTrbBx7iLXFZSq9DUYTSaO9hxHHmKtpotEppQlnNoi4lhwiv5PQEiMe0y7zkjzOc+puHhDXEKGFlkSY7gBtr4WfqbFXK+DbFlsHn6S49ScAlHCouFX6+RL54YB+LPnK+iY6MfNynnl3l+YUEfBO/SUA4kKZvp8Gdnul1GbfefYllK0jBhFBpTr1IV28TA3b20MKQVEvkzNKJCpiz0lt04lLbPsaSxlF5UoTka3SEnBdTGVl9BLmrM1ct8Vsr41+cJmDe48hNcXKgUrZWoPznD21j7u/w6ev/i7ZyS0+PP92NCvAbabEGSoBWZJo+x3qZyLuiT7KfOdFHi38DtflMa77/45gSrP/YvJDvBKc4ETyEt915Hn+2hOC09Yt9tUM+2aNoZHlwJohMG2uj+ocUrvEicIMK6AE9Z2zxA/cSQythmCwLVHahKWeQWBmkLZDoo3I5XoYYw07lFj2hJwIGRt51N4ecXUGQ8aM3Tlq1piRnyeun6QyibnQazCv9RmNezhxyAOX32BT+wwAS94HqPVjEr2Ck7vFkysPQjbGPjQtWO1vYTsTBuvp/rlVmCP24QcvPck9/+DHqPxJOkc+/mCZS+85wzOL9zE2HOJE51bWQGQ2QQnCzH38/e4CpgVEWZSacHi0QKgPGKss1dyQ7kQhLMVBa5uImJlHlm8/Fz0HrjkkbxS5Zh3i1kCnJiZce+PdPNd+CwBvr2rIGQe5ExBOYZO5/i6TygJLDcH8pM3Vkyf54w98NY63xzAoMJfrIpB426ASA29KbpK5eIXCMLU7rzJhYMxzqCWpybRAVz6V2spBbpYjf/urgRSe+upUQ02z6yhZBjQa8SWWpmyPVy2TvLmLDEGbsmIHrSbDxOSPDk7wz6PvSv3LfIi0+zwaph2LUSXtGEY1waqfnmGjvI5EUJ5Kg2RsQZxAOD/DobXPcgSdWyphIkEKdXvO8LWrPsGli9wyMwgEoZCIpABIMn4aCJZjg9IUjgbQdX0UGutf+Q/QZIKe22Co5cgpD7/jUdhvo6wjOEaEZaVyUL8ynRsv6ftMKrMkO+ewhMk9rsZQT5/TyJ5qYhJywk2RNBXtSzw/ndOc0QdEliDb1nj7xT2sUGKaPmOR54fHz3BraQXdidAE9JKnSJjnbdpV5k+XuFF7jft33gNalbCoGH+bz8KxIpPOhHwxIJmS1GWj5u2O4ZsahmWV/mvm0+7nSmmT7Rd8Cnhcvu5jlnKsfNtX4ozSztlEdyhHaRIkxhH9SpX6wKKlDvjvax9g3E3tZZCk/rEwDvHxiJ1bLGSHbI/ybPz+F3i1aFCVNstWgK3BnErYsRS/gQaY1JJHAEnXOYf0F1jUeywlU2F1ZWLPfJa+XuC8fgSvn9qF311lmxVOlfMcyb2A31vBLeo4uYCBFhN0e/hlH1dLi5YVuuRVm4mVZ9IfM9jvIjWNQpAwyCo0Y0x1ENKsFDASiRQCr1pjpteFuRqqNI+II9T8odtyJ8rJ4sgApzlk2z0BSfqsrIIkP9lGyLQj14mhff07kYnNvcdGHN13eejcLXbMMokyEL7DTz7yt3lepnuu203fz5Fai0zli9xUj/GpB9/GpbtOc6H4CIMzgsgwWPzSK5zUqkxUxOx4glCSYmsLb2YFhEBai0y8fQzN4DBgqQiZSMrdGklGkc24dDtpYWB4JC18NNwek2GD2LDJMCEyQkZRGnisRxne3kp48NY6XzxxH72ght2eZS2f7o26A06SQXQG6L+QEry83Qw4iDXK4SW8QKEFLWy7gFKK85U8B41DrM01SITGma2n+EePRtT9Ib1SBV/p/OL199I2xjTCDBk6JNkQM3M/AIlItYUn7QaV+dSHZR44gtOoYu2O6elDjoUJdXVAEGWYocNuUuFPzt2Juf8qrC8nhn+ZywuYGe2iTwFj4bgPRurwihO4XhIUzDqXShpPNark6SMQ9Flgx5xnvT7PJ906HzG+lV/KfxufeOSr+cRXfAtfePyrsW9tsyMOoXBIsmBL+Jp9ixJZRG6CnsbYjFd1Mt0WC1OxZTmd19IPr4LhcbJ3F8ujU+gqrYboYY3E2ceZQjEuaAUEMSfk6+iJc1vEPFFF7ERSPglCgtYLMZ0hP7Hv8LmR4PDoMDWzxMcnIUKFOO2YXzz/JP/XL/0MtjfAljZ1v047GHFCHLCF5Fqpx0dqn+ZY5wH62bQr8QObv89j/XNUZ1p421303RaTygKxlyYe4/YEV0+hIoY0aKGR1aBA2iVbmG6B/bqOFII97Sj78xVEktIiV4ELZsJhf4Fmpoecr9HkceZyB9QyQ1qhjgKauodaOsRoK00Eo0wVqfusaHcIfG4srWCO9plYHplWGfa3sDqwObtA0W4Rjmu0u7NEus5S2+ZLUR2UYnbY5o+PvAs/V8MWkmpQZWdUTsWG9YBGkFa6wkbqfPy9DD/e/Vl+1upgahMOWZepZiKqzU2QEtPz8cc6pXHEtSWb4nAIxjvxNcmXGrCXrzMvR8y0WoTm9IAfgeV5ZAKTgqvjmyE5L6bh90lEGgQlfo0bi3M0VxZxgxIle8TFXoUFJ3XYr14HXwoMT/G2z34O37OZze/gzs3wvx1PiIDdqkFkwbWf99FvpnDG9ff/ILGV5W3XPw7AaLRN+yB9/41JOlu1GP0n3hH8c75t9RyrYYfFuxfIahG9sSKJxvyYeZMiGp/9wPfy/BNfjyECVi9f5cLRk/iVEjeXljm8t4NSMLO7g8wpquNFNENjUpxCQ4KIA3OOmV5CYryCKRJ+Nf5qPibfiikSavqQWAqs3j5mt0tglVg7dJhn3c+jScgEkl0OmI/rJJpiaJuUBwN+6P4IEQTM0EEmhzjubtBkBolgObwBUiGdHG6gkUk8vNocWc/lva88B3baoT7fT6+x3Z2gNJPSaBsQ5I0yjpcGC6eSU6AUgcqz6wsOWTELewJNM2kJmKDwhYfIN6hGLZQOuzOznBob3Fiw0BTct/123nX9G3igcBev8824+QwPXC6QH51jyz7BIK7xe3LEJIFeXkA+prrY4j0vfDdvLf4mLXWU32v/NK/E30aY3IHXlPzDvLS+wq/svo/r/jtYuf5JMiIio0d0vSJS00EI9vJLbEwqVEUPZVjYQQ3diCmO1knuT+fjlFK81oqwEkFpkkfrGeznlkAI4tkRup5QHyU4gSRjT8iLkIlTQkwmSCdH3y5hhwYlZ0JsHOHrVt6FUVzkZr9AqARPeJ9ntbXHi3cdZb8ywJQmDfcEeQ8i+xR67hY90+BGdYIQIIOIXDzCslxal74DMRKUzmv8+md+nMduPE/32BkGb7+H0DEoz4x4OrwHKTQu1lYRkx7/+G+aqOwWMphlWPgBPuSfQ1kQRwVQLqvGNFiWFnlzyCCGZMZlq73LMTWPNXtH207LCTxzRJYC+57NXrbAK0YdFWUJ4g4CRcG3iVfzyAReuRxjhC6O22NcXiTpSYruAa3GDLFlgQhoBxXmci2qqoO2mfqgYXqMUGhuUphMu1kllzhYINF1aq/vs/7hgH6U+q5uZgannu7pWneDl3tTAhqrTjROk5vZ6AJZkRZR27pOmbQzs3vg8Grpfv79c7P8o6f/b35j+BBdivwgHplsBmn4HOtPWVydChUp8GZ0Vr0dEiHYnkIsZzrXAchnpqyX1TpOp82cEFxDEqNwdUh2JD/14SG/+Xt7rLLNup7uPV2mSeuceRU9KZIJc0hpU5ryW5uaRlNTRNkS3vRenfEOXSdLiSHRwENvjyhFh5jVDYTYY6TbHH/gm9I9ou8yycyTtK4QkrAQziOncjSBPUdQ/yEQNpXwUQbGGpposyXSDuZMvI8wYk6sjyhNYg5tezj2iASd47NHecsbr1A00i7bfvc1lJowFy7xQHaG51eeRJewduTrefXxHMqBw/4VRq0RTtYlnjJX/mnJilY/wSTGnIrWVyobhCp9Tpulc2STmL7McuL7vh635yIogUyZplfj9B0bg5BeLkdtYJMQYBND7xRdY8DYSG066/lYmoVfeZ6GMWLHLeINO5zNWDTEHBWrTeDarBKzZSvWA0WgXyavnSLWAm4Nz5N4i9xnbbMYp4gaTeiQO8+pFZ1XZh7D8tpE9gi3c4QWDY7XG9x78BJeZxE3p2MaMVp1D00mnIvOURVHyCoXm5CG7DNyMnjjMb0La2hSUZkEbCY9cp7CChOiuSoTp5hCOr2QRq9Dr15h3O1j9lr0Kw3q0zlUaTkoTaOQjLh0fRY1OUAhsNwBcrh2u8lgT0zCTJnYb3B6rou+sMqRtYuUpuQw2tDkpH7AxmSJne2T7Fwq8sHzzzL8wyt8o5unKDx+ZfmDvHbmfraiE9waz7N9+Axnrl/nkfsfRKBYnrJI51tDgtIcGhEmFba1FD32VuM60STtFEpT4R5NC5vNvaNIqWHNrhM7OZbjLnKyhG85ZDSXXrIIfupHelGOEYq/9/QLeJbDS0v3IQ80djJtSklCXkge/vC/YeEf/O+I564yweB9wQQNxQ3tMr6rGKghDaEz0Tx+6l0PkI1jrh8/w165yFzzZbQXUsivzBtoVsAVmnimixbnOf/styArGYy+QEUe8XwX38/QCwp0W+XU7+7ucuwHvom5fo51e5djYUgx6JOLO9hEXJcLNMpfFrj/8vqfXbrGwpe+BECiKWJfoMXTeYNiBo9DHC0/zFMNA10q/uu5X+S7nuryHU/v8PeufpjvP/87/O59Iz516Q/5+eA7+L7f+mmq3QOuHLuXUUdwg+OM8oKJCWfLOl+3P8tSVEMr+qgtjUmsoZYFulQsbaSzfJpvEwuB00gTq0/kVtiWKwgzIAnG6G2BV9yhMJzOjIkKtuaT0SfkoixTJCqSIo6fkDP76f15ig29TT/R2I01NOAd+SdoJhqJ2ceTithu8razr1Dz0oO0GBXZ1jOcLqSQn1/beQ4FPLL+IXZmDOpBi6/Y3OS7dz5CpujhvbaGUIpoqXY7wfW8GCXT6vWCd4KukuR1hTlJN2oNRaQU8VyL/nwOpen0y0VEYhFIQQ3BqyrGUAYXczdBCHb6GRbLEw5XdtnxGmg6NKt5ZO4Qfn+CNCx03QShmKWFpoOmazQTnb6VZuQPNWMMI8LoC8JZnePVGwz2ThKqDHFtjuM7LlfjQyxFB9hhRFJ0iPOZ26YTDeYQSErFAx4apl0Id8HBzMcY+zHX7U2uThnojtgXOSr7lPb30AOf4n+ykZrGs/ckvHR3DU0pltoOhaDIR48X6Js5FtwOtd4AoUkycYbiVGbTCnrM9nSGuQDV6bMkh2zHZZSCdZl28ULL4Xx8BGENWX8lJLcoMHWfV7saJgqZBFT7Hbwdm/xMj3ajzqm8AgSDrMbvvrdIZAu8z62jEIzmT3Hh/m/iAwdfSO9TzdEepslobTIgVD4mmwTyJFkj4UPZa9z/kX/Ce8s3SBT0Y4NnpM0vTz7PKzWTTn2Bk/4ey60DXjl9hn7RwLcd7tvcJycCau0Oxb8+pFD7ScqNEqaucG2HTBTjO2Uaoc6M/iVaqshL6m6eT+6ir3IslPYYRA7m+jpCSqRm0J5dpDtYpz3Vt7qkLrIaLPBUro/QBcXhkIfKHbq+TUN1+FTrOSrhAcNcgx4l9CRADyPQNKLYJC9HSKPO8v4utckAZWlYKuELV0zQBKPp3ql01wBF1ihi7aZ7+65kDiEDWsUciRIc6jSxrLTbMhYBCIhtF6/eYGyZ7Jcb7NVnKXZbjN0moNMIv5qj3cfxhz1q0Sn2qx/EdBVf//wtEBovDT/Au1qCsauxPPB466Uucw8N8HMzfKb8k3ys83/Sio/xsKpzoO5ot3pSkGncxf7sA3x++L/zyszfS/csTf5J9zf5bv2/YxOybS2RKI1umEUaFlZQoaq2oJpHLqfwsN9/yuOVZvocju/UQQl6xTkSJajXU19SHwfYQYJjTcgRMq7MoychCEGnVKMcj7ByMbq+ii40nPu/HYOEi36Nr2t/iYdvvEIoffbrgqXgCIYSFCKb2DpJog9paF2+6AuSBIYvvIgUFlGSobzdo/EvLd59+TwXF47yya/6Wq489nfIbu3TWagyF3V53j2KsJpcO75LfRDw7nOSH+ucAwSZ/RHb974TgCBK4aFMQhrtLMM4JqcPUEDf3EAguMde/TNHjnRCQsMnKwsk4ZCRXcA0YkrNR9kXDgURsNG8jiwZlBA89WpItpd2EyblBbyrAzJuE8fzed+f/AmtQpmJtJh1tpjhgOx2jFXYo2Wn8K7ysIsd+uhxTC8fgTuDN3ua+c4uo7Njrr0kMFTM2Miz+5tjlC6YaV/htb5GJFMoaThcABIqxg7atEOiJRmePMjxa0Wf/+sZl+eqj6Nixdcd+wTf7zzJF6wf5lsp4bZTmyi2m8hKgUlHRyCY1DVWvV0GZoYrsoyGYmm4jopGlPJpWNQq1tByDXQEt0RCP6/oBhJ/Q3JlI+b9q2MW2WNLe5NEKvXPS87rAJwYzeFiUogz6JbLbFKmqVlE+QrXtRrfffePoXX3CMtzlMQIGYfsNFYwlMmsYWLIDkllmfvv/RBSaJSsLTx9DmTELdGhmJy8jYMNco8zzD5ISXuMenQEW3+Wm1oNOy6ROAp7fIvZyYia6xHpNkt7PqVMB4Sg9cYa3/mxX6M8lcXqeiW2Ip9QPsw7L1wisIYMtc/QajzIRu59IMHZfgV/4GGZo9sdw8yoi9+RqETRGkgWtQ4TlZ4JleIOlhihFBxa/GPssIdyipROLiOfvUi7PENmkKKHDmk+2TjA6Qb0S3mOrqQkcwVu0PBnObCbKM0kNnLYwYgz1fup514DYNOt0JufEAmBZZ1gxt5j2C6zEAg2DQNLurTslzGETc2G4QRQNo+oS1jeg6BAkc5ffujtklEg6M6dRpR28DqHKYZ9kmeu470uiQ5MJlMCmoUpM/GmsclscpgyaSFiVvYYZWziOKR77jrFWFKMArbdbWY70+LHkUW61dROZzr7zHVaXJtfAgXasEvbz5LRE+qtVspibWep5kfsbguGXhdl2GitHr6/g5rO5ysBbqlNOGqkkgqHD6OFLkMni6WFWJHL4+YG+ZtXWFt7C8lBFjuOiPI9rlYu8AM7f4SrLLrXAvJ6k73mESaH76U0mXBYm+WEbrI4TgsJufGExvxlPvjgd3BP9RnOOhrPG2toRp+jb0shv37Fwz2SJoZRr8hkUqGRHeE6FRaCFtVRFaVpWI7LgVxAuDGGSvf6DeFzZBzwxNkXubBwhOtRyK455HAU4QQSgSK/GHDz57+PNxydimtx3Ja8pO/hjSVtLWEWjc2sQ208YdZLeOP4fWzUchhJQP5LzyOFwLYT8oUtjMIVElVECY23f+qPiHMSEenE/gHeXYLBYJ4Dx2W0NtWItDw2zu3Q6Bis23sc9kxUX1HXNlPYtngfK9odttO/CuvLieFf5rJMzIdS+FNiJQhfR6q0c3dQSci5H6CeOcRTDYOHugmZ6B6WrQ5ivIjrl3DsMaqzTaF3Cr2bUJwMcEKPyLQ4X7mflrtAOyvooPH7yyZLQY7jySyikBANBTsxiIWESNco7KRMTIavCCwNZxAyoMQvLL2HD9cfAGBy9RJGF4L8DsVRTIjBQTJHUUwJCuICwRQ6IlURJ5AcDa/fvt1zIu3u9BJBJjtiOV5l1TFoZ4Z4CEYyotuwKQSF25/ZU3PcXe0glOJ8HPKNnfeRi6q0qyZ3jS5haZK7xmtMjCLaldcBiI8aKDWF2Pg1EjFAUzZ+7p1MZDr7FmynM5olYJgospUdWstpoBU4DrrS8JWihsaLU2hLR3Xxw5j9rmSxErJaWKPl1bHzHs3ZWUbUEUlMVKqm85ZASYywszHC0tGimO2yiyENTk8SnEyC3ofjMxcwtYTm9fsRWo7ckUVWmj08/xCPRGk161vkLcp6jJ9oeFpE0aujlGC20acelBiEBagK8vM+pZ0e/6C7y8+0007dyeyT/MoXvpN/6PwOP2T+Jg8+ts33HXuRf1W9yj8tn6d214j7blwn27mXzUJaYZ7v7VMcpxXUul8nmxPEZUXObXJkL6ZbCBFRxILpsZPUkUpwMXuc+zsvoScxF7QTxFYfu5nBXTzOonWBC7rBSZGwsp9WLSf7GbRizM5ikT0/dZzvXvNYs3T+4GuKFPUdLrrv5+Bljd9e+SZMmV7PwJ9lIlMbKXp93OQGmghwk6/gvyXfymeaR9EmPX5o/PP8kfUvWc++gJ8UaVctEk3QcjT++kF6DReO3sP+lInwvsvXqKoJ1W6bCj6V8QG1bJGqO2BnZhY7gbKVMCPgJG/wVHI/clonfUrex6q5Rj90MNfT70bFWJ2LBGbC9qHUHrfkFoeCOdSU1a04HKKtbzOWGUI3pjdpIoCD7Cx7pEGV6aVw7InIYGkDJpk6y81drpw5Ri7xSBAYOx0oFAmkhpaE5Nw0AcoZJT77QNoxzyYatu7RLk31Ii+9gZZJE8OJSA+5SEzIVVY5v3ia6WAU2zNzvOP5Kxzqn0YTBQxl47Z9/trGb5Npv0ZuvkGh2aEU9zjLw7z9Wof7biU8cnNMYGmsvVbl2tG/S/zIGZJIo6q7VNU8V6ewBSUnDFVEvraA1CPQFOMDmwM/x2X9FAM5y78wf5uP6z9JW6tjm5L1SRVNn0GTFvWtV0keOAFC8Mz5gD/4oseJM+ns9dKBBQZgO3jKZCnfRkqNmjtBugV0KyKvuzjbA0QYIuKIq/YpMmaEpoEQS7wWj9Crh1nNv4VLnSUKMub+4ceZ5LL080MWBkepGgdkDRODVJLjqLVBJzZ54UKM1n6aIMgieqvMNZ/D122+/70/zMuP3Muw7BDuJZhbHXYXZhlEGXaiEtlDv8aVw+l7+95PK+710+Ss0BmyOZ9Kd3hTiYowijm17jCKPfKiS1VMSPw2x50lrGwK0Qt324yfOotrTplq/Txff+TjtP0q2mSOsWPTEjoLeYUYbfCuGxd5xDPYayvWbqQdv3F5Ef+Gh6baLO7uUOt06WZSnzmXPWBGHlBvQXbmGi3nMNnQpxBPEEDBG9KbduL85SfQk5gHHzlP9Faohl1GeoHT9rMkhSzV3i6+1Lg00hB2jWC4gK210EWM5k4RAm6J3x8+RM4UfFXO4gf1z/Eziy/xoSOf4WSyh6SEpV0lOEgLnKLfRjVqRPupX+5VRhz2ttmUM1wMllI/Fw2Jr/wnasWp3WfqaIW0o3kLyU4gGYcwh8bPfk+R7KjDvLZDe5oYFsLUJ+3Np/8/MarhGwGFqICmxTTiEh2VYZKp88WOwSfq72R/GNKsZikyItEEGwvHUShqusCSA8LaAko3CUuz1LJ7+NEcSlP0Bn+CoeqU4/RvSiPtvj82eRsAK+oZzulzlKIqQ3tC6O9wfHvI2LC5VXs3RqI4EqU21Vzbw466lKaJ4aX6Ca77RUCjcCXhno2YLxz/AirpUB2+jaCbJSl0qXcO0BijbIgLkBuPkQSEfUW7F7PEAUN5AoREMz30WKKSDDPlDt/1tt/ByoFxEJB58SJ79Rkyo2kBN9OiEU3QRiGDvMPcY+9HTwRW9iwL4QyjfHoOSLuIFQ45nj3N3WE/TWSCDNt1l7yUJM5hCuYIP85RbtkptN7eQFmXmSQRd1kmiZ/CGhthnWL4L3ig+w4U6ffXqkMeOWWx5duYlS1kUOKbP/G7bH30aaKBxIq6+NOZyIa4Rd8cUXcO45k2FXroYZ450cY3bZIoImj1ySaQDXw6/iZH99K9o99zmPahtOt/z82rNAY9dopVDM+jXarh7aV+YPXWenrfmRz1zAFSwh/XD5Pk8oi9/5e9/4qyLbvOM8FvrW2P9yd8xPXepkEmkPDeECAB0EusllSUKLVMlQwl1ZCqpTFUVEmtUV0tlUSyJbFICaIoeoAA4UEgAaR3NzOvN3HDR5w43m2/9+qHfQiOeus3DPTAert5b0acs/dac83/n//8Z48g3sc30/wr1BMS6w5+v4HyD0lOpBXqe2qF5cIurQODbwQn+Hp0mqfe8kesv83kK4+/i4cLzzEq3eT9N1/g453v8KW1t7FvlYljE2cuh2PbWF+/zruD01RdF4Hi2PE9msdf5d6JHCvn/5De0WPc1DdYCyosHZtDDwsMswnuUYXn5ciYecajOitWQj9rUp90WZwRmnp+zH7SRLgxS3Hag3jX7COzVf7iF34XLYn59yfzbEmXlSTGTMMBuYWIb3CPB1aRghNwNRvRVhE7bNM2TOYVlA43+cXPfZHCWLA9v4K/ssS4UCd/cJ9WcwGpJDcSB23apDVM50BHpoa89joCDW9uF3Ix406dhY0dtM3UZKg277J7fQ8hDPZtFzvRqeyUqGnbxGqe98krLA5+sKDWD9an/f/DlbzzCkIkoCeUQg1S8ysM4xJH715lMyvZyGu8+zAiVjWOWltINHyvmDZ+d5/GnCzidVMJ6jhbJBNNuX76UY69csiOLegqwTfmdAaaSzYznrnkQSuUJMWQw2IGsf0GVS8k63sElkDsHPA6KSB8I9tMYc71VtpLkdsm74cM4iwqqrAoU1mpGZRw5cy6XJWw/YRakB5uTe+wpRIMFP1YUqZFMHH55MpRhuaQvm0wHdjsrWQo+2UMb4pC0VVLyMEWltFCTo/x8fH7aJd0YkNyoZWOZljz9nCjMpWdO6h8Fm25i54ZoZRGb7KEozvY5DioXyUOUtlQby+tsuXRGccKq3TIOJte6AiBlFO8BGpobCUJiUhY9Jvc3u2hFDT11zlaSDXyY8NhVCrRMkxEHBEVat+z9veUSeRHRLGi4DvcW9KYd0tETQspQQ5gbmkDec+ADkhZIL84JpAGUTDHsTiVouraAnUxxfMT9o2Eplen1ytSqhywkdfYDxbI5B2s+QA9CvnUeIonU0J5qBrsD3Ksi1Xa4wpbWpn1SZVvZTL4wiS/7HN6ewN1eB57nMq2Fne20JwMsYxpug30E0v4JwSF6RYn90PGMxv7Ri4kxKTnVdmRq3yq8Lsc9+5zw75IZA1ZjbKM588gi5t0chrLdwPeen3meHmQPu/havw9YPjUNOSn7zvc9SWytMdL059k53MhT48L/OHRH6UYjTnSbhEoDZQiF3poSdqIHibLaPYyb/YW+eUjf5vvPv43qTHmx/Xf4LPm/8xqZQhKoYRgwZ8wNHNs56rsZjWEUhzb3uTUdJdcdkDGj7GDmAUnouhO2W3Ok/MDKsqnod8gK3y+mjyKmO33P4mvkhUuASZqcyZby/oU+10eHA15dGMZX08YBgN0NJZnQCzrBSS3UyC53bO+B8Z6epktFlEKhDcmQuJgYeYDRrki9V4XtxxhC4ckkfzVW5/nMCkSiTz5yQ6DbCq1ymh5vngutaYfR32WMxk6hTSZWXnhBUYzZ9SYATYe43CEnuS40ThPaWbs9PVHj/AjL3W4sP+W78UtTTag3MQOe0z32whg7d4DbuXrPCcUmYFglNd5+UqJkTKRux1K59P4tmaZHHobBL0RofIYyJCBFnLFO0psWWD6+EODPbfAkWiT3wv+CV91Ps0p4zaRrlNYzPBwUsGM51Ao6usvEl09Rasf82t/POHsms6f/1SWREwpjXw6ep2cDHGVxoLtMZ1WyCU+jpMmhRlryuZcmphNfVjXVqmKNKZFaoFfDzbxDm9xvPYxRs4C25rJ+fI+7eVZ/1bnBA3jPiUzpjDOYod5KKxzQvh8+fmI7GrqMi3dKra3ya3SGtW1PnPeHgKIg5BAL7CzPMc3k6touXtIc8D6AvhayrLfzh0jyelIX6AP0n5kx0vPT6IbrLVqDGNBUQ55TN8m0XQuiDWCbJrsT7/2Cq2vvMHYS/9fw59wsXGLMDEpOWU2ayFxUKZ2PMuNhaOcOVjnuLaPbSZ85XYRhcApzRPsefimS72dEhtaOIsDRZPlkYsVgtVYp2PPURp2OZ7vYcmIsttjYKYgNS6dwKk1MT/7bXqjPtWgT0erUD79dXwjT2XkoouEl/oSadXxh4tkjF3+cfiX0FVEqDSOyW0+sfA/89fP5Ljc1ThWaqIyQwQFzul9lDJomP+IcmfW3+cMELkqSUfhCkVX9jnq7nArWuD16env7Wt77zUeKX8LgHWtgiwuopRij5iOnjCO0++b2XFhPKCZjBiTfq+qX8YUU8bH15AiZMGZI9FdjMTAR1DTi4BgX85zbxgzf7jDv0Dwmf63KTEmkRqT0hl8q48pIzLJhKCW7lGvvEjJOCQYLxA1INNKSb9GVEEpQWinlZl39Zfp6TsYco+XjSr5MEdHtFDRgNI44nr+BJGxSqdqcKqfEjM9N6aXF5Q1Rag0Xj3xCJMEFC388BF+ZuRxUIs4yH0VPcrzcPNdBMcUZ+/fSo3WjDJxIyE/+VNnUkWnF7Ii2ozCY8RmgBBwdyjpPpPu2WblkL/11L9E+/aXKd26z3azQXaQZvlJbkQ56hJ6Cb2sxlZQJjMpUTUtJJJhzpq9rCJWMKJMjUc9n9tYHBhVHtRC3ua4xOlVT5htUjpM/x/b3mY5avHAh6bIcGLwJAJFolIC4Mnh49+L6UNvyE+/L0us4FaU5lf2JAVeTnWJOf0W8b5GLATF6S6HmX1Odz9E15KU6ZPtnqMuU/CtvFk7izSwx1OcZIvj7VRmG9ZOMjieFgiO7TyEjIlCYBxu0WksEgZpsWAk22Qch9jOUHJ7yJLO5489RdhoIA+6RHqLRELe0fCNhLF/i2DSBBUTnrJR0uCBWOaIuUOrXmY7qbATFZkkNbqiQUNMWZ+6XPFjwqnOz939EvNBj68Pr5IpdGlFfZ6+8hb0b7zM2cNLFL0hnxBfoXl6xMNmmad5D71sjpqhYSUF3h1fZPjHDzGCElMrg5gPmUyqFFarjMZ1LKnoHnOpDMc04pR8ytTGbCZlRKKYV0My0uG+9DGzTZYP9nlk6y4vN/O07dMsk2DPXKrMYMju/W/TaTxKLvZ4LC6ioXhQe5WWlWdeCRp796gfDClNNELdQMytslmuocc+7WIDEEy0CYs7T3Hgp/roh0fPwPoDhJB019K+xuKrPm9/fZMkkCSxoFLroBJFUJtnWE3v3ZOjiIbWYhifB+Aw5/KDtH4IDL+fKwi5sxlgWSEakPMlSqUygIXrv4AWaTzfTOUp72iHRKrGnL6BEC4qUdjWlHDyHADeTg5hJExzRU6pW2wtHyd3f8C6qdGVgkgKXs88IMrOjACmOu1AR2oJ7SUbvClvv32HUjglsCTJdItrPApAXxrsskK2PdNJm9uYKsbxJCoqcjo+ZBpXiMMijpbqzseygeXHTGeSznL5eTQUb1WKSSIoBod4owln7JNkc32UKDKaDDiYNykFJardNj4j4qjJn8Q7xPkNlLtKIm22G2mytLq1AYCGYs4JKXSGaJkFbO0WRrZHHGYIhcHY8HA0RT7xkWEqcZpqDk0EBpJRDGb+EI8/q1SG2gRfKdIR0IJhOeSSc5K7O2kAeyPYYa24jUDRFWmA3zPHGDEIo0qspY6knmYQhQYEERIYlyocc0q4jbSiMZmzyWam3OmeQyUTlNAp6m+wXloENEqzIeUPkjlsEaFch3Gk0JXORnsZ3dxno+izJ5Zo5DrcKS1BUZEVit8s5pkIwebBMQ5eafI5PsSz1at8xz3Hl7on+SfNKve0VcxSxFz3gPok4shWWkHSRw/w7ToTs0PTaSCffJzpchkzcFhpKyazMSO1TJpA703nUaMcR/WHPLmao5VZpC1rnDMibminebWZJjjH7wS0jRaeVibprxEHEnNuxIOpwJaKWhHO3g/4u8c9GpMuj+d+m7fZ/4G9EfxK46NUwyGVjksQQyYJkSiyKgWaYbJCQZu5zbW7dK58hPcE/xv/IfkxGgz5X0a/xldf/cs8OrxOmyFbzdNEowl9U7BEhB0GnO9voI7FaLNe2cXpNiV3ym5jnoLjMu+45LSncZXJt5PLGKV0ZMXTyWUSJTANRbidVvE2ix1G2ZCn9HfS6A7pFzW0Wb9fAQuRaAi7glxPwb8ZOJjlmXV/GLLPHNPIRPgeE2UBAstKK926FxDFOtUo/XlhzqDeGoBWJT/ZoTfrixRIojBECkErPuSkmaNd0ihPPOrX1pnUa0TEICapBBEXoQRj7TTn3ZuU/YhnLx5FiRzLwwtY4zQhNZIaxY98nP+y/DOcP/23mDvT49jmbQLLZq++TCmY4igNpQReHfSHXTRLYBgK173Ft/Z/B6mV6Wuwa2QJQkkuyWCLHLrqMoqanCx0SeJLtCiw76cX7CVtD+p5wkTHDqrocQsjmhJeOckv/+EEIQR//ZN5DEMSaLcQwJ3McXIEOALqGYfppIQXV3C8FBRblsPEMNErBV7XV5Ei4WSYAqiuZ6DCPrfXv45A8Gj9Q7wyXeFq5OHWbmLEFo3JEeaMN6iZDmcOQhZHJ9gu3OfPRTH9MMO1TkqwJdGAwnjIg8IS7z/yTWqTmZmS7jLJLdFarPON5AqZxpfT4cma4H4z3c8vVC6hSgaup6PPZmVOnTwCha3HZL0iwziPJhRr9iHd6iI5TyfMKAZjxW/0rvCZlZ+h8+pNAI4Wv8ODwREAmoHkYe4QEAy7I75z8hKBVccvPuRIfswLvTnuZM+Q6CbJWJLoEVaQnvvKZIhQCfPZMzTbaVx261329AylQZej+R4ZLaDs9HH0PEKGuFLSPf0k8vYmzkGPathjKPI8OCIpZXoUHI01echLfUmiqhw4NX7ZXuGVJK2K7TFHkZD1rEu24ZF4UIuPE2QOEZkGi7S/J6k77T2fygOnEzStitaDthYTuyOKscO6lmE7+DNgmFUrnDd/H1P6bLgWsrpC6I+pWn0ONYUzcwn2bo9Z4IB9XUNLTBISqm6Votaibp2mJA2MWTXKMUZ09TGVXHomd+M6uWdf4Of+4FfpOAUeOffRdJahEujiCFZmgiZaSBReOb2vvMoihfiA2C/gzWWpdxzG+n30RCc2Foi1LBcO9rkygMh4hZamsa3l0JRgoPcYjWNcS7LFETSZY2MlS22WjEdWlt35HCVNEXgWWpLeTWH3On58iXfUdDSleGPlHqHeId74EJHIUY/20Togi2eJ64r8dEysuYxbMQNPY1m0ceIyiZ3mBP/RzfBa1yZJJK8cPsad3gm6fJbsaEKvVCMzmo01CSLKqpua4YWKW7sxTnCClSSt7O5GKYDU7DJmMCJujzkWhjyfMxgXXEYmvN3xsK30+1XXLpKbmlhJwrzxkJKn2A4gUiE/Nj3HcmZCqNLWhCv+Crqe/vyBM2SprnGGgK90LxATYPpp/iSlIh8O0Lc1nKykTpdpzmRx/ygdw6buD3ll6ySVWdXLGA8hmyW0c8ggJBN4LPUjfF1j84+qlPV0KHqzd0hnfo7CeIjujpkU55lTQ7Qo4tWjU7LRAGVlqbQH+EcKHGYrvFy4BGMHR6Z3wantAkrCfrBNOEkBTlDocTh/HkdmWOOAg2yN0szJ9isbV+hSpxLsMEkEjx8GxDlFrhPw8/7TDOMc26aBoxJev3gZOXFp3J7w0/6vcFXd4kb3CF+ovZt/L/4GL9iPoRWG1KtjDGGg7grMqIQ0IoySj+tXyR1pMh6lyqTp8RFGFH8PGBqNCdvMxqpInXnjkIeJxLQXkUrx5PYdip7LtPKzLEhF0YnwR2leemnUZ7eWVsyPHRzltJ2wXn+VUa6OKTUSt4fhTDg7Gw/XKs3Ry6cE/l4jfefv3RxRKuq4GCAS9o4tpS5qwKRwn6lTwttXLHdHGAmEroGmekQZg7DSYLKwSkLCSdGnQZdhchEfxUt7t/hBWj8Eht/HNe5P+ZTzrzlXH9BQHoavMU3AGp8js53njn2d78xZnB3GtPR9PBpEDCmbM22zbaOYMp5/AXdfkq16HJtu8lb9u6ASXjh1iVF/l+1MyqoMxAFBZjY3bmpjTFOpmrcKSmq89drLVKMRvikJtQ5vcpkL2bQ36oa6TF4VSESIMmYzbFQKiI4mm7SjNUDH1yeEJExkE9tPGM/kNXH5VS5lYopxGqiSeIA/DSit65woddCUwecbQ/arJtk4y9zhAOF3yAVlfmdFY8nbxEfjQRizXdfJeC6l7p8Nqj4S9tD3wD2boFduoWf6eG4WIw5xdIdEuSTRNn0rTdL8+htcIQ0o4yRCNwd4skC5l8pZPNPDTaA8MwbaW00oJDmiTRAkbKo+Gd1joeyw5zbQRchATokyWWRkkWguBRyCpodSf2ovBJWgyoWOjmmnQdw/o+i7ZUb3dKyZDj1JNK6vngFAuV2EVDww0r+rZtvM7+wRiYjOYAGBYly9S0tfpmBOedY8y2gtTYruGgYHfRvr2fuMS6lsZWdhDn+aY1DQkMImt3yAriU0vQ4X4gOK/SpCG/OdCx5+vYaj7ZNN8kwvXmW8cASA+b7BxE6BYTZIL8q9yTyXpj16wTxPzKydX+cqsdxn84+LfLHyfmqjiIO6xHT3GNpz5IIc01aGZn6XTUcwbyvsmiQcKd4tDpgGixyzXuSY9RLNYUJXVjDigOwkJgwTcjPZcp59YlVCiRJz8Ww24KBLOS+J0Pli/Fb+gfa3+Nun/j5r7h6/dvP/QauYodk4SzT2cDU4FkGoWyyPDpHLf+Yglo0fUpQRe/UmmlI02l1s7UW+nVzEVwZG9XkApjLDlmrS0EdEBwGbzTmMIOLeScHj/eM0e106lTLlqcJTIdkoh0o0vNIcxlYL4oh3NIaEk5RZNEKfAxoMQhsR+IxVynjrVn529hTl+hyLbpp0ffPKkzy130JIi4yzy7BkA4JIBTQGFl7OZBh2MYWkV9Koj8BwEpJClb6YMBIFfGweivS8l/08l7pvsjZyCYqnefbKYwihYw2+g1IRxaBJdTE9fztaj/l3tDje3UGLIvYXjmMVQxqOT8GJOLxaRNvuEAchcvQ1rvW+RjOjodkN2prOQBOoyMQlZCHKUNb2GMbzKAXD5NO0Yo9JkFZEHpMPyYYjTM1EJDWK/VuofIbPdRrc2Y74ix/JUZ9JZWPvDsg897LHyIoQkR1g6THROMc4ruMZfwYMc8JnOH+Eu8kip7Q2TcNDKZ1tZ0AhHLNuWIzvfYnF7Am04U8QA08mD5lz1tCUxoJxhzm7y9FDjapznKE1QPdfZCW7zSs7T6TPdHQDTSV0SjXO1O4w1tL4GWsu0/IiXtbmhayGyOz9aeGY1+fSc3u9cIKqPcUPYTAMIYZprPGu5jp/w/otgoyO76ZVj8iI2JANDFdwI4n5P343oaOVCKTFzXvps1nIHPClh+nooVIi2Fdp1drXASEwlY7hV7g4fYgk4TeSj6CUwnQVWpKej92FBZYHhyxOuuSHj1PcLjLIStq5DIe2RXnUpW5NEbqkOBnhyApGcY9RkuAsPMXe4iL5WcUQYH86z/zqJpoSHJ3cpuVLPvtdxWcKIROh8Xfk7wOwIVK5biVJGIlUNaINK3iZfRJRIpd0UKTxdU37DnIiEGGEHlYxhgoKHXJOeodum9AO14gQhGhoTpNI5DlTvUerFyOKS0STFseqdznUEnxzRCwUcieiZjzkoWFgJza+5pPzq+T1Nmy/idBinHAVoRS2dZeN7A7ZOKDEiIdemZP3077fD92b8uHlx8kwRQ8LSGUwZ8aERlqd8CsLoBReZREzcbHEmHF9nnzXYdd6jYk2JbLSs/Ge9m0kcFw9zTMZG2OW3g3NIXeUwcZqlpwbYU4LDEsGk6Igi4MyTXYrBmVNofVhuTNGoXhDuSAMNPc47586dIoBhnwWEdu0r/8owTHIfUtDK50jaigyjofSxhzsz2YYMsVFotkd3ARcJYjn+5hulrXCOv/6tV9APn2BbrmCkjrWJESqBIuIqkzjoJiEbO+FmHGFU94qQ4YMxqmE0bBTKam9nRIsd8gyqR4gFFwdxZya3sGPTZonH8GPTY6HIRflBuO4SQS48jXeh0U9joE0L1nFohmlVc3DyYAgSPigtYOSCQO1jUxCeqU6Zv8Qy43goIST1WiILhdPv52mphEJjXpX0fIl1kCghwHZUZcoXyIopfG7NobKyMG1cwghKCgdJXX8YonQNLEP0xzLFQ3m4yHF0YiHCwbWUpfYztLsjYjnMjTdPn84f4rDMiQSCo7GQicFVh1tQjhJAVic7PGweRaA5UrIICjy0WTmhNwp01NVilEaA863AqKGQijB3JFNjhY3eGVwHlsmlJMQr5invPNZVtQWv1L4ab47d5U/0j4JwCgpYzd3qMg0L8hm6miLinwu/XPEAkzreF4BP9RRyykgq2oTLM8jNgWt2b6NK1WatNkKc2CnYLc6DXhy4zqReYRb5XdRjiLG+zYd0+btYcIzViqzL/UsrmQjxuYQvZLmKsrpUpzc40L6R3Y0jbm5ND+9ORvR89j9Kbo+k+NqCkN3ULpBIkK0wg7t4SqTjI+mFMt+QOTqxKFHxw1BaugtjT2zw7KMadDF4yT3iTGS2fydH5D1Q2D4fVxJpUwvW0avmhy3huDr7PmS0vYTdE/DQezwZlnjyfaE29broMpEakTNThP/xLkISqNb+n0c30BrJKwX1rjNBVZ6G7x46S0cvf5t1rMOInFZDSuE2U1kmCFQebThEQDKc2O8xhznb79MNvbwTZ3ruTyOyPHRJZizEm6qq2RUhSC/TzKbGTiVKbN4QlvnwE8bxB3DwSEiCYrYXsIoyGPIkEh3eFs+4nCYMqCO8AlcRf5eg0o+TQxeXjQ5zKZBrTrok510MJRBrIr8uZfSoHXDT9hqGCz3t8hqf3bYTrtbjKwSztF9hEww811cL08kQ5QIEMpjoO5ws5oCQ1FY5+wMGHpaB/OuYFwoUJp62K5LaDj4cUh5dkReN9KLauEwi2l1mRLx1ZHO0fIhG/01SoUuMYogk0VzBbHuUWVAUA++9xlDM6bqVbh6d4xmpxInY97l9d0rSMelYaaJqpOUedhcouyPCKcuejamKz0myuTyU28QnT3Nod1GBlXiSJAX30GSVvoeFuZwF9LnsnRHJ/hGGQzF+NwxEiG4W1rFdRO6ecUTlklYmgG8rMd82KVn1qnoXf7kkqB9LGYkUyKhF0n88knCoo4ZayRGmVBLCPa3yJlTNqarPJ77Ep34CIu2ohiMeTB8gue7FZKWwWZT45HOPptZh1zkUMt6lD3BdD9Lw24z8RwWbIVZTTNifeM2/XABZXhoxogTnQGGSMiMIwQQxmCbWZSQZLQOoVomESFzfirlkM4Y2xRYMqat8rhzZX5r4WOM9BzzQZf5uQHHmpc47pggBKuthMPSIrXhAL2ZfO+d6doWdV3RL5UBWJ48QBMTvpY8RlZ1EUYXRCqVejk5RVH3UJ7D/WaGVsXjHXyUYQLNfpd2dQEzkrxm3EMmOq70GJslLNej5PRYWSiiZtK8augTYtANc4g4YqjScxEUbGSSMLVN5lfnKSXpvnzh5AX8bHq2ZHDANKOT0fNM4yGNvsU4I0hCh4fhgE5Boz5STHPzZIwm97UDEjQ0FdOdycJXnIRL+zdZOdjB0ep0628lN9lm9fABIu5QchvE/XVswG28hpCQs9/K6t46b1w4kw5NV3Dpxgh1JMI/6PLmL32GoXudY8W3slg6ReIbDDTFUKbx7Lp1wFu8KkvaOoHK88XOp0iSc3TdEagiw2ieC2KduBvRyKeVtPmDVxmdOMJvP+3xlrMm77iUXvDR1ENODtGM0ygjiyYU+VJqNa5PDMZxCbeYAinLmqJrkmenywgUF/QDikWDSM1x4G5S0T328nXknS/R8w84m3+cTf8cn5hM0BVoIqai71A2+syNs0xyaQL2+sJ3+bFTXyKJ0krapSBNOMNyHSHALEtCqYEY4FSWGI1NZOObGJH1vf13c2mmh5vCoyKVTK+PC8iJwNR6XKockE1cGuUxc+30mXRyDt2h5Msq5J/dCTB1+Mnd36Pud7gn08rrYHSSvfERADRTErg+hhazszAPShHEHQx3GVMzOSJ7fG50mfHBhKznkJtOcWyb1uIaZhLx5P515IaF7C2y3dB5qI6RSMmKe8A4yhNYPpnxlFiYxLU240hihgVuffT9VIZdSqTJ4f69C+SqKTFRObyPfr3P7z3nMBdLfkf7fzHvp8nyBmnl6HgQcmP6HELC1JMkmQHZVgkhIkzhcqidxhQ96vvp83StBWQimJ+/SWUm7ds2FQmStpFlomfRd++zl/l5Vgq7jEYxmlWDyQYna/fwBWxIxURLyLsmTba5ma1gxRa+9BFhnSjj8PPH381WZR+V5Fhz8vjmPhPjkL67wSItep2Q+fYegWFi7g7RW1tESYIZpCTAmrQIZbpXjRdfpvnBv4BwZ4SNfsAkt4CMYFO9QV8fE5on0GKXC8MsHdOhqO7yrWwGUxkoQJdjXsrabFWKGPGUz+knUAo2V7NUGJIzYjpZ0h7DoaA2VsTS5/WlLDEOE/09/PxwjKNNWZk84Mb8dxk8eBfdc2tkn5VocpW4DgLIJIcctNP42UiKuEpg5w5pB4KTO4qtRZO1VofFfIt6pou93uLOWgr0NReypLG0ZIJQCjkOMaZjbG3CCW+VfbVHNAZTCLCLaElIaW9KmEjMzSZbcx7HPYH0LY6GDxgEZYxCES/JcDIIORv3GMwMcSzxVQwEV4ImebK0RHpvXh0+QRJlaQ377D2ImS/u8/7Vp/GDDUDj1QtPIeMIb5gQdRo4GY2SmvD+CycpW+lZz49nxjKOxureOlIlBFYebTX93Y2+Tt7xcK303s4EMM3k6C6tUG+3id0RsdRxkhJZI6IwGtKdD6mspfexMi1ynstTwwfctko8f7QKCpa6Ju/ROlhJwqEmKYUDVKxj3mqzXllFJjFWsI1C8pi8Q4kJq2GHL7zyP/D+znNkSah3E5L8LAAd6fHule+yP51HZSSVaZ/4mMTZT/it8Ef4cvmdvHphlX2RVscjp8DluTc5PGgQ4lCIqrQKX6Cmp6qYIDrOX9ebKASjcZVyJSURdB0ywRRvZ45eku6f89Em1WSAm5gcCoHKWxRHPkcOtzG9e/yX6l/Alxm2RZFndZ3H3YB1ykzNEnYw4mImRirJfCaV8yZuD9sdMj9Jz9LIypBNQiIJlsqhJz7W0pSfmDxHkSn9OIdSMegZvPJ9pBYx/502viHZnatzdKNNNJH4ysQc9dAjj7mHm2zaHdaSCEPF2GqRu4SI3JgfpPVDYPh9XAU14p59lIvxJuZsxtzmyOD64Ty//bLHdu2tANijW3T0ARoa67YPWvpv3b2TIGKijSEJksP5eRKh8QqPszTaYVisgtdnz46QcZ8j4RpObhvDmWOu+Bju+DjjGORcSK9coDDs4g91xsYCL9vH0FTEudHvcNHuclOexvQbeLldvJn7mjubfnxEPqRD2qPTLQg8EUKQw/Jjxn6Ogjlm0Us4YSW4Byn4GWoRIlH4w5NYesruFr0SE5le4sX+kHw/BU9PDQtcSbIUgGs2TDKS4/u3yc8Ga7dUnjPThxxW6kQLfyozGeL6WfpWGgQuTk8goh1Gopw+08wBqyT4KFT2AF7JElgWor5EYTxGkw5eklCZ1fru7w7Yy3Q4Nc2h8m8Agi8ODXL2cwzjIqKc9mOh6+i+Tay5VGWPpFkkNtLnNLIGNPwahb0+OXsACSSxYPBwHoGibKTRuG8fZ91ucqa3xXwfyIEvoRsXKOQHXDV8dk0HG4tBa4lVcY23ffPL6TvJ6eiVgGCq8Re+BH5WYT6lcKwVQtvgfuYIyncZZye8MzfFmQ09NhYjcsGUvXydS8keri14ZvUVOtqIhIDedh/MI/gnFTIJyUZVppmYiR/SyPc4GM1jF7eYiqOgFO++H/DU11YJEoP+GkSaxjsOX0MN04TnSfE6RWdEuJ0m8kvxHZY0D2sGDO2tz+GrAj976V/xycv/ho9t3uC/Xh1w/PAOSRITaxrNBLx8GcseMKwO2b3078hHGoalMDwHZ+CgK5dOkmev2qTpdFjyDnlgLfO2zBuIzD4/E6f7oTJVbMwvUxl1Me00QfB1DUO1EIdHmOZTCeeScZdEwTfiqySluwgB0hggSPiySnvw4iWHSJO8eMzig6PLHNoxZhQyyacJ0C0eEJEwtDr03JTwOONu0s+nPWuWjKiEaSWwHRQQwEDZ6ES4lkXRnTAoVLHmy2RmyYyfmLROvwWRxJheCyUleb1MW/aY69u4mQSRxHw7uUOoCRqjmE7lKCWqbMkONXpU3EMSodjR+pycTpnvHnJs4wZKSELzCHH4As2xQ9ZpUfIa9O/d5xgahebryHEWFV3kePchGTPEDBL6JR3TV7zj/jbPNBXuXoenmp/EyF/ggf8kAsFIRIxmwFCFDynHTRZnc99W828nwcebXVOH4QlOaevci5aR5nFUMkH39vmGWKWQFfz8j6TsO0Dv2l2EUmjmKRoqjZe10jZKCQrTiFGYw1+dwwgTDNNBE4q7coWm9iZVf4yVT4iSOTreLvO9HXZzNVAJ13f/CFMaDMR7aMYx5+INbHufL+Zt/p9zCZqSbCwcwQwN2ktjzmf3qRMQKknViUkQGMUUwFkli0glKDFimFtlz9tFs/cR7hFQknKocW8pJhaCMxvrfMx/BlNXPHQaCMfgauENdJGgECwV+hSnKbDwihscDuGX8DhREfy190+oRQPOTW4zYhEzmOdLt38SC8gngm4hRHlNqtJlksmlzqzFCl5+DxGc5Un9Hm5i8O1vjdCSNvVOl0GpjF9ZIBaSS90HhHf3SZI823WNXT81urgUrTOJcuwWQqxxCsTc6gg/1rF8uP3oI1QGHRaSDoYMeaP1OEdGDj2jzNP33oK+63CiYPHTjuSEfodQpURk89V9YiRPuD4vTTbI5QWDJERIRXHnTzNa+K/+p0lUnsVuekbG2bR6srj0Kkte2iO5a6ZEzK7MppWeoEv/nsbeZJ4ldISQiN4WT07foKwivh5X6UVTKkmeE/GAjWyNTGQRyRilTPaKeWKhEy2kLQDF0QXuWho/Pj1k3X7AIi20diov/No7Po4WxbRfvkPs6xhBiYnVpRE2iMUBHgYvf63Fpx/7p4g/TuN7Sd/BMVPZY885xNFcEvMUR/pdLk9PM7VeIZQ6zxTW0BMbQ5M86o95JWvjBEV+/eQn+Bdn19gMLtMtG2TlFCnBNyJKukIOBNlkCSVDlFB0zC386BFO+xFv8aeIcMJLK19CGC577U8jPIH9lXtEf+pMOm3TGabPtJLMoxJBNtdi7r7klz4TI3Zcqp30vn+0+Aalgw5vnkrjYqQssqT3tWZpFAkR45CsEaMX9lgKmmzVOmTCAhkp2LPTak9prOjoc5RGNr2SzztcnwN9jprdwSXNN3xR5mQQcilwaWkpIbQlPZ4l5McwmUciuM4BEY85ZyDOcDAY0r4fYRZavHv1GWx/A6mvkI9TYmI8TXBUmZGeQwKdnQPCXPr5rUkaszynwLmNW0SaTpwtoK+lwHB1t4AdRATVBcyKwPRgUl8gsjOcuX2bSNNo1+ZRUYAydaTR568u+eTz6b4NcgU+/vTXOG4G2CLmhQt5EPBTkzEfmlvnA8OAkSZZta6TuA3Cxj0e5CqsTNqMZ6Y3q+KQ5cyYl800z/zL977B7+8eoOsKdEGwlJCtDXi0/jpZ3eGmX8Ak4N6R06hYEO1KfKnxYvEtLCR75H0HL0hdjuXcbaZBRFmXbNt3qNqH+H6W3rRBIiWR1JmM5qhmFImlCC2LbDKlu3GKwI8xNcVOWKQQpsTnA+EhsiWKgyFSSS4f/Dd6epV/u/ozvFk7xaZbIR+6nJs+wMuvYqlDbHTmpnUW9fQ+ccIhUoG3/QxaophYFs72fbYagmPjPMXhBHsp4BM8z09p36IdFglCEy9bYVq7AYngyPNdFnsxD4+8DzvwMQcKUFSGXcolgRmF7OodFuMRkVrExKAtphzJnOEHaf0QGH4flzALDKlRSsZ07RQQrQ9MOuMiywXBywsZVqYJN4xvMp05ZX27YDARHgKBt90gcksk3RSo3a5d4J88+GXODTfYKa9g+h7ffPRJ2kaCGY2oxFW8TAdjVORo/kkcv0ErlKhKwpadGpWMd2y66hiv6Rc5ldzHOPgsZ5w/RkQ2hl/FzRzguLNevFkjljNRbI4sIhHTquQICAhFGT2B2DcommM+nISEicGd/PvSvrwsFMZjpgKsWZXwybsl8kGRUHmMtAwuPr70mffnCBYanEfnTm1mD72+QSXnEBs2OzNguF+r48+nQEeIBN/PslVOn+vHkvdQc7pMZn2EOS2hoQWMIoVROCTamRmhrJ2iMB4TG+BjUJzZgY+7DpvVQy4mGTKl18kpKEh4Q15HaFP6s+qpSGKsxELJmJw9xeuWGVdMImL2jT2sOEvghtj6BASM7xXJjWZ9Z2aa1Bxu59kWVU4OdmgOoV2vIoXAnQHywsiipacJ8CT7FJm6Rz2coBJBOTdgQYuZjE26eYNnPpwQlzXuiBjHMxnP2FyzNmAhN2anf5RQF+jzETII6GTKPKJ2ObmXcMfaZJiBOOPQ2+qh5ZcJTvtIFVOa5hhlQ1xps5rbojOtohSE4Unu/arP5TcF6/MGrVNfYqMWYhFztX+HYneHGIn+YpeM20LfyqASOK1u8vjz/5HVB39IYekV8uN1tgo1Xihd4vXiGd5czXIwGtEYRhjDHqHMUkKi5TU0PWRYnuDUroOIKZVKGH7Aa3/4GkqGuOjsVho8NbgGseDz9rs4kuyjyf/M+0JJ00swgcNSEdnwyQQxE2nTtzJY0YCTIoPSNVzTYr58wAO1SJ8iovp6+s6NIUrFPMc5YgXF+SmRPmGYfBQLyU4x3Ru6nJEicSqr0d0eo0x68c1N2nSttNpZNDxKcYtQSdphkbzuM1EmBeExtTKU3Ck3L1/h33mLWFqaiBAobqytYLsH1KYTbF+S1Yrs2CMaA5PJDOxuGmlSOt+bMigfJ1AJY+lx3L/L9KCPAl42tznlTPFVmYvXXwFgvyrZz7yOp2uUJ4cUvTqd9XXO6i6L5fsEe0eJtBE3S1/j/PQeegKHdYvvikWqo5D3nbrH2879eRqZk2xoO7hR+nk0McST6XfQ+2lFKCvmsQQs6mt01DVio0Ds3+RgGlLT2mxrcwziM6hwncNSjudyx/iFT+QpZv/sOms/dx2FRGjzFGfguZHr4zhFCsphX6/y+4WzmD5krAkdlUMhsEvfpDjoY1hjpmEJTWhYwqUudkgANbzH/eGLNJMPMBAmP98qcK32PL9Uq/J0ZcjI7LPTMKn7Nluaonfv/ayYDhNlsjV+yOsnz9LQU+mbnRfkxiMiPWCqzdHPvI7tF0lEjOHPsRIoolyfvXqTS/dv8dbRm6xVfB64y+CbXC3c556/wKC2hpsvEsQ5nNDmjZ0PkCj4KAZ/4x0a5nZKxpya3EUQEbcfw3w4QShBJRF4qkUYzlNOpoQzs5vNlTUSvUvBDfhF+Z+Y0yY8u2shk22sIMArNhFanbvlFY6OD4j2NtI4WRsxGaYkyuPqDj1LcaekyM3cRJ2SO3vvgvtGlVq/TW00Yc4cEJlVvvzgL/Hbi5/GizK89QN5LkQmhUwXKWKELvFDgyjRGCRFzgQx+8rHEC7DRKAUFHvf2wJMhqeZxu+iEraRRkK/WkSIBK/kctTdpa3nCM0UsO6LHLqKKUdTwvWH7HXXODJLj5LhHrVvRnwg3udAmNzBJYdFOc7wUPfSeD+7J6Y5h5vPfJx3O19gzrhDcXqclq7zo+MJu+Y6i7TQR326lRo3T16hU2lw/3qfYFrACIq4dgcjzqKrQ1pU+LJ4jL5d5IvDqygFlcwG/syt2HIlkbQIzEU+vBuho7GUfJnnSpcZZx8jG+RZSXY5FUs6SF4Iz/LNZipr3o9Og5AkeZ+JyPFWfYohYDSeIxNXiMQAgDvZESI0OeQi//1wxIOCQ6C7uCvfxu2e5OGTb+Mrd0P8+sycZdyj6ySYhORm8rlMrkc93R48eUvyauUshit41/AVZKJ4cDwFao7MkRc+T/ESiaFRJUAbhUQ5nfnEQCK5Ud2i4jWwBEwz6b1pOgn7qsnOYhpHPuT02KiuYGYiZJDuRdcqc9KPOBWEbMWL6HafW6zwewTUkFSQlOQmt/Qxj0QVtNhm6A2ZbiuMwgH9cYVsPEQaRykMbBw7y0gXdPMZemEKbDcf7nJQTHvlhJvmKe64xur2fQ7mlkFKsk5K/p08EEgg89ajmFWBmCj0bB7pu8zv7oHQ2G8sknPSeK2Ot2gYCp0EEfrEdpaPPPM1xqUK7994gV5tRDZJ+IiRVhSPTxMSBCL7On7UJDY3uGsIjk52GWyl+2dJHLKQa7Pp5Xj3o/8nXzpzFlNB5YRDre/jvD8hjjX61yu8bfFFnpucYEW1uGsfY1Jpsrq1hWNq7ItlfnTwRTKBT5cacmpRX1xnnGjkpaLdd7EqYybjKvtGWiF0TZvpuIEUMD4Orp3Fkg7daA3pRkgp+FZ4gpZYBeCuMUTaVfL99O681N/ng5On+dXln+LO4mOMZ0aJHx6/CsYKhtgmnFYoDlc45mRRkc96Nd0LrcNnmJv69OUzLO17HNTmCPJ58sMJRlviYTIly0BlUUrjzrJgUr2B7C2wkatwdWeD0jhPYGXI9GIy0qU47ZPv3WGr0sRxfXSxSajSuboj2WM++2ejmX4Q1g+B4fdxxSrmeHwPAUwqafI4mhrsVl/l7JrHSzWNdx2G3C3cIXZnLklGhZYckcFCIBltP0ZQSEHNbuYIf23nt/mZ1h+zU1rjzIM3eeHio4ysLKXARwmFsD3k7oSqscBCouN4RaxsRJ8QVa8z3rW5lVxmR6xwhdSo4FzwbY7P3Li83B7+NAVyeWKyscP13hyBrHNQMbH8hEAEKJkCsGwQUjAnnKsoJkGZaWRRFIJuBmrdLlMxRT+2CCSsdYqUghLSG+MvnSWq5uhZPYbxPCJb4Dwa/aqJFcRUOx2KeoRnFBiTYcU/YG+uzshf+t7zDfws+zMMO18/ydFOkdJ4TBxr5DBZTDKMYkVGtXCM9Bn+t5ZFdjIlNA2UjJipdvESyY7pkkVwJs7zqeGUk1aEp2Iy87/H9nQOUGjjIcJMkys9O0TPbXB85SWG1oCumWYtvWqVfG4KAqznNOpujEQjZxRAJTzUTqOE5Nhwl7wLD+qzmWAz5msprmBHBXpmj63tDELA3KkqhgOL2X3WEo/7Wo0Xjq3Q0opUVUhO+PSCIidvprKKc0sOSaIxvfcBnIyGXk4I/BRsrokWH3mgMRYC1xZodQ1n4GD/299iupRKX+Z6GpNsREY6rOR28ZRF26mx9Cc6zgMf4/2SP3jK5PbScV5s5jjmDtnW55kb7KE0g2bxrVRKi1heAadtcyF4A6NSZ+31X2Pu0d/EHpt8c/kkmop5cnCN3zt5mWuvtZFKYI56ODJLEYFVSatBk0ICeoRX3KSYqaO7EZ3WiASJkIJAN/hw/zvsHhS5MT1KVy8xZ9wAIn56I8CVgooTE64pMl5MnzIDWSTjexzTChSdMb2VMvl8wBfjJwCFkdmiERaQ+oA4kUxjm81JmdX8gGFBMHciTcJu11KGtjaa4FogZ6Do3EGJSfkYsZTkR2OGQwdJQjkTYoYDpsqkF2QpGR5uolMQAe1yFUc36ZfKPHQkellHFyEiiFkv1AlVB5Eowsghpxe5lQuRSpAkadI0qKTv79jOPSie4K62h1DQb/lUkj6+rtNRbQqOi2dUOLKzjRkm3G8OMQPFds2mMD5EVwaxp3N+7jqaTLjVfoL9/B7v3vJ5YpzOFHMyGutJhXu1AueSDiemL7AVJHTsPt5sYHNfF3SFQYLiXnIcV26TiDMctSQCwd7kNZaSEaHzJ+xN08t1VfqEKkvZv85BKUdpLcvVk+b3zn3k+gxuPgQSEFCYOcAuZJzUFY8p/jL8z8/8A15M3kooYC8pUYpHYPdYmTpI6dIJ8lyuvpeLlXeyHOzw6pF5NAVvDJ7hUOvjRR/kuPk6rj5hoqVX6V7pBkoKThZiOpHE2b9APQGFBaNDHp46gZI9/GkFKxNQ7XcJLIECqrHBu/t1wswueqJTTgKk0eX6sfOc2XjAvNPhVKHPlreIlghsLeJlLrJVucibnMCdZvlnL/w9DkcnEEaXj2GQ5MF9MTU+yCQ+Tf0O4/EjfOzu1/CBcixIJg9JsMhY8fdccfdKZUAjNnbJJQEfeVwxVjbTGYMvK6s4ssS1xglqzgDZ28AIxujFQwJPR4tCzrHN9eqUYSb5syH3uTSgagIOOh5W6FPsBKx4PtdR/Fv9EerxIR8d/yYfbHyDxjAhZ7Zwsho5I2KgFXnlsceYujaNKP1Zh8YmYaQTTesUfDc1UYrnqIRFWuF7kSQUjroMDQM716XDPEfcXfa0PHOxxjHZYT/JU4jT/XWkNuQJfZsjSBQJyaSFeUPj8fqURix4LpnNY1NrbAkPM7bIzAxbVsV9crHL1fFtfrz2D/mn/AY/OxyzY+isxm+ihw6a59CvL2CEAa+ffZxBL2ZvfASBjtDTc5Gjg+/rvFhLZclfNR5L465cJ3AXSGzFQE+IzKMgJO/rZekYHdai1/lm6TSadZlclGdZbTKfSXOHPzbOsuS2MBPFLkcBQVJ1iND5kdAl8E3uG48gEgOC1NDrpYIkJuGOeA9PeD5ObYRAsF66iVXe4kH5U/y7D/4EW+PzJCbkJxP6ImGBPkN9AICRGbAhLYYZk3NbCf9KPMJ81+HkxgGBYbBfq6CHPfpmnhPaLh/gu6zKFjUVghczyOc4M0kBwsviOnZYwJLwztxXAEg8wYONmMOzBlIpzoUB23Mp+BFbGm/+M5dxdoWVQKABrXAOLdfjdY5xXw7ozeJDQ9xn3zogi+ScexwvHqHaCr3Yors7c282jmINIwalBoOszTBv052m70gNN9nOp+fDi2cAyM+RnYx4uJa6jrb2DxhkYWWY3luZt69gVgRTZ4AlBEavhWsaKGJajUWWe6kEU6yk50eGGTTPIbZzZHyHcn+HT9/5Fq455b8bjMlpEZGSHAnS35/Y9/G6VdqxRUdpHJF7tCc1DBUitDHktvAV4CkGTcHLpSw7r9TwfYl7NaZxGHJhNOTdK98lQuf1+BOg4M2LF5k7aBEZGjXV5vGtuzx1I8J35mnuKyq1Nj27z451gJnEiGrAZFLjQTU9O8NMhuE4reB3ThrEmo6OS6e0gnBjIiXQiWnJeapWn/siRLPmyHdT8rAR5Pgf279FguCFhQ8g/Is8yK7w/tErRGoFKSaIQZl4dIrlaZXE7fHa8QaxFJjTIUcf/AH57rfIe6BWcngqS346Rn9D40XO8Vxy6Xt9/euZPkFpA7NznD88+xGGhSOcvfsZKnM9Cu0IIUC3Ex7Yi7y6dppISVztNpPkLB4KQ+6z5D7kB2n9EBh+P9eozVFnA4DMQhqcMoFGnA+571eIpOCxzphYxjh+Cg5qUZl9vUM5zlA1txhvPk7HKeFkS2hhylJdmdwGKTm1cYfQMAmMMg0vJrRTIxO5vk+kQn4kaWBMmpiaIl+cYszl8PsmN/00CF+R14hjnVwS89gklTBEhU00N902TeVSVh77XgVhzNEpaTx6p48nAkyRVreKkY/FBL0CsVbjoze+xcVdSdcUVHs9DsJDRrsxmj1iUilRCAuUB31Onf1pnsj9OXpWF5lkEVqGC2gkFZNGp4uUCRlN0HN0+k7KBGm1hIP91e89XtfPMzY9pNK48apFZXyS87u3CUKbalTFViYdMaKw32FULKCUYN83iMNZ8pIcoBJBRilcZbDeOyRB8djkNC8c/k0224/z8XKIVrzFQ38CCPRBm3A2D0orTNG1gIw1pmN36FtpL2WvVsHOeggHnPAC83FMyazTzk7QpKKdSxuoT6jUzv5hsclUGSzJFv/hzZ/jhj/HyrjGQfYANYiZBgXM3DaWLzgjt9FRVDLv4aeO/UP+qvP/Zjf51wgBf0VV+QvjEZoVc6kUYh08xoedt+PqJbIyxInS5GZNtHjChWKQfo9CP2Uhx1cWmMo1IkNnseUwyUQUClMW86ls6vrGVUpqgSes5zj6HpMTyV2uly4zyOd5Yv8eX7GvMOe3mRsPMM59nNzJ92PTZHKQZdXY5FeXPsW33/dONNPB7S/wJ4tneXxwg392/1eQJHwlOY6azTJzMCgQki2kF+zUmjG05buUzSbCTfDmbFRigQIRx7xr8DK3O03KgyG/vvRJNKHYL3yJT+6EbGuKo8MW/lGwXUU71+CwmMWIFYH5kPrWXezVtGr/B8k7QAYgEprDi0hjQIIBCJ4bHceQCScKx1l2UjLlVn1m0d7vMM5lsGMTqQQ1WWHcWGBcKGCMAkatCWXTQ548QxQqpomOG2oUTJ8xGSwjITQM2uUaRWdCJDSChSYZQoQXslm3kEGLjbkaSkBWL7JXDFGaxHbSz96pNClPpsy376MyNe5rB9RUwME0y4VSi1atDEgehh0ez7/GoHyGuUHMbk1he3nurWXIuimLnZAlWv4jhpFA7j/CiaDFh17JcGQ2YsXJaIijY57trdCpGlSNf4+jXmdgT3E0HR9FInzKYsRIKLTAwlYvEydnOWJK9pIpidPjXZMvc660zaliCm7fFj4HKmC5fR3f0HnH9Pn/S1jtvnwbEkWr4jESMZYMELpHUU+YTKp4RoYz4TUuTO/xm+af4990foEEQcYek/V1jhjpOdjydGrWArXqFd6ov4vDYpZpvonI5vjfl/4rRB9HioQzmac503orWqIzKNympto80khJoKDyEA+fxNDI4xMW0rg46R7BsqZUBqN0aLXmURmc4x2Bi9BcXKOLlCFoPs9euoyeJEwPDZaD14iUTtcvsjEp0x6e4dkbp1mP63xOnGUc5vn0hV/BKL/ILgm+HuJsH2JkAww74qhzk1hl6VsFPBQZKUnG6WcNV9M4KlWMK0BWKwR2l7vJea482SCfhJgTF9e20QtLdHNZXm+cSCsfk20K003q4pAAg8a0R9fPMcxEKDMkP53NsNWySC3gANDcNB5mo4Dzu4fEwJ/H5KP+H9AY+yzs/gFlJ6HOQ1qZAnnNZzQjHN2pSYaQC57Pm+WUiIh3nsAQHRSSTpiOI9oSxwniJqXjDuNxglm7h+ec5Ii7x65u8b7eE7zTfEgQNdFn7oMXj/bIE3BCKEKzA3FAUs9gn23yDtfgukxJiKFYYxob6MogE6ZJ5BnvDi/kL/DWc7/O58d/BaVs/qden8c9n4+7ba67qQw0KtapOWNunrpCpOlcm8lDpT4FFNWkgxNYeLrFseEub1RO0g4KVMQ+oVMnaOocZCGyTtDwElYCm73iBkLAdzI6WrKAQDC0QorNCE1ouPEB/3jjP7KaJGzJBSDBzqZANJ/obN58kkhYaIlJVW7zM+Kz9KXJnhxQDB9jKCRvy/YpkmcrDmle+W9oXoanbru0u4uEtRQYjrSYk+4ON26lBLKeGfCfLxrsNW0WexGb7gE3+ufJ3ITeahFHy2FPOniawXmRjoCq06Mq02pu28zz5OQkY8Olp40QiYYlBCIzG2/hK87WDtjWOywoHQHMWs0ZXx/jdwNGxhrZRCMCVFRmmEm4qVa5oD3knkqrUCgL3XqTEMVjzmmUGJOZ+tiZPvGOoGdUGFpFaqFgquWZ2iZeNsd0cBLPlFxwbnO/kFAOBvgipJrkUQgS0+LOkfMoIbixukWvADk3zff07Tydh68zlNsEQmIMu3RnMaJVnGc+GqCHAdXGzKvA8pDeBGXZbM7Nc+bmS+yfW8FUEf+30ZgH4yrtYJHlOAQBdzKCfE+w6cz6cs2Qll2hoXXo6JIws5Xuu3FAlR4nk4CubzA8J1GmoLoLV7RtlsxDTlfu8t3IYCVusDNXJZGSSzfu82H1x+y2HuXipsb7ns3Tvfd+4tDAW36WV3O3OSoThIDJpMrD3CoLahfHtAmSDNOpgd9Iv+/YM7lfOwZezKrocmqySysusGAf8DDR0MwFMtMxMRGZuMCJ8QE/vfkVrq9l6FrLPFO8wrnuG8Sz4oDdz3AQLzAX1EncHo985DXaDShEMZv5r3KilYL9zIkpIMkbQ4JdnWcGZ9hXRUZJun8zlT0QirnRST6Rj3j10s+hawHjTgY9xesY2YivLpzmMFNkGhtoYhNfneY+EfNLOXoX3ssP0vohMPw+Lr28wN+48LNMTAO7ljJNGV+jmDX5TtOk6idkvHVqQZmnotMolfComycSMRlMVkt7uP3jjKaKg9oclSAN8kenu6AUo8oilUEHpM7SMCScOZJqByG33C3WVIWFbjqSwjgywJ5PE9nSg00aqsUCDxgNG3QHl7kyGjDVwM/3sHxFDMwxZF71EPZljFiynLnP2vAAn5AsBkpJKrFDaTwFI0G/7vCXb3yBH/lmTF8T1Dpd+maPrc/fxcgMGBUKSCRHW0MMLcMpdQYZpZeDZ+ZpigCVNzA7XXILU3Sl4YQ6e0HKPJWyDgf7dZJZla8j5pFxl4JXI3Zgs3SbE50OblykNrNEvll6g9KtDr16mSTOAIID0kTe8jfwFJSBYWITK4d1a5uzo7O8Ep+i03mCd+YjSu4CrcqLTOwuuuMS6TO2rpoy0CU5pGN3yEQZ8jnB9JyG1BThgcngxBUGQRs7UyEbmwjlEPkaS/RZzA5RgJ+pcTOa47f9t/D8/uN8Lcxw1j3OfnY/tePvXcUtDVF+geWZTLFgPMH98DbXBt/C0/44/W8qx/PZAYWLI0wJw+1LXDM2iJM17DhmnEkTniPiAL065i3r6X6Qr76KoRI6F1fxhqu4DZNy32OcSbDLAYu5FBiO753halajaR2jqPscC+7RM9J3c+LWAzaiEFOFrPR99EwdLT+HKB5h11lBkwlN50Wkd52thx/kTypvp21XODveIKeP+MX132C73GCzVqGfrxELgWX6WHmIA0HkakSOjVO5Q0k0IRH81PoZQpUCw6Pth2QHLnMPPALZ5jcWf5QEwVE+SyGGtUlCcbCNfwTsIGZ4Yog3I2s2wt+m2jtktXKIN9TZTObQzA4KgR/XMURKCgC8ESyRRILFco+TvQEAD0s2vqEx39lnWKxgihwWGmGziJebMi3miUca407KBG9rSygEBAFEEY6VJ0FD2unv0KY+77z1GgBPj1exiTHcgK2GgT3d4X4jrVBimmSDLLJQZqFjEyNoV+ZZPdyjMNnGtzv4IqLmtQDB6WKbvWoTv7DIA3nIV8xzHKw+SWPg4WTqBLpJrfkOskFauY5lieVCjwe9ZTRlMWdO2LWKzIdtEgEdrYCac1AC3jhewjGyvKf0ryjKKbEsMZIJmajCMXnAUFMovYIbvIhAYknBnbDF1fmbvLfyNB9ZvMuV8j16YZVVY4uJ9xWqeyOEUoT77e/F1MTdY+/LTwNw7YhPRxPoMsQopCBkOqnyucWf4PzkPgC/sPNb7O9UEU2TsK5TcHRquRQYHvgxRbPG1+dNnl6+TLOXMNRjiGNu6/dY9wReco6fGnnMjVeZmy4wzG3yQb7IogFWbLKR28ETIXl3wN7yTM0gJKPBApnMiPog3SO+MWS5f4F7s543dIe+FMT6HK+dvZDK/PczHBt9E4AHziovdZeJwgLflHW+Hp6moab81BNf4Fx1B6Nwi20SRtdvo+KEt6xtsmyMODE4wBQjPnfs7eleKml0CguAwp/F/zPcwMFmcGYOkWh8Rz6KUHBl4nCiu8NBpc5LFZ8vyRy3q6vEQpDxuhjGhOX2JuN8iTV3h25Qo6dJsoaPlsSUvCHduI5V7NIFKsOUbFQrGj967bP8h+M6PxGZFIwV7EBjvJ8+r3l1h8+NfpQCE8x2eiYd10ai+JHJlNcqr4BIiA4uI9hFkrATHyNAMRKCSfAOcqWQnLeHVdnCnxylGfY4MARRkMY8e9ZrHAiN0ugBr7PKWS0kKO6ihCLJTzEKuxyLJIV4D4eEQ/MyVjzriQ9sDL3HWWeda/pJDos1no7ewe/2/iV/pbnIN7JpH9qgq1O1XT7uP8uR0S6enWWvuYw+2WJqHKaqHtoYMuJ2tEo2dPn03stEms56vIimp3lC7lSenaIgNI/z49suAkFOe4EtM89uvE7FSe/Nl60ivRz45klyznU+GFxnVYzYMlK3GNtO/93zXOFgvEamlypKLhevc1o95C3Oda5nJ9TjMl/InuKdvsv5oWJOz7I6Psv2vMZbb3scuOdImgnZyYQTg5d5362vU5nOlDOZAUc6GW6vzqErxeOtDX79zo+gjQTueYGjVcgPUnJiVaQy6zp9jukb6buOJE1/mcNkgBVlEEjMxGfzpomSEuFFDOtTvDjgp2bj4nTbwY8NghEk4QN6cQGDiA3dJBtUuJU9wnY8x6PqDvdJq6Ivi6vMRftcly6Pu0cphWX0YodXgkex9x0enDzD/SM2zVjQNdIqrK/HeP1VnKzGuekGQ0vy1GH6XRbj9O5LKmX6pRpTw2Yn2mWc0THDkFjTuHb7gK7RA73PdrGKUIp+Ls1DenqFnB5STlrk9FmA00MKmTTePVg7wnyvx9cu5/nvxmPyKuGZzimG0RxNUlXKLcuk7g7YHqVnaYVlWrkqK6pNX9PxzJTEyw59dCKCIEtYT5i+PSFs5/gv2x/kq8t/mb67wrtXnuEARRStkmiS1y5d4gMvf5u6aDHyLgPQKUreHH+Sja/8E/TKBq9lb3BSph9+MqkxtAu8l6/hGiZSJYTtEoqUkPpO/BgjPXVwv9S9z+Nb1+mToya77IZZ4kzq+OCLCSRFMqMJH9hIxyftlyvc0o9jhS76JP3u+kTSknWKsoKjepSKMeFighaNiWXCpXs1AqlhzMzmaqsdEGCsB3iYOOgoBbXyIUQG1vAqnyj/az7W/OesPtVm+UoPM5qZ52QirIVVzuq3qMkOVfqQrLIjekRPf4dXPnedH6T1Q2D4fVyT6ZgPv9zgXrWJZiiknpDzNKahy3fqkne2I/rahP9t/R/xVGyQEHPBzWIlFi2rjXXl7SgV4U0UWwtrNKM0IFkqYt5vc+vEeY5t3gagPFYE2dmw9LbgQeizL/pc7D8OQDwXYBYmUBZcunmNq7yChkd/9xLt2yc4Nk14kJfcF6fIhSFDKdEEvNt8FS3zOK2qxqXk29RGe6n5DBCIAvMMMMIYIaD2IE0Ejm7FqAkUhkOG+T7miUfR7QGhkV7SK4M0ATaQXJ4eQ6FomTY3CmnSFA4iiqsTdBXgTyM4DPExaOoDhDvCc/PEscaoZGMGbQxR5/9YGHO3+0me9Y4xCYsUZ+DtterLmO0Jg0KJIEkv+Qf2PCJJkEkbL1GUkUxJ2Cre51r2Hm+Gs/lU3hJuKHm7s4iZ6LzYeIFELxBrHpYKCbJpwCnSo2f3qPt1SlqPzLkWSsG4ZXOoOviJw+XKu1gISyTJiCBRnLHHZI0pnVKFF+OT3IgXmBddzlfusq0U74uX6BsjHC1h0Ftmmk/QxgWKbkiIxlYyzx8av8+d/gs8DFsIEp6pRARBh7mzHXYckwNX407uHnGQzgdLFiV2EqDHOrmcy/nZ6J0b52yWHl2jdf+AzqjJ1kKWdn2BYbGMXfHJS4dCMGWiraILAdTJtjc5GqW9TcXphOnOfbK99NLPz5zYAKzSEofj1G79UvQaO+IIre55Pr/wVsrhiFCCV4x5//4zNEc9nj7+JDsLqXQnthOyOR9/pGPulxkfGLjle2RVygS+FLeItXQvXTy8xc5zNRSSw8UcHbPKLbnKXHjIPXOTj3QiCl4fqxAQaYKk4MCsHyJvH3KufIpl45DJbpqQCiuVtFwMFVnNo+ml321gaEwPTS6INzkydOmYMTl/Sr+gMddr0SuVScwMIS41bQFBSFwwCaeS6Sima9Q5aKXJb9lLB8fvZWdjCHLp+ci+2aY1sJBJAiKkq3JoriIwBKN88r3vPM1EfPjFDazcPJlQwzEM+pUaa7tbaZJq71NIbPxui6Y9JlfLsl5exqukpMlr0SUOS5cx/LskWoZBqcpR7RSZ4jwy9tFpYgeQbKSzo/zpHjvNJcrhBNfWuKtOUBBQPzukvVHm2gUbIWL+WvDH5KUkIuKy1mZJnzKSCiGL7E4dYhISdYefLv4DFowhC5kxm955hFBMkhXmMj66d4878zUWtBGBF5PEs37ne7+HsztE5QyCcJGulmCKgGwhjT2H/gIH+QSNGQg63EDECmPFYOfyY+wt/yS5mX+Jp1d5Qyg+Hymy4YSOVufyZosgmPCx5xYoCoth/D4WYw/mf4vQarOdHfHO5Os8mFzgonOCV3OpHL86GrC9usIoMtkq19l16xjZPsVhWvUY2z2OeRneNAUoyfmHRU49f4zIPMk0kyXQDbyOwWWtT9Xu8eb0NFtOmZcqBV6MV3mSe/ya9u/RdZmaiFiH3Lf2Gf7JawihuKq1aNhjKlOdxeQN7lXSvqhFc0DHblIULmMzC0pxNX6FWOj8ljxBxlnkQOZ57TsHvLO/TimY8nLlBL7mIvwRhqboV6vosY9V8KlttxgUq5wJNwniMreLj3B/5R8gRULZHTBMKpjlA8IgodrvgFAM107w7bMu/1T/x7zoueRnSTf3SigR87R1gnFYJI+D1Z4N+54NHH+n4xLqIXG+jTdaRJACm4F/DAGMAoXLR1EKzmS+Rc5ysJ30HI2SMgroRU2imcKlY5XJdvdoW00acZaJ3k6b700b4fwuAsHH5F3WSej6Z7Fmd4YdFsgXHmKomL46jTJtRsUNZGJCWOdf1Mr8J6vKgVdgruzxifgb/ObG32fROyRnJ8gkYKpeJUEQ6fcAeNq8wuXRPmruxyn5E27Hy2SUiyUmxLk6u1VBaJ3gQwcRkPDk+Bt8vXwVPdxkeXRALODZcov/Jn+W0DpNEh/Qj8/yPz0T8A+uQ379k1Sc9C67wRmOs0HN7yCIOWGlUtJH3es8U0/VGNP4g8Ro/LNOjX+6/nepPPgxvnIpm87ujZZx85JbjQIf2v4Ol7bbjCtNEmOKJyLq3bN8sXoZBTx2L+LRzhsoAfFjI0K9SnaYktomMZHSaKoOF7Rb6IAYhwzzDeTRDNkwJW317g20ux6JbqIFDr9UfwoD+Kn2BgAr8iG9qIaQBWL/FkMkOTy2VQNNafQSDYXkvNhkSURsyDbf1n3MwOalks/xuExc+/v88/dd4PN7P4aWJOw2jtOLIzQEvrYCShGrMZFXZGJbzLsdPEweOUjjdzAtgYJMJQWIVX2ZQ3VILHPoScKL73gbW1oHQ6XPd69QTvdl1iYyMmjjgChrUSine1rMpiiVGgMAQtvioFphwf0uf3445prXoBMuMQh0ypqPrhTrmsmCvMfWeJmqOeTXTj3LQbbKcXHIVLNoJSGaKTFHaW7ljW3C4xDPweHD42ieS3zxKrfM0zzSfIOyiPi6MIkR3Dt5irMPHnBwcBLLr88+u+Qdtf+dxC+w892/SX2yynJWJ3JNwqgKQnBG3cQ03dQIZlgldNOzPEL/nhHZ8YMtVt20kCESRYzGbi79HURjHFXGiEPUtIEWKyZWhskMiFveQ0Ishp6FLiSGWcCxUsI8s6qojeGRu0UubG7Trhfx/FSFsFzuoM3DUxtvcoxDVsUAIaBc2Uf0lhCqwGfcn2PF3CbbCCmtepSraSXXzCQ8tJZZZptC4iPUPAKTtryLngQU3kzz8B+U9UNg+H1cZtfhV9Uyf3P77/M/fPOfMxAlZOcq/9X/GK6h8e5WxB+Mz/FpFfO/ymf4sthAxmk14LX8TcobMVljGxQM5uos+H/GnF8e3mW31mDuMA0q7WwdL/eQOAI5glg0+LZxEy0oosIMSRkMbcDuyWUu37vFY9MXiYMM/u1PYgtJbVJiPS+5wSWKscOhlrLqNa+BTo6LYZu59nEqW7fx4jQw9mSVRdElLxxQoGcjrs2tEEvBY7dhnEso9w/5XO696GKIkhCKkCJpoAhEyFvCR5lqQ+5o8FLVRMQJIydHqeSSYYoT6TT6HnvUWYsPyIwD3EmTIMiytnQNEXfZK8+jxjqWkuypAr6bJ2tM6MgxD/ObPDiyQmjaTKQBKFqlBvnJhMjw8eKEqtCItB5b+S22xIhvEKMRkyiTN0ZLLJgxj3Ueo6+7PFiVxJpLUUUgJGMKtCNFIAPqXp2y2qHW2CWKDNzIJPEn5PQyJVFGIrHsChklWTtlcze7zN972/+du3EDm4A/Mv4Rj9gb9AXUpIkIK+xbI7SeRqI0zL0t8tOIHVnlRa+LdPcZ5AN2kjkMMeSbR0KOljbIZCN2O8t4wsc2+gjnIgBWMaIWjtlITlCSEXF6X/H6asLiZZ/6Wo5u4vAws8T1M29hUFjEKgckU5vV8SGHZhalEhQFCjdvYEoLlELO5uldHdxFjxO2T6SyaKUScrka1baF1zdZ8Hf4ZfU3OFVt8/z8MT55+HXu51cRhsM9jvHuu6/iGza3T6T9NpHTImMNCUYG2o5ivJ0jMadodio5fCY6ICmmSeDJe5v4XZ0bjz7BJScFwv9n6ScRQEX+R+ZCAZeOkfVjRoWU4dSMkFCD+bzknXKCFIreXo5ESPRZ/4wV2tjC462DZwDQkwJux2Q5OOS4v8tuRqM+GTLOZzm6t8fK7iHKtJioMSvBAlZsohcTUALbi4mMLHJmAFL0UqLnoZECw0k5hx34REP4e+IzLDsHRAWTZTlAhSkYfPPI2e/FgKHp8+TNW+QDhULhlvJEhsnx7Q1atTWGxoAT8SLdieRMsc2/y/0EYzNLxt7kRDJPwa+SyITDzLMAdKrzJDLLK8uSrNsmGzUQ+wbh1KZXf4nbpTXCuSr5wMcxdQ7MRQo6ZGo+/uYCXgE+3/wwc6rLpwv/FqwB+ewOBZEwlApDZHjgrpEXz7Bi/yKm9Nh2SvzG7p/nYZD2ayZKo6BP0LU82/USmpUCvOGtDQD2v9UGBO6FDMZ4hbZMyMiAYr7L0C1ybeEsj4yvkyDom0c4Hu7wSOM1fn739ynvbFPNvQVD6+DGOaRV4Nfx2Tl0kNOYrfw8i8Mpz589xPY1vtb6DEP/ConK8k/bywz0iEhCN/R4xnkXZ8artMwenvQoj7r0q1XumnPsl2ooX/GsfIRvXzUJZIArE6y4wK4ZIclzpJUj7xpY8RFE5GFGIcHQoKoJjpU2edM7RSR0rmnzLIghv8izHDOvEzsmRekhUAyC51C9IWtzHaxYYefS6tDpye3v9RI+fv1r9ESJpcwuPWoIFBU/1Uc9VfNoeCZCCTr3d5kbp1XWLy++hXjfxZUWFhH78+l5roou6kARmhYn/B2UEbKZe4xO7gpCg+J0yFBUsKq7yBiWuweYhZCJeowbxzOMpMeoMmI0k2WOhmVGlescUCNcTHt5kmkqC+/MyJ/lOKYpbbrZLUa+iSVToN2LjmEgmLqKhCaH8TKnM0/jaiEmKYkTO0coqQxBdIyWSsmqvlYkO3F4R3kHqXT8vS6RYaI5FYLiYyBDFjOSUdinFpTRg3IaK8Ia2UzqMHwxTB0Ip6X0s5yaVunqGt90UjfaSb3B/5L/a1gq4K/s/A750gJCVtCn6exCbzbD8Ka+xtEwpDf3Mo90N3hZT39uUdvlmqjjWk2OO3mWHQnqAZYK+HZulXe7LicGuwyyBTqax7PRGa6aXUpxnrD3l7CShKOTmKX7P8rqtb+NUCCUxjujVar5x3hQuE5JTmmZVc5H97jqVQhFwkcHH8SLPkRdPMs3F3+N5971v7JfMdhs6DQHOq9M1gDF5c02g0KDN2snEPaAQSj5uno7u9o5+jmTMzsJ7xreYTiXY1rPgNCouyngP2AONylRY8BDtUJTBMhJyE5Wkr1cIBOmuYHeSxPtWOlYwYhR6HNy7hyj/FViNJbEDkdHXSxriTjaoK7dQBMKN07fQWM2t/O83OCCMeJQpsD0udpH+cbZFCw/0c/w3vZ1Prn5WwSmSWOryMbQIRSKBb+EFSt0f4qW6TNUdcwkwvYT5kYpMd6fdCkoG11Pda2m1WBoDlEii6ZgpzFHPnaIiAGN84fpZ3IMHTeT5/zDewS2hd3sECVguQnmZIHCvIMIfQwp+b33fpi3mCNspXhl9zSJLLKeaEgBqx7s6wZzbLI1XqKc2+VaecDEzHJEtnDJ0I0lKq8IpwEkEtUzCE4myDHsjk4iPYet2hLP2VfQZcx7qg94SUVcaxxDk7C/sMDiC8tIJYlEzFo7QsvvcSHzRXJL11jb/ChmLYMzrOMZOaSKmQtbVM1DlILn5Gk8N4cehrwz/DrDmdxLFU02zx5FqAQ/TonKB7mZ+Z43YpQUiZCMwlMU3YSJbVHqTXCqx7DkG4xllXZic8xP91WY75EoELMZxYYaU3Fc4lKCOy5ihAFz3pg7R49RDqZ8avdpLhgHmKaLlR0gxylZ9THzBaSAZKYQKpdSYFiyPEJDo7qXpypHBCrNMSLSnLx86ofmMz9c/z+uqJLj7fY2ywWHtfoBuh1RpUNpMcSMFI/3YsrZ+/yP8X/mPxn/kv/e+rvkta+SxWXPbnHNvUk+SSsXtiZZ8DvMZg/zZO8NEik5aKaB8NXVJYa5fYKxINJ0tKTIWPh81b5JdrJC3cxgiAnfuvI2tCThyvU7TA/OIZRGpfoQIyzQz/e4wQXqyYgdmSVRkon3BAl9bmSuc11keH6tihemF+Kd0TGcQ5/59gHX//NJXtw5zt68yUvH53nbrYR2U1BuTbm3PSUgItZ8XBy0THpJ35x3OBUdZ2SNCYXDcwuKcm+ILywidxkpEpzIoDye0gmLnPS2kOMEwxoThhbnzOdRwqE0Thmht2i7/MXyi3gqj2FMGSYJkYz4ztV5hBDcSnIsyICVepHCeMykkEMNN9ORFbVrgGDilLhPwkeL6XO/NVgj9IvY0yMs9dYYlDPEukdR+gihuDt4ivUgRVg1r4ZVSwPFcNgkTIqpC1nmCABvlCSayGIrxcNkjr+09g/xdIv36XcoahOyMkTMhmLf3XyGzLTAobmFTGDUb7LXnCM/jemaRb6TESyNTnJ7dYyjF9BCl5tGnua5DmNPIjsX8UWMtEfgXyARUDanLDhdHnCMjEgYzvo0AhXx7dd/hTNnnkaPYbp4kr2lowTZBayyjz+2WRImW0LhcA2A4s37bNpnQAhGGZtcZol80KHoeoSLF4jjiLhzh7KV4XgnZtTOsWTu8uTSIpuVHKGm85OtrzCyikgVc5sTnBg/5PHXv8tOIX2fVusuujbGH+qUulOcvfTi8MvrZLQ82WSKqKbPy7znsX9S49rpGoY3RqiEbzffxlDLcUG9zjDuE19aIuPFDIt/qtuBft7CZkRDexEvMdjw0vO0jE4tLBOgONkOWXFbCGLCuI4/SUmTZXGd3axOc9zn6099lP/8kU9RdTwQAi/qIZHoSqdcTKWZOT8kMS2UbqCEIDsz+njdPoISMC1kKU3G/Lh8mkfUOo+ObzIt5qhJh0hAfhjyhavvo23WMWWGPUPhZLOcfvUavXLEKJ+eqyP7O2yvzqVzr4IFlrInOVHs8NnoXQAsaa9xMV5CoZjk7jHWX0MkMYPqAs+ad9hvLpB1Din4DXrrJyirPNkYxlqHVraEFcQMDY0DsYouFYkCvwr93RoHieQ3o49zwn6BT2R+i3LnEbIa+DJIKxW5A6rmvwQU3zx8gt/ZuUKgf4gvlxI2dJ2MTEHL4946a5MJ224FUHS+ew2VRPRuS0Cxf2pEFCzhyBEZQiq5PnvTI1xfPMaH2q/Syeb5WrbBnOjzs8tfIGeOWL23wc8/9zKa2GPTmOOr5y/zOjEyCxMyfH31cSaGTWg6vH58xESb8oWd/8Q0egtV9Rr/6d7fAeAVx+QmZfIb6bnv2l0smV6194qL7HdT4POl4af5/PvOMZU+SsbEyibAxFIJtX66b8uTMpqzTYJAJQJ/AMdKG3TJ80bhPB4ml/R97iYlNBGhBQlSKLJBg0vtbcJcgSfmN/ENSTwzxphzHDJJAAoCb8BYWZxo3GdCAT2O0TyBVDH+aEJD28cImtR9h+Joh6mdYS/XoO9nGCmLajyiNZ8afWT31ukH6R5ruAMq2QPGZvp3gWWRnU4Y6GWsYlqNagwO0XJQ9UtsLqbJX9F9CSdsEglFK98gMId8UHuau410BEZXlgilTs+uECQGoTJ4p2uwntkhUIJEGfhkCTJlhAFJAtME7vEkBa1NTbtOXqVkaRAtYdlHKC4WeD46RojGJMmR8RPea6dyifJLD+gXi4idHlsPLyDsIb14hTekSRmJ0XsbAFFYo6k/JFQNDDclb20rHeFUEGklY6VVJCla/Gj8XT579D384dz7+bn9zxONm2jWJbKOh/QcXDkgVoLDqESpGJFoAUfViLsy7Z+v2/d5yTYIreN8dC8kJkHX/j+MQ5P863f5a70htufTy5UI7LOUne/yieh1/s7ezyGTDPfe+yyffkeeX3vP7/Ktpd9GCcioDL8aPcEvmle4ZD2HL0x+6egvkMflp1rr9LUQheKXoz0SEbMov8qGVaUyHHDxzu9SGwzJxnM8+WCfkZnjv13+cwhTYWb6xL7NjmqgkiLrTYv5fsjcZpe9+WU6s8HyC2FKJk9kkV64RkmMGas8tThBjEO2bai99G/IBikw1NrryMUySkjMYISRxFxauAR+xIZ2hNCUzI0m/Mzif0UzBCeNlNQwZ0C+a/TQtZicNaFAjp2ZO+3RQYfDZEJbhPzY/QkfDz6L2IoIV6sUXQ03UdwtCE66BrE+M4LRx3TdFAi887CDh4sRW0TRHbKxTpCkcWAjF6CEQmXSz3B62kPzcygBhexZqr4LKh1U3y83ON96CCiycyMSJXD8Ctn+Grm5EZo3QRgmL77lUT7sO3w5m2UQGIz0LM/Yqazz5FQw0QVRrHMwnaOa3+ZHDj+V7kVxSOSncSjJuwSeIvbK4EZEi2C9qOPqGRwMfu1mzF6cEo7vWv4uCrimrxAZcPvyJQruKpFMcOwJRgwb8RXm9QcMTnyFubf9O4ziIX73Ktq0wVK8S7Z1nqbc4+nwOF86eC9elCPrOjTjgGmUqsu6q/MUB5usjlv0wjJSxNy1Y5TUaI6GKCQDSvSjVWpuwiirY7gRvew5LHmLPvPsqQyXpym5KubaXHM13JRj5fLeCnqiGIY6brdIUQ3RUXxm+QP8lX/4S0wKBZpyykIpVZpc6KW9rzvqFPfdJ9n2UxfUbMYDH3Jaun9zd1Zpih5BcpKIiFjLoIDWiffzg7R+CAy/j0tkciRGQs1yeeXSu+iVV1iMNJLqPE91AhLlsdf8dT7dXucz8Qf4TPx+5uTz/E1+nZ+adPijytdQw01AQyR5jox3SWJJ5EmeaqU285srRwDo5zK8WlgmGggCPUMkI7Qoy039Psm0RsUK2DdzfOHMO2mXKmTegMn+ZWIRUM+lCYXx/2Xvv98sS6/6bvhz77z3yaHqVK7qqs5peqanJydpggIKKEvIgI2NH7CNAWOwMY+N4bEBA/aDDZhgggELkZSl0WhGo5nR5OmZ7p7O1V3VldOpk/OO9/vDLvRe71/Apffi/qn7qjqndrjvtdb3u75rLecmi3I/Bdpsh0UuDx4mkAVUuYje2KGx8SZtx0bdiaUw29UZyq1Y8pYzu4zetUPXHqbuOEztaFQLOumdDu84UmYzNAi1LtILiJJ5fHzMmS0UFEoyh1RVqskCk5uxgd/oxPfVD3UyvQE7gU3Jq+FlJIbZo+vlaO/pv4crMWBIaAPu8MfoDxKg9whdEyPQqaTjQ61Kk47qM58ISbQ7dJJJ1N2r2GoHJXseq3mEHX8UBcmnpUVS77Ban6PTHqIZaQzfOs5Qa4hIcfHtBqHUcS7ewS1XIRFaJEMLc6RKtTpOqznCjp5Cui1KzhwbtuBXjppcUz3+Ounz3GXJfdXrfFRcQAtDgkSbhmnzmfH3A7C2e4liy2E7vQJIOttjKEMtLDcicHTmoyS2+c8oeU8gDROj7XG8eYHUeI836iaT7iQuEtUYEJob9DWbMWpMNMtsKgUMLaSR11BRGHcTfGtDZeWpJtbKFQJN5bHrb7I/AiMR0m1ozCVHaSFpJ5+M93ZH55a+D0v2iBSVrem7kUISpHQOUcTvVRk01kmrAkPNUWkNYeoep4x1vu4cZKZdZqK7y+krb3H1+iwtUqT7W9x34VtkurHsZVSNQfbAU7HqHgeVKmHfoJe9QTaVIal0oRQHnK1kkr96XGPb9ukJl8LAp5FK8qX8I2giwhr8Dt5IE6Nr0Egb32k/X3McUl4XW3mLN+VBVlMxMFT1OoqXR0Qhs6sh1bSLqgwIQ422lscTOln1Ahu2Qr5T5blT9/GN+x/juYc/BIDSb7GjxE5rOF1DAsmBx66WxFcCfN1ECyP6ps0tez+aCT3LIdvv8DPaX9Js2uyvLFPVU9h7czKnd+qQ1fE0m4SWpqZ4bEyM4zR36OUMGuk4SB/d2aSe9xmJcsjIYDZ1hrYd0hrxKPablPRNHN2j5BdxnV00GZFr7LA9PIEvQqKkjhruossC5/Xb6al9RpUEdStgeTiHKqGqCKpBFoCLtRxb5jCXF99DvTbGFwbv5lr/HdxlvMDp3ueZuN5hXLvFh/P/jkeGr9IIHK60fo5zVYOl9EmEYnMj0eJN0yanbRBJway6zexomuOZbUBQOzdPf22eoKdjpH26zRp1dZiUsoumeaTtDq+ojyOUiIP9eRoJkz+pfgCAY8EaptHFiRT2yyE0NtjSiryUmyAAiqUuj3pnaRsO/+b+HyVfd5Ai5K3jFo4Cz267KMJlQlxlVia41FMJgt+hqoeoocKutUs9m0Fv9elO59g+PkmE4GhzgYXhH+FG5gjGXu1Y2h0mX4u+45iL9T764CaVRPws3R2d2cwyABcyt1EQXUaUNmetGQKpMN2Oz8Tk7ijDbUieGGLM7bNu5Vk0MjQTPoZvkgj6IODpubsBwVCuhhQKx1f66G99D+PRBuVBQFbdxGnNQCTJNiq00ymMyOe54nFCVCaCBrVCnghBuFmmkYnb8QehRl5vEOoxUOwkMpjtLi09TTtVR0qJ2W0Rag5pVWcjFWds7PmnGGkqdCem8Bydff2QicQOCS9m5hey07Qtm24iSdONZw++o9ZiJxFnWyIUal6BfgGqe/LiRhhxY/AQHhaHmrvkgw3aIkFLtVktTvIvNyN+nH00SWN7PhKY6ccGQClvUz18CNX36Vxbp6EO2KkdYDuM31eqd5ye1FEikwPBPH50kKAfoEWSrDOLFD7L3gSJvkquafD6ofu4lphlPTfMb09+ikQ04AHO0k7nkUKiNyok5CbbUZ7DtQ36WRddqiRyXcp+DDiHtFusJLugzfHuLR9TeYsR4zpvVqfYt2HR2RnFj0xqToJB4iFKg2eZWH+Qu7on+MrQ57gQLuGEERvtUW5VSvQVWEfyF0juibb5sHiD11OnebL4IB4aT06f4+fSWwgE490DPJ1wuL/WY8ud5t2vvsCdF7/JbRd/i7w7gwC+NPsAr6ZNEqGO7TTodyaI9bhwfmTiO3t7tTTFzUEMnhNhiIVLQbSptmMbW1AbFMIQEUgWdJeZ8rO8vxGTdobXJDnXRrFDDLfJUDvJ9NJhHK9MzY4ZzV8u/HO+kbyPfzz7Bqe0JTqRTWKPuFjuLTDa3eJ14wg9OUVnr0uy5rtxN1hth2nShH6dqKcyNpng4OSb/NDx/8OpI/8HWwqq2YPg+4RdQbl9DID37N6iKXoQWMhwEdWTdKKAob5L3TKYbc7SKcZ2eJ/sEVpJdKli6aOUMyXk33Y3Hp5k3K1hWR0cK0BXJHOdLbJb26hGSMqKlSc/sfbHaFLyBT0LBMiwz1l1r3ldHyIhuSgnkCgczaxztBXP2p0UZZTqHgFqlwHBdn0/7uE42ynmU6j+gB2tyNaS4JEbW8hIkMnfJJPSUTb6jI5eo6+cRgoVJYLd5BqBAtuDkxS1FV7thuQmLiAUSaeTZ7QyxKeeUVhaeoCXLt3FcpTnkanXGJDACrp0GIZ+iKkqSKGwlW4y7lVY98cYccosyBCsDCONmBzcCEdwZZqxgaTlKFhBklV3BCF8XJnmVjjMbf1GbI+mKlyVJ7iUOUxkQ345zvjVDZuumyarNeij8/KJe+iWkqijJrbsM5XdwPMslpw4hqx79/KN5k8zZMzH9kGR0BHY2gAt8EkPWgxRpRcdwScCxSBIZtlRSnw3rb8Hhn+HS8PHKHYZbtf4wrk/54GmzUYuR9VUONAKWUx0OVpL8uSJB/n54B/yq8EP8o+9/4cNOcKPdFb5xfqLOMl5FNNhKznM+GAHRYlwWxrT7ibIiHpmFGPQI+W5vGTcg6gKQi3DVmoBLUiQCh3qXRup92gp/4RtO8crt53GviLorx9CKc2TCWNdf0rcJB32sAgYtFNc6HwIS9lhuVDE3FlH+ANMM0s9FQfj+RGTf3bgNcZO1zlRLlO6vca9xjYSWB7KYLqC3G6D/WMuqzKe/ed0wU/n6asVDr3+K9xUutzVP0I5lUMqKnMb17CUAZf2hlb3fJ2k67G91y7cHtIxzR7laIrLYVxH0xvk0Ako59NUnRHwHBCSttLn2FqOQImN4cc0nQc3LrDQHCbdbhNqGnpnno38iyBC7nkryVKU56jeYrwzzWx6jWYndmxprcHAt5iqxUX9L9oN1r3DqLUhbrkKk0GOkeIamjGgvDNNu13kXHqA4vUpWVNEEmZvdvgbPaCsRvwLXeWHb3yTyNFZFQXUYIOvjd1LN51CAi8fey/79NuIVI+MWma7MU3BiJ2bnwloKNDzlzjQPA1C4PVC3ud/kcgXvDhQmPBK+ID0QsrGZVpugjmxxUx3nbrUkQJulUzMvuDwTYu2E3K5K8Bzee7IaSzf4x2bcUOPftniwN4MxoVMADIgkqMsREOc4hx66LFixOC7ldTJB2loLxMMVhFCoOemCJZiZ15dOcclZ5IPbT/PTWcf+Ss3WNvMIYig1iTpaHzPSiwVTY3GmcOequLVNB4cXqG3naCfu0EukSNM6HgpEz0KGEwbXEj5zHlpIhEx1RP0LI3/k34fETCVfJ1+apFUX6Od+v9mDNuWgTMIEMLn/4SPc6MQs/Y7iRu0ggxGbQfLhbOHOqiRoGo4WM4UWmRgims0jTb5bodqIsvsyjyZwV5A2fS5bMUtrIe1KoGtknB9Xhu7wgsjLxNpFmEU8Y13fBg5EOxvr9GzbPL9NgnF5VaokWvHwXAmioOdVKtOYOqIlIKjpZn3clyxJ9FDHyOZoZobxul3WB4fQ6oBh8Mx+pHEV0c5bz1OOTfMcKWFpffohHA8mAZFMNuepVTdZnMoplsz9BCpLRAqI6urGH6KRa3GmDfDP9v+awB0L8nRclxjqjeOErVH0TsRJ099lUhmeaH5Iwwii7umvop69zr/zf4FstomX6++i99au4cXG1cwlATrubibnqZVWJL7MJQ+raBEIudSPn07j4/epGS1CbyQG3/0LBKoJErINY2mniWldUgm6/RweCVzmg+uvYJGwGvhYa74s/RUi3zNQ7e6jEUhKaeApjZR2gZz8+ugCsr7JrkzuoIeBWwkhzgX/jMm1kc5ufkwH5l2aXg+bX8YR32GB7vTdAKHSEnxudNPk3VTDESXRjZL3TMI0wYYKhtmnkPNWwx7y1w4egcbhSKSgGJvnH3r9nf23/TmIkbwNuvFEbRESLCpM5PYRsiIrpbkuLZNT6jYImKLEqdbMbN9eC2ib4T09QsowPmNQ5Qv7GM366IHglCGKEiuK7EMtKLFmZsj6wF2PcfRxjZVNUlOW0cPTdK7AyzPpW6neFf5Ij09vsaMCJCKQttJYnT6tHJZAMpamutankiNv7eSGsLuxPZp3pihp/cQYcggGKaTcglFDOJqeRMreh0lWcKo1DkRrpHutjhSje/rtZlT7KZz9ByHdstCyIjT3i5ts4Iu+uhiQNctMhnC3Y5EyIiatUC/O86qOctQxWNqsEZdppkvTfO+t6/S+vavMBFEiGiYXNhiQc7gtEfwwjrbZoLmXacA2OgnWfCGyUYKn6z8DgAz6LwdjGCLDkPRDl50iFkpoBuwmBJkFQ2rPc3hPTXD5bmT/Nv9P4YAup7DM/l7uUd7it3cLZIFid6skgx2uMUoR3oNUEIe8A7RT6Y5urvCVpSjoK6xk9zmZO8owy446nPUyg6pCwlm7A4vNGPJaS2RxrePUXG7FDcfYNG8zh/kX+TPtutMdMv0ryT5kn+UFW+IhHD5of7TfF94npRa52+GH6KjJXg9fYIHm69xJW2zq9U5IE7yx+k0ViS5bXOD91y8CnqCZHeb8e3X8YVOIhjQKt7C8VPodpPz9ePIPenyC6UzcUM1DTaLBrf6kwgZ0QviLrMZ2cFfiu17kTpDe7LixTDgwuIcRTeJlBGCHsXSFn5Rwwi6PHIpy+C1NElZoZaIP/N66g5+vv1DfNr/We5U5vFRGIRDDLQ2vVSdgtnmpw/+R5J+RBjF2bqm8Bhu9ricWCXI34TtGNCOj3+du+/4I04WrzA18RKh0QUzBoOy16PeOE6owKH2Dg3RRw0koecRegahkDy0VaNu2JyqnSIK4thlsOITKCHFnmR/N6SSmQHi0TVLI7MkVY9ccq++UIDTDYiej21qLrNFhhYf332WLyYTaI0YeAw3F9klgx8pzAxiYvxvrNhnHcmusbUH0CfFLjfTd2ArAlWP/dB6dR/ukQjzqsCNEmjdFpXMBNpWn+DKNYSfINJ7uHMS4UW0wiRWbxQluoWCQtVZZ62o0e3sI6Nus8wu/SCGGGXZ5fljfZSuQrc8i6dv8LC+wLv3PUtfT2CLLtWhEqIfYgBLms/TZzZojG3TixIU7BpLUkOzC4xWYlnmRjSJpYSMugEtW6HkDnOlkUJKBT3wuCknmAoDpIzwC3UG9Qd4S30QfzxicrCFb6hoxwf4mk2aJr859TFOGMt86fUfoxsm2RfchPwWjcYIn43OIJH47nGm82dJKF0aMm6ao3clJCMevnEWxb5BIWoQymkEClak4A2Ncs+bl/huWn8PDP8Olxw0eCu4iox0nMojJDWXq9NzICPevR2wkBnhC8d/md/YvR+FEF8KnpP7+N3ok6z5P4tE8P7Rt/noxOsMiTWGwgYyEngtjaTWR/F3iVQD2xtwevsW58QZ/HqKQEtQTq6i+UkMqdOq73VWM5J8cMPnpdvOoHqS9M4GuZGXMTsT+HgMeZtMDOIOlEv+99AOJzmceJKk1kYgCXIjmKMnqdoxozOQo+hKxHingthRCSOV7Pgi5XSRlUKa0rYk2e3y/BsJdveYskJDQiKPVCpM6BXekGVODQ6wk84CMLGzzr7MCslOXGNCDxQJayL+fDE5QAjJilnishcbxF5kkRN9FkZmWe0OULw9QKG3Ob2lYQcOISH3REucWFmmr1vfaWbhKx1WnRcJ2sc5vNGlJW3uHr6AkCqH9B4tP4eZqjKdbWGEPqoSBwBLZoOvdh1aeNRDhcOqxfTYIr1eGroKnU6edaPMmCxhKAZfHPR5vtJFl/CDbZN39Gxa6fi7tmSGof46X869E1sOkLbKYtphbK9mJSlW6YdJzHoMjsNc3PJ84LR4Y/pLAGh0GJ0uU1nM0lQlRS9+fvWrSS6v3WSnnmBKlBnO7JBotShTRORUctkM73nXGhng/FSX8r2nWSxOkt0ok9Tj99yrmIzsSZjPikOE3i4XU0doC5s7OMt0e4XeXutxs5dA81PQvIVtv0pIhJMa4tTZFfyeSqL+NoqM+PTu57iY2oc+GOAPoKjuUO+Y5K39DHfjd1NyXEKhMrAMui0LVUiiXUlgV0lldHwjvsdC2GDDHqKrKGRK8TPLDfx4plEgWPFH0M2QlL+JEkgCXfxtCRYDU0EFAhSei06xkh9DDwMCvcHd9Q5GZZOVUo91fT+mH1C1MkTOEfxoFCEiZvuv0LWSRKrKkaVrvOvNl/AJSXUV/nymR6CbmPj0bJOkF+BZ2zStKr6hcu7gKW5OH0bpBOT35sDl+m2qZFmduIeSGkvU9L2ubhOrcXOpjdIEjpZGUQa86cSNfXK+zm6+SKG+y9q+KaQUzEbD9EKfmu9z0/5hpGrTNRR03aXZTzIlMrhhmYONA5R2t2klkvR1gzfCO/AmYzuQq4botWO8s9PlAe8wE2p8DUveEcKNNB4GjVKHN/d9jWVnwNWFOdKhhicMzst91PU0/6D+NVajYf6s8j84r70P0w3o9SocyN+Jk4klfZ/ub9Hs3r1nV1JYhYClO88QJHM8NnIDgO5KCwG84Z/Cq8TSQ6H7JJI1nuHdDFSTT258lWXGebPyAB+1z1PPCXKtAMPocFzaaErc8KAbpqj3VLKOxkC3WRzbB0rAz1z4X7giyVP5jxHW22T0LR4f7zPf34ep3GT6LYeHzzlMVR9jolIkEWaYbMb25vV9x5B7ktJFa5heJ8u/XP06VqvPN4+e4dp0m0JnlOkdB1SFSAiK1W30YB454pEcGRCta5j0QIAgYlqpcWz2dbKpXVbDSabdDfo1k2ytw9VJl2Vlh0ZSo7siiSIV1/DQZEgkBFNqk6p0sNQ+i34c5E41YgJneieio6YIzXjfjew0AChbWT618gZj3VhildD2AF0ugx5FBKrDqFvmXP4wz6dmidR4b25nx0ju7eHtYJqGFf9bkyNsJxoMdaY4un0/5dOPsHhgGrtSxthdIqetMAgdTm1fQ0bw3JG7qSUzeKaJbIKFx1LnQUbac1jOBYSAtV6eY9kvYzz+Y9iU6eVvglSYL46hRZKjnVvUyTDaWSS3dhFRu8X/M7yBL8bIyA7PyI+h9aahsc6ro8dZd4Z4Yfw2vmLdjue00aVCfXqAKzyOKz1uhMMkzXgP9uQsBVSMrsv1REhKhZHuFKPbSarpgJbT40L6ECfq1zm6scJvTn0fjtLmqP08c8UUIgpJyyZrcpgx0yWQKt1WhWNrbY721liWo2hqjYZd5/FKgYHikVJeY+VinkRjl8fsa5CMn3lX05FKEk+f4Y3UZW7af0UoQPdXaV+5xIv9WSyjx8nR8xgiIgUMG8sEUuNrpUcwugOeHrqfA/1VxhMur6UuUrKO4noF3kxYfO/mC0xuLKKN3oZ29EMk22sEhsNop0wueRYFFc2uc6s7hZBxzrAp9xMoClUrw6oWsu0XGfEqbMgCphKhhQb2xhqRjEdWlGS8v3YiUC8MWAv3owcdtqZ8TC2gkY195P4tuB7cQhEBvZRCX9rc+3wfT0Kg6RRFi0ZUpB0OE+o1hLnD/NGTJEhQF7FvMoRgIHz+rfwq7z39x6yd+WWaWyrGkI/fO8afrf8CP/HCf2Zt7SiFfS9SdEtEqkEYrRP0C/T1NELu4AsfzS+DAl4Q+5vDtRarVoiULtm1uIY04yZxZY/c8iXmFi6S73moYQhCwWr2GCQdMukt+vEjoHExT70yRVRJki3WeZA3AMnv5TLkG/H5TQQVkl6fWpBgIowB9lkjR5ouw2aVRdHGYUBG9OgOsmR0B02ZRxEhqD2kDYlvqaiWRB30kIWYNH8+cxS9H/ubY8V5UnqX1vx7ECJid7hCpHjkXY2lkoI6SNKLsuwPfLRmTLJ6Rourud/iL0/+CopUOeOpHLA2yCgNPN3E0ru0R3KIfoCIYEnEsYw/dWXPx/nUIot+YphUI8SmT5lR8pqC5reRikBRi2y4EV0xSVpus6YMk1cMIr/FQCikVgack6cJxiSZQZfOuEFqVoIQbLtp/mjs4/zPK7/IS5whUBReyx8Gs0OjPsrV8lEGwqek7yBL8Vn/qv0IAGk3IMzAo+dewZMDcjKBgk476nPYGyayEmyP7mlYv0vW3wPDv8Nlhjmm/Hh+UcX5ElnzRRZmjpDozjPVF+wEz1A8t45BwPHJbQIBKhE3whGC4B5+W/kwz27PUdRbPHPun5CLmoSuYNDSUTXJ/vprICMioXDP1nkCofNW6kF8PYGdXCdVuEU2u0Wf2Mkv5S7yU9cHVCZncU2DYu0cIl3DaE+wokT88o2PMVKNO2pmBnOgtLjb/hpaEGeOUA1qZkB218UnwCfOZGgoPPPIGZ4ZfJLfvfP7mR+LA6T+XkDrzNcxzR5IwUhDRTfyWDQQ6CSt8wgEu+ki+XaDnOMzl1nCCmM5odbZG3KsRjTVBCU1ludtmkVanoaGpB5kkUmV9UKJWlfg+HGgNtA6HLW7pP00Xb3LRneJl++7hlF4jk4+BsvdVIL9G328yiP82p2fQiHktrlnCPE5MRgCBP1Ej325deyoj9TjeoL0IMdC5yqXRr4NwPHEACOzxdbmIfJWmSjSGK8lGLX20ZcRn8fjPlR0KchGCjuDGpVCFjUIaUiL6WaDVxJ388ntr2OZUFNNMq3Y2HSNZQCMukmgqIQJj1mly6J9gEDvAJKRuQaKJlldzDHiJ4C9YmgvImh3WGsNo4uQqdFNJusuK0zgJlySSg1Vwn0bCaoZj5ene2Q6bR49+21GhraIIoWmPUNj0MMKPJ7eepAFVeH54iyKDDnJBfZXbpDq1NEUk8xex8Goukl9NmTHGFDQNAqDiMZumnF9hZPlLSb8bRaVccSepjMpN4hQGFGnaO+xnrPuCj3LIHAcDF9yrTlEqhHvC1PbZac4TalaYUovs0oeMwLleuyoW0ofhKBYbXFtqUAkYGqjzyDh/v+cUaHE/19hGAWFrXSR4V4NLYyYWZT4WsRbR1qE7hiO51K10/yvo0dw5QlCmeZU5zVqe20unWhAz0lg9poIBEp3nc/e+SjP5u+mbhgkBi6RFtcbro6meO7e9zC0FjeX0vaSmNlehzJ5jvbexx3NR0j6EjOMUWyyXqfQrLM+Os262eUwZZrH9qR8TY1qdph8s4qfzqJJFQUF169QdQdoRod9coH14WEGtQN0fAMVQcVaw4ps8v09ljZR4Fthgf6R+MyrZEBGvLaxxPONm1j6FqECb+sNlp2XqIUFkk7EchQyXzrHxfVj5CJBZHZ50X2CD97+m3zs5H/lM/4nKZMhiBKEuSF8XfLVA1dIBTYQ8pIlSNbvoRNlUESIbgbUlIje8ByOIemr1nfeWdqvEezN7YoUHT3V4Uk+wG2rN7nmz/K/+TiOCEjKkLPchuFH5ESdA2RQw/gs1aIhOpiYGZjtrvKtI+8koeyQUpf58au/SyhUPjd8jBtSZ6DOcePA3hy7nEW+bfD4Ky/xzjdt7ntTZ6w3TbLRYOnQPsZ2Y0BdTmQBhWyksP/8IoVOky/ctY+24aCHCuahKdqZLLbbR4lCTo3dxMz5CFdw7eox4pZO4NDjoHmNbH6T3mYW2w8pv50HFbZzWd60NRaaGbp7RNdwOz4fI/4ux5RNJAopvcOaMUO266EP4ueY2Y5lizeysTQ03dikZ9uEpk6qvsMPLr3KtFtGM32IBDtDe/Wr5TKT/W1eyZ/kWjq2T1oYUM6XvgMM+16aUI0BeF7JszUQfHrnXTwm8mi1JLmKZPJWH0VJ0/JtzvkfZ7rTpe8nOb6eY/9aGiQEAw0hYL73CMeaB0g6b8dnVi3TmfgCoe6Tzr5BtEdU/tvSv+KWOUYq6rKr5Ck1VfR+DArGyjc5bw6TFB0qwgd/HOlILs2d4KKb4Tdu/zilYIl3Hb+JAEa0H0CRCgcEKEgC+zpSCtpyComk1B3QtG2qiS38sEOxabI80sbsvgaKQan5PBP1Mm8lj3FVP8YH/JtMJoYxTY2E6tLv6DRGdZbTQ6wqVznec5gUHVblMKbooalzvLMcgfIqtYGOUdkjMtspRjK3QxTy7uf/HCEjFOtevpF9kUN+FRnFhsRV6pRGXH7qnt9hXyHOGDXTaQ7pl7muHaKrOUwvr/JM4V4AHo2u8lriEppi8kTlOH+QHCFR74DXRbodEgeeYPnED2C7TQ63bpDas9Ga3WCnV0QjQADHKhvoUcT/OvYhXm8+hquPMzXYZkFO0Ihs/sB7mM/OPki/p1OUVYrmgISm0HUFIhRk2yam2+bV2TQrvSyL2fjvRELj+Ma3ANCNHtWgRNR2iGwVwwipyhRfih6nHQ4RaG2EUUUmFY40B9T2Gs9MzJ6NbWwny0r5MPbZf0ivbLNSmmbh+j28ljuIaitUXp8ht++leDakPUpbmUci8cIZmns10GFnk/qoiiKz8T7vDOhaCWbbFrYfs6jthIUUkK/WUNo7FNp9pJQI4ODiTZqZDOn8Lo1QxPXAb2h0R6ZQlpLkcx1ul1f4WiLBtqaR7sagLTS6ZNUBu2GaIWJ1yq5mclRZJt0NWFH7DIsmYSiYWNnG0vPo/hoFq8rU2NuILpjzglxSQQx6LPr7UCMfS6ZxB7P0cHi4f57Hs1cY7+QIrHlCzafvbLK/1WatEN/bqnuKw26ELWzcEJ4eeh0R7XL/zkfZNhtkeqMkM7fw6nEMaNodKoU8IpAoUUAtShEFDmOpDUx1gLtXD7maHYdeREHWaYg0w6pGf280R9WyKZDmctukqK6Qlh1sI0UgamyISRa9UZrbDtv5LEoA6kgfyvHf/9z+d/MLt/4nea/FdfZTNZMk52J4VKuPkhYDdkRASq9jNLapyySvpB+P94vr4WVVTl66QkpxkTKeoTrob3My2k/T7WBMhXw3rb8Hhn+HS1oqJzINXMXlstmmkbao5YY4vL0MwKV2mvogwX/S/pBaPoslIInP1WiIt2SZgxszXKiP8avqR/hs6b0IQEtEpMZig/B929+gNNimbznMyFtMy1t8e+ZhBtmQUmuObV8iRERq/xa+hEvFF1EJ+ZP5i4THB4y036BYWEHvTPJ2KJhIrnOme44N7wSJKIO0ruMrGr0oBpY300usJw1uHTrDb+83+N3bZzlz11/woTs/y3994if5s8SH+ZrzPq6eeYBmwWOlmCEQcLC2xrDXQgksEkEGW83Q9I9yvvfzvDN1gSvWEpvZIiOtGvq4x5S2TUFpE0nQ2yGhEAx0nXlniokgDjiqYQYtqONIGzcy2R4vkez1GEQphr1YGqvobdSTFdJeippZ5aaqcHlfgFn8Fuu2heb71DNpHp7PErnjgGA6tYBjtrjRfp0791i6tcgmZS2RDzxCPQKp8NDNf4TtJ3l7/Dn00KSYrkCgsbMzSyYTd8WbapYYc2a5SogPeCKkt3ciN/qS8vAw1iAenK4lpvAVgw9uPcc0dTxf0JcWip/kqipQBz1SvYCWo4EQfFSrk++ZJPvDhGqHkeNrtDccNgIFozvJhrc3YFdzMVo+81Esu82PtJiu+yzJSVqRSyIIufmVOYbfLjDpWzRbz/Loa19GTXlkkhW8XhI/O8J1dZGp9ja+Z/C24vBiMc+xwTwpOrxj60VGyxu0ijOUEocAiFobuCVYswZkVUE1M0u5NULC6fHw9kUA2u30d85K0I0DuCGlQJUIqSsM+6t0kpKddB7VD9kIR5ENFQYG6rcvcOHgETThMqLU2ZUpDskkY72YrQ38GNjMdYqE6xGNhE6x5uOaAaqvobo2ka9gERv0a9E0ZxSdupFitFfj/ks5FNfnteNNSm0DReuQG3To6TavTKZY0SYYRHdwZ+8iHdNEDXxGREQzk6G0GzdnmiyvkHEDPn3iV3nj0O1okWSoCVKYvHDn+7HcAZNvxeykl7IwQ5dUv8OiMsxwUCKUUxzsdMj09+olLJtDCzdYH52havhEocHDx58lEArtjo5nOmT7XYQQZPeG91pyha5ikx3/M35K/iq3r3+F5tJ9dInlTm5Ko0+L7F4KdSUxRITKjlFACXugFjHdLQ4U2/zNXI9CENC3VC6qNtnWfvxuhqJS54mV/8AHrv04y8pphvBJJdZYdg6xYo/zYu5ONqypeMh9YOMOjRMl51iNAg40TpIQVSbP6Tz82h9zS0mT2qstTS1cYjOxD1vxcPeGjoPkTPNtWmKIjKyjSoO3ldt4+NJF7l26Ql1mGY7WCSdXOTnzKivBFF1MxnotpmQOpRfvvavEzRZ2xx12zCKbqVFkcZ3tPJzZ2OQjW19Fkz6f8v8tf6ocJDd3g0jaTNo1vvjgDn/xrknayQKqmkAYGa4VhwgSJo+9+DUS3RqtpBnPJgxCpnt13nfxFbLdOl996DRLkwdI3GaxPBKPXDizbnDC3Gaw19To2a0HUaOACIX7Ocs91yoUk5t0d33aA4P6zQzKnMonwm16ikLlbJK+GX92vBYBggPeKhPOJoKITuDgZNsc3xsnYxdvYlYLaIHkcmqapugyUtugnsuSVl00t8uj3SV++vrfIFRQA0l5OA5MD66ukOm3aG7aFPZUHGONCrV8kdQeMIx8E0NukCgNyB45z+m7PsvMI/+d2Tv/klJnFj14gPrU92NmfoiXuv+aW7XHsE2Nlhjl2JrPkXUD3cvS3CP4bLVJzm8zpC/SC7PcPrJEKxMDIOvgBfxekUALGbMWWRRTCKAjTMbVBAwaABxfeJObTgEFyT7RQyAw7BN8PHeMpSWJGfl8cu3POaW3uDuhsq9/jKvOIqUwzUl2mdAW6MppzNCmG/pM9rpIIWjbOqEX19wvj/YIzf2IsM0H29/EjDxm69v8xsz3MRq6ZIMqmVxs85yWR2AKtgtZrqoakQwZqTZx2yoZ0efhzhmcECaVr3PjWikO5BRJ0Jb0tAhTqoxuV5jbrRI5t3PT3KSvDBBKTAxMZRdZPbmPLWMMy9wDx8oOKbXO1zL3ociIA9VNls1xVvUS72y8wSV7DVcOuLN3lDtbP0KrHPuMW9EqZQOGD9zH/IFPUOp4fOzl+D4ivUfbSzHh1xBCctf2NQIh+MjN57nH+zzChly/ygADhYhbMs9nDz1OrZdiSFbJagGjmgqdgHKugHRNDK/Fc4dcngnuYDkfX7vi5Dhz4RJeW8WymsjOFKtaiOII3u7O8m73V/iGeph2WKRpaAgh+bXln+Kfr3yDVaWCogQkU7FdaVemaH1NZ2NvbNACh9n2JmkkdH7E+CYfLT/FTTePnl9CV0ZI9H1MZwsxOEpTxEA1DFyevOMwrXwfI9KRUR87UhllAjuUSEWwmo5taqFaJerscLA9QCoCZMTR9UWUlIfpDAhDgVITECjMT9+HcQPmtrpEAv5HLo2QYHghIoq4/ZZHUauyHubJ6X2IJKHa5qhYIdf02UVhXFTp+SaHVpaQ2jgCnzlngdHcKvqqQEiBs5ngjoU1fuMrv8WXv/zveFdtja9aDzDPYfarFznaGmIg4EndIZAZBvYmj1x3CSzo64Il7xS3d038XItXOhpSCbi/9w+IeodZU2GoN8muVaO/ExNQZqrDhrU3cF5tMfCHCDpHmZA59mVWqA2y8btIF0FCPmzQVXSy/W3e/fnfBmDLEhwMx1gU06gi4onum6h2nsCpUqHIIkNoy21WtFg+L9IBYi0GnHPODp8oP83vifcggJlbS8wZ19G7I7QGRYpql9VIpyWmOBQu8pZ6iK41RiQh43modoDT6TPXXsGT+xkQIKvL9BSdL8h38NTlFt9N6++B4d/hCoIBydosDbPOrl/i7Fjc6ejezS5XCHi7N8sTypvcGVyjuLlFImfSRSNA4XNqB2XnJo7rcykzw1+XngCgXzEw9+b9/UjjCm+/8SnePvtRsmOXeVA+x+LoPhZP2kipUsKm0Rjh2tV30GsXGVUV/jL3JonqCTZGP4Hahspbt6NHBjOtN/iJO3+P2wcrvNn9KF1VEhpLbMlhdvQtvvT4J/n6w/83f3XmUb503xP8+T6Hqq1zR/sqP1z5E96x9Br//vp5flb+Au2EzasP3o2ra6zlMxxprZCKdGRkQGIIIRTO23W+mOogasd5qriDq2mMtmroYyFDg00KNGlLh7Qb0EhoWK7CkjnG1GALpMTZ7OCHLcIgLvQOMiadRBKRSDKxF1CYWpnekI6KRt1scKMoMaMEKD6XMxEybLM9lOK2pZiNlULh5Ng5OvU0Fysv08w+xQQKnfVHWTr704yEOqE6QJcKXmqR+1aOIyTM9CaRRht/c5gwNDALbRRlQDqaJGuUOC9CBBHdzCLhHgMdij69RIJ+4JD1B9zadyeFdplUuchD/iuIUHJlRJD3HG7pOiM9SSGq00nsZSwT24yHCml3iGRxGRxJ5XKO3UyHTDfPze4ITnsaP9XH7odc1GLJoZEJSDR32ZFzNKSKt5BhUNeZfmeV4tQjgKRufJNg2AR1QKo9gdaq0crWKIQdQqFyxdK5mtF4uDJP6Krs85fItarcHB1n2pnF89tIr8POap63CgqKEGzte4jFKAaNU+ICEQKloX/nrPTrKlmjT0rNUMbD0QZYokIvofDmZFxTs6oc4GZziMQXHa6b47imxbHuTUqiTkemONIb5f2ZX0MhwvL2OjTaRbI9j6VcikhAohfitEocOvcAThcKbQ8JtCKHmVyVrjTIeE1mtzL4qXFujTbZ3w0RWoNSLwabdTVLXU7gRQdxZJsp0aFYL3PUP4BUFcbKu4SKxOkG/MezS3x8/WlePBN3BB1pZBHWD9B1hvieb/01gjg4aRYzzPXWKIgmFUpIIEBwvHWObFfDlBF1K8HIzioDy0FkZtAEmAtp+gUVS8Y1nJkohEGLoozPQMG6BQIK+iI5UWWi9xKdjdtpO6sADMlhOv4GhqqSHPSoJdMohMxvncCnTKgPkxncIEhPoqZfJe1HuLrC41d/hrvWvge9PMqw3GZpn8l87hI7mkIq0LFymyxNS6a2Nxir7FAu2vSFxAxVEAKZ3c+7bvwQqV6JnixwIrLQTi3wrWSArbQJpWBi8Ry/f3EUN1DI+s3v7BUBKDLiqLrEuOiSvWpQatdJ0uXHxR+yHGZ5dPJFMlMLHD/5LV45XUQVGSxVovqL+KHJJTGKpYf0skm6mkPCH+Cmt9jM6CQHkpIb8tHNL5KWXT4TnGT5wn56wUESyiUS7Rna1hrro1MMJg8AcH3yIHa3Tbp+i6FaFdMOqEc29UGCI2vPYHl93v/q1ynUy3zhXd/Hm6ks1/efBODMhkUflc4ti+XxIueUIxwZxDV3M2yhANPRJjIRcXYzls9bx0I+NlhgrC5JVNTvPJtcW8c2VEbcHRJDa0gU+kGCRidJsaITEZE79Awi0jhUaXC1MMeNcJ2E22dgWTjNeI8nTvXRsnsNFUIfz0kQCsGRxQWsfsCHF5/iSLx1mapv005ksNweB8Pr3GU9z70PfY0D37uEM/M6290061fjrn3q6EVOOl8nVLfxul/nQPQ/iVLfoOheo+32+O/vSxHpHlZ/hKqIA8kD1suU1AVm5Ra7wSxvJPYYez9JNF1jUJ9GqPDg6/NUghjAJpwr7Dg7+HvA8OjyFhcL8f1MWjFxs5R7nlOuxh+GCX668hq392zyV+9gSBM875znDec8Fgb3MeA2ZZE3ojkuXv4c/712lbFu/B1fLV0m9G4QmUkaqQS+fTt29w3OtDzWRorMVjb5yuh9rBpZ8t5bhFYcqOIFKFKQv7XE9NYCv37c4tXDcySq8UN9fyVLoDTw/GvYSyH9wihaKstWL0NFqTEtRzmQvYPxxTdpmKO4epbfTcdATgsSbGd8pBCsMYlpxRmzoywQSo0nx+5ntFujFLURLZ9vZe7lwfp5ikGGG+p1RsVR3l0/zo3ONKoREhwM+XayxWgE0fRDvHDqCHPlGBjWpQIIeoUkIuFx1841rpSKHK0v88nt19m1CvhhDYnC6cQiP37lKwDsumnyokkeh2mpILoB81NHcZUEqvCppeDWoRleH94784qBVASVKyk0u4esF1jTInAlo6KCEHDNH+VlU0GL4md4I8ww1e+yq++SSNSBCCEFgSoxsKj1LmGpCUYjHTeZ5g+v/nt+evBHON0+l+ZvI7/vJRLhCEIKsuwSRZPUyQKwfOIuNsc/xW++c4Ynj53hckblTC2E9ASOHxLqOs10gmTXp5o/Q3dQYf/gb8ktGOtVyGRjosYCRFnls098Ly21xNBSlZGyy3kny66ukfUcXKWJJgUJDx5bvMhGVMRQIoqeiWKUKZgdsg2fRmgzIyo0SDFSq3D6bMD3PxvyHucl3NBAXDaQqsRduIXjS+ZzUyhIjna3+Ur6KB2ShO0h3J2jbGVWWRBD2I00kRpwU9kk06yzOqSy5p2inYoQQlLuG/xkacDHupssy5DWXja51h2nu7tXDpHpUo7iPVNILRH5eYL2QUpRltHkKtv+MEJxubHXBCbrNfEVCcvPMFKLAf22BXPhKJup2/Ckyv3NSwgnj5+p0I8cpA9KO2CwlxiQQE0O4asKv7rw66z10lSYpmyVyTZuMGpcxakepRNZWAR0tQ52GDKj7HDWPkqp79LzDCx/L1ufUZjqruFFB9jARdldZGVvXi79Db6b1t8Dw7/D5WlQufVOEBLNz/D8yD2MlNeZ7Gf4RfrkZI9f1X+X5XaG4ys3kfmIAJVRv83Nvsnpq2d55PoqXWOS27biuT6bl0rc/NoIgSv4tpXi5/b/S76Rv59uUnLEfwktCHhh3wM49Fj3q6wGOdqRQcMtUDA8vE6Xv7LO4ZgnCZIFDt6Kg4q+ErcYT7omG95Jzo9rmIpgiX0sjE5yY+44TvtV3nXtAj/w5iv85bO3+PWXW/y3q/+Ff1r7cx5al3BpnKPBdU52Frk6/D3UUyZrxTQz7U00bMJIIJxYuvT1Q4c5O32QL6ojXMrG1zDSqBIKB6UpGRF1ajJFuu9RTms4vYgNdYxM2EXtS4bWt/HCNp4ff59M6ozu7pBQFMb3huQKp06rGv+8p3bZSGww05nBCgzWxxbZTHfoJ9LYnQa2P0DIiMfGztHaKBCpGjfkt5lNrbEUmdypZ1EUjVAdkEiWsYfmmeo6/KsvCN4n0ggl4mL1/UghEYkQVauhGymEELyqeJSEB26CNOAoAmk1AFhUYESF8wePc/flS7zc+SecGcTvYr4A492ImhNyUuSw8NimSBSqGOkdTClJScn46Bp6X9JcSdFI+aRqi4SskOhOw+AjGJHDkjNGhRQJL8AzVtgXzuAqYIcOBz90i37/dl5VvoeMcx+XZwJemtgHSojTncbaXML0egTDCXxV53I+BnRPbC8jmyoNNQYl8xNTWFoKtxfL6TZqH+bJ0SxSSvTiHE/NvZfQFyipbTb0UfL1JhLQVInXNhhLaagiST1yOaDG40K6jsq1fBx801cwe5B+scerjx5HiUI+sPFNsqJDJA3eV9nGVPqk6JDYa4/eSxhkex6NIZ2urVKseRjNJFH7gyQ7BYaqHi46k8ouQfU6kVQILJ9QCamU4qzEaNFH19pMdOJs9T0XQtRoklAOI6XgaHCJ4VqDMIjZUbvrEmqSXFunp9f5sfnXOHE5noOYdx9nd+ghxtafYnrjFmggpGRrosRcf5UCdfrRML96xOCf3gUHql0EYApJw0qQaMeysO38MFVF5YHKNSYebqOlY1Of8V2MWoUUNpGMMI0mmlPDUWNG83gwh4x0ms4KkQwY84aw6w1kGFHsNOkmLOY6t3hu52EadpWBPYxdu8mXrGEeX3kC2wvxFIM3Jr/Gn9z5b7iRfh5dBGyOB+wYC9hSoEkNade5Mn6QqaU1sjs1bo0OETLAQsPtbuBbNc4f2UIDQmsdce82rY8FXDFiR9sOC0wPlmkU5rjSLBEX3UlAEFoOt6UaHDJCdEXy2r6jkE0yGa1iEGDme+iaj/Nthfq1u+lFDtsTfRYf/gnk2DpNmeWaatAdTTNXrfHwjo+r6mBW2EjE8kgnSJIKO3yy8VWKdpX/WvmnXO2MoysbnO4cRfNX6TkGEeBGksWpA9jbFb704DpOdws3maHha7S6WRLOCZSwRzKI+PhX/4J8s8bnxXtZL00iAdlK8LI7wrnRET537GH0KORM9XXytBgnPkuFhkt/RnClP0xpokEh2yCPy0deM2jZfxtwRmieTsIKsAZtBmZMIKoipLNhkt81sAdbOFMNECHHdxrMO9OkmzFJICJJrlqh5zi8mRrH80ZACoR0CQ2Tai5DqV7lrp0VfsP4bV4zTyCikKPBdT6k/w1HP7XIzys/xxHrPIPdBKvPn6Ly1C/x6/0qtRuPErgJrJErDE2CSgIR3MDrrXLX89/CsHzW7RKFZhUxdQVzUKRuDzHwE0yZ8zyhXmRUdtn1Z6nvE6zIfXxFfx+O0iXoZ4iiLrYakQ1iwHa0V0WPNHy3Qc+0yHZdmnvNJLYSMwD8xNGHedddGr94wubtRz7F4iP/gaif53y3ybVOj5qMg725SJAVXT4fHeVnj72Hrw/N8lbiKZARZTtEhlu46Tlk4l1IofDJGxFfGP8AXzn0MJdL00ih8L8n3ofBNmPqMgC7UcR4kGVsNX72B26e5zPvej8yjIHjbb0qOfE09Y0HMH2f3Nz3QvIAdTdLgIqNzm3Zd3KkGXdP1KMz3DAk9MeYc9oEwRZZ32OdKVRtgJAhx7jJqns75cQY4x0PU4QYjR5fGXkIHZ/PrDzCmJxCVWxW7AG9ahM9F3LX0Dq7/TVuJQRHbI3W8Kd5ezYLMmLo6Q4H5Aq7bYP9/iITnV1eHT1OOW0wNawRCZX1Pfn/aGadmc1YIXHVKKCJiCEcZnyBAC6MHcfTUxi6hQS+MGRQ3euYrngd3LkczWUbURY06yn6OtAJ+ZT6HO8unMPO6LxoB3w7GgEvxZP6Pr6pPownAmy7SdasoqHQFH2G8h+k1w4oJSb5wCDFvwv+FU9UX+Fr2ZMMOjrOUkQjs4lixMDG6g9oKONUyaIFfd48ephpeYt3dZ5nLZfnf58+w9W0wovjOWzXp2cotBydVGOY+UOfYj0xR0kt8LdL1SMymR18zyCrR3zbvovPGvfQ77YZm6kTKYInSwZISaE7gRpU6aezbJUK3HXzApvBnrS7m0QxKzRyaTLNECFhTmxTUUfRxs/wyS+c5/FrEWP7N3ht605YMQlKEvXTP8nzj/0Mn5t7GE/VuXBwlJ6qMz1YZPfSh1DNBnLnDUKhsh7m0V2d8ydOcezqmyyWIIjSvOHERMTM4n3YODij11iRPqFdI1JctMphut00ShjCQNIYxOcvk473bNibJeu0GbZ2kIBi7LBkxkqXRDd+743WdZb2H8P0fJqOjggkw0GBS9EBDnXqCNXAzVdRI5dfuPdX+NDBr2BUFMKsRCsrXNt3kCFZQ48CPte4h4QMaZq3sEdMVMXFbR9jR5gk8BkqXCanxtd2NnWM4XabXTeBsQcMq9PDlKI6vtxHhQ7UbrIsY8XRB4r38t20/h4Y/h0uS5hsp5ZIdibpGhaXM4fZv3yNZ5lhk4ifav05WdFjpZPlg2+d5df+9JcwCEj1G1SsLC9Mn+Dcvkkuze1jMhFL5DaTdyAk9No6jhD84fhH+JXJH6WcyhC6He69+BZvTJ6gxA4fVV9m1HVJCJc3c7djGC6V3AWqapeX9Mt89b1PsGDso8uAxnis416uvRNN6XLpsIPjZ/lGymZ5+r0MVbZI1P+A8coFnE4ZJeqRFCpVmcLyItRWGsMM0Or7+VT4GaRQ+eo7H6NjGWwPxQYxDEJUMwZtq0mTfgjIiO1EifzAZaovadeHWO9PUxINyjKL6Qd4wwFOmGJbxPSh0dAY316gr/RQeikMI8RSXX7yud+h6ErU0EKGGl62T6eRBSDXUtm0V5lqT/H9lZBqYUDV6YBq42o6oaKQFi0c3cVfsJC6QbedZXzsVSpIpLR5oHAfkdrHNQIK0TbNdIozxnuYnDpHt3yQNzN3oWs9hICO3cXXoEPADQljA4uVXok0PXQh6NsehutyThlFTKhEqsq7r1bwpU1TOxO/a0sh0wBflxRScS3can8fgZfETG0Rqn2SyRqj6SrcMkAKmgmffF2hy0u0Mtexg2GqYx9jK1FgV2Zx+iH+5IDDLRsj0hkeHcHKepzhKn98+T/yscQqw90S37ptFYQk7CcRUifdOs/wXtamZXgMDSIO7Aqcqk81SiER7AzFclzRqzDQVBqpNNupFE0ZMmE6NFMF6vUsiUyNq4lZRHeXjpakZgwjI4WhdCwB6UQeR4iDsp5pk63G976cGuLATptKNseTxx/HCVyenH6ML08+CsCfjj/BD838e8rpFIlBHyEl60oXkQogGVJOJ1AjKNXqSJKYrSMkeyHLYpiD6hp3vhDXoCTCDunApZGIJdRj+7vYyoCZZgxWjV5IWqbpaCFtxeGh5huMdqdYCmMweu3IT6HoY+TaBltWmebgYSbLXTqmwv71a1iNLvtvfR2AgcxSGDQpF4eZ6q9RoE5P6lxPhVzMpVE6MdjUVUlLc9CjBplWnRu5LH3R5YS4xJhe46HsRSzPxel3MVp1kqFOP/JZtk5hD698xyYVwzRGehO1v0snrDDmDZFvKTSFRbHTYJBM8EjjRfTIYzXTZWDmcBp1Tm++g9tbJRQJHVXh3MTTKM4sl2VMEqRoczX6ENkolk/Nh1k83SC7U8Ns9NnJF3GVCgLBzfQ2yqDHcH0BTwSsjLyIHHVBhawmaAuFEJ2DYoMf+sE5LjVHyVrduA4nO0Rv31EsQ9AXTT535gH6kwH5TUFOVijLDHcffBkEWBcVDj6d5+KFJyi/9X4SmycxTJ/dnCQAzLzkvfNv8YO3WgRC4KXPsG7GmfVkGDt8r+Xx78d+g7nGBr9s3QPAB9w+Aok0BijAQmESNfQY2X6T9742wkigxA0x3HWQCge3X0Fze4SGiT2o88lvfhO79STJxm8jdUEvNLi+NsZGKcPzzhkeWz1LXoY8rF5GEZJ+oJGv+XRERCBUDszGksBKkODMZY+FERMvXaQzNUdf0yFMIKSkvDuEIGI420Ld6lFoRji9FrsvfwAtUWVsW6NsFDldvUHfstA8l2Knz2BoHxXvDhJDExheLF1HUVk8FGcrzyy+wBup47yUuBOHHn966IO8g6fpdRz+uv39/Ofq77H01DjtlWP0JCBBDRJ0K/soZHaQW++HMEVSh4awyPRaqIbkWnGOoXqVzswKAoV26jhuVwclIKk2UYBNw6aQ3mCpcRunNmKfaBcXSUQ2XmSSo8lA6IyHIXd3fEy3x+tH4wzj8OIrABxprtPUXZxeG1Pv8HY24LNTKj93OstTu1+nU9lAC4vUjDh7Oi5C2tLm2eg0XTUmi1pSYHhtji7GpFhg3UY7dT92f4Efqd7Fa6n7sIM+m9khRBTxmdGP4Mkhbtfm6fgmfqiQbHcouWU2U1Pooc/P/+nvk0kfjW2M2ELRztJcjggMm2DkayjJEZQ96ftolEcR8L7sIfLNXeidAHObKd1m2goRUZvh+pusMYXsSvYpy2RFm2vBfdQtk0w7BtDZZpvXc7fRV2zWE18nsac8WLJ0JnZ3qGsWw1aXD7p/w//cb5BSBUfIs1uYRqfFgVd3+acLX0NKjU+sxiO03ijewfqUpDcV+96wHQfWE/llRGIASN5KjBJJmxRJpvbK4beyFpFqYik6oXkX9dyn6Cbvom8m8IMWv//BT+AbOu7XRngtPE6UiG3Pe5XXOTd7ipFiiid6OpsiSW/5x9mJbLr6ImGoowUS92ICTe3RULrkdZ8oUMjlBbfJIoGM+LHJX+XmaBq3q3PMXebpzftJT86DkqEz2OW57DQ1srSHdTatcd7pf5MfSP4W/+rNp7l/4SJ9Ff5gv8k//9e/yBcefhcd1SAUsUpmc+R+tEjFVOP4p5VwyGR2aHcKaCosdcfjPRpeID01YMfexyVDBQHpwQhK2MMa9GndD8n+gMcvvQnAVNdAiJB1K40eRZwUt9gn1nC1J7DP/DA3vu9X+dOfTaDokm+tPohVjvAnJX7uMo/IAnP9a1SnRvn86WPsX1+g+Rcn6FcOkN33FENmHS3yuWibqM5Rfu/xj2AYDqvppwA4XDuEdA28cIQbndup5leoKipDyQpGeouJ5mH6kYHd79O+PkzQVzDVkJrYBkJE5FB0dpFhAsWooljbrKkJJKC3Yj/SSThU/sH7SXc9mo7C9uJzHAzHeFEewdlrMhhYVWY7C0ymNnnfzDMcfvx13NkIbVuQ99tMRNv8Zv99rGSPQhhwfGuOzEQGpGDHP0YjnUIVkqbSw1CuEUiVU8Vneabw+ywICyUCJZJUpwrYqWFAR/ZXGaghC1EPQ0LpcIrvpvX3wPDvcGnlAcJqMrF7muU9GYuzXufbODxkNLhLPcsg0mnXLZLVFpcPHmZKrbOeGifrtvjCgQf5wsOPEU4Pt2AAAQAASURBVOgJRtx1QhTK9nGQ0HA19rt9kJLioE1RaTLoqdx77QIDw+TN3EGOqjcotVappbLc1OKsy3rpBufGx2iW7mREFpgfMvhr81XCIKJXn2CzeydDmTeo5HRa4gTfmJim7wxz99nniRCUxRIIGKCTRqFGAtMNMfWA+6wkg/okk6mL3Nl+ju3Re9ktjLE8Ed+7Nuiim7Hj2bEEG6UpHnrlLVqJadL9FUqyQKc9xEX/BEXRpBnGTT1ysy6GUaC8V+gd9RxEGDtt1yuAozMtV9hfuk4mkAgEoZekl4no9TKoUnBosUfP8PBUD6udI0JHG7RACF7ddxeeapA1mgxcncFGiNQSuM08s5k4qH5p4mmSRgqpRHQim7EruyAEu/fYKIkejZvvBFclI6sAbKkCBLxEAymhFOj0hGA6UunLiJ7Zp1it0taybE9m2be5zqnyLnmlypV0FVVEhAOoGfG4DE+PmazF9mFC38ZI7RBqXcbGruOFOk/dfIhIQMcJKLQlA9XGtcu8kb1GOTVNoGhUozSJXoi3L0JvlnmkdYaJAxtgjjLeWeCBxnk+tfgKn06EJJ0Y5Oz2kkgtQTvwuOPyOQCmmtvcs+vRb02jtASDrkE1V2TME6iAaFfpGTqKdx6n32E36jKKylClzm5zBCfT4zea76YX9GhqaVa0WDqZsMcRDHCBo3KdSAh8f4Jip42naXzima9QaDX5bx//QbpKEkWJuJw9yEJuBoDPZR7jyenH+JvD78DxPXQ/YkUf4E3H0pbtVJpKTme4uwF4ZDtxFu2sNseQbPL2bPw90611xhs9KokeRqgzth2SDAccqsfjI94e08gFsKXrrBhTHOsucqi+QskeECgaO4kdNFXH9lQW1GX86BRm+tP41iynbza479ttRtoGEkmXBHm/jVQUjnSXKdAgFBKzu8T+8jqbQYGeIZC6Qk8YGOjs295ksVBgSrtAWnpUyfJu+SpP7LyC628jpCQZaPSlIKncgTJ8CxmpqD7oTpXMzMuMbdXYVXYZ84ZQAwMhBLl2fB5quSFmeiuEWgeEghPBFafOjULckrslwYwk1fpd7ISxixn11wkijTzxM71iDKEFAfWuhd+Nn7/nxCywGd2Lsb2KLiW95AoNY4NorwnxrCM5ZxloWpOU6DN4+wJNz2ImXQcEXiaPcAckFt7mbOk4dSvP+8Ivcz3IcFy5xSZD2IkOhGAsCIz1S5Ryq8x3s/hvHMTuhbzu3olUBP+i+BvceecfsTnx3zF7b9BLvYs18xQRAjvak65GEvGaxidvPMsFMYsnk5yUi0gpSAUhrqrzxuETjOy8hqpdJ9XTGV+Js0BNK5ZF3ZrZhxyEoBlIAWvjVRLNv8Tsn+Py8Rj4Pz/ns6YeIkThIwsvkFFs7lbnCaXgjfoU5iCitxGSlynydh9dGbC0lscKQmpJk0GhiEwUaBSKGG5MpHR3bJJKHT+fRviSFVVSzx+htbafoDNMopHA8iRHq6vsDg1h9F30MCRXvB2qG1yoP0mm4xJqcUZy8cAM5VwesanwQwf/G818ilBoDITN/+39vyy88iPcaLyHmmUCIaqeohcqDPWLqJGFgsBymuyYMemTN3rsyDRaIQYO88V9ZNtNrqYm6Zt9PP0g/Rb4iosTxffUGovld+dujmJ3d5ChSqJ0nTCCKBA4Wo8VZ5SuEFhBLEGrTvr0jDgr11YdhoI6xeAKH7zxHN935Rs89NrrHNm6CsCvffh78U4Mk/SKNMyQHi4ZofJj/r/ExSAWMsP+8r2kWhETu6ugZammRwm0PFr3GWrqCm9ljnDX9gKPXT2LFIKmmuOr6scZUpr4vk6km1Ra85iRz1j6Pp6Y/Ac8sv9HOZJ7N77MYijzfLs3g1Ze5OL4EFZuiSiTo5WJgcWmuUPD+ktGmg9wsLlNx9tACMn9+XmGtbjOtDP4HT7t/TJaAo7qNwhReMWJyY0ci6gSSs0agaLxmnGI/cECFgY+OxxsxUTxosxxoT7KXcZZ7u39b7ZEyCFLYbg/ippvcPHwFMev3OKDiy9yfGWRlcIIW4lRsvu7rNlx4z3Ti8F0KbdJMDmKLULecmbxonhovBEFoMDOHmjC79FPxORoL/f99OwUdr/FWyOH+Oyj72fyXI21MRWhCApGmxllmyvOAXLNkNs8jR8VX0UlorP7PTyv+0QS2BVcPT+NyS4dMSCnKCAkk8NLRGR4euWdSBcKmxMIF44qy7y5cwoxdQlFG6Uy2OKc2qIqc1w5MENCdnDOp/G6SeaOPMmJjQV+96VV3rXSxvIG/O/v+SSfufdxvn0sRTh4Ac9Is9LrMKbFigS3ILDtDsZOnE2dHuxiqIJHc08ReoId+S6WfYWUIrFCCxEFWL0m9sMVrvzgGC/lbkNKGPditdXsG7Fvvke5xvhgh4J3B76U3NE2edwOWRqohA2NRMcjGJGsp64xjUpiTuEP732QdiLBPW99Gyt/H3pyh+L+c5zNP8AIHpua5IUhl/zmT/H8/pdJtr9Jw9yEyjHcugMI/NVjbPfi7GopuU125DJJL0eoGjjdLhvuDKIfkrV6uM4uo/T4114VU3XZcYvY9hKKuU0Xg4aTxNwzv7tjk+y/L0dqENFyFNzaKoWdMi8EJ/GDuNFdKOqkzZjouHzuMJrt0fhHIYMTETKApNLiC+YjJG0Fo1XD2lTxZm9iNqao+5LmeOx8rnbymMo1luQMz+wk2TRqnM/H2Wy7H9KcUJFOHI+lqqv0dY0l6TOBws7y3mDk75L198Dw73BFOY0hq4YmTW4NlXBaNc5ad3BAKhxOXqWUHbDVTFNo9VmdeJRq/ggzSp2eUDhZW2HFmWapELOdhX4V1xJ0hmcAqA80spFP0a8z1+/hKAFuz6LYb+G4fV4cuwNT+hTCBVbyJTaI0/4jegTBIn9xaJzj7Twf8+5jONDZjWa4dOmdREaZVO51AL496rJbeBdD2xu8JM8QbL+HdXsbRxp0BCQR1MIMlhsxmdkmKQWv+SmEkLyv+02UsMHTD32QXjLNQOmRblexFYWWGuGqgrajsy18PD1JKzzLUJQiQGNdTJGhQy+IZTWJUohR1KgrHXb1HJpv0LFjg9rzhhnkbCYHZbzSKAkEvpQEbpLI9Bh4aYxQ593n6ggpWUkucza9H6EEDHViluf5qTux/QGOMWBns4SrqZj+NH1RoKTsoBJwMXR5vbcMwF21Oxl9O0SNfLpTL0Jbo98eZXpbkgvjYOToIDY2L8vYYP3tQUxHPdrGLoHukWv5RJbKVjbL/fOvEtaXuCOVZjd1E93Q0doDtkpxXSrKEhUc+tLB7WbRE7uIdJnh4SXeKB+m21bp2RIjMunsP42jAmGAUmnT2ms0sl030UIJEyHt9gIfrD2CPdjgqvYe0kGHHWWaUsXj0d4iDwfxfjnbSeKbEt83kZ6CKkPohszuDvDDCfqRjVvVqOZHeddODKJFdYl2wsHsbPOPP/sbrIo2mhDcsdjgZu8gQoFJ9RbFoE5R19k18ggg8kfQxU08xeRgtEHP0lDqBV47fIrVsZO41hg3DtyBtdek4990f5c///Zv8h8ufg6Ad59fZnr9Bdp2FqRk2Guw7Sh092uEUiHSM2wVx1FFE0d9lrS7RDuhsmwVaXkWN5NxRjoVrZJr+TSsNqOezrGbbbKuStFtoYc+dTsODrf8Ef7c+FEAHu1/hZ7ao2Ml+MbdBaI9dV8tWKGgVtjhcywNB5huh/t7sK8d4mkRTS2FLeIgbF9vlSJx192Z7R0enj+PHOSopiEyVfpSxwwUDpYrdC2LGWMHKQV/Fn2MRWuC/7z639lNLMRnBhuBy4GBg52fp1aZY3d3DjO7jlO6zHClwZoVA8NbyTkywkU0YuC2PTrDwc4CVS0OOjwrx6XZX+J0Pq572wQKvkawNUUzFEQh3B69Ca5kRI8Jm/mhfRy7dYPlxDAtNw4MO9kYAExXzpAMfGi36TsbFJX4nkUXJvIRG6pDZq+rrnzlBXRdkFHiawusBEEY4KkGi5NHmA6WGG5ssaF4jIkabvwo0bYFiieQ3TKl9jiONLmZ3EVR4Jo3wYSlsbt0O51ujunxKxyofRWEQX/yENVkHs2vABLVDKlupsn3m4hIcjM8Qla5SuSWyPgGV0amcQ0TvXIe31xnuB/xyddiAH1+8naE22c7kUMddEEIbk4NeHnqLGNWlkhJcW28hUQyumvzjaF7uGP4IqWoztBumRNikXk5xW85H+dqc5jQVTgw+ijdMIcQoK1GvF46hOPasEe4dYZHmPOvo1oBVAX5QZ+MWkBXFS4aAYH/Ior5a4ze/fsI4PaFCsl+h3YqhefcxtnT/4aVzG10OvF8teSgh9Tj87ZZHOPLDzzKP/yhX6KeNNCiiP8c/msSYZ98xSEV7SfR2ablaEiIa+EDk39gpQGBUOJs19JILKsumTXwIdBj67jhjDDa2aWyfg/VdBdFZnC7aZJRn79d6bE1+tUZwsjgFyZ/gdruDM7wNbpmDR9JVmmyYKR50c7xthl/75lwnoUxwaF1l02jQCaq0BVVbtPexh2kmA+H2RqJ/WwrkeKLQzpGaNGXOnWlyx9R4vnoNv4ZIPQqENGWNiOVOiPVTXTSXJ0yEL6P2T/L28N/SltXeLiucaSyzOn5iyAEP3n6Q3ioGLqPny0y6NeYTZ3kE8Y0XaPI1crz/Jb9+0RyHFUssjMviYDQDhl3y3QLFs1MBiOE3xz7DM8d/CY31AtYO310LqMENsqVDAfMeIalisIfVxR2Ny0OBWssyWmW8zERkS0rqG6eUb8B/YBX03eTkm3OJb/MWu4cY6GFdIpUUg7Pbs9xpTnNj699hkbyD3AUhZS00ewG5+6ZY3V8mB+59CX0cp9L+w6iE3Cv1WbRH0dEEckgtiMZs4V+cowxaZDyT9MLDgLQlB6GqVIPY6nhxWGBZ+5DhB1CLUc9ncT0Wnz7tf+LD018Cc9W+cRffh7R8HhIfZub1gj53RUyoUATXY5pt7jHepu8s8BSc4RMuME7/Tf44f1v4OzG/lnXbVKjLi/lbhAhySSOcvjbX8O6ENv2w+YqkVR4ztiHZmXwog6phWfpZFTOm6c43XiTqK2wcmEGO7PFyMgiLbqcrvT4vV/+OT750suMVSOeP5ng17/vvXTVTRYim+m9mbTGaBwX0IntZeAXuF/c4mBmmcWdKb7GFp4UzBgR6UF8Tdp0iKb7hCLNq/vvpB2YDMkIKeHSZIatQY57lSsEZ09gyzRXWnVem7mKabZZrU5wKojLkYIRST3dok7A8U2Vs6ce4NjiPJNVk3AwSvH4FxFOnSUtx2NeA1X0WDV/FyE9fFWhp7vcKlzBbc7xX7oKrwy/wq67wKXqGCgu46kNUjOvAhDqFprnE0oL0QsYsnd5ZyriX/TL/GjqJynUfcJOljFzHsWMSZ+14jCio2B3e2yMjuF0XiPnd2k5glpqEu/cn1BpZ5BaDERd0cO2BoSRgvmSz9B/0uls5eh8b8iJk8/SLGoU1ABVSLKRBG6Sze6SqJ8gvb1A/W9ns7o6hrjJWnSAmhn70bf2SCunF5JyGgQcQIZd0jsrDJwE60JgJkJSD353Qa3vrqv9/7eVMBm/B1pmn630MNalNr6i8x+EjaLskNZCtuoJHMZZ2P9hSq0T7O+OkpDgWWkUGVLrxSzacH+Aawiyo2fpWUXcZhwIHOouc1QsA9BtF9geG2Nic4vtzDBbWoFxq85qvkSiHSB9nVEVMo0GP/aVJpe8YZK+4P5bASPWCkFoUM1f56o3i93tcXGqQaQVyb+9G2egWnexk44oBA5NETO4VTGB4UsUucbXRiSibhCGKkNWm0TjL9ksjXN931GE22OsVsZRBLuGQiKIGZbPv/PDAEj/Mn0lzlLl1T6OcAm8ePtGGSiObuJFK8wnZsgNerTiZGJcxJw2Ge+2UK1hsgi2Ip/QTaDpPQYyBYMO+W6ILWE5ucT5wnlsP0FGOUAoBeeTI9y3dZmhSotauUgkBEJNEyR0gprGlL3BcnWasojB6HiYIXnvv2Iyv4VVWCa4tI/u5AbTuwHpPSB4T+skycjimtBJqz5VVSKkZNQzsa04wDYHBtFonFW4d/Ucsr2FHUg+3b+byFbQmwPWpu8gEdqk5CZbsgQSWq1hhCIpHfkmqhry0qBNym/TcAIm3CxqGNDPDyEVlcN2mRpxpkvudUkzsgEV9waz7gSF6u28Vdnr4jX4h6xlhyhtznBCFmgGCs9NfBVhN9H7GhtOlqRw6UQGM+sriESJQBeEfY1+JsU7axtxIFOZxz7usfKhQ2wNT3BFjwPCAzWbp8Q7kBGcKV7GCF0m1Rw1PbO3fx10cZ2+MNgnV+kmBPX2GNdHp1mb+ghXjvxDtks/QG38GKlwwFTyLE+3f5xa5XsB6PeGeOLKKQC200Oc7NxgJ52iedDEWHmCMNXHiyaQUiGlfgFb3qJSMLCSHZ7cPERbS6Hi0cr0ybb6tNUmU4Ekqfqk2jHiMCIfpx8D7V69xLn8LGtmiRljjQpdsm2bd51z0KKHALjjxmN8q51liA/RGP9p3rj7FwENBjO0LJW+ahPuSaKO7ElJARJuHz2MyHY0enaIm9Dw0RCu4HglbiZxIuhSDmapyv38yNGfJxe0+AHlBiBx1CS2AmVDknbW+YuF9/Nfrv9jzPQ6VneCZLXBQqqCLS26uVhNMOxuYvoe22MHmO6v0dkDqT17iAeuFRlTt/FVwTwKEwOT0zOXSZOi5UPJj2vhZkgj7TrV/DRHF+a5r/8y31N+kpFKmXo+QbTXVkfRDpLcWkRKheNBbMsS31ZwkpKhPfPpI8hvXScxo7HdyyAVFVVR6OkG1w+cxHUcPiz+imfXH+CQEtdeKntjN4x5gafHgHR6a4Yz/jS9bLz/17wiH2gPOOu9ztKt0ygCjujrTDdfIJxKcXliFrvbIjXTo5BrUXUcAkUw3d7mhfAwulLmaKeEEyrMj05zdPEGdd+hnu2xb+Z7GbrnJxmuVbA1lY6nENgJWnqPDWeDV49uM9ncz0/kdigk5uhFy/RSPnX/DvqKzbtnnqU6VKJULjMr13kzOshZ5TivV6fIJ7rses/Rj+LnpRghX5+9C5nIIoRCW1QJk1n6uyn0tEJuUGMinKFv60yrGstaSL1/lUHNIj35FqHic3KpAUCoKKheBSEDFr0mXrQHzPdmpbmKyusTJ/nMez+MiCI++q1bZJQaI+o2hxpl1osGl4eWSDSu4KomrmGRm15k8p4/IidiG6fZDULfxMwtYIo+BTPex6oT24cdo8B4s8Zdqy9QS3eRRGzpp/jbFSqQyO7SWj1Ja6xEz0nxVPB+jGSFKD9PMjIZ8ausGQkq0f3Mi1j6eh8VFsZhcheaOBhUcA2X2/x5TLPDaXOV+t44lKG+x5uzY6zn6piRxVeky19h8X3cJJ96C3P4KUBhS6Y5vBoHjzdLB7g+YVDcaiGkz+vZeMbmHY0sY+xw1/Y1cAOkGqIR0bctMtl40LmUkkU75OPS439oOse1CYJoBF90Ob58k3ImwUy9goLESQzTzGSwOh0qRp3dYIwX9V2q9RRa8iZC28f+0oCMBmO6RIvupBcpvNQ2SEVdLnOA9VxEuu+huiFKZDBOE6Xh8aXxJ5BS0NW/yZOpmCALJ++gZ+ooqDy1OcVfDL+bx/2v0Df/J1EUzzBM2IJ/+Y6f5LXJOZ47Oo2ihrxPeZWidLmuTJFvVdHQMfERPYE/s0EegYwsXHkMSY2+8Eip4HmCCMmzp2f4iPpN/pP8aU5351kaGUHzm7jSwsp1WblnhH5kIIBPh08xrzUpDc6RGUhMtcoM2/yTwWW+qfwXXjR/kp/S/grDiEjrLtNRDD7aisvoSI7P2wHzTkhi6HZMz8ffiueqppIDhoImFzbvIzMRlxQUOjXWD8RZ8iMrN1G8AeFSRK8yx8zMecpGlTFPRwDTlWE+9WKD3/vln8fC55VDCgPFZCd3B3oQkSrW8XyNZj6CnoLm2fy08if0I5O/mXwffTW+ztvtkHQ/9j2Zoy06nRyFbpKUHlL1E0wodYgstnI9Xkqe4E7lBtlTD+P5fVZlCpH6IsJL8on5n+SOve7y7rAglWjxun6D//exd9JKZfnE019Ds+7FzK5glS4DMJdb4rCrkZ74S4Ro0El9gsroL/C+pQ8wpkaoUuVo5Thto83TI6/ynPE2yYP/kS+rCzTtXdA7eKZFz5DsFkcRg5AxZ5W7k32eSP8eiojItHzs2hQ1p4xQ4w60K7kR6EekewM6jsbm0iUyok3HUlgq7Ufp1/m/Ln4JxcmDHJBotRkIh7IocWv2DGpHkLyUgi8VSCTr5A7O83DpFWqKTUIcJjOhowhIVI8xcfMNQiEJEIxGWwjh0bfyKHqTzOYxlszYhyS7AVm9ihftRzaX0CvrdJwcFdXg4miaJ2/d4rtp/T0w/DtcSr/FVO85rhzeQmwM6HU0Hg3m2YfKVBAzsgu9PJWRR9H8Br56nWRviFlf5WJmgv2dRaJyQLrTp+CGuKbK5tQ3aWbnsLfjYPJk4zr7cn8NgNcZoZdIoK22MV8s82nx88ykLXbSeUZ3ewyak0yoOruJW6wMa8ynt3juxlfh7b8iWvko+cpt3B1dpB6U+PCF5+mkzpDcWGGFIab7S0hp0uueohes09hjf2vETrAbneN5uwyRSqtRwrTblAYvYvU2ePXgKYx2hBGG2Iqgpik8vhUbu5v7D2C4fVR/g03tTSyp8w4llmKZfswUV3WboaFlDBa5ntjHZG+XSk5DRCD9JDKlM9ZwcWSeEgrl0CX0kthqG4RBprNGJAAFQlXiai4z1WEay2uUXRtP6Dy0fp659W1cOUfn4Cm6w10iy6JfNZkprLDmThJoCkj4BQnCznMkHxFFCtXF+1iYiEVGakonDFXUKI+QGmWSTIZdtrSAlNIn7xXoal1EpFIRecIRh2MNl8wgiUCy6r7A6O4Zcm6ZwFfoGg7DQYnRqE3LPQSRSb0TkwWlkSs0axPIrk3Wb1BNe0y405yu7OIsXUXxXYJMga1khCpBH96rnxqEaIktmmqH1ObHybTioD6SY2x2f4iq8mHCxAail6bu7NBIl9FDhfVsgiBl0JQWdvsmip1D68dZ3aTjMtuR7BghhB76TIONwhTPPvRu3tSLtEPJaanwvhvfot7OUkjFjVyeOXyR/swzALS9Bh25jCEChinTdVQ+V7gHewBSy9J1hjl3cIsbI3C8sYmiBDw6+TN8LPevsfE4Oy1ZGPpfOIOI7dQ0gwhayRRJcTuTa+8gNFukOpfw5TS6solAUs6bDCubbPXThBkHXW2zlTdRpSTd8znudjDUkEL7b+cfSsTeROJeGNHKd7jk7Kdg3ASlj+E7SCSRrgI6XXUJJ9HkZmqdleSX2b/weYSM0K2P07RiQNYoZsj26ziRS0L6aERYgY8aOKhSUEuotLMxGOhjUHIlQ91tTvbLrLp3ENg1LqUO8o3gfh72u9yea6AKlYHX4Y8PN1C0gPX+EJUgyeagSKI5zcBvs+LE72DMcIik4Nj2FkP1Cjv5AkIROA2dntaiZw9zel1jfLDLwFK4opsUgoj7Ei8RGAfYCBUsZYBiSCKKXBuPbUNqq85Ua52k36W0vcNuYYqukChCEqiHUaKAiqiQTfRRGuBdiNmeIO/jodBUFIasJi/lFtnupwiNOHiv2UneOnkf6U6D4/I8r+2e5kH1MgNp0p2JHXl/QfDHj1n86sdNBtkCw3qd6lCsEFiVJQ54u+S0WTqdPL5nMZns8amNz4CALz3yGNmWT/FQg9HtLqGq4Kd8ZnqbfFnGI2w+0Y9YzZdoJlI88voriP40kQLNooKi2eSbfaSlku7sgKqR6ek0+lcodpL852AVQwt5zyC2gVfuj3g7c5JpUWE2u0LDug+7P0DthVz3j/Bgc4WWb3E6u0FyfAnpx6Raf0KjbWkEyQyjLHNGewqQXJ57kFrnLvJ+nZIfsDKkc3sv7gZ7NXMK309Qc9OQX2OoY9JMJHF6PUYqlxitfokDyrcQCIbsadr9HVbyJf7qrkepWVlm15b5w//0b8jWX2U/cSOR/RsRfVPh7dnEd0ZW9NMJrH1vk5o4R/XmSSQSjSahlyCT3SZhLJI1YgpA7pF8bZmgn8qAElB0lnCtCsvJB+LfkdBOxO9295bO6lgs6Xo9ewoJJIcWMPAxZEDHsWmp78Dvx78/WLZgWKJKUAYGqqggklCKWkxPXsRNJQiFiiM7RLoHRLx0MonX28efS4d70PjnUZdnEudJGldIRF3a0mR05yblwghfO3mGUBXcvVXFxuLt9HFMr0+6naBEHYSOttBi9uw1FCS/PvOPGMrWsLQs670blEbgwD2CflJyf/cMoRAkRJ902GWhmMcdyuNFB7CCSZrZLOlWk9wgg7L8AH3T55ZVQah9UsVD5OZiYnJcj6gYGtPav+CMVyFEcF3MsZPTGGn2kYqPBowHAWrDZSVdZF2Z4KF+n3krR9Dexhw+AUJgm3GPgN9Nf4rPFe5llqcJQh3NbPM7x/4Rbl9nuZgFISjVt/kn2tdZksMsp0qMlysEgY0jfMJFB1lcISl8toiQHMBUbhIpHgUpwZcER17gx8Z/lu8Vn2dGLfO+7VeopTMYXptemIFkwIWDJ3hu8nZG3Bp3KrdY1jUeds/yw/4v8X35n+GIusZ92qtEiYhntXv5peCf8373F6nINGN2A6SkoXTJqAd5+FnJuazgSFdwsgIZfy87l4jYr/S4r26wL2cDKvqIzmuJuzjdP88BfY1M1ET4IavXHkXTXbSZb3O4p1HLHcJwC9jhTQ5vX+cHt77I68cO09NrlEMTFUF6qMFOM4sogrEpmeztclS5wcvcyfhal4bZIC0ijjshahD7nuRYl63Ng0yvXaOodNmM8kyLMlIKWlaVt7wjqHKKyDrOQqCgORWyIwu0QgcjMnlIfwJfM1m3h9hUJ/jVew6zm4/LfC4efoD/D3v/FWVpmpZnwtf7+e1dROzwPjIz0lZmeV9d1VXV1d20N4AYTA8jBBoYEDNoGImRtP5fIyFAPwsQIAbXEqbppr2vruryNiszK31GRmZ4syO2t9/+7PsffCE0h3PGYq1+jyLXihW592uf+37u535Qswye/DJBoOH7Bkdzy7w2fhE/uYRT+hD6Th+pKIys7jCS20FofU6XT/O+9ffy+aXfYHzjQ5ituygFcL2jkRU9EIKu1uHd6aMICcPJXSZ2uwyqW/hSx6pZVN0cvt5D+inSosNaegRh90koKVQZ8vqVCRJqpLjoptJ879hp7iwvI2IFVFFmvNKkTYqSGOHtk2foxwzeY52nszbM+XMfpOYNcPrwy9x5/Lv4ap6JOZ8wULCac1zKBJy5+Q4tI84JJSJ6uuoQCb/A2OoCes9gVzNJdgOSRhdPTuNV10nYHTZTA4Agnuhz8u2DWoh/IOMHwPDvcQR9h47ZYHPAQl9qMqo0OaFHLOkd3iYNW8cLZmhmF7idfY7doVusjF7naKDSU1QO+wViniS+3iQle9iGSsOG5uIIWsunIyye7L6Eq9UIJWjdAZCS3V4W4YWstAf4QuIYpnSZadxGeG2GDZ9KfJOv3mPw1ozJFwdncfUUMjRJKi2eUZ6npze5OD6OryYxb4Sk/A4fLn2bkV4Jr/4At8UtmmEUnHgHxUGW3mTx2qv01B43949iGDYjWsBc6ev0zBjnF06wm1OIK9ASUOxGl105aTFW2kANYWXgFQbDFHklEpgnZI8AwUZ3jkSywbxZYyU+RjxwyGodkrZGNuhgmh6ZVoDRHqOAQjVwcIM4qYN6p+R+h86Egk3USFYNBPeu9dnRTrLuZjHxGaPKsZ01WNlDb1UJDB+EQlObYza7jiNMqrpAAS4iuWAv0x0+S7J0N+piCzNWJnP6c6jzUY1h757fpjm0SojCUb3NrhqykF5HEtIWOrqb4Va6gEzrPL3fo2aciuaj/S6mn+TY1lWkULC6HoMigYak2z9CKAI6dvLv9lh59V4maqMIoJmyWXFGOJzXUfs9sjsbePY+HSVGJvAprT5DgCDeC4gN2TxnvcBCo8hDjSpSKmyhM9i+l9A5g5vcRd+f41B9kWuZaK33iyrNwSwdaVLVouyuX00g1JBj8ZsQjFE7yJj2chrXLs9gvxlQcSUVP+SIojFevcWaO0NqoItQJFvxCjK1jq0YNLwKO0GDGVFCQVKLJfj+6CHuXY32gwLspVL0YyZHdrZACtoZybetQYqiymx3ldxAjIGWw1Y+Q9WOHj2x8ZO0CxcAyHZsusFjBDKLLwvUtDwx3+ZQdp+uiCP0CtuDEWM+XJfM7UbZwZlKFGS6ikHoSAIpKeUusZEcoiUH0YXLDJs4ozlePdmhnb9G0unQF5tUhs/j5Dd4e/JFJreeJ9P+PlJ20ZT3AVAdzDPT2SWUAl/OkqKHAJJ+RP7sZSShGcmxemoc3xA8Wfk2KpJ15zTdZHTNX2s8yFumxcNDN9DENrvOBkHmPEGoUAkiUHWpcoyUn2KnINgxIlnVHCGFMEPD1pnc2aaSyrI3PsNcrU0zVqGTHGJmc49Cv4OrK+xqGqOFFscH12jqR9nxVVJWh8XYGqZtcGk4S7rTJnR6KDLaO8l6nUp+gFbCQUFjavgqCJW11BX0fBt1R2W7P0LYBCensxeMIZAMxTvsDFm0PRMvGQG75UGfenaAe6tv8vz6Y7ihyf3KNbaDGYLxEEL40qzG90/1cTJ5xv0Rfnc2TVZp40kVX2ZRwzafqf4oFiqlZpYjVsDDjT3ymz0uHz9GM5Eia7YYvuJAqGDnBA8Ov80NJujLNIf9Dc5PHiLXajC0USLdyiGk4ELianT3iwzrw2Po3WjvVocs7rme40dXh1GGqwRunPgb/wO+dZwr3SnaWoqT7quEfY3NsYO1Lhvonbu5o3URqeocT+0xotWJ3Y7OnjuvMNvfw0zq/Ij4Fj/s7TNqr1EZztDWYwgg41zC8CXTHZhwWqzkJ7nrf7hAuTFIZvgSKGkuHr6LQq2GKuHaxAibvSqD1gQim+NL7/kA3z5xP5bnosiQO28uEUrBybUbHAmWCAOd0dsqQkoq+SGSB20cEg+5WKkae+98lG5zCkSXfiOFonqYVo+gcItQH0BIEAlJV5icvn0z6vMGDN8o0Y+VqDONlJH/TblgoLqS5ViArxscvnWJairFZe802WyJvhHd9y1FYSU3xUCjBrqkuZJgRjnoe2inUUWD5SAiHUdiq+wVMiAl73dfoaolGXHPsZYYZrX+FCO0+TfEcJtJbiZXmSzHmQv3QYJu77M0fYzecIyRmke6m2DeDdlKLDJUa7HpdBkJVCQq5n6PKS8yr9rRB/nVU7+ImLsPN7TZX1mimsvxT/R30cNBLqezADQHk7w9dpqLc2eo+x+lQRdP1yk0Ozyw9yCB4nHLiKOnriMQvN+6iRNGd8G4KhlurfB7l6f5SFtwzkjRUeI0khZDNQUEmEaLaX+BdDOKSV5MHGKMPaaaJYLdd4nl5tGFQf/g88yW6/ziwj/lOREZ5Ax3mvzbt/8Cy+2TDhrRfPZ3Oaas8Y32/eznBhiulWn6WeLCJbhtITSPpFUjRBKSw1JuomktprJrAOyOlFjxFvg1/j2hFMSVbVJBiB54vB4/Sd9UWbKnuJUb45fsvwHgF+pN/nnlPFPiBqveUWoywWfzH+Xdk2le8++DUCF7h8qFcJ6hZBfhOlRkg3hnkeO3hnl+PIWCYPL+X2FOnaKjm6xrRRa0Hd7rqpjt+1HNNJW7EtRFgX+89iWGrT2KShLPU+jVJ6ntHqE4dglL22Np8YcJFIex/dcxMiH3751HD33enenSDUHNHsZK91nvmKTjEmVf5Y7Ng/ZBb+xgdmJcincwBBgKpFIVpBCgQ31rnPhemdlgl1U5wpBokMSmp7d5yzlE2/8ogh6rjiA79xJIQfZyk29PfZaEPganf4Lv1p7i34T/FgLJwlaktHj+rtOYym0SxasoSshqYwYreZ0Xx7+Paz2M657Cr8yiBiG3xyYZ1jeJDSzjOrNoGKTCBHutY0x5sxhISk0dK9wCwFE81jLRWzyl7TKzbrMbK7Dm3EW8qeMSgtIHd5AJpcJKYgycDjI5CFIwe+1xxq9GZGM3meEPT5ygq8dQkjk0pUxTy5GlQTcocGNqDnsyRsNO0MvHCXoGO/VJlm/dxWhmg/Enfwtt7DZKawAZqhR311i8co5mIskRsU5fDqD7wzyasskHDcb3CqxrYNkhqiEAjXb/wJtgOjIWesq7jjr5A2D4g/H/cgiZImzOs748gIrgQeMWQo/R81vM+ju0d+OQeADdbfHy/BvoxGnpN5iYiWNJWI0P8lMdi8WNOpoI6IdprJfGWKtfZieboiozHPFuI/0YzUCgyxhGvUNf0Zj3VURa5T/1PsSp0nWynQ79bhZLd7G0kEznBl0jxXJ2jJXJpwDJQDJyFXO7h7k6Pkd8eYuub3CPtUMwNM7T62cJ3SGuWDF8okAz4KBmwZCk9lbY90LONo8hBByyQjKdKgt7m5xfvItqKokmBE4o+cZEgnw/pGcZLJT2yfgmpZzLQL2DJqKDl+j3aFgpbu3ejZRwOGWzF88CMC6aJGyVyXCXE91beFUFKpF0qBqCGijE6QKS2e1dKif9qLuOgLm9GHnHRU/Eua0VmVaqVGZjHKlvYrQDrNIGWVdQlGVa3f9uQFNSBCZRW4vKHVeQWp/czkOcCY7xQf3LFGdfQI13QQo812K3MYhA4rkxXKFwaugSncwKUhXoboZWIQLyT+0odM3j2FYaq7bNjvI2eSfK5hwuuVGhPLApUiiEhKGO58Tp9xPYOycoHjivNhMeS26Bm5pCEMsQ9DscW9ujoSTQQ5vAydJR0sTbIe605Lr3NqGAe3aH8GSR6s6LGBh4VplQDWg2j/AzpRieFUlo+zkL03cAwc1UtO7VdoJYoY+bjhPKEYJ2ZCxhbeX4v2p/iDpg0XowTzUI0IXOjx6userPo+gSa8CmoXcI9T67iSQlZ48dNcG8iP7Gt2IfwNE07lju/N2ZaiSiC3h2/QZGZ4xuVqPaP44uHBK9LkKfoZ5QaMdV7i9HNStrAyUa6TdRA8lA16XHGdr+J9h2/xcMO4mZ9rhzdpNSkCeM7VMqRKYJIzXIvajRb2jMVwy6hoqn6jSlZNcUNKebBIpK0JjEFhaJbItMGCffbRFIQTZwybV0lsw1DocBdiaD0EKs7jJu+3PUiYLoTjHHTHmD0vUh9s9bJMt1Yt0u46sdwEMPS8j/BzAMYgGP1V+mrqW4kStwMzuL4bn4sZDfSM0RopDXf5PN3k3ucc9S7eYJD56CS+Wj+Ika2xN59vUaAZIRVLAThEGFhc3rICVXjt7FeKdBW9+mFxsk3e8Scz1CBfY1lXTWoy9hzFbZ7+dQlZAfkc+R7Eu2BnKcXrqKrnX+rt4s24pkTNWCQzzQMN/zVU781HU+eGQTNe8i9w30hIZ+QyGWVGg7g2TDkDghn24nCVFopwsEIqRhfo1CtcQp712+tfokOZqMigpb/iwy7aJ0FJZHBGO1Af6/Z5/k1QGVr0ye4IH182zJQQbUOtuGzaF2QNLwudJXSKhgK4eYXeohEfzXZz7KzpXDqAE0RZY6caaLK8R8l6vhUSZZYy+d58MvP8dqYoRhGWO+P8HzqTfpC4fF9h6BprG1YNFTbdqFOIqh09zxWVcytLfOoHkxBuUJ7PJ95KwSs811nL6FNrqO1GGzPk2utw7BLra1iCLgamcB/ZwLIaSKPYbUHh9Wv09c+gRS5ZR/GalJqloEfFzlOqO16Pwe7ztUgizXegucqa0zFI8MK9bG7iYIJRK4OjlF0/Nxxk7zb595hqXZYzx89QIfvPIqoaIy3O7gKhoLGxuccG/Qr02R668yXPPpxlMk7QgI28UEta1B+hc0IIWj96l0h9AOegj6gyVei/eIeyFKAqpqjqlGmbYV1Q2pMoZnNBB+j06Qp66l+OvhD/B77V/hO49+CKRkbXwe03F4NvgA2WyJYaLv+b2tj/LmQIaZSpkgHvAvflzlrfKTrKeGSPQj0ueiERUB+/U41WKcQrfFsYtR8Npv3sA8t0+o6vwr/W9IINjRHFw9YLwyQk4LQAhaWorbTIKpcnqrhhHGWXTA0YeZ3fPo7t+iINMEUoArmTpwOX741ruMOfv8+iP3sTxzB6+VX6cUxrhDOQrY/HUq6tu6PD3OanyRjpnkHTHBNX0NgHy5hBaoXC1c5Vz5DhLpS9yT8LlHnOUF5w78vsKgAN9sYKs3yMom63mLaiKNFILBpo0vFQTbHFUnGO90IAj5bjoiJx/YP0tQuohQVIbjsywfiki1sWoVTx/i//Y+AcBMe4XDnRZz3ZX/5smDPhhgS4Nr+5O0E3kG6mVqIk1ceHS2LQg1kqkdZlEJhUdl/DxHHv89zhz6SrQutz/A39Z/krVwFtdJEEvtM+VGoOAvhx/GQ+Gx/lu8Yf0Cnx5+BT8UvNQa5V8p83y2/Md8330SicLQ7Dnq1bGoy5zRppIvsOKPUKRF0qtTV9rk+iO89aGf5WpGwQeqXhu5c56+rnFdTnKYTc6gcsnpkRxt8VbhHjJ+kw/sv8agqDKhP8agNYvuxNm5+gxSKmwsfA7bGKKXXKOwvYyZcui+qPDExZd5+fhRwriHjEXxzKbfJ6lLer0ccSN683YTRZaK0FAFLRlNaipfJbAMyjuTJNp9/J7KkOiyLCIfgHnpgJB0TQU7fAiHywSKT2r2VTrbJ8l9G8LCNXob3yQ/dhfZxnsoVnb4R1/8A3aKk1j9HvWUzvbYJfy+jq47vNUY48u9Hml3nObAT6LnrkLPYmizyZvHT5M1S8TzSyhBHDUwafbL1JUUh+vrTDseOA6aGpXMKHKAvh+pbJ7YX0KVIefNR6h6U6SVMouiQqiE5HyNw3KHFWOEQEpEEJ1nJbWL9CK1Uzthonnj9HULkSggRJnN5BAWfZIHpcjP3fcQ/esq3UySZKfDfPoGr2w8THX5Xnw7R2j5ZKozlPQKY7U2c6UGnpTMsck+kwz6OR4gTVHukymPs6rrWP2AQI/WoxZ6OJrGlbGjgOTuGwOM3y34hzR+AAz/Hodrefzp5kehFXDSEFhS4ghoeTVcX+VW5xT95DyFve/jmQqa1KjGt3kntcyjQmfJ9GnFBB/uRfUe9b0oYC0YHd6dGkKmuyR7AVqo0fA0Asviqj+MBB7qqYwOS8IQljfySAlOIwJOw1pI1r6Bncgw5jXYG7mfYvMtlME3Abg4n0O6JuGGIJuQzLaX6eaHGRu20emwzRm6frS13DAXGQ0YASDJlipc6k0SBipTRkjSi3Fm9V0g5OV7nwYg9CR7sYD0gSTqTKVPRujUFAWjuk3iwHjC6rpUrTS7XoHWfo6xlEc9EUkXR0QPq29SdEsca9+iVE/iOpE0qR3oaIqHIiSK5tKMJygd+u+uUSd7MVxHR02Dp2jMaHWq83FUGZLueSAS1E3BYXGb2a0N8loNS3jsC4Mg1PnZmb9havY7SClo5K8Qa87zu/XP0vv8HKKfpVudZfPyB1jbGSYverjCRSHkRPEKiWwkv9LdLN3CINmqS8ERzCSy2IMqEyWXm5VvkncOrNIrDjO+gwdcy1TRfQPNS3Br+R5uLj1IQsbItaM5aSU8sk6R/6A8iJMbQsoQo9enLU2k4qIpTcruAinbx5sOSTUC3sj5qO4pOuEoudVrSCmxU2vR2raGOale5Sf70WcpBmv8+e6/AWDPStMJbSq2ID7Up6wfR6BgVm7RMWPMsssz2ttwPMZCxaOTifZLPJyl5Uf7OD7cw1OjddnJCXpenXomyYIS1Sr+VfJjTFT3iDkWkpBQSGqpBLlui5HedeKNQ/j5HiNtix3LZosCn7zxLErQ59E9jx+yI2B4be51ZH6bVNtDygQymKFFn113Gr2fJZ712U+kcDBQjCrd2CCuKhivquT8kNI7GQpth3YsMg7wBVxLCnYL0b9rzhwv5e7kjH2NzXSCfLdNU4mRTrloocImm4yHA+REFjPlM7N+i0euLxOvXCYe+HgxA2N3lPplnc5qlWSjgx2P01eHyDQ3+D/++Pd46FpkT95TY0yoezzQ2eSl3N0sjwRUElnGKns4cQc3GOZt+70YyjKn0m8xpq5TqUXzfbd+g9uNGaqxPTYms4ShShmfjIwRdAMgJA8MdussD88CAuGsE+hZGIzc2XwUPCF4yTb59VKMxXCNcjN6tBdS21TSCrapc+T2DZJhB8t8BEUdYrweER3bVoykFJz//vspbUyT0UOECkrLQCZ0UpcUNBX2FYf/1rZdbERgw0lotPUWQjicvvJdLrQP4wYGT+pRTUxNzSHUkHBXspNWSDqSanGaf33cZHp/nWl7i3VZZFRpsBd30KVAtbq87fcJpGBtbBBF80itVfnOA49yVrmXeiJOLT2IRFAK85yo3ObZ8AhZ2sz2NvmhV55jJT3KUSXHbLtI1eiwZK0xsnUJgBeOmNTNGlNOmuKoCapg7XtFKuvHUXBYWBsmdEaJDb7BxL37VNdzxJxNzs8V+Z41RND7Lihp6rEH2PDyHPPXUPcUAkfHNPvcm1vmEKu81vpJNsUMR+NbaK7NjcQsDS1NoOmMV30kkilLIab1eGX7PgaSDQbWdjGcBr45zsrYJM2YiRklyDk3f4S+ovOZL/7fPHbuFRpWJF/P9LokPBszdCgaa3Tbo8THbrG45RFoOqMPRuvc2B2iUQtJ2CuofgySLR7aj+YkcGKYuSrvopGwbUzTwwlNPBTeHT7Jem6Ib97/CM8dvYvf++AQbw8usGkN8/vm/8xbmdPYVpxEX+JYcUar+1y0TmKbBuPaNn1hkM7UuZXRGa7UKccVruc19lWHmyMWpoyC6Z20jo/CkN9l3ZhgvFFm197AcB2clUehH+CcHuC4cRVo0srE0XxBzrsDU40C1k1rnHbNQqn0uad8i4F2iGVEpRXpThOrvkpZC6mHBgEKp5zbdBWLjNfij975U451b/HVJz/G8ugE//jLv03Mv4+N+Apz5yKTELIB60aBYV/lXW2dm2Yk+c/Ua9TUt7ndvBPVqODqTZ5MuvSx+Lb647gdnawi6ah9tsUX8YRKOmNRTUZknuWtciso8Jv+U/w1DmnaiKbH2aH72VU17nEus+dX8LwuY7F5PrK4hWka5JoVUEzsYDo6j5bOg8YXeaT7FnHHA0XgJQU3mpMkw0h2SFilLWLEZJ+VokesdphE5haPj73B6kP/nNVDdcJeAuW1jyEtlX0/jq2bzO5sokuLRKKO6ydJTdj8n+Xf48ELNT4jvs27Yp4L9VF+Y+09/MeJn8VamsTrvUxPuFwrjBFPtGhvnAHgxal7eeytt0i0onskI+v0VB8dDc1rY/h93g0dsiGEoY9hCa6Hk9wpEigIulsv4ZwMuCJOcXxzAykkuaBDGijGprla/AayO8rmxnHkyLvEi5cRZo14pw0S5le2uefsWQJVZfnwJqFfpL15gmosIjwvx+eRKUmAwvnF0+wORWVGrhS0GjqZoTqhZrKzcwTDD/B7Khm9ww0lWoe5fnRT3mNWkcBq3ye18AKG2aF+67147SLTy+Bd+DobvRK/XBH88oUv0k/nacUsHn77exiuy8uF09z4m1lKF7NclTdQBZipH8fwA+aDJsS7NG522dAGcIqCXOrdaJ/6GV6wriOF4Ehri0nfZ0dTMWWUBbX8w7iO5D5xnelGm7VsgpXaaVp6GiEkk1ZU1zkf9DkjlnEVnVKigNmL5sdILzHQj35uxRTyvRQ5p4OiZWgpfaaDNQCGLg3x8MVlvnL8CWIDHq14ilSjQ5IW3ZTLrfqnKX3/5zh6tc3I+nvYMfa5NZ6m2Oii2B5p0WVFzzHk5Nh+fphHklfJ64IdNYcRSoTwCejSF23+9r1P03cMUkaPcS9L5vYPXEl/MP5fjkrD4s3SOHLU4CHzDYx+gbZwabgVNn2LW4kPoLttfP0iSS+SBwrf5rLyJ9wnQjwU/vyuGFvGgQRl/yNkYlP4d/U5PF/CHZAYfkhKtPG7efpS42xygVRCI4dLOsjw4NAydlPl+dQx9hsRI3pEMdHc6/RjOmfi40hFY2bpeyQbfbatLDcmp4ld2URI0CcFVmmDfHePneI0R7vvYPePsBpGWb2C0OmqOonQxsmNctLeYCJRodsco6iHZLwMvigxu/U6V2cWeCevYrseD69eICQEKTlcdsjqkpqrcFtzSciDxkZVlY4V53owyMZ2EcuQWGqXbWOQqcAm8AuMtbdYWLvNBa2AFDF6SHxhghEVMntJwZ9/4BPsD/33dfkpdQlDCdgzsqS9LkXRxinG6Wkmg60GKAlMpccQFVJKErdqMK42KEuLQBMY/QRCwP7Fj/JnvTR1RfLDawqjlQ2E1QA7y77ssJocoSjaoHXIFfp04glU0UEJJLprEZpJ7tzpUxN7zJgKyhnBtcmj7DdizNk+KSTxTo1D/Rqruk4luctU2CDhFqjUJmg2i5iKxHRdHCNAU0N+2h9iJRzgZnwaXxNsWxY+KoYGCWedsn0Eww8hEzLX9lnzbwJxuu595PKnEULgJ6LCd6+XZUi7zUftNp4aEm+vM6VFLGBTWlyWW/hSEh/sc6YePbqGvcxeMsewqBOTLg+0LrBUsrna7NMLQ5zwGNgxWr0UqWGbduEXqI38OvsTIyjSpR6TzIltymaGhprlxPomAg2h2jRjIfWkRrFZZcioEK+Pge4z3TzHnWv7VL0MQ5/f43f++qv8+4t9mqpEkx474TBhzCXT8mmJiBX/XlsSOCUsdwTF8FnVog0yYlRI2nH2cwrjNYXEZB+7ZqJ3FDxj5O/20LIOpeQgiZ7L96ZneTl3J5NOieu5Cvlui55ikB88oDD7NrkgzaQPqRmbZsygbRlsZKdIBtG86WKaq+/5l8Tf+9MECwYIQTU3QDK2ix74/Mu/+H0AekqcjrHCQODxWuoMt3NpGrEE8/urUY1Pv8CeuIO2/wR35dcouE3WWlE91pPm64SovONqbOcE0h2kSZ+0jJN1o6z4gD7Mod4yHSvO8sIdJFuRAQ1Tkay1LyEfBFzra7RCgR9coFaP6u6ctM5KMfo9P7AJhEIiPERoDJHu7DFcKVPLqAgEl1uP8frGSZ5rRZkbsz5NLxbHWhKEEip5BykjA5rEQU8rQwa09IO7obPJG+U7OZO5wsfbL+KjIoYjaWxpJ3r2ZuMa//qhOfoq/Mpf/h7xmMO2LPBoEIAKNdHhxUKGutZnxRvCndjnnRN5vHUXNQg5f+gkf/SxH+Nvf/THqKfzXF5ZZLq3wffC4wB8YuVZ8q0ma+kROoqO3e8etKi5QFC9CECoj/KJ/hI2Cfa78xQesPFtje7tJVRzk9vVHKrS58j6bbbeGqLyZpLKcoyeaaCaxykVfojq0I8yHMZY7k5y1FinmYhTI0fowxPx89wKZrgi7qV1qEJKc5nvXmNfzdI0syR6HcaqPg3DIzbxDe4fOcubu3fzy3v/jBu3j5FqLjPU0lkdmaSazpIvb5HUsmynYxQbbfK1fRy7SsOKSBbdc9BliDcuUdSAHS2LcmSXQ7vRXt+YmCPudeg5WSynjaKYCFSy1jZjbiPaG50M2WwJtT1C0nFJGD52GEP2QlaKSb598gHOjc6xmy6Qspv07WGOdNb4/1X+Z37y879LoOncf8PGcF0URRIKlZd4nBH1NuuxUazhaM/mG2V2D2TWJwqvUxu2EUbkhBkXJark2FfHcIXFtLOGkJC8tI/XNkgVv8ARf53RYJ++aJPQChRrJrp6iOtupFpQErOECQ39Sh1VLRNzBSXrJEgXGSyjeBtcMbfZD+Po0ud4L/p8rcQg6f4n+MKlX+RM/xLfeuITvHb3x1lJJrlQXufY1Su4jsKMsoOnKOj+CXwCAh/0AEzXZexagk79TiYTLzJhBAwYkg1vkoo5QcNNEFMlSMkJ5RqvZs+w3ZmnGs9jeD4bqRfYDyNZ9p/gIQlQGi6t1AAvJEeYiO9RzcSpNZcYic+iCAVjoIHWOwCmRnQeb/hzvNy/G61vMx7vYGohvcDAvSxIaQemRVoLKRRissOt0YB4/RBnJl/j6LG/QDhZjl9sIc6ewN9fQMQ1ur7PXibPkbVb5OsWx3fKfGTqTxh/sM6Ms8Nvjf8YDzi/w6+6P8n3S7PcOHEXZ+94hGtHjhM451A3L7GXA6cXI1GeBAk/9+U/5jPPfp6prW08qZLT20gELWEz0xUo/auE7SvoZhotPU5v5jBbbp5MeJzNoIdm3uKd4XtRZMDi7V2q5EjYPk78FkPWJMN2Dc2Ps729iNPLMHj6cwy6CgLohpHxkhoqPHzhbb41vYifbFC++kGKB+H5ucHTyIxKiySubmKoBvEwyrB1dhIkhzoITcP2C2heG6+n4CnO3wHD8Z4JEobMMh1xldVgloGj32LDWaBXPsLGzBH+MvGPUWTIF9uXqEufO8NP01h4D0jJwuoGBb/F8sJRvLxF+ewQH3klyac2cmykx8k1lji2fxRz5kvEDQ/tYp3v1N7L9laBQO2T7Q9TsTzu0jY5NF5izA3Y0HVKYhDLtvGsE+g9h/+P8Wf0Q4WNQxZhfZgDU3gSZkSWP+Tsc0JdBmAtPUy60wNCRHyPu4wQ03VoxRWONPdRrSwAb+cmSKoHdc2Nozx4tc5OcoTlwzO09RSpTht9RzBbXEaUU4zqS1BJQTCFrZZYLQZMlndZaEf1hUtqhjhxBpwtRp4NeMBeom1HZJLp9fHFFqZT56+f+QjxbotB1+XVxFmu9yIQ/A9l/AAY/j2OfEzBPFPg+JFbzOU3yDlFpJDsiRov9Q/hJg4xsfU8NxYzjPYj0PbApRBXNLhQ/BKKAmq5x3j3bQAavoljfZyr4jHMRxt061FQVXAdwk6B6/0BPKHRP5zBVeu4usqDiasU0l22anHOW3nwDQ4pCXpynb4JxY5Bs9Akbu+T2nT5F9M/iaiEyJrBRKaDUKN6lln7FlIR3ONENXS3dUmXkGERsieypLw+y7lFfmTqEr9X/wvijUXiQpBxMzSMBkdLK+Rtl986YqLWL7PYuklHi4pHnhvIUIj1aEnYKWTIBz18qaE3LGJxla60+Gb1UaSEjKywlJhh3gvoBcOk+m0Gb+ySDgW6EKwQkJQC9QAYxoMWL915P7dlHiRkgoAxafPM5C1WeymO1NcRAozeEJcG5hhpVggVjZ9Q/gxX22Uw1cCumoxofeoyzsTIOUbG1nBdi+W2hVMe5qtFm4cqAcn4g6D6OHaOLRHDVzWGnQ5Jrcv+qSn+kJ+n5aXItHoYXgfTU/mhzSbLvSqIkHjmg9waHUIKwdG5Z5hAY1e2WexucdMwaRstGl6Boh+ZASSlhaa2CYMafUtnxvM4bYZYMZ9zwSRbRYP1xMHvKh5usEEjjABQ3A6YNrqk+9fRxU2kvBtz+jE69WvY6VUCz8LUyygi5M+GPkZO7xPra/xE/jRFarRCiy0RZQdSOZvxuoqrSPq7LdqZGIqIGLT37b/C47uSpFKj6kvs8ATZdo8Vfw4xrODEzxBoQ9w+8cN8+7GPscEgC2Kbq7EFErJNspYFwDYrbGcCQkXw1KsvknrFQ78dMeDx1CoDvQ6OZrJ15gmOTnyQDcvlF+40GKRMNRwGIUi3fDrGaRxc1ht9aqGD5QyBGrIuonk5pu2RbcFOLmS4HhLmJlk+9OPodoetwn+XtG5qIWVlkLtubXBhNsZmGD0eJ7rnSLh9ym6cw6kokMq1ddpqj2O2Q++oyzfunuT87BQ7qWFkPGJ7P8AfUQ6HeMk9RpkomAj1AENW+NaH3sfv/ehPYgV9bDNNshuBoxtilt1cgU4swWJ3BcNxyLpZEmqard4nqSsJji53KHUGyRhNDKNHRm1zoT1NJVEBZ4S+0iIj42hym1DT6WoWj7dfwfA9riyeJtvykWEXbTBaz2ogyMqQvgArVLgQ2uw1D9MPNGxVY2VYR/V9Ut19sGZ5ZfqzvDXzGuBRaAbUs5EEPdQ0Spl95kIJLqS688Rjwyg9QbOuYkw4VLwxfGlguiq+qhAPLCqpqPfZ0mABXfG5X7vIvL7BDkXiQ2sA3Dpg0NPJhzg3YPBP37zJka0N4oqLQHK3t4RA4U39JpdT0fcyS7NMsc77t19BevC+N17g1vgUV6em+PEv/Rmt2QyD1T2UWJcVOUJJzfPBnTfoayrlWJYle4PKgZropnqVF+/cRvXKnPbzpK1ovdz4GCPzm8gH0sigxFr7LOuqzr2VCxzaitGK+4zcu8fJ+/ZYLBxCiz9ONRGyMamRkIIX5NMoCqycHGO/nWdy26UvTL7b+QTqzPNUB1X6oca8to6HiqrrxPtdRvcbbCA4MXKFjy98nY/Of4NNe5Rfm/gZfn1mjsvCZX3oCJV0kWRji4nEIVYTCunaNgljCCkD2pqBEoYEMgKAzcWIyHytOM9A6ianjv0Bg3KP1xoPkWi2aSYyjK/1aKXHAZjjBgnTx29mQSoYRp9UwkSTgpTaZ8cYINH0sE1BsVXlmcuvc3rnFo/ePMdExcXAw7xhU56eBmBh12OqVKGUGyTZWeH78kmGwj12jFFWtfuYa3pYdputIVgwA9pDTQZHbEI1yp4XvT22lQEuqBFRdEI7z/WgSK+q4M8kCQsrfOL29wG4nIZxr8iwPMqlmE+us4cZ9Klkh/FO5sAN+RzzSCQX0ndgOBvUExt859QW6/4qS8EIY2qToqizZo3yRv5pQmZoegn+4vyv8mT1O6wWR/nhB+N86dghXj8yRyVIMCXKxP0+7xJnzusgUNAOJHmx/gAShXjxEh/OeEgJ6+sRcbWvTZA0Q464LiOizdcHH2OnfoRKMstgp0lMquzLJHcSMihaXA+KKDUHqSictc6gapJstkupcxNDjeFVT2OkQ/x+BaRkUHERikenO8AfNB4DBA9O3WZAa1Hx09RkGsWKQk8vHu39jNvEyRUI9C6m6mG8+3OoZ/8Fdk1nSB6UHxgqrhviKRp31K9y5tZFJrZsdrUCGy/mee3Gk/y29mn2KPDUxnPMJGu8s3hn9D6kjqMnPoDEZeu5HL3ncnRVQcoTZGtN1IxLpuRwKxhhSi8jJeyJOuN+ivs2Am4NHbgZL7yPhYmfYaw/SSCPsNO5TOLePi/xOHOVbZLNBiv+PcR7Aau5TbLGELO9PiLUkb7F2sojxNL7DA9FYKdMRCK0k2l+5Nmv0TESXLtnF689y1h1Hj+AHatITHfYNQdxPYWcM8awnSMmdZxyHEWTxIeiOCwMushAoecqNEnSCwyKniAZxtkxS9y2fVJHXsbQu/yR8T8RCMk3HvgksU4kBSjH2/yqcDCVBDcnZhgu76IpGY7H3sJVLJ699wRff2CXMG0gL2X4zF/9Ng+98xK5ymtYwTXuHTqLTOt87dLTNK+kcfUa0k3i6B7HtT1Wg6Mo2gBSSKpKhpht00jH+Ezn6yyILW5XBglNQTLd4qvdWTypM6BtYHkJDm0kOSS2EFKylh4h23Mw1ABHU4hZEsOr04wL5ps7KAfqneeKh9jSZ5GhgmzHSfppdN/la8UnkEIh2e5gr2Q4lb1BticZ06+yzzySGLrYYWmkgyold/vXcNBZDqMzNHdQ6zzYaWF3olrCRM8Hc4kv3/8oPS1G0IFcvw8CZlZD/iGNHwDDv8dxu+eSsQweDi+SydTIBZEcp6ba1J07UfweI6XXOT/RZ8iOgtypHY9DW8O8kHsDPa+i7vWZitcIpeA59jD9fY7tDeELBevLETuf6AW0W6NckyMca6zSHrTYzfTZz8ANY54veP8nigIvK4s0eyMMawo+HoXmDpYPW7Mdgoyk14zxbP4Z9Ov7pNQu94dl4nYEsMwwgeFkCYvjaMlrNBmiRkgcyaY/TMz1+YSIE9M80qLMQP0E/X4KTWo0jAYZL8ZHtwKWUypnR10eHtyhfmAFfHNogAHLRgqopRSysk6XGGpmkVP6HPeILstykZ5jURRlbiRmmfVcWjKSxl6K5XmkWSGBYIWQZChQDowIZssrxJ0el/1JdCQLbgASng3vxBcq03IDIQJEN8/5oUNk+z0mg22GQ4fR0KX5+E36DYPBMEAiaHYSFPK3eX7rIdb7Y4xpddrdc/RFQGzsKQB67QKlMIWQITGglU7j6Qa3xSF2zGFGaruI0Cbd8llUUrRVQWPie1Q7s2jNKhgx8uYEk4TsC8G4u89SrEDF6nHZO84kcWLSIBcm0NUAGdYItDSznofpLxMupOhhcC57jOZBK4ghtcNVI6AaiwLheDcgneszGfRIaV9DUQdQrAzLvdex4/u4zVGGElcJEHyw/n1yukuyl6GS3iKpVelKjY7aQ1dMcnqPuFukRptio4xXiAiLXWOAZyqvMt25zJioUPElgjTTLY+L5mmuxk6CUDm0/cdka9/j2sIpvhn7KDNil6uJBSQw0o2AxF1vfQ3b2EcNJPdfvEI856KLNlovT+nOLI0zUW2SN/VBwm6ZL2ivU0mYJGhTUSLQl217BO4J/lBpk3CrBKqO7kQPzO0g2ktnxB5Ju04pD7mWz/XMv2EvdwQ19Lg5to1yUMdUlQ6jOw2cRB9P0/n4ziRNdYCHG+exdQM7UMhqNob0ybYNblub3NdS2NBV4n2HUNFoCYlMJDEcGy/xIo1EB1uqeNVIch2oNqvubeaDVeyMhqGGNFNDjMVKNHpJ7nvtLF0jcis9Km6T7QXEghgpJUPHd3knP4nhhvxY//sMxcqMTm7ygHGZK9VFTKvFlDNET3Qx0Oj5EFoJdowehxsbFFtV1ouTOLpJ4N7ESjm4umC/bKBIUEOVf7b7I7TcSXxMyq5OT1dYH9JYWF9G9z0wT1KJrbOR1ajqeayKTTM0uGYFNNWAFVLslB/mW5ef5r8UT7CeiDKP4UqK+KDNbrCIgUcv0GnkDhwp88eQ0qRtOTw9/TxmzSUb77DGKGquEa1l0iKvzPD70x/i6V2P4u1X6eaijNeA6JJRL1FkkB2lTqHZRAsNgt2D9Y9FdXdPv/h9DM9ja2SaicYqu8kiex8YQC8WwFA4y3Fm1G3K8RQIwSP73+Wey12ybZ2bE1X6lsudndtcTx1me3wQEWrIRBlN87gyfCda7DHOp06ghwHj4xZ//kNDfP1MldzROhNKkxvyKfLVyyyWr3BlwkIiWecUQSA4cewGd+3skHZdvsJT7OYEiewGNSfDW84CR+O7GHhoiWhvGP1dGqaNmrcxVZe7J77Hrz/8r/nna39ONujwcsznpf4In596lLJRIJeZpGwpZGslZlPHUIC2YZF0enQsQSg0nDkLpSa4xTSa1iU9foG83eF26jBxu03ZGqB4W6WTiAItt1vml5s/QbCXQ4lFdYbpgTobJw6jiYDbsSIrk3MgBHeXbjLUabNUHEeogoKxBoDcmWTjyCyDco9Cq8NEo0LXjGF036Eshkg5NrvqMOXkMO9bryOA9J0B/3TIoZrVeIJBJBb9wGLEs7mWMTmfOcaIt4PQHc76EwzoNfyFNJ55iMX+GiGC50cnMKTOke4CNxSLo72bZII2y6YJKR1/Ps1tJ8dlM2ApNUGhuU0lvsZ+QRJ6YzRJMKXWSBo2u2KAGwOjlOw1XtPHyAU9fufyn/CVVzrctb/F0twJ/uSHf5Eb6TlSlsuPbf0Nu62LDLZWIAyZEMNIPQFOQDJ/Fs3sM2+FCAEXSg+S67ZYjc2jqpIP9nr4wFn1CE7jDqrJJAPdKjPtCTrS5CGxy69rf0oPA61mg5TcFHcS+jCa77DlrNPOXUYvXMCWo0gfMt06A8JBizXYlieZ6K6AMYCqTjGTqNHwY5y7917KAwMgA6QeBczD7TpH3cP4sSphKJjZv4e6DHFdk2E1kk5miVy/RddnLLtPW8Z47d48zw8fp72fINm2GV3aJOfWURIKw8c0qolhkm6Hc4cn8Y0FBt7bRY8HrO9m2FMadGMef/WJQaq/7HL7UxNs2lmOKhu0pM4uJYbDLKOVm9zx2gs0+zW00ahv8ENq1MKpqb3K7clFeiLB4vY6wqmw6d5NzAnpppcJRMh4MIYQPqofZ7U9SrM5iLl4FhkPCbsHagfPZ2FzjZOlq7w4cBRf6ZDeeR+/G/yvOLEcaTq4nZBrg1lcxWWmcQcZmUALJFJCavigHt0NCYFqL7rPGp7JqOdx2J5mydxmX2TJLzyHVrVYVeYoZ1SGWiE/87W/RALlwZCbhDzn3eJaRmNu/TrVXJb3hs+S83e5nj3O+EiP9x8+xksf+Cg7ExPMbJQxmyXO3MgwZNfJnFYwMz6/M/3DVN0mIYKKHGCbJDedBeph5Lbt6Qam4yPjFX7J/zzn5HGGhiJyNZZfxdBusSYnGBNl8t0YebdBTLgkhctqZoxEz0b149j9FOWB8wRhiUZcMNXagVT0bi+bBXaNMcJuiqmV7+KYQzy1dIE3EncAYPVtWqtZxlKbqGaLUeMqZTWq4U2EVZYPHLQXzZtsMUzPi/5ubCsC9HLbQk0qeEIhbgfsZbb5ymNPcW//VXypk9K7IOHN/oGS5R/I+AEw/Hscx8ZixFt7nK60EektspokFVp0jJBEP0+2+iJWfoaN2B4JW0GTCpoa5+5rFmO9It1RHRlAkFKphwkupY4TF+t4vQm2zx+j00jiSZVkN+DNxgl8ofCBjZdQAsn5uQHKWZOdoMiM3OWnrGehE/BvSz+LaUWHc6wSZXzm1W2cxZD/cvojKKt9hKNzr7HJvKszWm8AcN39NAN1QaAqTKvbSGnygvSw0CkHBUwn5JQe/b2E0qb83JfodKLD1dLbjLVNTjUlp6our971AK+vPhXVIACKlSWvRYBleyxB3KjREXE6s6fZj8X45zKLIfr46AxS5kZiBlNKBlUNx7RohJLTnoOFYAsXDUGoRlKWdNDkSPMqjUDiKTHmXQdFKPxl5z2MUqE4s4tldfD7cc4PRczQvB31/UuZAds9MNsh+YO+izt+FiEFL+0t8tb0Fzk79AYx1+Vd4waqUkSzC8T6A5TCNDNyj5IWZyNfRAkDtNDnxvAUmeoevuKS6wZU9X3yd36T6uS3uM0uimMj04NIYsyKLYoykkXdiE/QMLokQ5WspvG0P8n9/iEeiD8H0kFnmFnX46j4D/zuzm8ypdSo9E7TSeYRMmRMNNlU49yIxwikilFTCKZCxlotYsqrNFPn6aqvU6iFBFYdpz3MYtglRCEe2rxSvJu4LQmdHDWrSUPG8DXImyPEe2lSvSLVsIEeBjASZWw+O/ph8rLNvP812rU1qgdzmPYH2O6NcZ67iHstHtu10Dv/hU9+9Q+Y76xhiIC1xAg/9N3vk29LkCGKlLy7MMdk2edrH/wUUw9X6Q3vEm8cxhhucaYbZdx9abLuLnP3xagmTyKo6mksO0RxdV7qF3nBbqLJgGElgdaPHoJ1d5RB6iwENnpQppQTaIFkvVVnOojWoJ+CxEGvTdnY496VG1wZnWey1ucO26fDUR5qnGetMEy8GD04uhow1DC4GVtnzk6wpWkk+gqOsECAl05RaFT4jj7Imq4wPLCDLyQi1PH0FjdnTHacUearDWJ4mL7DqFJizbubxe7u3901494OsdgQCgr5MEfPbyFSNisTcZ5R3+FR/wp+MuAJcZ6OlyThTnDGidM+aBxvYmJZcSzZZ0c4DIZ7BKrKxRNn8LxrxPUePV3F3zaoC4WT9iAPN7uMNGaAgEoYsJoawdMUTl1/h0Y6x8XZNLv9J9nb/V/5q/FPc7VhYLxT5ZuWyw1dpVV5P9/c+ghfrH6Azydz/K41yJvDR9FWcwgF6kkDVUS1pXYyAob1eIqwP4hm7vLkxAsU2n1UISmnEqCFhL7B6pDESb+PjOfzK1eX8OwaOyMRcTBp9snqq5yxevh6jDt3dcwgx07fQLHzTBZvklI6uL7BR176LlIIvnPfM9zQPZrdAluTkwQDFm85R9B1m/2pOIpw+N7AY7xSXCTbTqKG8Dt7FQZ6IbvmMHtv/wyKl8JVHDzPYK87gZec42ZslpMhHO4V6GaeoC9CXrqao16+H1cm8VtXObm2RBmDmKgw5Rlcc6dYcMs80FrhnH6E1f4QZ90sX9p5nH/15q/yrHOGuOrymHgXkU4QCoXQ3+XR1FfwdYWmD+faJqoScufQRX5InuUfdUKmFI2biVH+ZuyT/Ko+iLLT45JyhEJigRGrQyuWJG338EyDndG7keNdjFXBjy5/ATTYuPFR1K0RAk0DBHtmAblj4ut5QuHxOec+vhR7ms2tUfREm8AzyaR3EYUoO972dC7NR7WqD9T2iLk21ViGZizBkB5lXwbNFFfzRzns3CRubzDWiQDF1G6Sif4aRhiwY0UOjg+uRdn6/GgETOZzMBhE2ULXVhjx+lzQfd7OnOBQe53Xq0fRCbnTuIYqPXzzCOOiRDUsspSIznK2kSHwQgb6ZRLCw/YkUgiCmSRaAp4bgUBRmSj3qMcrvC8+xYa8C1X6LCo7aCLADOLcTmu8HdzgC40PcUFOowd3k/VUJnbf4L/+q19iZuM8Z8dOk9H73Dh6grvrr3KxqYKiMKAkqKQGGGuVuWP8uzyV8fFCwXpzjJlej5nKDrdSh0BKnuz2OGtZJCp/Cf4AvqaS77Sod6N5xpM8qJzjHrGLlAr6SoueMUyrEmc0V6OrhzSy74ASsJePAt+5+hJJHzSrQakPRXcf0zqMIRLcO7DFRKxGqChcPnIEJagh/ejczZTLHGrP4CS3UQ/KZi7g0WlkKOhR6cKQf2C2Um/wgeBNLjemKZPBj9u4ZpyrpmQ/TJOI98mdivH54fehhA4LFy5iWzG2cpKR2S0O3VUnHjNwVIlSq2LHKvj9OOW9YVpthbhw0J0ujr9HAovxfhKj30aRHYSqE9p1Ro0sDW+b1Ol1vivfj+k7jDSriH6NSmOeXpBhUt/iirJOTD0CUkP3NSzfZvX23WDZdD/gk61GBPVAs04jmeYDta/TFDnenOmitQ6x07mT+9eukZYd/JbL8O5lruWukXUHGLEnUVMu/apJcrBBAFhBDOuR/43L/knisk/bNZkJbRb6k1SMMoljzyFEwKnb+xihSzflMFnvkTSjkoVBO8rOPj+dRQrB7PoSsyJOItzG77yCby3waH6QdkLl7PhpnCfTuGfS1DM2x1czDO8EHFGX6Z0Z5nhthS8lpwCJ0ZjAtxpMs4HbnAAJrmlh+R4fCf8YjYDPKu8nlJGRy8TQc3z6nQbb6gRTQZsTux6JRBc3NPGFYC0zEtUYdjTadpo/HPgaUlZpxVWK7W3sochY6IGLNlqiSrbfYqAaOUI/sb2OOGg70tMsjF0QQpKeeJeCtkGcSMM64pdoxwWloTiTaotbYhBJlGzRybA0OUNuv4tq2fREirgd8BuzD6EKn1PliECMxTyUvoPml/iHNH4ADP+ex8cr5ynVRwmsJoV4j0GZwrUsfNliPf0C3eEJfCUEoZOUFnqsgB5I7q49gz+UR4gAE5uub9BT4+xM+/i9AtXb81yZO0JT0TA7cLk/yaNb7zLW3WF6e5UbB5IbRxbwpcrPO1+gkOxTWYvzX+0PMSp1RmsOngqj6hIrx4t889RjaGsdNGEzLtuMe2kmynuEQpAwfVKeQPVjnHCTCGOf7+JhhTqIOFoo2U5dAyChdZlc36LTGiQkRIqQaWWaRCD5qWsN+maMP747qvVASpx4mqSItup08xxx06ZLnNpgkYtKAdc1+WRsmZTZodOKcSMR1UzNmjb9VJqx/girAw8AMNxXQXHoNSMJpWJ6xLNtdH8Px5jnRG+Sde9jLMdnyHYr5GaqJJQWfelTTwxQt5JkmlGW1OqFXHjdYLDnoAeCpOizokzQbA/RH/0saB1uTP0I6xm4RYWQkPz605i+T1kmmFBaXGKYjXyR+dYmJys3uVmcIFlp0NdCUi58ZeILJEeu4r2dYdfdQgBDsRnAYEE5zxElAqlrxiShaFIMJWlFZcvcIoXBrh8V2CeDWUY9H+mCF2rcqW0RoLAVGyUVdjGVkK4xwNtHZ6iIIom2hTclyTar+EJSOvaHbD38xyQmFITRRXUVxsM3kULwE8l/yergPEbgk27mCPQyfUxsxcBMFrGa0xhujk07AuOL/jY+KkvG+5BS4d6xSQpqkm4ItvQp+lnEXsBFTnOie5GTvZmDvVrlVDUqRF+Kz/Llx5/hxZMFfLXPK/f+L5QKCeZKHgMy2is1tUasfhgt5jGjRAFgFcnboxoD7T5Fr0RbpugqCfSOyop/kn+HzWk3qkXzZQb9ABi2e1lG1QpjbsBAukDpoBl6wi4z50fAsBs3yCsOBj6h4/HG7B10Yhaf3FuhdPTPaI+vkPdbKCmP3ZlIQicFxG2NW8Y6WjDGhjDQ3JD+QfuITi5GvlHjFgYpdP504q/5zpH/hOEI3FiFnHaSZKvJTnKZZLfCCfU2GrDiv5eFk9sMOjWMwGXMlvi6jhoK0jJJL2ihJbpcSE7yVniEX/K/zt5LP8dj9iUUEdBvH2HKT9MSUcCX0nLEdAtbcVk328ynr5Dttrm+cAbh7xEPbRxUUlsaVU3l4f4KA8afQ3sBNbZJJTC4YS6ghCHFvTVWJ09zcUbF6S6SVne4r/sNHup8F+fuAY7lkzzS0xhe+Pf87nv+OZ+r/zLfdQULwH8888O09guEPvRHomBm1OghYhkCAV49JLAn0aw9AifGUKyNlOBnD9rfNAapxwNqsUXuqcIwbzFW79E7ACBWRsdUHZIDr3FhcpGsG2O8kyUUoFYWsdINRtx9NtJD/Oh3v4YShrx7+B7upk/buMr14hwio/FSsAhAfFAgjAoPp97m17Iv8EXnIt/c3mfY/2mG2iMgVKpxEzdWR/oGu/vzpGybK1YLJMzF2riNWUb7SRQ1y3kVlmofJJ+6SjfXZry0w6O7bzPdfJ3hQOEFcS+WG9IQOb7tPUlO2SYehFyoHaPjJ7jpnaYWJviU8iK+qtKPFQnCEncMRMZi79oql/oCpQH9w5K44TLa2+DDTZ0PdL7D4eA51vUuxuU6TlPymuozk6rQTGXI2F1C3WR39iRquo22JrhjJTqv12uPc3THRfNc+maMhpGmnsyiBgmE2mfpoB7qQiuSAre7GbK5fVIyCpz9rs/WYBo1kIw5EZjI9ltcG5mlJwx8qZHSQ1THYLK6x+bwHgmvz2C1RHlokadvvwzA7fRJBvoO+b2bBClJIS0JPLgjHrBnDhL6dUQzYMxpsacco6fGOb6/zuXKUUa1BoOhxqC9TGAsMkaJPX+akv95AFqDiyx0byOAfraAsAMIJYSS7LSPn42UEpP7aR5MuoydeofceJtjzZtMO5F1/xE3um9eLcbxjThfUu+iHD7JurHFsXdvke20OLT0F4xfit7S9TPH+d1/9KtcPHIvErhS87h0/BdpHfoMD6x9kMNWSGftAbbe/mnu6cMD1zymbyZJdgNGvYBK/aM8ee0zVDKRQVmh02LXH0OToHbm2fMWeVreIib6KLc7bCWK3O4Nk7R65Mw+lXhEPqXSEZjLLFfQbAvNaCCdJUDyROL7xNRzkStuaoexpcuU0xlUv0LLH0Egma6WUKomXqKEaEUGPV8kINxVMEQPCCg6AVLAJ/ZfwVB8Rt9t0qpnsBJN3h3Lc7YwiRQKa/kZDgebfHXoPQztX+Tu5TcA2J/sI6Xgjr1dYnNHQQjUTpvFVwd59eoo7f2QZhApaAbUCl036iNa0Ee4cfcJkmaU3Q5bO2iKzpryOvXpITaUGYZq0RugeA6BX2G5/zAFWeeascKePAJINM9ClRK1NUl6+35aD4PMBwRCMFreY210nGO58+SCGi+eOUJPhx87e5XRTg1DeHR9g/mNEh25ScNoMFMbBxQ6u3Ey2SpCCZhXRnFf/k3sXpJhUafhWuRFnbhvgJA4Y2+yWr+HbN/lmf2LfLD7FaSbxNPSSODkegMzdLgxkibR61Os7PEedZE/309idN9EyJA3eZIvZ5NIoXBf8Ab6zC2evaeKmzKQlQbHxdu4usWjLHO8vMSWGpK3M9xp3eCjfBcriBH34oSqypSxzqP9V/l9/8M0VJ1PTf0sVLOUa3dyY/IfYbUGGQgDnlzqEUvZ1MIRbGmwG8/hOB1EWEWVKpuOgRHUcEyVmFummZulrUrGyz5WapeM26NxCPq6R6aXZKDXwFcUVtNFRuo1nG6O9PBZhJCMuQrgMizLxPwY6yddVOAak1gH/hZ+aohvPxX1UK3ZBZRwCL2n8Eb6Ad4vvkZ1JVIhZUSf2NYSE+Ul/iGNHwDDv8chuzaD3/0c3zGiR6ugwlAokbpB19zm9aMO3z0UWVjHUUgREqQiZ819qwCqQGQ2SNPBcQWj/h5vu5HE4d3DD3Bl7hCNmMDsCHwU/tHS9zBSExxaiR4Vq98iX0mgEJJRenzAu4huBrx4+T7GxRmKzRgdS1BJbPKXhz+MeqOFETqMK5FsoRimKXTK2FaCzlAPJ5FDCdJkpEE29S7rAjYxCEXE5hf9iMG1VB+RGaTRKtIzmySDGHZ+nmJfMr2/zx3LO9hWnKF6hWJfEsQ1Go0DFjNVxgo97NBkX+synRjj3Z7Px4JhFCG5vrPAcmycEJjX9hhpH8NIfxQlHjE9iqtAaLJx4ccIQ0FzaAq1OoLqtfDNObrqv+WrwacIhUIiaDM6vEOq1aavOGSFYGNgmKCiYWsKqpB8atMmp0oCxWciVmKlM8V/ceqEvTna9V/BjZ3m5cWnsZWAncwVMluP8lr8NiEK3bCAa2pUUlmm6iUO723QN0yuzC7iKlFPxHeVEs3yFK2dEbR+NO/T+jSSFhPxtzgsNulJC8/NoEiYUDQUIfh84Rz92B5qEGXKLEaJOYM013L8Xv5TpBWHWOYdthlkUBywhVqXy9l5duIxEm6AtAClwr6ehbQLRkj9A5E1+Rn/JRS6fH7gM1xKHqaZygIwUhOEVsSOtWSMMJZG60RBcqMZBXnzuk4gB/jEuo/DPJP6JR4efBJBSDnss0gcw3PpiSR36W+TbRxkjrUKQwdObb+0+ZcMt3u8cDLOnz5V4K0jUWA/UfbIdwWu1NijSaxxYCaRiAKvDWykV+X60eMcDa9EmTmgaxf4r/IeksATTp1AGOwFKVQnA6FKs59mQCtTcHzW1Aq92IE0tb/HRmcNgEryKPepWySEy76eYa0wTr4VcJ+/jJPapDwcPSpH/VuUYzluxqfwQgUFge/02A6GaHWKCMANokCtmzcYaIcEHti511ixNjizlebUxVeIOS2eH32e2NbLHL54naTf5T71Cj1MSt5hhoIdHt1/k5P1G+T0kLpokXUjQNsJG4QZya3qIr/k/hxCCp7QvoDiJZhOrbLXOIofKti4SClJ6jlkcARZv8HUW5Kj+hVGmhXKuRE62TRW4OMjGCwJTFfycLeHowSshlMMZ25SdkOuiJNMVHYwXQdTTNHQfKSfY7F9gcOdFU6Vb5Mwu3SKFmOBwrSmENdtrG0FTxH870YfX1H5i+EnqDfTqMObVEKDsXiTHEmasTjhZp3QTxCIgJ1OluF4g32ZJ56tQihYayUItSFaeo476iFJ9Rxxr4yeDGiIBNVMtB909QKXBnXKZpmjjaMgYauRQwi4Q7/OjfwY6V6Xu989R6BpdNKn6YXHWC+McKK2wqYcohkOMJ5qIowqn059i5xo8ZvBp/h31d+hokyS247OjHPyJQ6PXY72595hsp0W57QUJwKNwX6OEJ0H91doJ58i7Z2iGxYYmvku0/fcREHy41e/Qer2NYSAx9TIgfWaPIaPhqp0uSBnmUhG+z9Hnu/4d/Owdplkr4WqDSP9PZTRKDP8blMntR7HuKngzYWk3RojtYvoAcjkAvdKjfBoA+9QEkKNv1Ja5NIufStOuttEmCnkRCSnrrfzFJcaOKHBWjbNdF0yubNKM51HCoXVmSlUP0agVNnVo0DqijKFlIKgnkQ3HAbM6P3bSE4ghWC85ZNxI1Ll3voFlofGWUpN0HItsmqJU2s2+paNFnMZFkssbFxnZ3iSY+tRtuDd5H28txQiGhs4RyOySF6IjECaY7sYcgOvpzLmVGnqUeCXK1douWlmMmuYiiRtX8UxxwlUhd1gGum8TMmAgVic490VPC3LzuQQAjA7Hma3j5GE4ayP6Hg0nQE+lPAQtuCZhef4zJ2fY1pE5hRjtVMU2x2uz5wAVWKFk+jhPC8m3ub+80tcvHuBXNui6UTk5L/5/G+jOwHPP/BevnT6URreBq3+Dvn6EoOHv4fbT9C8/QhGcwTXmSXXGuPk5QxDFYcQwXkxSTW+y9pgHyUIyfXabJkdRkUfFcGud4RhUeaQuocQ4Cw7vGydAGA2WaN1cB/PFm7hCx291EWx43S0gKRzk6NDTRazb7Nif5yS/SCzqRpK5km6ZgrFL9Pyh4jhkep0eMeMsixa9SgV4aHJFrlSCyFAUWzytodM6rzf/j5+WMS642eYXqkwntyhllTZ1mcx1BB132bPKGCrceZuv8tOYZN8y2dzRKe8Pcqg20Elul/PH67SMwIGbkjm3nsR80SfpmpxWN1kI5HD83sMyyxW5hBICP0+6sAhpJT4R1/nufBp8ENmS9s4qgZSIsUtrtuPk+wHTM1couSbpKwlRBid93SoMXDrUyAVWh/1qSYt8q0GVxen+Z3hX6Su5pGKoDS8jNYpYikHjpu+hadKji2NciG1hvBj1LsLtLcTqGpANllhyI8Dkli7xLzrIhlHEQG7ZuRku+uYLDUeRgK/tv8HKOORqZjtTLA3nEBRTYbCLuXsALOba6hqgT8Z/RLrQcADGx8iadu8Kh7l2cQshaZLrh4ymmzi6JKXT9xB6PSYKUUg6O1Td/N/vvVnBOxSDBTWa4uk6aBIlbHWICoBd+Uvs6EN85+DD5IKNLbTe6ysfoLdGx+noN9m34tih7lGj7RVoaFEhH4oFNZVDc+MHNGTXpIwiPwtGsk4IjaE70icbBV0n5gdkL4zjz3QYMc9wUirQj2eYik9RdLr491YxCreouqN8J3VFcr2TVRDp9AvwFiLELhuHyKJi++0qIzOsz8XZRbNhkAGcyT7Lmm/zDPdL7PbKGDiMVjfR/FdRsYOjOb+gYwfAMO/x9GRfX7rUwprWofA1zEDk5gfbTZD+KwOC744eZlcP4dCgkHxLroZyVb2zCjAGzM2GBZ19snylPYK7x70YdLUAssTh6gkUqSlzXxQYrxTphabJeVbqIHP8O41jqy/jCokipAsiHU+Pvg8wg54sflJEs4IzbhDz4KzrfsQDY9PrjzPYW0PiSAvkyTqNXqxBKtFA9sd4nHzy0ipcELaGIR8XYY0RaR3Tzjlv/vuu4fuo9XNUdWbDCsa11MKg31JorLOY9d0rH6PQztbFJyQTkJltXyShICSrmB4IbIn2aNKMZkjRLAho0e+3k/jSodNY4D311YJ46dx3AtsT5rUkXw72SNWvIIev47vWSjxGI+8XOSnzv47Pn7uDM8ZKt8jZEYKBocr6KpPareDFJKi8FBGFEJPYUNG3+nyI49jaEkC1ebw0HWq/QLO5iM00r9IGI+ksr5mUBk8Sqn4BkposuodB0JaigKFKBDNVdukag4Zu823HngPDQkCwWTlTt6+Msl+voiwe3hmhkk5iMGrDMWrHFY2WWcYw9kh7mYYUFVCJE3VphorEQvThIoAkcLpzyGCBgu7BwA98xYAoRJJO+ecbQbbJdpGj1TYQEhJO9OllkzQ2jzD/oVPIA8a12ftDlX3/0Cz34ubj9M/eGhHGj7ywLW06Wl0TYfAjkB9rLuEVBTiRp96EEN2Ktj+fZhijQ33HFLrUQ8gribwYxkU6XEmfp7tvW9w1/UUvmGx4G9SIstQt8qn31zh0y/X6Wgabx+yiPVdcp0AqxNjnSItv4fWG0A6FiKzhgUsqz6j26t003Hu0M4xxubBZx1kSQ7xK2YH29nH14foShAoYOepu5GEOdH32YuVCM0cnqqxGZQ473TZGB7ncGcSE5+e1KlrcdpxlXtu7ZLUbfxYFddUaOoFHm6c53/a+ls+O/whmhFfQa6tc91SmCs/DEBLS6GIEAyFgU6MhK1yfuBZst4wd61YzKyt8XPeX6JoVd4+JjizFBILejysXmbNOwKKT8Ft8FPn/oL/8MafYiqbOIrDSCtiwYPsDmiwXj7GDgO803mIceMSVWWOqfQ19rtjrIoeOZmgF3ZImnmUYIgHL61wxwXBTHAbNQwQUlJdnAZAoqGGgvtXklzr/hZ/VHscKQRPZLZoOEVWmWW+dgWhTzKwfw2tEhEFvVGB0AdREKjuKqWcIB0KFv2I1FBrBZruLgm3xS+svsGt1Bhfuf0xRLzHsmYxFm9holGzssiWjqlHBMp2z2COXdbEMFamAYpku++jaycBONLsEnKbtdggE2qZnhajnWzT8GOYnQARbPPW0FvsHBjQ3GqmCAKVo/OrtIsDOIbBT371bxBhyBtD89QT9yOBn/nuZxn1bc6Hx1g0t1H1Cr9pHOYp80f4I+8jXExuc217BrMeOUPuWQbDI8soik+zU6Dd1mhj8uOaQaavo+JyYsfFTjzC6e0nCKx1znUS6MdbBIpg4doayeY2JxNf4aR+lbaMkRU7WFabK/FJ7hJLHMlHcsstI8bn5eOYwueQtk7cLyKESy+hEfqwhmC0rBG7LMCAHCUWGm8QCtC0Cb4oHsDgJOlEtI/2jBZvZCKDj0y7TqBrWAMr4INtCIx1wdtLd7GfNrAcl4XVa/StqLbx9tRhFGlQVUqEQqXgVtk28+zvL7BeiZqk542o/ODt6bsQoeRIpU9KRiTQvY3zBKrK5wvPENYkSWObe1Y7WH2Lo/IyLTfFL8kvEyoqozmbAIVNa4RHNyqouzexj0lcGyY+q7LUUumPXSBMreL3VFLSppnKMtNbZ9fJIgi5b/JVrEQPz70JQuFs5jjb/hRjekjPLrHQ9ck6uzRTA7jpKDs4VvFI2TZNK0U1lyJb8xicewHDBP0/p0n9tUZqssHw1G1CBC2ZZmblMqXhMdbFAMe8aSQSZ+cqludSfdBgsGniGBE4Pmxv8hN/9U0evLpKOZ3j1rBGOVhlLvwsufw2yzVJ1/pbrrnPk+c/0lT+hqDyWQb3PdbSGf528a9JeCmqGYtst4sMBfvEmVbadFWXHW+RIbHPqOgy3dtD6fh8YegJ6p0Ys8kq1gEwTMWrJGIZjgobApO20+Oe+E2eKVzmzf4xXuv8CA3vEVQhySZfoGdaqH6FqswREy7SDXhPLAIvQ3vH2dLaSCnwOhqhFBhKh2Q/oJho8kBwhR6D9I2jbIbjqGqIEUtyOz3GM8tv8Ydv/ibfHnyElN/h6tQZLhy2mSv5rKQK7L47gItC6IMmVbyCxzcfKGEthqRGe4ycXKWVVjkjlllV8nQ7NxgOsvQbVZyV7xPsX0eoOiXzLZjyeFM8iLrTY6DTom3GwDDxvF2q/gzd8gTtm0+jGh2G3/cHjN/3BwDoYhWtl0Q/O0H/jKR6wkULQ75zz+O8w728b/975NtVXj48im+USRHNcV1YXJ1tMlWB3ur7CRMtamKGVjkbGe9l95BBRD4O9upMmWPkzLsBMKwVFCTre1PMXpqgGTNJhBu4U5F0tBMfJ/ZEk1P/4xK5Q/v4usrM+iXaEy2ezb7NJyvv5Z/WTnPPsqSppKlZC5xY9+nUJiiaPgmpcXnxSQJdwbuuokqfm2PjBPEUzyz/beQ03XmQ33B/DF3qDHdS3M85UnqPX8v+DA4Gw3aBfPMmrd17MJJ73JP/bbrpKEapH7mLuNLA11IQdZ9k1UxQjzUICBixRzipRXHMfq5AIYzRCyUDI9GesmyLE91zzGjv4MoEqa5LM5ZkZSwyhQuXigjV57XucTp+gx17FxkGJL0k86LPvqej9SSqkPScMr30KJczp2gl4tyxs8bF5AlUJB9s/il7JZs9rUBG9EnWIrD6rPsM/5DGD4Dh3+PIGDHeXN/khzs9Ws1hlCCN3R8HKUFLgITJ3jSP7z5OgMoMq9xVeBaBpG3q5JyQn28tkhE9rpsj3LfwNqHi4ZgdBloB25M5XnPuAuCU/nUAFDFCxu3zsW//EWcuf52U8yoAIYI5dZUhx+feqfMEOz5fOpxkrbDE8+LjaEstit4Wn7zyMunAQcdAQyUI+3iawfmBaUJ0jvibzIYbTPeGWdT3eUH4lIMIrOphC8eLDu/5iRKqFNSNBvOGyqoR9SXTm5skXZ1//Lk/4T1vvUDBlZTjKrebU8QDC6H3UCQorYCW6pIwYFfzaBvRAZT6Csmex5p5iFFlk5N7z5LLW9y312En6FHLJogXbiO9NmFfpT5Q4gv31rkx9BbjrQTzN3pcEQHvFTrjo1W8QENsR595QPSZGdkFIVnfjIKTB/bP8uXMGPHcJkcGI6bsiQsOnyo/i0zqmL7DUyWb781OI+IrNLLXcOwpNHOHNVXFGLDI9Nrkul0UJO/ZepOzx07ROXD3O1S9g3dzy9SsFGq/RyF7Cg2VtP48IUWOiE2WwzFsb4VUf4C8JiipdY5u/xxbRpl4mMeOga+6VLxFNNOhsHfQZNobAwQVmcWkjzQsPvLSX7ERZFBFgNUQ9AYlHcuidPYnqS0/TX31EQgFS4NFUPc41ogR5kxEOwqek66P0Jqo0qfrq1TUNr4zSRvJ4f5llPggQuxQDnSqch8nvA+AvPk9HNWmdKD9LxUnSbg3segTTPY4vprn8LrJQrDJhjvIsxeKsPklJq/9Fp/561/n/nOvcvjm1zD9kL47yFVtGi+w8OL7aNVJTCXNAApLAfxp/AnmWtc4qlxhkSiTUGaQD8gJUu0kDXcfTSnSPeih2GpNIFHI+RaOFLSsGm6YZideYLS3Qybd5M2H78eTAtOfx0EHRxJzQo53LqDKKGMehBrtnOS+5iXO5Y7wT7Y/jzuuEgpJvm2wnKzTP5DBVswcMV0BIRjsFrAt6Gk9JjrvIdXpgg6pZJ+TzUHemVFwrSSHlS2GRZ0l7zTF3Fm0MGCrnyejP4QQPkUqjNUjYB8rRAFBW9HQQ49SJxH19Qw9rFQk/9tSLCb9QdpejayWYae4wnTJQfcl1n5ASnSYqO3BQESSdMMMrgqnVxTOMMpV7WkMGZLYXsT23oMUCoedy6jGUXKVC+jlEKE1EdYuleFILjxY3aaZMtA1hREjJKxpmNoQdXePnepNnuw0eXzrHV5vnOZ6dYFWzCShecSlQzvQAcFkIgIT7b6DJTy2c1kUJVpLx1c56X+EtBvyN+Y3eDVc5Hz6CFPsoRoJAqvBhjfIQLOP5q7jaA65noEWGMhQ4O2lGCjucDxV46sf+TA7J+Y5tnoNT9VYGZpmsl3ipLPO4dYG3w4XSSldDmu7vD02R5jUAMl46yjdUOG4rpDu1NlWx8DsQsxFkwGrXp5hBHejMXLHOsJoo1RmuHenT7Zf5PWx77N2M0eiFOJPhzgtjfBEyP3Jv2K1f4ZngzsZD0vk85vE0y5/YvwHLnRsYuOfpSq3eVfOUfaSnNZvo2ojJAZtUOG2owCCYyUPYznah4l8Da/gsZ8OSLk5NKGTTOqMduooahNF+HzejIKeXLWEFBJj4Cb6psCcbyFCwf7OLLWUggybzG78d0lVNRUZ+uwSkZ2H5FWkUHh5+VF6/QxhWyOtN2nLGKWBcaQiOLx+E6sVZQkG+g2Gm1W+M/goHTtBTtkj01J4orfAq/5xfj/4MDubIyS9LmnLRSXk+bOf4aGr/4SeWcNZDGk1BEIKajezhHqPnfnL/LeOY8Lymelc5p1wnjGzwtzAbTJaiXawhhr6vJ65g31/ihNWwFJMMtkDFYUX77ufrBvdsQMNj4zbp2rl6Rgm91W7PD39AlwZ4MLof+D3g5+l8Bsasa5P3xLsD36WhfWbSFWlnB9gMhxm2djgoXM1rk3Pg9lBDQXHxUP4YQJrwOPevQuc3tok7vTZmpplMrtE+4MBtg2t50bxrmmcal9hsxbDrG6TNvdI9n128hFAPzdWpZyOkWu3qcg4EsEETYa8dUruEYaUHbJKn8dvvQ3jJjv+AJd7E4zFWwxoDZzOAEIJiQ3qJMMokznnvMPTIzd5N1jgp+U/45wiEWKBnV6K05koO64GZRxpEhcetUKMZGEPpZ0k4Uyyb1VwpEItkaFGhpjSQvcVPsRrKELSCqt8v/RXtHej1VofnCIUCpeLx1BHdF7N3cni9k1aI6eZ2z/MbMnDU3SWUuO4QYqeFKRknKb9HlwSNEcz1Owsf37tfdg5mFDKBEaX9p3fIqUJHF2lffPrBPvRe1Fb+BovB0/hKiaJjS5pr0ctmcGLpcCtI6TL1e2fxqkeoh3f5lvNT9HYi8iOMKwT1FbIv5xGaYD5QYEUkkK7zq+5v8b/WPpDHlp5kc3CBKWxOukwigU6ism16Ra2YXB/4w2+WH2IAIVubppmK2rx4rYiorPYq/Ht44Ok9cgs5xmjRUERNBwXQo1mTiXT8jGWHsDQK3SS42xvFym/kcE1J1ACyfTmEqXCBklF8mS/zICm8DObAWoQkULHN1yazSGEgCMU+eur/zuPzt7C2BYYvR6VZJry2CGKG7dwCHg4qPL74fv5nmIyawc8wlvcCsZ4XjmDLgSF1hBP3vgwUiqM3fdHVFJJVgfexvFM4qk+zzV/AUsZZyReQgkD1tLD7MYrbCe2mGrPcLH3MQCWZu4ngcZNo8Fs/BwAWnsWiwaPBX+FxEeRAS0rzvJiRFqLkiDsaqzsR+9j021geFlctc0px8EvGRTbUYxZCxtYJOiQpJrKMteU/OfpSAL/hP06bwU6VS1PRti0PJ+Y47E4P8w/pPEDYPj3OFw0bD3GcTegV41ssfthgPA83ESagf4A24lt9jOvkR/Z5Ub8IYasbR4Y2mA/m2OwHzBZjyRCN5R51GmHAVGhpjsMNcB0Wny18l4AjmlR3yxPixPHolgvk2957A1ErP2GPskMm3S7OT5efJ5M3KZc6nBhfJirK0cRbsg/kZ/FlAFzpS1mag5h0McTUQ+elXwGT4Xvec8wzjoCwYy+gQesBIfwUUjJDit2VENhiohRbRpNisk2jWRUo7BjOMjQZqBr0HerjHSadHRB2x/DclJYBw+P0owup4ra4rGEycKB4+Bv7n2MB7p5lpOzpLVdZg4/xZPaSYqBxZ69yvaIiZtpYyspsBViZoe1gS1em/kiZ7INvj8cPTSPSp0TQ+tslUfw7Oj/GhAt7ojdojsokbeiYP+FdJNbZpHRsRuMJ7dRCKj0M/zi/ucgqfLRVY8Pbim0TB3LdLk18CZLwN1OHifMYA+Y3LdxCQFoeHzm0t8SKgrdg3sk350APUsY+qi+w0zmKB3RwVKWWPVOkRY9roWTSJknbU+S1wSd0OELaYNr2iCKUBHpBOXEJm13DuICw+kRENDvRDLLtoixmRikmy2Q2W6wU4+y1tZuAndKUm0dIfRjnIh/mXhmDac9zLl3/y9eNQTnsxooglS9hit0fMNFCEnGa9LGpCdUPKmwqfQZqfmIZBZDadEgTauzhSvHscMB8voKgWbT8zSWLY/9dAq65/BChaOxJtdPJvn8YztMK/vsW2keKXbR4k9C/GGc+CQPXHiLh945T8xYIkTjknEXrmfhJSMDmkzrMFkkNaNM7/CXmXSWidPjVP8chnTYMEd5giF2u21CAmJGjqFkFwnUOhE7n+uNcVuPUny3e0fZGCziTiXZPHaKfLvHd2YHWAgGkJoAL+TMch87t4M8CDXPbd1FZdDHCl1kqNJVLP632DncuMtww2I5th4Bawl7iQFyuoESSmKOzdZQD0UqWN4gsW4Pd9JgyRwn3XwCR4dzh2OcNlYAeE0/wkTq7ME5O40iouBgjD0K/Qh4J/P7BK5CwwzI+T222zZBILD8NXb0MgWryrZMMeLF6bp1kmqGm+o6RhTDo28qLNg3GKvtMOoftKipjHBzDBbWXb7HOW4aeYZFB8fX8NOHiMsu88oKXb2PFrj43TxKaoeC8iQi5hIKhcMrkXRwL6uRz2xjbQqUeAFFrpJVryFiOX7+wpdIiS7/+fKP005HTs6TYodku8mEssYjXpuUIukQ3RX1IR0ZCrT2MD9f+TluZBKMtrdZTmxwtXuIi4VZhpU6oTIAVo+1YISE71C0L5PwEiSCgJQmkKjELkhi8Q5vqIOM3d6gk0hx784qluvgqxofajxLK38Xd+xe5pUwclF9vL+D6t2mf/i9HBY6DzkGdREyrXsMVvfYMccQAjoijydVdsM0TyDxYjXm9rI8v1igEw7x4FUHXStzbfASXuYm8f9k4k1JRCiZPlHBlXFeaP0814K7SYse09YykzmbP88bOMVX0FLX8WN1QHClVWQxXCKphaQme0gJtyoRUDjUDglsDSTIOZf9kRgNs8VgW+UXApe9mEK+XmJQ3SX0clyKjUV3VXUPCEnkttDWFbRjDoEmeGb9bey4jwzqJHsdxnej4FWKqJ5rS6ZI/v/Z+893zbKrvBf+zZXXk/POsXblXNU5dwu1JFBAEpIAGREOxhiDMcY2xgcD5phzvT4GfGxjY2MyhxcQSCAJZbU6x+ruqq4cds57PzmvPM+HVS/vn6BL16X5qasrPPtZa845xn2Pe9wj7LA98wx2OOS2M8b4xA3sjiRPh32jiBrG8tSzUQ4zPUFCuvTdUc5sLVJLFNk58gNohOTUfbpek69HcW/1q8anOHFnBT0IWLImCTyF4tE+waEIkjDiDGHGYWp1Bqs9Rz2/w14ijlGjfhOzs8EtOcVEMOSN+hwJsYGQLkd7y7yYPY/h5Zgb2lzwMqgI/OICKzOHObn4NmboktxYYcxv/33MP5/7KpoSsH77k6hCZc7rsyVzJBsWTqDjnX2D7zn0dY7vXGM+Y1CRCW5GrzNV6/P5h5+ieU1HCljQj9L2EyRTfTqjM0jVYXyvyvL0IQpH9/EWJJ2LNuc/ucT/OvAj7KklknaRwYHTHEnuI4FhJn6m7ywMGVoqhX6X/SiOw8XONaZuv4YvkxhITBFwornCnF5HSSn8Tur7UAQUmz6X7zpDj4yBakXk1HXeb1ygFqR5fWGMT7GNtDdRlCRX26PMKvuc617H8KoMpUECj9rYDP6EA41YKthM7tJXLJojZWoUSCsNFKny0eGzXIwWeHk4S9urckD5CCKSXLFmmOhVyYaSv3xXDBDufeVzJNwhWvbDzFZ9lCjkwuHDDGWalojQlQQbteM4m59kNrvKemuOC9V7aKXvtr4Me6yOtVh+9OeZOrpCr5LA2brANfEFlIkdno0+yLHmFuNtD5OAeirLMJ1DRCEp7Tp1dwEtUWOY3yBYy9LYPhmbrng2YfUGar1O++IEVm6Ae1jyTxq/zcml27xx61EevTkgOejx7NwRcnf3fktRiDTJG2ceZaZf5RzvcDkYI8rkubF4knS6RnTXcGmsX+eXlns4UZoQwYTskx9M0LD2ycy+QiuvokhJTm6SYINeapLtaprLW+fYzMwzud/C9F3eSfp8142Q7vhNLmgrzOsKRhiClBiBZNmV+BG8Z9Dn0fYl7le2+KHZd3j17U/xv6/9Lq0DNhChDjcZ901OWi+x4hzme9TrCAm/k/8AYhhSVBRkZDLeXWCxeJG0otIph4hVk6ApGdNvcMd5nOuNpziQW8MOXVYzY4hhl9vZTXSpMleLW1iW5+5DFYLblWe4k7kJEvBMBFCQfYS9DgJ6ik13okDHzqP4+3TemiYMIW+M0vT2GIYPYukbpKVkd5gh78TneCsRUg5BkwGruXFePP0wrxRjkmvG8XldyzFULCo0GSiQcTxG9m7z7bS+Awy/lSvsMTAijrgK+f24pK3aV1D8iMiyeXhjyFAbopor/Le5H+IXT3+C6905zpW2aeTLVHp9Bm7MYG1FE9xpzpPN7rMlBJkBRMtLbEQVXFTmO7Esy9eT+JaL4SskHY3VSrwFXsmdYiRsokURVbr8syN/gPAjvDt51I0+yfwFPmqvEgiFsf09bLPC0KohAduHQFHZLGpI70n2/J9lSw1Jy5B7UHg7ytKSaTQR8Xa4QCgFZSVu1m6ZLfoZnXwQV+WWkwFq0MUk7uGarMfsYspOMZKto911rtQaDiKKWJJNLCTDRAMCk+2BxcDf483MHEJE/DflGr+TX+Yzq7/Fxe5FgoTK87mjeKYFfYWcbFPq76NIwU1jnc3QYTQQ1NghkdqjvT2CVNOofkhF2UQXIdUjJpM7EHoCS0geaBiUSmuIUKVi7XArN80v7/4DLEvnZ1ckx1o+WhBA0uVNGREAT8s8ImsQGArv3niRhBxgGgPmdrY4ffs6b588hCSWMp7Yvw8x7KIKDbu9x5p7ASGg1Y6T/LflHN3EPgcGs+hC8FrRpHeuyBujMdmgJ7Lsp9aI3CmMlMpEOMBTPSImyWtdorzBTXMSOwrpJpKoazH4yfQMgjFJu3YUU+lwf/rPUVNNZKSQyKyyvf0UzdUhT10eUN7r09NShAqYrkLBa1ITcdLeVDqomUVEu0/HbgFQ00sYkUdD9OiF91BU9rC0PRQUvlqMjUL04dss+qMMT/dZHp8npw+xhUfdLBJpp9DMk+wmz6Kn7sHJTmJ7CjIRzxZbts6jdsBN7uB25kjWT2JqDhKNXmGHYMZjrTrFtL5BKaizZk4T6n1QY+nJ3D0vUnjyF+ml1qjfRemd1D53DJ2Ml+EJX7J972F2pheYXV5ieuUyanaMKQzCkoUAJtcGjE3cJNJixndncYFW2iBC8Gjrbf7t0Z9kzyxzUu2Q6+vcttaoBEkMX7KbyNNKRUwMIy5OfJFAjYhEhBo1SHg9Gj8+YPN+h8ce/WMsIekWXU4mNrkezbA6ElFM3KYjdCYTT7Dv+vSkxRibaGYOjz5KwWNQtdjtjVCQIVHUp1O3sJI9dgKVU+XrbHglum6DbtBEU1OMdv7/UnBtVeV4/xK+EnKov0rNyLK+l2KjLCi1+qyFLbYFjKotinWXjdQYh93rJPIKbnSNO6kDyMhCybS5XZmktPos9Vyame3YzGK3CLlkFXMjQthF7i+8xKPllxF2Div0mE38JQM/wR+2foCetJhmiyl3m/ddu8q07lFWFJrGgJZnkcpVCXtppi/8Ek1DZSOpoXR3eNf4NfbrRdTM3ev47oyqTTPu49b9dUwjjyOKjE3cBBnRaMQkwXRxhezKHo8/80UOXX2Fd22+xkRnj2OD4wwyp7hv8xp7skA1GuHBoIYStZnbb/DdbZ0t0+fP0wNuRtcoNfapaqMEaETRKIthGYHkbPIO+5U3yXRGqBdjwJbopHgw8RnygcHidBvtmETfSzBysksq8nmm9TMMowyOGxM+egteVDf4vVyWA7tx8u7nGhiRy53OCAqS+cQ3ycx0cRomrZUEOTfHfv4QtWKJINAIRuDN4WG8KDa+EoU+kRBkG9ucsKpEQR5sB8sNsAZdkskWqurTFwnUpGQ4bnF88Q4P+kvIKL7zH7v4BkhJJBMgh2zooyTUTZoZl3GlxVaUZXLqKkXZw/JD1lJj5Fs1lEhy6O480aQs4jonObXfI+W5/MVkbFhSst/k+fAgHZKk/B7PC8mT/SKT/i4vFs7zy/f+E4499Dm8aYGM4PzWgKMPNjgUjZBfexrNHnD9UByLx9199nrx2T+lLfNCbQTD30aTkkdbb3E9fQAUm90XHmXXj+V+ea2A4bjonQJZv8125PADf/dHaIGPGQQcnvoc2oUMg+AEAAd78PLhPpYWsu4dpvHyKOGBIb9k/go/v/0MEZLUzQt0bZvnD5zH2zVJWDl6Rp9B20O1YWPiPKHqkK52CHSDlekZZAtGXs1xq2fjRDbfc+Mm0tBJuEMOZxrsqTakIxIChIiJT1+0aERpMmLIM4fXWazEfY//X/04L1a+xkJzk0y9wfBMiYss0JRJCnWPV6MmqpMnVWySSkg+kP9VAin4V90fYay8xsKZL1E09vCkzp3OCK7U+MGdL5IbNPHRCISkPpUjLILZnEDi002vIoWCkzvJqlcip+wzHq1xzF3ls+Ej3IjiRHwucQC3m+S2N80jW+8w4nS5MH6Qc613+Mq9LvnaZ+iq4xgBFBtbVAuzNGUOV0T4ZgYtsslEOYp2C/qzOG6F63KGUAjOKXd46c0fIdE4Rnb2dZx/VWf7ox7Do1/hHf8cO0aap1YdxojjVcdKsj8S7xfFjwn70UOf5cSZrzPubxLoDRJSoannuCP2oV/jNf8hpAR/TjLSqSFXTfS2h5kYcPb6BTYKowS6zzDQqNshh72AiyceZGAajFc3md96k36ks989yjc3HkEPYhn9WL/OiZ7BxuAWQ1NF7+qorSl2jJDU4a+wq0wSoVGObpHqbzOwK6iJBAnzB6nlNMY2V3A1QS8Z8XT479m/8ou8oy7ztyNdhoYFQnBlxmRh+334tUM8EOzgS4MX7hnlG62DtAcGP7r1N3wi8+fMf7jGh+zfpqCtc85Y5nHlEkf1DV53TvFOfgIxCCjeLdM3rF1em/kyVmceOdLh+BWF7kAjq+1wLvlXbAzynG6MgIyH3CcGQxqFx6mlspzobZEc+vRScS4pwwzVhKQdqDT0bSRgScmTyT8FwGrHf26nMsVYZ4utO0ky013EqIoT9vm8aXPcj8nFi2aCRj6HEoa0kkMyKOgDwZsjR/nDh89zvCnoGTqFQYg9mI/PdrhCIhqgJMvo947z7bS+Awy/hSuUNqu9BQrBgGxnlkhKxsdvUXAKoKgsaHHlZskuU97foGca/IfcR3jFOkWoakxXV/CiVQDqMsVru2fY02osRTY9Iam2T/Dg2Jv0XZWDxEmdpxtIxUPxPYxAYTXlEQJvqAMUJNNs0xmkmC7d4j6GKG0fobt8RP8quAq+aTC6u0smOcnA2kUAqaFAlQFLExpWkGIVuBEWUKXGg0qfJgpvRnGy8rp+kn2ZY1bdx1VchJBsaEcZdWLd+CDsk+nXiYxpkJAexI5iyYRG3tdJ3x3gGw0F6e6AjajOl6ubtJUG7iDHs8oab6W/xs10fDj77FLz9wmkTzLsM9+MeEfGQVnpSWxcDrb3KAQ5XtdWGHqCMaGxHsWfc7h+nsBUSfX6mKJDVWbwT6vsZZLc3CnwD9odCjPrCCHx+ypjuXVu56d4urPIQ60IXYIl4YHbl9G1IdecAgLJQ8JgvmgjIsnj1Qs8rn6Fb8zN4Q1U3vPm8+yUK6yXNYhCxjqHcIJ9stYIb+x/nmvbb7DRz5KVMUN2M5ojEJLDwzhp/dsDI+CGfPBKLLnK6EV203sIqbGeOcRrBw7S1QRRP0dztIx/OEvPNwCBVs4Q+irtSKfku6CAbyQ5aL3Mn7ufQCQ7aIkWTxb+L8af+I9sVAQP33B4QJ7EJEXaMSi1DPJ+i65IIqKQPaVDwV5GBAHDdAuAppKlYyXYVdq40f1oIuKQ8Q5SRrxS1lnohhRdj7+STxNl4dRUk3nv7ozAqMQdN5bl7Js7ZJ0SfS1OGFPBHRR8/LBEZi/AS+6wP0iiBgnUxAbSj50N25M6X1h9Gl0NGPf2WUtMMMjfxGYXhEm9eg+9YYaVvkF1WEARISld4Yr73bx7691MCAfPXeJ7vvgl7n/jTa5XBox6WQxdJRqNZcaKu8JBa4Cf3GMwLDCIMgSdQ3RTFu9qvkrdzPKBM79NkNbQXYWB7DNIm2guBIqGm4I9w+P66Ksc270PNVDI+l14okWUjYgCjc7LH2AyimAgmDXrPBedxs15rJ4IePOhLM1Hf4e18a+xLSuMiipKIo9QdomyktZ+mrpboBjGVYKddpqiPiTthxzP3sSXOi9HHfp3Kx6n9xwGpkI3NYW+oTCrLLOdG+P44Da37Dnq6ARqTCqkduMq4uNBgSupIU0zxaH2dcxMn0y3ysVK3Oc34++wXhjhnYMhO2VJ0hmS6bbYq/gIIdG2BKFdwFd0dNWHxF2JY3SL08XnuNY8xg0xwzRbnBCLnGgPSIz2yUcm20bEepCmZO1T2XsXQ7XPv1z4KgCFVotJI6QtLGZE3BPrBzEgqJey3LQmaEmPURt8cYjc9BvkOy12Mwcx+pKT5eu0zBQJB84bS/z+xi/zfzu/zLn1g1Rtj9ywx3zgcSE6zolon+ywwMdegW4CPv3ePI0HRvitwyN4ZmzOtcMYSiLgTlhiUmnRT9xhxb+CJOK9rS6K4qCLIUftZ7HVe6nlPP46+QjZyKdwuM9aNIa+59C0O5TcDDeiST6jhNxwazzdkjzydgXLKeCnFhkNB9xOTbMTHOCY+Rx2waG9miKMspyuHubWwmG2JiZxa0lQwUgO0MJNXA2uJGKCMd9q8LQe381qFBAOI5TQJpOO40y/pEMAzkQCt6XzrqXXUKM9EDqPvfM2CEEtk2KgLdPT0ojEOtODGSaNPi46q90ppA+qp7JjVtB9l5FOFz3wkUiSqPTVHYriFmd2bvD1kfi+P2t/leuahhl5PNR8jaYQFDsuuaDHijXBD+3eoq2nYUHi7wt6mxahL5jNlvBrh+n5GuJYiwjB8fYdgvYIU2KfROZF9ESaquJzyPV5qH2JQNHYKmhcUe/nUPsbRDLibM3j7F+/xo38JPXxUVp6jjVdp9BucsC/jRJK9m98CKG6qOouQWKM88n3ook+XVXncvQEf7VUwVEUkg/+GdXKn3LmRouvPPg4YT+k3O8xYxzmm+lLbJrnECJCUTRQIg61dkh6PS6m7qP+lkFlP6Lwkk5KtPjZn+lxczaJm9slZw9YCXMoKsybAZkgBobr+Sl2oxQjSg+Bwm9/9z5DrcdacJQjuyF6FOF0NGRS56i+xTejc2Rrkp1BHqc7gppZ533W81hKj89snGIpmsV6aYTsyB1Gpi7Tl6CIHK+rx/je6jcp9OPKnCt1OrMxeZbtn2Ex3ceyYxLhRvJh3g4PklDaHLeexxcqX1Af4pqYR1EMEqrFla3zSBQe3b6MXoR9u8SJ7dv47hgHeZ4j/Q18FRSlS2CNc8OMSYQbio3jBJwtx468Wv0oigh4Ze9eOmmVB5SbvO1WmL38PjKv/AK1xiTKo0PSk32+NPxe8k7Ak3tJKkocZ7uKwfLoAaTQ6HsuP1T+CT60+2XedXmFjxU/zYx5nYzSZ2Ak+M/vjWcaP75noe+BNwtGq8Sgc5qDfopKqsije/F+t5IOISXep/wDDvfLSLnNpVPnqfT2mBzuMNO8RkFxuLj0KJET349pf0jkOzQnvoCTEJitJK7mEAlB16yzd+uD7IcVCl6dVHUXhEKgPcHtyVgSMrv6NrXckIf7Z5gTFe4z8ljo/MHUMkJKDrcDLs8bVBNbbA0tim6TLSuBnwi4UQn4u5VDvG/mt/ivmY9zzZ9mqrTEhwr/jl/wXuC39N+hHmW51JujZ2iIYYjlgEBihBZ9s8q6V0AxQmZD2EunUUXICesbTFsKid3jjJKgYWdJdRMIfQITnaw/IO2EOKkYHD8m4RQ+u4FEUbbZy+o0RI4j6jvkafGextcZr/VZnJ+hqvbxg4CRMw2G8zEh8pL2Ng8OoCYsnp9KUey2SQwGOMkYLE7uDXjp/L10TJ2funaTnUSRpBdQacVzGh/0L6IguWfmTcpubAr27bK+Awy/hWs4qNEXRWxcUlIjoI87sclYGDPE8q6hx6YasnUjJF3r8cqZx/mDzA8B8GD1MyTvViPK2T0u7p9hqDbY1eAN0yeSCu8/8FX8ukrJasWfaUe0oyTirrxN+HBZtfiHv32NKIJZuU6uGl+cT2TWMYrPkRz7Y368uoHS8bg2uUCm02WuEdBTY3ZfCpMHeru8M2OxITxuKU223FmGWh9NXaUUBSxFMWj5lP0s++Qp06Sn95nwKtzmGLP9AW44QE+dxB42CKwyaT9CdOqokUQkdbKqoBjGF5ccCqyBhm8OGTPGkckarivp6ssoQZ0lewoflSPKOmYj7qdKBgMeX22RHMQMX9BXwZDIqIpUsgw7GUAwrJio3VEGjTlORvcRpXSSvTaOUPlmeI7ehMG1yTLvdCYxBeTmb9BsTBC0BQcza/T1BPXSHO/eczGVt9CVTT6wedf8oXOQstJlnwinbDGz3yNnDsioPd4ZeZiea/H44usYnsc7Mwpa0MF0S6jDAVLViGSIpUX8zeZxyso2DZmlQ5Kg+SBzUY6BDNiym5Sutzhdv0nfb1NUynhWnLANnXH+5sF38beHvxcRKXhFG5nRMf14H91vrbM2JWgPExh+vGfM4iY58zIryjmEErHvJ/jT3ie55B7mzx4t0L7vJTbUgIxSJNdPcGRnhpzfBCGQkc6+0kbpxJepXo7fX5Ms/VSKXdFiTSRxMDjACkN1wGK5wKP7AScGCywpx3nDfYD3im9yyovPTdMr0uTuuIf8IqrUSPvzOIqB3TGx9Coj7ZBBkKNGm5RMEAmffPEWSJNzSwa/t/nDlFIxeFnobbJpFbljNBn0h1iJJL3N+7n6zZ+j1c2z7psUrCZS6+OHRfayl6nrfZbtq6R68fe6NeYyNUjwhSkDacdMJPYGxmAEL7GLCFQsLaS+v0C9AMe7y+wwge/f5LeP/xgAuZ5BNedBEFd3htkUeFdQI517Nj/IA7v3Ms0OwydDrNsZUp6D1vfZGyqciPqoQvJceJrq7hhHbnexN0vs2wHmuZdYSk4yGjURqSIyfQNU2KzGLGZRplBEhtteXKV/YOhwUl9GV3zeFDqCuDJ9oJulkSnSS46j7whEOiI1GDLt7LKYmObmwklsN0ekK1T2qth4RMYmKzOxOcn8/hZ6skugh/RME8XY49jKDr5u8PRbJ/ihZ1YAGKlus3PX2l/fEDhWlq81fh7XNdG1u3O/OnBqr835ykW+7p+jSJv7tNto/8cPkE52GHEsBopCtRzLOfV+hd+b+E2ayTGM0Gek5TOqR6xZRU748ec6w/j7D8o2f5c/hBSCM9oOxxOvY236jGzt0cilCWp5DucXaaUT6BFMFtpsDjJoXzsLIqTqxkB6xO/zlegYSVx+7E7chzf94O/wiPlVbNXh1uwC/WOxnPL3+En+LjONg86CUmU5tPC6+wwKN7l/QyGKLKaMSwxUjRuj30fFi3i68nXmzmwwqBrsBCHP3quziIoRJvjNzDjPpyWnjRz3rRXQhGSqP4+aWGZWDejmplgaPEbZ2CY5DOhupij4ZYpeXPHYHx2hczs2z5qa3+aovsFaWWfDSqFIiekNWdDvoAiPsG+S7oWo+gyZ9B6hm8CYGGLcESRnPRCSUy+/jhJVSXgRk3ubKFHIbt5kR4vvmCC7zonGCcpsoMiQt9bvp2qmSHoubSNBJ5VjrFlHCA2v5KFldumhkhJNZnd2aBh5+sKioGyzaATM9deYH6ygy4Brw9jtcseY4PDeLI85XyaclkTbkrHxAUjQ1Qn2tH1e6GkUivvU9BwHGyusOWM8obxNVtSYA1Z0jXuGEfe1r4KUrJc1QiPNaHeTnt8kr5cJshUaPri5JB09TSoL+8UKJ823SDynU008jJZoUqiu0k1PcUKPn/loVEOVOj+98r+Tefsfkdo/R+vMN2n9VMjadxWYbS6jECG1cdyNe+jJUygiltvG5zjiHvkmlzjPne0RtF6b8xdm+fD2M4SqIOVleEDeJpAqt3txdXxalbTNcWw3ommVcdCoiB4nG6d5ZO0gmd4q9zam+PhSnJNshzmQkmAmy7KRJyk95vYOseFJjq4tU1AafGHrBK/rJ5jt7DP25QbN/XnmD7zJIBqQ0NJ8Lv84qXDIE/04FvhSp5LuxkSwc5K/nKyQ8+IKbEs3cIMj2EqLg9aLvGGfpp4usqxOoBLfk6/V7qWS2Gcm3GJ9LkcyGKDXdqlvfZCHhwsc76/TNSV7+djh8pVirKR5saVARme2uIwXgbeT5WDhNq/vnqNrpzkm1qhJjX1xjdHuYZZvPsm1vzlG8xsT3Egf4T13NhjHxjJqsS1Ec8BepgB6ib435J/P/Bp/mP0R+m2bA3stfij6Ao/wDAAfvR0TVEesQ9j+vQSHklTM/8Dx/D/m5PwPseC9h6Sd59zWJinRxFVHOKTM8lj7I+jONd449RRDNf7+Z8LLqP0O9xsrGDJkLR2TN+7GsyROrtCJLFJRh2YiJpJXB0m6G/dyR45jeQHZ7RgIJRJFVkYTZPoOk/VVqjmHH9h/HzfcfXQUjlBhL7OA4dX4wKbHXlYDe5rs9inS/YBhISYYygg83eTgzWv81rFP8El+iVufG+XZ6k9wI7qfgTD5YvQUQejSV5KISFIIBSNGSNLPogUmXxZ9/gs/z3/60U/xytgTcawni1pUSUy8yVkvjg9yOMLpWpl3iicRoU7KadFMxr93IHgGw1QpD0xmfZ/PKTa/nDxHIFSekq9yvJvlmRv/EL8wZKWcoazlsCyFA2OxU2vg9LnXiXhbznDlyPt46PLbmGEfX8b7tlQd0pkv8t3bAQvbV9i0KyScELwxBCGRjAmDl/q/yPr2XVf9b5P1HWD4LVx2qsJ2834ACtoWur6Ok11mSk8jAp+qjBMVKYeIzC1Gb9yim8pyO38ILQwwajWyukcoTY5PXafrZXnUyRJJj0tmyJncLfJmk1qniGmFRLaBb3XRnRJXj8fJa2qo8pV0ij9/8ml6HZsD4Rr6RhwERtM99JEXOFKpMy4HLFkL3JiPK39K9RZ9GZs8DLUcP3yjwMBUuDiZoCZcEmpILblFU+3xQFBHEx6RhFllm5LSIUeHjtGm4GW5HR1lzunTDftsF++H8lE8I0Om18epGlQcn0FSZTTbpxDGlbzbUz/I0D6NVCJ2spcxEzXya23U4auoQQ1f0alaGQ6KTUb2NogQGNLnyHCNY8ObhEJQU/OgQMOssZssMRxkAMnmXFw9u3nn3UgiDucfI0eTjkjzTHSWtpfG01Ra2GwXLXRrwM7GEZy6wfHiKgBX5h7hvfWvUjZ+haz2BxwLh7ihTq03RdZo8/tGwHJW4/x2HS0BDX0chIo/EJS1NpO7Q67PJJBRPM8s3YHecJ90coZ3Ty0hFZXRcId14sTSbd3PmGKwobRQwx0mVI1OsEzHrzMSVTD1Fo7eoeHN8w9f+Axzd4FqlDNBCBrJBBChKApL8y32wwSq7BO0MyRzt3g+OMNcIgZSv3/1h9jxkrwdxo5n42Nf5zOZiF3DBukxVrOxlbhXrBGVqYku6m68V/LjXSIp6BHvsVo0ZFWtssokE2KdpTGPSFF4sOpwYrBApOb4Y/N/Q4TwkPSoygxuz0IJbQQhvhlXe5JRkppZot1PM7S2GWmF3Jm7l9VakemwRD2xyWQy/vn7g+/hWv0o77ZeIurpHOxt0Nds/tfeEZpuE2N2mciqoWg9bhdfYzVQKdl1TmlZnp/8EnnrEnvJFdbG7//7s7yZdyg78OlpnWInDhzq9D56v4KX3MXUexSUAa9XD9HIWihIHuhcZlassFWKjVeKHZ2ddBt1Nj6bYdLEdC4xwgksP8lcb5oDR98iu+tz3/Y259/uYk1dpJsQHNM7OJHGJbFAS6TJX5aUb34fvy1/Dk2EXDtaQgCKlSfM3gFguxMnpIVQkOkHLIs8LUXjiYFDYehxtHCLO1YJS40ripWwgpM4SGKwizqIkEJy780L2KFP3chw9cgDyDDJ+ugYh/bXuU8qNESXTrZItt0g28wiFNiZ7+G4SdTkEmdv1kj3e/z+Bz/Ol44+QiQEI7VtqnaarpdFbYCRWaLFFC/WfpStkTiJObZu4vd1vq/0t9zU4h63Mapk5+LzN9uFD9efIjuSBz/B4tHPsSS6KMYhZhod8k4e1U9wOzPBaW+RSFo4vfi5B1l404hB0XFajB/9W4yXEpSqdSIB2/WTaEpIcCSuYOtexOXmGO6VN1n0Wlj9mIRpEPFqFCejh+QGr87/KRVzhY9e2+LXwn/Nz/zBr/MDm3+BkBEhKu5eiK5GTCptdv0J/uvxX6Qz+hqNloJQPc4mP0uVEb6n/RZ/s7XDWdnmzeqj3HlpAq0q6Kd3KGfic90ND/AzjRbHtg6wX08yk2xSaYcIxce06kTGFHecR5DAyJ5Lf98m6+cQd0cL9ZJJBpfiZ5Ce6lMZc9gtCOoJlVLPYTpskPzTFOPOJqKtMNtxcbVJ0pka/V4OMzfEuqpwzFkmNeaSvN2GoE2+1yI675Lxe6yVdbYiA0WGzEQGVmTRNdcYc3a5UjtMPZ1HQZLXdxkkUxztCSIitnJ7GJlFQjQsQlKuixKFREKhLdM4QrDQv4MuAw45bRwzJgJvJ8eRveM82fu7+B5oFxgQk4NeOI2rbvJqD+6E82xZI5T7TVwMHtGuMBP0Oe71WDYMTjohWhBR7HVZK2scb7+MAIaDfcjOUM7XkP0IQ4BEoB+NtcqH3Zs0rj2MFCqppkd5/zIIFSOMf76MiAHeZu8aU95ZRi7/FF9yP07vsMYP5v6IX73n/+Tw9y0zOPkahYlXGJ36IgA5Nb5by6UVHjaexRUWS1P3gYzYm7qXj735OlNVhSwuj4Sr3Bk+Tm8Q78sKgqE5zXTV5cSt+GyVlR5TWz2q/tNcKkzSDidJ1jw2SqN01QTpdpfd4iizB28QoPCEO+DQ3i1KTZ/r+qOs9lLcshc40NkieeT7WLzxGL5n4yer2FqSF4rnWbIqvMeL5Zau1CgneuidEiIwqfdXKLVjcqUv+pScGfLaBim1wdviHDKl01SypNt7NJwGl5xp7hl5h96swTsHZvlg9VlWi5fQJSRSPfxeEbXbJN1pgJRcKB7BlToROs7ZImOpNhu+QsOq8vDI27TdPBvN96KLgONilT8nhRAKlShDT0zwIu8CAefv3GRJ20FXPfoY2I0etXQOoY0ThVXeuGVye+l9/Onak/xe9H5++diP8+pdpcRCewehSFK5PezuHKHZoVf9H1TDP8HY/lUuJn+NbWWfUxtvMerVuGAZLDl9DjvnONrcw9dt3OlYUbYmZzH2NlCk4OqJE+wWY9BfLb2AkojY3ilgKX1CYwuB5E6ziKI57KgPETgKiX4NEblYmT1WKgkKjRsowJ5VJKz7vN3+DF913uLLY9uE+igj9RrWioMZSlaOqGRrcf/eoKBCAPmde9maPsqBtRsQ2QyTNvaET29d56XaP+XfaD/NsjZLiEPkxnf3nDFgVjcQCCa7j7HmlXldPMQzU+/if5z7GADXiin++0GLi8cchonYfXWgPcFsL8G5ZYE5HMEK+1TNFIGUFLwqUpPYfQsFWDHSvFBe5BvaYU6KmzSjUbp0eG/16ziGzim2UOsWWsbFs0IOduJWoxvyLId2siRch0SiTd8zkUg2p3OowD9edAl312klbPRQohFiaC2uyGzsYso8jqLx7bS+Awy/hcswNZZEfDAy6hboLlLz0XM91GGPIRWEjNl6LX2Nyc0lKtVtdopJCs0Wy50CI3YbX9c5Vb6GpvhU18eouDUiIXl68nlqnslNJZbZqHmVQOsx0a+wk4zLLwsdlZftFF986vv5/MlHGdHqtJUFokAnl9ylOfbrHE4eRjMli8oIImfQTyQJ9q/T9WJGpGLlOd0MSLV93jho4wqVtNFjaNcwpcaksccBsUOVHJ8znsTBJkuPqrnLgJC2lmPMi9jTQ95WQ8qZGBCnQkHoqcxVt6mmQkZ0n4PdUZwoyU7lAbKtu9WaAxlMc4C1H3B5zMdy40tjJ1ngpLqCFbjsmbHU0GKducE6HTvJ8nRsyuEbLTxjkpZVQDV3Gc1fw8qvIneP8Jr6FmO5Q1SsWNpyRS7Q68aJ8lDT2RhLMhxk6e6M4tZMxlO7WCLkoPcKZfW3kRJM5QZGwWCpNYeUCmFo8GLsb8ATAwPDclhMHUB11xFdMJMB37V5B19TuDJXgGALHRU/HGIkkkwbNYLJBQrGgH47AkLsKE1aUVgydlCdTdpjFvWoSiuqMuWNkk92qKbW2PMPcix5hYK/h7RVVDNCjQJa6RKuDNmUI/SMFuvZAqYaEtbmsAtLKI0HsNIxCEtbdb7g38Ot/AS5VhvvlTjxyZRiMKh5Tfz/38gKWUEKSa8/QApJPtnHUzRKNEn6AyzhsKr49LGxlR6ivEti2CPTXuXEYIHi0GUQpjBeNhn1fRajSWQvBpW2uovpZpBIdKGgWyoNL8G6vUjKlaxOHCJoHCWNTUtvkjfjZON18wEen3yJYr6Gsa0w7cSV70pyCyEjbkZHaZUuM0yvUxcKwyBD2a6TNT1aKhwZekzmdunln8RTNSJge+Q81YRBw1R4dMlFSBjoFqqbQ2oO69sLKMCNwMbzTxEogqcbL+JZxyi4LTzNYKyZYsneoloaRwDSUjHCFtXch5DhNhOjVUaUBmdvdWhJGyWUjLkb6B4sJJpcIYWimAxUi7VrJd6wR7hhzbA2PMxs4iYRSYRiMczs4oYm1aiMkBH5SDDa2EcKhTesJOcdl0J3yOnyNTpahr49jkeAlihzKDNDX4kBttoSPNGNZViK9NipjLBTGmGxPEHR6fDuXo+HghNsFUvMbi4j6nEis13JEUkDNbnIkZ0+U9VtaqUKn608QTWdZqQaV/jv9M4TKoK/GHuJ8t6L3FGe4k9GbtO1BYf20ww0DX/P5PFT32AoDS6ER1BXL4CEx5rv4h/uf5RW8RKbjTw3jCnWdIuuOUux6ZEfjnDpztN4qsGMUiWQ4/SdfUJPRbUddiIfO4o42PHRtTbJtyM0xlGkYKd9mIFvYR2MJUvDts6dbpG+qbNWb5DttHANgztWjh55dqMJCqnnWc6vsPbcz7N+7eP0XvopTG2UqcoipbBBut8hqoe8L4pQFcj7fbay09xKtdnyIwqzzzFqLFLxW/z3m/+ebaXMxybG+LzpspxXcDeTPD79LNcq36Bj1ji9cZofbfeptBxaYZKFXJPSQENKQTe9gSmLdMjRzOqM7bsEqopQNJQwwHSG+EJjertKOFSwsh7p8V1ItahlVModh9mlPXQl4lC0h+j6jHVUbuTz2Mk+fhTHLPuawDJ9EqMOoaMw198n6XhsHCoyWhviGgqL9jhpucvCcAqEw9sjt5gZrLEX5bnkxMTTtLXIDKvcNyzQ8uss3/obsmpssrEt43v9e3ZeIB3Fd4wZOUwPN0AkmO9vMinie2nVnuDNgsVo2ENpw+upJ7hyKE3NnAMlgc4aXRS+4Z9iy6yQE10MHJ7gCqNhkdO9ZVZ1neP+kC1GGW802Cxp5J24LzlZXWEz5VBRuhRFn3N+PPP1ueRZVOlz6qurbJSeIgrrVG7+LcXabUASEn+XIHJQZcDV5BBF6GxYAX9mfYJfEf8fftP5ZXYuHCB0bHIHn2Pu/r+geTyOSVNjL5DJ7DE99waTziq612Vl8ji+qhAkEgyTWX7i6yb3cwlD+Fzsvg8vPIuUYEcJIn2ETK/OZG2IqkqywmFJZngzmOK2jMmSoTPB9fkFFBmhdxy2cmWCssZiYpQfU77K470aK1MJmoUREBqr9gwF4SCnHsKNFFYvP06Y3cJSUzQzRf6qeJoT7DAvttECn1RyD7t7gLC+yKc++wcUW/HZCvQVlChNUqvjRgk2BweJ0hqRUGmYIzwXNYlQuGfkIs/e/xCOYfKxva+wqxt872CZTKKFNyiR6u9z/tkXEZHLcn6UWmTzie5ldDNkOlFl1VXo6pc5P3oJTfH4SucJAB5Vr/JcMIOUIeNuAidX5ssPPsn9Vy/RIOINbRELSS8ysAYuoaKyk88hkKS8Bi+YQ7ZKB/mNe3+S3y/+IKuHdBQRcFudIRgbw5XnyXdjgOxHb3A88VlKM29yLNwmEirfH3yJstfgRvkwl8UAn4Cf2jiHJgOWjx0GoNpLsZOvkPQaLC0cYP5AfCYoNPCvW9TqsWv04dDHErDvqZiFWzRa59mpjyIAXdnhncRRAk1QrMYjIjaDB7nSusBw+hA1bZdnRm2UKOCHX1tG9OFwo8ZLI0lOJ27Go1ZyOsO6yah/ku2pBdQo4sSti8i8TnG2S75+Ay2Cf9aNq6aeNoUTxVXPgtGhpCkgJe9/e5TtsUeZ2Vnkd/xP8Ytb/zP+M36b2zmVTxc+yGefnsKKQnaSJ4hqKjPVAH1zm7TTZ6jpVBWo3e0VH2u37hJgH+b71z/MpfARelg8mPhLfjR7li8G86SHLqODOzy8e4dmL2Iv43LOj/PItdF7ePKtN/BVBXOyjZQqz5QkG+MW372zzKgjidbXMfVW/HPSxlZ2aToJkrqKEIK3Np7j22l9Bxh+C5fju2hSIZAGurJF3YiT6ai4jjLsI5UExTALkUC1NxmNFnnsyiVcTZAbtoikQkb3cC0HG485c4PbyQPsWRWm1C5TuU32nTSv2HE/lpGTNOxdhDR5ePGfAoIDPcmaFTFSW+HLuSdQkGQjA687ipXYRqh5hn4JIST7JNEVyfb0IcLqDQZOLPc4bld4g4Cp6pBqTqOtpkgbXYzQYi4q45guR8UWV6I5NqxpVplEJUIaVep3mZSMY+Fm6twRAWoYBwU9e3do+dYaoieofvPfMt8r0Y8S3Hfh10n2etiBw5PbryMEvGUfYy+tE4kulhdxSz/CKE00EXIzFV+iwXAHOTRABLxTiS2Gk6okVMtsKSM8rug8Fr5BcvoCSTfNH1eeZRiFzGTid2MKyaCVA8AuDRnkBTvbh1F8H2VbQRGSHzRe5Z9H/xlXHiZCRRF99HSPW80FpIB1v4CVk2SdgAf6aQIOcjszzbH9z6CEAjUR8kT3ZSotj9ePjmB33kIVGiktz9rIGj2RxLYDVCFpDm0yQYesET/Hm+Ymem+DtbJBzx2yp+5jSoMDIslWepV2OM7s5G1uNxeI8gah0JnobxAVTHqKwTrj9FXJwIoJC6OeRkk5FFnESO8SRQrvOfj/MFJ+nk42y9StNWoXY0nizLFX/n5v1/MDMm4P7+7MsZowiXISrW3RUU3czHNEhedRpIovBGkpiaTCEfU682u32ZK3mXMn+D6+xA+JPyBxwyfrOCzKcSJhImVI1d4hPxxlqMcVuqlEC4B9Gb+rvDtgOoxlNcLNYCoxM1/R6nx0/jOQg8yWy5QTS2zad+errbmnCQON250kX3DO0EGhZDVpJuMAfsjz+Fhxg/cZL7FTKNNLZOgUP8bbeYWJnsPx3QgNaDpZAieu6HbvVudOjF6itnc/rZzGo823WBIn+PHaRbrJDIW2zh17nTU5jaF7oAjmWmfYzs6iWpc4PP53nLncIRgofNj9Ff48fDcnu13e1wxI6x6vGRYmDngRt41ZNtrxaID9jePklQZL+fgMdDJd2sM0DbNIJuijeV1+6+HvQ2ohr9oqhShkpNfjZOk6AO/oIyhSQSQr3LK6XJ2KiRt9W3AkEcsw7d4AJYq4eugcW3b8HE/t32Y/mcfTDeZ2B/Tbd+dxRfNAhGGskHNC3t96hqGmE+ZNGqk+lWqcKC8HJ2imLD470sGNXmYnvcWLqQGRnSHjCUzPod2YYja/yaI6Rlm0ePEtl+ylf0LWfxfPVv4OYXfpbdhc8UcY2geRQiXT3cHy8ryzeR4tDCibXQI5St3bIRzY5JQmflRl1oP8vol5WUFzQ3bK91OO0rhCZWlvnqmJDVAjepsWSqTTs3QIr5Fpd2inUwSKxlGp8kp0lANih6dvfwp/UGBm84t4ThIj9XFqr/8Eakeyth2z/I/afUBiEaJ3HXaW340g4t7EpwFIKF3+U+mjfOTU79Dr2zw/32DDOIK+L/nLdshGahtf2yXjH2CDOR5WrnGteIyV6aO8dfQxImeS3dQiWSeBW9lid8TEdiOmrAGhZVPZ38fux7Ly0WGdftVCKGCkq8yzSSOtkuuElBLHSD3+UxTOdhASop5HeLeaq5sOen8EM3Z+Z/9hCy0RMFHvYoWCr/rvYX63j+JHNJQchrnBmJuhKKo4hmR+sARAtR6fXd0YcoyrHO0rLLGBMbpO2Yura6tiDJD87Oaf0hJJiqLL8f4tNLWCoo0wNVhkRt1nlzxIjZdKCnbOwbyu8ML0E9wZneKW/1S8h7fie2AlOkTTSJLT+oxGGzSNFFk8ysNlTBkxEQ7YZITxWp1AU9gvjeFi0QirPK/fIOF7fK9xiwfj64gr2jxz4TLtm8cJzVFC9wpXxyWddIK0IkDs0FIUaq5NhRpOLk5ojbtulBvKDN7eQfbetnCee5p/vWXy1nMl3GoBX1EYSd3m9JmvYWVavFEtkOy+zdLMETYLGfKdXT73vk+SC0zuk++w0jtKUy7Qs27i9zXaStw2onqrLJJhmh5CwKuP3s+YbPFjm3cQMqSdmOf6/EHCtEE7sokUBQebzeQMpvD5jP0ENyszqIUqoTVJqGgs3XOUq9ULSNWnvZXCMzZR9Qy9ZIbPZaYJUPi4+hynhjdQzB5W9yCdxg0WNjfIdF1M1SVvbVJT+iSVFovOQyQHIJJ3jeoK83zDthhHUNDbPHPoMSYae0x0FznYnSJpbGPpQ/ATjLQ3WGgMyK/ewTFMdkZGOLP9Iqecq2giZL1v4etvYmke56wOnyNFU0/xgHKTbaXCkrvPWJhjaWyGTirD9z7/NfA3CYgQKLF6xY/7qy/HR5k5Z5ct3eAz97yLUFX5katf5FMvfhU70SYwDFh4DxJodYsQQW9M5cOj/4lbfzXOfxYfI5Lwn8R9qEi2rTKXj0iWHI8zg4N8cKPNjdwxIgVCr8deZYpzN9vovs/lkQShJtCakv0LC7T8GHwdkj5apNDWeyRzOwROmt1qHJ9Dp8bNkRxaEHJobZ2+HTFwj9OJwxdB0kZVj3Om2uQhJXb81aI6fV2g2ot0tRyRKujXR8km5vFMk83RGU5ff4N03iNdcTl5+nU0PPaiuL9SVR/BuasA02WfYOkb5Fu3uTF7lHquyLlLr9J4O8/JRNzLfGiwzG988SL/9Paf8mTvy5TcDZqyx1Q1ZCMBh7aeZboex+hVM2IzHecwBzpJ6nKENjpnbAVf2vyV+d1Mmlf4xKaB3VfIDZu87Gb4pm1ydQ3aaY9JMSQU8NXpeR66+hb9rIJV6dCyk/zaqTSjnYB/vr6GCPcQThd7O85DRmWTabdGuqcTGlkM0YO5+G75dlnfAYbfwrW/pZJyR3GiIprYole4jFqHXv4KuhNH1blhDuFlEYqPYvZYqMX/3+g3kYBORD+hMlobUuw1GaoJIhTOq8uYVo9Bd5wL003CIGZ+2z5c1yWFyEQoSUZiUoTe4A4vZ+/BR0X30wy7I3ipLc7619gOYqlb1YitpAdjx5Fen7AeB65JJc8XcvCU4pNwIlpKgrTRox0YjIg0AsmIqLEkx6m1bPaIGa287OFphyj1euiBjW9t4EUG1/gSAPUjCyh6xMTyDj/43ADPy+Am79COeiSH+/hmmoeUC7iZGBR9OfMQgeESConlD7iunQQglQrZtuLE3Ol1cIZpZpUdGnftCJMKRN4IbmTwwHCSY/Im+5MtJJKp9lk2vTUmzFiukxEOXjP+e6XjTaQv2N2bw/cDEu0k2b2AXxT/k6tylob/Lja9+LuarHKjfhiZ1PCFTmuswNx2gCc8usH3kahneHg1lvjt2AXmtWucXq+xWbbYSQ7wpcuBzFn2Cld4Rx6jImMW/IuTCQpeGzF0iKTkprmP6m8jhaDr6qyY8YV00p1iP7UKwOLGA7iBQcVskxp0OGFcQqZ1mhmDUBhIqRHJ+Dtm+/F+yxdvk8zGMxzn+y6N6TYIwYfeeIbLxQUSikclFf793h4kkoz392hJQSLS2LOLkI9IywFXlDx/WIS/zA3poqLLgPEowYY4wlPt11lYX+OmcRMFhfcMt3hK+TrycRcrCrkjJxid3kFGHa7YAZX+KH1LRxJy1t5EIMk248R2stFjKizTVLuMO1O8tnJ3pmflGubdHoVcW/17YNg3dUIzwXGzymqY4xX9KMVMLAssa0OGdlzJOuj5WG3Je1JfQT/aZvlIicCYYCehcmY9JjVCoO7k8dS470IdxvvgZDvBcmuORtZi0qkz5tbYmtCxwwB7KOgpA26LEl7SR/O7/MB2CSkEp05/mXM3mvTcLG++coBeVOBz/sfoCJ0fuQu4XrYSCLUKXsjygXnuvfAiuu/jbGUZ+gka6QqR4uEkhxQverS0LPmgza2kxeH5O/hTPV6z4yQi4QYUjBaj2i6vGQqaUCA7xXa4C7aGmzLQNwW2EiCBjVAyXd/nxqEzmG6bvWSRZPU1XskNEFHEfL2A4w3wAo129yC6tQH6kFYCLq+fhTAiGjGpFfcoGE0KssaaOk/VmsQOLP783QPemP4CSd8kq0+gBwGFdp1aMIvvGwQVl+NijT/b+SDd6jky2p9xpxL38QR3YHMAvnkIISP0YezkvBRanK7fIWUOCOUYO4MGgauTl1UctUZ5kCHfG9B89f30EmVq+QXGpI4vBlTXRshbHcKDkj3PJm2N0TMN3pkokOl02L3b53NIKHw9Oo4pAs4OBTsHPsNouMp29Lukpz7PsLbA/HYCZ1twLLNOIvUmxt2+8f/2Rp3Sao4PjfwbDlTrSODTtd9ga1igkS1wpHqEo/176Zwpkxx4rHUFHzJs8vVthNBYGT7OUWWd9cw8v3D4Z7k4dwbfPUnT3KLSgezYBfZLBlEERzN7oBmMbW6hBwE6IXvZFK3lzN+f6VIIoSoodnRKxz+Kr91L4q7kdoc9HshcIooEqVQDqocQpVhZ0SsLrBkPvQFGYJJGodyRjK03kCgkE8v0CZiLquiBQNO3seWQYrsVxwE1x5nwCk5rkQ3zEvkDXcZ6McnjJUwOs8wJZ4lvDuOE9V7vKoo+g1CKKGGdaX2f1WiEs7sdXqlIVDPCuibQjTTf6L2PxjAmTJJv1ZAIGuZRuhEkhMsxv81PH/1lJt19djTJcddDAbbEKIVarJjZHJsl7QmePzZCSlp80L0XW5r0nBa2CKk5eU7evs3Vwx8lEqCaJ4m0JI0T76aoKdhil7qi0uilmRbbnBpmkFKi9i1GmnGMHWsvARHacAMfgaeoLK3cS9ObxNsZY+XyeYJvjPKi55Dt38I3TJ47ez/Z+g7Xx84hz85jC4e33B8m2dviA699E7+jsWvEwDAIV9lAZZz4mZtKSPO+GX7jE4/TMxza2Tluzi9QpENmJY49i+IQIffzL/lJfin6FLvuLF52FSt5HHSolYrcLMbIItCHeO0enXS8X3q+wysc56Pqi9yrXQbA6szxVip+r6GnkTU6dDWb84m/RCXi1vAJzFAlHXUAybqZ5ipJnkRn3TnJtcwxvvutZ1lV88yvJiFrIoK7MvjuBnakITbjX29OjPLvf+Cf8Pjdu2BxOMlOPk6GPiBNOghWjALHRUx8fU32KKol3pyZQvW36GhXKPS6jHbBFxFW4NCMkiScAdvRBC0tw6zeIkpqmLeafPit53mq8wqdOyPktrv0klmyufvZU3dwZ3uILoSTIa1kXN0zAo06Fn7lBQCUVsCz81NcCwx6DPjxRclucoKwrJPQ8zxy+xYzcowTV65Si0x2DlYQ2ya78gxtL77T54OAKNLpaz2upm+ylXqWXlNB0SIStmRxTGe2vkGhFaGmRtAAP59F7XeQCB5Y3eDpV7/BkBgAV80xyq1dCuEtQmJDP+kcZmBq2L7LO8fuId9pcHxwC6FAptJnOthCM2JisW/FxjNJBU6/+QLe1b8i69V54dQYiX6dA2u3qV4pYDW12BFDwEH7RZJdh6TeIs0WNVVwwAr5sugx3apyaBC/zzvpDjlzChlJrHCbVVFhrFGlfuAtJIJLvItGMMr3am8QGTr1fJ5yTfALlRKfyaSY0btM2B3WtXFO3riN6QV4/8AhMEO+duw+hIz4V9d2SA+midSYENtZnSYQgnmxTUlqmL7KQJ0kr69z39mf5ttpfQcYfgvX9KxG88BLaBjoYhO1uYGxpBAWV0h5AqRkup/AH86ghTrXZ2vcmJkFYGHlFk7SRlVCXEthbN/lXfWLaJHPYXeFSqKBokQE7SmckVs4HRM71Yf9BBftWEZqqSaKp5MKNAbaLRzV5LI2jxNUGPTyhHaD90dfIHe3pN7WswQI0sXY0EFpxpIhafu8+kCOP57Jc2ZlgBcqqJrkocUfIBI+c5GPJkJCqfBGcIDW3VlJY2FIvXiW82sxy5NPx5K+5+7ONOyE9wAzaMNdXjxmUbv3HRKixzCMP9ewfe5XLpE24wCdc3Ogd5FYiGiHq6m4jyJbjri/EoOugRRIqTKV6HBqPwYHtmpCL06Ajup98voWl5OHaZsDju/fj62+gUGA7gcUFAevl0A1A/ILHTpLFcLQwJUaB6anOHO7Td1I8MPeL7CurNNfSiEl6P4Oq50phA4yaxAaKsWOz6uVBk50Pwd2PCZWYjera5kCk+oix7Y2UULJa6fPoQqdrHWAqWDIJU4wFvYIUHh13KdTdKgJjbrXQFpNVGWPYqtKFAkWkzGYmfBLVJMbQMQLnUcAeO/2a3z8yp/wgBEzcqup2NAl42WYc5r4kUXRWIUACgdD9PQuCpLjXQdDOYfmtXnyxgWWCuMMIoML138CoUlAQ6h5ylqPDRHRi1LsZ8uYyRCDgCvJDgWngK9K+nqPBVaQcppXsg9ysrfIqb1NLmfXCQiwm4fQd0oYozHAWpQTzB79JkJd4bpqknYqBIkBA8vhpLqMbkGxrTLUh+TdBCMywy1rhYHUeaH2EAoRQg/IBTZRBLkwQdYHRYa4qoEzPouQUGje4ZO1v8ItxJrfMUUyTHTIBEmKUUTaCfjsO99L+yMB//HH/zG69Cg7EQvLIdtpQSSgPihiJveRoUG3W0IJTIZrZ5kpvsiQ+Aw9XX+OF9LTpMM6WiSwHJU1koQJg3JHYuy5/LP6/+TBnS3assAXNn+ODT0LSsBlEvy3TIVRHKpOAl/O4VkbKG7ExvF7GatV+fDzXwE14HL/PlJ+CjcdO+ju9ys0tQx5r45dusyjI2/RHfXY1DVa2CiA37I5lbvOKoIuEk23cKUk8CJalRH0TQXTDhlaCpfMBof31ugl01THRtkZmSVorPF6SWe0uksiHIGwQ6tbptqdRkssIYXkMw9rPG9MoNZcolGF/byLXXSYY5kNq8xWcpKT9fNspNtsZRc5u/EYkZnCkw5qFFK3LZrNMcKChyIkDyuL/CQ9Phke5+3t7+cvbr+Pq+ER1A2XSDnEZGMT3GXaSkRNN3mieQlFRPRlhX4YoXohdlDFVz1yzRSmGDIYP8ab9/wbIi0iHUoQINfiqmjnhIInFArmKO2EyZkbb2D4PtvpmEwbo8Frd/sMrfLfcrVwle37votiV2Hkni8y995fYth2EG5EpTvPRitBNlUHJOPe1/lk4ecYURYZWAp7jNIIZziz7/P+d16ioh+m5JQIEnl2R0f53nqJJ0fqoF9GENJ2Y6AkDqVpmrn4v9UjlAbjaBEUK1cIVYXefp7DqT0UGWC3GkSKACHYGK3QWUoj71rJSyVOWs84CooeJ/i57lFkQmNL7TKSu0Z7mEFRJNs7aRKFOCHttqYZlvIgJJXeDmnPIz1USG/Flf2HzRaB0BilweEtnTtTHmpeYXRQJQIua+c4KG5yq/MalZFrGBmPrNNGlz6+nuApXmZLq/BaKwZ4x+QKqj5LW88hCJmTu6xFo8xsuNRMi/VoBmXR4Dev+byufRdJJUcUdUj0+uS9SVwtRbMXf78PGs9w6EYWCazqOifcGLhsM0q+tUS+VWNjfA53bopAUXm3fwo1EfLZUpIOJulkEzmQnLqwS9YrUTYFx1JZcsWPcDB7Hl02yWh7dIMcjWGKCbnHgbDClhjwxiDkyG5MEizsVhEIlkXcQzo6uI/dcJR2MEGeBsN2AedCQMfoMb2nYrsObx07Q9Df5QeudLnHfoEtd46p1/6WE0u/i9l2kC2VLWsaNegwCGIAWlGaSCTZ7SatfBJF+JSbt+mkZ/n+3S9TqLcYeAYJr88dDnNz2OSN6AxhR9Da8giNHsVCElv3qRhFkr2YLAwzOdSlPtVkDBSTgyZ/Gz5KWbQZOTWASKXmTfLKgWmaCZMrzggZs8MNb5yD+hs0tTT7/jxmJBhtNVAswfXUESKh8CQB7yhPIGTE0xeeo+FP4guThN3G68XV144m+PPR80z5NfL9Djk09nIVrPQWu4xSj+bZzChEEqZNDUsb8FZwkJzocoR13hAaF0smncQIqfbX+L33Kuzr20RuvMelm2SAQWlnl14nRc8qYfS3mbGqRJ5gw8lyLFwkbCRIbQ0ZJGx8EdI49HsMK4uIno0/IxntdWmXTBJKQCOxSimKc7WRtQYD3eTmhMHiwKfim7x/OyIx+/2czj2C41RZb1xgamcFTXNZm55F21XR9WkCqeI6KserPgPhIwX8rbZOT76EOgyRmYid3AFaKRVjcJWEq/HO3FnmRR80Fb25z3oqy1x9l1JtnfbOVQTwwV2Td288jyEDquFxytd+mMr2B+iIIQnP5fb8CXxN5+OXPksEeH2FYr9LVzgoUiFbeAZlGJBVA9Rujer5H6Jx/jG2ixonbl9jYPmE0kTbNXGN2ALtgPVNhq7Ja+oRdH2PoW5RkH1OOw0MP2TauOvUnuiynLqJ3jKw8HgjUUOpNLgYxgD2tK/wuf67qZgd7il7dIpHKXciZqtHkO3jnPBtKlaPasfmu770TRpmmh9Z+y1+vvubNJMZPnhtmcOdDISjhEaPgWmxK6eoG0nmxQ61fEwEC7lATlvDzt0tvX6brO8Aw2/hEkLwfnULSRlV7MItH9Z1IsvD0jQ0LyDplHhs+ynOrz3EZmXI5bFYZjOxt87msaMIAa6h0FTmCZ0+n+j9Aee0dUwzltronUn+xaXHcTsaiWSfWmDTMzxO1N+iaAR0fZPjfQ3PXkIP+lwwHiSQNtVhDJQWjLc53r9rVKIa1I00YyJHkJlEGYr48ysr/NzUGsW9/8Hc5gp4EXv6BHlnD+l2OUQcHMrKgH2Z44aMAci4F9LMz3N+JwaGenGTslbndLnH+EP/jVRhHSNpEIU1Xj6s0o4Ok48CXF8hQqCluhgETBnxwOQz4SpChEiRRPc3uZqfwI8UxtJN7lFjcOuYsdOrnalx7/U4GJqJwyQbCpoq8EpfAeAdzrBb6KGFKXLaNtvDDIbjkxMO21gUjnZQNMnuYmxx/73JBGdLn6UvdF4/UqZNiusEKDe7RIFAG7YJpYbtuoTj8ZiKCwsm24l3EHiMqzPk2jEgvlnU0URIWexxeGvItcNnmM6cph0lKPcP0REpRmWLDdUm1Hq0yya+ENx21zi/1kUoLoe24v6W7XQbTx2QcEZImEMMfZt3zFGkrvDBV5/hAXmB6WgVgojtRPxeCl4au5+mGU5gGPuwY+KMXUdqLlpjmkHHxkkd59DaO4QCWlaaidQ2v9ubwNHTCG2ElF9iLBXSAxaDNK5poWVjpjGyFf633Q8x2Z9EEYIjYpFhNMGnJ2LAesTeYzfts2usYtWP0l0vkN6L99CdaIKUXad0/Ks03SlAxbJ22VC3ySo92mYey1OIlBZjIk7uXrdX+ANcQqmSs1q03QyB0YRBiJkSBFGJDG2GiQyRlQAhKHl9Cm6Xs2/FoHlSaljakDl3kqGu4QRZPjv9cX5m8D/YFpP4wuCjax7pvs5SOd5XXS9DkNyl61fwzAYZ3yDKv8Q93edRm0/g6oLvqr7KdU5iHIr/Tr5dIIosSKY42O6QT1zkX17/c9qGxb9v/Bpd6xj7o126ioYn4It2jqTmsdbPM5PQCYwWhJIrczY3Z+b45DN/ywNnP81jl18k1cnhZOL7478e/RSR0Mh7DY6WL5JP1OhZcQ/gqpxESujVNE6PXwMELxInqLn003iaQVAyUatgqSE9U2XL3mO6voftuFw5fJ7C6DH69/4kW6UKszs9kD20KOJG7SgSFVJLHOlFPHMGssYuTzafQRpJGvlJ7JLPrFymmjTZy0+Sbx/hQHeOEafMsVaK/twivbu9/H6UYKc1Qy8HUsK/UpZ4mhpZeuwOJvj66nv4euVpVnY+AK/kaL4tuei9ly8n4oTrvkEslx3IOHAXhl06Qdy7nNuNwd9h/6vMam+ghxo3m0cQUlDUVVba07SOQr4TcizzAKWhh3q3aL6WGkUPA9LdTVSZZS2a4oB9kXVlyB+kLpIdG6DpEbrdhbCBNBQyU1XC/adg4yE+wd9xT+IPaYUL3JC/hulFXOUYncKbLCbzjLQbvDlxiOXoOQJcVudmmViaIooUSseqmGqNtjfKC/nTLE0ewF5tQCQx7RKV7jyIgGxmG2Vg4HSKJBSXBfc2A12hcLdXpl4sIMIRAkdFSmjL+O581JdseU0GckC5O4Ke1OgFRRL5Hh4GQaCzVdNQKz2khPrNp1jrF0iNO0ihoCCxXR3Z7iFNBSt1BIBmkOXsosvNaZPG3CijNOlpJq/r92AoQ9r5JdylNKmvaiRCjyQhSa/FCHX+ynoP30jHioCs7TK0E2iZJroIKUctNqMSzV5MKL7VO0egaUwMNH71ekjRNQk6u7xz+AimH4P4WiuOf1NzK4xvCkIE30xPc9rx2REphliYbouRvS02x2fppVJMrtmkVTATq/z7E7/Fex/7PfRUiBgE9MZLBEDiwMuMzr7NI5MN7AQQbJJS6vTbs+w7ScakQVYm2PYd0sLl57Y9jlxfY3r7FrnI5vlDd5Uc6gHUIEErmCBHB9nPc2UmllgebixwaKPHndkjbKk9SpVnSasNtu6YpLsbJJs1UCRKQ7ChzZAcVmmFWTSgKLqEKJS6HX7hMw1+4/XfZnT3BpFqMNkNEIMgntE6XOUOh/GGWUajJp40Gd6JGYTJwjalsMNaqoxrxWTC0Gkx6Krsp+JfZ7pNng3OUCPDI+3rmL1Jvl6x2csavHpwku4wQdboYqqSg+Y+z+bvw1a6WBFkhgFhxiBUNHJRiyk2uJA4yjGukqVJI5glyJXJmnWG9QOA5LcPP0UgFM5oO0w19llJp/ixV3+fCe0Oi/IgfmIGX4FGP8uN2YscLFzhS704Hr1LeYcls8AfTKgkfIcP3Ewy3jL5s0eq3CrHRMFpPU6lldUOhODlUqQGXd595XNUogaXgnEsOcBqCBIxx8lb6cuoU8u4mQ3s3gTShl+9s83SvZ9EEbCXvc35nfhOzg6rJIIumyMhddlkGEX840WXlfw0z508gm/Y3M5p9G2LUmmd7ewk0lHQlFx8v7k6U40ISSzdLLoJ5nYTpFyP5bEZrlTidhCt+RIAtydmOSiaEEU4UZ3nj92Ho6qszczSCT101eFH13y+24sdPH/6kEp263Em1BS1sIHtO7yr/irn0+ustzN8PvkEW+UxcmZED4eUNIkyBxDDkLTS48tPPsDW6GG+dMDGdiPuu3mFuSd2SBTTZIMOQz3+HorexjY8OoGDtONCwqLf4991Y/+AkjaCkJKaraHZTYqdOG7dKibZnimwM4znX55MbrHcCtgZZnkwcZWHg9i5WF96hN7Ox/iqfg+aIjGHfR7cu0Zt/AwzJ/YJxxLcs3yd2c4aI3fh07Wgx/LELP1shi1RZF7sEOnxXaMr4zSSG9iDuMr+7bK+Awy/hau2tkX7+PNsztQRQmJu6Gi9uIoV2gMMZ8ggKnOyM0O27ZAaaHSUl8j2+5iBz9Z8bIHrmCqdxg/TDw0+qC+iJROk7s7mSnemcEMNvwWm5ZFmQDYYMFeyqZg36fomR30DoTpUGq+xqcZWziUnrsIJASfq6/RUm4QSUkvmKPkK7coRZAiKKnG9AX/0/K/j+q9jRz4C2LBmKNRfQxv0mLibVLZFmQJ9Xg3mGaIx6cXM9MFhC0lEkNzl39z/Xzh/+mukx99h9N4/4sDUMwhgan8FJxwjLz0CV+CZSfJ6DAjrdoIw0FCJD58gBeEuPUOn7ieZ0OoIxQJ0vLt9ZEZ+DVELCaXANMehIxFZlbWFHYZOlg2mWZnqAxG1YJ6lbh5PQkJxsN0+pcNNBtsJWsMMI1Q5l/gfhJHFl70DpHIdCsLjzegA0lPw+xpFr4NGgDtQCMs2eiAZWiqPLj2HrT7DTDhFQrQIVBXTv5cIwZiyxolbVxjaSZ49Ms3lxG2a7ikUKSgrO1y7W+Gbases5R3FJr9mcOZOlkp1MX7myQA3tYHRH2NKjwjtNaqhim25yHvaJM/3sG5Bot1jmEvjiYj39zusOffRJUfSG0JnDD8RSyqTt97D765/N30jxcLyFp89cwJf6hzbu85P7P8R7dBGTT5BxilSLsbZe/WuXNnJxP0MDxRC0uZNDrUPERHhG1u8Zs/xammOXXLMprYYWCF72TvY3RluBSXSezAQBg0ydNYeoHR0mVG7TUORFI1l7snH5MJtax6BQIS7TCkm+1qDRafIF/F5xN+mbNdZ707iWJLJlodu9nAdi4qzRydTwA8DxKBHf2KeH557g24ijy5Din6StOYz647R15KMDJpYikeYi5+9HoU8tOwiEOyMxmfPkxodsw59C4WQKfs19hIlRoZ7iPY0jazJfb0bRCisn477XRO9uNIUpJKcc1/mqcyn6aV0foKf46KSRioaw/wZQuJne7avx0mEk2SqLlHVWMq6zBj/88OfJNMaMP5/CIp/oWJ0iwyzd3ACi/rN+Bzk/Rav1As8u/8A0psi4dksuRMIAYma5GBlCY0Bz989w1lzCj/7GHLWQUiww5CeoRAoAbpvcXB/m6XZo0xMPMqVY/ciFYXvH4wwb0I+c4i33WPoiodpr/KhboeZ/jyPZb5KS/8bkCHSfJBMyWGytw5CsDkxQzqY5t7OYX4yaXL0A3+GP12jZxlIwFYi9rpzhJpCW08xIm7xf2p/zS/l/oj/67F/x8Nn/g3v7v8x06kX8A9mKIsmeqBQV0PmOztU7hoS1Y1YMp31PHb8OCyOtEZpBuNMmZeoJJb4/tLPcNS+iu5l6OYnuFw7Fley7QjdG1CSknwYS9ZvJ20ODNo4/jHOSJWXomMsDDyE9BFeldx8hyA0uLR7iltDm2jCxjlyixtzf8Yn7N/mCIs863yYX4l+Gd9T+NPoo7zEaXxtSKozg9lv8ebCMc4uTWI262xNTGB2fFpb0xQOt9ivvEEHhX9x6BeZcHaJFoeIjo/MW5R7x5EjV1FERKKq4SZaDDE5xTVaCZOPp76I7nkEdhJpPcRgP4kQsGbqpP2IXACvihY3kuvM9nWKloeMbJpehZTVo9kcZSADRL5OMFRI7CpsdFXS8w4ikIxvbaG7AS2RRqTg+WLs7nurdpTTyyGt4oNERZtRGuxS4KqIWf7yRJuDr7bJfE7BHyjoGpSHDXao8Ip7goaaoRkkMHMqbx1I8eXCIbJ332vgl7gQ+UwFK1yNzhLaSfaP/gkP10LyepEvHj3M77//+xkmjqD0d3k1iPvy9VRIsvg5bopJUnsPcMwNWZfxOw6ExlSnhqebVNa3UczD+Il9jO4U+3d+ECc08QwbZRjS1RUGpYskjv0Ruyf/Fxv3/geWHv0XjI52EELS9WfphQZ7zkeIkNy09gnVK0wGBn+0VKfp7hB6Ic10gBZaVPUOOQmtqIKCpJTp8OahJCkvRTpIwJ7EMy1ePHmC+8NPs6RNkr7aZmXqEfQSdJ7UoKGxyRSVfoOOV+EQDoFiMIx0RkSNfvYChdeuMlqN5Xn6MMN0J77bpqJVdsQEHZnlQ3dHUW0MJpGBQSq3iqwUWU3ohJoPUrJ7MMeB/TXqydjgqNQc0pU2X+c+yp0eqfoYX52wuH/jJSI15JsnuqS1Lk+IyyhI/rLyPSSUNnqkYrtDguxdybt1lRdLAftGgsd4Fn9c0vALSFWlmHIY1hboEHAnW+Ef3foCFhGHGh1cVWXUHJCjxW1xBFl+EIngopPC1t/iVOkKV8IDeFLjXu0OUgjeCnw+vl4nFRrc23qcQhd2MjcAOCxiwNFwM0QZnfWJuL9thDmOpZZw0fjN6JPo/QYj6Xg/f8XSSP+1ShgJbnRiZcpu6RqXUgaBCCmFWR4LZgmlYNP2mOxdZbWi4Qd5TKDsSsqOx385lGU8aNO3DG4XRnAGKSJFY79SRo1xIB3DwDZDHr0mQcJ4PYvqSRJexEb2KRbHVdL9OpP7Q0JFwTJKVPQGaq/FaydnGSRSGNUqvmGyPW4RqRtspAc80Nnmtj3OzeKTbGkbJBTYVl3e03+BP7z5y9hZFSkF7/THWLXGsfNZulGbpC9ZMc6DE2KqG3iGxnIi4rkRjQeXu1RyW4zP9CgecMnqQ4bdM0RAM2NxVlwn4a3gpuP2nguRx+XuIlJI6nqBsiPpmza21aPgDumqCiOlLpvlCoFjoyo+XeUaucEmL7c/gKW1uCcdE4SpTgekwXk97s+/2J5CCSXD+1xuTZzlTP9t3n97FTeKiVyAZ6XNUn6SUNNYjsaZEvtMNTaJTAshTF7P7SP+5L/z7bS+Awy/hSs1VmD+Vo9mMU7mcpNNFqI9RABhuoUYdJECaqmb1NQdTi7mUKIG6foXsXLzHB/GlbyhTDKsxdUYL5lAEQoJrUkYKmjdAi3DxGvHv38mWGKiWyVX/ksy+oAIhQe9IVIqiO51tuVBVDwWgsV4Ns8wz9GOS1XNoyMJrBwKghsLJ/E0FVMGfEFbYai6/MraPyKIYsrcM02ujZZIBCZp2cARGlvKKO/VrlGTabZFiooU2N6A/OQyKw/+WyKjT8Ls8fKtdzG15CAE6GeH6Amfg7u38LWYnaOvMLBSFLRNPHS8tIBQoS3HKQ1LWL6Ff7cHb0sWqPg9SmOXEcIgsixMEaFYfabTr+BEKkbg4Tgh7yt8nhn7Mnf2zqEOfZyMTUrd547zCM8nzvHiyXMYxAy0mfOob5coWEM+JT9DQ7f4zO4CojULwFFzjUss8CsP/BiXxTymDLhfXyYyVLBUPEPhh7/yOgWthap+CQFkU/eyn0rw3MhFdpUckywzvfIMqX6Pi1PT9NUOjkyQGWTJqDWupWPp6al+zCKvGCXErM+ZxRxTa3u4uhKPxNMHmP1xZvSId8oC6YQczmzSfyoicSlF6Y80Di+/gUxobJsWT/db7PpH6WdD8uGQ0l05DkDJO87E7BGUKOTxi2+xlo0Z4BG9TSbbYCIcINDIuEXmg7gKI10P3fNw7bjiELpJgsIF8m6eulXlbzI6f16eBiFY7uaZttawo4hm6RYKKkP3Pmw1ZEspYknB5fXjhL7CJw//FRtawLxymTPOEo40eNuMEzqCXcqa4KK5Rqt5CkPCRxyPc6OX2emP8tzOQyRaOTRRx28GJJohXTvJtXyFd8ZmUaXkr+33E2V8DLWD4RZQBMyGaYaiQHbo8HPXfz1mToDT1RadYUTHFqRLNxF3mdmqCOh1E5S1fa5wHCH7GErApqzT1+ZIhw731d7mTft+sAS+H5M9MqFxr/8mnYzKp3M/wJutk8x5N9D9HkH62N+/j0eHffxIo+MX+UfhcyxELQAGnsmlw8dZnJkl9DR+92M/jhoUGGQ38D0LedftOO83KfcS3AmnWDV3SAcZ1nvxeysPHFQlopyq8aaiESFJpBSK0WluVf81bz38T9EiiS/ujnmQKof3V4hUhb8u9fi0eQPT91loRpxKlXi8/L3U6lMczC1T1n160T2caZwl3z/OjgBjeBMvcQ+JYvfvnUlrIyVu+gOOTb9CZmSJ2pUKretP0bUMPNUiI1zyHnR7BVqZBIZyG1u9wU4hg5Sw5Eui7BZGLkE4n+Y+XuPjW5/j57W3+Q+v/A56XkVKlRZxkqFKhR1fIREZ6PIgu85hUtkeLw8+wevaIRhe4rhIgNHj9t6xWDFxLGK9vcF25QexnQ4D26Zh5HgqKKGGPvcIleei4+gSTjkull8jM9el3ZvgmcUPEiHIVnS0vs6vD79BQd3iL6MP84J+kLB8k88bVWoUKfoj3OgfwR7McJ8zRMiI5dnjmK0Wkari6wbVqzk0K0JUrvHSMZt1a4zfvP0fORUtorQ92pkslcEk2uTrSAml1QGb5Umuc5DDxjb9pIamSmy3Q2TaqOYs9Y0YCK0ULA53Ii5ZoA1GKTpFZoaS42ZcNVhszZFUh+xVJ0HTUDUXv69yaOfz9AyNejaNkoyYXqsxCKq09SwZq8+N3AEUNaC8v81kDZzkE5Sba0zKfdaCUTpk6AwNysUWhV7MMrkdDYw+A2nzSvhuqsMkiojouAZFzeHN+QIro1MkYhEGhjfHAMF4fZU72SMMkhO0p57jncQWugSlv8fPfPr32SkfwdjdZp8CUoLVjagceJvXGz/L4c33s9z+GPVhfB+20iNU7hrE7GYmmS2ZOJkVDKfECf0z2LpD04r/bNCfYaD1+LNrP8fNr36ExRf+MRf7KuFY3E/flUcQQkUNF9ilQceo8tlkjj4utVBDEvH50QdIKmmm3BL7io+hmjSUuKJUGXmdlco+k90KkeoxaAUYroM4ZJNSalTvZHF1g//6sU9QfKLHO+fLbI+NEgqd6X6NwJlgRolNn4boWGrIB174f9D3fSy3hSbaBP4IJ9rrGKHLARErDzZzSezzv4EiI/btUbzmDE52mYVEkd2Egqe5iMCnbVWY0vepJyHTa1MZFglQ2SOFAEqNDktJgax6KJk0K6NtNNXnA8rrXLMWWA1PYCpdlMgg2dshyhtARHvsLf5qukgykNwTvI4/IVEdH0OqWLbLsDHHLRM+tP48C1Esxz3d9DCigKsz8T2a9AWukSRrfojXfA+7C/eWbpFQ+tyJxlgQmwjLR9sd8g/WNEaGAp0kT2zcTypIMlCHWJqBSognTIKZJPWx+N8eKiVmInhAuc1feo9QTxYZrdyPIiEzGJD+psp/fOnjbPTmEQ40yncIjB3qZp2PLL8LW+nS8w3eNXwf7909Si2ZZDeR4k/sTS5rNb5vU2HWaXCstklm4NCyFR7YepxEIFifmWYY1giFwo5IoiVCPvliSNFXaGltLC1BoFp0k/ewUdKR/qtM1vLUCyMcrdWQwkfvNNmYOIflDCh27lCubdPJt8hub/Jy9zexxU368gi+XuZKSkOIiAfUz/Ph8Bt8OfkQPy9+mla5jLLR4r7mZRRznJ7ionUabKpaPCHXugFIXjiQQ5XwrrU6yXJcmMhU6ggB++0cDgaIiJPyMuODy4S5gMqgyVtKiDa4SlAB6Ywy6kgcPYFuOGRaEZdMg7JqcN04yki/hqa7LG/toCgma4kPsumeR6QVhrbOIJUEFA5ELnvkaA0NtkYr/NpDP8q8u8737D1PXq8wFB4SiSq2Obrr0hopYrguV/15VCE51bhJNzGJJOSb+QZfmp7k22l9Bxh+C1dqt0buaoLSlX8LQPSEx94TCmEgULM95CA+HFFihRe1n+CC+kl84yBB9A3y6TneV/0GALdrD1N3t5GK4MvWA6gyxEx06fdMQIEgFwdS4FywyLG9ZTLKZRztbq9fu4HujuHJVQodQcbYYl5sEEUqwk+Sp0sQxuDDvturEmRn8TQV2/f4mnmZRzvn2JZthncZ2rLf4fOPvot+agJT7LKhZzCki64KRkWX9XCSOenxG/Kf0j/zOqESMBim6PdzlLcG5L27IFATzL1vg6mdNQZ3hyHrXYW+ZZEzaizbE5jJHkL3kMLhaOsoB7oRZhAbctxKzJHwfTKFaxhCJTQsDCVOLsSTXyapBqit+LP2cxN8ZvuT/NntD5HruTSsCofMlxhGeb585idR/VgDUizEP8fKcIEfTMfWyx8+81v85lM/Q0E5hwg1Dqevsi3LvDF6jL/OPATASVYR5RgcnVh1eeKtCyhGRFc4tMJ9JkvH2EuMs53c5npaI+jXUKIBD6+2WSoWyewVKe4+wpQTg/wlNU7uHwhS2BKqakSrcpaNsoPtRLRTEk0rI+qHUP0UR0SSC+mY2TzX3aH0HzTSfxKhduGR/dj63MyG1O6aOAQjcbJcceLkJvIVJCHHByc4sLnCoa06e8l4PwwXXA6/f5VS5gQETXJOkYODCgYRpuJTrNUJNR0JvLN1FLWggoCUusNXkkneqCSZaQ/ZbKTQRMiDQwcnd4cIyVg4hiV81qMJ7Ehlzd7i5s0cR8pLGJNvc3J4nUPK89wQJTRNI9JNSthoQnDTz7Oiw0eDgEk9x5a2wDF7kc/c+QC7+/chRMi1oIA9lHiazqUj9/LKmUe4MjHPjjfKdjRCYFXRnJjRLQQOBOOYvmSyvAtRvCe+Z6lONZDcGTM4o6+S0OI91vKydAZpdtQS7cjkdW8WgBvmOtHguwD4yMZXuM5JwjEVZRi/W2lrjChbvDF9gP/7zneh2xHvSz9HsX6VTT8eP4NweSzYZWNQJFIPoBPyuBcz+uqwxv/L3n9HW5ae5b3o75tx5bzXzqF2qtxV1dU5t1otdSshFABJCDAGbOAeJ2xsfAy2McHY18Y2AptgQMBBAQVQlrrVUufuqurKceccVo5zrRm/88fch3vGGeeP88cdl6sx+MaoUbXXDjX3XN/83vd9nud9XtX3+IWf/mf85C/+Bpmsiqek8GIlkkqb4f4e0SAgGtjEeh1uZx9nw9wn6SZxui5VL8aIDCWV6UMSOxDcxCerOrx8b4fXjph0J8PfUffDMBL1U+S7LcZaFl8cESyNTTO9vsIbHcmV7ctUhM+eHeVofoEfq72NPfc0A34fgWCwO4bRfwvFjEJcopcckl2bej7OtuySLO6zvzXF9ht5amKadsTE1lIoQqLZLW7U5mkPOCjCRqWCk/NotgbwPINa2qaZniXutmkmw2fX8BeI9XuYKYEnizSdBp5mcCt6gh1XYdBWaKUO02/rmGqPhGiQsNrEzq0wp4Rost/R6PWj2CcklrjA8Lv+lLxzh1YmyWNOkagwuOv673PS7fJmcIQAeLDrMDDQRTcDOp0k29YgZ1F5yLnEv7/834lKuOb9G9Y5glRdCt0ms/FF/p74C77fP8EjWg5F2FjKCGP7C1w8egph94h1OtRzWVLXG/QaEdJDGq8eiXB6p8oT9Qv8rH6FiVYJVzWwzSTp4hJtV7Dau49FY5o1RtGVgKlMg5oTIxq0CSIxfG+XZrWIlLBlZjnUCfjDSRMhNXQ/jwLc15wnptgs1EO2e6s5g9QNfCdKv29glbq4msp1rUB+ukPM0thRwvM5l3DwFZVWJka+uctrx8/iG0PkK68woDTY9gbQ2z1u9APkkE8nGsaxlmUyZy/jYFL3jrLtpSgodepOhBFZo5vU8ScTHCgZiTkjJNQ+1q5CoKhcGZvHs2OkjPMAHFu9iOoLrFgSUfFRVBtH0UlsB0QmewRGjH50lYvdD7JjHQUpiWXiJOo1irUKl46cYkLR6RWfI67/CbWhgK3NabqZsHCz+6P45iwTtTJ70RQvRBf4ZFPB0tcAaMtpipm/S1LPsN5fwAxcOprOorpDqReaW2xkJykbKoNWaHup9PIsJUIjD+E3CETAoV6SQLU53G0zsr3F+71X6TlJ4pd7XJ8/w8qsyl9N34WMu6zOhcYzg50eSB31gCXxJfjS4M7QENcOmbiqhhOtUXVnmentkndrHNFvoUqfvXSOei1FwalQiQ3RqR6in1zn3Zu7IAQXpwsoTh+jKogNOJRjkO200ZxQ5k9S0khppPp3yO3vE7V9iseWUYCi2OOEssZnC08z1PCJiBZBEMHsbiCzJnO5G6iROtfyU7xtzyXX6uOOyXBclQTfSUCgsa0GfGDhRSr5PBLJoBflbGOFi9ljCC/C++UX+NHzl/m9f/t5jHKKUjtJXHOY7ixwIa4yLEpogxFE3Ua6EZ7Ul8kHSbzkGMPdATp6h38z/juYigXCJZHqU0qlcDWTjr6MAB53QjXJytkfRdOimLZLyu+znS6giyECVUfsaMRTHdJ+BGnnueK16HoLdDyTncQ28QO33rVBHUvpcanxMkYA/+iaR3Q34PBeDYlkp3mdlGezOzxMxy/h6Rrl3ghCwFDgkatImgmHmBplf/AeVgej+IqC1rtEqiOpxXeIls4jg4Cg36OeO8XczjJeT8VqdJBCsjPi8MEXl1FFj5HO3aTcgJeGMuT1X+Eu9TXOOyf4f8X/CdPKLrERnVinw3pvBpcofQ1Er8SGCKXHVmSfebHGzdEc79x1OeE3iRXD2GPkt5HAasfC3VaIdwOWZ2Mozj65pM9Yex/HiDDSqOKNBtzb2mOw79OOxNHdgITtctGI8I3yR1hhlni/TY8+zU2NucwJlkbivNz+ODoemVN9NqJFQHLGX2VFDNHXDP7lT/4cfcXkk1f/Vz6ye4649JFCYuGgiyVi1iCRBIxtbHLZDsH6Ea+MVAfwIi081YejBzH7e2T9bWH4N7jcdIyt7lMY1gw9L0563WdnOoISkaTyXRSnjyZV9v1xIoFDLTVGJ/sxfKXHSv5NJtVNfCH4g9S72Xc2UOMD+HKIlN5AzfZxmxpSSkw3idtV8XzBnLLNie0lbHsU42DEgeuozAc6Ui8xXHNRoyWGKOP1I1iijBBlFDeBq6gcs0I5YNJawtY04h2Xe8uPMFebpyxtXDMM+A+trLI5NMqFoQia2KUkNMbFCprm8v0jz7Eri+RsFyyFwasfRJ7/aaqVCVLJCj9lfJk3kyNICd65GWIFm+Mz1/HVUPalNxVacZ24uoOI98gHdRQFbkYbFPtFfqy5z5FmeJ23U/MAJHoeiZltpBklXgyR0WjPoeQKKuUMEvhu+hmuOEkqUmGqE9Aw45xKfhEUh/sW6vzMX/0eAOl8G9P2+fng22jC5y/azzB7eYGdwQl+9cnH6bSnmMytAfCzTp9VeYi2jDLJBs5oHEUGvO9cF0svEw9sGqRZrG+h6VFiw/eTRefViMrNRg6h5HjbVhwpBG+eziAVlZwWIvQVZxt8lbuIMCQVmopCpno/5+5y2MzDVrFDX52lZYQy0BFvlJI/jBAgKtOIHYWe6lObOcIH3lpBsV2CTJwb/beRSC5jJcM+LMNNo/QiaE0oj7zIybbOhy8vc37oCGZnBFVt8VJkgV4An3/kCM/fXSRl58n6AxQDC0+oJBpNoqKHRLBqbnBr8XEA3mUv0VfjdDMRTm/vs22l6Acaj1k9oqLHIh6npYbp+yx5U0SkYCe9xKWKSbOZ5omjX2DQqeAokt9Uxzim7uFFE0xqA7hSUusOEg98nvIlST3PkrXAO6c/S9+L8CfOw3SI8fLY3aSaYWHcj0YxXZvF/DR91aDhF1D1GtIOgRFNd1G9sA8p1nNBCETgM9ZQCSQsjugcU9eIKWFga9hpmiIDjk49MPnn8U8BcC26SaT6GN2IyqPORQKhsj4zi+urxDQbU7jsH7YpL43jSY0PH/0K49oyhcpVaiJEyw/H3mSUFsvtJArDlMQ0z9hhMa931sj1W1TSObYKQzzauEA32UEICREfXYO8r+IrAsWxGau8RSA8kk4atddlo5Nh2Gzj2xH+3tYfIqTkFWyKnsrHir/G+4d/gzH9LwFIeX0ybpJ3KZPk/RRTu5vsF4ZopnPccytUNSSl4HLoLcex3B2s2B6nvSne4z6FisKgkyPevcAE4d7uVU1GymVq2QjNSAKhSeqr4XPaNA9hGRqqGsruP+eeYXH/NI1sGM58RaCl2zTrRXLSpJrwKRem8BSd3bRHkLLRNx0UJLGYhysGaHZ8GskMr5uPsOcKpi2Jp8cJyqGENi92SLxex7SbTCtfQ5ceahBwozZH/1hAQbtAJLGF2eyzP/8kk57GcuF1Us4SLdMlT4olf5yHug5jwxa2r3OheYYmkn+gPcfv3PpFNiPD7Li/yW/7s0w5swz7GQzf4z3Wi2xFYtxUN/k+EeGI2aXpzvHg5XOsj0ywPzJGttGgnssx1ujSWc7y5+kfwfRc3nZeUtczPCHX+M/1ENzYKfoU4g1WWhp3RS6wxhgLmodtqRxJldntJchSRSoKk7Ee3698H+3+PD0lQr7vcHFURyJ5xQlZ8Zmewlxqi5XGDN1ujq3sDIGukw9atGWWrhmCHa9GYmSmLTqJIXY1iZABakxguA6ruWEKtTpffPRphOeiei8RVxxKMku6VCF3BTDhzr1ppAZ2S2c0CPd6SWRw0DhRv0W7FydBh0K3CrpCXHewPB1XmtxdvMxqeZxYu8Nbk+N0drKYqXDPLMfmuHbqMAQSmgUS5jp34lNE+iqBrxE78RkyY79KVlunEzwGCFSnT2a7wV2Lt7k9OYod32e4sURW/SyTuw0qC2eRsTDGNhTJ4WCY54/eg4LPiBcn4kWwWuAKlV6QphgXBPh0nUsIAQ90LnNFXWPFukLbHOSfksPW2ox5KRKxBk5niK1oDBsdu+OQVCSjMZVA9DnVavJI5Qpnunf4jns3RnyE6MApfrD7JcanbhONuexF5jFlH5wQrGzHQoO2QVkGBG+eOozheNyZnKakenSDAlHhM+CWGYiWOeSWKWdTVBcGGLRLIfhVmwTV45gooXoeb8zMUI2lGdveJ1pw2I9FyHctXC8smAdjPXaLcVL+Pu9afC68V/4DTBk+j9jX8KTC59NPMly1MJUWThAn2Qrjt5MeI289QqCYzFZvkuw4eKMSs2fhqi5WOwQ09zWPfKdNZaAAAnIywX2Ni6waE1itE0T7Ch+49iaKlEyWU1zzoXwrTWf827yVtFAJOJbaAQSv4FFERWkcZfbOGqowkKLIurmLHPsUmrC4r7VAJ6rQj6boKSFQ51l38XBPcF9qEm/vCvgBAnj9xD3EPZ1Agl2OY+YchAi4fyGOCKokNIeOZzBFi98v/Bc0r87WoMdE3cUsL/LFEY0Ha1H81DyFdg9PM1mxruF3o0hFwYn06OmChhuevWvzcGLVox3zON7R2R5+mLURHcXv8uDWFgIfO5IkKR1ct8ar9zxJoBqcKIV7o5S3iXXHaOWiVN8V7u3+coNnd2xeGcvRN+6w6H2c17tPonYdTpqr3B1bp2dGudm7l3UlVHJNyw0qB+qyhEjyhPIKQvH52HqDeKAQL/bwHRNhOHQiKmudLt2GScz2aMY1yorPmOkw2KtTNtKorQBrQMPQMgz2XFpRnVQrZPPvaEO8Ov4uMm6VSF+i1hSEJhmbihJRA2reJK+7DzA5UcKIeoznahREi1ozw/OPvo+NkQl+aPnP6E43yXllptQ/A6AlLLxgh2o2BgrESg0Wg9BzImdYpL0cG/kUHw7muG/iPr6X1t8Whn+TK5Vl80Q4Q8lvKKTbHrtX5pAScrNtsjNNcl6EgmLznr2vEZ0Ez5whWx/jr/JXUIRHxzBYGRyhHrSxhiYwpc/zo7PEEi5+Q0c1FxAyCggaTox0vMtsdIBS8N/JKu8GoO0avEPZJ9UvEPEElbyPAJSaiZ60UdQ6Gxi4eopEAD4SzesiFUGs43GmMkDLFWhKgKeFB9A9i1WSVperAzk0sUdJNcnHtjl16hvcc/y7kGiRkn2WP3eKzP4DSF9jr51GKJLn4g9yy5zCsnLYZharYlI8WuWJbsjORZsqjTjkgypGtIWm2ri+ys1Yhb7aZ4/DPLvTQfE9FtMhKprfzWLocaSq0VkMt71X89hzFTY6IyRUGzSFPT1MYk40FR5vXCAmLJrpOjP7MBSrcEZe5x3BTe6/0CCCxZ/xAWo9k2OLV/ip186zkjT4t7F/jDZgIQhoJny0QHItOMRxsYpMGZxsbqFK2M36FGjQEgleUDbxGxscKp5kWpi8ZcUp2QkikSNkupLJmsfNyUFE4DKg3KYrIpRwKfQOkUEnHwgaQmVGz5DG4Pl79rg6U6EdHWP73j8H4LZ8EBqSIcVFkSYrQyb7OfjcvR7sXuVIbYlzmVM0vXES42+x6QyGjqpKicwb4yRehBcGHRq64O1WgTuFMcrmAAVfoa/YfK5V5LWRGc4dn+LK4TQChaxaoaEm8a2ADC0sIjzo7nIusYjuxHnU3SKnngWhcGRjGeHDgpvj8V4Pdd/gL9llTBw4jXlTRCS4epta2mb7/GFy8Tobo1H+XH8PtqMyo1apxKOMR2bZ9LrkbcEZZxsniCANja52icHiPg8NnedryjC/F3wQT9EobCz89WOZ7bbJOS3WksN46KQltL0wCPaSLbBDR9EV5SgIjdnddRwnTqBINgcCiuxhEIIY9X6aVyN3owAPiKsMylA2vhDfxpIqdSPPpFvF6FhcHTjLjjmMGhcMiW3S249yd3eRj4x/m6cKz9NbK5BsLtBQfOLS5XE1NBha7WSRShpNSTLnhyoDtVvCcG0G2nUirs28t0I/FTIPBJKKmSMXKFgRieI55JuXAci01RChbWVRhWSwFCFfaDDpNHkNDxWds8suT925way+QCAg0lf51c2fJik16OeYrSyhHfRgnF4JE6OqCedxMPEZipRxU2t8dvizGGKRKX+AYWsY6de4xz4HgCxFGSpt0khp1NUs7Vac9oZKJ5FlP+2DEGh6aGMeocfxrSO4moGlxahqaVAkdj1JUVGoJYr0I3GkJyklc5jDNn4lBEsiZpe+FqdpGTSTGRaDCXwEBT0G0iO2ugbAXPtbRMo2337wXiLKLoOBJKYFXCifQcbBNwMOXe2yM/AYVfEY50yX6VOvs/fvXexTf8I9qLwUnOSI3+NYzOGyf5irjWP8kvZpHtf+gJey9/C+05/gVtbkjlLnLgZ4t3sWlRQZ2WalN8+r+gKLbDITGSCnDPL0hfDabs2dwej3QUpKo+Pc7t3NojjC9++/QLyvcEc9jaFcZ6wXELMd9kZ6KAKuOpJtCgRC5VykSns9ylSiTrmf5GzswOQkmUPt1KhVngDA6HwX21BoxSV+AMtxhVrM41D+FrvWIJmtJ/mxbZWU0kMVksDL/XVh+FbxMJvxJGuDA+waCdKiRT2aZbxe4lpmFheVq8eOcXq3RyQSmqc1iKHvdXno6yJ0R532EPEA0VBYSobyrKsyho7HfO0WXTt0A3zP1nMoMqAg2jTcCJncTe4bOY8XmExfW+bS/GFaWz5xN0+AxI+O8+dnniG3toeUBiTPs67pBJEYndWzFEZucLdjcTLy+7QzCxBAdHOJiWaFE8sLtGMG10eWKVYcAgGTmz2UkWE0JLqEpnDxt19juTjGheIScS/O01vvwOwFWFEB+EzqJquRm7x/IBxRkLTbqDuL9L0+ZyKHmDXgoaiF7GXIuz6g4Gk9ajJNwreZjOWIJy181SGmxPhY++uU9Qz/Y/JZOuPHKWYmuV8JZ83qhsameogxf4MtN4Oi1+gqB322WnjvlQRM78K1mcNcPDBn6pjjTBqbKEIy1d9nPzaAW3UY8po4aCw0QmYkyO3w4EYJw3P50gPv4NDuJrIoqJkJBro21sFg82jKom7O0VUifLjzHZp6hE9un0Q2Rrmvs8tLwV3UghTD1RYNOyDAINWVxK0uQVqnnXkY1d3nNn9MsucRJCFKm0ikQ682Q1fxUKVKPTtL92AUREbGOdF+GYAr9lkS6w+hVkI2bryS56pZ4kttnf1igyvWUwA8W3mNtNvkBWwc/ySBGyNeCc/4wZ4kv/M+tPgK2vBXSNR1EIJWXCXZ04iLLk+nP8+HZISUULDvfB0RJJCAPZxABpJuoNCuBCiaxIw1OXPl04xWGyR0m45rcCVhIIBsfYeVogn2GH0zwp9M+PRUUE7/KAJoJfMIX9JveySbLYyUxBUGkV6oilo/qjFZBilgP7JGOznB7REVvX+Ft+0HB+/7u4j6UXbiAW/d9SCx9Rrx+h4SiSd0Yt0JjH6fJCYtLcIvH5/gAyvPYasGvzL6H1G8DxDIEbA8jqmbnG6tcmPuFE01z3f06+RqdV43skg7QAXe33oAQZ1/vPQpPKHTiZRRzYD6UmgmVUvmCRBczIRtFlbZwBeCQ45L0a3jKyrbiQGCtIofDFCwbDxFI9oKTQp3tIcwGj2OvXYRBQW92SI732J/aI1zpS5tEdC07sUXKj+nfpZHUiFz/iX9Ia4fuZsHL7zAicR11tKjVOxfIS9C05uu9iXqvTdop/soSKrSpEuUjmaQj1iYQZG1bJzp9jsp7B5IF75H1t8Whn+Dq+sr3ExM4hLg1ALUaMDWrVG2awV8T2Hq7TuMH34RU2uS0MOGa9X30LcewVMULEtSVxSOrS/SnToMisIL8/eyEemjq2A3dYS7gKeFh/C2WsDMSPJ3/whCKJjBGVRFUndjPMkWhVbIru2P27iopBphcteLK7RFlGVijFsBpYhk6MCm2fB8Cs0bmDKGJxVcEW4pXRY4XaqDXkcIj7qSZjMtiScarKwVuRoLjWNu5CfxZRaPDm8Ge0gpqA5mmMuu0WsVUSfL6NvQ3orxBOFh7vUV6uk+KgFtUwcBpfohpFHjRqbJBmNku22SnRa1ZJbAV5naX6cYnuMENR/FNdk0TNq+YKM9yT3bN0FK+vFjSAGvTUV5V/lFuiLCO51P8NGBf8rZ49t8n3iOQafDVjzLReuX2BFD+E4ftVtnuD3Ob75lUday/IfYLzIQr3Idn3WR5Ko6zRFlE0M4PLzVQ3O7bE6MYygeLZJUjVGcle+Qj6R5qHOUyY00huKRjeXpSclWWmEvnsZNvMmof42STOMqHke7YS9D0he0UJmzFaY9F6EezIPSR7jYeQxPuHxHPYVou9zvbJDuF7k1dZrJfcl9b26AHvDh9nPsR/JUE4L49Hm6QQxHSaGJLdKbDeLfUbnoneSvBl1S2Xn01AC7Zo4xO8Fwa4ZXxaNIoTBR2uGrJ6O8UlCZlFuUoxlqXoQMLcpamvf2LLaSyzTMLRQhCcz7EH6T2NZ5Yo7LFTVNwQ8wywni2hIrkbAAuhOMEwkEKTtKLe2Q2dknU/VYnkyQ0AVFOYAqJM28QVRLsNAvMRAoKJMluhJeTl0kovkM6JLx4cuksflz91Ey1VVytf2/fi6lELznu5/h7V/9CgBTTpw90QHfwI3U8P0JJHBh6GF0x+bZb32apqtTzsOQ2KRsC1LsEVVcGtYAkUrIvD6rvI5lROig0NRbrOp1eva9aIHk7aUXWRbTtPQU7mCEgaBMceljTDHI26e+yPmtZ/B3ovQNQQObnG/yeLDMij9I24vgiQQZv0rAAFHRQbg+FenwyJ3LvHvhSxTUgH56lb6bwNzTacs4eRnQjPVR3P5f/+6ZJtiRBFtWGilhsObhjUiO21VWEFQIiFbOEHNtNBEaKFmdf8qUPcGv57+G28sR8VzGt7cZaJTJWgfnQea7vEqfIaVJzRektAbXEpt0I3/FuF/ACAwO9dJkuUWDDMmGxkB5NezhTOgsLk1h9jrsjExR0UOmSDNVLEXnD/T/xBgK0fo8lbRO3muRbjrEOgoF1aEfC8cYFGolWvERolmDuO2iGAGq0qMXFXi9Pp1EhrHdcK8NJKPYZh16Hp6jMuxfY21yiONDG/helEF/CkOB69WjEIBflPRWj7I492Fsf4+XIh7XOh7xVwXR1BKnYhVekcfRhWSk63J7L8q/tH+XH9e+xLe1Z/mViV+ho8W5ObbArytRAsCWkjNu2N93aWAKCbwYWeCzxutEkrukMqcYqLXYHJ7BJWBwf5+rR4/yyXs/wuHODZ4Z+mOEZrNpn0ERNhHlJiMNj+2sSeBLLvs633IfQMcl2azQWouiCklM8ynIFYSEpdK3cG78FSX3DACThVdI2A22syZRW3I7ITgc3GAuuwLAbwQldlN3SBMWFwy9k8ihtyGFYGPyI/xxskg1brBvFplxdsFTmKzu0Yol+R/f/1E8XedntgTH+wdSQ9uh0UnQ9WKU+oLEaBct6eM2VT4/+jSBFFyVBhNBGV16lMRdAPzDjT/la5d/hnG1QsOJkB+9zHxmmah0kGWXSibDYvcwSmuSjmIxY+5SGU7Q7dRQpYOXuYPSUomrDbLf6KCpkBhQeMk8gRKtUfRvkT/WZuCBW4w9GiaSjfQPWR8aAAEAAElEQVRlTCfgznQCpx/j443/yr3lBmkfOpokRZJo5wob8SvYmoMhdSY8nx3NYCCzQ5IY30pfJCksVFxEOo/WriOkxEhP8gv3Wzzgh9LRoXrY1xt1m5RJMO55LPIxDNMK2Yt0izPaIl/XH+DqzCnKAyPsRvaIRsvYGERFnxVtkNHeNgu9ATLGNq3owUigTMh6HC1vowc+N4amuakm0ejTThxiNBImxnI3gqtq1KJxRuOhUmjFS9F2DPrpFR7f7zNWL+FpGp955j2sJMI2hoGuQ0eELKWZ36TtzvHlwhOcia5RiQ5RS/ZJN09S8B2+6D+C0XcZVBt0PBcpPaKOSs5q0Chm2BqZ5dDGOS5kq9QP3D5zUYiZHXqVGfZ1j0wg2B2ZBUVBDUAgyeqrpGSTS+oMifpJtGoVgMGmS7zX5cZ4lwcCFTNxkpXoKA81rjDbXeailFRk6KJbOTAes9BYa91HYf8Z9NQ1rmmXKfYrvC99kbjbZjLYpEieY5pHpVMmqK/Q9IsI4A4jXPAnuWx6lNthzM5ntnHUgKlaFUMJaAcRfmfkO/jWBLHNFK1IhN1kCicxSZ1X+aNpg0yqiFqYJz1cxdZ1hL3CUGkfmTRJU6TuRHGlSkE6bB6Ywq1En2IvE87vLXYuk2mrCBGh2Av75948/h4SnSbBYodvzF2knnTJtEAEkjMXLzLml9hXU3ztwUdQUhf4wd3n+POpw6wnTdLqCF5PYZ5N9H6WaDzFVloy4WV54oVv85X89yF6HlEVnmif5ZvpB/jJvU9zMefRy4RFenP1IVRX0kon8PUol1JTAGw1Q7B/Ap8BGZ4zt3MTxBMOrjeIa4V5a6IBe3KQmVqSx772XeZleH8Vx4HxDL9XnmFXBqjRFlv2fXzKeTvfp77K39n/Cm0ifDN2L7Nrt3j4wncwCz1irSksjvNc534UGeCpO/SaCnakQTpmsZINJd5WTCEX6SGUNM29Jn80OML32vrbwvBvcLUtj4mui+dWcNoaqipJOTa3yiNstjX2LuaJjt7izNmvIY+kMDyHfL1E+cwjHAoGQ0cpL8NDm0sonsvD3kmc1CDDbkj7l608XqdEoJo4eoJV4xB61CFwy7yp3EKQYiQ2StVLkLVsRptH8YXHeP419rQsY72wkurGNDoiQdlIM9MJuJbW2fVCZsIQJjObNnf5oxzxRjGsUWJS4mTmKChFsl5oItEWecrRkE28KTV29TCw+UmNLxGQ1a4Qye0SeBpDI+fxA5Xt9Xsx8xukyxrrz4+i9BUCAa4J1XTY3+Ta4RbeKB9B0RsspUCVPe5EjpDqNXGiOkEgAYlnhJFDODZUxljXo+x0hrF9k7vat8m268xoHX5y8gV+beOf8aHS88Rln7viN+l4Wd7qPc3v93+Ul+/L8YX4/bwlQ3Q68G22onMcV+IMNit8/JX/TpsUtfQgd7wou94gl5jHwONka4mzGxli1j6lQ6EevUWCIbuBt3WObuByuvQoE3sxsok2aa1GU0h8RZDwurx4YoRUrE6rP4Ct9TnaO4SHR8wTSARVJCcU96/3WIQir3lPUTXrXPByCOA+9RqK1FiayKIFcNeqTfsRn3fU3wBgacxFjzUwIj266gi6WCeZXkcEArEp2a9cwvFdnoxP4SsqRU9npF/EjT9M3Fnk2at/xGTT53+9K0JebxMoKqVkjhh9dhnC9CX/TrG5OXQOV6hsp44Ss67Td5vE3IBzuQQ+MNzTqIsEXvwtAgzWyBMHbCFpRgIqvsqf3PkQUhEMj18hboyyJaPMG1kCGbDeWyAWCG6PHMJL3eTb6Tc5c+DmueHscY+2QUUm2I7EMJ0+qmdB4FGLp0iXWvzPE08AkJOSNXMXvZ9DMzsEYo+mGeOVzD3Mb1tE3Si9QHB9zOSQuspyR2NIpMgYbardAtl2iz4aE2IPF41bSjJ0ULNLmO0PIoGfsD+HKIeBqzlcYKdUoBUodP13ob91N+WtY8Q7XbqGRk1XGfdd7vWqXLRDhD6pmhhssNEZJSu6SC9JVL7FaiPFbGmZgAL91BqenWV9L5RYjWev0jNdpNtnL7aH6ZtELBdP0XBlyBxmunWkCfMH8uXX8ah776clZ0i7PpZp4vgP8ufpL/Bq8gZqEEO3FZ68eoGPfPYP6EcGUP0qV+NTtNC5T7hsSYe8HqLTV2LLjAY5QPKBWoYRZZsNJolbFgPVkOE0kgZrOxMIJDdmThB0t0GCNA0G9Qovjt1H3nSJV0+wPqdiGwqnrnfIBBYJ0cU154n0W0ztLCMjM8hYhmTfgQPpabk3jur1wUgR238ZRUoGYy6RyDqNRAqnoaJn4Run7udp9S1qjWnG5AgJYdPzYshShP6swqv+PyRm7XND2UQKj4ncBvlvQ/sPppnJ3uGinMNHMFi2+aXtczyjnOdS/+/wicw/4MdWfdRAshPMM+Kl+NeRBZ4TLqf8IdpKjhdG7yfRaHHP9QWiGLxuLPDGCY0T+1VK6TxXJqaZXF3j+bsexFdUfuDlb6HqLunMFrXaKTypoonXGC977BkFrE4CKRW6ZpxIdJ/RKthNjbabZyxWRXFXUJ0+rqYTvfuDbOhp4rJNvrDBWDnCpWkTBWj7NqQ2mUptoAifNecQnyl+gwwhM96lyKGJ9/Bg8f04RoRvpQK6gYqrGNy7dZtMr8t4rYSQAV999ClGOj1Ot+AeK9yj2XoZKRS+ce9xyuUE8cEeiXwfr6cybJXYD+JYKMz21kBCXX+QQCpEXJfTrVtklC5NJ4o3eIdma5DDToQNYwC8gFsj7yHeHWbXKCP1UaSSJLpnMNldpdArEm/chyo8hlZvE98IWJ+MM/PYKzzw0Oc4/PYLTD6wjHu3y7BaJ+FbB46Ogsbnhlk4lyfltfj3W/8RE6iqAi+SItH8DIHIsRt/AIFkxHO55utMxH0CKXkpcYfl6CgDSgMnEkOMz2AXJvnf5ob5OefXqVUmsVQX3xkmiLSJORY7WpRx1+O93RU8JYyxdyf/Es9T6dzU6EdiXMipMHQFGah8RX4/Pc0MpcGNLk0vzri5RitiI4OAb0w/BkC8Hp6VS2rofJoU6/TiUxQToRxwtxzG8N2hCQYnSuhSUlIla45KN7XImbZOXzd5auE6y0OT/K+z/wCAfM+jK6JEhYthdLmqzXLdPYyhBBxKtzGMEu/tLdEVCs8FZ0l1usSyuyyMOsggLEDzXomyGETIgEfP3STuwx8YGQD0XJWoCr6dYkMNyCgO+8VBADKegSV79JIqJ7jCtfQobmIFsxXmE4X6Ovt5m+FKjPcPKOyNznI5eoTpYIvp7jK+gNcwGdAcGAjj7F7TJEDh3vYgQe1BWpHv8pu3fp4nlGUm400K7j517wy6mUDc+iKWFuFlI0NHGlzyQvfSTRFlPxjFdU2y8V0s02S8FyplqlLDkyq97Y+y3w7v+dqgRkEvcOZGgk9PGvTdDsaJDzOSirA3mEUGdcSBs7yWNLB8k4YTYcTz+ObdkohjEph3szJsgQyobY+w4aWIGTHifon9hEE9M8J9578KvoreH8CJRYlZPYRbYa6+Spwed5yjFBu7nOxf5KPbV1CCgF85bpITcXR8xrwSXwgeYqJV40g/z12tFMNP1tkYyiEsHxsfBUHX+yDxwOJY949xshv4tkJxYZlMy6Wd8qnnppHVLo7UiHmhvD+SU4lqNuPtfb469SA/VftFXGUQV3FQpcdAt8Ouc5ikozAbq2LK8P1a0Uf49v5TvFU5xk8oUEiobClR/pP8ILanMy/XuGQehZ7kbd/9KqoIyBhVitVJHLtM1ZxH9T3ueJOs96dBSAqZPbYyA8T8HnYcMnofIQRV12HppsY3vIDvpfW3heHf4IqXOxxr9NCb63h+KLcpGjaljmRDkeydL7L93UfQVJeH7v4OJ2LXyPZrHFUu86PDawx7Aao7AlYXv7zDN6dHGO5JBpUD6353FttpIaVNKznBUecBAPrLv4Oz+TJgU0wco+bFSHZ8RrojVGM7+N4Gq6LImF0lkArduEqLBI1YmrwDawmVO3p4QAfjDn75FidlkUe8I9hOnhQSWwpeyAvGemsA+N4oXiRMfLf9HlvREF25117hd+lTUFb5ieHwgQ8Cwb967V8QyAhCCVBLIyRqHt2tFI6uUP9xn91MeJA7XnhQ3m5NIBSXhBVhxt2ja2YZtOtUjQyaHiB9QUPPQBAgXAd7P82OGrDbmsLE4Z7CTf7q8j/kpYt/h3+19wdMWnsI4JPp9/Hbiw/x5db382brJ7FVgaJJttrjaOIAgXJt5q0yU6jUsqvMrq/xL+W/Jkjr9AIdKQVX+1MAPFO5wjQm0V6Zfj5EHHu2wZHmJgQu57waQ71p4loKaajE1Rp+4DPR2+EDpefZLI6gGpJ2R8dXfE7ZQzSwSBMeehv4TEdDUxoRqJxuFlga0HhxuI9suggCTpjhbL6+4dE1BKoWcGSwwo41SMryWRwWSClYbcwg/Ak0sYsx1MczBadv3+L09Qt8zetw0hxiHIWBQOGIXscxJhGdV7mY2OaXL1hogeQvjz0LgBkPr2/HG8FDcKbT4mNTZb4yfjd93eRQeZdACiJanO1MjxtamlkqXPJGmZIl2moaSyjMaCof6oYywN24ZFlJ8NLGQ1AsM5hs0IxtcL83yqayTFLcRovWGfBipFOfYju5yH0iSRBApHyYUbXBCXWVr2hP4wc6iW4Zxe3gajpfnHuGcvKgPyi2wq5RRu/niZo9ouImL+Qep6UlOSvPEY2FidSN0SiTYo21psG8XyATqVG10wzQoxTP0BAxon6PJTOLEoBXWUIJiliRKMesTSJ7bURCQUZ0SpUMN0aX6Ad3M+bViTgWiW6XcjSJK1QeUG5iILnVC9HImegOQgTcaQXYkRgRJ8Zo+3lumqMUA5u2UsSN70EzxzUr3ItzUy/i6QGqD221xpH6ESy1QyToARIJmF4TzQ0oJO5QoBvKSWUSx/03ZO0AV8mRUD/PV7UlhNYmriuY/QxGTGDIHq1klurAbW4EIcp7d/wTlF0FIw6qmuLlhI5USgwGOg0mGFEd9t0h8o06CatD3HIQaY1FZ4ZACFbHZol2GgRSx45GmPOb/ObsxygPF4lVh3AMhSt3JfEDjSfF6yTtHq55mExjhaHqBrYxg93P4UePUJsNxySs1ULWfX5jjZ1km6JUicYbzEde5fbUPL22jpn1mNF30URApZYhLxOkDp65ViNBMOKhmg1mF/+YshZDGHWOGC7V9wXkfuw21vE/YyhZ47acZHTPZsxt8cv6R7hTzJDU4W0ln/G+zaZW5DPZb3B78ndYjb2GwGBHfT8bsQkmtjdZyUU5pJiMbgnSfoK50lXGavt88fH3slIYZq0wzOM3LvDQNy6j1yeIj5/Hs9Msug8ScI3xbgOAv+y/h4luHkVo7KYqzJZNMJLsOEcZjbXxVUEhtk0jX4DENGsJhdFgDy3iUGi6rAxqtOIBasOhn14mKjXy8QamVWRb9EkfSKn/fP9VLvXPMRGd43+5/AKu1NkPjyfuWb7DRHkXw3OZbIYx64NbAU2/wfF+aIxmWB0Sbpdro0fw10ZQNIk/HfYmvX31NdaDDAY+hxpLaKqBpqaxegkUH9zQ34q6iBLLlbns9jjqgKtojKx32RgbQ0FlK7bOtWwU0fXoyxiPby3w5NLHaAShnNbOanReG6XRKrK7P8PalcMsfWWc9S/+LMuf+w94r7yf6R24p3qLXWOA1EKXm8fn+eXpv89h+w1+2nieqpBcKNwCf5Nu8kO8VjSIyy4GAbcjCnl7iJInSVhFbkUGmWKLQAi+fept/LcP/STv019CMbtYnQI9fYGSN0cz3ccIfNYNDQ34xZX/gdOKkKXBnPEmm3vzPHzhGqbd5/WhFKmxt7Cr0yz3Hmad8AxQK+HYmrnkDbq6g/Qs3IiBiosfGGwVBmm3DaZdhZi7hWcOkUi79D2D9a5JotthY3ia5ECDQV+hoQTU+gZ+osyIouLqMWaX7/Avbv0+5zMhm5vo23S1ODktVCr8Re4w8e0mVTvKU9FrZESZZ9VzXHYS9PQIsX6XC7vHeCkZQBACDik7/Hu2c5tCs80PNyxejOpQV1GKDVwnA8CKqpBSenQSJkhJLkjg9pr4SZW7ncs0IxFuxELGtxlPMFTdYaAewQ1MXgkepJQcZL0zQEJYjCb7JII+38bhgXiUTH4KpOSKMkFBdEgqXR6vz/K+ziBPtULWK2v0MO0ATRvAaaziVC7RSGTZMnq87k4Cgri5idOdo27eS7udJxZpYcXypERYgDcDDWvnBzniZaAv0VyP7UGPlJ/j9H6dZLvOSuVNtMwkqfUfYVR5CKHGKSsK2UoVN2bgS4WGE2FASDpxOLl7P4qIcHFKRbeX0Sqz9LsG0aSOVBxujhzn1I03mTxgUse3n2Yva6FIH09uEj+Y37gmJ3jH8ptkvDZfLp5hsrrHzbTGxekY9zl3+CPrB9k2kpy8dIUH5EkaXg0ropFOdBE9D8dXeD15jbdVJrjMKZ5tfx2Z36FXjjNqfY1026UX71IaGyTes7DaBnc119C8GKaAWjbCu1ZfZyk7ziRtVKHR6QqOdlYwAo9K7wweASJjoNk9CHzOJ0/xanOOewcvcmpiicMyyW3doyPjbC+EgNT5TNgusq6PEEiBZysorQl6S9+kYyjofZeak2azMI7iRUhlt9lJDTDe28eKqUSERzSyw381fh1VBGyUQs+B75X1t4Xh3+BKTaZJygh+dY/NSOjolo6oXNXirLgGiu7T2m+zeOFDWO0B/q7xe0zEV3lv89OUbj2ITsCS2UPsrtIwUnx2QsezfYpmlUDCTXkEkATuOu30NBEZsgspb4PDt68RVS4wah7GcjVUT5Kx01QSm1zvGbwSewhFgm4J2nGNskyT1OMIwPAlLTXc6PUjAcLuYVo/Qz/9z9lNLhA/aDBO9ODE/mUCGUULDhOP9DBsn6rqsBuZQEp4VrlND/gd+x6ub0huvn4IRZHcm75DJr9K4Kv0rGkKHYukZdHxkjhHJLOHuziqYCUdzn9bDsIk3nIGuM/tI1wbIxBU1Dx2oKBokk7ERHH6CKBpNTH7Hh+pbvCm+bM8PrxMzm3wy9Ef45HC/+Cy8jAuGp8Y+zB+IMgn30RKnUQ8LEpanTH2hQVSIDyXUSuUt8XU14jrASOtbX46+mcH77Rkxyiwb+R4tHmepKoiFZ+h3RAR9LuCnBUmUq9roaRxeuQEUfsUMdFA+hpnWgt8dPerzPVDFqXTsogEJlNBioqrkhJhkF0SHeJJCVIlcAaYrgXYhsLXhorEKjbjiR18cx9T6VHojvGXDw/RfKxLioCl7g8yue+ynU3T7mT5+sqzSOcoQvh4UZW1uWHuuXWVeKPN/zQ1fAI+hkE6CPjm2NtQgoAz/msURtpMu5KfvbxDNRtKn1JGuF9qpCnJAvmyiwgkX5p6DFW6vLO8TKAo1FMBDb3PJW2IIXUPTfbJux3KXihvGlQV3td+GIBqyuEedZvqxhFcN8Jdp57j79/7DbwHf4P+07/K2Y9dZva9P88/Gf7naPfW+DcjfSZHdujVY4y3ZmkkbvPzg39IH5Nz2fso1usgbJCSzbExdK0Bahdb8dg3qmj9HBGzS0K9xlfybyfjNrl35I8QxiiqIWjGVca8DWRlikndJx2tU3cSmKpPKZfjfwTvZMirs2YmGS/HaHVDFq7PNKmOTbRj4QyHCXE05/LNKR8JxIK7yPd20XyfzWTomnZ/5Ns40qDeSeIqUUYjYSKybpnUklmkn6Ek2hxN3uIx9Rrb2dDswSrPsGjfhYbPpeQau9kwwL9v4z7m94vsJ9uYTg9FCWj4/0dfi4eaLfGUcpELeDSDy5TMl1GlxBMp4sqncL0iitYmiEg0dxQUBSs/yuahBr7qYyFRDGjpEcpeWBncp0R5KxLF1y4z5o9gGwaqIkmW4mSsPkJKhqo1vLTOcmyaS3c/jVjpkHVq9BJZAlWlYBn8h4Vf4p5an2y3juOb9KIqn3R/mih9fmDfIkqcmLVIqlnCV2Io/RNsjz2LyIQGVTdiISj36FuvsjmsUfTTqJEmx9XrXHvqSS6NnUJXHL5ffZmN1gBO0EZBYdgL5XB7e88AMCP+EDvmUxzd4Z+c/CRZA7pnwVyC1u1/yCOtWT7nPUo5SPED9i/hDPoMnP5TfnDo17Bi+8y2VBYzNpn8Im/ffZx40MIQN9D7j9HVQqn+N848wXOxK8zfukSkdpL39U/xS1c6RO0uv/WDf4ehWonpRrhX0ueHiI6fAwJeUZ9mITjLvHkZgDfthzhUn8PH561uijN7OZTUIG9tSXq+hqEGZEYrOLqGRY3VuMJwr4NQJBOZV0FRuDYRQ6+q9NLLmJ0RoimXdneQAEGSJpaMkO3XuLn3El9yPs93k99huDXBrm4QC3oMWxWmSjv4hkJ6r0bcc3jfjsRUY6iqih0IfF8w5y+z4MxR6eZASraHwmLm6NYSq36BcaWB7nTwYmEfnN3R0ZWAm4fDPS9zIXj4VtBnrvoWiQDEdoudrE5Hg73MTd7KqcS3D4oNmaVgjXE+E87vWx+eZM2b59blx3nprZ+meilBozYIlQV8NcqWNsa7yy9TcJvUz0UQAm6cPMYfDX+AXecMP6T/KfPKJi9kb2AERfrph5HlBoY8GPDqjxL1Uuy4Pmf6h9jUFeaD8HkuxcI9+sqExeZSOGP4WGufXpBhNwsKgk01jH0KcLS2x0O8RYDClfY70TyXM7evcnNqFsftM7XzJElrgJvyJIr06bZzRLUeY5EwZnfVFh//8p/QViO0lCTXxucIfMEhoWE6WyAUIhlB10piBj1G9tbYHJrAVCXDnkpHkSgH7rRuep2jlsmx/Wv8L+VPkbGbICW2YtFVY+QMC3yTTWWUZKXOtVaBu9VlftzaIBn0WKtNIg0V3e2xkdimn1j+a8Yw1gpBmYftF4lrNj/erhL3FZyqAoN9sAaRap+qIjECD9fsgxDklBz9bg01rvJII3SkvaSEoNUbh21yHbhr6wyVYp0vqM9SbJYxF8LYNRKD6e4iF2TAjlenzwy6NOjpCY6KPYpCZ0qp8HP1Ba6ZKaqKQtbo8VLsOKqM8O+Pf5NA8bk5tYdR/CbbQYbp2HWCgRcgiFJJDGFXkxgpi152CP1A2tt0U8R7h/k4EYQeoJZ7rAxEsfwxzjTanLl9nXrlMnZ7myOGSao9TWI4jafA0M4mjqHjm1EafpwhLISUzDUeYiddoZEaZnz3NoeioaFPLZsN+/JSMZ5445ssFm8zKfa4I8ZYyYdFoq3vER1w6AsFrVgmbilsMMynRx7g2N4OJyp1PjlvMpHq09HiPLZaYX/4CJpQqXh1rtaHyGkS4UkEgs9nL5EMIqz7H8YXoKdbeJUc7v2SdMsDAZ35kAlvdg0mgw79/ijpPYU1c4i3b17AkA7DInx+fVHl/tZVAK76h4lYgwSqQaCo4EnqRg5TbfLxY5+iPHCbcVfjju4z7Slc7c7wX8c/RuSqxUDfYj12MCu8arLbFfRK1/FEQKzXQ5o6tXycSH8AI16jbOQZ7pSxouF5o6W3Gc5ucV3+GD8iv8r30vrbwvBvcDntAFn/r7jrb/BGcRI3UCjnA7oRi/1uCi3qo0frJO0i16+/nV1G+KH0p6jZR5GtMGBsqV2Srs2GHKJXtbksXYqRNpajsm8M4QkTYd+hk5ri38gkrlQx0y5Jr0tUfZWokqCgjlBzhxBSh/QGl7oxXszfh41Osd2lndDYDPJMByEdPl1yMe0wqJWnw8T/a12HFyKbOFaMrBpqvCdKFWbaa9gMYegjDBouwpbU1ADbGMbpaxQMix/E4HPBfUR3Rthu9pASHsxdZWBggWbtEPvpPJmuTVxzaVkxYi8qPFTwuDUUJ0EMzxNURXg9h1oWlX4Bo7KL7kAgVLabIQoU9300x+JYao/H+tf5j8slPuhe4oY+xm+kDvPe9r/jf7bfyfLkLA9br7Gg3oUtw6BbzF1Hj+8TSdUJAgXbzuEqfaRvEgk8etKj0t/idO9N3EQMq2JyOnERXXGJa120QZXLySPMdkOTEy0dZaS6Q4BAaQaorkfNTBLrrbBjLTKvnWXAmMdQwqT1rto6RzrLHKuGMuE9d5D53iQKgrptEgk0TGGzTQMnWWPUTxFYk1yqhUHteqKA33Y4lihRTWgU1CrDrWkunOhyotjhO0YUuzdNotbG1Q0Weic47CXwDoYXd+Iqrx6+l7HyPuVsggGxwSV2eKfU8WJlllOnmKzu8a7OIZ6uTBJRFIq1Pn/3wu8iTYVgMHSQbJDiljKNIQPOrUrO+2c5Im9y933nmH7XBosnd2lKnxuETNhPmF8h6vjs9EMAQPFb+N6HOds6TmksAb0x8tLm6uWnWbh1nDurd7O38DiLC/eHf+48wM2Ft/PC9gSvbI4Tv/whFhfehiIk3y3cphcvc1f7Om9lT5Lf6iK1FFqnTWMojUsURa9jeAlKag29n0M1LBx9mRcyp3hv+UUGXAVParSz4T7J7pQZsedJJSpkzQYdP4oESukcmwOHKARNVgzB/H6crirZN/u43cdC23/lNkExZJGfWfw2b8TmuaFU6flv53h3CYCdRI6f1z7D/foFbljPkvJt2lqCmLpAy8vSGk/jmiZ9P0yS36H+MeOiTCsdsizbtQG2/REUvc5zbY2xRPi62N4ltr5AI94h8MGOutT6MaQUZCsK+WKLp9U36QGrao7Bg+dCBg2kKGKLYRABHaWG5mUQnkcwMEggBIdvdln2BlHSKlfVWXp2WFD9cu0Kf7++z5i8wngwSDwRSp/OLmRRpcQ3FQbLW1gJHU/XeUvOklyskPAt2oXwmTY6RQYdQdzXMZVFKo0p6mT4rno/X40/yLhj8wc3fwndvUWiEyYOWj2PFR8ip+7Q9bN0gnBv+opHORGQ6Y8iBGSMGlapyq4WJo7jSpXdtQzbKQMvcBn2ExwLHGTpMYJmHB7cJPiHu3zkgc8ylijxXEtDfU2S+z2dpdYE96LxR/4zPOF8ghtijDe9NdYXHiEWWWPrwV8kp19lT4+RH9pACRRikZsktK9iuAUerPisjIxxef44onueQm2Zvt+n2d/mLnuAkx2NVjzBD3/jLxGKyu7xh9C+cR3NbBPJrbHpneR/Zn6CbPEKQ3KbRjRP3B+iHC0zLwaINRu0h232PLhYHSGhO8xXQsOENbNBw1RJlMKPP6R/EoCbYwZGvBTOn60eYyi3jxuYDO0NkhQNGiRRkGjS52VDsh7d5tjeDHvmAEfkBvqYwPQ94hR41/oof/VijYK3ShSDhlFBWipa4DFpbWD5cWIJn2THpzJgEADPdU9jozOuhAlrPxPuCbcZEIm6BOsHffBj4Fga265gfOcNjthQ74H0Jd8teDT9NhezKtFKl0m7SnPwbTS1c1wcCIeXe2mD/aEhuh3IeDVU28JO5Tl78xyD1Rfou2M8tf01LCXCV8YfJfp4j1eyDzLUCPjy5vtwiPNb+m8hvBgT1v0gFKQfJXkgtz3auB8Xj5K5y1TnELuqzfDBXM0TW8tMeGtc9e6mupWnZtRIdENZ5GY0jLN6+AhTNwwecW9wWt7ghneaunEYBXjq/Gv0onEulu/lek9jpN/jpjjOMDusOmlm0muoMmRHu2qTY0u38IWgG4lzMzOJhs+I38Ts/B/S7j6eFWekt8Po/gb9eILvRB9jQCpIIQh2ziIldFMLPFR2OWauIqQk2w5/31emB+npaTLRCk1/iGyvhd2tsaQN4UmFnxBv0rEj/Nv5f440VfBcIrHPoUobeWDeNVZp8LaXv8x9pQsMJB1iUnKqU6TeCggGPLROATtWBwEefYIDdjJPEkfZRNFgvrHPpFPmUuw09bhg5aAVTImcJNAP0YyN8YHvfJ35jRVsdAbNGsc6JXzgX3k1ykqZAZnkD32D4+4q3y6e453+ORKBxW8O/zy7SoaM0eO99tPUlQonXr1Eqgd4h/B3PkxSdDke2Dy9NApISloaY10gFGjNqyixMN/q9JNEiyYn0SCrE9+tYhkG25k4ub7G6Ts3yTfrrO69QExRmYlKIoUKPgpOvwNS4qVy7BlDmHhMd3KkrGFenwuB6adrLY60egTAfjTLVnaAx25/B8N16CQ8CrEtmjKOG8yDMHGohaNHhM6h2StE6PM55Vk6aoyTi7f54S/+IZ6A7x49y0fdz+Md+SG0sQcBuFDIsdAuYIhw00oBd0SHJXOTWX+OlcggCEi2oqSVBMmWh5SCfKqCZSbZCtLkpM+olaZcPcJFcYy42+dJcZ7ngyN0kHzg9O/xYOsSJS3Db8dTvOmPIYAgEmWfFELCyOQXiDejFJUb3JA+TRXmHJVLs3fx69M/xam3bjPpBWxFR/CEir2XJ9j9LuvDYc93zlYJVDU0QbOzlDHpyASZXpNu5GCub6zN0qE8MeGQWw77cr9X1t9oYSiEeEYIcUcIsSSE+Bf/N583hRCfOfj8m0KIqf/T537h4PU7Qoh3/v/0wv+/tKJGC3av4fcrdArD7Po5hr091EgJrZNAi4YPjyclrq/w+dKPga0yd/gNTk2+CMDhvdBYoZ9dx7hSQ9vYpqD7uD2DpPCoRSfwvA1asUFG419llwHMtEegqUSU8wSBy3j8CJtO2FA9kF+lJfvsxiQryjjJjodrKPQMmLNDpF/Z94j3LQIhGFIrVAYk8W2d38pl2JZpFLOPp8DMTomC2qQfDBITCQZ1yUag4gmBGkTwuwI1gI8FBjmlwRc7H0VqLr1ahrnCMvHMJpuVI7yZ1YnbLjHVoecoRL6aZNVWKE9FyMTLyI6O1MKk8jF3jRXHwOtZ6AezDMvDoU37g8EV/kHiL3h2dJGEdPnvmQIP2b/FF4bPsKzezb6Zwz2dY1rskFd22PfvI9M+cHnMecSHrhHJ1Ol2s8SFg6L2UTyfnGLR0lXK1hUKbgM/HqVXiaBEunxg9ssEKERHfBajk8RlBzfoEM8ZzGh7lGWa5fRRzL5NKZqh0NhgoX0VQ8YZic3SVcPk5nhlkzvRQxzfvc2uXuDXP/JPGfJDBLnmS3QvSUEG7Cl9pOryU9Wn+PG9D3O7a4fy2ZaLL+G4blFPRBjUd0g6eT5iNYgi+aLyFH6g4buhrOZqcJrTAhwZFoZVI8MLxx8N76fMMibb/K6nIABnNI1jRDm8u8W1tUfxrk+Fe9IxePjySxScJhmjQ5cIXZlkQQnNW+5zM1S0UeZKbezvDBAb6PPYPQ0cKdjT8tS9YT6gfgeA9YP5f3eMJZqixz/Z+zie6pBo7aMK2HESfDXoMbz6MaZWf4SRPynRuiBoLU1Q3TmEvvw4cvUJnm8maLtZ3uYW0PH4difD/bXzRKTDdjOLFBFEfxU/FyHwsuhqm0Z0HwUVrZ9DCPjW0BH6qs77S9/G2ToKKCyPBgzIfexyCk3GMeNVMmYTiYKNhqKl2I0OoBCwrPUo7kXZGp5iIR3g2o9go/G0cZ4hIUi3m0zeuQWNgK9nGwSkmfZCpvCJwTv8jPYlvhAr8Grrh4n7XWpaElussd6JUJkZRpoqvlRJ+0luGiFgIuNl6OW5kb5DSZdg7vEzdp/3T7YPzhg3dCIOwpCwOuDQtMNCIN90MHMOR4NNdCSvMEQ/GiKyvlejVe/Q9kN2Zk6GKLDZcon2LDK101g9hxYJhs0GrxbbRLoh+7uQi/CxVgdDuUFeJknFG0hfZWYlvIbScJHB0iIIgUzq2HVJ3gnHinTTmfAMbcUZtMI+HVUsc/P8D/DLwa9RHvHZTwT8wuR7eLJ+nn/WepOI7ZPs13HbCiJwGdV2afuDjNTHUIjz3DOh+Va+G/4821R40LtM0w5Bia400ZZsrmdP0HHrDMkET3XiNHSbyCUbfxD67Ti/c/nH+cy37uMHlhu4xRDAczrbHEUlKgVdNI7pNUqxXZKlDzL52q9i1OcZyr2AFAqNWAYlVSEauUZEeQ3PaPBD6zZ3Zk8jsYnvuSjSY1DbZtvJ8dmoz2vDKd55+TJPvfEKrhZheWYa0fcwFgTx4Wuc6Sj8dM0mNXCbIb+MzBiYUmEntsNhK0A6XXZjLlJRuFku4gYK8+2QRbowEIJLxe0ISEk9oxLxLfayKrHBsHhK7t/LO1Khm2Zha5I0LRoihSpCYGtheB3VN4i1dGpGjge1myhTJ7GjEfTuLt+PScaLI6WJq+wxVlvEs1QWR3sMtvdQ8BFumnojh1Z0aBxTeCFyBl16jKktBApuPEozCg03hqJCrurguwIx1qC9GcewNVLtKg/uLxIA0V2L5wc9ZPMd1AV0OoJxLYbudUj7n2MrDrbQGYl3cA0Do9ol3w+BOVNEMOwec3e+xvDea0zHV3ghdx/XTs4xMGCxkBlmotJEiBF+1f1JZsQO/+9qm0PtcN96RpoCdXypMN9/hIuJWyxpLbz6IcxUhyg2Upec9K5ySlxk1xvHjWXQOptIcQhV2PS98FqedrbwpaAeM/GliobPW/2TWLEi24lBHrhxBcO1Oa88xCuJGyS9MvsMMeause7rzGRWUb2Qhe1qbSqJKDNr61jxGNeNcaa8PtneGlqnRRDso8U7iE6SQ90NphdvYVgrfCH9br75+IFzaXuaek+llbzJQ2WXYrFJ3U9jKwZxq8rl8Tk6SoRkYoe3tGM8sB3mMqfUD3GtO4YiJH+mPk0/l0E1JBZtbo5XeagLBA1UoWAogh/Z/xqF7SjFrIeUsKM7NDsmKKAoPq2Dmco/aYYjggCyQQL9wNwk1fKYk29we2iWxdEohw56ryM9FRF9FyKweObl71Iwq2zIYaa0DQZllCf6GkvRQV7wh7kpdUak4EPKszzesTmlXuK/THycupfF9oYpmA4ZpYC2t8TTl0PW65XcB/GkzgwdklKw089i4LHlZ0jeDK95+fhlRCJk70Ug2ZnLkBQKuaE0+XIIGqwN6vR0mNjcpVivspnosdtfZC4W0F2RbJiTlBMmsWYNN51jVQkNnR6qzBDgszqYQHebTNgD5OtVOoUiEdfFpcDDy+E524p5aLEVFGGTLj+Cog6RcisYCZ9a3yDp9nkHL9MK0vzCp36P8a0V1uZneGLpDqvFUb505O1UTY28lsVH8sLJo4Bgww/9GWRURe2l+ULueTIyTjsTthjdFSxTlBGEN0TFH+aEd43ZUokVJdynD3Ylb9in2I0O8OLPTvHhoeexhco3cHEiTe5u3eJicpqH+jr7QRO13Qhjikgx4Af8naXDlHaexExv8+exHpqEOVfl/IkHGCntobltugM38ITCXnKIdjnLDlH2DnpVhw+AV83R8BSba63w94nLNh2p4wmVlLbLN9LvYFX9T1gDT/O9tP7GCkMhhAr8NvAscAz4iBDi2P/ly/4uUJdSzgK/CfzGwfceA34IOA48A/zOwc/7nlodP8L2fp7qQJ6KVLiqzDKn7CDUFl1lHKELfFujo60BcPb2KrdvP4iu22QPZvpF2kUCIalOnWNY66L5exS0ALuXYkJqbMYmCbDpqS4/6z9HS4kRybrgShTRY83ZZyw+z5Y/jxAuI/Ewkey4a1yJHCHZCVFJM97gWE/BJ6DqS6KOjavpvBjEeG1a4eim5GNXPZwgxrXYHs24x2jNI6P36Ps58loNVcCbTpgozTfKeJaKqTWRBLyTOrfkFJ55nM62jpJsIoRkqzrNa3KWncERopqL7Sh4RoY/qhi4gYIX36PvjKLoDZBRPiA3KPXr7A6OU4msAnA+cRoLhUm22fbSfGn/ML+/dB+fEGcpk2U2s8JpZZ8frn+BAdHmZ65+HgDNupfUQWHoFARkV4lmG3TaGUylh1T7KK5LznToRAw8L5QeaUaSXjUs6Oazy1h+jGaqQFcJX7PlIkPGOPfq19kVeT4TO06q3WYvnUR3ejiVNdqyTFRLcCcWOloO9iyupI9wXK5iNzUUCV+bfScXYx08CX2jSs5OsBaEDO5I7xA/IKIcVfsQgFENk7vjqLgJlUE9TOierA3xlVicfP1xIEDLvo7oetw25zmGyp4GjhLBsxJsDI3gawqjtSodRllQE1z0fW4NF4k6NnM7kph+h4yWD++ZHYeWwb2bN5hw9tiMDbGQHKcZ5BFAJX4WgPeVXPyXNW5+aoabnZCJOjb/CuV0gszB2IPtIEzWfSXg2/YtUn6cH6q9m06ySE1VeUnNsG8ITns51u0dZtu7GJaOtlslX76Hb46+QLHZZyIocNKZZNLb511di/VmAlM6DKY7lLU06raFoVwLUX03S0J61OLbZC0Dvx8WP58qvJti3+KB5lWau2fQVY+3xiUTrFPpz6G7bWKRDmkjBCbswOS9azUGDY2WIjCaAt0T1AeHuJQx6CkpzvlHeEy9yt/fvM3HblRRFIUnXv8GC2N9HMrEIg8ycLLN96fO8Wn5IH8ZvZ+ctYvqt2lrCZbJsm0l2BuY5mDiCiYnuBAxWTUTEF/H7aY4X7hI4Ga5pzHGhzaa6DEfX/fxlACJIGOnCITk8qEmDTeCEJKYa6FoAQu9PEfweQ6H9chFfAVijsuWn0Z6IeOwYYSSpHvkEzx8U6D5UZZioTy2OZzDlftkewVUO812Os6PDg/zj4dMXKVENt7BsjJgNQC4OXE3g+WQpQhSOlIT5NwwYfHNCLFuF7PnEumOAS4t30dYw6T34zRzBq6yx5+P/AC/M/Bu3mN1eHBojVPlBfDS5Gu3MLUqblygBKAn3oMYDguhQiNMTvaNNA8oN9C9WJh4+nn6cRfLyNB0auz7EXQp+Ga8Q+dllcFf0Dn/xlO8VTrNe0t7nO30KWQ62HGN6P4iqoSzB+ZHT7dqDDkF7rcySDcHmwonF08DsCnHeWD6Oqdth2ZMUB95iQeqPtbAIfT+LY5sBbSSCYZNjTqDfOZ+k3Svyz+7VCLiuizlBtgz++ydiJP+lEp6YJFTUZV4ZhVF6/PoXgRpqLQjMaTisW+HZ0G+Vw0dMDsBW9a9JNRLHFI3WVDDZOy9wR/TlmkMrc9AdQ+EIDt4kcCNYHZHOeaomHoHtz9JXnZpkiISG6Qd9XAzq4x0xqkEIbh4v7qAPxieh2Mrt/nTxqt8zrcIGCbd+EOKXo2V1BArIzZG4HJEX+Fl/xSfDD5KLdBo/5TDpaEjTDrbaEKi6iYoAivhsxINwaxRvY3j6oiIQ2sjQapexHAsjlUWSQaQ3upxOZeA1DGUSh+JYMrKMHTqT5n2iyAEZSVGTK8igoCR3RLR3hKGFLz7+W8BUJscxJ+9QUxt8YbxKBtDM7waexuepnB4/RpOrMg3B9b4ff/dPMYbPGndRvgBMm5SUPZpiiRSRHgpfo2F+AbSizCvDVI1koyrm9i9JONvtJiqhuzODzy3SWDPkTS3SDuhFP2416EmMmi2Gs6JZZyOr4NQ+Ob8u4hqPe5avsatkWM0ggYFfR9XGMTrLSSCmdQqBgFRL0or1kUCQ6USvqYxlrS4V9YYz61QiRYheROhBASNPJO9dfbVAieXXuMHb79MwQZpKPzl+ABflh+gnSkx6AgSRpp+cIpOJE6hfoMgEPhCkIk0uKYcY2b7JlJXGNSPstY9RU8aLNUkSlYSV216iasIKXhgvgqyga6aZGgxPdDj5ZRH0ehQkSk2zSqpagiUm5lN9hSJgcemCBl/3VeIYmBmN5GuRsuGpfoNXN1gY/wJ1F6oHHCVLtX0fUQ632F1qI8/KFkUA4yzRzs6ydmezbHuOte9Ec7JFHtv/hqus8Hf796mGUzy2+MfJWX1qcocEbVP39tB7NwhMCSXC7O8mRvkblthxDdRhGQxe4yiYdFHp9pJ4LUVUtk2ajyg4xqYgY0bVbiQFciUwahoU6jtsz3o0ogMo/sxdN9nIzfAlcrL6H6E/vgjnMuG4x4itQpSN9nxMgDc1c6zktqgHzvCWG2Hcssk0tuhlR8jACZ3mrj9OAKJNKAR3UPLXCBhTSO0Yaa0sJ3GK+kUqg6nuYGwHJpDBa6ePoXvBjy8luNY0+W3Jj7KYlQy0HLY0mBneBgZTdH1Q9VISvexnQFeTl+kI/p4qQiyrTCk7JLXbtFSxrminWBGWUSOxVjUw/fooXaZO72wSHtn/zbHt6sc7nf4IjZ9S2ekX+Vc+iRn+4KPlF9DrR8UukGUd/ZMWq23027mCKTggudyPxpxIVgcH+bk8h320lG2x76KJiWbmVFaDZWN4WkauSx+4OInwrNLdfIURZm1dhj/YrKF39Pp6lGGvDWe4xm+Nv15Vsqho/73yvqbZAzvA5aklCtSSgf4NPB9/5ev+T7gkwf//hzwlBBCHLz+aSmlLaVcBZYOft731IoEPvFul4vZKZ5zT7AcDDNCGTMIEJ0kDnHcnopwr9LTIzSTg7yr8zhCgOkGSKDidwmExDYkM9Fvcji/T0wBszvJXSLG1egoSAjcVRx7hGFlDy0SIH3wXcGXNY2YlqLmH8PMbGNu3EvgZNH7V3kzdZJExwMJqUyNQ11JSwSg9iDw8DSV52QThh3UAB7cMQAFX23SNK5R1MJZVr0gx4AWopvXD2QvD+9v43ZVDKVGN7bNaO0op5TbPO89zf5OBoDAMzjS3mdXprk5fghDCbB8FS8eoxUofHN9CgKFpjOOotfJBDnynonfr7AzOMa2HrpsvmqcZYtx/gt/l9/rHuZqP4tEoDcPoeAzldrktLnIqewiv/mf/x3Pll+j7B6iIIsM1ffxdQ0l7eFqHbSoi9XMEBddpOKj2RYDSY1AUYh3SuwbOZzOWdxqmAxfLR9HZnRcxaSihSiTIm+Qk3kSvkM1McBwt8yA1aCW0elrEea39yj1wgR79cBIxg8SlJUU82IbZcXjP/63X8NVdf7l2RztiMCOLzJqrtGSEbpOjKI1goLg2bk7oCkEzYBhAtJWkRMti1HjW0DAd/vv4bP2M+TbE/SiLeZzSyg1m73kAONEuCl9HO8Q8U7A+P4O9YEcp8uLpBUVKQTnpM8rAzoP7bXR3EESrR0ykUH60sWVCkq/wISzz5iosKMM8PLJ45SNHB1ivJB/iHR/jeJCHUtTkK6OHYRVTat2mPahMFH3UdiSIZo7tPoChe0G3xFrlD0bPZCIWp1e4hp37X4IHcHMlS+zcGoQoU0g/T1EEJC2DhOv1nmbe4L7g1n85B1+qNUm0zSwDYXy0RGm29toCy2E24e+A1Kl4Jp0jRYRP4NtR+kS51z6NE+XbtP0i5TL9zMQ67Flphh1N7H8AYxSDTVaIyLD964nDd7+1iU++OobLOs6U7txVMVjONvlzVyCc3i8HJxk1K/zgPE1frw5wPHsvcxsLBDt9LjKBsnEeQrHO3w2uJ9/LZ7m3tLdDLcXkNKjrSVZCMbY6SdZjx9i/MCU9pCdJBCCfzZxD0G0zI4d49j6BwDBEc8jL2z8chQz4aIrktLACNM1g2rKwYoG9LraX59V2brLsogzo9+hJRzMZo5uRKPo+CzqYww4Ibt40bsA0qHnevjToZDjZqpILmhRSUdRgjYT2y0Ma5Cin2U1leXVaIyo8hbRRIV2N0NZbeOYOiujh0l028QtG5nSQREMOBVswyTuOaSaLZReg757FkXZo+aPMGxZvPvVi2S6LXYU8PUx3mqP89lkgoez23z8zhsIESHVW0IVVayKitr4OkIfJbVxH4YXIdkJC8NtM88c6zw59rsIAYof0MkVSHpRNv0IDSvF3ugNtoiynRYoTcFqJgRFhquhjXo7qeEUVca3V+gLl48Jg5/EJFpZ4jfW/hEKgn933GTSuc6hZhRNumzIKbKxJtoRk05GZT//JhJ4oKER617h8JbkVj5HRh3i5WNRtiMxDl//c/ZFmLDN7zQRwMuPPIRWEQyuP44m4FbqKlIKxqrhs9RNjPBT1e9H64TXui4ypH2LrKsixE8TyAiPe+fYjWUxPY+/MJ7hqnIXipDM9cJiMppfoV87hEBBNk/gx0psxKeIENAkhZfKsT4TmsAcbc2wr4QmIGfUBSp6eMbNLq5yojfEk66gI7uUrq6iRX3emLqHZjI8D850F7gtJ3hh8El+q3SWq+uH6ShxZkeXAYkVD8/bmGzy0sTdAGhqQDcWhUChsxVnpBwl4ju4eozDnkqrHY5NeHEsQ2yvRyyAQ8oq8fkrmI8vo/qSmlTIahaJeoPj1UXwm8zslJFGFJJ5tn7U51B8A08obFlnWYpP8NnsBwAY21imbdRwMhf4TZ5hKZjhWfF1pqpryLjGULBPjQw10eZlX2d3IJwxqFbHWJ5IMOtt4Hgx9LbBXGmTRkSlZdhY/gRdbZeYH6AKiz90nmHfSTPRa2AKj0WmkLEQUKvmj9CfEjz1xmtY0QSByNM+6JMPyikEAaPqNjGzT9JN0or1GGxaDJVKuL7gmFrCTO5x1Rzk6pn78SfCHvh9LYJ3+CRDo2nuaibJ7Kp87MU2Q7KJ0nT5VuKH+Lnof+GPZ12q3E9X/CitWBxD7vL4cthOkTWbrDBDfKuDMiJJaN/gtP5hPrPwHl48XKKfiJGTHZT0JeZUnbQmkb6FosQoUGWLIe5EBhkRZUpWnHtUSLTuRToaZmaTVd8gIWxuK+OIAOJ+uEf88Q5aI89PDBcZ37iD7jrcnJnD13UsM8qtyWGEhGzzm7xyTNAfF9zU4ihC4ifrSG+bOaPNkNJix0/x3GiEXPOXUajTd/8R//mih9qIMXqgvtjqPo9o79MzDf7bmQ+SDGDGVSkeXE9G9JiLVlEIeG3wKM4+zCsRtGhAxwvdf2NWl0/crbITVznVbzO6s8ZKIc6+MYuIhmzVzbF5KkGdHdHh0fYZStECAy0L325D4GOKIaRUyIsG5w5VkEqMXGsZR5QQfh9D1ynFukT8BrYnMfWAKV+yE9tBy75BJtAQWpHxWAvHV1BXdQo1h6oV5dHXX0PIg2BRCrglevyrGw5dNcpXRnRigcrKwUD7heEJRM8HTXCk36HvFPGEzwXzNm5mj+5+no6bRREOV1JjLMl5NMVjcrbMWkKlrigctTbZdjNk1A7T3RrypuR9ssM6Em8nLNLOpc/S8hcI3C1SHCa5N8tjzWEGfJUB8VX2gj63a3NYrsYTQiNIK3QjOun6LmuFAqgOx40uq9oUQdMhXasRGDpDosy3pzZ46ladSH+G64k++50RFHxMLHzLpBvRGetvUxd5FgtF3hz5W/OZ/6drFNj8P328dfDa/+3XSCk9oAnk/x9+7//fLyce52c/8u/4venvw1LiLCpjKAIGtRMEyTmuJU/g9zX+y+O/xJ88+E624yeoz30RgExpBkdXSD92iZSS5P49lasj55k2XwXgSPs+8gF0tBgp28F3V1k258n6ISNoJj1q5QTPJyN4gYfljhDJrCNXC+idw+jc4bY6ihXEkT2D4dQeaVdSkQpaOmTiXLWNpxV5IpNECvC6YRB3cs/SN0skD/r+ksJGi23hSIWKJ4gGAffVtun1dRTh4ZnXMBL7POs2sTF4xXsSKcEqzzHSz5HyW2zroQyi4+t0kwaJIOCtbpbfeuXH+cTaUwizgfR0tnoHPXH5BNAm3uuyHy/wPA/RJMWT/RJJB46n96A3wYS2ia64FPUaC/4cY+09sqkK670z9AybkcY2rWTm4B07SPTrOUw1dFA1HZuBeHgQyY7Lm8mTxGsuMX+IVifG+f0zJEcdhPSpRnK03AIxccAsSkE5meJ+f5G2oWPSYS8ziqpKFF9BIjlizwIBlp/lgxeeA8BeUZjqOnzirR4tQ+PPnkiiRyucMMJm+q3yEV7vqNiB5MJoBOEHKA2bSdVnsF7krq0umuoRUV1a1nFOlJ9BBAa3klucSFWJ1Zv4usZGyuS8b9CSo4zYZR658hY3jk6SdHsUa2Ffz8pwBEcVfGzboJJMoe3YZBLD1EV4f3Q/z5TYY0yU0fZ8fKHwjRMPcNE4xrn0SR6pvU5nd4GeoeMboGphVVOrTPDWuV/EUVSa/jC+EgoCTuxYaK7KhqjQEX3e4d7NMzf2EVqTB/szdISLvPsS5fs0BiIOECD9fU6tFliN/H9mFRqxBeY8n+G2QTntMtyp86H1vwI3wN85jd4M0XgZC5HNqBOna0c5zwP4isqZ0nnOWx9FET5a2kAKhUyzjeL6ZGwTJ74HMuwRaQcK6WtfZfz1t1hQTSb2o8gBgxPuLo+WfV7B5nJwNNwT0ZfZPPVfOZx4ACeW5chb1xHad0hpn6LeuYt/7v49Cv0etvD+ut/GVuPcCKboZA3WtRGO9sNjPS89fHWAggwTwdmOwUz9NAADagdFBX9BJZZyiUr4wrs/htnyqWRspK+i1ML9HgC5houTM4ipNcyRTzMSNLjuTCMCuBKd5ayfO/jafTzZoNUuYUmFAJcb+QkmrDIfX/xdAIpLy+jdQVS9T5Ymd6mHUPUqGF26nSxbcR8yLr1UDKkYDFWryJSOcALGvAql/BAJu0+y0yHo1QnkGELbxhu/xOPXfpHve+G/89/+/b+m+NoREAr3LK7wq/ksl7wU79O+yKz+XeK5OkJIErd26Sjr9PUVktWnObb/MFlDR/ShoUfCIqi1xl6QYUipU4zdTcQdoSqHSQ5fQaR3CFB46XiOm/Oz7KsRFOkzXK3S1xTcqEDL+hza2aKsdzmJxo/Q5Gj27RT9HEvmJt/JV0h5HbzMGiN+hWV/FrMX0ElqbBdNLDxW1TLv3XY5unGNuA0XCod4Pd7i1WMR7lvf48kthy9lzwHww4ttmpEENWeC208+wkDtAXbMLfTiDdblNL98OIbme7STg5y2DvNT5q9gnPk4bW2KYrnH+NDjqEoey08wJTYoqPsMKVu8MjvJG4TGT+80vs4PrfwJMmLTbw7RFX3sxj2I2ArlaJYdmaNBilLC4/pomUKvQMoy2Tey5AKLpOjRlSaBEJi9PsfLF8hHonSqz6O0JIoK+5E8g9YM7ZjL+EF/W/Fqg/ntFF9Zvpsofd5/6ivMzb9O5KAXWy1/k9VoHv/A4Khd0FBbk/R9wVQlPFt2IxqP+xoBoO73WIkrBFWbOU9l3O2S+4SGyHmMNaEOpBSLbk/SSIT/x53TZ8F1sE8qrDZGOCaWqBR0jvhhofv81CypTh9ElvMTXwOg7yf4Oe/voSD508X/iBJTGJJd6jLNomiit0/QidRoR/qUKnfTHvSYOBj15BkRCp0Wi4MT/MW7RpGKzrp7h4QXIx+0+Av7YS4Syp0vyDl6bRNLj+IoDuMIeiclj198C911qMXvoZQM702rOsB4chtchXjMJuEmaBk9Zks1lH6P/809y1+Zx8nvP8T77K9w7M3XSPcP0q6dGHp5l1rfwAwkngt9fIZlC6/n8bO3v8sEq/z2TJ4nHv4ZPjEXzjAM1DKHqyHrE1cssvvgdwTDE3sQ/xR2wuTQ4Y9TcX4ChEZEOYdQXB5KKCS/qRIEFkJJMiBrXOi9j2PNKZJ02e9EeVAoNCMR3FoRPbNMVV8hh4cUAikkKZnC9XbxhiQvqm2qqsoPrvvctXSHGxOHiKoxdgbGuTY3x/S+zX2lKufmBc0ZwXllCoAh8w6+t8NGMs2T+hKq1mRt6gEGJ1qcrz/Gn2QOc7rh82+tBEX/oTBf8K/StSt8euqd7MYHGFY7dBRJ2okhgTmzyphTZyha5o3iMYxVnWS0ixHx6brhvRqp73BbjZJyAyZaTYb3dnA0jc1cDD0ZFoZbxWG2hie5KTcZUnWGEBSafQJAazdQo4JukCeubbM5PoxhO7je67SFT2BGifo+u9FlZmjj+x1sLc7dvSYIiGodDvldmkaR0WiTHTuJ2YBM06V0M8VAtUw7FvbfYQtsscB82+Gxcpv1jMFGTmcl8MnaDW7M3YXo+cSFw6ztETihyulc9jV8s0mqfYKXxHsA+MrgYda7IeO7ksqxnTZY1gyyZpV9P8VEbI9r+vtpLhs8GdNICB/qJp5QuJY6QuBfJFCLpBoNIoxgSpWvx9r8pTJCIBRe3XkYXXGhYP7v7P1ntGXZWd8L/+bKO+eT86mcU+dudUvqVkSoJSGCCCLb2BhjsLkYsHnBOGEcsAEJsAFLIIEklGhltVLnrq6urhxP1clh57j2yvN+WAfs9x3vB49xPS6XO5ifTu2x96m9zpzzSf//83+ojsT3O9N3CVWVg41x7svs0JAl2mqGAxevgYCuyPC1/Dn0vQ9jBBqnnD1onSMUZAuhSMJhhmESpqMdRtwdzulv5fDBR/mbtP5fLz4jhPhxIcQrQohXOvXOX/fX+f9eikDfa9F6eJrg0TLX7o17xibM+7l16D62s/FFe7j6dQ6tvMw91xzaWhWjJUk66/hhkcxMn4OPO/xo6x9hRjq9XMw/D4Z5OjaoUchou48Mt1gL5/B3pcLNfEBzO0NtLMuqs04odcrGEqXwLhOtgwjFo5uo8lv8IGu9GWbTa1gReK5kKxkrGTpGiF/4Cf7b3vcRjEeMLtmUh21OBjXeb9+ioMX0lxeTWZz0DlthmQjBWAiLXp2O3OVph9uMHPsksvcQP6B+kVeMI7zw/Cka117HsnOZSq5DOx1X1+zAoGOFjAUBXT3gNecYVb+AorWYcmw2h2kioTDMxN8x36nRsQyqjKGHQ5xIJwg03jC2hCvHeJ28juZDoMM77t7EmNURQnLHPY7UvkK236aWreCho4g4sHBbI3+1hWNKnqxeRJERbc/isjZHQQXNGOc/nv97bNsjKCMaszvLLFnT7Ph7KZh3aestLDmkY1s8cvM8V2YmAMGB9GX+8G3fTsWawtZbPNQ/QUKzGUQFStkug4bBzZE52jN7ONKJePfZu7RTKh8++Tgzavz3rtszdEPJl/o+L8gH2bOxg/Alb4muQTTGpf15+klJTlWRikYySCOQXMrdYtyQ7NsVOnmlqFFaP8urgU8h6HHPWo/zk7GDn9tZQkFyc06l3O9ztCs4yAARQJo8TSVOWnyjzL7EXbLCpjcQGBeaNFNZ/u7Jf0YoNH5w5xmsnVvYpk47J+jujvt5LX+Wdij4qv8Yr/WfxNk9t0klQaucQBp9lrK3SKKz5+CTaM3X8QAaQ+MCg7f7TB1YZXbfS/F3CNcY7xR5cT844QApIwxlmyZp0l2TRrZPuXMW3dxAmTCQtTHM9esA3JyP99zrb9GPJC/I11H26+y0KywNHuJA5ovcmogLIKmmIDN0qOSO4SdqOPERJLRDpNNBuh7r9SJmoJLlHl6/8l5+dMnlBXxK0RSBSFLouHD+KsKzsebv4+3qK7xT+wbd7lHuKL+ElBYz7SE2Ll46D4CqZLkUzNHdVyQUGof6cZ9KpPkM8t/JbCLeM6f9CANNBQn6btGmvNxFSwdoQ533XP8SoYRm1qXSEaTrPqEUBKFCoe0TjBrU9A2szBVmlR1edQ7y2+E7WVFGuY80eqAxMAYoYZeeVaQ/7NI0FDzV4PXL57i3/w0AcraO4lmEZpd8ey9T/R26qTg4ULvTbBaSBGMRh4fX6OQmGKmtEqV0pJCk/RbtfDxXzXRdEAJFaOj+BZQPFVGCiMaPBLzywGFe2XcALQi47+WbJBz4TWWGbX8vjxd+i4PF+K5sKEWEDBkxP00juc7p9TdTNjWUliBMhHRkGgE8Gx0lpbto2VFkfwJFsxm79w+YcOPvvV48wGsnjtCWJuWwBX1o6bH9zqUHpJzhXw3gjigwl4xRyQ+OfYyR7tdpW0mG6VVm/RZ1bYTM8hjFlscgo8VKq/4m2QDeuRHPPr1UOc2/Oz1JxfZ4wysK787UuD3uEigCr7fJw/1RCnafaOJdhL5N78BvYRVXWIoOM93codJrs5HN8pnNT7LTfA596n7eNv3j7D/yfZQmH2a5f5ktW+BKix9ofIai12ajXOYKsYz7RKHGwZvnQQis0Kfh6oy0R9GM+N6ci/bRIcPV0hKO6pH38mh9j21zlH1RXKCpUQQl5NkTZ3BXnyVsrZA491XWFuO/jSEDyu4820UXpx9QTtRJNxwmexYb6hHuW7vK9vkKY2NLLDx2CU1z0fQk9174Jh0npno5BZdGd4ROyqc0jBGLc5kCRxWVcQSJNRvR9ogiyZsUnQO5k5hbWSb/RDITRtS1LBn6ND2d89MLSLNIv1hBCzw6J3cwt5MkcdipGMx3PLQgVoGe31ylVlS5WT7LbPMoSIOL0QSr4Y+xJ7jKv1z/XRJqgC0r3FEcfjzZxdBH2crcwauNIxVJONtByIhQiY3fzdE9SCVGQ5/bv0zZSxAOI9zSDS6JWHG81sjCWoArTDLaXWbKN5DTAQnf4+jaOjfHD7EsRrH8kDtOmj35O3hCw0wNyfgZ9q9GZB2PP933BCDY76wTKV0upOZQXZuEVSMKdMTGBuFgwNlgmnSyjaa1QfYoMwAhGF+d5OfCX+P/s/bfONCFP5uNExxH1jHCGLFW7AB1V9AuN9Xj2lSetfRzLDo6E4kxkAFt6yWC/h5EmCd8VkVKh0gUKMkWrlVlRsatHlUnTc5Ryczcxu4tksht4Yw/y7jchbGEoBilqeYuggJX/YgPbNfIruucvHGNamkUVxnjiw88hmuYnFgKOH47g2MKruYkVXeWGkWOqTe4sreADEEXIfmZb/KrxodYCypc6L2Fz48LfvF4HxUPN7oXKQV5fcC1dJ5PzT/Co8OzrAiDhHAxfJWemWRU9FBlhJK8RNMs0V6ZQ0hJQvMYujFr47vXnwLgXZu3cfwOh2sdhJQsj6pERnzWq4USG1PzrA7iO/gGdHSRoDS00btNIkXQiMqkrBW85BFGV2zaZoeGbuDmSkgkSkZjc9ZGRm2yqqDnxOfqgFJkVIbYekTFsllxc2SKHn5bQyypvHjgCBfSeQIp8IAF5S6GuMaP3ZIkvYh/fShBPRpw7+AKS3MHEHbA6KDOWKAhgyxqJNDycSFkYvgQKxzg0+n/zJ+OP87OrRS2k6CdVelkAlYxSWSGuKjMZ1cIygXU+YdIaiUeNwZMe03WzTKuYmKnDMzkG/h8eZQbosdH0g573Rd5ObufYaRyubafY+UrPD/tslLRSbgRBSdmfTy8sY9DlbiXfiU5w+boYQTgksEILH5u8gMAFEnjORUKXhsQ+F6FYSZEFZJTm89ySxzA9/52juH/6toApv+nf0/tvvb/9z1CCA3IAY3/xc8CIKX8PSnlGSnlmVw597/pq//vWfZqi2vJEmlvyJnrrzJonQfg1MYf8Y9+/1c4cDMWAnl3+HF+ZOQPmZr/InquilrLotLDHSbYOlsmnL2Mv/A13td4G2UtNoQvOzukQoW0b1PZHd7araqcn4opX+lJh+CuoKD02YziIGl2YDOuLHGotQ8ZabTkXYTlsNSdoWQ0CfU+w0DyqhlflilL532NV/hc4fVsns6CFLzn1jf4qa0/IqF2yKlbuFLjbNLHy6zTs+OEKiMNKnqfrhnLgAnFJT15nu1klUeCHhPU+Wzr7bTXbAaDHtXFGZKZOKq6qi/yhfwxmtUn6Tdfhy4DCFyE4nLar7LpeOyUxynq8TPpXptGMjauketzQ44Cgl+qv5UhFie0W5hBgK8r7D1yi19939/jO4/8R55aOI1qvYiwfbrZAutyGksb4nZ0wt0ZWwCL5gJ9kScnHDq6yU4nhzAn+L3CUTaGE3z/yY9T08d40wsvMnWjwXZwkJTWJ0zF6N/sa9dZWF+hkTappOZZmXgdUbJAWi9gjz+LQDBpgUSQSTt8avbNfOF1p5AjC0Ren9FtyZMv1ailRvnA0e9BELFpzvFIwqc+LunrFvdtxHML1awEVNqpGfpZhTE1QpEaSmSg6JKJXDxLbI+3zUgv4KWiwuNLX+Bz++Nql1Wc4Y4yzkp2kqnqDdKWwnYpwWJ1mR0/4CE3SdaqYEiNltpGEjBMlJhIxcWKJTHCfM3h1O0bNK08Wa/PQ92rjJtNhrqKmkrQCRS0UGGg2bjJbZacN3Ft+DhDQCOkWSmxM2aT8jS6uVt8oPBhLGuEfz84QQ6F9DOv8PEvvofBMEPj+CrdpE8YLhMZk6zOLFAPqwysVcyhz04QK5TV8wot9TVKzh4m0n3QIGicBiRZ9xaRSHL+gW9n3Qy5Ig5xxj8Hg0MowueM9Umul+tYcoiyqXEzfZ2psSoISbgdnzvPifcPILO5gCYMHk88jKcv808Wduig8gA5XPcQxaYPKY/h07/KA8HHeKiyyqXuOCvPJ9lU4uCq4jQZIAmtOCAwybHENNvjMVo+X41p225koljHmbBAH4xxrTvHtlDIRYIHjL/A8zUmNIe2loBA5d6NVwCoFjz27HgUei5d38SNdCwvYjS9weXyDWZdUJFECYffCL6L29EEJyNB0lHoJyHTrxFoWdpSsq5FCCl5cPkia4qCGoKqlhhEMeL8XvsMtjLGYFcddbS3j3Y+iz1qcXjpFpujM4xW74AiSKVd1CDAT8cIPVGEMOO7uHWuj2KHvHb0JxkcSRCcbvKNEwcY69/h1oF9TA0VdHGAz7V+Ec82qBTiZ/3dx74jtmXKEl/a94eoUmW5m8btJzDTAy6JA9TJ8FQUz4C9nJxCoDB69M/QdI+RQSxYYw0nEKrBIEqS15sgBV43tsUZM6YRlfrxM6voBFLSDDa4nHJQnFepZ1M0El3mHJumUqZbzTC2FCKFwEr0ySnj3E30uVc+Si2fY/PkIVrJJL/42hA9UNl0JggyDgNTZ6uzxCE7gyIF0XCLD+5R0e7EPds33eO849oNprpd7qQ1Hjz/NO5rH+H5m7/Izc6zpLILKCLkcvtZWp7JavAEb2k9x55ql0ioLHAHKQXCCCjOtwGYc6/TCiDvCyaFjxF5nIv2sSMs1jLrJP0kVmjRd8FVLe7zb+BGCXZkhbJs8tnXPYESeAye+ZcoQ5cvPvFY7MNyR3hIVqkWXMJQ43DmOlVVMgxKhDLFg1sXabySZ+niPSRLdY4f/xJToxPs7H2Iahj7uWFC4Yqt0E35KDJGBK6kK2RUwf0Sgq6HtmGjAo+rGj2/iZqaQixNUrJLODIuQnx36wukgg5hagzLj5CaYDM9x0PRLXyh0SyYDJrjLG7Efufea+d4eeFVjMDkcG8BEx+JwquZCXrh63n/dtzHHsgxTKPG7TO3aaTfwk76CoabZW37ABtTFjnRAhH35PUSKTLOYVStQSPZRQlT5De7/O7EJ7iVK/Fd7j9j/EoduVuQmjcvUpg+T68Usx7eeH2JQTLDa+I0o/UhDoIFq45p+ehWQC60eMdLkqaV5Etz9+GdKPLg0nlcbZOoHzA0dIxcgOyniKI+aiJLzSiimdsI1UM3t5j24wD4moROR2fWeIHfOufwW89u8A+vPc1Y36UvFAQRVtPnxvgY61P72cpO0SlL0voLREj0nEGy/xyO3sVrPsKdQY7n98b3PhBlyjQIBUxRIwK23BT9uoWYWsHpzqAZPqX0Fnriyl/56ozQ+Oq+LxBJeGPa55Trkq1LDqzEoeONhZN87Z4zHLt5FT2ImNjYT86WnPcVHrZd1hjnqLjDtwZTZPGwVZ9fGNSZVmr84+DH+bPCFL2MR6hs8iv0uNbdwpcV8obD7x1+F2l/yMnOFdzIoLBLM7WNNHoUEiLp519GSMlr3l4ML0IR4DqxDxnrbvOW+ov82Pqf0ws67I0yzGyusz4a0tGLOKqBH6hsjc9Bb4O7YZ8npEqYHmGu2kHtdxGhpCnS5JX43preJqL0gxSbO/jZPHWrzgPFHi8UlkEOySsGX+0/Sc7V+cmdO4RhjhHjEgAb/RzpCYfti1mWiuP8zt53cmMzz9fCRXaMJEfVJaRxkQN9lTdu+KylFG4tmByPtgCBcELy9hYZx0FDIvw8lVSHKFRIDuaohAU+OD/P+LANtQD9jkIxVyNIdKj6CQw1ZFLU2ZdeJkg1cGZbaH6OmewSR8VdLoZxQtvLjKNqE9zKH+abaY20N8CeOkAgBVeNOfpBknvGXqVdusnFgsp0bYiux+NWSm0da/Q8pUST5cQs7VTsf4dai0Ptg1h+fB4/WlhlDUneiYEnP5jETsf7W2ydJRE2sTsJ/iatv87E8CywVwgxL4QwiMVkPvv/857PAu/f/fk7gK9JKeXu69+9q1o6D+wFXv6/6Xv/b1uFuTz/9uof89v/5Z/yr3/3P/Nrf/BNtlWN/YMmjpml0I4NlkAymqhR3P95FM3nTv3bCaRBzUvSuTCLfkfH2fssj2T+gn3oDF0Ls66TkIKy1yM3dIkwCewazdEyrtRIlV0UX/JHv/lP6aqxImGqt4f5zF1m/AThcAH8m2T2vsq5TkxzczKrXMpdQB/GPQLTiSo/uv7nSAQfu+9dPH34Xt66/CJP+3k+obyBnLpJx6/wkLpNaPRoDzcR2jTjbkgy5dJKxZdXyA5CwI3pT7Pefyu/rH+ImlHh90cO8sHp99O7IMn5MQL1+cLjfDV7P5v9e4iCPL5QEVJDRhqHfYWWu8PG2CwngzipFlED18gxiDTUXocoFR/5i+YcAPJYFdWXDHSVD868l8+PPcT1xB6+fCrDW+//z/zed/8Ml/af4pvhm1DSDsOGRRTGAYYSaoxbczSGQyrmgJ5lkllN8MtWjqpi8d3i40Tl2CAcv/Ua7/76s1T9mPKjExcBUlWdVspCyJAoM8VHD72N123GzzqYfJmb1hrzaoayFlOptgejbCcjMqlFosYSCd9iodZiYf1PuJA/iJaQXOmNIm78MavT1yn4HfoDhYQI+P2Db4oPXm+CdkajrLV3z5fCLSNiMV1DStj72gqnmyEXCiq//tbv5+xojBIUzTts9MdZG9nPVHMZfTSJkJI9G02WBg4pDI6Nxv9HL9GEqINjlWklYud2U53liGOTXWlx+u5VTixdwI9UUrMx8lMqdWg5Ookwxf7eIqHqkXTGUIG+AIOQ5bl5kCr7ew32SJPny1d5OrjIIXTCKGRZNnjWOMWXz7+dp5cW2Sm6CK8Gaom8NcunrY+yffo3STgR59x4b/qFKbaSW1w+OMVEu4Y6HQdShnBJDO4iSHM3c5KPHdqLFAr3cg7LqZDNvkpa6WCrNuPhFlq1wc3CNrVs3LPltuJksC9NqlMLRKqB40UkMyN8Qv8gIvWfCVpVdALuFwaD7SSWH6EckZSOOtyvXOArudN8eWOR24kBN3aRllLQJ/ACfOGiCo0REdFXLO5YC+TsFlZ/mRwCtz3PvL9CRVvC6s6RkknWRUQpEkwqVXqDNKWkx2tmXDCrdQOEGtJJBSxugWYFDAMdL4ppvIe8LYgC3nk3dpAHSi9xXNxmmxIr3TtYrqCRTyCVHkIIPC3DTS1ijz8kHTg06yajbUkvk2Fdi6nG84rFt2+9h2F2CX2YZtqNOwK2chM8euEamyOTjNZiO2iNxQUpa5eiK5AoqQpSSjaZovDg/bip/WxeficD0SQwFzhy5zpbExM0MxGV4SkCN2Dt6zmCKI+LybVKTFNassp0E3W04i06gUq19iSm4fA1HuI7vV9hQy9ya/gQTX8aV4tILFwl2TiEk4zRD90ZQ4kEwzDNTjZGaK1Gn6QdQJyjUKrGd9iLJJoQrOqvYmcewJZVqqZkNWky34ujei1j83LvGEJAOt0knbL5SuE5stY0n3vL99ObTrHv5tcY37nGuK7w2uDbmBSSbkIj16/zSv8pZsMKt9UdProvy9bpPG3yvP7TL2OrLgfrA3xN5e+9/60Ue3Cj0qUtPsmY8YNcFZ/DixwaXpKN5KN01RTfvfNppsNlfowP4ARJhIDcfA8kHOpeZ0eNUeqj9iKL0Sbnwr0sJ1rYus3IcIR0kKYq43t1MrFOLZimS5qD0R0u79nLWnYEEcHV2TmCVHzeXGnwHvcz6LsCXHuiOwQoPBstgHApBxvxjLM7I9w8/yZ0Y0j+ng9zYHaKsBufUVtkOSdbeGZEKCBQBK1EhrwqOOXH30fdtCGlIaMuXb9BJwXVUOcr/ncR+jF62X0gtmFhuohp93D3htS2j3FSXGMnV0IdjtGVAfMb8VndNtbYKNzh2PIoFoJiGBcH1qwrfM5+E0EU/15HS6GEgo/IH6Ds7aGaits02q8dIFRgZi4+84qM0LwVKr0Raqll9jg6UqjkWz3Uz5n8dO4jnBlcw9zyuTYd+1XL3CI9eZ719gFaZpo3nDuLFvgEik6xGu/XmKuQScciWXsGQ07clXx93yjaYRPKOmduXGFmcIGJ2jq2qWHmfMJebNdSSoyIX4mmEKFBmGqQGU6QFi5XRUjQE2jFNq7iM2+7vK/+uzzWPc2O3iNj9PF3BOnBgC8/8naei16HafWZU6+zrgT0Mxqp3hcpuEXCwT4cP8PF+VgECSVHTjqAZFytclfXqKci2jUTbzCJ244LZGNkuTn+HHv9ChLJB2Y/RCHdIxgaLKZCnEgl03bJt9uk7B5fuu8wrUyG7/7KU9hal1DMcf+diKtDlT3ZFmvRJFlhMyU6ZNUuJcvmXZ2vc44TnFhe47ahUtuM6PczfJ0RKlqSMJrASsBKZpK/c+kznFOOMp1ZZ2pXzddXYuPQtOo8ku8y77Z4sXIEuxUnHaEdxyufTz/Ob134CpPui4SRi61F3Hf1IsulFLXEFN1khagVsF6exPRcng277BU6mfwoI20bHRWt16emWeSiAcXBS1TVARvJY5S7TRTdYjUbcjx9h4Kzvvvdxnk4WmFx+Ts40FWQqOy1XsGXCvVBmkBX+K/pb+OnH/6HuIrG2+a/zE6Y5YXiAcaUBg0jPstv3wl4+4bHxb0jdKsROCFCQi7oEtir5MUQ3xtlLOHQb6XYslfYL6e4ks/w2NazHApeo75TZixVwzIc+u6uUrtYoWx1sc1NhgvxGc5Zq5jC5xv2MZCSbiZuQaqEgo4K891tWjeb5MSQW04eE48TxcvMRzdZT6lMbW+iihGS+ihNZwPNbHM4fYeNxARe2AAJ50qXKLl55nrxOUu3WkiIEUMBoTuKnYj3bVpusPfSv+XB5O7Z/Ruy/toSw92ewZ8EvgRcAz4mpbwihPhVIcS3777tvwElIcRt4GeAn9/97BXgY8BV4IvA35dShv93P8P/1aX1G7zX/Tivf+N1Wgcsio0Od3SNWd9HzWUxZIyS+XbslPR2AKHA3j5JQrFpupKSOUn60j+mfTdNZ1+Pvckh7jCHQQmBZMxvxwPdtREifxmvM8u6kUUxJHbWBFMhokxCeETyPrJmD4RAdw6iqjt8uXOE1d0L4GaX+fzcn5LfpU+lwyE53+H+7gt8vvQ2PnLmbWhRyL5rA7Rhiry2QVdUsMbjSoo3TCGDNearLkIBI10mkiZOFDupZPI2r2VrHPBdflx8kdnhOocH1/D3ZzlIXPn7sQsf5SeWf4+fKv8G6cV/DwSAit++B6szi5QBG2MznLoaB2EyaiIVi29Ei+jNKq8aJwBoGQVSQR8jdKhKjRVjln83/0Mc397hx/8i4M+e+QV+9tJ/p9LYolGo8FX9Cf5h5r/wH8o/z6t7p2kks/hKmmpC5aV0ge5MhVuze9jSBTtjCV432mC9tMjXeJycrJMau03eVqn7C0gJ6V3jm2uH3B0dJ1BUfv2xM6Rcmz1BFjtycdMb9HMvkhQaM+Z1PDQulvYx0BXKYpyguYQeWYSaw0j/eX6x+p9wUkk2Oyly9z7PV6fO8EjvRV4S80xaS6z+ZcDVnaSd0SloNSACEXK3e5M39arom4I97RpvaIR4qsLNQ3vZUsoE0iRr3cEOE0QjB1CI6EyaTDWajDSz2O2LVIerTCq7PZ7GAD1oYydKdMz4/F5TFzjk1diQae5ZvcmRa6/SrhfJTQxRiJge2WJgSxJhgj3dvQgpkUGGvAYDJcQixDcNMt19pLVN9voqvib5sL7KMi3onOPF/QskVY+b3jwXxJBBMkBIH93vYYoZTj2whGo00JBU3RK2leSnd4PIi5NrlNtNvNkcOekz7SWxrSq6l+G9nSvczqeY82rsUW+hCgcvsQyAaUsqgyZ6u864MoWWjBP7TS02SQ0rS2f6AK2xCXwRcfe05EDWoOw12e5kOamuk0Qw7MSI+oHlNpW9azRXknzowBPUCjrL5Tw1/w4a8B2j72W/W8YNeyS1BKe0CwBstOaZqK5iKhkKMqDfm+AJ8TlMvYneG+cRqVNVJIVQcDU4ghk6WNmAhoyd6qCTQEnbTDUj9q3prN7rsaJrpDWXhq4x1vHJBz/Bm1MxKuJGIf9R/x0sBP8slUUbZnEMSZiLg2AXyaoIuX935mHU0ZloSHqaoOPGgY+frLLfmaOXvkuyn6VIhsTQpaHsYbbTIxEMyAw6JIdDwlQ8bDgR2CQcD1/TUPOzyCikvXCIzMQN5hKS1vIDXEpOg9B54JUbtFMGfZllvLuffPM8kTLJnxT/Iz91/F8w3WwD8GoyTuYmaTKb8Oiuvx576whSQIhBQXf5evcn0BLb/NmTPQytS6p6ilPdCIMAWyZw0YikSa4UFwa0lsTuFfCExjCdg+Zd3EhiKIKGEvDVbBk3dR8Ar4iATX2MqV3Bn5XUJMt2TGmKIpXuvj/nfPRFdpQhn3jwfub6IW+8tc6F+tP0Bs8QYTG68Q52CoKM6zKX38feaBxP+Pzz1m8zam7zX/m7pMfPEIqI6+O7qnrpNAqwUYLaiI8UEbfbjyO0LE03ycWixn+dfA8P2ec4cfcKo+xgR3FBRdUlBKAC2/kqgZQc7e/loLLKVTnHurWDGqm0zBYFO8OOlsOIQk7qF1kRoyAEE1Q50bvBxx55Cw0rw784+H4mtuJevbdc/BYpdUDe24+jh5TqVXThUVXyqIkV6gUdNYyIfGh2x3n13NsIQo3ZuX/JzdExrk+n6dVG2bC20XfR9XbCZEG6mEIhFwgqUcymUUoRbWeHnFHmWlryr469i2xg0WeXZdRUUc00GAqW3ac7pTLRc0jgUh9REb1JAr3OkWvneOKbn+H25HUytsVCK2bFTPViev4LVwqsbz3NVeUX6Advxal0AYX0oM2bbz5PQXq46pB0tURl3Sc7tY5p9PGER659jZytciO/xoFhHGj2xiOsywr6RwSvv/wSkYDLkzHduFGQqLpLsLGflcwYWmeDI5txcUlphRQl+I1JFCVGtvdXV3B0WNrboFUuo4WSjAMz1RsUG32GpoaRdrHbAqGOkJRxUeVc8zSJ4Rh9I0INM5TpsyF1Rrouiia5WbxOWjVo6S3u7x9jS7XJmx3saoJ3n32JRq7Iy9EbCaVCvxRyUXep6TcgWOdk7X4UJFGQoZOM4wShZJAywaQfUJbrXDUMeskA2ibDxh6oxXs9FkzTMZusmnWGqs1SYpk9uoqpg7UzS6ObRokiuomAuY3bDBIaE/0a9115jZA63dw+HrwhCRDcLK6zFcT255RykwIu3+9+jpaSJxNFvEFpcCTQEGtD/OoAD3CTRZpegYreY2/3Do+tn+e1/AEeLr9Icc/XAAijuEC2k1HYLxMcGvjczU3Q2YkTGjkQ6FLl2+/28eQRBkFcJKkHW5y+dpFQUVmtmPRK+5ENl0DV2Rid4au7SjC50h4EYIoRtPYG1zNzACx0XyY3n2Zmc4NotyVhqM8hI8j247jTjhb5PuUpvhkd54v2G+Mzol/jajhLkEryPeY/58MH38KJ8kX+j/n/xHv2PsXfP/aHeELnp9yf4hm3TFWDeTviR666pPyQT40+TKYaK4TOYOC5SxSEA36RMTNgUEuxNHyOAgpv3gqYamzwto2neVbGCquzRkSBcHcfbhMEY0TpBtFkXOQZFXFh5tnwOPr2gHYh9jMndym5+6tXODVYZig1nEDhRHST8sDBUOJnHt+8ihAq5fS9uKGN19V5VFwiFBobShI1MMn150kmX2FP62S8R9buDGOvhWqZhE6OUFNwoiQLskkxmGTr5v9McPx//vpr7TGUUn5eSrlPSrkopfyXu6/9cynlZ3d/dqSU75VS7pFS3iulvPM/ffZf7n5uv5TyC39dz/B/ZQ2UDL8Vfh+rwwIPnrjD1ru63DU0JnE5cO3aLvkM/KHG7fYB1CgisS0xlTgw63hQMifJ6JOsPD2J0lSQuiQYJvD0MorqUfHbAKyZoyAdWstj9EcEQsBH73kTiYFL5E0gwyqqMoKM5hjmOsy1Y9nnTTfNwE8RuTl62SVUVA6G8UVYlAPW9FGevBPz37spkxdmjnPiyjaltk1GrdMOp1nuxTL/T25M8Jb+gMlqbLhLukkoK0QiNnb7A5WXZp7imvMEv2B+iH8gX+Kx2re4p3meXHoTL1SZb9TQZIjVjaWKhd5CaB28xqMMe3EFs1oaZfL5HqYnUIPYCFWtAl8vP8pNGSN2bTHOmLuD07ToO2n+Q+IfkQt6PHjlMr7W49HoOWau93jXlz7CsdarnAhe5a08RV9keO7UHj5+zxv4/cce49seTfPPH/s+fvaNv8afvvNH+dyTb6V3oshfnDzJl06/iyWxj0P+sxyd7TBIjRDuUkiyvo0/UNBaXZopk9XJBVr5Ij/38Q9QSc6ypW0Q+BpF8wVs7pDXllCjADnqM+/EicxgUAOh4qs2vjrk9cHTHBfXCIaC7zjzmziqhRa4tIIy4/pFAhx2jAClP4GTVEGtUoocRnZe5tee/S208ZCmIwm+fZQzrRAhJe1CAWXbwZeTFKyYohiU9vDKvsP0Mwn27CyTcqYIwyWudmLKapCX2KEgMWxhJ8pIAU6kc9cYY0asU4ti+l8/L3Buq+h6xEyqTSI/pBtJEr6J5SeYCBw8KTAFDFU3Nt5uFtMtY9k7FJrxOewm4Zjx40yP/iqV0hZ6oNDX+jSsNslBnAxHwQZhe4xkQsDm7mSbQYZGZYRHGpIZu8JK5i4Jd4BvGiwKhYejHVAd7OYRpnbW8VXB67vrqEaXcPQcI7sI3qRTJ7XdRUPhnc33kjT7hF6Sa7PxUNuumWRnfIyNAqhhhDvUyPU3qftZtqISo8kh0aBOlDmJHxXJ9QKqiSl2XsyRad4iUO8gpERrXGcCyGoqbzNPMwi6pDSF4yKeH5dcNxnd3CBnLpAIB3TDNPfLywAo7TmqEgIBxVDwLI+iiAihwPHeyl/ZpIkRm31rEV8+E/Bz96e4nFIx1RAv2EO+7WOkO6QMF18TWLZBgMrfkTo9VWez952ogY1nxU5wTYuQQrAvkUUKlWwPJhrQlQGOk0EEBn5yh1BxEKkOVq8QU6d7EQ1RxPO2OLV1GdQ8Y7UdupkFGrkSiuijRh5zqxso2SnwbYbKPojWmNUl2SjiSjqefDRerXNrtMiRxikUFKa2z6LmpvnIzAyfyd/HYr2JKiTrhiDhFPFbPUaOfwKrsMz22R/CFJDG497taRCCg2N/wncHfwoSktWjpHxJgEJfGnR3EbEnc58iSJm4XZWaN8PZkTOY6QkG9iatMA7Ynkn38FMaoT5Gxk7xgqdTjyo4QQYj8riWWiDdiRPM1s4ibuUyp+0Bv3xAEgmFB1bavD08gxc51AcvI/11RjoPsFwBJT3KvLgHmWyQy9eZLT7PJf8hrspT6CJAA0as1zCdIUoqTj538gpfLEzxfP99SJlgrTCg4SW4loHfn/wOHAy+f/3L3PIPkTOa/8OJaRJH0ZhKn6UVSA4P93JKu0UoVDYVk6nBFENtSLofsW2OUIkCclqDDZGPfYBs8mjrFZ55y318x7//IJ1HJxhJdWhqWb6TL3E+OESh9TDVostw22Df7gy6kr5K37QoDobUlAKhElDzdM6ffzNWd5bs46tszFssb0lczcPy4v79dtLiAS/uS9tQWxxGgJQ88eoX6fhN0lqBpyoPc6W8wBPhFZrs0rVtgWpMECkupuNivKZy2HsZR+i0Rlz83giBWkPxt1GCV6nnfe5b/25kusDQV6gUYpZJZzJPYdzmXx2Y4IXs+/mQeg8AC2ufI+fDfOcQO+llXGMG/WYaBcnMzEVC2WW6FotI1VLLtHbnhtqLAZ85+CDFHY/kZkh1pIC3q+wcjLmETopCdYy1fIbI7fPOjQDd99hwHGZChdutvbhB/P6yrPLSSdgcFwTJBCOrG9QqJ8hsNtAbCkomRFEl3aaBps8RRhUyYkDk5LDscUDgJLaZHdToYlHpxPa5nnmFVJDja/rrmfcmqEvIGAOCoca9GzX05pC6muQlHmR7xGIlXcfsfwFL0di7+QgZ1cX1s6R3RbWEkmYY5ZjsvEghcrium0SJiNDWsWt7SLvr0NCYNH3KTomG0qNltvmF1pOomofUPdIvFxjU4wJH1/CZqcaF2u/Z+AsUKUnYVQapcVR3HyU14qK5TTuYZojJ/enP8wQvMhXsMMBin3KRpfQ9HNIlYdlkqRWzCO4S8DkxTlo4vLP5JWwzi6uZHHCukxq9SaD1WU1+EUf1aE6dRDT3Me3HexF24sRf6iZGCDUxoMURut6uGFqvz9GlGyhRxPKIipOfRGl5KFHE6uQCd/QUV5WIVDqmuvvWCVTH54XRowDcp2X4N+YvcV/1ywTZAm2txehqkr/71f/AnevvAmCozDEtHBIMecZ7GA2XBVnnHPv57fIPUtdz/KPmH/ATp/6I8Zkajpvk+OhFHsi9ii0t/oP3Xj5tBBR8kE7E915uslOawFZjlPSgMY4X1Jn16oxqKoYCrabBknKbptnj+5ZdNKfK/IbD16IHCCPBvBkyr0SsyzKH5TJqs0xk9tCiWPzsZP0KQ1OhH+noa326+SJS+mhI9ig17nOXeWiwhLc7Nuhe5Rpq32RHGUHIiJHtCyiEaFpcKOxvJTlg38KUHiuJSYSncN/qt3Ens8hs2CRSPKoyPkcFv41m5Al2z6njhswFHkowS8n0+Ju0/l8vPvP/5KWEBsqm5NOrB3l6exEtGXBX17FEhJcKSXg+ipTYnTTj2hbBOHitFGYirj72fQNhZVgymgxHFjh3+c00m+Mk6irDwMI1OpR2KZi3E5OAoL1h4GZiKpb3eoNBsYSUSQbuEhEhw/AhEpllTjRHiLwSA+4AAaI/yjC7wrsHJ0jtzhnLKi7+Tp79m6t8t/ww094yn1t8PXoQcHD7BRQhabkLDEsSbVjkqv8GfqaqcLI7QEaQNNK4UYHxKHbUB3uSdnKHp5US3aDC2ytf4Ef2v8ovr32AaRxc3yBnx1QrfxBXghSjzXj+BWSQ5+logUEqjxFIUnclCU+g+fHIgyihczVzkHvGX6WvWrgUGHG3GdZNvpB5DyvKPL9x89/xbv9bdDJXaWHxqh7/X+VMg3Flg+/hj/nhz/4XfubDz2BeavDktT4/dvYa77z8FX7vwi/xnZ/9A37h93+DjzzT5e/+yX/kRz7zH/iFV3+SydpHGUEwTIygBzWEgIzm0d7IMDB1AsWnbo3wI5/5UxZXW6S0HOHIBQZOmtGohdBihvUwOsRvXv7XHHDSBISsabs9bGYHXbhMbrl8Z+ubiFCyrI1TjFx2tLjKKZPLFPrrLKdUUvY4KIJbmZscPffr7Ln5CT79wCOQhLoZMWYVyQSgdz1QFMSGTT06wGS4jUbAjqrwide9DctxmKguIVCwlSZ3aHAtHeJMCfyeJNOvEWkpkoqkFyWIFI16pkUSk2Gkk2GSb42e4ZXoIJM5GzUZ0DHACJKAwpx/FAk0Qg9HiTAJaA9nQEZYOw3ayyZCwnT6GlllSF0t8EP6MxxilTB3ESFhppNEKDoy2KTSgY+ePUn/bB4/UlB6LomcTtsvc7pbwtF9tnb7IZXMJlcnYkVB4Y9z1oiLDo/W4rP/oftPUZ3IY6sGi/Ya5eUtElqWa24ekg0GbgpP62IELr5i0OzeZUsTjHYHTNxxyQxafCWMq6C1TJGwcQutuIdu8P1slKe5tsfken6W695VKn3BTKNL0W1yaHgVSLHtVLGDLnl9iO7tkJCSZMtjsrpGX/PBbdIkwhyMghSku3v5VhhXp4uBw8Cf4mb0OgDucWw8LbYJ6rzH6j1wdj/8YKdH1o/PWLuXRQ8l7+m+xjAoY1sqFVuwI4scGyzzeO1rdJmmW3sbrncEiWRVjylD19IKUW6E6TpM90KGiSRBK0IqIV5yBze9gRASo3eAMGoxHZYIELSjCgdrN3CT4xy7ehbHSvDnb38/qsyidzcpqAWEoiLtBhlVZdU5QU69wnzqLGvJQ+S8dXqZFLcmp9lXP0MjsUqpvYbM5LmQi13fSKeFpcWzunBH6YtVelPfZORo3AOWbBzjyDBLIihyfPq/csZ5maP6K5jdWXSvgIYgqQT0pEFPxklEQesRVQRDW+eBzcu4HMNMT6N2tlhWItqB5EJim4lkXDg4WhesGZKgYfCt/CiLw1UupfdywNtVf16/h66v0zr6Zl6ZHuUfXXeZ7wzYTpj/w5d4l9HDFL3sLNbR7yKQAaejf8HhfU/jDDO86Vvfw8ef6XNXrVHMr/LDN57h8d7LVHN7kIAQBtvJJpcG34ZjXeFOeR0/0li1TGyR5GVO8DAXWN8+hvyfwgYpBUtihke8r7IjPMajAg8rV2O75E4z35tnzB4jsoc0jBIzaozQVbUCSPA9eLT1CnvEDb6Lz3F06zYTNPDRGREdrm5VGO8tUMt5MNR5dPxZVAKecM8jhU6lZ9NXCzGl1OwSBAlGzv0MvfpxQtfkRm9X3MQ5HBe6kgkOE+ETcC51i5PdPHsHGyz2lnDIogiFZu4wT97+Fr5h0qCHjSCtOUixj0AJMAOHTDNgn3GDa6k5IkVgtzNEuo2veNyaWWOiVeLg9hhRIoli9ygZPiBphOPMvH6TdnmFHz1d4JXFk0jggWse6rVVFrunaKTvgDrGVe0oU5sOo+N3SOSrHK5rRISUzDrzWpwYisY0H9z3Lq6XJpBA97EzWK6LUHzSI3fxNhcJ/SLtko0ReLxtR+WnP/JHtIVG2RMsk6dV2w8BREXJpYegudtCv3dZUh05RVSM8AYaRm5XiKtjUE4YKMCcvkVaCtTIJOEkcBJb7K/HhetveG/AH6qQjGmTp3tPxrYkNFG1mFUgNIviWg0EfEy8D89U2Bm9jOlc5JSVQYRJ0qpD18tQdFVcXSKEzjDKMp9dBuCypZMYdxFKnsjLkNZuo24ozGY2OdA8SCpIcWQ4x0FttwXETWN8a4OgbhIqGgNTZ65Z5x+c+yw/vP1xQkVQ6DWQwNV9j3LSkqxoDSKps844b/B2eIhX2FLKTERVXgreT0Pdh6O38I8XSe8Ke30Sn2fUOMEYMVvczI5wv99kuKEhJVyc+Ty15BIfObUHPQOZxhzLCYuF9gbSM4gE1Mc1dM9HuD2+MjLJmowToFKzy8BMUB4GrJYl/dQUIpDkOj3qi9NIFJ7JCTQ1SZSfA2sPdxYe4ZXdtpB39OOY4v7Sa0RWkpapMaV3efvil9hjXsVXNIQwGQSTPKSex1OL6NZVNCTPREd53dZr/O7Lv8596hWEANWIWLl7Aj/UeNPUt/i48SsEKHzEtjlPwFCVnFgTzK/eRAxDBLDPinv5JnsrzFuxb9ruCuoJhc9MeuzpS/JKmpfzp/Aig5pjMW9IXjIf5UY0zaLYQLR22z46RaSMKMou7ZROPvkKUSukK5I4wsaSEksEJBYrFNfWKe1S3+/VbuLZWW5ygMKwgRZ5lNWQWmgiTWhsJtkRCieDG6wkZvCCBik/R2b7Uer6OKHu0JIJUtEwZvgpE0S7Tb62UJj3fZb6Cn/+Nwy7+tvE8K9x6VmBKWqA4FqnwieteZZ3p1Nr+ZCSK7G8gLCukUrHdMzz9iksPQ5e+4HF86kaLxq3CNJ5/KFK4XKWxbpNKBUcrUPejz8XZlUwSkSdHmE6rlq/x/kcjTMx9c/317mp3WYYPUxFX2Ik0AjsfajWbcyJz5LsLECiwXxxi2C3Ido3TbxzfURxknfwaaQnsReKtBdGmHNiZ9AJJigmdjD706DmuSQPkHAcvL6GpmZxwiwjUQt8qAyGCCl4cfQ1/qz+b/lK+ydZEcc4nK1yj7uN6oGmGuT1Ic5f0msTDQ4nnyZhrvJ0co7lsRn2rrX+Cm2VxIIP6XTEwuAO33X4k6ylYrQxpa1zwz/Al1Pv4FH5NPNbcDTxDfrlL/CpdJZIdtA0nSl9nQmxTuDoBHaR0sBDbDocX3VRb13jWxt7eF3rVRa3lhipraK1dsj0Giz0tnDO5hh2I+qDNMPEKI4W750qJMOGQXUk7jUZqlO85yufR4zE/ZzK5Dm6wyxFt8+o8gputEAnfC9fDs+w6I9zV99hKxcjMzPiGn+wvUNqGOCV42q+1bJ5QzngwmYRUzisZOqUepvczhqUnTGQgrq5iTKo8eFDb8U9uYvA9iXKylvZjgLCpgdSYgwcrkWHMGTIw2KFb+k9zh85wmOvvshoVScKe/g49DMlfn5/wAv7bqM4Q3LdmBJWFgHuLp3wmgFHUbnoTmL0fVanZ3hKeQtfzD3JKy+9h1ONe5mwK+hSwfRHkUiquRu4UsUQIYnIxJJ11A1Bvwu6nyBj3eWKPst3Hfn3eFLn17TfQ2YvMV63mH3wBFZRIQrXGG2H6MN9ZIRH3U2hSMmiKRFOyFFHIecl2RqNUcAUXdDje/KOe+a4Vp5ltt2g2I6D//nwCj+//2e4Zc1xvH+D8e1l0kaZm1LipbbpOBbH7wbk3TgAGjYbhFJhvN1n0W4yoWt8NTrDXmWdppEg7FcRRoph9ARN8R6CQoenHpuipgwY65ZJhiZ9NcVc8xVAIZIebmST03usO1myiQA7CNlrd1h2XsAMO7QIkUqI0Z/AjJKsBLt9GGGT3FDlD8rvx7dVDgQew8Rusajo8oM5j4+cbfJ3Wj0+VYrR6dZuQeakvEFGtukaOuOhx1AWWOm/wLHBEg81vkzQOc2nRm9RVUJWtIjRSPC5zpBuMcdMTTLZibCyGnJnAEqIm9rCy8QS+GrnOJ53jankAYSI2EmPcyu7h0F6jL3LF3jP5z/EIJnhMyffgOqluHQq7qUKe1vkDIe77j3o4pto2ct41l5me7cIRsFTF8j0Z+jrrwIwSPQoeLtKsoMqPbNEO1Gj542TPXULEekUwzzj9/wRqltkZlgiW3+VfPkiSelhBBGZnftY36Vr7TNtBtKkJXVAkhYCb9TH62lMOw2Or5eJciNoYcDv7evzM4dMHh9+nS2jRMlr8Z5hbKOClRtsJzoc7N/ldnIGPRVXmdPOKH/cm+PPU9/L8epFym7EG+wc/0bbQexaOhmu42ldjon3oo0e4frWi3zqyDyq6XH9xsMsJS8SBS18fO4ZXOV+5yJuN6KTGWW7UGC6q9M3enTNNuemnianx4HTplUkFPACp/DQedvOczwl3vmXxpXBRoVL+kHm3U1uJldQhKDEBJa6g9ado+gWmenP0PQTSKEwlWwD0JMprDBk3R7ndPcKUaTzLj1kc2SMMbdOPuiyaWexqwO0yEDbDeoXvWU+N/ozTLXj5y53h2Sd+Oz2jRhhvZVwSN38SXov/DLbqQA1Uij7JRJeQN80GNeLrJpbXEm1EarHY8oW5uQod7SYTXLa7fDuzWfxNAs3cmlFBhnNBXUShECmNV594wiqIblRjs9gq2HgGBHPHWvRM30eWn4rUsTtDNnWOqqUaDKg7WVQkn2mlFVcxSLXaaB4LvWySu/IPPOiRNa9jUDhxfS9zK/YBI7FPQeuMN+bopHa5NbIu0hECYTvUXH2kSfiE/e/k+cOzbJ+31ux8CmUN1DVgJ2d/XTDCY7nYlbAsLeMyMdjFEaddfzJFrmlEbQaDKZ0jLLAETb51g7Hej0G+VG8cYmj6ZjZ+Dx6gwTTiS1CdEbyVdJRvBfGYBqphsxM3gEkL8kjDBoJMukWda3HojvNirlG388QKnEx+COTXyFl/TbJ1pdoBIKb4X5uJW8jhc6Z6nfGvhCXjpelbKcYmn85AqjIXqNBBFwzDcYn2yhaTNtNGCtYqxHlRIOpKI1AcGjNYZi/FSP9aw/DsAtthW4yRyQEMp3ljfWnKGHTymcZbdXxlAHNwkFOmipSwGrmNmuMU5Q+QyyGGPye/j0s8QYUmaCTC7GigH2sIoh4mZBWEFNC85bLSnaEd8qQqK+y0cxybuQF5hsn8RInuad7CXV7jhfTGvdvX8FSfIa6hjohSXoOftDn66M6S1EZRUSMNxpcH59jKB02yknqiUn2haA2Qu5k5/AP5PjCwRQhYB94JwoalxenGYgEtjApB0N0LyI30QQi1kdPkYgCTo7cZlLsMNil7dbceb43/HM2tYhO6gqRFBzYXOHnXv4o3nSIVt81BRKazSnudBaZqKwxodQJESQUyT/G5rwW0PI13vytp8i6HgUhUJUUFWuaTH+TuWSbdiCoyYCBofJHs6NUzSH3DL6XV2buZVRfZc3VmDFCnhGnuCGnGFFbWFvxnTe3ygjvLgkZsmWazKoxK6hfF0S6TUYKDh0poD98FPyQQaCiRx6TSoOd/gTLLDDbjtkIU4aBLyFRGcXeTtIVKvdrN+jqORrS5lb5LHu2xui7k2xbBh1pUQjiOFsGCyjJFoQw1FSykURGIzwwHjMD/qasv00M/5qX2KW1lEybnVBlg13lQavPQ8fXCS0DtbUbtHkWHWeWlBIfwn40zlTvBO9yzjC1soO5covHeY47XlwV8vU+ZtgmEApKIkBLJSFo0hgWCITCgr1Je3IaEQXIsM5FcZlATjIfVBEI8v4+hOKTybxGsbMfISTJ4h1CRwUkN7KzZGstgpldBSg/R1a7wZ2JJ0nujrToRhUKehW9N40apbiq7MUfqDh9A0NmGQRJ8tjgaMhEiOnBIFWj1/0LvpQ6wxc7P88fVP+EblDBdXSkqTOe6BL0ByiR4K3pp+loIYet5+hoGa7lDnLs9lUaySSuBp7aQoQhe9NN3tz6Kl1FspEYQZEBpOp86sT7yMsW38cf8oLzXfTCEj9rX+ZTGZWMraElFKZZYYYVBq0MkZamV4h57F+VHh8unGZCNEEVpM2QnmWy7W9QL1QQbogqBfu7gmYni50os5qr85ekAhWfaj6LZ4zwyILK7cI0VmEvTtRnIGq0vQJ52yGrtNn0HiSSpzgsuux3J7itbtHMTCJkxPvFX9DUVM6eynO+GAf/vq/wxU4Ss2Uzpy3RVmGk2+JuSsGUBvSKZM04iXx29CCTlSXsCJRekhwW60KgNGJRmEwh4pkopha/UbnOyphFYOi8+cVvMbvlEbqxQEJgpGgnE5w7fxZr0CU9qAKSsnAJ/TiIbjgZjkaSa6JC+fxNTj59lpnWt3grX8MSDSpOhbI/ii8ivpV5nnbxNTyzhS81DALKQmLqmxg9nymjRc5NsmpKLg4WOXPlOi9VH2HZcgmNHnu3Usx++xMoky4y7DLW6NAojZI3hizt9skeUzIoGw45Bsz3Fqgl4r31NIeBPiChJDh5vEgjnefQios/jCu2jzdf4oc3Psmfjr+NE70bHNNWCcxR8oZDpA+wbYuHrkoKbuy4+noaqSgYUjK21eGC/xDn5QL71SYL9RwbY/cCsO5F3F2J6T6V45dJeRkmGxHXx+d4vng/ujdgY/AUaTWmr+T1FhtGDq8UUVclprKXam2NVAJsFDrpDTI797BBSDOEhARVczHCJOdn87T7KWZ0j6aWo6eZXN2ySCdAvUfyBQ5yMy2JpADRomWlmfLWSQYOTV2jQg81zNMc1phO67x9/atomYusDhe5IdrUVck+T2VERFwpqRT7MFZLUbJslHaXMFSRxoA7pZcIfYsg0Sfo3MQ0CxTMNlvjE9ws7yHMx+jI/PoSb3rxayhS8uvf8+OcP3gP0bCJ018ja9qseidQ1Vd4oewilSQnhyF7sg9y+o5EioixdiyatSK2+f7Nv+Dt60Ncr0sjmUKKiIKqkJ1vU1x5gpQ9TmbqPGLkLEOtx5Hrf8J25wQAqUFIpnqKT+1WhkdEAYlCXbVIKD44RcIJD2yFwMuT1o7RGY3fe2T5MsPUDu/2vsTV5B4Wh2scMwcUbY11Y4lTvefZby9TNcs0x7JEkYIjFc6m/h6psM+PZn6LT82G5EOF99eaRMS+IWUV8VIb3GNMEPQ2CTOfZSS/RmVNkuxKNv27LGc+hiBiLlrn+7xf4nYnDqRf27ufiUb888rIs0w6e/lO3yJUVHYSFRShMZApXoju4X77PNcGZ+LhlgK8zaOcTx4AYJD5KgC3w8cJ06uEwxmQglG7QlWJ9/CAEScoQaSRlQPWnRk0Iva2t6nWHDYLI8wMtzDxeb4+gxYNGIoAER4kUCKaW0ms7ICol8b0fVKez1yrHf/O3T6hpUSbvQOd+WiEVlFQ7FoERpWM4+EYGkW9zJ3EKroREM18A2u2hjJxkD83PXwkjzpbbE5OgJQoWAw8k4zuINU4AQqyFqXxJXypMCzpaMMS+sYKL429zN2JPu96MU/JuQcn0UN6IfqwhzaIyPpdPCnwPZP98jp4ISeu3UBxhxik6EuPPSLH/TdXiQhpBwn0UNK4tA9d8QmdBdqpFdZyb6DjlBG+hzKqckioKMqQnq5x9+wtksKnMrKC6yTZ7sdMh1NKXNDaHOywYY6gRz75/vPYpQSl19qodUEwEZGKMoBkdu1l8oGHmujgFFSGhoaZ84gCwUCtMGbeQKIyawz/KjHUg1FSkcswWWZCNFmReQatUdJZn/PZcwDczMTtCCknPm8nWotAh1T/Tyht/Sy/U/VoD+5gJo4xsRPbQUft0nUzJIcavUTsPbfIoyFZ1nSGisJYSqJqkyjaAKwWxjpxvJLqQhRR0S3sQnz/vbuPIbIz0AvoWgaNnE8oIjbVKQKpsJYbZ6K+g61VKXctJEUK9ii3i5e4wwwS+Byv5/tP/hu2ghH6u1TCRinJZHUbPQo4LJZJRA6zCZ8oFBSMIWEuywm9jDIUfLSvYKDwujvv4ds3n+efnP8ULzNLSzW4v3mFUdGiFuVIjNskXJdhOODFkkLLTZBRXfJ2n+uVOUZaTaSisDpi8ITsI+s+kaISTqUYtyMaVo9ceS+K32R1Ypy9m9dwEmANJJvrCroZkEutsTQaF0VazXHoazQzLqoV8NzwOP+Wn+KqEfGwuMHNaJK3nXue1LjDDb3CHW8cKaHXKxH2Qm5WF1HNgIvZCab8kHerOgdQ+R3p8rwWMMEIEzJgOhIMJMykDiICh72ZNVY8lV4yxEnkGRgJPlzcxpRJfjg9TSG1xG1fYiig6AM25CiqkOR31pA3ypiNMpEegxGXMjoT9ijZVIjc9vAsD1VqHF2s0Jke49WRfTjC4C2cZVS0eEk7SCg0DlSvYFspDKOPFBJTX4CeQdvXOWzGVONN8tyceAGEJO1KhGjSkQlGvDjuEsooqfIq0UDBNeLkdI4eWzEe8Ddm/W1i+Ne4pJR4fkiAyu/kv5eeYmMPsnihSjkFRa3PVKqOq8XJYroa8WfOcQzXxA1VfGky9JIEQQrTLBCh8In2PTztvgGJJNAHaGGTnpFEV0Oy2ZhWevf6NI18gkrdY2hPkZCbCBmwGqwjiZgaxkb7qL0fGZqM909gdmNKRGgOCT0FTUSIZlx1f8GMg9+elySlJmmphwlKEHgCUk0UEeE7M+iRRZsc/X4C31ERskhnV8hAegZRBko9CUaXi8kRPvtgiU884PGxhI0ihvi2ipqQlJIOqmsz1c9ihTusaTqH+01Kbp2dYZETN17m2fkJQkXimCGm26aNRmQpbLgqVWOcQljj+uF30MxX+AH790kyJDQl59w3UQojfqHVwnRClJTLnL8dJ4ZNk9uTRQZZjYSEcyKiHHT5uPHL1MwileSQvmXg9VbpV9K0/PjZ3r4T0WuV4sHE5SqboYWMwCgHNJUhldQ8/cIN6rk0hfQ8HWUJf6gjQgt9V1Lp/OB+BCpj4duxpEk13GZPukNaq7HUH+PXFsrYSY0l1UbDRwx8Bk7EwDZREsux6qcdsrFbcQ3aU6gFl5XMKINUkVz6LiuuQs7biylUzpYilLaHiCImskk6wzx3onEOK9dwR4sYdsDi+l1GWuuEwR0kEjMUDJIpcksDssMuiWEdS/RIENBxDQpOl5Zf4RBtAHxVw8yXaDU1jstLlJWv8/npz9M22twXbWF6KaQSYDojBEIhoUosL0Eg2/iaxvpUkYfdPnVN5bWh5Hs/8TF68iQftPaQiCJ+NNdATyXY7bcn11mnXRgla3ks+xUCSyMbThC2u6TFgOn+PHroo3s9PC1Jx+iQj/I8UxUIKTlwN0HSiSvAmpXkV2/9F0bXV1m1ZnhsbIk1I8GeZIw4dnsWp5YkuSAu/LTK85C9BzdxGHPd5ptyLxKF/d0SR9ctrihlAinxpKTWK9Lu5VjINjnUPECp3eJWZZobqb14qsFrzSt0/Rhl0pUO6lyJVq6AL2BbOYFQoLwQ97l0vTTZ7fu5HO5QNRKMRQpJxUUIhUHa4q6cwDIjvpV9nL8YfSefWflZwisZVmcTXFb240udjjDJG0Pq6ggF20YAWyKNIiTR0EVRobKoUepHWBMfB8XhpUzcR5I3NB7vK7xWjG1FLnOck81buIqB78QoUKJwg6A7RX/0HOFWHLyNDjW6+RzNXB5rJBboADiyvsy7X/0mM0HEHxw8yocnfXr+BmmpEUqLhrePs/nYVj10p8O0OMNDSy5WQrK449BJClajiJ9Z+TN+6ZKNGwX0k/El+7HJr6F7EYXV16EPRwl9hfHKUzj5lxlkDDZqjwGQ6gsMe4wXCfFlQEmP7/mOWyKHg94bIxiN71nDfitCaLgj14mE4Ojdq7xl/QV0QpbTkyzaaygpyVEtYic/4Mn1rzLjxRTTO3PT+L7Ff9+fxLNm+Cef/CBFq8FE6TOsJAWnE/tYqzhEQmIXM+zXUqRUQXXnk1hva7LcnubV6oOUVmpsMcbacJIxY4ufK/0yz8uD3De4ixKGXFnYSyp8D0kvxfnRF0gGSQbBaQbFMpGicrLl0JUJXpJnCBSNn1z9KKJnQaTg96a5ml6kqWXZzzMMohA3PIJmreAqSTqRieIO2TZGyAc+9zSfo0GWUFVJ+h16RR9bmJxpXePO5TV0GZINB7RljpVBnlBz6aiSkn2Cet6js5GgndRwB5KRjk2gwGQrZiYofg4hQrr6OkF6BTN/mVqux7ThMbnwIdKOh2mkSSgpjo3d4ZdPfoqj9/w5x098ka6/xXvdEDuEkcRJbu85geIMmN/Zg+MkSJkBkRInJfq+TR7x+qyY45T1FehM8ccnrrKZ2uSeldOcXnsMSUQnr2I1eghADFqMO9sgBFdaezklzvGz7gX2BQ1CbExSyISLhcq+JZ+uuU6lZdEiiehHRFcqaGGCUvY2CBUnyKL4LoOZLocwmdyOg+KRa09T0LuU8+vUa7MEesxY6Gt7CDTBoFfnsgiZc3ooYZVUt07mzgr4AjUV0FNjY1lqXiVyh7TzEZEQDPUYMXS7Bn66SCIbyz0sDjXewHUUfASCE9E1NsQ4C8oO9SiF111ACLhVfpGQiG0r7pMs7fRRhcaR3gw/9rVDNMZ/A5n+Hjy1SKSk6GfeQToGrTD9Hl0vg+JAPxEQMqQqYlGg26qJKSTd1iE0Y4JE6Q5RmEZfj5PVRKJHz9EISxWCZA19MMZyw0JqBiIM6VghW6UBg3Cb2+oCz4tDrCfKjNerdM0eaUfy3MYx9tXuYSe9zhqj/Do/wQV9LzvGOFakENghqEO2CyWmtzc4XF1hv1gDRXAi2MDtaxSMIZW0xFRLXBiVbCge393Pkggy/MrVD3GJB3jVCBijxZzcYYI6K8EY+ngfM/CRRCi+Q+BopGV8Dm+WZpnbWsf0XJZHFbSwx5NtwbGvXcD8+ha/cMGmEHyZpGawMdbHsZI82f8qXkqiD1Q+31hASsH+0lXSwqFptBg2MoR9jXrS4pMJm9/IHaJFhvf0BUfVWwzrBqofoR6LaPsJLhdiW9tqTWI2t7i5uYASSrbLCR50PWYCnX8tkjyAxleSPs9nz7DTCplCxUcynphHtQLK6Rardopuyqefin/nprjEnyl17kfjLWGeG0EAwFh6kyb5eH+tddzP3IfUy2jKJUIFLpk6w9QKY6kGwo+4vCt+l6hDLVD5+vRJkv6Qv5f4GinhciUTt9vMbC7Ryee5k4dhxcYfHAYELVtHKDqFoMO2MkkqymCnYjYA2PioFNw6QjEQikVu5DbBUGWQjhPDBWWLm5t/O8fwb9f/4up0fNaUcapmmWPD63TSPrObFZpegqQl+dPGfwJFQ4Qhe24P0NspfDRSSpVeYCLDGpY64NpQ0k9ZCOCFxiwZkSPUbBARSd+hZySJQoXx4nUQaQYbSeojAsuLyPUCzNEVLC+gvO2xlWyiBfdgii5vHaTo3/0p9vXeguYWibwE20yCVNCVEC5kqJZKfKj8o/iRwsBPofsHicIGFMDvaZSULwNgO7MkAkGyN0vQN4AsoNEXcXDo+wnCss5cHUKty9fm3kg3maVblaxZEQl1QDQEPeGi786TmWmUeFEs0lcFqU6W090LRE5c1XnlgI9UVEJVknIadHQTLR1wq5+jpY6S1obcnn2AU5ee52B7V6DD6PGs+538p5E3c9/QQQsCjExEzkli4OHUNfYPVKQ/ZKxfZypQ+HH7FkXR43ZymimrTaQIzMZdHpi9AQgEkpqTJujGSFMrWeNqZgq3q6GNxMbiRHIfyeQtRlI6CS3DIHcNv69i7SaFbZFmy59kRdnEjWIVw78vPk0oc5j9Jqu3xhg1JVJK2p4krdYoOD3eqA8BwcbufEIz0vHd2DGH3UmCsmRjah/vVEOKiRrLnkrOOQLAc4sJlCgi2RmwMmKx39WoeofZq1yHgsH0qsPKWIli6zoyqKOaBvlBHISMtQwKQwctdEhqMU1w3c4yPazSoMB0agNLSq4V5+iVDfAMzssMui5BQCrUebP4M5Kdo4x2DnHajdHKtKaCVGlEKp/7trdzK5flHX5soHuGh+l5dIIyF7NdjjcVTkSrjL74YSrlWyBA+psExjiphKQ5tDBKPqHZxU/0MKwBRmQw1p1Cyjr9VJme3iPTz/JcU2WmNiTtDTGFieKlUHTBpizz7sbTfDJ4iKTqczD1NAvJOEgtLYERgJaME6K2VeDi3tucPapieW02zToT1Fk2N/i178gxWwmJRMissHnQu8RLoc28GbEwTGF5LuuZERCCldQ8g1Bwofl0fK9ChehwHnc3EauqacpjBRaOxcWdbnsRwx4joV6grglmoojpXSXGck9yzVrgspyjq0zQHbnFkDy/uv4PafUKPHTkeaL+fpYMhaLhsjMo/5Xt2gzjn3u9bQpTPtGUTa4PQvHRM5dIBUMSgcOrx9KkA4utsd3haplxKht9mkYBrxs7bMWMMDpT9EbOomzWkEGLohPveQaPZwtnEGoFCdjpNCVP8hvBkMeqAf/lnj188LFHsWQOVRty172XG+kjmEGdqS9/ms96zzOMYI8wGKu73B0lVkX19mHv0n+aGRtFwmSpj3tnBMWvoA0rDIMUWdEi0HRWZ49AZZ1AFaQGAQ4haWeVnt9kZhcxkSjkhINl5whGJSDwtCfQxWVKyg02KqPkOx0KyRYtNYNtJlgYruGlA07nXLJRyP7wLmkRR8Sr2TkuhKc4P36cU1e/xD3PXGSnnuMt8imemu9QsSZpzFR4/nCVm5Uex8M5rrFC7y03QIWnzj7ON4bHWUtYCCIGpFBTPXrNBTTgoLvJwuYa1+cPoGrjZAMNW3Moeze4pJSpj8SjQ965uU01SuKoKjfHCryz9nW86hgISfLAC3TNJC+nD3GvO6QbNSmRZ64Tn7G6n0Cxe+yYo0yEgopYZSWM+911o0Vq6i4X9UUebp9nxyrzg5ufRgC3BjMokaSTCGkKwZg9TSflMu4eQtz5ByAVksf7OOOScfMcmubwcNrh4Uc+wv1H/4CVB36Z147+Jr6I2D85oKjtkHY8CkZMmf+a2ODmxbdx5crrEAKKlVWa+Wu4qTU0bUhgeGi9DpbWpe+bZBWXjB2PQJpPLpOVkhdKxxHqNr/p7LA6MuTMzgn29k5QGz2JZ7SJVJWDy7cIzQRqf4dRNy4aXWnuByQzPIORMWhYbYRQmAiKBIMa5iDEVu8w2pvkM/oM71GfYaUd92Mtzt/mPc7HUSMJgcP6yJA9XpOKV8c+dT99NclYaRlFiajW5pCKDwTcjPaTyPo4gx1uyZA9/T6IDKdeexbV6dHNZBGKpOvF7B892MT366yVLUw32h1V4eF1DcJkhtqsh56qY6+fYZE2qvDR6TJMXUXDxxISB501L253cHJ3+Onp/4Stx0lNsVlFEybDsM+YlyHSR6nk5xhU/gmNqd+iYyygxgAwM802IpTIQCI1DV/p4wRx4etm0mBCjzjXejORKJGo3GbgjNCmSBDoFLN1OmYGSnGBLrnxEF0lhd+K/UY3YdAuOGi6xFbSfDb3BDsiS27Qx9Hjvrfk2iyLjVOxD1G7DLFoJCzSrktOJpGOQBTX2Epnma5ucaR2BxOfISZz58/j91QKuo3pbWFbH+Dc/joP2UN+aDvuxfxQ4X18Vn0ja3rE+9UvMrCSjIkWS8EUQ83EyMZ/iHx9A8UNMPwICbQXZhlr1Dl6+zpro5D2U+wVKoVhhUoIfxwN2BmqRFLy/JFZKq1tHhr/OgNVJxMOmbNP0OmMkCvX+Kdbf0Iv1cZvJDibO83Z6Me5LVUecFT+2P5t7herWMKltNQmt2DzVPohenoKa7aPENDrlJH9LmogKDc9zJEue0gwIQVbaZV/RYIHQo1vmBl6Q5gSCiYSO+yTjF0Vd3oVesmATmYBETk0tVf4A6lzLuryZO9hKv1Zho7GfH4ZT0kTSTByDtawiZookDKW6KY1hp6gHGTR1CpRUuVGuIvo3myyfWWNl8YO8UDtGosy7uFezk2TdLqozRCRga8VWnTm7hL5WaQxgWdr1CgxHe2wo0+Sr80wTK1z0+rSUmK/lvXqqHoRoQWYpW08V2OYVwgiwSIbHHpghr9J628Tw7/GldJDxtwd9sh1ZsMlAlWyb1uwKQuU1CZ2ZLDunsAJdcbWfbYGFabpkhdV+r4BasDekS/SCUEocwBkwj5lTxBoMbSddEN6ehInSJAst1DMSdS2QzVvEArBgnoeY2YFRQkpt1xeKNkEcoYpY5PDUuMtOYt3ZIYIBN4wj/KXU0G0iNJag53paXYocS39QwCoVUEglklbLgM1T8m4RhjqdKIxclFIpjuG4vqgxoGlr8RVIM2GMCOY2wyJVI+oElMP3VrEydHzqEiwQxIJG40QX9Mptw3quwiN0ZNkkwGqCX+2/3FuLmzhOrEzLbTbDJJZstMDlrpTREJjfd9BCp0Gr3vpKwybcQNzP2+TH/ZJ9i/yMXMcpGDEqhEFsWHxqhoTwzxqqPCTa5/k76yvEIan6UdZrqT3Mm3GfIFMe4eR2SUsNSCpepxrTnHLNJDSp52osmbMM9gxyWSG6IbKqD7Ove0Go7tBiz93EduxGHM6SOB2YoxQBry4q0arUmUTyXYwRzi0KTQ7zGkRPU/wQNfDTdSRfZtSb4ggJEruJoaBZHJziZYuMFrzoMB9xyq8c3ITRcCyq5AJ53CR3CxYFKI+asOhnk3zdDqg5xwmI2wO2MscXLGplvZi+H1yQ4fI88n0Y+R4Yn2b9E7c/5Ew48RwK0gxGdSoaQWCkW2OovHS2GHaQRxACvFGmloIEorKEp1wFKROL7GNZHeciR+fPbuUJNvt8ri7xIITvzYwYwN9ubCCp0W0Nk9zPjXF3DMfYaRro6YtomCTYg/S4QDflmSTXeziVbwZAy2xi2i1j6CENe5MjiCFRIq9VCOdY8sRY9Z5GkqE7hQxtAHbUZmyOWC9qnC+Ncm79G9SSm1CqDF3uUU1B1YlTv7rikYqSJIY3Y+jaTwnj/A6+wJmwkaqKstKGPeLGUn++b7PcslRUQRM7+5dJ5GI+1zyo1SsPv2gi0BSDzOsGSEyHSdZNcUjpe2jmNpNyGuxKp2ueNgKzLsD5kSBQJFM1B2umwd5OjyFIKKY/zp/v3WHrkjxr8/+DFW9wJtTHndMhbzhsFRLsJsDUXV3E09fJb3YxE32yQQWagj51CoLkwNm0y1uTxrcrahslG0GloIYVKlrb4Z0ArelIuNrjhlZRGEX4Qk05yqzcpZkv89is8tOKoFq7KeXm6VRrlCIUqQUnX/zmsP7Xn2GL9z3GP/HyTR2aYUl9wzNxEHGghto7YgeJXzV4/aYIN3qsjIK7bTP+vB7GQTxed3JtSnrEZ1Q8E8NjSVzHc0pUVMr6AmHdK/H5uQEhf1fZ5BUSbku9ewNHuht0fPqnHD+h03PCAddjQhLoIzsR9VHyGhfZMKtcndihnKrQZ4OF1Kxauoee41+WmM+CHlzw0cVIAc+hnS5lVrkj6wfwvA2+KlP/gl3x2H1uXx8Tsf/FIeIJ+xHuT3j8G29BxHApYXfgYUeuY+rjOw0ueGXuDObJqnFKOSSeYpG32XR8tGaNQ7evc366BRb2YAufRCwX7xCMdK4OxYH9Q/UbtDCAiFZG0kyVEwmG22Kd99OZuomw6zgorGHqSBkx7pCQhGcqN1PxhuwIfPYLthakjEZUTRttpwY7TFma2gJuCxmWBhu4KeS/Pj6x+Nz27XI2S6r2TE6iiQZGUxGFR6sPEmp9yCVxBTGQ338MdBrPkILqPVGWFk6xq3Lx6nd/Wnsa7G6ovuFIyz/xSxp16NgjhER8VTPodassFQ9zM3WAsXKOkKzWUreoqnFI5tyjRop5WWaUUzDnGnFVNnJdhdXUXh6dB8fqBssKT3e/kKWPdUyoeni6nlIrMUF3bVlEuhovo29S/9ebu1BpPaR0V8lM7fBTiFu1FrsT9Fovha/JzFAkwbPmjPoIuBWeBBHtdnHOm+OvoACOGrIWtLG6F0hROHT/YN8ZfQJyiMr2HaKfr8EoYaIBtT9BRIZj4EmiIRgGg9TO0x60KZWHmVbj/d6VG2hKgmGhYAo2GS1bGK0JLapYmR9PNdEN12aIyr59E08t0gvKONHOgnuohkDjsgbWLuR5Q1Vp+oLFtSIhtbAUXaRPLeGqSZxggE5NWZhWJ5OoOic6F6j4MXsCYBDOy3Su/3RE9EEnUQf4cSjfV5NaOSCDKd250cmy7fZsC1eeuAB7H6OfH6bUVFHZNdBCpLL8dgFX88SCYW+ZRBlhiTTOZKRjuin6O8yADxNoZNoMtZbIBsmmYjytI2YddVKpLG8IZkgC9LEm9giVATjrTYz/R3krp18TZnA7WnkDYeitsy/Hz2LBF7XXmQ9mwERsqnPcK07ii4jvkP5BsOMgaX4bMkSF+uH0SfixLBwtooShmgD0HIRexeTjLTqHFq6zVYuRVMb41ORg6splKXgIlWuDh/ixZTH1bEC39P8LL2cRqsxjoKkJHxa1VGctOAdW5/C2rH4VHSaFwv3UbLWOF3+HA87Bkt3HmBil6bZb1iMHO1y0ZlmyxhnZnQd1zcxDIed4iITSpuRuotueCiVVeZQuZyFlu7zi1LnzK4+xQwKeUWh5W7jHiggI+htjdFNBTQLU2jeXbKbj+Oi8RX9Bl11wM9v/AjNbpnF/F32oGH7Jpm0S9+ooyoRGaVKJ6cje0kUFJraFuF0mpZMUFUiups9bt5o42gWb7h7FjVwCFGo58uMrG3g9zXS2QEvlAokp15FqB5Bai/mQKNKiWl1h0io6L0pUARh9iZtJT7oOb+Joo+SqPgIReIKgZ+H4UBjj7LJ06+4/E1af5sY/jUuZdhjxOpi57rUtSELmykSQcgVK09edHHVZUIRi5P8u+AHuT48yEQYUlLa9EMTNeuhFZ6hpAqkMw3CJKkl0EIdTXOIlICUA10jRcfP4I9KtESc3L18u8xqNMui9Tz9bJ2tfEAE3GpfACImDUFaEfxE+jlKSh4nkgyHaSaUTYQi8bUIzfXo5dLMJyP+sB0bXNNWkHKVrO5SPXwKOeYha1kGIiInQxK7Qgv1ZGzYTS3uc8v2bEIroNLd/eOUbUTH442NC4yWdns7HJVUqo8nFLYrkyT6EoRE9wWhY7MyMc0escNydgx/uJ9CPVYuTQxb9JMZJo9vUbXjgNYezfG2r/05uiaxq7EjaKVquJ0/wr50mCs7cVBxqFvDVzzCSMVpm2zrKXL9IZePHyNX+wq+muEby+9jW69QNOMEeqgLtDqMqH38SGFc7dBM9HG7f0xy4DFyXWI3DDRFsqDWEUKQ6+whlVrEDnowsonmJDkyuIMAlnNlHCWk6wV0tVVWrCu81/sVVGkQag5Wa8iYBluewhs6IaHZYDBIcOF6E8XaYI8/AAlWEHF4+RZ30wppN55B9drCGqvzscrtqqeQUkrcTCskXYdJZwevEYFQuDCmsOrFwewDW+coeTu4qfvjrerbIPmreVjr4+P4ikG9UCS9G5BuqSoF2WSgJ6lrLd4kdLZTRYatkKOF1zHtvo8dTSMXCk6Ky9wQ8Syuod7hRW17974kkUic+l0OLd/gLfIOz0fHyQWCZnJACFyceIbkUOWWfAO/l7mfXkrjyHWbgqkgwx0W620abgIkqIqkP3IOmc+gJOPqsPQmSQy69JLlWBE1fxQ1lOzbHDDff4EtfRvNLWKJFk0KJLWAit3kK+3jVKM8aroJgzwTmzVePCBIW7FTb6NSdsvc7xzg2p4FHEzuXb9K+mhcTLimSXRUVFSUbJHl5iF6boJCJUYgPVUgkxrLiXmQEZqAoqFyMXOGuzzBZDhgOuzhaT26g9OkW88CsNM4hkfEVREjAfNKjV5ullpOY7o+QAQTfNU/xWG5xptv/zBPRh/ho9q/wA4S/PpLP8XRfJ2mrmGpHr2WQzuj4+kCdRAjlHpqAaOUIDT7kCiRH0hMvQFHx7m6uB/D9+gNv45t9Glm0ww7a3h7v539wyp+X0PsBlBqsolai6k3urxCUkkx2uggQpv73adRrTOs7HkvSd9lJ53h+W0XlYgfeOVP+Icf/QOeq6j84ZlD3CpWiLQCi/4S3WyRpDdDp3yRR5c3dqXdBe20zzA4z83d2aidVI05I+Jza/cRRCOcS19F8zKs6TMEBVi8vUQ/o6IYPQYJndQgZDDxLBk1Sc9vMu4rWMT7nBUuTqqBVEHd8yihPwD1BRKhy/L4BMVWi8qwyfVkTF9aGK7RysZiEE90HRqKQm+jywTrPKc/TE9JU9j+ADObPpGSQd1JcL79CPcoz/PK2A0ecQ7yWOs0B4JplrVnOLJQpbVeIPm8wpHeMtvhCLlBmZtpjfqYzouJNHeRFJVNrOoOB5dv45oGn36gyL3t0/H9LXgcFsdYK0+T7bWQ4Sq9dCxV2RmW+WjlrRz2lhi7c4ZBt4iTsri+O7/0W+V4ZM1+cYADzRW2RY56FEvvzw/rmGpILcoDkJurUm0d5KYX98H9wPAbTHoxo6HvBhRsh/XUFB1FYgjBe7UfJIhcgshnwVhk678nOSum0LshdduiPyixenOR2tYxPpG8l7OGhyINLGWEjGOTdnzyxggNWWehO0GkRIwNSvQ5TSFTZSpZ56otWVK3UYOQ0VoduwV3MrGvsisemgyotBy2iwZXB0+z6Sn8yJ37GWnmSBASqEMiEeCYHZxQQY0iSgMHASRTEkHE9mAE1XgLuj7gUOGL/NDROKlxytfpO9+glipyeZcZ4vgTPJ1IkLPnqCfq7LvhYNtxUbVRKbBtN9gaXKGamqHhWyykNQqFLVprZUCgSh0RNcAfYyM9yjOjx7FwGdENxjsehh9wdXqMZjNGhxeN2xR0jWG2hwx3SCu3UOvg5QWKJjGHITMzl5AKLARXAYVasAhCZ8q8wlHHYdG9S0EMUZGsKrFfmTEjyhgMogQKIVbkkNELDMM+anKUbOAQEKOAfmQw5kjcCDQiDtpbpMOYjXKIA9hGn4FM8rHKCc6aFrSmWRwOEIRYxWW2KlP0/0/2/ivatuQ4z0S/zOmX92t7c7ypc+qU9yigYAmAEL1tGpmWpS5lW92j1ZeUbVFNSlSzqSsvelICRIIAQYCErQJQ3pyqOt5tb5e308/sh7kFvd43Do6BfNxjr73XzJkZEf8ff0TkcpgtHc2cEDRv4hXvYkwbOKS+PpEaYztD3obTsctV8x2eis6SjSfMyBT8hbpgs/guuaBIUj3kUpRl30oB6sApYQdTzCA9y241vf9VP8YeBvRUgf9q/gMujNZwxyaaVNwVZV7M2HykHNN87A6tB7sY2RbHdjyua5Ln1C0GUwOrcaQySbK8uX8/Yjm1i4th6getYUS+6vId1UManQ7z+6mPWG8Y1OIO11RMXynOxgFuUuK3VsGKFY8VX0ZNdbYPvh+AMgMGW0tsj2b5Se/v8fnkExgq5Lv3fp/vfGiL/VxaD3rvzIdYEq8RjDQyKwGBZbG8c42JaVCd73Ons0qlusGd+05xVm5QaocQa9iLb5BHcC8T8FJ5SkHTeM4z+FtTg6fRyUqJG0+wmhPcrs3CQarwahcd9GCNdwoDisGYij7kV0p/QDOsUek9St3pclpPaMsaVWtKtzGHKe6ks5XzOsFojpiYsfU28VwGQcJly0cEkrvaPNnY5/72XcKJzvXsMSLd4OzmFUAwm99jv7LAqn4Tp7KFI06Tm5j04hzL9hZGEtBWeTQnR01O6SsHS8Xk4glKzJBZSCFVoIPKQzTQuKBt8KMPfxsYfnv9/7lkpcbaA5v4sUG/EHNuLU/LKvFOIc0yVPM7iKPMmt7p4ssCFUKK2pRBnCFXCmiLkAtOSKw0NOdJhJUCSXSXUPpk3ISR6RAok75eQNoGIFlbL3Jz8AB5rUMYXsNdqeCZOu97+RsIeYOiljrDgTlBa0VMEsVwUkATCXbZJwoilBDsV+t8T8OnPU5BgYOiJLYQAtZOXMJfkmTXpoSxSxaB7aXAcLuQZsdmtA0mkUFh6iJlRPGo+Y50hjR2Wzw9eAPXLAEQ+xLDiYllzG5zEXPso8VQ61uAYnN+lScPrpBLBoSt9/OeraPak6gDQtAXJYb+eZSt8dj1b6IAN1NmcpBBKZiZXgYUWuBTbKcZl5ztUVAbRJM6JIJrM2Uq2ilE4LJZHzM3eY1t81keeu02mlCYhsPINuluzPHW/Y8SKAOtJaioR1D4fPylGRaubbFPGlifGh4wTrpkD89SzB/jwNsGAeV2zJK3T6gJ/Lwi0kIyboUfO/4L/LX5z+LEKej17AgZK8odxb1IctGX5PRDFBrr3Rwys87xMKSQSASCxYM91h1FRVXQ+wqjeIut4S26nomMDApJlVfrOqe2W1QZoAYRWhwT13S+WG2wZc3wZPsyk8wWllhk4NjURimokkZ6bt96+BGkNNmvNMjrLbwky8hKyJGi/p1pwLMY2ErxjYvfzbnSE9w1r3NXyzIThzweHLAnjoGKUbrLpp1+ruxFqLjP3dpZ/FNjcgS8oc8zC3QKPndnTPZLXR5sSUIrixdXeOdcjsRweEy/DCTMHuxy4B71Y/dsEtMlEttQySFVTCwMGv0EpIkSZXZqJzi+F6LMNTqdfXZzN9C9Co7eoS3SYMryJmzoTX5j/B0E2Tb5sUAqxfXTiuBo5ImbGGhKoyt8Xlk8S44pHTePlU8Dnv7s1W/ZhbPTBfzDj7I+KJOZ6yJnTvJev8hfTyx+RjR4qP53+Z7lv8MH5v8uP8iP8s+/OMPvfw1+W5vnX5jzfKCQozhOm3zMR0UM9jkI0nl1zYVtPn+swmFRozaEeFriqlzlQ/I1ZsfzLNRvs7Df5numl5Gh4uff/Klvye9Khs8bc4tcPVGg6k/wE43mpceRVhmsCQelGqUJaPGQx775AmHeotZrMYj76TMWVtBGu8xJk1B7gHCcysgTJQgqt7F20zNtakd1hmEGhGL1bhfXibHjCCOJ+epCmUZHoost7lSbfNcLX+TnX24xdHL8+nvTJicXR9scNO9HTyzmckP0Xnqfd5uCbiHCj1+gFWzgmeBrU2rC5Jub34/b/4t8Z/dZNKUxTaokBcXKxj00GSK1mK1kAStMkLU3iLMaw7CDROAYafCWFx5RaZNg2sCq34+78wpvWxU0FN1GCakUzcM2N7MLSJWwNG0zzQryfsiDYszXMw63kzELpN/3Yu/z3HdvDaFgqGX52gMtRoeP0KOMOv1fMRD8L3t/loE2ZPLAp3ATi08dKASC6qCHjGN2qaL5Z/jU6Y9xW0vn+X1XXKTUcTm5kcqpejnYrn8Hy2HIa5kCr8w26OdKVHuHDOID+rV0vIS89Z38ofEsvjDIa5/k2s2n6VIlnI24pll8sbRLrGKWdYdi4OJismEvoquEJZna41G+hqlPCH3FtcESw6nOrlnn0ck19sz0nI5Dk/LE49Ccx9NCHsloZEWBz4/+K/vuPWazp7m9YOM56R3Ugn2yImCsLGJdsK5LXihvUo4bBLaDHUYIpahasxwm+8z6s+SShPx0iYfHc6hEsLr8JjqCXdml4EHOC3FDnauNlBCb1BJOqA2sJOaXzRxhPOQvlzRO38uTSImfzYIAzzkgkLAmavSKRWYPDkkQPDL/DnlzzFQZHF5f4uWXfoCXeITnXYlleHT1HqXDFv/iqe9hhMnI7NEcrfAz9Xkq0xn2lcMgLrP/7ocBOH/2FupOGy/2IJc2AHpv8x2EUNwap41biAJMlapqPpv5IM8vXOL7wudJZJHZg1dY7gyZJGP8fnoX5+wdlvURbVOhpOIDd34f2hKjkiozqodjZmZvMeo3WSYdS5Ic+exs6U0Ww4jxNIsQihpTunGB1iRL1ko4nwnpewWyeOT0EgWjghdPEPkGM6M+npNmk66WjnNqGOMrhSUl5y/sfCtjuCBrBNoYhMnmfBpLnNxLGMcr2IVd2u0ZZNHm5I1b5PcyIOBDzT5ecQ2rfwxDCJxoghUMGdiShcyAxUDQdvaZjYvYUYFjKv27hanLYWEXgaBjO3w83GRsHM0WzVbJBh5h6KBkwMBKs56WADlVrAdV1sM6pdGIeJiG2XNqQDRZ5tOv/J/86ss/xqhVRsu0eSOoEAn4S+bvcndUxTpix00/5krnHKP51LacjdbTfXYD7GqI/soLNDttHNcj403ZnBGcjzwCAftScSy0kWafN2aLvL9zCNUBk6sF+lGqpCpNdvlC8Dg/+9Lf41a4xD/S/xN/Nfo15v09zpxeYGC3UDJAjXRmrJuMeiZLZzoMyaKphPuNdzHzEZt7c3yx9ThtkeGs2KSn5Rnv5KjMvIUiYU8f82I9QQrJvCFYxUBDIIRACsGccY9Bt8Tx3gAUCNWmONlCz97jyd036dgtrmTv8t8qX+R0/yIAYWPAlzIPUDI9CmYGU94AYCdrYPkzdIgQRpu8mFDIuFwzFX6SYT2zzIlQRyNhGuu8WkxLZxb3U3/ZLBwwI/ZpcMhiZoyuskh9Hs0dU7APmPe2uaVncGSqepgkWRpxSvwIMUu2GqDFirEOQoNwolNhQO9WSv78aVnfBoZ/gksPJvyd1ginl0OZJuWxyeX8/dzNp4ahkT1EyJRtNfsHNMJ9Zo2bSAH7cRmrGDDWNKrGAcumQDcvYqplFIqh0cMXUxwvYmqlhnt/0sDSt5H6Aid28tzyHyRWGpdcyB5/H0oIjq0N6URXkKTAsB+B5ReY4NPqpQGiU/Mo9WMGK3VC0+SCGDF3JAldOxZSIdXz71pFRCbG2gqotLawhYnppYxw22oiGNMUewxDCztJQcUXvytls5YPr/NnDl4jskLk0TGNPInuJLhWzH5jAaEUlaHFbNcBBLvNRRb3dpH1LxP5C3ST1ABaQZqVfDs+TuwuI/IhT77xVV659DS+tkw4MklijaI2YH/poxzMPYqI+gBs3WfiZxKyvRT83FkoMclcYvZwyFx2xLNLv0KsmTR3UrChZSyGjkX9pSmNtoskoeR6xJnzHM4/Rqvokm2P2M3ncWOdWmFMdHCDzOAClp5lT6UGZHVjC4OYTtbBtscYcgxRlUCGaIFD6UjRO84fdYTbFGxGGiMr4alg+1tnzLbXmEhJJUrPQKdY5oABGaXjdHI0Mn3O1TfoenBpuoBE8m5J5761KVV8hILiYEhSNbi6YvJy4SJP+FdJZIRSAe2cRXniYdomiPQMbObmqQ4HJIUieb3PMG5CXsc4ko2uW1UyCJ4ROm/rVW5Pr9Jrv8WBZjMTh2SAYXAcwznkobBF4mSO3mMGqQ/JXjjJheIOryenuBhtM28mjLIRn30sj5LwE2GbqjVlHBRYN/LcfuZvsZhNnb0zOOTAyyFkQjTMQmDh1/YIGifI4JIRIQ+N0yDElE8xNkzObU3QMmusiymHZgfDq6IbE76uXSJMJHGoSEyN7zC2CJ1DCn5A3JT0azlcs4VQChE5jIwRL9h3+EbmIk/77/L1808STdNzc2zlXdzcFvtGh+/qvp9/H6zw/u3vRRgJ6uMf5q8GNb7bkzSEZDseM/D+mKH/23x+ZczPnTH5w1PX+V3/Lv+SKVeyV1D5XWwZsstdGsbP04myaCTk53b43JyBiLvo2Nw0Upnch41XOen8IroVs7N/jMXBHj+0/yUKTPn1rR8FoG4lbA7meFVbZYEWk9Cm9MwZ9HwDYURcbjYojRUkEz7pXUTlDJq9PZyjYMrPLCGTmPFoi5nKY1x30zrCYecEsd1DS68ck0wOFYyo2scgSQi9HKXMDovTFFj8ueizPNjzMeUtLr2SAur71+/x82/cwQkDsl5M7Z1HaVefwtXHPBisEoy2CHSD4UyOQSnkwM9guQU6pTQYjfYWcZSPG2pMjvZE+CWEhKicY3HhGlImvDNKs2r5cEzxvnVGR02Askc2NicDrPwW9ub7EUInufc8b0Xn0UhoZo4CztaQDWeRBa9LSB6EwBgILJnwhlbkch3ey5f5iPos9vCzXFoDBdgPCvZnpxw0LvNf+REa1hrvzLyEEJKbJ38VuzzmP4c/xq2yjwKyvs+J4JD1uIJ/1FGTro8jBA+4RUojn9JoiogiSsMur62scmaq87oj+UxzQKSbVHst3GDAqGGDgG4sKJqn+J3GJ8jKF7BDRSQM5vN7/E6hCER4aoeqLogzKWi7nT3OTKTQ8+m9CvJ5svk++6/VmcoR+YnP85V0puebhXPESjKNDcoTj76c5wd0Qd2QvOausWassT25hWkV6S/MkRzNaV3aH6MJRV/LgaZY7txADzdoeA3acQYZS8JsEUfPM3JbmCLDSpIqPFpXykwPT0P1gFWtjBKgaxbxkezx9eWnAFC5gFPaVfpS8oJl8xfLOhf9FSZeC5kotoqpz3SzW6AUW2GRg5kZ6p0ubb3K4uo96lZa1/ru1RHlpTmuhPCOWKWUNAj2T/Lp0vu4nDnD48X/xkHhNjOjE+THywgkaxS4Fq0w9W0UitOFGzyjdTF1nRNOKhlfaF5mOi2wXUo7k6u4T2GcygBfKt9HLCQ/1P8K5tijPNxkpTVASQ1tv0McSWwjYImQsYAXPvJhRqt1/MTAPBpVIeZCVCK5eecUeXsT7b/32FYRgbOLUnCVk4wsh7I2xg+a+L1Upnqx0qXnl8j5I2rWMraWRZEgTD1t9mLYzE1TH3LC6+MrkJk2rUs6+SNg6D37C2SyA7Q4QytJf/fhQp/D8ARG5jZ37j7OJNSYvbONtptmB23TR2kBxrSBQlGd7mFEU4YZk+PZXTx/gbYh6SU3uRidIudOCHSdufYhIzslcAdJlVNxi0Wxxt3CNXZKDTK+xzQ0ELk9DligFCR0imlZykOj6/yM/2fJTaeEwxTY1XWPD2x/iAeVw9eHD/HTb/9D/mPQ4E0rYiWKeFC/wr1xBd1Jn6s5SfATg6vmMkYSoY/Ts+MEEV7FhN271HsdWtUq52/fYqMhKUQpYMkmkPPn2D2xR6gZPCt/Dc0rMr6RwVlNiJRByyxzWytwbHGbf/LEP+L77Zf4iHONxDCRrRGWcOjbPY6PvoxhRlzJF5GGYla2eXimQ+VYGpeNtx2+tP0s7a0CZ8UGcT6kfSuLZQ9xS7fpJi1erZokKJZNiX0kEwkTn0w5whEue8Ey+dCn3rfQogOe6byL5dyhkH2bm6WbjIwRX8y9wY3hPCQ6g+Y+/SPAPWMHWPI6E1OyK3VycZV10p4O5aCFWVOEQvAF0yQSOvcfe4lwXhEnkpeLF8lPBiRHXdPNQsh38FkAZkUGRYw0T6FNx5T1A+bYoq9Z+KN0n4fKphIOAIGQJfbcb5KdRHS0NJ71Yh2JIrFT4uVPy/o2MPwTXIlmcuftOo3elIWdBNdUtGvH2DQVCsiLPThi4zJayMPebWbClP27rS1gFQNCW2CIbc7YGoIYXT+FVBNiLcRVE6woJsykhulg2kDLXEMaqwgVQlRnT1vmQt9j3Uwv0jSjITZeBSBKAqa9eSxl4dsDssKFEJyqx1wv4u6JlJ0PRh7PRKmDeGvRoXI0vLarpwYu7M6wunYDISQt1cfTBeW4gqSDI0MmkUkmSaUY7yycQihJY3AXKWBcL1AL+0CaMdSdmF4lT6SnwVujZzLXyxLk6oSmheW1SOpvYONxufwExAIRpzUcn4z+AsJXZHgJLYmpdNuUjmoVVKQISja//tFH+LVPfCfdYg1pxPSqBoEp0XrpM603S3i+hPr7WHAGFPQDLh8zuFv7IABLwTa+oZNfc9ns13mmsc58PMW3K/RzbXQZQgI7RpEDN4c2H2NuvYM4uooH2f/OXKWO8GahiWVNcLQRhsqwPFFE7jzNOC1scvMJsSEwNgS7oeDQjPjY/v9gp+bNu+zoOtkgPUd355bQeusATILTJHqIwZi2H3OfmwZZO6LNcrdBQdXQkwi7MyHIZRks2rwqz1IRA5ZCjyBap5PLoClFXUEYeogkYa1epjIcsPxAg6LsM4obhHYe/BA9idgf1YisIR/DYgz8nrqC52Xp6wm1KEW849Ex7PoGi29dxk/SvbFkifyJLB+232VejPiV6AM83brFcjY9Z2+eHFIc6zwuB+Qdl0FQ4JuDkP43N+i9kSerC1R4wK5bRndi3Img114gOO3ilc+gE5AVAY8EaZOJYfnjGKFioX8LJRWbNUFL76J76V25otlsT1MH8TedT1MvATIhOx1jPQHFpErP6GMTESuLsTVAhT4dUeSJgyucsceYZvr5LkW+ed8v8KXiy4TSIrDaXJtKCDXWrd/lexnxo8u7/MijNr8Y7PD85pt8bn+X7aeKfHLZ4vrSNfbsmP9GxNbiC6hYw9E8lNzFVSPaUqNhDHmncZIDR3JiL5UJ7esxDb/PKbHNM7mXCaeSDf8S07DFrDL50eQm06PZqlYpR+/rWX7+jZ9iSR2QUGcwq2NWU3n2C3NLlMYQGj69TBE0QfNwB2m2kYmicDx1vtHON3hMGNwSH6HtlhGDVUg06Hp4pokXrhK1b1GunESbjkhhkYU5TT+f3f6f0FQGTdwmHKfAzh9tcd+gwD+d/ix/7fJr+IPzREaTfJSjOTqF399mrzbPUD/DKOPRCXJ4oeIgfZU471oUcBFezOtH0vWyl9rN157+XmbmbhJFBuEklTg7Y0mheJ1hmJJg5yxJMzuhlHUxNJ+Z/cfx5E3EcI/JcBEFPCKuEWgaetfn0Jrh2HSLtmkfff+jJlydDNdmBfPhdX5E/QqbeJxbl4yyDRoZl7N2zA3vFV6On2BdrRKc/CRX6l+jsPgG97aP8bLzYYQuGeV1sn7I49MDtpMi7Uwekxit42MXTW5Mtsn5AaNiHmsQIoQg0jRC7YcR6HSC30BJSaPfwvU9/FyeWAgOZI+5sc/PHf8JQvJ8Qn0RoRK8SZsvF02enboQXaeoCarmHEIlJEJjNjbJ6HuEaEwmBk4m4OBunhObAflpwr+f/z5+eeGHGGsZxkkGLVbIBJ5Ry3wHRe74MdcCl2ww5Pnq20TEHNfP8+qxq8QC5BGRd+jEeJrH6p2vIVRIzS2wkxQh1kjKqXx+Om5BHFIl3fPWaJ549wRIiAhBQcuOaJXy2CrCyxcYSI2Sdshp7vG1jMOHS0ucygyxR0u01YBMpLA9HzOJSLSABl10XbA/O4OmFJmiwil7NI46m+5Km0t/5hI7gx2W80vUwiID6fNrZz/MSrTP4/IqO4V7ZMIsp1opaD7QIj4fPUqij4kVfF0+y9kzQ2YeCvkOYfMfKwFGeZ3W4QpLUUqiCKFxT03oiJgNJ8fj+1cpbk9Y2H6RUJPEmo6wi+ijHpNpSsBVj+SWmxmbuUmbfsbGKoaoWBDcBwdrx4kHJaZ5SdVIM86W3mYhDpmMDfZzTQaWpCZGKGUSHF4kiQUVZ0rXLZOJJlTMBRz9SLmhAma2d+iEGjOks+QW1R5+oiC3R2IKCvGQyNDQtvPMeTYSjZ3NcyBrXBxPiTA5ND2SWON1t8nUyGLci0AJQjslZA4HDUZMqR+dlaFjspAZYLipKmuQf5kL5FgYb+LrkrnWAUI7iUKRG5nEgcOjnsXl6nWyvV/CcHeJEwO7dJddrc7CJGE0q0hMxamDXWr+EI00bnGVpGy6/Dn/q/wTMvx08hm+f/kz9ITGWMJ3qWt04gzT2MTUU1BxvhuRFRFvdS+QL7gIpdKsfQK3Zoo8Ft0gF7i0kxza0KSdcziwmpSSmPt9HZB8dXWJc9NbLFRfprr+cXR5msWPO+wkdRZFmxMnoHY8IJeZcvuZD7Fo9Dld7HLv1jaruRMc2JucdVOg5Nd1YiX4XPwoz5avM7ewjzcwmW/vI0hw4pAl2WKq6fT67yeJDTrNl1H+kJFVYk16lHWBLSFUip5/QKaexlXXzEvEQrK6m8X0d3iwPSLWYi6f7tIXLSbGhMiv8Q9VhDlY5oS4Q2U7jYUrzgRT3qBbMOmFJk7ssBMsIBDIuItXy9FMfLZ0cAh47MQfoOYjjCDhxfwl5vc2GJXrREIDS/AevgZAZryAbQyQ5kn06YimajGbSWPJvVGWWOgM0CkGbRAOQkh2W58nO43ZOxoj5MrUh2jjNDnxp2V9Gxj+Ca5o4GLchQc3DviBl7b50Lub/N1v/jYffhWGZCgHLZIk1bvbWoSgQdVNpWlv2fch8yEqm2CIu9hSYKkUVGgyvWz+UXc7lSi0JGJv1KSW66AftRhW0T67hQr2dITw0gO/c8JGuzbA4BpSxIhemrr3sl3OGteIejpOzcOOYl5aSrNo3tBjsBEhFJzffZuS6TLWc0RJ+jfvOB/FGaaZwmPmAQdlRSOp4R01sgkTSREXlOJRNqmMwdXT7NLabJNa0EMpiAIJGUUVj7w3ZpIp0OjZlAcarUqD4iRmY/EhBAmPeRb7Rh1tdJyE9HsEg5TNk85bAJy8egNDpXUNcahhLWTQwj30YJuC72JkY6JperFHnQamjHgguM5GXWfcm7KQHbAZN/jqhTyuzBMlJkvukVzKtPlj5xwXZwa4UZpp7WT3eOge9EsOrjLoBQ55PeDtfOq4JuEAObNNlGhk6hFKwTVzEdueYGpjLCQLbz3NsPW9VKOIRIRY2gRvVkfb1BjEgn0joTGtoMkJtnHAIgN2DJ3s4Eims3KC4zdeA+AgvvSts7gdwFJ4ic2MIHG/DkAmblAL2kSdo8HGhs6roxQ8XgomTJIbtEo5YiGo9kd4YURhOmGundbNmSfnqKpOCgy1MhJFw+2yNykzqVzlgpLkkxHX7TPcbTj4WkAgYBgXIc5ilrYJK/t4YQRKYSOpVRXPXfk19lSRN4M6sqs4LlMjHBqKB1pHc92sLn2/wHqygPiDl1mvPESunJBEO/QCC6vkEwQRNwZ5lAN+p0csIEPAJS9l2CeZLGe3xpxa+zK+MthswCAOMI6AYdka8Ja/ku6rOsFeJQUN0VWfk/Y2T08SenoPS0XEUuMDwUfpxSY6ERdu3+Wct00+nwUV88J4gXdij9+uf47fOfcFPnnf/5ev2VfRrkvi1T0OSDhrr6Ecg+3qMpPmDJ9pfoSekb5XW/hsHD+dNpFp3GK8fx9V6dNWRQ7D43SlYt7Z48u5SxRCxaqXzmxr6ZL7O7ugwNISBmsZDotZEhVRspr046f5JeM/cEiRtqnxSvY8ocrQFD0m9go/etnh3w3SPRiXDEoTGDsKI5+C9frBNoHTozmQbL4fEiFpTyPiJOTDepV//fafozj3GpneacIDi6HjEHkN4vZtbJkndGxAEKoOsTFBJAaBm7qtQ32P0EyD2Wi8Ty7JUctscv9j/xfF6HkArPImiUqgv43BHA/fWGSqK4ZCoOIeB5WIjGZTHvgUcgIRJnzpaNTE7DAlvvInX8IwfQ66i0z0iAQb2y1QKW+S5DTGyZgPhYoHM3uUcn0y3TMUwiLDytcAyI08hqbJo6OrbM7MMh7q7NhlTrh3CZdSYiCfRCQK3nNjipKCy0OLdV+SqITldsSgdJYYjwtOzCgKUFGLXxc/ScHpo9//q/jTPJ8dfBxDRawGIXt1RS5IKE0P0RONNX2GRuAh/IReU7I+uIEVxSSNKvRDOsUqK7tbfHXlgyyqP89RfpGVcZeJB5KEfjaDQlC+/Pv0jQJviA9xLN7mh/Y/z/ODA4ZC8j2jMTX7MpoQ3C8s6n5qe2djSV1usm/WSBIN3ZjlpfNdTHdINtC4njnGPzr+V5jxO0wCSS1JaM8/yN8hyzv6AS95EbnI4pkbispgm7vyJk+OHqCVO+SgBPpRsB/Wv8nnlj7HH9+XkpsZ12BLa5ALA+QRMBz4B5jtfQ6nx7DEkX/tpjLmA9GnHBpYSqeTc8hFEfWwz56R5Tl3QFYp7vMC1jJPg1BowwYjPUZYGQrjPoFM7+NCvM0CaTYn0DTOr9wjiQWZ/dTnbWDj4tJ3+zwUnMeJsygpWPTbLOZuUvYr7OdT0HWy/TB9+4AV6yrPx/eRSBfdd/nP/M+0JjVKF+8QO4c0cm8ihKJ1uEo1SaXISi9zM3eC1+2YUEg+vvc8g60cM/uvcPl4nbfuf4CM1EFIvKFFEglq6SMwNXvUOl1aeQerEKBiDTEUeLcaDDKScVZjwXwXgGruLVbCiOHdDJFpEuIhzbR23ZvOMRmXj/a+QDaaUrOXsEV6d1UyYWGvz1Jyl2P2mwAYXQcPRXlyP83X/zdK0RjftGgOW5xup9nR/33nb/BL9/48e/6TuJldRkGO5fhddrUqnpnF6I3Q/TJK99G8MtnJCjvGHnmvlXY4tio4esSZcRonbTh3EWgE0wDfCJltH6KJ40hjSrMfkx1KLvjLVIffgeHfxItSyXur9g7bRoEZN2Ru8RbBqmK2NWBhlMY8CsGuaVM2XZIoVfPcHxd4/PiXmJn/Vf780OJ7zc9xNZ5DGQIjBjfWaQQapzSXt1v3kaml39GMY3aLBe5GTareUVflIMNVUgn2elPnqajN2VDSn93jTm6RS9rLJCOd/MYTNOwLvLk24g5NznLIqGFhdHWIDToVyaGf49nyddw2aNoxCqPXKRU7jGKLc/GQTbnAzwT/MzfUEnapT7Blkw0m6TgncdQhPDa5Y55Dti/gNl4nN56ipMM3jTaaEFTMBA3oB4dQ3sFNMtzNHKedmWFlL4vjbrM8PEEpjtlruNS9CkoofH+GHhGdQRFyGzQbH2OqTJr2PTTRZ1LScL0cbqzhTCeUKePHAyb5Eg+qdN9XxZgJP8mKGNMqV2k7Veb2NzCkxsjKc2ewgklAb1ohjDRWpI4mcuhhkWoUUyybVIMOd7SIBzJPAFDwDxBaFb2SsBSH5CYRW2FqQceGRuTpPLi+wZ+m9W1g+Ce4EsvkK4+d5esXT3Blvsrbs1UWu/v8T19N0HZjjvfXePzt/4RMBNY0oeuvUlCpsbkjF9kSS+hOhCFTB9LMCuLgDomdBuanrqdOT6iYOdXiYDRDOTNBmy2ByJJEe3RnImKp8+QkBUs3mscRoYDO60jhUHZTg+MXNlkIdvA6Nk7VR2iKb1YOEFIwvhszXu+QVyHf9fznmRFjDsMi85uv4vo5dgunmYrU2zRHUw5LgmJSoS9TZywAW0XokWKx/w7VqWCqTzF9n7eXzrKY9AhCE2lJ3Kxk2eswO91lZ2aJxUMHLYb1mQUWD/tY5tMY4xM84DlkRYTXeR++6ZPz2lidAxAhZPZIBJRDQex/A2nGxJ6GbURUDv4Z5Tu/hYxD7EJAGKeZtnf7JSxD8W+v/wPmKj3suE/THvN66QHGjoSqwSipka2lLOjINql5I96c+z6mdgoMh9YuJ7d7tGYzCBTnigdIAXF5zN70HnvDd6lkB7jjLJYdEnmS8Tit1xBWCvavZp8lEg5FIyTWPApihL8E5jbYEWwaOlvFk/yY/ApP2F/FTlIZRaObPseo4PDg268ylRBGKZCJI5P1QLDiLnGjpLHUX2c/t4YhMjT8FpOhhhEFaKHLeq/KKCmyoq2hB1twYpVBKUf5oA9AfjJk6ShjKZsZbBUwiOskSQVJQj3ssBcU2L/wb/Gzdzk9vsVducxeNj0fm4b+rRqIgW8wflTh+WCpCIlg4dd/iVq0ya9HH+ZcZw3XL9KcBjihRCgozz7JIK9TMtt0/Cre+C9TPhjyH+57ht3TGTgaSp5ppKTGrckEJjDqvMkUg5xKqEchxSD9vffffpPzV6+Q6U/oliuoQuZbGcNL1Qm/FzxJgmASfy8TM816795qctNZ4QfGVwnEBBEfybCufZHr8Rz3i7tMVcBo/TWu+nvIeMjQO8PlfpnjVswHG5/m7alJ3S2Te0thZ3yW81s8nEsbyvRm6gx8wai2xJ2Oz6zaIdeb8rWqwcnyXcr2AK+zjOUXORRldqKT9KViJrfDK8E8z+2HxPVTbGousZCcHU/wBmn2pL+WYbecBiE1a575wGLz8HvRrCmnjE1eKz+MRkxRc6E6w48uhthWCm4KzhgnMNOOfMc1RJJgjnzamRFz4yx/rJ0kqJno0wHT4R0+mmjkkeD0MIeLxAMTEQe4ZUXcSYOux+dTGepQ6xLKXSZGjuYYEqW46S+RLM+SCAj8bjocpnUKpQR+dBZfH3BJlgnkLYxwzMuPrLLZTEmxfi4EAvrZMRWR2rhiI82UvJi38CQcax/VQc9fBmB7/yEmeIy1GfKRhpQJxXMBw6jPogs53yWT7ZLfej+uChksvQ5AzvfZzuk0wy6tZp2gayHDkBPTTdycgTXWqGlTuprFiXsxjYHBZU/nhq9xYk+hJRBpNm07xzknRqDQojVuiPtY658CAbfffoyrqw/yTO8NciLLXjkm5wck4Q4P+4LhxETvpGf66d4WucE6ANn8IqVBiJKSpc2bHGZMXlp5Elt7LwBm2KYbOCxOdtkupvuRn6YB6du6znVzlb+/9m9xgg75SPGU62HkUmKlJgPm/LT5VIGEWXnIrlVK/clEZ33OxZq/hRQZsu5RDZl7yCQ0mPV0Fi7+KG0U/2fzk0wkOHqRcUbjh15I2J9cZz5s8Jfe/T/oFvMs7af2Mdd5nEvtS7zneoGHto+hjSxaVp2SP0YvLDBSI4LEw+h3GPQUFTMN2DLZbVxvjkmkk5uGPDCpg0pwnQr1sMuh1SSjFCMMYmMWX0tJRsLUrrr5EqHUKRzV0zYm+yyoLoQ+VxrHKJ/ZZ7hZIT9OffN6KNnqpXbyTGuZ31ep/fv+na9SJU/Oa9JzDnCNGE3pHOQ3eL/5DXrkCKVA96aUukP+/fQvEkvB7qV/wWDum7ijOtGkhEtKzCS6YNNc5Y4R0YwEi6yhJSGainj5Uon1xQUiJ0NcqKG6aTO3WnaUknjxFYy2YpC1sYoB0oyIXzmOsx+SSRwOHIOT9jfQCKjkUiLmoJ3aRl+0uTXzeloOQZ7RuI4fmXiJTV4J8mYe80hl5CUT5j2dv8wvcVzcQktCMnFImAi0MlhanWzkMtUzMBtTN1LQ38dl3i9yO3qOSf4elco2xb09fM3G1w10b4RSaYxhD5dY9JtcKdxjPL7GxDLRZY0kFCz5A1Rs8YvGWW6YaxSGEZEmaHTbBEaefHYbARx65xjIWWb9T9CZ+0VOdh/G11x+w9qjY5p43KTWvMOknGGue8g5NwVKrSKYjRXKpssL4WmgzwUrz3ZL0c5v8PHmT7Novcur0SqGE2N6knFoYk5HeLFgEmbZLqW9I7J+wI3lMRujjxFOUtJ658ISwThC8yM2m3AuKFJJNK6fSMjFY95vfoHDV+YJ929Sypzk375coBflaWj7bGeKnBhsoVUuEvcu8/z+MiXN5YnJJtdvZ5g73MSpB9w08yyoIRvZMzTNIV8oPUqiCebHYxSCB6zLnJXpXeq7Fnc1k/r+IyhnxOkjwPjNcmoLisJACoGvpvildbbcFQLTZJxvkAkkM4dtEnWSn+oOUALG2dQ2jLwF6mJEe3OA0iJO1Qu4qkz5qGPqoGDgTvNsqTJnJrcoTgpMVZepneW4e5WLvsajjuLg9gSnFvBKM63DPZVMyY8HjPMlrnfT8obBcIkMWY6ZRRQxmnEKxlnybp3l6Sa3pWCjkypYikEbzZgjt2DwgFkjmjrshSm08somtz47z+6Dadb/T8v6NjD8E1xGPsPyX/9hBhp85X6dn3vmg/zukz/Dz/50mXcWKhjFBM/UsMIQNQLtzgFZ2SZSki553t14DzkzQRcpG1KzGoSTz9BVdxBRiOanwd6J4wEXjE323BmiGUWi+kitjopbaNV9bs/cz0d630QYCQfhDLcbS4yuXiVB8R9tj7/NhOfjkHiSYdDKoZkJycN1Yl1QGhqc+jefRBttUBm1eOzqFhXDpbLeZTW4S+nmhDPrl9mrpJfQifJsNy1M5TAql0kQ6DJlUW0/YYDNvB/g6i658ZiDyjmWwg6hb6TyP0djxh1wn7/B5uwy8qgv9LXjZzl/+DZ2nOPU7gfQheApO8ILjtNjhude+yW0zj7S2UMnHVieicck4V1wDIKxjhYN+PFLP0C+/QQiDLArHkoz8EYGop0wsmaxE5+P+f+UE7O30ITi00vvAaV4JIFJXMUpamixYOiY/OS1z7N+2GDqpHLVlb0DjDimZdtkigrrSIe+utjiysavcrD7hzgZj0o7RghwWyaljdQoRnYKZGK9BEBOmSSaR5Eh6piPFsKpA8G6odOxcvyM/G3quRc5aorJfCcNZB69+wZ6krBtu+TDBmYQE4U6iGUqocGwCSeGS9ypvoERFamHY2Klc+HebXJbbyKUYDM6wZx5FTM2WHjsDIP5GtnBGCuMeOb1b/Cet78JgJk/GtVAHiuo07THFOIBraRAlEj2Gi9weniLREjWVerkbpomh2HaQfNwWGKwkiP0YqwkAZUwf3KfAI3fjp/jXGeAPzbJBDEXc/DI+BGe2bvDvcUstjkljjX+wuu/ga8LHvwzs5w+n/vW3XPbP4KZ/zEubvwFbn3hX7D7xX9AZf9jNFtP8Mn2L5MdaTh+zHPvfIrAMHns5VcoJHOcObuAjFL2e7E4pugPGOs53ps5TagP0NwMNxbP8Jnmj1BUY/7SYEBGpu9woz9lnRlOa/v0S2WWtj2+vPsGRjLAEAEtfcATvUf5/duPE6iEwijCviJIlODB+jucKt8kOxmSVCzaosijJ+DWROMEt1iaSKy3ezw2+wZBbKBnu9ieTUuVuRqfQQnolyuESvJIN2ZOOdzTXIxEMReE9O9m6N7K4k0dRvYYpKBuL6LHkreCR0lCm1PaNudL17nkX0MKhVyo8/3zMX/xVFqHc7p8h0KSnrPysM2Jzdu4wuagEDEX17nDKZKVCYXJJm8xA9aEv3TyM5BoqO0m+cEIBMTlhGSwg1ATjg2fwFQ6QThGaRprzRK5nMcwDtno/Tjbqx8gQRAkRzVIh/dzsHUBz17ELxxQiyuEkxRk7t6X5Z1jR8AwH5KgCPQ++WmGREhmFtPnCIXGoS1Y7FVRCqRI61Ge7j2DrQz2RJnCuIfrlaiuHDIO+zRCk4zvkbPHFFoPsKltMtF1YlPQ1EMuZ1K5mn/aRvqCf/Ev/xEnuuu4dkK1l7rhe1aOeKrx8J7FWpJwearxvrX0ApvBiNv2AhkJGQmWm85e/dTkJ3jj9U9wS1thks3zgwdfIDFrrJUFWhxhhhMecMcYLZ/JboBpSR64ZZB1U2lT0TnOuf5RwTIRM9OYRAgWxk2McMQ7xU0mkcXJzkvcbqSdR4NMKn/tiAr/9+wPUQqH/H96PY5NYzTApEOLiIIW8MDgMu/3pjhyypI4ZC1O/0ZrkiorLtS20TSD/FH9VCPoMIktVpd+EE23+N/p08vewdQAkWejcWTvzV2UUswako16yEIrgiSkOjU4NjzOM/fmOO5e4NDPYkc+ZhRjFebpiBRAyiRi6e6nyGXSzJpev0vn8EEALHMdbZISEofLx5kdtjmw0mzjmqzycvEiy6wjIgsyEwrCQxZmMaQgK0b8kPY5JoGGY8BAt7j3UAVyCZPbi5TclMQNEby7kWZTX72X4fkk9dW6k7A4zmB5iyAUrUIHTygOcxt8UL6Bg49EIaKA1c3rXK89wDeSC/i5Q/zCBq39k9gEDON0n2IZc6e0zFQKHvJ19rMpCdKqXiAut8n0BwxzebJKEoxMpAa6pqjpinx0F1oarqFhlQKUb7Kz8VEc14PE4J5hUjM2uHDqP7As7jIIDXpGahtH5jYTa8yM8NiXNoN+jb6fEkg5HAwpEEeKJi+eUJu3mWebA+c+ytt/nmacfk+tITFijUw0YSjyjITBQuZFAN5y7rKe/2nuZa+hITl56iVGxY+nz60J9NjnzlFPA+E30dEZijGiv8XQMdG0JlEgKSUDhDdDYB3wq7nfxoygOkjQlELEPSqZW6D5bAX3c0CWyJIgLJqjRTq5DT5STe/2O8bz/JMDg6/UqmhK8cz2G8QCfAMcchQMnyhMuBf6ePFJtvtQiWMuqW0SYHdSxMp42HHENDQJ3B7luTGGDHlXPwuA40dszBb5anyKwTS1Vwcn5onrNkY3YK1hoKIynu3z9ZkzPBG/SJDo3Lx5FrX5Cr+iScaBxlLsYwmfcjzmhByiVR7EHncxihFtLcP7eJmfdz/JjzQ3MLMx/aP5k9uVCzxYn1Aqt0gSwfIkTT48rr/OWbHJVBqMRxaJblJqX4JY42Q5lQePFkaE/30+ESD0EL94wM3BCiqOIJ8nlILlvRDPWaKnS1CKvpmek76/yP3DK0w20rMdlF7FTs4ghCJCZ5LVSMZV9qMcZ8QW+bZFkqRqrF7i8glnSnPcpNNNGORyfKX0MGbgcfpEEWfSo1+t0+qlsVo09nlBv4bSFIHZRTNPMhrlsUSeFXeTWAg+Q4hUimI4RGiLOHOSBTdmz6/gKkgScCsS4hBv0udP0/o2MPwTXtt//BoyUVxbGZL4dZoJFOYyfKOu0LWYdx45iZdZxLMt1KRDXp8ySmykStib1unsXiAQAxQJBZGyY8rOkMWis5BeoBNssiz2aftF/JJEH64jtBoq7iCI+IPae1nwD5kv9lGTkN0HHiTs9ngt2uIVEXNHJfze7rN81P95XnYfSL/3/Sv82POneP8f/heKg7t0V1fRTlX40qUVjGzM6Ls/ij8r+MzJj/A7z72H3XLa/alXyfH2udR5vDJvsWfVyemp0TFdRdFrIZbP42oukQjpJw6N8QGxLzGdANc2MEO4xD32mmlRuzQy9AsVsqUDtoo3eLB3Et9RPCgtdKb0J+/Fak2J3Fmy2S0c1wIsSDpIfYXDTINgaGLGY5458RDPzVgIwCwGOGJKYM6Dgkns8zdO/6+c9G7wHuP3SRRcKVxAKliMBbHukNW6KGuRoWPx2MF1TnzqMwzzc0zNgIdvhfSzGQaJjTeT7kGoCWbsMR85fZN2KYuRjTjeP5KITCos3UwdW5JNpbXZBJxkQDYoEuseZadDtJqyw8f2FeuGQSxjOgd57gkTeRQg5I9IgoduXGGYzbHpdFlwdaztHOXpgMUk7XRnbI2wYovd8lUSYppRmmWobXcwd6dkE9hIVijobcrZZeYeOsHkZPoeZqOYB66+zLF7d4gyFlbQB2Bfz5L1q8xlhtjxmASNtltl6FynHA2oizG7R/fBk5I78SlyskUM3L16P0EicYSkKPYo1zv8oXGRgWYQhQZhK8aOEn6oPuFnd36M80GRbtWgddQBtX6lz5snBZvj1yjNVZCGREgLzbRADZnIbSb2ZcqnvsRWfodx/g73zX2Gv9r9I/6avoMmprz+yMOU+30+9orLYmMFlTfQ/AK23mE27FC1iggBWvYQo5fj6xcfoxQc5554iB8fjHiWlOH+w+NPAlCWAdLK0+grCpMEFQ9BuwzAe3f/DLd9QT2okhlP0CaCnc48D9XfRhOKk4NbJBWTbXuOZ/V3GRsZTnCbF/rnMHyfh2cu8273fuZKr5JTCk8ZXFfp+7mdP41JSAlFRZncNXWWI0FmvEn/TpaDN4u4dhUzHCOljpRZRiHcMRNeDy9hRzF/58F/zV898ZsATJZSGfZu3yFKJCeLd1lI0p997Otf5ON/9Ns4uZBQF8w7i1yqFegt5DD9EXLhG9x76u+RKd+hdve78fs+VhgjrRjiCITCklfJ9WYpxjkSyyHRBKGRpRZbzJhfIr8Qs+Hfz9uX/iYkBkkSIXsn2LnynQCsGAJPm0AnBUGHtRaJLJMIm34uZJSNUCIm35G0Kw1W01gUIaFrCgylER0F7MP+cSoNm9PxHJtRFnvaww9OUyi1mcp9DDTyGMwPTyCVxqZ/mUlQI2pAZTrimrbIUMvwQP4W//rHP8TS/i713zskGE+pD6aMHY3u7dR+fyI6RAGtSHJxS+Fmqmhxly0tzaQ39QR5VAe7XWjgugXuNhawYp/3dF/HLujsVtJ7n/VDjHCP+1zJqB3zHm+C5u+R8wNCDcrmCveFkoLXY6+xyA9e3eLEKGaiS473IjT7aIZf6y3ahQoJgkGtAknCOMnyeuUUv1E5ww+MxnwwGKIU2IHiDi5V3SKXxDzgligbexgiZjNcwcyY7B9lEk/GCYWSTm4yxIk98mpC0biAWVrhP/m7jPQthBaQkyGJMnjjdJn/9AGd/O6UTjRhxlRs1AKMGHLhmKKaMsFkt9ok1nV2qbAw2QfdwjZrtPUJSktJqCQZUKteZd58FzWzS2+jjuMMcBZvc+CuY2NhJIry7pSdo868Hhm+nH+EU/Fd7NEyYW6f8nGXZbkAUmPPz3MmvsUNtQBSsplfJHexixxD+aBGLh6jHdUfvXtzyKL3CP/G9blg+tiuy7BcQmu1GEd1qmHMS5rPLxc8NgyPZhJwSmshBERKcmzzFomUvLv3LPP3TiHCDO3DVfKMcN1c2uGRCFAUwilnQo2DbApwNxc/QJkOs/uH+LZFZTRBC47GRUwMGnpCGPbp9XLo2RipKSZrTYaWhSbS778pcihgUX+elShivGOztZTWG4+MA2YHNS4qi66yaW01eP1KWodfkWlWcWhr6NLEjccY2Tpf5oP0Cx/kwblLmG6avRcLkjAJMJRPX5ZwHY22ShtAjcQuu8F7iYwpi1WBqfsIIx2hVLJTELowOJ7OL9xaAeDhg1MUpyEDxyTKniYONBwxpjqw0TPrhF6a3VJHkXFm2mZfKGq5a2wED/BWo8k4A7WRhxXm2SjeoCRSaeuP2jvUMfnsqX0SAc3eAKlgtgNxJ0AIqIkBrTAiYYFX7QJPT10E0PKyzPYPMTIRGQL80IbxPg+dKTPnHPD2+D7QE5wwYhx9H5uGop80QCg6hSKiqHO6O2HoWHTyku2ThwTS4APG53hefoh9J8OVYMjvE/K4paGvpvvx2+/+Hb6v/Wme/rWf46lXe3xX6Sa1eIpBzHviTTL5WSbxe5n3voM2ZbzyPNnQp1De525vmRd2j5HVfY4fHPKs8ybTvKDnFlkSGjJ20A9PstjcQaiEohtyII7qzJOITH0KQnGnvYzuuxSFx0ahyNKBw0hX/E5mlVqYJxc6qESn7I853rlKoJdIBjpfOdZjqlLV00ArooRADmeY29+jvFCmcqiQceforJWpPzkmGRpYXp2X9Au8WT7P8v46xZOLaJFPu1xj2e/yX25+F+O9Bttal56Y4DsdhMyz4Z2D8pRjpRArCVkjoZwEaCRIrU4phMyowyY5QBAlGn5ZIICZamrb/7SsbwPDP8EV+xHutTtMqgbdYkg2rFMtrzFbmePGkfEtZydomoFr2ESqQ04PGMc2BTGmpefY2ryPdW2GBA9HaSgUWFkc3SHvpw7wWHyXuhyikLTdKsXxW0itDiRMDh2+OFwilDqr2SG5aMzc2fvRshb/zfepIPj3muA35v4u/4f+H6GtSGJ4h4R/W/sJ/vazP8U/++6/QsssIE2P/BG7M6iV0ETCplxlfTZPcHTUqmGOD95KHcOXHIM1cZrCUUt/zdWoBy36qw+jhKIzmzqHrNdHuQrDiQmUBAUlNeSwOoOSOtNcEYTg9kyXmzNfJas03EghJzbz4jXC6Rn21EVAx85uY090BAkgmGafY8tZJPI0NBGhYp/Fo/aIZiFAcyLCeB6kwPCm/EH9vfzywg9i4dLyC/TNLNUgfVeDnElWdkGrM7Yt+naW7GhIr7iAJzs8dEdxcy6d2dWaXaRlFPA1QTXx2PZKeJFG1gyYHaf//6azyvydQRpsZY9qdZRP3eoilE6seVjZIXEdQktjdRd2dQ1DTHnzzmk2bQ1fSoRSaJhIEs5cW+eV8/fTze4x4ylu8QBqGnMquIAnFYN+OiupnO+yVbpBJZZoKqaTZFDeLLVYsuenIH8hD3omS3RyAV/XaPgh7XyGTBASNSpYw7Q4fMfMkfermLkRpaOh4vuTJpEXEOVKHNM6DK00azETRrSiFerGPeY4wL8T4EsLW5qcq3wNqSX8u+nHqFYHbBRmwI9xOjFCKMbJDfZPFhEIRCkNUAZxho2nV3h181WEWaB+4ZD6iT0WH/tdzPhFutGX+cL8p6kf/10uZ13c7C5ObZ2fbP8/PP1kjXA1z87CAlvzFe6/coe56y5RBXSvQla2sKMxs9k5QrtLlN1H9TPcWlxhtVfkDT7GUEp+0vwqAHedBU7JLVblHpsLaYD2N/7YoKL6aOFVRGzjJBbdwjWeGFwiN0mzYO+0zzNbTPdy0b8LpsZGc5UX30md3glu8Wavyd+v3iOnT/nG1kPkBhnKxTQbsnFUAL+RPUGAgZHZ4UBojHST45FBzt37lk0aZWfIjly0RGMvVCgFoya8HaS1xrN3nqJRSxuujP1XSfwOb96OGQZ5Zpw2dS1t7U90C11F2Ln0GWabp/nuuYjDZoq+5mu/i99bZuWlf0h17eO4s2kzHPGJKcnVz5EUwdKugDIp5A757wMPG5GDrnQS7S7H/3qeY5d2GecWuHXsr7E2HVGKs1huA8vf4dHgBHfrl4n3u8RzNQ6Cu6CZxMY8vZKil08Jqeq2R6sxz1xBpQGhITmwZToz00uD5dW9p/CrCWeieVpH9TwFYxGlIJk7ahhlQmXnGdaNNu3uPuNphXgmwtw+pGscZ6I5PDK8yqv3Pcnf/6m/i3Kh9q96VLoD3snbDLcTIhMez7TJhtm06/K+xmFplYNihaGaIVZwMWuixX1QCX0nT4Tg9uwq7+u9ysul+7nkbLJ3BAyLocBjm0cCnVosuH9QwuUqmTDgsKyhCYOTSlIa99hrLPDUS3/Ib37tkO1qhWPjmO/sfw8Au24XkgDXMIkMg/ta61hxRNcs8G/yCT0p+fjUZ0SaMY7EGjk9Q8Y8gRAa8+VU7tUNy2SrWQ4ZYGNQsYuUMj65yZBmkNq4onmO3a0v8inToRwOWN3N4ByN7yhO68hwBi0RbCQRZU3HK6csfyGckJUhE2XSLpRJoogNs8n56R20wiJCSLpRG10YoGB75n68lZAzj/4cXpJhkETktBbOYoeWv03JnuXh115HBJLtyTzP8xiFRPFm8TwLYh1ruMQobqOfc1nWjkhK/yi7cVQmMVFlzs7ewrjiMDftIYRFGRcd6BzU2Nv+GHkEPx28TGE0IihXiP112mYG1X6OzaCGEoqD/nvQrTqrMiU5ds0ZzjV0zDBmEl2kMZVYX/wp3MCmKNtofh6RGAyStEb3Y/uv4hk99psP8dKF7+awOkdGZpnttpCAUnD8TnofencL1HVFJ4K2yuJU02fqrTkgOnhHssbiJM80o7HUTT83eddhY2aOsT5hYA1Y6T7EI0mGBElXFGmPUjJ0QaQZtr5RxLQzuNEYa9Lk8/73MlIZ/tpDf4XgSOki5mF05DM6skyQlUwmlwC44PZZU0vY01mqS3fwRzrPD9IaxRPVVKG0/JVFjn/t/8bcSP93o5tmjAfZConRJAwNLM3l2EH68/Nbad3jsJGeqdnuIe8a8xzT3mQa19iyFukWY07spXuyW7zDeriKUIpHc1t8aO+DPN75CHuNo87GgAb4e2mMUxEDJqZCCkktXOCMEaOAa+YsUiVMpENW8wjCLCIYYX7pjxAipueX6NdL6IliVz+JISDx8+hOzGzUwSxodNrp/9ibnfLF44tcCK/QjA/5kvbdtBtTfunid1GNI/5e4PDJ1Q+yJuaYSodxpsnO4z/IldVZXlqs8ZsPPsg74qMcur/BwfQf81byvRS8T3BbnSaOYmKvQzHf4Z3ufbyY3EdGQG+QZS4cMMlJtvw5jqGhlCK3/zCW43OSW+Q3DHaS9F1Ooj5OLVVB3essUR8OcaIp9woLOIFGK9hkYI6oThcxYhPdLfORwy+B1Jg2T8COxYxxl9/KpwqQrm0yjQQDb54HOm+RmZ9jrhMgo9RXjXJFnNUsdlNQnMzxpjrPfnmGBzevoU3TfRsUyqxk2ry88Rj1aMJU+LTjQwKrQ0JEO3kQa9Ilv9Jg2Uup7Fo8AgyEdFh4LcGmyz3TQAcQgvhINWW/lfq3Py3r28DwT3CFExdnaYbDixYiLtHwbbKzV5itnGLtqBNgxZgi9XTA9diCnBEw8TQsK6QTZJCmxx+r9xKJLgYCo2ESiQQhFc4kDQ4q9oRyNmVq9idNavE95j6aGvfJgUNta5uN6hwnrQ7FZMSxuMbW2ft5KdPgOzGg1OHicI8Z8zWOjzfwuxbPJa/yTLDPVtXmm9Ei3VGC5vcom+ll7+rp/2vF81AVxECAIszkOTE+AcC5xQStv0pGj4iVQPcleYYcBqkRP3jyPCKJycVjkqlCtxMyk5R5W/OWEUqxvXCCe815HN/l9ugNirZHXxuQDQRhX3I8fAeky1vZ96R7rt+lOhFABAg2zQzOsVNERx0I43CMd5g6X6sYgIBgQyAT2GwOyI0H/KrzYa54J3l7cppACO4fpsbnK/n70USMbeRQApSI+Z1HPoHrNCj13iXrw2HOpmpNUHPz3M4dAwW5OOKt/iKamdAYekggQOfrhfvRIkHoW9j5FpBwn+zxTJI6JU0bEGZjlBBsN0wW9xOUEHhanzvHZ3AtwVjXqI6hXXaoDQc4k4CX73uAQT7NRG7IR7mhVjk/ynLDCuiXhtjC4OGcz+366xiySC1o006yuHGBWizwJqfwYpN58w6jr8VY1SKdnEOxPUABmSAkWWpgDfYZW0UOchmyYZH9YkLpqIvj/iTN0kbFCmfjQzR9gEwE84GDCOvUjDXud99EnwxxzRx2CKftr7I1znEtPseDJ23WC+kZ1vZTMzY9/DX68y+R717g6bNpdu6gUKD64ffTc3scdvvMPtJi7n0HONMmuUqNuq9zUI1I3jHY8Y8aJMQGejClfOcVVCk17EM7wrMtZn/+U0SF+AgYpsBsvrCMn9wiNseM3QKaE7I6sPE8h1+olDhltDGOan4eNW5xUm7SqjdIBJy76fHEKy304B6J5vFXjv1jQhmy1GuQHU8IpMbLnZQhnwQZLmXSALvfbHCndhw9CZhLtngmX+P0/OsE5LjaOcO/zv0lFqppY4gtPSGr+6ALQFExXuRlUiB+LNToF+dRR+1GdqoZZKTIaDl2wgS7LDAWJS/JdPRAffs8Mzc/lH6f4cu4b/1NGsP/QBQbGElCNZMCw+CoeVRipNnvDDXsL/8rZpfvAZD/bIatb/5ZlIiJREDhtRScGrtN9FGZqKKhrDQrdnxhDXk0DufkUTOoSV6imZLqkw5P7n+F3GSXK1GOjVEePc5Q0idYyuS12QGqt8+olKU9Tc+etObo5QK6hdQGVDsJ3uwMtglmzUBJyY4jAcHcYBWUoNK6BBJywsabXQGgqvn0+zNYx1OnfyZexHSbvOau4ZfquG6ZuAH6YZ9i5jixptBIeGp0l868Q/zhPvmijwQ+Pcgw3w650zDoJXlWRiuc25dIX7A+U2OzVGJgdRnGguN2gkChJwMiw+DTlYeZOjm+7+CP+bp9H8v6hFYREgm1yCRUe5RjyfePTQLpYnhtMkHAoJRBCsFpJMkwZJwrshFssf3yP2di2xybSEyOg0iQU5NC5/9Hz3JACJ64+S4KCOM1xtLlFyolqnHIUM/QTfLMqFTu13BSAmSu9BYKkEoRCJ1eLmDGrBPmquS1DtVeiw/spTV3+57LZ7mLp1nMtXs8e7mO23ojff/rZRp9i8nsIm0/JQ5XzFTFYk9jhKETRTGRZdJzJZ5mczHYQpZS4LYZXU9lawKmeZuxbLIz5+DuP5Ha7O6QYGiQqJh64TQLOzs48ZBcP+SrPEmoaRiZAEMG2KNlWrsj8rMDhD0BBVoMd0cVlGnjK0kz9y6GFmKZ92PfuIku5yl6XQwFvelx+qHF/150qFy9Qt6SREJHqTFv5Yts9L8Dp/Am4tSbJEGDXwq+j4pK78FNY5G5py6yKLpsNHK8GTzEMDogkSGBPsSOLcZxhmtxE52ET9z6OiN9h2K0hF6vMzEHGJmT5I9qO9cWliheS2WukSdpAnEiOMxmKK6mcsHJNAtaB3cxlTXW7lmMsul9bEudeKJzWKqznk+D5pXeo5wKUtB4aFSJuqktWDpSobTDAnrZZxpPsMMi5d6UQ1+gDcE/UhzqOcFhkIKJkZFnFOQo1TIoLeR1p0mCTXa0iJm9gde3OJASK/a5NU0Boi1PoId5lGEzxsM6Ij6H5dSe+UkOQw85487j+EUe2nBA6mhzF4ikwWz7kDivc1Km9cLxcB7PViy1IhIR0c7usKfmqake5bHH+OAUVT/H6EwqSwZIZutsd1PZZ1mO6C+mPuWEt4RaKPHiwyX+2/H3QixYGx5HCoiiHFqSoHV6mEMPTcSs5VeI9Ay3jYTH5g28PYmRiXmq9yZJzqDlCRpuwhfus2lbFZ7V/5gb7gO0kyyD6gprxTl+YP91akpjc7jCn3v0/+HPn/zH/IH5Ubbf85PcMk4zXYV87ynK7l9GeR0mr/0TXqr+Nooi4/g5hvtD6jMpgXOzdZIbudO0ZJ1+6DCNDMY5neuc4LSS+Cqg2nkSEo1HeZGplcMfpY3v9rxt4soe0aRK1VAs9PsQBvSdRUItYTzaZtFvsjCeY2SOefRGhWrYZTK/ROxMOYwWqNDltxab7IizbJXBcyXtMMNyZo9ppoyZKPSjOsxRrkjYG7H4zBQVFdmz7wcheer22yTX1wHo58v0rAqXrb/IstFBC0N6wT7ImLZ9G2GcRvY7ZJeaLE5SP1b2WwhZQBITfmCMFCF3rIiGk0GTCSKX4OoaSSHLn6b1bWD4J7jsSp6H/v6PsTY7JnTrNGJJbu4Ws7XztDWJL02qcgBaTCJiulmbvO4zDk3sso5SAmY2GKgSb2gbCATlp9Mi11CCMZWEUoIGjZm0w97+pEHW6VN5uoSQiskgz7GNm7QKEWVtyqp+SKYl+a2VxxEo3r/9Isncb6Lv6ThfOiosP7TRlhL+zN+rc6L5SX7Aeou/8lGT49HrlI0jYMgYH5N9e4laVSBscAV0GqvUQpNYwA+cjXEbqTzKjQwyboxuR3ibR/PulMdDh7fI4BMdjaqoTAIiaXJDnCQ/7rA1d5qNhTNUx/vESchpbREvegvzKNAtigJm5UVioaPpHWJjSN4VCG0BSNjXPR57co4kSq9CZ9AnaA9AgLLSn6m3U8cYljJk3D1cM8Pn1+f4fC6db/Vod8okVvSPxoJYVkp3Ti2d12qnMGPJ7OEVhpaGTHyO5zpkZ2e4kjmBHaZOoqoPMQsxjZZPIHWu2yu8taKzWYdkaOI4I6T0kIlJLkgDooJ2iJcHd1pgq2bR6Cm0WDGRPW6vpO+7LyXNrmJYzjO7s4sS8Nq5++kUUmAwEKf5qvMdnBkmrBljjMmARWnySDZmt3wVpeWp+20OVJ4YjazRJYo22ZnmmDev0nopwiznaecdjIlHwQ1wgghxfAGrf8AwO8NhIWVh180mTTkgG03Ym8zgjjJEuSJndveoqm2SqIAVXkxHd2hdTmkb+NUZfGlTl22ySYffFKnD/ciDc0wWU2AoDtP3NPnAIUr3Kd/8Pu7rpPWEby7lOT13Fku36L/8P4bI58d1onINexKixYL17Rwj5YBSjIP07Cx97hcZanmkSjh3d8jLj5whs98m+frvY3gVTLMHQjLLAtHR8OFN2eChyRArgYX1u3wml2VdM1kSacbvEe0ampUwNWPatQLxuVUmpTUECR99KY8nAppBldr2NrnJmJuzq+xOZpiOZ5Ca5GRjj2KvQ1K1uDt7kka4j+s5/O3RLSa1N6H4CLHS+MPwLAtHrd8HmsLP2xgCHiolOCcu8iIRK1aLnBLsV08hSCOxe/Wjrq7GLO1IUbmosd+LuatSBl2IHewgIhEmxiP/ElV9jlP5N2hk2wg9Qi245FyFa6fnqxP3ycYCbeYfk6m8Qd9+ljin0A5NTs5+kr0L/453tB2En955Y+ZRtHaMbiwivFUELs1rP4YZ99F1jye8HSRDxs3U0RpJg1ymyAOXf5G8tk4vlqBiVvM1Nsw9XrVPoU37HE6mJEdDifPOHIEecHvJIq+V0BOJnE8zg3ojzXgd2KkEqLL5ARrXfwwZF7H6Gn4xwbp4khAda3uN/vAkenmfiJDZ6SqRMWand5eoUMGsLhE1FULBGeGgZMSOWedDnW9yxttBnZzFfM4lCgQ/+lsmlTGEFHljcozTg9P87LvpHl5ZmaNv+Qz1txgngrxwqWUaEKZguneyjhkHPNF/m5anY0soSsWomGCFEY7bp69vkVMSX7+MFkXk3JhpsYifRFSEht1Lm6hcO3aG9XqaET3tGRzoERnb40xfw3JfZ63cB1KA5+sG9vQbJDLLZ3NZPCFpxH1eU6fIuVeIVcRMLZ1vWkv2ONSrmCJhd6TTywfM5+fxMlU2tnd55s4aP3UnBRRvja8we9S989b8HL/3nh0On07rjguF87SPL6M5S3iJZEfr8pB/kX4WjElILA0cf4IlE/bidFzGBf8ArbjEFJ9bznWSI3Clkh5TN83s9ScxWgL+Rsxoq4AQsGqnEsHiwT5TIz0Xr+eOsUwKoLTBLOHbKUm3OfcSucQhsbN8YfcUkZNj367w8NxrBEEDLj6D9AMqrkXB7xAc3bcfx+TsaoC8s012toQCbudP8qVpkVXzGvrsp9CztynnX+bXx4/RissoBRuySbB0nPP1IaOM5Bv9p9kOT6d1iUaIriR3kjJ34yoP57qURgN8sUPWr+Lqx5iYfYp7HtvH0y7T1x54ABlIYlfDzIUsrOc51jdRiYaRD1CJRHlV9GCD43o6TFxu24yPmoZNhjZKQmRa7GW2WXBzFP0azWmHgkpoJxmG2SpGElMnIEliQmcNzdnHi8fYUmNud58DX6APVTqqAlAxdI6A4VjLMQwKuJku3coVYpGQG50lNCZI0cXvWwy1HIVoyHaUkgzTjReJDq+BmaUvJ4Sdm7iGTm2gUCRMRRnNSpjrx/zEm/+QCA/hVMlrJ3CdGnOtA0r1kKK2j7CHzLc0DjJ5ZrsQGgOahqJtFWmKTRa3J+ha6ptfLaaEiBKC+NwKG7LJOLEpWy4sRozFhNOj41zeexIvo3Onlypc7KOQPHHTfT1+bB6/eZoThXvciU+ykTtLLOBhdKTromXgmc4bBJaBAJqdAM+okEtGPBm+xEvRe8CN2Jyc4tG9q5zd/AqRmvLevYjrdpVTk3U2WgbuwGW8nsYMxwcOvdJVhi/8AqXCNj8cXkETt5mN72fSnjCz0iXwM1jtIneyx2jX0wzwy7UGrZzFu9YZTiiNcdBGTzJ47ikeUy+xtqAzGt4jUQmteBOvdI/u4BjnZyIq7oBYKUqxxWbTRe8PebB3HjMxmGmZnD7wWC+dpFuGNxe+wc5Rg7q58gE/p/+v+HVgqLGwu4M6OUNLlgCYR6FFfUa5In57wFLlOgVtm1Z2EZnEnL59D/92qkYYFMrs6rNIodiXZcx4Sk9OyGJxq/EWQhZQkxz2bJ1ldwNHJdQm6wi9gVmPSI4dke2mx1yuiiYSjExEO+8Qf6vP85+O9W1g+Ce8lFLsDfdJgjozMsBZ1Knl6mhS59ApUaNLpKWsW5SV6DJhFFnML6fB9u2gwlnnXa7pHjuyi79/xKgLhT4VuJaJFIrKaiph3BktEDcT1r5yHascMR1mKI16vDg6TaA0ThXajEYjXkxmeWr0LrU3/wu5T99l48s1kjgNxqa9AroxoWEbyIwkIyIuzkZkDjsUbR/PLBBMt9himYlu07AhMyMRcUTiFMlqWZQTIzRBuJIaUD/RKE89ZFYxs5Vm7A7GXR7bTJm/2JMIR5EJFK35x4mVTiYYstWc4+7CMlI7JGNkWMktke9fZk9PA4uCsYRZ/iaaCihpqQHI+2WEk2Ytx6rHuVUTaaf7dri1SzyaILMKpTtMQofrg3TvLrhnGZm36VQaKCG4M5sCkwtdi36seK77UvpOzpuAZOSYPNzZRiQxK3sbXF4tI4AT+S75Wo3r2WPopFPaFmohGcel0k/naF1zjrFd/iNeP2Vj7SfY1hhNmyITEz00UShK2j4qFzCelCmdewgzhoU2tM0JHSsNtA91Qb0PUSHPzNYOw6bFKJvjIKOIREI+KNLR3oehYMMMMVRIY2YbXQJaSDc3ph604Miw5Z0dBjN7rMWzlPQ9wmEXFZVo59LzuNQZIAC1MoM1PMA1GuxVSun7TGaYzw4phQP2RrMM3TkQkqU7N8iZB8RRienkfQDcjA4pmx7lmkGgNFb0m7jZBr/lvA9bP2S24jB3rEA/kyfuaKAgnIVyL8TQGsz96hvoScTVZpFX117ggfkHKLzyP+Y7GtMGu+U6AigOLV7Vq4DAFD4TXyeWOo7fpyPKZHWfbg6qwyl3jx1DfOmP0Cc50D2sYg09MoiNlDy46ixxfpQjQdG88jy5SPEHeZsmPRr0eCi5xb3MDJu5TXqlJvLODq25Q2JZ5OzWPL/80vfwT2/8OHeKNtnxlGvN1AGOevfhaBM0OhzbuUlSNhmXy6wmd7ETi0n1EKUFnNzexdBBjmM+XfvObz2vl88QKsFz9Zh+/RRXiXkkvw908TJHszyBgTMEKZBmGhRPj8O93ZgxGaYiC2yhiQ4Tp4p0Glz2fpj/5YWfxY8NkIqtJ/8vcpZiMKMozo/ZPjeh5kRo9nmcB/85M8/+BYJ5Qawi1Nwd/NwOBy2byI9JgD+y19Phypxlqs5hyuvYicHx9iwPze2w4NoY8hZXrvVRcULmmgAzi1QJfeubPJvTeWjvqzTNJl+rvIXXchDASGjMTNOsUSmXBmFT85BKkCOSGtm5lPSKShb2eIqUR2MMhquUt58jzCU4bYlbiykslGjLKpnDTSL7HHGi4dtpULBWvkoul6o9qhfPETZTu7I82qdv5fla5VGe677CI/2raOUZKm7AVqmAOipqSoTglpvO4LJaPuNclrdPrJDom4ySe+hCwxEJ988+jB6sg1LEtskHOy/ytcoj5MLUdja1hO2KwD2aZ7ebfxnXPiCJNsj6IVJBv1Dn1tGYh2MdHS2OuL18nI2ZdH+OTwTbMgYnpjjWibUKY/VH6Xl0cmwVTEz3MqZaSiVzKkFHUWJMz9PpBYfUMpLl9/8z5NRiO5OCu2s9i9BQLDWWefFqjgXrPXxk7ifQj8YKJXNzrBXn0ZOIrXiGQS7iK5GLQFEwV7CdWmIcvQABAABJREFUBhk3BbKvZ29wzl3lsJnHHKYZqQX3ECkU1+06M1GHrDdFlJbZNg4QNe1bdyIJhnj9CiqBvVEV2w2xkgyj9RxO08PWTbCL5DojvnLmIQrGgG8UzrOi7kGs4XVNGOW50T1BPPsyi8omcRymMguGiaMrzlTuYJSeJn74LMrQabgDiuGAWAh+BMWfxcb37yKUwj6+wG6c54vV9zFPjx+2fx9kghHc5b7y71EWLl9Xc8RxCpq+fi3iiVp61m7XM0xJbfCWGZEIxTXKJEgeWEyBsAjTJnVRkGdsDijdHfDuhVRyuVdvQPM8SU/DLIT03q3xvp5NLBVdO0FNC5yyLuN5HjNxSjiFQ4eWYdLNaIxvOhwcbyDjNkOzy6nBOWyGyMkhZ5WkEzuMzSJZFBkBsd9n9rFfQc+a+PGYjIDzex5tXyCOMoZCg6CvGIZHwFDP0neLvOB1SOQI5Z8nO8mTc0ZIGSOCBgO9QElzCXQNBXjDXdwX/xWOVSF0O2jtDQaORXWpgl1NGMsGmpmgjw8IpU9hOEYYDpPKGXy7yuLBPgdmAQRopTWWD0PyrqLgaljWmBN2QMvKMxe3mW35lCopIfmWMU+3XGacz+MuNdmtzjCSBcqmixkNue1scspd4mvbT3Fw5WOMu0fN4czU7qjBUdOpjT0WGgYLmV32kwb/delRZpXAeDfBDvrgWDw+fIdYSirJhKCbEhXvE1/k2PaIXXMO48YAqRQ/fO8L2EHEIHiH9x2GWLHiiclbIGD35W3u63wc3auwufwNuqVfRHou0ZxgwR1ymH2eksqyJGo4+j0Oe7NcCHOE0uSwVAEUu14B+hLfKFIXgu5RHfH+4WNURJdKqY+7oPEHW/8Gr7RHbA3YHRzj5PEcZjjClxpV4XG3pqPFipOHFewk4ul3q7TsPIPaMoeFBht4vG5uEcc6J6w7rJsdjFyI6Bt8/PDrWOdPs+GnhM99uSEi7jLKFfA7fXKtOzT4IttVh+ZwTGhn8fc6GKZDYNq0zZQU6yRl9NilbwtqSZ5bzXdQKiYIjuPoRbKxy9+PX2TVXUfqizjzAnv3gKkQtLUps8XU1+h2zKeeyXHroWX+NK1vA8M/4dVze4SJT+I3WK3eQM+fQJc6tVyNLceiRo+jkSjkjjpDjUOTE8fLJFmdu6MzPFB5mYpyecG4hj+QmEpnIiIMNya0UkeomgsYGuxMZ4lmoPvNG9hlF79/VH+0Ns+bySlOFdp8VU1xE4P3Zb+OSBTqikQ7qXFYTlv5tt00iFLTDeZm0yBiMpiQ6cWULZ9pvkk22WGLZTwlaVgKuynwE8lSf4RwqiQqlbBoZ5r4R50Ms4GPYUcc297AMqskvT9CH6YSosjTULYiAa6a340e5cgpl83ZeVzbYZzc5L7Z+7CLeTQSNo6cYS4+i9CnPBb/Gg/2026ZZfUBOJp/VhIdpBAYpRT0+psbyNDHzAcYmqI/bvBuJb3Ui9NlKm6HRGq8culp7s4fQ6qYY6MMQxVQ+EYqVXOMPSKzysDJ8MjuJsXBXbJexG6hjNSgXoiYKzrcyKaBkm9J6tohxzNdpAJTRVzPaCQk+EsPYx3GmNYUJV1kbCIjm0R6lPQOjjlhPCmhVlLm9+JOzHZ+woFzgIyhZwlqXkI2TCh1ewwXK1jKw8Vix+yyOkk4OzoaFSFSiY84eYOecpiqhBuzV2j4rW+d1+aojiJirZQGFDP2m4zfzeOZOn6zzFw/fa/JQg1rcEASNekW0kyNF80y7wwpRn32Jw0m2gzSTxg695HYY/QoQ7FVxdMmvHIs7RR5XGykXRL1dTYufoRheIxj01uQJJxc0LmTm8XvG2hHs+2WtqeMPuChbr1MOZgQZHN88c7zPFa6j1NXk289h+E2eC2fZomqvTq3GumZzsgJXpThTtJkpGw84eDoEb/xnOT09Q0uP3CJqFBA7PWPNqRI0t8gqgSQaGzZc8z0qhxKl46mkwkld02Tmj3gfeIys/S4m0nvYrdWRfoB5uYhgfMA//nZ7+HXXcFvHbboVSpkJmPWjmol68XzpNBNcXp0CzQJmuAil9Hys/SbN9DDPMcuv8RpNpidDvnazOPfygTKrCQrFY+UE95ohyjg7P4MmrmPIUsczi0zyi5gehOkZTKVTfIafOpdj8xRZ/6WM4cdrZPINtvZtBnHm7cCpG5jyjSQKV77bgoGtJcVqx/f4kBJlg8XyDzwt9CcJkJIvJUShhvQqxpYI8lT9m8ippBIwVuTGwgFZCtsl5ax5FUUNg/nnuDUzsfQvAV0eYdr/Sytr76Dc10RHYFyL9yjqAvmVh8nJuFa/U2Wd9NgeLcqqY5TgkeaqYxMoKh0oFWdYcZRxAqmjonsBZxwU7sTH+2fX0ywhhpeNUEIwbiyQCU4xKyUabeXCYtp04qX7H0o5NGHXUQYEi6koLt25TJ7Ro3P1N+LUPDx9vOE0xZmqLicu0TPMUmE4L7tFvmOh5aERC3J2uwxNuaXuTvbRSKxNA1TwAPzj1GS42/VXn7/4R/zucLTRDmNfiRoKcmdmqQ6jImkZKYfMC7dRHh9mhzNiM3Ocr2e7t2SspkdbbMxt8StCw9iBQF1X7GRSIKsxji0mBkHDO0CoQix/AE7VhtBQtF3qMc6BvB6fJpH5E2mkcGIPezhCoWdfTKhx6F91PjEK5L4Ve57o8aZ6Cc4V3qCzeldtidfJ1Qa2eYMd0rzzE7bkKR2ue8PMUWMTGw0JXHGKaV22dhAIhHzD1DppHdyNUyz81kRMqcdMAlMtPwsV7K3qD/0IKVyeqdIIjrXHsQMvpMpDnLYIqMXcYc6hYURk+o1wuoyxd6Q7UqDSq3Du/kLnIxuYoznGAUD2o1jvH7wMLnsASvF/4KSOmExDS4XymlmLXPqaXAsogdPUevdoXKETR8ni7QEbN1CmTprYoWvhCep6AEf3fp9al6awZHJiKaa8j36S/SxeDuaZVYOeeEtl+PFMnqwyc1VRaKld3BL19mKi/hozMs+5DSUEGSn/4MYm5h9amtd1mspubmbmAznTiO6AjMXErsa0c0SXtFFLwSMA4d72oMoBDfe9+eQscSzHZIbJpfPlxF3dd44eZyenkrsZjofIHPCRHl9zgmDPlkGZLA1j8RSRPkD9EyXWDxComISFXDer5Mg8LsKXyn0nMA/VEyjEYaWRQnBcPMM7UhHxMdp9ipH+5wCVYOHGBkF5ubT3w10G+VkUPU5NKEzc+VFzChkmMnj/G/fSXbVYmjMIyQE1jbXa89THSpQCQNl49p1ZjuHrMclXN1C5rexQ3j8ZqqKquRbrNhZptJhta9IzBx2OQ9KkBUhodIZVkpc3R4wKhQIjAIl02PSuscdZ4uFuM7Qq/BK6zzWMCWyT4j0bqrDlOQw9rrMVDUMPWY+t8tOrkJOeNjlbVQuxDc1ZtQhK/4my9kuB+0Bz6nX+WD4BRZ2PdrDHNqhx0+Zn6aZnWIHMdfdDexY8Ewr4j2DNzjbqPDQKzNUtAa7+4vI3D2c2wolBN9sPArA28UhYzzuLznIeMz6uMBiXMASUzbjBlnDZ3LoQFdjRWgIIegkB4RSMVq7RKQ0HtbvET09jxuPqK2kMcdWf5Xjp6vI6YipaVKSLtv5IoGuiActcls76JHgjxrvo65N6ZbOcL9pcb24Rmua5cz/y95/RlmWXfed4O9cb5634SMyItKbyqzKsigUAIIEQQB0ICE6URIFUpSjhuISe1qiNN1yQ7VGGk2rW64lsSVSogUpkhCNSBC+YMtXpbfh/fPm+jMfzqvMKkJaa/oTxVk4X6oyXrwb9567z977v81/Z9cY1W4hBMRHDmfMNcqXLnG7pRM7OucqLbT0iH6uQLy7j79zizujQ7YrOnMHGrsnTzLuj/D8Ik4q6VoFrh/L0ZZlrDAmskxqWYFMj8i0OyQcx7qlYxZzHOyrVgfNmMZfsrDXd7lvGkgBM5OZxkKD6bjAG1tv8MdpfR0Y/hGv3b6qedeDOnMzL6DllIM/lZ/ipgFF+ghDvaacoRz3oeZzasYlK1rs9xaQluQ75KcYEXGYjShJj64uyYcjJlwAjCtzlPIa+6MqSUNSDVt4tTH6KEWWdayDkGv1ZyiYIXeNDSqFBK1+h5ln2ix90yF7J96DbSiDu4ciXUh6d1mdU5m3u2u3yQ0FZXNE3ynhaCM2UY3BdVviNDXCTIBdQPMqyJ6a5+TN67TjJobI0GVGaRxQHRwQuT+CJn3W55TDlYQaupWR6gb3byzieQVqg9GDfcyi21yYuYA1qeWuLsVESOy+okfX7ANSR4GWfNJASmVUFlz1M7+hyiGs7jYiDvEKI/RsRLU8i5sqQzDSJB84UJGgL126QK9cZyZsoQMDY4h9bUgmBR+M77BTq9FzbZrtNeoHLzM2wYlhqpoS52tMu3DPV/sTGYKG3eeY0SYylKP3ujVmvP1d1C+/k+HQQwhIzRBDmpD5pEaAMWEq7YVl+o5PYhqc2s3o6Brb/jbFQIFf30yYXlNyNjh1hqbYZSBzbFgbrAxiLrWG7JlHmPRJzAiyO/S8kyDg+tQbVKMumswopoJy38K/8wYv9KaJMKjkP8/a9i0yK0d/oYkxKQFyf/tTaGmM3q0xcixiLUILp5jxepSjDsPMZWSXyPVT7qx+F11T0MyGlEObvrXHxoJNb+48MxO+0hwhv6SfBmny9Pp1tHs7HJ8zuF+YJuwZOKGBHdpUOimjKqSHN6hIQTWp0Q76RP/lCtZIkqbqLFmjOq83p5ACamGNPU/1F+atLsMsx2fmnuTfNP8CfemhiZDnzwjSuSLlfo9X3vEOtMncNNHIEW9+laQyQoyq5PIBpzsa4/YdfvbydyLTAoe6zov6FL8fX0KTGWveLN88eB/jGSVLK1sxkfcolgMfn7vAr8+ew4vGuGHIvlfFAkrLZ0FXsn0ut4aQCuSesq5i+g2GlTewrGe58oP/K8ftQ+KDPkvRDkIlFEhzJs/VUywNXrwbU0NwPK4TDTsIrUzno7u88u3vpjTQQPqMpEPJFbx8K+bbn/WoFDTWjRkMbZtI2+Wa3iRIJK/ejnlkZhuhWQgBYuM4zbtlhh0N7eoJegiWwrNgPiyl0U8uoKWS/KBHbTjkTPnT6KMMAfxATg0NfmnmLq96u2ioPk5TmNjDWQQaiX8b7dwM2X/ZQYshnFYBM2c0JJExmlvmVe8mU94GxzfWiGyX6ycMAnx0mdGSNczJHLrSTsJuY46mlbAemqSaRtzKePpQVRcceAKJJHHVfgdV5cBF88sUGRDtd9jfXqC79F/YO/kf6KSArmMd7dJ/9Q5paY60CLlbt9mwZhDAv577bhaDHWodRVPfMc5QHoesrZyl6zk8/vp1Tr/+BslYZ79QI7Isri8XWQqm6SQZQoArMlbyCjiUww6Xele5N4gYma/x07surVRnp6KGZcd+Db/XQSQxzjBgwofAi/4cK+V7jGTGCXRmBhvs1qa4t3SCqa7K/G9kBiOtBAge2x4SFL6PjtVjrPfpWl8gsk+jZz2OKdPEv0vfR184PFHbRJfX0YXJ9C/PUU9adPQGmmlQxean1/4Sj65dQBoxNfMneXn8Eo4+ZKTlyRfz3CnOUQiGmLqBhotlDbHcmCATlBMfI/HRRMYw1tg296kWL1HuqMySbSod5IuIkreB0GYRms41/x6z5Tmax089tBvhmM3uMZCQ9fdRBcSCfH1Mf+rLxLVjFPsDhMy4Yi+yWVlgUazh9Y8RjfbYP77CD4UvITKJMZmN2q/PkyBYbLzM4WAVzVVBlOSZ83jdHWYSJXtrWUSwKtBfusHGxUv88xczHFI+srCDnQS4wcO+pGqaMUXEcW2fN+QcTdHnaCC4uQHF9BZbeRf3KfXcWZbj9XQaECy7bYbDmGyuztRwTNdWWdmh3cUOdTqGjQR6ts/WxWMYXQcrH0POAgRzeyl1XXLV6LLtK3mTYReROQyLOfyXNKw7ApEJXlhcZdvfpBSUKPSa5M44RFGPM8IAIWhLD0+E/F7xNnvVffq730zUUcGCcTqgotcRUpJ2IdDAzAvGexky6+IJh2fNezD2OFl+HaTKzEkyCscU+dPLgSAVOiempkEIQtNAaDqGULr9wI4RwLA4j1UW+PMao8kM05nxmFvV38LIQEYDWokk8mrYcURbFhiHNrmpq0gkl2+HpFpGvrKNYytgXT2ICUpTWEUdPXNpuGNqnUNeKp/kteKxiazZ5IyIaG+dO9YmhtB5xBrwW/E0ZpwgEPgMSKXAHKjAttnuU8zptHrz/M0n/zHvXfg0t7D5mVzMi3+jxtpfGPPZZ6r8feuv8pff+f/in73nJ/goP42+YdPKSoxvhmh5gz/Pb1KZLeJHEdeCLtIa87ePtrnQzvHU5iMIKfnkzn/kwFrGEAlaH4KFBtets3y0eobb8TmuGBuYzm0ArocCgaBUS7k1nqdAwGjfIezanJNKR8pln7AiWEhy3AlOcFm7St9TwQuv2EWkJu1hiUZZwxj06Do+JTEmSWqsNUccDG6j90d85dSAQK+TExF6McdqvMqyIXgjGzGv3WcqpwBa9yiH0UjQ5qbZ2JfYywkzVoqetujlSkT7Lbp3trmTWyQxNBb3YKv+GGNDxzMtGkHG0Hb5/ZcvEmcOeqTO08gcUk8qdPOvIbQinVd7+PMN0jACNIRWxj9mYx/ucsdUZ3a6fIxMU/5XTQjef/n9/HFaXweGf8Rrt6cc9mrQJDd1FS2vgFYz1+TKZBh30VeHqTDJGOJXWfTAqpgkscW6bDAvbnIxVUq2lPlEpiQfjzFdSWraxLkqszWdceIwxmHK38GpTKx5LqM53iO58DSJ1Dhvvcz7Hnd5w5cUF8a41ZjfnNokGSgQNSwpivSodYczc2eItIjdO3exyMjrAUeJOlCH+hKggKHb1IikRNh5hFtGbq9BlqEZgr7WxNFjhIDpvQDDTWnsBJzY+QaW+sqopqFg3xf0q6cIDwWV5TLVvlKeyBQz3ubc1DnMST/bamHEjp6iZyZOZNH2DHZLeczExnd7WLIEwIw3GXi+oO7V1TtoSYJbC0CmFJbPcbp7j0CzWNdjvnfvPMiYQrqBISTHQhVxH+kjkIKRnmO+oZMbtogNMIM9Gocv88KKh5VlnGkMCPM1dAHVgsueWwcBOVJmsiEjxyQUJkbjNEn/AkltlisTFrjMDhCZjZ55pHpA6qvn78cloiBmPFVhYRcOdQM3NFjeV6FpUUiZXttmbFuIR04xpffpyCob1i6zI8mjrYB79gZz4w5edReBpD6nFJmOhq57TEddZlKNLL4HSN5IpzmyZzkh9gmcfYbLp1grTDLJhk7u02oYe9QGhGBgtckF02iWQWUyS6wrHU7u7TN78J8Ya4KVQKeaaYxFynpnncOTz6JP+oFC6xifuy9BJLzv5l301++w2DRYL0xBJli647HSXyIqNjF+/wWQkqrjkQ3nadpFcp/9KkdekZ6UZKlOoufoW4JRsUA9tMiSMjYhvhvQI8e58wHvfd8iPXKEQlGKh3/1e5m/d5+7+TzGZAREUeuQbL1AVGyTjCqcFiZOBo7X4sJ3PskgbXKg68wZL9EyStyQ86w5M5QKy8yVjtN3dU5sQWSfRVhKHQsy8hNG0r6dYwaNbMFDr6j+yvrUiJmjHYrxkJrWwkhD0FLM4jMMp0+Qe/odHFLir9341yS2Qoapb/EN9ZQklbx2O+ZJxyBnuKThEUJo7GycoX76FzFTDSFVJrtnSso5wfufdFho6NwMG1h2SEl2WbMafPxqyjCQXKi+hpg4v0N9l3JapWNC7wvqbEznl9+m87JzKtvsb0fke+r9WmGGyHucel1l2A7eO81V6w6ZLAEREQEpSv/1y2ucuLjBvH6csTUmOqmMcbOvs28ocPC7pc8zZyacX7/HvZkF5nOnGBXL5Ed99kKN2QlxUaUl2K3P0DATbo6Vw661Q5q980hg3dEUy22mgO24qlDVqKbev3nvDsODAl1nl87iJ8gNdPRhD1Oz6b96B2lPkzQy5MGIO84KjeiI/3XhT5IhaPbGdIoOvLaFnWTsPXWOz595hP1albPX1OzFECUHY2+F1VsGe5FyuvRwkwvVaew05Pmv/gCfqD7DyPoqX9HaTBsa453veMBMWpI+xCE3fJW5NyKN/SKcTbss/IuPMUgHHEejNtojNi1uei5zfQVydskIS6pSZLavoaX7HBQXySU5EtEh8t5JTIuliSm5JWf5xewSM26f484n1LudWgKgHXmULZ+fJceppM7ryReJPnIfR7+G7TvkzIjIqxIaPj3bJxUaS1VIwhz12ghnQWOUSWazCplWIZMaXlzk+fyrzBonsaSOkcVErpL5J7M+Fa2Hb6nKgDvOBk19huqlkw9kUWY9dvZirEigpQmxEaMbOrWNMf36S8jaLLkgohJ1+VzpcUpaF9cYY/cX0Ntb/Fj6z3m2/yXah3WOGhIhJbbIsHNjpnJ7RM4zD/5W8o4JU+bBED1LuJl0COZCOvfa/K25b0Omkm/1t7BFiu5YyAC8TMlbJUsJOid53NzEkwF3syqOiPnMKwHzxh5S6KzPKvnNjaYUm6guyXsp0SAkO7HAdCfmMKcCHpHZ58rKBZw4ItM0pBB0nlvGSY6h6ZJiroyXxtimiaPDdpLw8uxV0DTGO4doGPRzFew7Gu5XNKQOtxt1Wk6LhZ7yYXJnHI7MhNM8LN8tJQ4Iwad7CZ3gPUQtZa+DdIDQTC62U7QehICRh2AzRiZt+tMNVvQWfdPEX7nL9QlrqD/YJCsNSAKdo2QyT/VVg2JxitAQaEmMVlZ+0aGuhDRcOI0QAm9eI8gU2F3oSaZbaq8jI6aTSvS8ChbnuwPud+tUG7cxylsYGURWD1na5lCo7PMg3ia1PIyCQI9dTgx20ZFs1Wfp4TKQFv9mpLJvxfYB+7HSjR8srZGgM2duUXNmsbQWw8TCkCAFmMOAoi9YPzrOv3ztz7A0yPMny1cZRhX+7hd+ks/+p/ewdDuie7DIF4IP8fFbH+KXb3w7hQ2Lf5z9CQgyli5amCKF2TpeHJNGkiB3C2urxFH8UyT1jI+ln6cd7bF6/jKpNEimQJ6uggZxdBytr3Pb2WNQu4Ic19mXqmTdXaqA0LCzjCzWabeKXMpikizGfWIGMSc4rml8ZfgkNdHGMPcpX1jFyB3g9JaY8rpk4wg9jum7eSyRYcRF7s0ovXdUgxv1PA1tgBBQb+bYGc7wZxtDdgcmupBcdhX5V9C1CIsG24cpSQa1lRbp0MJIWkSmQ3cQc3U3z9asCsgvtFsE7UXGloGbJjQCycj2GIwbIARaovTnfXeTubDJrWlVTnrYTyl6yt7pWh4hVKuUOzzktplHExrNXBN9YhMtupjGHy+o9cfrbv//cG33dpCpzZxuYOQdNEtFt5r5JrcnwlSxVd143laKy8ZDE7A6r9LxrwWrCCE5l8xzIplmNZsiFiH5aEjOTQnKcyAEx2eVgt4b1smXdh/QUB+mFTQk2t17vBSv8kHty3zjox5HNVVydV93qcUQGJP5T40qg0EFGaxTckvEVox2NHrASNp5k3XMUAfwzVLSKAPNcBCaAe09tFuqzCssNB8Me68fxeg+LG7e4czaTRquSskj4eeqOf6O5RDpATOXS5TGCmDo0QE1cw7f8jELKpI4Y/TZthVA9eIKO36BnueTD6vYdR0hLEWmMulF9BaPkYQaFuqa7gQ0a7lFmqLHWPP4pFbBTxzKQYuBKBCgcXyUMpYJeq9HP5dj5FWxBkc0nlL0/gPXxI76bFQ9EqGzbO0QTQzOopepPsN4Uu4HxFJw3T/GR5/4AJqA9UPBl+aU8dGcHkiBiUWqB8T5lD45Us0lHIaEC01qh4Ix8L57F5nrKsVmuEWa2zvsVsv4C02m7IwjbZ4NexcNjUKaY8Pew01CZht36GZz1Krn0ISGlmmElsG37X+WbxoLkvguQ89Ftwx20ioldjjZPo0dlrhfmiLTNIbVMrc/qIzgZ402f+b53yI0e9hJjn8qPoo5pRRmP4DqMKImfhuA6d4FTASbepkkS3i9uUgH9T6HzcfY2M6RL+6Tc0yM1+9iGoLhpCzMXOuSbx8QlKaxfuuLJOeXyS97tDKT997+Xh65H7Dz9DT9TEBQ4dDpYIU3aVemKY4jZFTCoYNVKZJiwPZttINdEkyOxJBmR6A/c5HmmRlAkpSeBilYbV1D6hB7BwyDClObytHgRx7jzKqJNzY50jUuW19GkPKb6TPcd2fYW9Y50Wpyc1ZwZltDCIPEUuVxeRGSGyk5HOAyoyVIW2BUFLGUU+rw3k/9Ot/9xi+o8xisYQ2mkdUlAOanlGMsV5+jIvpgCOb8hFVfcm0tZhxJLldNfM0AoUqWNjbPkbWUPtGtk5R0uCczPvwuD9sUzDd0Xh82JnIq6Xk1PnMtQdfgdP55NE85X4G9Ty1rEpuCu0KVVk/nVAnnm+to9QkyTWBuaaSHJlGsYSUZlGvoBzFSCB57x7fwXR/4fkJ5HkvcYGC0ODA30MUun6qcoRl/mVJd487BiwQVteeVnuS6c4+hCPhS/jWm0Znb2eTK4hJneY5oZoZ854jC/g71whw2JrmxwWh6CkeT3BrblETMmRB0TjM0MgJdFePqkSA1JVFB6al+WVUi1LJDNNNke+s0+70mWehgHe1h5k8Sbh4SBQWSpiQaGNx2j/Hu9gtc7r5GjEDPYOQVyN9QGY/R5VXG5hKfe9dzbDVqDC0HLThCS4fY8hTTGxJ5s6Tk4nc/RfHffpL3HX6WSjrg12tPkaa3+X4/5q80hzzVTNlWcRpmxgIp4My1F9EsHWMYsV0R/Lnf/BiimdAJ15lHx+tPIv1CsDhICPWAMZB/92UEklxgosdvsFc+jiEN8ukKjjhDpAcUhALkO/aIF3oVtkYFavYBQw6Q9ROM06foH2lUux4vxbt8HwOSHz6LrCvZyJd0ckZE1pxmoz0hAnOKFMc9stTH94dYyz6RhHpcJTWKTK3qzNsuX8i/goGB2TxPLhoSuiVsaXLe0PHjGo4/TZyN2DWP0F+sY65WMIUCUSkd+p0B5jDE1lyCZEDx3Apys4E0x3CsgxMnFAdt7hcXWJoQzzi9RYrDe5AzeOlP/CN+aedD6HafuVJH7XnjHnGmUz//9AO5z5ZniEtlGq1timmf+yKk3b3L33rqh+lh8119m9m6zbA1pHhmmc5oyFysAielVCcMO1gi5bnhV+lKl5IY8ZVrEcu2RGQj3ohcJBm7w3OA4NlVQeY7yNGY9MQ8zd2AA19V4AhzzBfPXyIfjBGhsts7DQ/fehyAarbH43cjZEPZkFr4KPcLa2zOpYw2D9CETjBpx/Be0BksOIhUOegr7YsYOXAaggM3pYRGccLKfKx6n28PL+MjWNu8QuCpYM8oGSCAD27HWH1FPmPkBMFuyrhWopvzWUumuUsD2xuysKPKR6vtWyRGh6BtMR5O5iFPhyyKE4QGaOMuYuYiYyLs1hahoWGdVRljb1YjnGQeHTPlO5+fjKpYPk8G5ItK380c7LHbqKHrGaXma+r39RFm9RY7Yhozk9wy1pAyxcwJ9MSjuaYA+Befe4Qls0Op22J/wno9HY9oD13iLOQRkfBo7TUeKV5hzj+BqXUZJjY0K2SGgRFFFHyNIx1W9x4jf/cZ5oyQfzJ7g8u71/n3/nfy1zd/kum7AZ9wv4v21gf4L2vvRaYOvxK+k2zW42xFgdBkMmOyEvT4fLih5jtqn+S3n0i4O5xUQkQGQb9OeC4jWbSozFdY7iv2dLMqGJdvUtq7RHMcq1mzxSOOl24zGKqgU+uoxJLU6MVHVM4uENcF5Uzjxe7jJBgUozVO//h3k3j7ON0V5mYSOoeT+7NHRCIiF+fZrgU0Zi/xqUf2iaMpGtqAsWlxsmlyEM6S0+EDKvbMaXdMmOikoU43s2nd38U3hzSnDmjfyuNM2pYOzAI3+zXuLc2zNNpkRf4BeqhKZt1ej3ooGVkOaW4yc1Do6EnCdfcuU1GVm6UeIl1jlBWpDZUPJ7QywhigWQI7OuSWaVL36xi6geYpG2F6MaPth+04fxzW14HhH/FaO9ghixosldcelJECTBWmWDdMJFDTutgnlnFyGslYoxgqJXtpVkMagq8OFX10RsxzyRlmsgoBOvloRMEcE1QUwGumKsqzO2ogj0WYXkrmGnSHRULdYedLt/gV+W5mtCOm2rfwps+waej8RsHikU1BMMk+OJU8B9E0hugi4z5mziQ3kBRtZWCifEqLOrHmY2mSogFWWRC9RdqycQvjBdWDIednH/zcDTNqhYTj969ROtrH01X5n25lzNgJnzT2+dXH/hcOxi9Tj44wkxgjuUs62YM3M4ayP8Rpqj/oxUUcM0AzO+THNt24ToQkEwIzVQDQ8KfJYg1dRJPrJCB0NHeOxLPwsoQ7ok4/lZzvGcS2IudYaXt0Uom7tcPO9DRRrordP+TC+xVtf8+xSITAjH023Fnc8RG3x2WklCx5klfdVZwwIxEwtDRyQczN4nFKnsVCU+f2VsL+VB6Zgem1H+6fHpDmYzbkDFpmEw0j4hPz6Klg/gBufOgbCLQRdixZ3pjFTBL2y0W8mTrTvk2sV1m3dh/KYeUIyxoyV9rkxc5jCCHI23kC06HnRRhpCy0bI9M99nIl8o5gvesjkFxy1ih0LpAbSfZOrbDbbOBM2GmHI4EW14j1CD8scVn+AU8ffAZNpgz7IebgkPaEvnttUlp7gxxZVOHq+JDN8kW1j7UC4ajG6nxMem4Z/fU7SCmR1hQSyPYCnNYWw6CIfnOD+ANPk5vX6CD5cO8MtlXmC6fGvBpXKGx8I7e4x6rTYrPYROt20MdlpNnCnFXvVbZCkn1VxnrP6jM/sFQ/11/+MNXDI8bpCCMsQjEjXSwrSuusRHk8xa6Xki6Wscoax/opgaaxKLssW9f5zexpds0q+zM6+9Yh1+cy6q2Emf4Wum2SFwEVMSQ3GJAh6GcmM+ZkPElROXy60aF5tM1q5xUA0myT/O5TpGXlxM03FMC76p7j+7PfJ5n1ee+Uuv2XbsaYBlxYMHA1sPIOUia44yL7ex6aWUQzmsyZGkNL8p5LyoFebBrcS5sP5KXRqHKwEbI6m+DqI/S8CuAkxSFVobJxV+dBk1Ar1Xnr+vy4TK/pYqxrrG2VuXegEIypTxPH98nqeTANRMVgkK1gaVcoJ1PUsikscZOfr/xpZOZycPxjrI2vsfaKyq7l+xH/dO4/8FdWfhYpEuZ2ahhRyJ25RTacGUw9Ry4Y8vgrn+fS8nfwHb3LpIaF3SiTSbg1tli2In4Am4SQwO5TiOGur2GOBEElfZODiVGuTqqbzLh9EsNhc/MsN155H0JmmEkKUs367F0fkTQkMtBoJXk+vP8JfvGN/5FkErSqHHWp9YYElQL2coWxXSczTN5YnuczJ6fJdMHS5iZCW0EgKF5VzqWWdMmVbP7nu/+SNWea+4UiH/7MNJeLGZqQ/MDSb9L1BCNTpzPp+3XDITO1MrnugFZBg1rK0V+rcmSq3rP6cAp3EmxbHen0TQX2yo0KBWuMiCzM4DqHvnKcCsb34YcRgRHSiAVtmSMq7zHVG/DpgxWEgKrxr9CLj7Md/98ZE9PVd/jS/u9wJATXOjminHr3jz2dkHcS0toU63sRmswYWB7W/R0KToEw7WNVJyzRkQoELO4IcvqYG+59OnofbfYSdhDQ1S3sUY+r5jpOZKIX59mXGxRlme6XDMa6pGwrWQ6djtrP3g4lq0kcBZTOHWP/W/802tgmnb6CQDCzp3TliegaUoLZn8XUAv7Zt/4rkqWzFLswjl2ajXsIkTHVuMat1nlKpbcMthaC8OI5Ku0bVK2ETc3kH7zgsZmv88NnbKZSjdJijjiIyZ1eoj3MmE+UrffSAolQYGNpuMaqdsBeViCMYdRexQyucE3kiPSQtXQKgeR7vsXH8B3McUByfI5cALerL/DK9CfRtEO+cu4SpeEYS6boSLZjjSNH+SC6voszPkSWlH1c2vsWynGNz5/Y5mh3G900SPWMXXXU2T2dJ0teoxSWOL/6FRqPfYKk9TqHltrf2cl4nLnSNj4O76pVqMxVGJa3COsz9NIuhpB8425Mrp8RxaDbgp69SVSfwtVN2skCrTSPQcr7XlUkSMXuXTLRIuxYjEYJIFmr3sM5Xic0dYxoAPk6bW1IaTii53oUTiinXrMEWUnJkm5Jju0FioBrWtnuhldT/WIHe+w2piHT8GdeBpEwYycYVo+97Djzo4xbziGbQR+zIDBSl+bOLtFcg3pOR2ZQ9gb8xOd+mUxCUw9xe3O0wz3s3iLvXfo0fjxi1juBrfUZJAW+fPyv0skfJ7SajP95zF/pOiz3dF62U+aS1ygf7PO3Xvw5fuzlX+HVeIG/2P0rjLeHPFFUPtr/nn4LrhYRnShyLFJtO/HyEgDV8YBfG00hnv4VfOt/4+efT3C0BKkbbFzZwb7pktZgWB9RP6Z0t2Zo1JptEDH+0Tk+0H8n4YzOtHaHd8x8hY10ATNN6Q09GsJhkPQ49sIvETeVwiyMHV7nEebkHtlwDbQUt7vCwskcazsKGA70a4zMlFLigoAvz+wxsMdkUZ26NuDIL7LoZKSTHvElPaEd+hgCOnEeTUoOQx/z3hUea76Krkk6dwrUkkmlSb5EIjU2q0s80X2dBf8lkglbuLe7TyPI6NsOsV8gEhqRbWPEAdf8u0zHNYaaJCdeBeHjHqmgAcY0uj9CG0oMDrlnwXRRHQptwiFhlyPGd74ODL++/i+s3d4uWVhntfnFtwPD/BSRJujYBWq0GJWa+FZMGBj4E0N/rijJihbXhsqZjcXgwfeDsY2dJbhiwLg8RxImjK/cBiSb/Vni+Uk/QlGQH/cxTyyzZazwX+TjJFKjcv2zrNRX+dDcDP+2UGTm+gGho5jgcmWfuyihT4f3KZaL2OOEwqTklVrEGotkQMOSqvdIE8i32MikAMZX1Uw2eXrpwc8lcMxRgE8iqAYd0lDDcCXfrIf8iasfxbB0/sHLP8e1ygucvf8x/M7H2Fo/SX+Uobs2wtCJ+0OaKyrD6YYO0hwzsFv4w4joyGXHSDFkQjpQAAazgMw09Mmgdd3T0NxZhGaQIskRU9QCulnMxY7z4H5fFM/TjgXWuM3OzDRJsYE5OMIp5wlMj6OcxytLefzQ4OJzixhk/Ofref7ez/XIxQnX/WNowK2yw0bTxk0zdmuq1OnYtMHNjZh2VxKHDnbu8MHftYwjbHfAZlpBDBzCUUh6Ru3j8q5kuHmLIydiJkxxdkakmkZrpoHhO8wWqyAMDv3uRG5ids0WU7PKQfzk5iWkVDI4yn8zXT8AGSDCu6rvyJ8h52us7wky3WSqeAVNROj9Fdz/8Nep//uf5MSiTSLLGMMzzO4dZ2BJrMxhbO3zuHWNUtzlrnuM62gMJn1bqbFARkZLSGg9za21u7za/AgAN8bq2Z8+XSY9v4x2e4t4Y0Q1cej5HmHHwAiHjK7GSEMnft8TtPpKxgdIzMd+gE/mtzi2+L3Mrn8zG/ou37rQoFWqI7IMP9AZ+22ySflHNnIJ95UzuO4MmE+UAxGVCuyGLqO4jRFU6E+ZdJ9Rgj2INU4PNI4WlXE2fMglKpJaSCTPmV9mUzagl3KY0/hi+XVuTxyrd159iaFtcsw4ZFZv4w+GrJXVQPNpPUQbSITuINxZBAmGF2PlFYkMQuL3nnzQx1fKCXKuYO1IMD69QHYyx7saEiklL96MOHfMxGwogoC8N0OWtcjhc7TnYRdWAcmMpXHihImhT8BmU+e+fJj5q+dLiGGCU1NGVyueVR9UQyqaikxfXRA0By5a2eKt63NHOtlsirUpuLE9xZc2VbbRyK0Qy3vI2ck7SDMOx22E1kGgYaQ+mr/LOD+Hu/FBhvVXqX+wws5rd8h0gTscEWoRW9Z1mrrEu6/ey/2pEl+smVzcyqhWPE7deYN+C0rrCQe1aRpOxk5kMMx0HtEinsPgmrdBKbtNM8h4vqZh9TSC6kPyIjSNQWmGabdLKjVEpMC70zvErjcQSRF7tsHwy3eQk++ZnfjB13UpCC2BG4bUhyOGj53Ad0HaqhxOi7sYmSQxIMvucFhusFcWjL08UkLtaZsPzN2kHnf40dP/E99g53EBTZ/oL01gm3m2qzbmoMXIVIByPihhJhk9Fw7/+iKjiz/FsKjuKx/PMbOnwMeJwKCtq2cq5gSOHRJHDno2ZqQfkSFwooBcOCIVKdOBxZassZRvURpmrNEgzjSq+pcwxFVC+UsA9DZvsXHsBp4d8eLNiNTJk+kmhegQPUuIclXuDUzm+vuEusnq7h2O1Uv0wh52VcniZluxHUZ/0uDGsQ5Canwh9ypG4xzWKKQvcuzbR5jSwhv10QrzrOubVCMTmcLu5xKatVWkEIRlAyPykOMDTE0FQYpnjmG/8wLp+iLDxqvIUompHeVAnoyuoQ2qhMM+L5U+SDnvoEVj3p9+ma/uXcSu36JW2cKxhrTkw2zhmyt+xzmMNGBWRLT1AtfjIj+x/0mmuzZWWVBaVHrGnG4SZAYzk2oSY+STot6TlsY8bqzjEGNokrv3G9jjF+nrNr89+xQhJk1G5IoObsHBSFOGS6q/VUv7fGnpN5DpLN1cHi+KyDWaNB3J3aHgjYn+S8sZggStGCIzQbDR4Nu1HyQyUj47cx/dBkTGSyfV/X58eYVIbDE/niLfvEah+UtEN/8Xjv3Ay0gyLuUVOKmMlD5kMc/l73kMX04R1Wa4WRxhawIrBj0GKaG9d49RYQOj28KPGpTRCCdjHArWNaa5SkneQjAkmIyqyJspR7f3CF77HUJDR5MZepzQTjvkRmP6fgNv9qHbq8+r+9GsDC9OEEBHn0MDPNPG8ATzBzvc9I5hRmW80g615/4h0ytfQgjYk0vMj1K6+oA34i6mn2JEJo39fUbnVvmw3EEC//DdP8RvXn4Pbd2hZI15POnRjvbIBVMcL97HDWfxjSKeMWYce+TsHplj4AZHlB7J+LKdcGU25XknYXZ4G217H2GbvD++w0/NfpE5ccD+6xkvJwmPoPGaPMY769fA0jg+XifTTaJlpWe9KOZWMsf64Sa/on0T20cZK7kRZqXA0b1Dap9QCYTYPaBxooFuKtbvvL8OwuSNKOTJ5J205gxWucm56i12vQrFYYhtaXi6R2imTH/lY1iJCtpdMuDLPE1Rj4h3Fainc4zGmVl29yZzMrVbdPwqtdRASp1X86p3kLBGVYxoeXnSXkyuWGGUuMQnHTo9ZWt6yTR+EHMQ5qkfXOOJqZfohlXGRzYL48ksYr+ImMmTGnme6r1GVqqgN5RcDrMmc+0OmaYR2C6plPSKBRKGWJ5NzVHBhJL/FaTMOJQ+T9S/Hd25jF2JsbfGZKLHjpkwU5hUePmqt3S4VEBab6+a+e99fR0Y/hGuMAkJZA8Z1pmfehU9t/rgs7ydxzVdtr0cVdli1I8pMGAUmbg7ipBh2ZeIskl3VKYvXVKhDnRATNhX83R0K2PALve+eo90HGIbgrX+PGggM8FQc6jGLRafOsFL3gqlRLI2LJF/9ZOk9mn6hQ+y1F7B2D5kUnJNqexxzVIZuvH+TeqlCuZ4TMWJ6eNheD3us0Scqf7CN5dWeUhAkZxtYLx4A9KMeG6JcWqSZBqhpbHCASAJT59gdbCuRlU4EpHkKPcv8Lfe+//gO5wGLxQP2bJ+m0IUkUZ1XrgRIYTALPjE3SHHzxokSIzUYWB1iY0QP0rxRoK+mMwm7E1IRIRAajqGk4Iu0fUUzV9EZpJsHJC4Ls/FN+kkEad66jm0LOaz/m/xyzO/hpn0OajXyWpTGNEIPRyS1Rrcrkzz6dMVJHDpkjJCFy5Pc38n5d/8QucBM2m34hLnlNE7rK7ya58d8eWrEWEM2Sijr+Vwc3sP5cPbwtASNtMces9DphK5PEtqwuqOxNt8hf2SYD6LKex1OKjXGVebSCmZmZBWSFOnbXe47WyQDSWN5gZ70TzbR1Wu9gVTlXOMi99Cz1dR4zR8lcTQ2dAWKeRN4lDSr69gW1coyxZCX2K0qYC2u7dLL6miWee5OjVgs66e7ZY+x2yxxzNHXyTWTH7qmT/P/xn9KGlYpzZwSESf03M6ce8SN7fusn9LKfXbRxFCH/DU8TnS8ysIKUk+f5eZVGOnWCPsGooQ6YVdkmfOsZF6fO41dd87a5/Brl3gPcFTrN1RrHnjUsJT0/OI5kThx0M0q8PeviqHigOPqDfp7zLHzJvq9+7uJLzkzjBMuhhBBbwhrSmV9fD3HfwUxIqSD6EJ8ppyyG0p+HD6EiYJ1vaAdiL4Yvk1tOoxpBA8cv0GQ9vkUX2X43oHfzjgyrSSjTkhsdfVOdJLqkS5fDzEysUIdKzgGJo7/UA2hFClnxv7KZ+bepazepeKBdtHGfvtjEvHLRJ1W+TMJiQHGHoF58gCcQbXPcTVBMfPGw+uOVvTGWg5hroqvbrTVqBrvVBCGgU0Zwp0D1GOqGZqP3q+YKZrkpQeXIbtsWBrEKLPjtC74I9DvEA5vOHJGNFPySYzBYcbe7TCHWRWhkkpWjSdcbmfsnDrG9EoU5q/ilnOERoGZhCgpxIhA6acFHNTI9PgoN7hq1Wdp/cSlo6rUTPRH3yRcOeIrfoczbf0F77rDkTAp3NjytFt6qHkatHACDXGkwDGm2tQmqUS7qPrgJSMMgN9ZxNnQd2/u7DK4CBAm1QXNw6PHpTjW3HGXt1mrVdFSyA6v4AmBBMVQM8MMCRsNIYcyASE4NWTdYyDQJUw377NzOYr/OKFP8eN0kmOtTYwJz3HAL25v0hszbFfzTg12OGOMyHJGE7GFi1VGF/8a6B7pHWbvkyopXlWd66R73dYDh32kLg26IMxhhkyihyqRgk7vknLz1MZj3AiFVyaTlNadp2LmXq+g1yBe2EDCVTsv4nBF6hzSFKFq8t9LhyDV29HxCmqyqIzAXu5KrezMguDPRb7u5wdrLPcLDGKRmhFpQtadhXdBXFSo+92cOMcnyu+iK7bFFKfMS5HRaWHFuIAYVjc8NbxNwL85R0Onk+ozR8nqjSRponbVlNvg3SIVfBwp6uUTPiE/36kHhE95jO1r3TvrL6B3Vsg6++yPn2cKVvitLf4Ru0lvrJ7Gc2IOLn6Iv3Ip7R8ia9Z7z5LhsZKV9nwv/j6f+Lpkzr9WymFkxq5mjpfYZThzTZojpSLZgw1sD1A4uQdfFfjGfM+SSZY37Uw29d5dPM12nsqsLCaV8RkhYKS620zR5ZzKQ6VbupZZ9DSBF2G6FqZaUeyPtZ4veCSjhyow9g0sIsRRAWyscHx2eNc6p3k/vSIdV857bfPLPLxb8r4zGT+52x3mTsf/0cw+7/T3vkmdr5aIxN93mONebz5Ast355FZSrJSQdM15hZPYR8e0XU1vui+wqYcEUoInH22+/c4cHI42/d4apyjpEt6Uv0dURtwYufjpCfVv8OORc8oMJ2XWFHETa9CZKkArgh6jDo30YB+4Rju1EO311hQeizz1XUkMAhLEy7iAMsPWTrY4aq3jBH4aFIw48WEM18iQ2NH81mMRtTSlJctg3y8RfVoDyNNaS3P071/yKxxxBOjO/yT7/8h7uq6armxTNrRHoa0cMcN6ulZ0qyLpaXorS7HT9zGqo/RswhPvMgXvJhPhQGJgKZoY2ztQiZJV+dIO2N+1vlpni1d4w/aMa+S8aS4SqWm7N/x/h2iXBVZL5MZOm6U4KVjPrnZ5J8G38rxOQN72CE/X6c86OGtj2AgwO3il33e9RfeRZZmeOZ9yB3nY5XP4OIzk2isypu4RhWhR5RGARW7pN7H4hxhscHyp/4BmSN5zNV5kSdIpCA9fJ40KJKEeYTjPiglLdYqHOXmKIsQGZXp2MqfLUU5dCFpaT7ruynTFYPN/gzxLIj7KgjbGVvkg4iDuMCJ0RVOlm+xyxMgBEtdCTKlny/QOavA2hPd18mq0+SaMSDYWPhWFtcUsc7QdrGygMQ0adtt5krzVOtKp2elQ7Jkne1MYhgzCGHiToG3vse6aZAKmJ70r+u+KiXVy5Lt4kP7/MdhfR0Y/hEuS1iUr/09qoMnMPUMLXfswWdCCJr5JvdskxptBJI8AwaJhbHbguEYXcDctA4IXmIFzVD9A6GIiLpKKepWRn/8IvHmx2meaFIraewOlZDrXcmll7YwZMqeVmTP8HhP1OVmr0Y+7vCp11sMy9/HyYPjJJqGnGC8WsXlXmGeIPCJO3fIbtxDZBllK6Kj5xBkrLPEMBFvA4aiPpnVZUP8xApiMEa7sU7sl+hEeTIEsSGoJgNOrfiId1yiGrdJxoLEEYwGi+RWNPySw0/2A/6nYY1CVOCcOEW9pPGVa2+WgfrE/SGr8yZtXWIlVRQHPujWGTQESbINQnsADAF028FwEtzqGCETNH+RZDCCLCN0PU6ONmmlIcf7ykGZj3t8R+tdfHnq0/z6s7uInENSViUGZv8If75BLu3T7Ep6VZM8SgGeuTTDP/5LJZ45bnBHn1FEFGFIvp8QC52ff73OL39qzGxdOVkXZmwOzRpeQWWwpIhxCyrStR3r2JEybtp2i9iCE9sSv3Of3bLgZDeh0B6zMzNNjMGd5+9QscAkRgiXn1n8Lf5V82M4cYZrbdMzHkfEkt/Z0Ni33glohJMEqcyOGOddBlmFYlkZ0sP8MZzRbWaNLiDZ/6x6B3prl8NkijS8wu3qLnt1hUQ66SymlvFo/wYfvf9z/PD6x7kXn2R0969ybRQwNIe86wmXKM3Rlj5H3QAB7B0UqNQOsAyT9Jw6J9pLdylqgo3KDNHAYLhjQ2vE8Jue5v/9ywMmlc8c7F0jzo35C7vfQ7auHMb51WWEEKwsKxBTiVvoepu77RtoZIShz3gEIAn0gNlJFPDGekIh6jBKephBFc06wtb6iCiHlX8KgMLxhwGQgqPOWqBLzmh9LqXX0fYC9gct7rLO5fEl+qUqi2vbBMZDIOYPRtyuqdLaORzs+5PMQePdAJRPjHFqMZCS33vqbeALYL6hs7mfcifNM1tX8vHSTfVuHj1hkpbUPbpUydJDhJbD0BeQaZ2pmnLStbdE1g1dMFPT2dabZIbF5+85FEs6O06d+86zCCEQZhE9H1OIvAffm94bkxYf3tfnjjRWuEUyq87Q6l6HxSMFLg4e+R20VkQ2o0D44M427XCXKDuHJW4BKaOVCu9eT4iwMRc+jBzdYfm75wh0TQ2kV0eMKTND2xuzVRWcLMeEk8znomNx7+QFcl99EeKU3foMU1bCrbFNWUs5fUXn03bEXa2ALg4xJPiTuXHBHwKG/fIc3vCIWl1HWg5xmiCkxDup7r/gKcbDjltDarC0t0XsqICdJuGwYnHr9iSTJ94gC8DSAkhTxobO0NYYOgnZtnIwjhqqXLewJ1m9e8j9lWfRHn2Ov754iHbYxsxPBrejMzYXGRqLbJdj/FGP8/nH+c+N97M/VsEOef4CaOqAmLUiW0mPOWnxxM7n+Su/8M+wsNjGopTXMD+9jSETJIJFWcOKr3KUK1Lrd7CiNllUYFZ2yCoNakcQGRn7FY0bQQNNgEXCCXedv8TP8eP+7/Ivdvf5cff3uZRc4cbt/qT8XpVatY0yh0aB+qjD8e46C8ERRVfJ79gcoFkghYE7oyGEoBMckg+KvO7dIsyGlA3lgFliSCxillKlp97Ib1KXBcbbnyKLM4axTVSdQu930PpbaBh0o30aSyWEEGgCPrPwDEZQYnRxRPPokJzs47tjcoNV6B+wXZtiypG4rU2KYoiXW6ATlBF2n6/uXuLUMZc/vLSaT79yjG+68ll+bOdjfOjuFxjMnyANIH9Cx87ZGLbB8HBI+ZHjPHEg+bntXbR+hNGsopNhl/PMXphlXu+yoqt9S4/ezYl7N9C6EZiCTz51gd/c0amW1PPvtUOy4/NUJuZut3aB4+u3QUiSA4NpR9KOYL2qwTCPVogZeQ52IYJEybPT0PjG1fdRb1s8n3uesT7Gzab4j4+ZaMkm+ahMIayjORJ3tsjeFwfE3XPQ7tDYXMUZtymFLjJok82qs5FfMbDbEZVul32ty/POy9zQt+gXb9B2K/RSf+L7FMgXJSM0wtgiqUnE9iHJMVWNEA08+laR+Tfe4PT9uxw0mw/GhmRBFyYBv2jhHJr1UD+7CzZR5iL9CQmOUyVJVAuPKN/B8hOmWofc9ebRRwaZHhPlN0ntPvuyQawJlsIjHsk0XnJsyp1rVNu3yIRgM1eit9fjRHabf8Tv89Srv84dW1OzDBtVWqEKNji9Jab007QjVUGVjjSuXD9kazjJdP3eizjEjBOlj0sMELstCELS43MMtg65nj/O39T+A//jkzneScg/MP8Ne3YNV5NMd+8TFeqgaaT1El4Ucy67w/85/gD7WZHve49DeNTFn6lyIlECMtYddDtAxn3CQYhlDzHYZ8g0V927dJxDntyJqXOI7pzA1jrsWQ1K5gRALea584G/htvdQbN2OBUIRsLnWqI+T7orSKFs8fioy8ix+NCFD9J3PUoiIIuqIEBmJs1MPXcfl/s7CdNVna3BNElhTPPFydzHHYllwjDUmE93MLOMpPgMdq1ErivR0zZryxrXZo/jxD1WxhvImTlEHCBNl9iZwjya9PXbLlakbOW94i7zlXlK8+q+DwsRWXyLKDHZmLCWeksWzs4ed02lT6fzSgcJ3QVhUKHDYO7rA+6/vv5/XGkkOTB0lkotNG8eoTtv+3wqP8V1kWKKlAptPAK6wkdIiX5Tlfw8tqSU2Fc5iW2qn/WkwAsnDrqVcWieZXHxRU6cX2O+YdANC0gJHa/Mm3z2X/nYG/hScjHpc6dfJUHnx679AgtHu5y+u8N4RilZYeg08iY9x2cwriKCNXovXiEuVKhoPUaeUrDrLDLOBI23AEN9Mj4q9iC5rDKOxgvXQGiMMhddZIhMkAEXC0ecGb2GSUQaasSu4PDgFOVHdMhS/L3bPDkzz/t23scTuSd44rTFa3dihkGGVfCJeiMMXRAXIB9WH95DcoIMiTe+hdR1ZJyQjFVkzcwV0J2U/IyKtmreAtGkbDe1HNw4Ikz6lGNJIx5wYjjmhw6/hTO77+AzK5tcr18nLigFYvcPmDo5hU5GdWAgTlWw+ipKHOVrlHIaf/nDeeYLJntuidwooTBIuOvPcGHO5h//pRL/058pYBkwGrocUsPx+yAiUj3AzvXJpOBDH7/Fubu/BYD1d/49zhBmD+FuUxKZcFJxJbA9PUOxYnP7+dsc3T1gyhyT6EX+QP8CN9z71HzVT6RVngTgy1sZX+pVsIdfQBjmg/2LcwUSTEo19Z739GmEzGgWd8ji23ReN2i9EGBnhwyzHFJ/Hi8Ysl2cDBCPldJ89/Au7+0W+PPxx/mmmb9DIf8y1/WUf+cWWd9LMHVJ0n2MUWOArUOW+JxaVLIkiznSpSmsW3fxZnQ6y6sgBQev55Gewz/rrbJ7lPLRD6no+1HR4/CDbfzA5kf2vwuAk2dU6ePlpknPLVCOOsx3O9yItvCsjFHiM0p9HG3IM05Ewd1Axj1urMcspnuEuUxlDPUIK3cPOapRlg12cwIKD41ApaAyNAe6jp7FPBq8gYwkm3eVo/Lk4DxJYZnqUYtmp6Mi1VLiDwds5BuYSGqNGta6chJ0bxaEjlsd406ASnHtiQdA78210DAYR5LxMGPJU/v20s2IxaZOraiT5lHnIMsjU1Wma7jvQMqMKS8k0gJ0/+3mYb6h83qyyLCywNW1hKdOaFgy5LM8C4CwShhWCFGEOckczewHyO37TB6Lzx3qPGPfIJ5V95SPYvKhKv+VOohMPgCG/Xtb9K0ukTyBZ/0OOf3X6c8e58JayqeaBlHzXQhnGs//CkFVvetjLZUxmTIlHHa5X4f3zFTRkXy5ZnBiLWXv6WcQkyjXbmOOhqEyhhdGCZqEz1RD9uMculD78tSh2ufxW0tJgX5J9br4rsp41uIOAN5yA6OUsdp+gWm3x9FhjrQmOXVwn3FeyUOoCTpFE2tfQtlkZfsz+Lc2SfUxaapR7pvomUCzi4g0Qo93iPyT5Msmj9xpMfR0Xnj2RzB1QdHISA46OJPe0tSssRFZJMY0WxWJAD4Qpmx5x9ge3mPgQH35YV+3US1wEB+xhIbm6fiGQvJrOBR9QfbqNs5Y7cF8R5KNrrBZruPFIfO9DrnuCXwR4s41Mdf77FUChuaYjYFKlQoB/y78Vn5n+E4+ZdWYjSVPXfuP/IL19/mh3/gevMM1nLYqY7/TV++xFA6YGe2S7/Uo2Oo6/aiHNemjdaeVbLbHbYoDG29ssBm+Qamg2iqO6SG/tfBbFEQDmUZcL+1y7l3vYrS1izN1lddba6Dp2PubZPF1ClaVWEbMNB7aKy+nYx4+wXhpn4XOBt92VZXDOv0lhinEvoarg9NS9/74+QJf2HkMgLv9Jyn6/3X3qrtwluLufR4f7SOBI30RBBROqPLuXDXH4GhA+cIKw9jmYhjRiUxELocWR1ilPLNn1ft7wthAF5Kw+yhXgxVAcFrusNLv8jNrJr87UPvZ6oSkJ+apdVNSvcJhZYkLYwUqs75JNczIELhTEj2oYOZiDv/0d2EXI2SmdLbTFCw8dZJnX2uQkvBi7UXMuEYiHMx4jfnhLGbsk1/RCfZaBAcdyo+dRI47OOhM91ZwTJMs6YGpZDV3TEMIH617yPvjS8Qi5hXnBkbiY3eneeq+ClLZvo+/or7TH0yT1kDrj0hmBDITjLomA82jYcc0/94P4hQcAlsFXbrjHdzOHommoZ898bZ34c1oBDIHEybbTlFVaZhlMAs3sXIJuW6fgfAIxxpo6hyI1GRDXARgdXiPs26VXcNgtP061c41Wo0pdjY6ABzP7iCrTS7sfoL7loGjp4yHLXazMYmMye1dpmQ26SSqmoWBQBybQr+gAqDLJZNGUwUZbGJ+X3sPdEOEhHi+QdTqcadwklOje9j1Mf9Eu88xbZddq8q8K7H7B4STmb3ZVBU3SnhKvkGKzpPuTZbzI2Sa4dTLTO3u0ikVGeqKbTPtvEY4CCmX1Hs4PDJAwP7yIc2Rhn/wCFI/z4w85PbiFEWrRpiGUIf+wgV2Ln8n/vAlpnYSkJIXkkkPa3cZQx/TijLs/pCxZ3J57iK2FBgiw4hL6n7DBk1NATbbtbm3q4DhZn8ajJjFjV3++dplHv2129j1CQFO6BHtF6hPLeA2KxjtCJG0OHLqvGIf41jvphpKM3+M8KCLWfVJ9CG71hJIydByMGOl69dLXeZL82iLLqXEY8s0sO37QMZB5iKzEd5sHudon7uWkqGpwlvKRg2fghjyztrbbcd/7+vrwPCPcMWa4OQxkzNTX3hbf+GbS42sUABvmQnoKyinSb+usoMXayBzBi9kp0BTZBkHmBQidZiygsdXXnyCYXwKDn6FlcJtUmnQCQvcsY/xV3/y7yKBRGZ8SOqY8YAwM2jVTvGcvMLiwQ7nb16jfUYpTMN3KBhgadCVc5hGB83MkI0GOUbERYtU2OyhehXemjE055S4hQbIeol0aQrjq4qAJjYV9bATpawXKxSDm7zzyq9gaWOSQCf0NPaDs5QvGDitLfQ4IJw5zplvOsPCows8dcYizSbkGgWPeFIG6E1rVKLSg3vI9+bouRI7GyB15by+Cf50t4JuSgrz6t+at0jUURGpzLSQnqP6dWTCP779Cj9+a0ifHu+8992c7C7xqvEqv7ujWMuswRHNkw8VROGRJaz+IZlukrgPmy3P1mAtN4U/TMgPEt7IrfLRd9vM1nQMXbA0bdBq++xkSrGn5pjEGGFbfaw9yXu/tI1rKWN1+JFvZeNMGT2D8kDte2NNZ1jKMcjnOPHsCvlGntf+82s0jJRAayAnRTPTpRaaf4xaQzkBsdCIJFRHv4+m2cS6JBOSQVFFaEs1D6FrbAcFpNAo1NdJw1fJQo2DX9hHFwmt8SZ22ccbDwjtCiOzhx6p58jlE3wBbj1izw457azx0b7NSSvkP38xQCKIu5foujFiwhz73JmHJCbpuRX83Xv4cwLj7BIAQdvi7oWLfP4WfN97PZ6YAMmDxTxhfZfBEzrFNEdgx9h5ZWhP5zM6fpVy3GbhMOSe2cP1NHrk6JHHtUZ8pBETLL/G8IW/wDnjZ2mMd9CXfMxQgd00t00aljhxlLE783aVWmw00TM4nMja4mgdoUNvI6aRa1Aym5TKp7HimCduXCHWDdzxGCPLaFlFps2IZMnC3AMxVs8j7AZCjhCECKOGGZRJym8HhvMN9fe0QcKilzEYZ9xYT3j0xKTfTxOEFriphZiMeNCMGbJkHXs8ReLvIeXbjdlCw+CnRn+Sf3v2fybN4PHFAx7nSzw/XiHKQJglkH1GDChP0oQzLYHxuZcBuDcSbAYaF/SbyOlpMl/nTe2Q5lOseEKi9ZaMob5YJPVNyPXIez+PbB/DCeG3ZkzasYG18D3IYBvzg0o2ljrqvc4FoA0GbE7pnGuuMuNIPtswmLuTUZirc3/pJInr0CuWQUg6qc6Taxnt4zFpSdIaGUhTnf2njhKGriR1H+oygEFZOedBt48x6JBYPkatgO7ZWPWY1dEnmZ0z6N2XJE3J/N42QU5956BWIwh1yv2A1uPnSUyXR9/4OVJjTCtzJvP0wMutYhZex4zuErgNPlh/DS2TvHY6T6o/HAOQHHaxa+o7qT3DWmCSmtMPRlZog13eKQz0wS5bVSh5tQffNatFuuEuFgLHmsW3FBBbTw2aiaDd26ZxkAGSUitCkNC1Ja/MrVIf6lwYqGeKvRLZYY+9SkxHHzAaCI6EutaOs8TOYZ1/sfOd/M3GZb76f/sYf7/5U/yM9u2kloOWRCROjltb6qy7cUDdHKMnKYXxpPwxeNhn6M5oxGnMMB3jjxPOb9TZ679EXi8BcLx8AjN4D4Y5SzzYROqCk888Q+HEPL2tL7FvbZPvj9GjAJDYmpKbBbfzYF/qtuRg9AzoGe7KkIu9FwFw+ou0hY+WV/fitDYJCw0eO+Pxu/e/iX/x6g+RnznOf2uNJkGp2tX79Fybw6tHeLMahq+ul6vlGBwOyK/O0Y4VsOuJOlGUQjDGKufJN/IIwBMRp/U9kDo3swYguaDv8KdGm/zwYswrsXqu/XZAemKecl8SuY8AcPH0hFgks8i21b5PuaBrDaxcTH/9DrqdESczCBPMosDyLMpWhUv3ptnz9tg2Nsh0Zc/mB7MYSY78ik77VVWWV37qLGnSxzJMFnqnMS2P1Age7IVdE+iOTxQMmMnKXNyZQZo1iq3znNjR0bwQx8gRnjYoLCvd1R/MkdTVWUzKMVHXokcOKQSlH3wn2nSV4+84TtFUPXWbwV0KvT49r4g/9zDICYqAJiSPcJTe7jZPgVCMpRY30H21/9MH+7TkwwywlIIj1PiRE93XODEZiXF74zb57gZH00sgwbI1ptkjLDZ5fQniofr7ld4G3UKJtjwgf6DGEKXZhAyuD6vf9w4q36J+bh+0HwQZir7gZn/hwX0McuqeulMT3Tm4QlpSAeg9u8asm2H1jx4woWfzddwo5qy+yTu11/juwm8QHHQAcAs+9pW7dE4cIxtaZJkgab1IMAgol7fBKLKzo6o79i836DojymvvJ+wcw1+cojncomTV6cYdrJK63/XnfghyPcxIx0tCXkjP8tLREv7u4zh+xu+t3Sc36uFXC2hCo6Krqgc3npT4RnUa2oCe7XGsoLOxl1IrCbYGKsuQTEuOvfQGCwcJxVPKhz4MfKLdIjM1HXe6ijwaoqctYnOegShxoaOCsmJukfCgTW6uzii3zsipcW59zNB20TKwg4DISJgvzZNUYSqps2kaFLwhabwBCLJ0H6eYxx7tc8e0KJklbMN+KF9mEWSMzB6W+f9xWF8Hhn+Ey7UF/8OHhzw99TzaW/oL31zNQpN7kyjEMRQQHNdmyCoF9OuK4vx4TiJLJq8ny4QTxbKFmmEI0LMLaLpB4dJPoFcuU49Vdmlv1CTtSuZvHpKUqlSSFt+peYxTBSg3jGX8sMUP5++QG49Yn5mMBcj7im3OlhwGdTV78BuXqJjqe1E+pW/OI4VyWppvAYb2lEaUSYaT0qzk8mmMl29CkpL5KtJvZJKtap4cPapRC01kpKFG5AvGc6uYBUFuVzU0D6eOM39xntJMiZVZg0pe48tXQ1VK2hshpWRqRcebsNgZsc5skGNUBjsNwFCGJp6AP2Er5ZmbGSOsCsLMEbUnpQqmSVDIYY17dBPJysE0jW6TTjJGSDh79CjnvHP8/N1PqX3qH+JOVZG6Rs+LqS0tYPUPlIIWD534JS/jureEF2SYieTV4jnKb7FdKzMGe4cuW5NaQbnwKQaFO1ilAS8XLvLT/+hZ5D/5iwDsG3P0FxSwW96VmLHE3jE5mlfvrrQ8zaXvuISUEm2rS994mDWo+x306pM0ShrCFAjfIKfDjJuR6ClDL6NdlPQtBRbyOR27XmJwMGLYXMU3biGTTQx7SC2nylzbI9BdmwIxCJOBc4QfleknGlYuhrSPU43ZNQxKw3mKmcZHZhN++s8VWWjoIE22d6rEaYZu73Nufv7B/QbHlrGiPgWvRfPSDHKiyf6t/ghPnLb40DMOzpffoBAOOGjkkeEhvW/QSAogmg/JUAwNAr9MOW5TPXJJNUgd6JGnR45tQj71aQsr914ircEj9uuIJEV3/zN6UHr4opgmn0C89HaA5jY93FDnSFc3GEQ61WmNuD3D+eZFtnuSfE2d/XN3bzDWTXKTeaF9zWPKGxEuKpjwoM+w8HBAt2mo/0/Lb/uzzE2AoejHLLhqEH0mVRnpmyvyBB7gTLlkUjlrWXQdazRN4u2Stl962zUXmjpjHH75qya+I1gp3uY5Ps0wM/hKS0NYJWTUIXJjKhPDPmsew/y0AoafO9TRyShHt9Dzx0mWy6CrZ0rrGeZwMq9zpkYyHDPePSK/Mks0I+jwZ7j1bX8D73VB4MNXqjqHkUCvXEbLrZKcUqnx2a6FiWBmTW1IdnIR27CpO5JNT2OwB4si4+Pv/i4+891/irqVcSdQhvyxg4z9R0NKOeiPBb2SyornE9gufm0p0CjfINVNjNYeYjRAGibmnAqILeRfJy8O0Z+8zLDjkTQkpb027YZ6161mGf2WjZlJnp8PuHrxw9SHV8j0iL0JmALInBMY+ddpGj1+cv1nmNUP+YI+y9g30EMVxZdSkhx2sAqZCvJNgGHeqbMzkYvhcJ1vxmS632K7Kii7lYcyVC0yHit7YuXPsnRJgYQ7gWT2EI6CbfK7GUUzwGorB6c6eI1b9Vn2vDazGLzOSQ6UP0q/mWPoDxAIvlR5lAiDUBoUuj3ObMaQPkLq5DEuPsHfH32Ez6z+IAJ45aP/mrvbCVPDIyLDonJKleXn15Uz2g/7WJUJ0/SMoDPuqM/JOLXlE+9fwUkmXQNj0FvfgHAXGAQbVL0qpm5y7Ae+mVG+hkCyNHxY8hxnAXnbpjLaePCzui25wirGqIZ8JMKrBsihjx7n2Hfq2JPKALe9ybgyR97TWJ4v8MLeJc4svZ1w6a0rPbFAZOYRaUYr5zDYuEfh5ENXzK/6RKOIJE65az3Bb2yeZmA/TjSMEOMxVjmHEAInZ5Ki8Zi5iaqzETQY4IqEyrE8H5pO+X+eTxmbFu1OyC8sXaIwgsi9RL29T2VSZuo3bXYn7es5XWLmZhAapJpyoAfdJk5dILQJcF2c4uRth8aoweulF9HkEPRZckkOLXXIrWi0Xr2FN9fArpXI7ATDdDAzDd3Kk3oPnWQhBHYtj0xjoiykaDa5uDZGy3Qiu4QeD/H0POMzGqWi0mnD/gzpJEaYpfuM2yZdSwWiGpNex1MHTaa8ZRJNIAYH5Mdj+rlp3NmvdXljM49hpYqRtLQKUmUSvcF18BXgmzncoy2UvOT2HgUjoiUW8GPJVHKTZvMUvtBp31PVRu2GykxO1wUa0PIK3HEHFNfU3z+e7NCrlDmI1KHphPuYupJzLTKR5TzaMWWf9aMuhUnQoNl0mJ+MGJKaRncy57J48jQjzaGx/zq9FeUH7llVFvQRWpaoUlKAhSnsNEMKm5+z/gGpvEN/R9nr/NYBIkkx3v84MrTIpD7JGA4plXfQiuc56h3ghrCZn2J94cv47VPo6wb55RnIJAWrTjfaw5zoS2na7D73LrUX8ZCRXudfrz1CJaiQlF0+vbVNftBldlbp/pmckuRCrPbaispYIqWTy3OhIYhT6PQlA6l8mmgenr6u9sB55ATS1NjJcjTHIbYplA8WJphRC6krvfrE0TVG0iZNJXF/RGGxgVY4AtnjG1/tExUypG5gBQMcaVPLKZ+tbjYYj06TJmfJIuWDIts4fQudA26bNs3cQ+ZuUEFcgGy89TVy99/z+jow/CNe6UBF1vT812YMp/JTHGkaASbHpDJYaWOW9NTCA2BoaeCWxgyly2GmjNGGFlCcZAz3sxxLjy/h5H3s4z/GV8vfDsDt3hK3dpa4fMJliwozSYs5NCKtD1Ky8+v3yNC4uP5ZMiG4k1cehlVSEbSamZG9pkqt/GMmJ5eVwxm6Qw70RcxJT9/begx1wZUFyatrCaOtjPTxU4hhgH7tPmmp8eD3Al+SonHFmVDgBxqBZ1G4qJSFv3uL1LQZVx8CBU0Injht8ertGDwfmaSko5ClswZerIyGGZUwEfQKEjcLEROW1ag7yRC6DzN8mr+kPptkE6Vu0nV9rCygl2pY4wZC6rTDFFMLEULw3cvfzcWlJ2lpGvsbr6AZOtmjTd5Y7lHP1bH6h0T5t1P3L3mSN/yHA5e3amffihtZmTWIwhzbqdpfO3+IZo6w3ICr3kmavoM76fcbbAaE09NIK2NlV3J2XSJSwW69hpAZum3ilT0ufOgCzmGHWH+YNchpYFSfxNAF9ok8UhMMUkG5cJpQD5FTZ9Dr5xkYSgnnXA23USE4aNObP4ffvoFvOhTML/NYTclFN3KQEoqTno6x28OLiuxnJlYuwZRrCF0y0ATl4QytvIZpFDg2bfD3fqSIaYYILSBJdJqNFrr2MEPSL6v3U+jeZ3nBYTtXo+P47B4/zp//Nl+REH3iBcrxkLZXIgsPkbbg4IcMWt/x8DpKZktYMqHrnUXLJG0zeJAxPDLGlO9pmKf+FC8bP83PfPb7AfCaY7L4YWQwSVXZT+HtlUrYFR03tNmbjJ7pxg616R1IfcT2o+wMMoTfIHZtGoeHCAn+YEiGYJwaNKpjolmB1MFem8y7LJx9cH0nVrMNkz9USuo7Gpan4Y5ifANeuhVR8AQrMw/7GOM8eJrAqddI00MymYJ/gJ04RNaQePf333bNhabat+3DlEdWTcToDmeNTWqW5A8OdIRZhCwkrsZUkxJ+6lJcfQz99has7fH5I51353cQSR8tf5zsxCJMkpLxgod+lCE1gWyUGdxToCe/MkM8LZCtJfq1J3FuS9pnNTIhOAwFQgisxe8ls/pIEx45bPD9voV7XwWaKo+qqHtuAkC/WDV4ZDslcDxe9edpWgk3hzaFOKNSCwlqGWWl4rhfmENR0cCt3NeaSqnpHHnTLKVbvJm8ExUFuI6Hf8A4y3NQf4bB8im6TQ89yShu30UiOCpk2G+o7/yGf4NfrdRZyxRoPCKPtJVs7RKgWW3+7OgOP7L1q/yu+yx3deVEGaGyAVl/hAxjLG+MAFJrirXAYsH3SH2bwJWIwRqPRxGVccBmVVBwSw+eQ/cc0I4YS4k/nsMTZWItogcUBgOsKIDRZBxRT2LqFqX4ZT7y8mf4op1CFvPrvI+dtRGaY+HMTxN5EzB3/Bl+t/ktAJhWxqWjK1w5uEySSi6dsBACPtNRetyIRtw5slntbDLM5ak9q/Sie0XJQi/o4S9oGD44UxqtkSKnKPsFlvuCajdi3L5KTloMBwkrYQdh+Oyn68wWlZOdWi5JoYJ5tEPNUPpeEw6d6IBm08c9XOPNZvqaJbmTMyjsPklyIsWfGaF3p8nGLbr+HH5JgJQ4ra0HI6HeddHGtQRnlt6emXrrsus6RxWV4RnMzZJF6+RPPtRJuUlZ9PBoSO7sBW73m6RS+QdaHGJNRiwUZiqA4FJ5h2VNAYxHUP+tLCubt5qTSM8hHwX8h6jBb7/7r5OaZ3h6+y7RSMl25YzLNhogCTKBMa0yUrkZVUkw2m3gNB7Kf/nkHEaacHn/STSpoWUjHKkCVLqwsMoR/VsbVC4qeU4nIKEiYoTQSMtvP0verHqeHgMsO0d2EGEkKrCdjXu4Vp5gWVCanMHRcBrpStK8JC0lipHUUNdolDXsuxmFz0u05SKhYSgymEwyyB/HnfnaAE/i5rH0EUN/mqGm2k5KpRbW8JC0pN7T3OEum9YsSEHsqj3eycosjjJMsU1UX+REfgZjyyS1XXoTRsqFnPIfXok6SAELtwQZGpWsQzA26Q5Vldfm6Ca+MSBIDZhWA9b1SoEMMHojCpOMYTmvc3ZmApDzPv2NfXTXZmG6yFcLZzl58CpG75BDo0SsmRzL3mxfUX6HnFP/DUdKv3Q12Lx3C2HouK/fRToWuQ9cZiQVVwTZGDt4HtOMMCuPcBh1aYQmdwYgZn+dVIuZ2oHc8gyensfSbLrRDlnaf7C/vdMKXDfHQxBlhNkmh86XK+t04xJuOMavqEDiYtUiMC3qcZ4syVMeTU1kKM/qtHruezsJpVKeflwiXDE5M4nlZCcXMEsxu2GB0+k6yAx3Wr3P4mjC2J9FnBlcITDyDzKlTqPM9Kkm/eIm+bGJ268Rug5ZNmBJm2NwU7L2yxGnXvkIz9z8cQbJM6TJXWTaJcsOMXYyhNhnzdSYLT8MtgOICSlc1r/9NXL33/P6OjD8I15Z/w5oiob+D69GTimIIy2PK1QfnJyeJz21iHZ3GyLV2zJVnsxbSxe42rzHfafNVDRG6JKOW+fYE0pJfblj8QfaZYQm+U83P8gn1t+N7xhsiwpO1CfMAvQnZkEIOpUqwy2TcvsNNpeXOByqKJ9VVgp49d413LUj4tAkG60xk1eKPHBjtrRFHB0MId+W/QIof69F6sH9XwiJLynDb3z1OqLeZJSog19MB/zlk3+Dn62rUQVpqDG2S5QuqM9zuzcZNlZBe7uD/+QZiziFrdEkE9gf4tU1tMxCS03MWEVz7iYxdhaiTRrO3wR/wp15cC1tEimMOv2J46QRxRlmw6ObPgS73QC0SQ9Xvprnzz7xZxm4efr7N/mDW3/A/rNF7i4FlNwSVv+QMP8QjAHMuZKXPeXop0IQ1Jfe9vnKjIFM8rTSgEwKHGeA76t5hptpmapfQWgCwzJJkphIVDErMcu7kidvZ6BLdnN5dP2hQWysNjh1rEA2KbsC8Nx5NKfBOIXBtI/XDTCEpOc+TaiHGEYe3XAZ6eqF5l2B0ywT7LXozZ1HS2NmywnJURu3u4+UEPhV4v6QsjspIc4FuFGRLWFj5VLcwhEdTTn55XGTvaJONp6QcwjBI6f6yMwBNM4tv/1dt+U0qWbhbdzFtQW/8Nz38I+e/EF+4vuKeI4GYYz52Vcp5wTduIIMFVhNS+LBvL83V99Q+7A/1WR5FzaTA1IMIixaZsB85INpcGMjYTY5QHckdjFE2gImvXSiN8+eJ/Crb7+2VRK4kcu+ZjDScmj5PJr7FdACrl+vEhTU/URTxyi2OuTjMf5wyL5XIgPq0ykYgmhOPACGem7xwfXtwSxSg7TA1668iTGISTPJK7diLp2w0LS3MAOXBZYmcAtN5PgrRMnz1Bem0BCM9RpZ9w2y8c6D368WNDxbff/R4xbZ4C5Gfon31FNe6WoMhdpHOR3yHa1v4Ef3PoK8rIBZ5/de5iASvNu9PnmGVbLTZxByElk+dQJt+wjZqIBp0L+rIqy5pRmiGYGQUPz9FJFBcmkyAF35teiF0+iliyQ1SW404lKpi7GR0vbh5GnVMxumAl1IPj9lsHJ/Mh4FQdNMuNuzudRKOXxM6djSm8DQW8YQqg/rVe8hoH7ruiNnOa5tkSuZICWp5WGNe8y1vsqN8bsJD21G506x2ZjCbwYs3vsUd0+8i1Tr4d6H0WyNytxxPn7zN/hU8k4AntFeI64pB25bu82xMOGHrn6cFwpn+adTP0g26WERXeURJYcKhBmmyla09Dnaic6Sm1Dx6hxUBPrwLvcGvwrAZsknit5+nsxagTViymEZM6jSNZS+1zgkFyrmPsdLiEcmDW+KsT1GIun3jjMnrlGmx0HfwlheZLE+S2aOCawUUZzj4PyHAOiXM84crjMcGPzOlwIKnsbJeYMv7iowHbdabMZFVrpblBZLuI+eJBVg3dzC0i16QY/KZZ0Lf9tFtwXtkdKD9eoU04MhAwc2glfISZ/+2OVMrARkQ99gqbKElJIbn76B6Zh44za6bkyeETJSGicbGNEIc6Cc6YYtuZ3XyO8+CTpYfoLXWyRKe0hNp1iWGKMuRjgkKCuCoGfP2/zr/6FMwftvu1ZWRWO3+QTxdJPBwjlkuovTjB58/iYz6eBwwNL3nOPUj/8Y/qkJG2ccYU9scG1F2RKzd8Q750as6gcsEYDUcPIP+QoM38ENxvyFYzE3l06QGjZPJi3CoQpoVi46rDdMbAk7gUDOK2c2PzdEShhtV3EaD/WGP6eCuH7k8Nje00hhMTNWOik3bdO9dg+ZZpQfmQR2q2qfG6iqhGTqYUANIL886SEVQzxdY+DPo0s1syIY97EaBdAFBV8gkPQng+LHT/ugQ9ix6ZlFDB2qQlD5tZSkDnx3ntC0KY7V3x03z2AWvhYYZoUCjjZga+Y53hxU2tAmVUkL58F0OHG4xW1vkWxcISyogMyWtJkfJQh6jMtzrEydZXldMJibxuhVOfnuk5y0t4mdPK8f3sE1HFa3BSPylK0xTio5GN5hzRpxf3CFvDFgFFtkM+rsCyFIDR09iN5WSiozZSNbhSKHr6/hzdWxdMFXSo+w0r9Hrr3O7qT6aTlS2cM3/Y43GZ/TCTttaHm0t7ZxaiWML75B8vhphG3RzU2h6xlSahSszyEl6IWzHBhjaiJPr7+JaXY5rB3QjASVuUVqtSUAutEBw7XtB/srXUGSl5RTE6HnsY0WAsHHkt/Dm5DR2BUlA3PzeYa2SzOTDG/9FAtxDgH4tRzTVR3bhPu7KdMVnc3BNOmseo7Ytxi4McV6j/bQxc+GuEcbuE2lWxoj5Z+a0R0cp8fQyRMcKP3h1MtMP75M4B6C7PPE6xp6UkOkl3jnV3+UW/8ypPVigpga8nsnfobHZ/42/kKBsPdvkcmA8Y2MffOQSBNfAwy1yWxmKb9eSvr19X9hZYM7aLllhPjaV2EbNhWvwo6hFEGY6pizM6SnFhFJinZbOU969Du4Wp8r6Srrxc+zKQIa0QjNsjFPn8awDXYDwT+9Y7KakzSKGqBRzWe8cjsiKqvD2XIPKD2qegl7zQqHj78fy0+Rz81BV0UPzYJPlqQsfvL3OSw3CJImWrKF296mL1wyXXA/W0IXkpol0f6QHjZ8weJHLMZbku2XPNKVWfQXrqE36rQiFeXPRSEfb74bI1EGJcsgtBexihpkKd7+HYZTX9vDcXLeoOgLrh9OgGFviNAEWUFj/uAZ5o8uk+Vhp6UcKD3vK8A3AYaa9bAeT/PeBIYDNP8t7HLLdXpvlsKafcaxQ5qb9AOVPXRNJ9c8wTFh8Ysv/yJfWvsSVb+Khuo7jP4QMLQ06FePkQo49HM0/Lc7oFMVDd+20dMBkbRx7IfAcCt2KHvqnp28jTQi4r6PXU5Y2IfHbknSGYgygWG//bqXL8+Q6ZNRCkKSm34HAL+3r5PoGuJWnydKKVfCJcb6w56QSFfvyHcFTqNMGkS0SkpmZss9xnEfQ+wyzGxyJ5eI2n0qeQUmgwJo6KyLGQwnIzcbck1YWIlLLsrTyUG4//Aev/HRCdoRCc+deQjaAUbbgmF9Ef0N1bD/7h99hG/7iUcfDHc3vvgGYhRQnM4psqXwkP/W2pz0w2UenFmXbKUPwdDYGDM3GVVx4/6QuXAdvzHGOfUTaAsLGGEJMp35nTobU197hq2SwIt8DjSdG9kyZq3AfucVRHmf26OU4uMawXENM3eccqeDFUXkBgOuTqk9nZ5SwYtwQWDuSEQoEc7UhDRKYLcqivXzDx20OIOxZxL1E67eTxgGkkePvz1Kk0560nJmgyy5D4MXKE0yH4G7DEIn3vvEg98XQjDf1BECLiwlyGAHLbfMN9RTJIJXRsoIi7mUc+NVvqn7FMlynfTEPPqnXsYSkmV5SwXCvDmyU0sPb+b4ZbTtw4fEM3e2caerGL5DNInye1cl0TSIKUHRkBxGD5/ZWvge0ookyu6CliF2h+zOOFR9FTFuxYKSKXmhrOPfl3iJOsMlkbKjGZxNYobTCjC+CQw3jdkHBDRv+Abd5O3vN8vgheEs8+KAXMlGC8dEMczefh5NplyL30u0r9GfX2CnMsXM0x1GepmXHv8uRJrh76YML5/iw+f+JDktz2eru4Dkx4xfJapU0Yo+qfEa/5+DLplh8ncu/RQ7pQZjR+mmZEvJaXLYAcDQR0jgbqrOypITU/HqbNR0rMEIf6xKejfzZV6+8XZHxawW2cqGTGcuaXuJ3iSQlJg75CfpULNkIqXGtKzSogXnS6TDYxyz1ni/+xXIUjp6iWlbAdd2LiYdjAjbI4QmuNUYYaeSb3XW+dXPjmj3Mx47aXG3bbEpa2zeVYBstbPFuccrGDmXwHPQNw7JO3n6YV+x307u7bClnN5GfQb/YJfdist14yY5adNLPc6kEpml3Le3WSgvcHj3kNZ6i9VnV1n8jueIE2UHEhkg0PAvqzPnHSrHv6on9KIjrMEcoqN0UX5wksGknL5eEbjtTQDGlbeQ+ehfCz7euuyKoF05zcbf/nvEqZob2r+19uBzp+CgmzqDwwG6rVG9mCN/cTLDMA7RHeVET52YAiTbSYVvfF+DH59/ESF0dEzEW8pOnLyDHwVcKGb8b5/5eX701/4jF8qCaBhh+RbdkkHf0ygFmQKGpSoyAyufIMMcMjXfljH0JlknkSYsDJZozf0fTPd1RKZTPu3ReuUWhu+SX1F7kkwrHVbT1L7FC7m37Ud+Ve1tLx3ga4KBPwO2Qc2MSGWMsaT0s64JckZGN5pkVD+qsnlBx2LgV6iXNGq/nqGFcPTdBkZZI7LU76aahjw5+7Z9ebBqeWwxYHfqcUCCBpXBdTLdZLCyiubVmT/c57a3QDLRccNwln1NsBQOiEpNpGlzNp2h2ofteQGpxvy5Jfz+LkGxwZW9K5xqnkbUy4SRq4ChKRinfe5UPs0w6ZDXhwShQTb3sKootk20LKNsqPdfzmtke8pfKS0aZN0eia6A9qvVR9CQ1Ht32bVVufTyQLUgvVlK+qZ+pa/Of6W2THo0pOCY6Bv7JE+fA2BUVYGOYFBD1yKCqIHow0Euo+JVsUaqzPhw2UYApTc8znyrCgB1kxaDuw+BIUDS1ChmJRKjyJx1m5f8a9zKungjpXOtScawWbEZWg4lLeBbrSssa6oqoDGVR9MEC02D+7sJ0zWdte40WTFAahJOLtHe/BJuJUCmgn5ikd+8glUuoFkmzb7yYXK9O9TSlOvm6C3AsES+nqcYhCTmTSoDQal9His7jmj0WfmzFo/8XZfC9wy4W32VgdXHXZwMsTfy7N1OWLPUO5kpvt1P0SYA/a3jpP44rK8Dwz/CJbOIbLSG/l8hnnlzNfNN1iZZmkFi4TQrZKeUY6BfX+Pq3lUOe7eoOC1ezE5QNm6yH5Qpxl0wS+QuPkKUwT+8ZSKAnzweszhlIgScW3Z5417CuSeU0LaMAwonF0HTCI96HH7kT5HpJu8f/xL/zPg/+DPLL/Dug19l+t/9LZ4Vr+CeK1IceZSSPbzuJv3J3KDr6SKZfPuoireu0nmD8qM6O78XE5w+ifHyLShUOAg8pAQnSCnQY6mrUEKKhphXWTX3aAM9DhlOn/ia62qaKid9Y0/tV9RV5bTetODZ+9/JYweP4i0JZKCiR1bBRxom8aSUFOOhwXprxlBzHkZfx4s1hhmkWsTYW0PqeVI9VjTjlgIlcb7OjBRcmL5AN+hS82sYox5aGn8NMARY8DVeaS7xqeYlZv8QwYUQguUZAy0OGWo+jjMgnz8ikA7dJKTiKUNl52y0XEyw55GVM4wMSn1BNGcidR3Le3vPS80BMSENyGkSo/YkUQa/vm0wS0x6FPGUHzNINSLrYS9OopdxbYGuCZyG+tuDbsyotsSUe8A46YO2TTe0yS1NkwURpZKHLiRBSd3DlqaiaF494kXboTZUDsTQSwkPJdlkqPOFxSamfx8rf4fl+tyDe5CZZLSZES4fQ7+xDlHM8TmTkwsPgY/5iRfICj6FxRLdwCUN/uvAME4ke4FDZLnkwx6zR0UGxujB50YS4Nca7N/6HdqtFG88ovjIsxiVx0iLAjOoYER1SrHBcOFrnQ7dFXhJnoEJnzta4GhKEsZD0mmPGNhqSMYnBLnCChqScquFNxxys672aLqpgE24qLJm1qZECE2xGFslzI7xNcQzAFtjQZozyTL4nS+P0TU4v/J2YCgn7RBe9jAgkrMnEeVyDr3yBMn+Z5Hpw8DAey7afOApB18qR1bzl5l2JGfyGZ/rKXnQmw9Ja9IyRO9+lOnrt3iX1kYb3kLLraiSsuVZ5JuAdvE42s4h2UwVKSWDe9vkJ8yZWV6QTtruRo8ok1W1JP9f9v47zNL0rO/EP88bT86xcnd1dY6Tg2ZGE6VRAkkgyWRYEGvAxl5Yr1lYvFyLfxiHnw0G2yw2LJhgzJocJJSQhDRR05O6ezp3deWqU1UnxzfsH897zqlwqrOwJM/3uuaamVMnvuF57u/9ve/vvbqBGCrBMWzDRFSaYIFSrNOe6gfrax3BsM+lKQSvRVTetSYDreCSJD0jY/WuWNAjhvOkUFnFxeFyUGG2tfn4XVyAN1vyuhw9kiSYC1NfazD61udYz+yhmhihs6ywJkw+OPMyQnM5Xz6C65YxrghUC2onpggYQd7v/E/4bBNba5KhyInQFewfeJR/Ur7IeKfOc4//KIFYjJVQlFI9hOuC7fVGW4USiukisHCUINMtHwouw2aHZCDF5YSL21TIra3RUaGsR3jxjfam36Inoyx2VgkgiFgxql3euH6FiK7h+E2MvDy/sbJCw6rzpiUAlXF1jTUrhP/qeVxX0P5iFc3RWA+3sasNmut1ArEAL+WrOAI+aF7FsuF3P1Pnnn1yTfi0fRcz5+U9OlmaIz0RA6CdjmEUSkTMCOVmedN3LqwtoncEKTOA0mhSimS5Eq8RqFaooTDhajiVBVbCFkPhIc7+9VkC8QCjx0fJPX4X7WAHXcigOmwkuDrT5AvLE5z8zb/hK//43zHzoz/Hd/y/v0itU0SbP4brgr82xXLAjyMgl3B7jqTNxAg3iq6zavWSTaeSQ2gGxVOXe38XQhBMBqmuVnuPtepybI+wOix8Usd1XXSfjqoqFEiQLZ3n7sAMjmKh6Zuv03DUxN9pM191GM2H+Nin/gx252nVWphBkzfL8p5KL1ksNAUIDacp13zHU+fMDcTQiIVRAz4Up42ltXGESqTRRrF9hCcF629cJH50EqHI11i75LkM++VN3NnT728FMDy1qNKo4lMEmlCwDZ2UKfdvZU+/HCIccFntyHvWLkqjt1bRoGLGyLsKvksu68+qWBmZQGj75GdXA3H8o4PLe91YFEU4qJqDYgr8WUFo8S1q2T00JwyUYJrMcoEr/iFabUlS550juEKwq7lMIynX6vHTRQBOjUoFv1NxMUuLXIgkWauvcSh3CHvvKPaaS9xoEPRM1SqX5gFBWKvTaqg4w/0YoeMlpTOeOh4LKaieU+tQaAHh2Kyvd1i+uMxsah8NRd5PC2aKmO4SqC57hnfye7vxMLamolXk/Z/JHyJUV/GvysoI6yFJDNWQ3HdWS/JcNZ1Jaucv0DIEavoAY8552moUMZ5ioeMSftXFmHNpCBfXH+1VfPR+R1qQqghsxWRRD/C7qb/E5z9KqCbv6W55tCrA8SrBkkodIWS3weSQPA67cipXFmxyCYW5ah4UBzsFzt4xtMoLrHrJ/QUnTWjuNEIR+HMJRpfXMOovMT77Eknb5gINzp17HdVnoHkGPmMYrCdrrIcuUoq9wacnfor84x1iRzQUQ5CKyr1xRW9i5qVqHhiOsrjucFGT90t3VEUXQveOe7s48Nr7WsXbxPC/KxTMff8ALf2OHZ+RC+c4K+QCUnX86OEAznAKN+RHOXOF333ld0n4EwTCNpfcIWy1TdP2EbTWwIhj28P82hWNSzWFH53skPW5DKdUBDKzqSrw2N1JDMVH0VpB0VT8mThOq01H93P6Yz/PpXd+nFdqY6y1Aph2g+zyG7wjM81PF36dx898mXd8ZY1k6QoNnwpGigUrSNth06iKrRj7kIEWgNnSJKLZxlpoU7VMhIBg3SZMidGmVx+PivmA1yvkGc9UByiGAPcdMCk58ibtVGSAn9qtEnYFAVfQTgn8XqBrRII4qt4vJfX6FFD9PSOa9noV1zB6pK/pnYvZ7F8zF/0srhLAchoEE8Hed2iHUxj1In/3vv+Jhyce5r6x+zC8OV1bewwBxgMO7933G/yDkf+LYd/2YzY5pOE0OxSJ4w+UicYWWRB5VKvQI4ZG0MDRO7h2iHa0/x6t0SCuomFGApveUxWQ82soio+wbqKYaT67orLeETwTk5tGvG2RNlzqYZmZdXGxRZqw3zNdyMpFuLm8Tnn0COnOArbbRmgLlDo+zHRMPi8ZIapBNSKPUZF+EHXKHyJZ9/p/Qja40Fz2eumEwrvfeZH3PraIskFRb664OC2wj08iOlbPobd/Ajronz+J9fgJ4lENy1GptcC16mzFalmSGDeZJLm+zEL6PppKo/f31FqNjnmJM2++SbYtExWR/bKfxooJkhc/iFXz+g73DFYKwsKzTS+vciVWRFU0OtkpWf5zpUNrQqClJ3CEwFetEqzWmI7m0IRDIimPYXtU4Ip+n6GWexot9y7UdXfbDEOA6YbA9aalv3Kuw8EJnYC5ebl3PSXObAZQvKGP/m45aFqg554Cu45VeK73mnee8PGdzwRxajKQVb3Zq0+mbc51x8JoFVpuo3eMTt17N6rr8oGzL+DUrqKGPaMtv4kzJtmpk4wiltdxhlK0CiU65Rqh3f3sa3tI4CpQP+wRQ3MzMQSwA6OoNYF+VUG4LqFjMpnkuLDeht0BF024fGlI4+llaZ++vm7gt12SE33y6zfAZ7isNQ200Jdp5r5IWxXMtDcHlicvwBUhr92EUSO2fwiraUGpyNV9j2NkXNpLCu87/dvsr8wweymCdamMWJ/FOCfPZ+2oTArGF4YZao5R0Mv8mX+MZ4ufYN/J3+G9tTqfGP0mloePMO7rYCkq8x0/dkcDu41da2CtFPEPS4Lj6AmmmzrDpoWhQDKQYd6Lw1vzGotx2F2ocWnBpVDsE3gtGWW9KR1IBIJiR5beGsUCoY5FeyyLOSGTZbGCPLenLioIfY2cXWO2GkIXNrufPUR7vcGDyw+zHrJoleq01moEkgHmfDUW0gaxN97ivQ/4+MJrLaoNh6GUyqfce7m4ZuC3msRbVdyk50o4miXQaBFU/NuI4WpllWBTI1jx7tfcHqbTFoHCLAgw1DRO6SrrYZXGpQbVQpW9j+5FURWEqhB6bBK/lwwstwuc/a3P8pW1YRprNYIjWUbe+zCfefpbmB0KMXLu3WT+4170VpyZQIKaT5AwBb61WRxFoxXJcKNQdIEeFaydtBFCJbxnjOKpS5ue03Um7aJRaqCpoBom5bMay5/33BtjAVoYmNOnKa2a2GoTI7i5VLM7y3BhvU3nybvpPHE39qFdtGotjIDBm2WFiOIyvGrRdATFDnSHj9od+bt86f69JoQgOJJGdVogZMmnv9NBdQycziJWpd4rIwWwJ5K4VgtFM3FaJdxkf68EWeoqFJVqXSY6AirYLZeAJf/fSPcHocbDKiuOjdqOgF3D7vhwOiolN8jYmqB+WFA/0f+udlSuL5XQOIGhweGuHZb7vk+R15c/5xBaPE916ACdnECE0kRW13BdhXVDquHzmmyDmSqf73kdmC+coZBUOZmU79MpO5ilJZ7z1taD2YPYe0ex5tpoikvW6wdtLq0iMAmobayGijPcv5baHmke76wykVPZM6KhLMjXtSz5Ob5cktf/9HViusJXvP7zJSNFzud6vgYbDO+EoB0NYtRanPnWn8WYfArDUgjOLuIMp3vrsemT91+1EqdWjdHWjrE+fVE+ljrAHs7hBvfgyypcaDmoHfC/5VJxXMxknurlBVy7v750soKk56rd0KOcClxkJPEY0bok0d0WJQD/lqr9ii/IeFieu4m8HMNkaILZitwfOsMu7cNRwlzlVEc6xc4bY4Tnz3jnM0lovU208IscK62jCPAld7E8M42SCPZU5LH8GAiwgrPo1gyL8Q7DyX5yMe6Po7mCed3FF48QGE6TvWsMyxUs1h8ihEHQ3HxtCz2KmnoIxUzy9YS3ieF/RwhFQ4vfhRLYOduYDWU548UjDT0iL2JFwd47RvXVN1isLPKtx78VPSCzSM8V5BylQLuEMAIUXtH5xLLGN+ct7kvIGzWfVHFc+OtXW9x/0CBTU4gZGcoVGfiGJuUNVzx1herIIZbv/zBfXNrFn8wd5I94ln9//n5+5wP/iQfv/W3+2yP/C6f3hngxvJ/pUT9OQN4ozS0zDLdCCwrGvtVgyTNccN5akY3XQKDpcMK+Qo4ydlvQ0lUCQzK4Di6ewzb8O2ZoD05ovQxQVwkM5vuX+bLPwed4xDAWxNF0Wuvl3vlA9aEExhBCwXUc2qUqjqpjhkw5G8kbEH2lPsPsShFQaLXr24ghQLBZ5nvu+x4emngIs1LY9LeNGA/0j9PQIGI4rEHLZoU0mtbB56tzlXFUa4WoT26aRsDAarfRw0FapgaGgxnt0PH5QNPwxYLb3jfvc8HIk07ux3LgD+ZV9oUcHvI8eJbWbJ7MWJT8d9NW2jTUJqobI+QRQzMVAyFoLK1RGT2M5rTJ+Sv47BIVEUJ4JWhmMkpUdykFI9jCQnGSXX8HFvx+UrURaoaLPyYfbC71N5Rvv+cjfPSuD2363nVvpp/ysDcT6Y2Lm/6uvXAaUW3QefKenmHBTuWkK15wHB5KkVpf4YUD95CrubieedLQUp2Of5FLzrMMt5dAQGiXvD/sKATXDpI/fZQlnyCTH3y9R3xyU2iYNueVBSb9e3G1ALkRk1fOtmk60NrrZz4zRHx9nWCzwZI/QTJQ6xnuuIagM9TvM9Qzj2Km34daZ9sMQ4DpuoIa0nrxwImp7dlyEVJouy5GFQJDKYSmYrb8tB0XJamghPchAqNYi5/CdTf/Nrt6CWGmELoMIB5K2lhKEAcVt1OiqTdxXQcr5PCXsQmWkimmnvsS4KB0iSFg7xvHySUQxUpvhmE329wtRQMoP6qy9s0qjufOlzJcCq3Nv1vdLa+H8IsyuEneLY15yh1wEGQ8ZfPLWY3jizbPLrd5M6CxV2mjbtkJYyFYr0Ij22TI+U0SapuZDYqh48KrFyEwlsVRVMLrcwS82Z6z6gjzux9AzzqM2q/wHZd/j0+NPEVB8WHMrSFWpjHPKjTGs9iRIK4LnQXQXEEoEeMX0h0s4P3zb/LXRpI3Dn8EgHGfVDmXwnFcxUQPWDRPXZajKrLyu3X0HFebOhM+z1gkkGLeG1lhN1TmkoITc8sIXF463S8n1ZMRGs05LG+AyKIQhAwbAfiLVTpjWUR+DyGtRaBQx7VNmuVxwqGThDotllcFvslhortSjD+xn0wjRVo7QHmlTqvUgBA4wmV1NIF66jIfulsQDwv+n7+scfdenRfs/bzgHCDe9Fyg4/K6UvaPobougbJDpdU3tAAotooE2zrmfEGOKjh4nLkE+Ba8/jDFwi5epR2JcP6L54nmo2T39V0DjRNZcn6Z2Ni/91Hu+uc/xPc+WeJb7yuw/0c+zPiH38n6kaNcSgfQ/XmCFUkGCrZBK6AgBPjXZmnGh7b1u18PRlzgtEALQ/Ku3TSX1ntmGCANaFrVFp2WPOeNUgPVtTBTYWJHVGb/tENt2iY2HAcEhSurLJQSuIpFILF5HnI8Jv9/bb2JM5Gn/q9+BPymV0pqcqqscDhmk/YC+fmmQHiEqmWNoEcFqm/zvRYYTmO3Gwhc9i4so7gWmmlQfOMCKIL4kd2957rZOE5L/jbHqWxy5QZJNLVQiJbniB5UBCnVpNWRe62Z6CuG8bjBGi56XZKnVsWPq4apOyo5v8L6+9RN7+96lRfVyF78OxDD7vgon6jitCAbvYpitakO7QNV4IxkUGyLVHGNSlgmEopeQmxP/Ywkhu0O2lfOsno4zSWfTUdp4RTqqFaLl9wWmVCGdCiNs2+MTkl+j7y9hOW5twcN2Q1g15TNiqHXIxe5Osc/+8EYmZiKKFZBU1hz5Xk98tEH5TG8OMNz0eOAVAzHfC5GeYVWZHMyupOM4mu0WBs5TmethnBccnNlWg8c7B07nymPScC1eOWV96OFx1ldkj3NdSPKEPMEo5PoMUFJdal4lU6ltksgP4TT7lCfW+l/ZkaQ9AbCu2qUuBWh5Zsg3yyj+k00fz+Zkd7Sn9uIhDG8h3blZYxYbbgs1rO4rqD2dx+meaSF6wreqN9LXQ9RsOP412bR6iV8uQRquYNiw3hTvtFdh95DtGEwIwo0OzIeDOydJLG6CkIQrJZJkkWLbBg9oSiklQCzmkakUOPEP/1BRneNEVbqiOKjpLXNSjiAUH34pn4YNXpo29++lvE2MfwaRzaS5WJAoW2r1AP9G7y2J0v4yioncse4Z/Qe1MBlVGw+v/oAAIFWGxGwSZ5xOBiy+Y7RfhCQT8rTbjvw9D0+jEWXqJGmurKC67jEDslFfe0r0ijCaVtobRlorJ08R+aR4+SmRrgcGOHF8Xczmw5zLhfDiTdpGH1jjGsRQ4D4UY3wfVGqoWHcFy9juXKRNFoOH69+iaS1hNVQJNHxEFy8QC27Bwb0ZILsQ7j7gI+m6qPllZJ2hyGrQZhpOUQVaTLhi4dwtb5iCKDGjqMl7wNkjyKuiy1UzJBJMBGkUZPvuXJ6iLWz3vyurYqhV4ahewPtAYxrEMOJgNezYriYA+KLyWEN0RTMb1DaLrCXmNbsEQczaGJ3bGLHwrQsg8yJEpljZeyGiquoGP7t9uk5n0s59aN87O7v5QurCssthW8ZtkhGFXQNFtZsnkzbWMY4LbVFVW/jdExC3sKtaCpmKioVwxGZqTsQWUYRLp3UMO01r0wkESGqu9TVBFVzHZ8dodFSqbdUbB3S1WGW4hrxhA4KNBavPQy2PuOgGGAcSODkkqivbyaG+qdfxg35se4/SDzcJ4bOAGJYKEkFODKawtdqcGVkhKkZQV2t01SbjK04qMc/wvm1EXaxTGAojRaQG3LXCTTSgEsZBXVrQ62HuGdhvZBssuaUmSgcJtB2SOzz07bg5bNtmvs05kb2sPeSVOKKapBcdLNC0hoXGHMueKW2qqwuGlhKeqUuGAlB3rP3780v3IKGAkYDEsf3krxrH1pFUHdAD8uATc89jVOfxqme3/Q6p3oJxXPeA/Cr8GASisSwWiWsrEqls87yqSs8v65x5YG7MV6+jGhJ45kumv/wI9T+9d9HmZfnxhlKUb00j9BUAiP9zHlnSNA40r/nk4ZL1RY07Q1f6pAkhv6vqFiqQIxLAr/W8VwRDZe7Yg5XNIU1XfCjZ1tcCKvsSjTZilgQilWY3/0AgfIydy1/hcJahfCaVKcvL0C5Ljg2pVKN5gkV5wiHBeByPnYCW/cRjazwZOzf8GZwD3969w/SSmjoRQt1ZQ7jsqB6t1SenXW5xrquza7RKeraEf51IswbhsGPi28lHpG/O6HZhBSb5XAcWwlgRNo0XjuHVSjhS0gCsaDvp+UqPRKZDKRZitGbVzqXhFEzyKHmAi+e6uC6Ls21GvOvLhCy1pn2bGIvBhxCbgNVV9ELJdpjWerRPAmjjrLWwV1/H6AxHjhJzdKplToEpqRykjqYZ22kRr49SqXigAtVbyakdWASYdkE3zzPtz0V5OK8jaqAhcoiSXK1VeyAHzyVRfUU1eBKg0qrgrNhtmbZrRFVQ2jnZnBGM0we3UPdp2G3ZEBaFU2c0gxp7QCtaot9j+/b1GNmx2AieoTJ8HHG73sQfyZBKz0mewzdvqv2W0EVIRS0/HEst0Wr7vYSFL612ZsqI+2iO48xslcldljutxtVw43OpCCJoei0MeJhxj9mYEQFl36jTdwjEZfLYZbr8r8jo5t7+PyeEU253Oo95rourVoLyzQptAWHIy67vJ8xXxOYQ/K4t8sjm4xnuggMZ7ialPfXvZeWcBWbQMLH+msXiEyNom3sy1cUHFdWa9haa9t7yeMRorOBGA4bGlWrCEJgRPu/Jx5RqSg6ek3GQs1VjdH0e+Qxe1iXhmAb0BkawkGhFJ/Elx28Pltez6ZPk3FAVj0LQGVIVspYe+RnDa0sUSKDsfsHWBc5Uk2HmDtNIzmG+up5RLON++g92EKwGL6Mu1KhDbzRlGWkAPbeUdplGc+kOktUPMU67PUQujXRM4gB6HgKnnLRK82sNRAdCycVpdAO4Q/pRIYSHH3fUaILi3w+LpNhV3zDTIbkcPutVUp2Nk6gbWFV6jSX14nXm5gduHSgr9qFu8cE75wkgqyWpXCgtGRlgRbeI8emZBSmdXm/lC2X4ISMizaWk3ZSEPeIoaNE+eDqk1zsaKSapU1qIcBIqp/YcAE90T//I2kVVYGrSxbxiI+yncaO1LHWXuR8cTfrzRitaJL1stc/P38Gfy6JcCHc0Mg05XEWsSHCDYNVo8bvnPwd+b0iBqMF+XtFp8zu5gjO5luJTCDOrK4RW/bU7CWY9F0kUptklAN8o+BtYvg1jlw4R9V0+Y35e7my5+ne41/0zWJa8O2JxwEwfWUOiSustWMI10Ztu6yHO+SaLj/tb6FtONP5pCQToxmV/WMa+pJLJJzBaXdorqwT9Baj0ltXAGiX+8QJVWX8Q48R0CCguhQ6Km0nSzo9jRAuRa1PDHfqMdyIsQ8ZFNN70d+8gKbrtGwVzXZxKwWC1gpWS6XuBeLCtgguX9yxjLSL+w8a1BQ/hQX5vY24QDEgNKEyW7DJ+OTm5E9EcDUdp9nG9hxefXv/Hnr+3fJ3e4TRcpUeMax5JjwoPoSQZNBR2gQS/VLNLvkzK/2MmVFZwVFUOsHYtu+bNuSxHPIPJkSJsIJP8TNv90vrrjBJ2ug/v9tDGD6iYrVMkrsahIZaVMuAEOj+7YpR3ufSUJJ0lDD/bU5jIuBwT8xBEYJ8QmVx1SZtwr6wyqnELGdSRZotpacYAvgzcZrL63TCSeqRHPsj8je7o5O0VssIVcGIhojpUCFO2Szg60T5r9EgvxkNoQmHWCPHfEInmvRjpgTNpWtfN7UZh8CIglAE1tHdaBsVw46F/rlX6Dx2Agyd6CbFcGXbexWKDgJI7pKbZ6S2jq85SV2rU1frjC+7tMaPc2XeIlFdJLRBxdroBFoa2XkpTaakBHtuVF5PmTOHiCoubtwgEVF47s0WzSnBan4SxXWxETQdneHEZoOQ1rhA2EhyCGjF7pDn7Z85XVcYD7jsHdXZnVfJJQYrGk3dxdeG0W96hH0/9CH0mkvDddG94d1a6mFQ/XQW+yY0bqeK21pGCe3e9F5PpG3WibFeL9L4SJQv1/6ML76+TN0WmE+eQLQdzAvxnsoI4Ho90xuJYeXSHKGJPIq2swqTNORv31hO6uz3HOBqyzSGY+C9fs17TkJ3uTsm75kvDmmc9kpt9wa3B6txTzGcm3qEz33kXzHsc5hWUzzwhz/N/X/5c7z1agFNdTk8AdXYMOH1WUZnXiLFGjP6KMKxePDMLyCEzQ8c/BkSPpV2Vqr78ZOrCEtQOyHXsc6cgqXKwNmMBTgU+Si/5dvNtw0PsV6/G68CGyGkargcTdBuBzGCFs2zs7jtDqbnCn0OGYB2iaGp+fAFIlSi8vqcSwrC45M8de7LFIouL/3VDKd/9yXqVZuIVeE8kmmf02wCzTKJZBThunTGslyoJ4ibDahq1JbvQQudYlidZbYuf5d/b3/wduRElCuhK7iKXHeW2wsoNgTvOo5raGgvneEdRwymRjQ+8WKTIPL7764sQnJDoOj1mQYXaziuQ60lAzfLtqirHWK+GMr5GZypUaLjBun6KOv+FrguFbdCwV4ks54nsydDYnRLRl8RhPIZ7km9C8e7PxrJcbRmFb1eBOQe9qpP/k1NTlILdDAbDmpYgGPjKy70RlXcDIxEnxj680mMeHhTn2EwJU96tVDFalu0621EvYYZC6MFBLu/26Bdcqm+6KnU5Fn3eoVjw5stirsOpa1KPwHSaXZwHZeCKv92OOKwa7+C4rhML4DiOXRXZ3ObjGe6MIfTnNojk4GZolynwnmV2szSpjLSLhxdJpbtoL3tb/J4hHDVGi1cQoogrwvWLa/9otSPP2IhBUuoNGsyRgmVx7E8R/fk7u3rRXtqN3/z8M/jTA6jaDsQQ6/30UQG+8nWOdrBBG2vPLh9VP77wOIVrrhR9Ow7mW8pjNUdNDFHMzmK9twpXE0l8cSTKC4sRs7jrDd51WfSciwOZg/K4zCapYMPy1WJu0Wqimfmpnuu8wRgg3pG1+jnqiRjyqJMNtvjeVbaYeJhL6k8meb+wwlejh7mnXf/Gl+KnWDMZ6EPMLxz8il0x6GzUKC5vE66UsdS4K9T/UR21DRpY+CqLd75w+8kMZZgpVMiaBuEWhdwEL3135cVXC07zL5TMN9xCY4m0IJ+Khf7xBBdEPMqo96rf4D7G09TtQXhanmTIgwwPhrB9hL/Aojn+n/XNcFIWpXOpEmV+doQdukN3MYsLy6eoNZwUTNpqoUqHaERnjvdG1kRLxtE23KdqTo+sGzGd+/nuSvP8cLVF3D8MNUIE6xWaVsL7LKGcY3N10wqmmZO04iUusTQJR57AVvYjK2c4BsFbxPDr3EkAglUVePc39lP7lnZi3h68TSfM6T5Q+qqV2ceCXNCkbNSsuoKOILzcQNbg9xbmwPtkF/h8RMmH3syIFWBRZfgkFz86jPLmEm50TeX1umUa3Q2KGqrDz3UaxROGS4rLQG+UTQv47WkbiCGO8/47UELCfQPHESxO1jVI5Q70uVKqTXxiTJ2U6EaiwHgX51GsdrUctuNZzbi8C6dlu6n7PVoCEUw8e0Gw+/RmSvYJPQWiqHhi8tSUmDTb+yiSwzblugRQ6vTQagOQvgQSp8YBuPbS0m3KoadUGqg0ikEfMeoxftzgzdNgHQoyoxn7ey6MOemSQf6mTXT6ytRYxZttx9YletyYdN9g4khwB/Oa8w1pVrYTajnkioLq/L7vCev8ObEh5geepBqwyW0oazIl4nTXJLSVWXsKP6uzf3+g7TWShiJCEIRspTUNmiYaxitOL+UzfIfMxl89QwKKksxlagh8GcVmtdQDF3bpT4niSGAfWQSZWEV4ZVhaS+dQVTqdJ6SmdN4lxi24wMVw5WSQzysEB6R5yxdWGQxc4LXEid5LXmS4VW44ESJtIso7RaRDcQQTQ5bB9B29o8imZHnrRK0yIsRQq0YyTAULYUHDxm8eqFDWXMpjchgrOCP4SLIJjefs9aowGVDn+G6Nxx+Sylp1ZKEadzv8P3vC/JPvjfKTmj5BT4HWRvpuhgtaCpuz/lRqD609CPYqy/gdmQ/SK+/MLiZGB6KODSVGK1mCSIa4XdM8pKaJqrajD48iRMA/xuby9y6UOZXcRWBnYxQu7K4qb9wEFLe2rLRmdTJ9QMg5VA/OO0Sw7jhMuJ3SRsufzOu8XJaQcNll7nZiAVkKWmlDpYN9UgW3+R+LEXjk/f+AMG1OV69pPCIdoo9Vz5PNTZEoLLC2FufIWVUKVUE+1/6PRKF8/x24O9xOTBC1rCwpuTaGH/VxlWgdkReNNaCwDYkMTSiPlIRP43pjxNY/0FigeCmESMT/g5Ff4hSNYqiuSi65+rnl2vVRTtHQHFI6/21JBFIs5iSJHg+qeA/dIh3XD2J5tq8eMoiPpXh0Hc/hBky+RtR59WwxUzdwV9dI+QP8PnhY/zT6T38s99qIwwVHHjsrr/GP/qfGbI7zNSicj0d7Zdp5iLDvJJ6haYlk0PTrSvEqjrB8Tz2sT1oL8r+n915jWYbQqoMjI/Wr+JuCBTdXAJHVYgsSkJYbsn9bnVdBsopfxxldgV77yhCFYzqu1iIu5jNBqvFL/LGwT0otsLexwbvGR3Pmdf2kiv1lCS3fs+ZNG24nPMp2J6SWs6ZBFouZlRglldQ7A6N+M0rhoERBcWAyD4VIQSxQ7sonb6C6w0sD0QDKKpCdbVKo+TN9KtUeupKcFxl5H06lVMqilApEqHuysUoENvcT66ZGo6m4tSadCcttWvymp/FR0RzGfW7xPYqxOoOs+sCNXkf2u6foVnIYaa3E6rXw8OsxDynS8+sS7Olg2Ti+HZiaAe9tSo5OOQ0oiFwatRsl2FDjtFpRbwZor/6x73j0k30LZellDPhPsJbtlzX07Ht762HBZYe2LGMFDaUkipVhA7R1beoDu3vlVW2jiZBKOxdXOSKkMmFWUdhvG5hB1wsfwT9+Texj+7BjMXYo/pYipzDKll82e9DFQr7M7I6AFXB3jNKvSWdSduK3LcDmjzHbnRzr6rwqiaUZbnHKqeuyO88NcJay0dGL/Wee+ShXQjX5a3QJAjBhLOO4tj94fYe3DHvMy4t0FxZJ11vsTgZ4aW1U1i23L9jJpSJ4PhtfIaKsl6h4OsQMPewyz1P0xhFqFIV9mUVOkWXVb80ijFiCqHdQ9ucSQMJUFwXzTfEmYRcj/RKeZtiGBtL0Fb7VWJjQ5tlu115jcsLFrmEwqW1HNhNXARfWTqO40JoLINrOyyE9kpimJPE8EhliJDWxkVQrcrr8e4j72BPag+//ZXfZkkpEAzv4n1/9ucU9QITYpStSEaHKKoqqlcarS+6LAaucDV2itD0MI51fTHk6wFvE8OvcShCIRvOsuCuomgqHbvD75z8HTpjGVxTRz0jN7BYMMV+7QoAKddroh5O0don8J92wN58wf7gB0LcvdcA20VfAf/uNAhBbWYJzW/2zCjW37hIa93r+wCeO/Zo7z1ShrSMNxNen6CrM+9ZHSq4pG5AMQTwfegALgJ3KchaJyZf31IwlAZWS6HlzfQKLshytusRQ00V+OMh7Eody/vd8aManShU6i4R0UIL+TECBq7WdTAdRAzl77YVDV/I1ysXFboDwodQ5YLlah380X7pjG0GsXVfr68QGDjDcCPek7O5J74zIRpORCk5Cq4LFia2VSYZ6GfAjaCMlNv1Nm2zv9A2vD6EnRRDgL9YVBn2OTyY6H9+PqGwtO5gOy4PJgWuMYLPSFFruL1SUgBfJoFVa9CpNqiMHQUkx1D3HaC91s8GxnSXtiOw/XW0ToiR6jCjjQx6RQZVi3GNqO7iywmaBXfHBba55OJ2IDDmEUOvDKs7tkL/9Mu4QV/PdttvCkwdSlZ2YI9hoWSTiikYiQiKzyC/NM/LB+8irDUIijZKKMjpFZW8Vz4T3rM5CFwLCgqGYHh052s9kNAxvblxY8tHCO9VSAah2IGHD5vYDrx4pk1nzKTq83MlJp3N8unNG6LrF3SyYF7tl5I6hhyzsRHTXjJgPOCiqQJT39k+vxMEBYFaAdEEzRG0N3tXoOeeBteis/TXANg1eayV0K5Nz1MEhPxRTKfIcgsij9zFxfF9HC3PobjrNI/YmK9UJNvaAmW+gJtJUF9cw+lYPUfSndBdW1Y3cjpTx9HlcVaO9oPT1bacfxbXZax3V8zmKz6VL+4S7PK10QfsgvEQuAjKko8wasrE15fHn+Y/vfMXWCDJ0/43Of6F/5uJU5+U71+4jJFLsrv2FpNv/AVXDj7N54bfCUBGt7D2yHXLWBa0JkI4Qa8keV7gRhsIVaAHTWJhgWuHWV4cJ75lPmVXCZxpShXal/F6TvUqLipXWj7GfJ1NbVzJQJppr3Sxko9wftUlaLU40pzhqppm5IkD6AEDPRnlIuv8q3CTZgfWtRg/w9P8s3u/k6Kl88F3GgRzMmA7Eghz39g7GLJsZhoxfHtGEBsaNbPhPK5wmeY1pj52N/OtReIVQ64X9x5APXuV3/79ZT75UpNMXGHFMzuZbKxsIoYoCp1UjKTnIts1oFmck/te3vUjXBd7St6Xk5ndzKZdQrU6q4EkCyOTpA6merMBt8LyiGG3LLyRlOTdvypLhlOmi60ICp7iupo0UVwIRaXxDHBLimHsiMqx/8uP7g1/jx3ajVVrUJ2WIziEIp1Ja4UajbIkDUq7P9weIPOYRuygitoK47oaHaGCKx2qt0IJ+gi0mix7fbmtmiTiF2wfhyIOQoCiCTI4LFoCXEG7Ku9vX3aLaZULf7IWwPTU244h98n6xav40rGeQrMRtkcErLx/298AjFgIp9OkYlloQmDh0nLqhCbylM5MM/cX0gCr2zM+NxcmPv0MojDEW/o6QZ8g5N9+I2vdUVLXIobdsklRIZat4l+fk8Sw+3vDGiKcZHR5jUtGhnIHSopgvFmmmRpDrJVR37qK9aBU6/dFhlkMzdEq1vlSMMhkag8+vZ8Qc/aO0i4K4kajp4wFtTq2I7Bym10tlVwCB1C8hUg7fQWAxkgGxxXknAWE7ZVHCkF33KomXJINWfrZ2lJKKrweeXF1CfvqEpFqg86Dh6l36ry1ItuHTAVqbhgCNqJQQrk0z3JMoIQPsofzfQMx6JUal897SaqoILx7iPr8ClZjQ/lyWhBruxQtwamEiulYOOXqNmIoDA3bc7R1gD25zdfMRE6lXHeJhhSmy/J4LXf2UfdKeLJ7ZQw6Z0wQWjiLbijo0RCZBZWQ1qblj9JcletIIJPg++//fgD+3eX/BKlJ2gGDsyMwbmxP+CRi8rFVZQVt2UUrwrRW4kz2OWholE7vnNz/esLbxPDrANlwlsWK3DA+fe7TLFWW+Og934a9ZwT1rNwg4/4447rM5MdteTNO7B2iflhBrYN5eXDgqhVA2GAPG/izCWozcjHxpWIITWXt1fOsvyYJmRMIcK5j0vCu/ZTpstoS+LOyKd8iw3pHRRcuSUM6X94QIkHsvWPEi2dZte8FwN/qoKkWdlOFYRkEBZfOYxkBmvHrz4RJ5UL4rDqnLnd6j80V5Bf3u030UADDv4EYDlIM1ysgwNU0zKDZJ4aGVAxVXwxUG3/CRNnoXiGEdCatbiaGg/oLbxS7szEce5V1N820PYViLZPw94mhGZDBQLvWxo3Heo/XhUcMByiGacNFwcVB8KEhe9P5yidVbEeas+gK/PieCj84EcSFTaWkvg3OpJVRWVpUV0KgG7RWSz31Oer1IDgReQ6eWZ/g3UQI1UawabMWUojqLv6sAg60VgZfr7UZSV6Dox4x3D+Oq6nSgMay0T73Cp1Hj/d6lEAGExuH3G9EoeiQiipyU82nSJWWWEqmeU/zMX7gTBY3n+StqxaTygqq38Sfl+fQduGzKwr/ftzkN44ahK9BvvSYINCSm9vo/GHSD2rEdJf1jmAip5JLKDx3qk0wUebNPft4My+VpKHc9gCrNa5gzLhgu2hFz5F0i5nDdF0em/HAtXs1oR8QKysumpd8bm8hmop/CCV6CGvpM7iujVO9jPBlEdoAQ6NwlAhlPrcseE2JY2k6u577AnbpPM1jDkq1jXry3LbXdWcYVrwsc3jy2ophYkApKYDrqVb2vn5Z41oHojq9cvq7Yg5NRzBjmUz5B/c8dUdWrHvEMKNbGMJhtq1z8rKKprjo3/IRnn/2J6h4ipEjFMzRDN/MJ1mNjHH6/m9nLaYQqdsYjosdHcP2DJZqRyWZcG2wFgW22cCI+KS67n22C8TDm3/fmNlB4DKrymx2dK+L8Bmooo6lBFlsa0z4Optekwik+OO7bH7tm6K4LYPCUp1aLsWz9XM02oLTl+Q9qaekMn7VU+xnAqPsstb4J6d+l//j40GeuNfA7/U/tRYKGJpBtqmw1goQ2FBGCuDT/QSsAJVgjaJrUXHrJFsB9JCf+l2yF6f46VN808M+fub7Ivg8x9xwvYqT2BwoOuM5MmWpZHQVw+UlWaaW96717vk+MLWHuSQEazVqoQgCl0OP7Wz8UD+iUHlAwY7J/++EElhmEH9BEsO0d52VUvJz1rzAO5YA3/rNj6roQgiBsqFMLXpIkrDShnLSUDK0STEU7damIFoogolvMzFECHBx1BaqoqEoA0o/Qz6CrQaLTfmZXcVwQUhi2MVIxGU1oFKddnru0Ft7DF8vK1yqKzy0fBYcB0dtAYLKW5eIH5saOCuwdTyF69q0jg/eA7uEt+QZzhQMh/Z6mfDeUVL3HeTqH36eyqU5Yh7Rm25UiF34Fp5f/CQlX3igWgjQrVr3X6PUH0WlowQwlQrDcRnrdPsLu3DTGVKFVRqKj9e98R676/M0kqNoL5wG6BHDyeGjWIrNGW2Gt3StV0bahRxZAVG9iU+V915Yq9Po6DgjmxVDIxrCUhWUtgXNNqpXnln0XHszermnboNMwMr367eybO0xVLwkijK/QvC8TG7EnnkcUzN5ZfaV3vOaIoTq76CsFFEuzrISgXAoRpAaoegGYuglDirnHYQmvRzCk8Oyt/hyXzXsZKUBTbEtOBNR2EdFJjK2lJICqN411NZ0fFv21q4BjevCdHkMF8ErhfuIBBUEMLo/A4pg2Y6hWG0CSxfx5xLY9SYhrU0nku7PMEzFSAaTfOc938nFyiV+Z+QL/OpPPcjV8QjR4PZKm3RInp9FY5XQyw7gMqM2KUTOokeg8PzX1yD7nfA2Mfw6QC6co1AtsFJd4c9O/xknhk9wOH8Ye/+4tOp3XRKBBKZa4OnAK9zjyqyPlc/T3CNwfBB4c3CQaHj9XJ2cIDCaoT4jlREzGUH1GRTfvMTqV2QztpZNYLuCc1V52aQMl5IlsP2jIHT8mX2sdQSKuL7xzFbY9+8nWr7CUlvWaUfa3vDhpkAMySAqtHhODrbfwXhm0zEbDWM6bV58sz+iYHbFC4A6DbRwAKEItLAMbgcSw2IVNeAHoWCGpSupoim4mo0QPhQjgqN2NpWR9l4bTvUMZ3Dd2yaG+4biOM4q/5v41/y88pOo1kpvuD30FcNWrYWb7BOKjimjzEHEUFMg65OldY+lNme6un2o3XLSBzMxxv3yvTZmZv2ea1pzeZ1WNEsrlMIe3oVrO7TWK71FP+oFVHZcvnYovEBy98ukasM0tQII4SmG8u8bnUk3oj7roJhgepl+fAb2vjG0Ny6hfuUsSrHaKyPtIhZWKLWjOO3NxNBxXFbLkhgC+HNR4t5mOu9OMXW+jp1Lcn62Q769RHj3EAjBC2sK//B1g1+8aHBuVOXEY9e+1o2YIGQNE2pFySrDRA+rxD0FtekIHjxk8ublDiLQ5p9/5w/yJ/c+gaI4JLYEyADtcYHSAWNBEkN7gPHMdF0QVGVy5nqwvUtFLDqo3Z7FyPb31LNP47ZXsddPesYzu7c9ByDkj6Hg8NJKlS8UVBK0yVw4S/3yy7QO6bimjv7XJ7e9rjvDsHppDi0ckI6314CpQETb7kzatVu3p/plQOttQULvn6OjUQfNc53duwMxjHvkrLssKAKGDYurTY2TF2H/GPh9gsLwYZ5/z0/iCIX53ffz0Fu/gwA+Nf7tOKrOql8lWXborApcI43lxX2145L82ysCLIHtNjC8qoNosDdSka0xk191yWgdLvslEUrsr5H9hx8BLIpqHhfBuG9zaWzCn2I5LvjEwRpRI8ahb7+PzkOHeOArXyQcgBdPSyKpJaLkS1cxvKXi3e0X+Okrf8TRcBXFC9SU/AQ+tYM9v0ylWcZXkmuff2p72VVCxCmF25ybliQrp6cpVh1++sUEdc3kY8Fp/s5TQeIhle94JsBwHLRKtedI2oWYGiG77s1881xLC0WZwMwvNHCDPlxPpcpPJChEggRqct3Xi5dxK+Y2V90urLSg9K4NTpZC0EiO4V/1Skm9fazkmTjNeWcmmZCOpJYRoBOIDXzvm4ERCRIczW4yoAkmgzRKcsyGUATCtrapK1pQMPxwDIRL2yhi+Abf9OGoSajdZL65WTGsGz4ObyCG4zno6IKZUw6tZQehy/VrI/5gXq5fD+llhCWvHV1TcNsW8eN7GITmg2nmf8LEGh2s3BpeJqamyxtuNdnCaVv4EhEmv/s9GLEQ5/7DHxFSZeC94nb4q87vstqaoySCZOKD+5GjB1R2fadBePLaMUPbCONTquT0c7hC2VaVZI+nCRXl3vCSt41MVS/QSI6hPX8KJxrE3j8BwOiuBwH4/NCLAD3jmd577R3FKqsoAka8UtCIWqfR0jYZzwBo4QAtr1daWVxFzBdwFYVqsYJQBAmzQXCxbwzWjbuShoNR9ojhllJSJR2noyooC6vEF9ewgj6UA7s5NnSMk3MnsR15r3VEBMNoIQpFKtNX6OiChFL1vlf/PJspAQp0Si56RCCE6LUCbCwn7WQEyZbLqip4K6AyZRcBNqngXQS8Ncgd0Gc+ntMQQK3hUmgk+Yr6c/z5uXvQVcjEFfwBHX8uyXpVvnZjn2HYZ9MJJ2ktFzHiYRRvDNm9o/fyjrGH+b3kJzlZe51drRGc4PZrJhWUMdyCXiLwmoOgyhVdIeMYJO/TKL/l0C5ePyH7tY63ieHXAbLhLLZr8yvP/QoAHz3+UUCaLYhKHTEv59mVVJefDv0e91T/BgA3FgFN0Dgg8J/puxluhL7o4qpgpSA4mqW5UsRqtDASUVzLxm60sBstGbjHQyi4nPIyZt1yrjVLx3fof8cY+zCrbYHj3pjxzEZY9x5AOA6NpQVcF8KWXIA6tooRjyLsDoHly9ctI+2iO57hzdNlbMdz5FuxpZDUaKJ7rmlGJCAVvmJl23u0ixVU73lm0JSqUjyAg4XQ/Ag1hE1rkyNp77WhJIbXY6g2K6hW67aIYS4WQ7GL1BU/ddVAsVZ6MwwBFFVBMzXa9TZuTC6CtqugJCR5HEQMAX5ol8X/tre9yZwIZI8h9IkhQLUhF7yNimF3VmFzeQ2E4OJ7f4yZd36fPJ6Oi+llNmNe5t1Jy+PZMBIUXYVkbZi6JlWAqObNyxLQWBx8/dRnHAKj0nimC/vIJOqpyxiffAHXb2I9dGTTa+IhhVIzCJ0yrt0PmotVB9uBVLTr7LqM0eqwa/oyL0SHURZWKUXj2M0OvlKBxsgI//iUwc+dM7Bc+EdTbf7l4TZ7Q9e+1hVd8Ojyh3n3Wx8nda+OoomegrreETx8xMB1YXY+zHokRsPRCQebvWB8I1rj8jHziou63lf8NqJrPDPg5dvgpAWu66IU3B4xHDT+Qk3chTASdGb/ELe92ptfuBXdgb6dVolXSiqP5QRmIoRdOotI7Ma6/xD6517puT7KJ1uIpfWeYhjePTRQddiKrUPuAaz7D9J59BiE+uVHa23RUxhBOqgeCDsIXPb4t/cXwgbFcMOyMGq2mVkWrFcExzf0lLqqRi2aZ+jSi8RXL/Nn/veyVPHjurCsaiSqNu0lBYRKZ9iPq7lUjnqOh/MCF5dOq4kRleq+qgq8fBXx7TETEwGLi6EJXBdUt4wRriGARa8nZnyLYqjO9Y/R6NQkZtRP89gUer3B/dkGpy7a1BoueirKgcpbfPB+eZ/vGtExri7RGe2rGM3YMEmjjr5Spdqu0CoH0VTwjWXZipwvTSnY4eqyJDtJX56f+o8lZtehfnQvE1f6yvETd/n4/3+HjnDczaWkgDuRI9JwUVzRKyVdr62i2wrh84syCdAlropCILaH1MoimaUljHKTM/+yyemfb7LwVx1ahesHbY3UeE8xjOmyLO9LezTW3q+y4Pm3+GOi70h6IzfaDSB6aBfl87PY3oiKbvlr4VIBw5BqiBHfTqzSh+U956odfInBPbyRqI9Au8mClydt1Vu4QmD4NMb8/Xuj61tzaRqayw6+lNi01l6sCV4rqbw/ZxEdTvaIoSYsFFMnuq/vMbAVWx1DN0L3ZPJqosZrdZtKxjOOS0TQgj72/s8fpLlSZOn//SSqAjXVT31mGRdYa2pkdlAMhSpI3KVt+g2DYJlhfEqFZOcc9fQuHGPzcbSmMqjtOqFala8UNVTHZaJ5jkZ8BO25N7HuP0h35k0kECfbCbESXCIiNMZim9X09ugIK0LGMZNOES3wAUJag3ZzOzFUDZ2WKcm+Ml9AWS/jhnzUZlbw55O4pp/g0oXe80c8A7shb4ahoxm9UtmNaPpN1PlVUpU6jUO7QFG4e+Ruqq0q5wuSaNp6BL9aR1kpsro0i4tGzpmhLQIIf79qS9FEz2XX8Eqj9VAAXzbeqwABsBKQ6LicDSs0FMFoW5LiQYphNioroPwD4hafIcglFZbWbQwNXr4cpdGCVsdlJOON/xjJUF0s0opkJTHMypgoqLXohJI0V9bxebFLFx+7+2MMddKUnQqT9e2OpAABI0DIgTm9jtIGEVjmoqGTUaKk7tfAhdWXvv7LSbXrP+UbByoqZbt8/Sd+jSEckDf29Po0zx56Ft2nU7bLGHtT+IH2qTMY94+ypihEWqukayo2OuWQi2OXsQ8qjJ80cc/WqBzYvDHGFg2aGUHZrSCG5Z2wcvUKJEzsZht0FdVnYNeaKBGd8YDF62WX99llApoOGEw36gQjstyz0HLpuIKI3qTs2U/fCMTRPAFFEFv9Mg4aAeR5atkanRA4S6dQ7A4rmZEbOoeWV3LiVOt85XKJ/RMK0ysWuZSgM1vDCWmU7TJKQMU1DGrr69vet7FewvUysG1/G9u2MWIGnZkmZjCO0F3s1jpKTNn22kowTLJaoGwVCZXk/J9SMHjL158rXNQNr1XtFXRT3/R+elCnVq3R8KLJhq0iokGoQUNv0LK3qyPj3uJX3rqWmS5+E64WmpS9Hoalqrx2hFmnbHsRkgp6PER5cZmyXaY8KjOJtfNyQ7Dj8juqigKYNMNBWmqdWj1NuZLGdHxUAxam4tCiTEsFPalSWWhRthubvpJrQ31OJfqwu+l3W4fzJP9LC/1Pv0Tj8aOU9SbYfQe+QNCm2JAbTaVxBfzyWp1e88pSI03KzQKa9iaQZ/LcOT775NOU0bmih0g5a+C6/LYyQbHl8n0TZR5JNVEFVG4wOZgKZGitCXz3NSnbTUxV3jtzrTr7Ex2GM3D6ih+OgahbJKLNwdeKD5JJE+OMg9JRqEWblO3+yXNduFJP8Y5Uk7K9XQXfinbY60Nds7E1C8tVacVa/fO7ASL9MMrcnwLQ8GdpDPp+qo4KpJV1pl24K1nB94696IEXaSnHqDw2QeILr9I4c4bOPlnSpM4XiLou1YRJ48UC4fv23NB9EtWjLLe23Hvfep/8Z8Njq+0kY8E2ZbvP8t4/pDOpt3C1OpuvMgnXB6bup1C3aCjy+s/6DDoLJobiMjXZoLEhFi3Gc4SLc5w78jRXa0dorFQpuC0arkKiZtNYcVCVBmsfGqVx4gyNSASUOq0FP05QumgqMYW2IiP3aFinXFMIx1q0lc2Jh2G/ygt6Gss20Jw6oimNXC4zSkrvoOs1unS3Plel9UoJMS5whUsoEKRBlc7xIXLAw7VTfNq5hxfeqnHCk5gXLy0DOZI5DbVcozYWp4G8ltaiERJmnZlSiHpjjZVKiFhWp6luP4rZSBJ3Feaar+OzFV6+Eqedd/jx79JQPzOJ+m/eoLZwFTsTA0ArLBABajFt07VljoTxA/6mYLVRoGyXWW+XCRk+lHMz1N5zz6ZrYDQ1Tsc+yeOfW+b/+ZZR7n7UpnJSYf4vO8z/ZQdz1CV8l0P4mIu2PSZlPZEhUy/SqMzSCUSIG0kuYrN4rErzlKyzbgSqmGszrA/vv2MxhXEgi/sJm8UzZwgfmQCvIKRRauD3A0LQDDq0tnyeE3UQisB1XHxZc/D3CUrjj8VSnbLdolqp0jBM9obbVJ3+88O6CiRZsgVDF22C+zavtb8/F8GnODyYKuLWgyhWBwdwSiVCB0epKnW4hbi443EXJ1zmypxDTJeynBXzYrbdUTLvv4/lP3mB0P77aehBXMehpgXp2BCJtjetgzf9+dEAYadMuDzP4v6Htx3DzmQIE9i7OMcrk/sYbTgExCxrJZvESpHqfZPUNrxm0k2zRJWDZoZiuUrjsqB5SdC4LGjNgznxIxznu0hoy/yJnuTvam0qDR/lvB976/mL+KFco33pCoFGGzsbpzq7SGAyTzm2C//CW73veziq8aeLCQ5FaijleRrhJGVne9LbF/aTWFxHdV3W7pvEssuMpccwVIPnrj7HUHIIywhhtlu0V+YpVJaxjFEmOU/dtwvV2by3aBmF1ooCUav3XXy7MpTPzFKySr1EX1SJYnskPVJfoQG0omz7zbsnVOanHY6HGwOv55Gsy6W5DpkEnDzv9R/XXNJJW8Ybw1FaL55m6f49ZObexH3gfajCwU+LuWCIxso6wQNbYkkFfnz1e/nfc7/A0foUtUBz4DWVQWdBl7FtKXaVNVUlpiVpxav4JxWWn28TeGfjRgrbvmbxPxQxDCpBngk989/7a9w0SnqJX+QXGY+M87MnfhZDlRu4c7zFWfUX2HfZ4P73fZjfVP8RoVqFZiPIGvDk0AcQhoF7yGUh/AJTbyVJ3duvd3ddl4Xl5/EdSDIV2kt53zK/yp+xeyWDnh/lL3mOD/zoP+bL//V3KFQuszd5mHclh/j1uQKP+p9ij9Lhn3GGvDjGM6EEluNStl4D4J2R/TwT2t4jtSNCcHnfr5Kcmabl6gQUWTJSsw0eyT5JuvB5AI7t/i7YYpM/CPPZt5jmz4mJFisXRvj7hw/z06uf4aFdMexGm73xQzwceoZytMxV/WWiVd+2a+Ni6TfxZdNUDYNnE88CoOZUTr4yh98ycC0XR+vwyNAj7NqqoKSmwfkjnhF3QUeuEMcyz0Lovhs/JlsPkfh9usuYzy7yweQHUTasPnPhOWjBXSOP4Dz//6Np6SQjw9Taa7w79u6b/ry96b/BLus8E7ofgLo7B7zKu5LvYHeon05bz38WZ9XZdPzeqn+eS8BjI+8iFRqn5Tj8A14n7ztC2beIWU3RXB/FBMrpCFmjf/z/fOh1yoVG73O7WJmpcMF6ifumDjMV6isU7fsPcJH/jLBspt77Xdy95TyeT1zgs+2ztGyd+5VdJEOPAPDHLfl73p9/GFH4t5yPyeA2sbSEoyj88aNP8fzhJ0gvnIJL8B3338v37Z3Av3Ua+g3guUMXqOSaPLNLmuKM0uCfc5Zx9TjPhOKcP3GBf/HJs4gpC1G32LNr+/XYO96T56m9KHuOD+WO499wn11ttGg6Z3gmtpdnQtdXqCvZJhfsF4hXApimn6KzzonMEfaGctue25o4wZfmP4HrWjyR+W40bXsmuqHO8mX+Be+J2Qg7yPenj7HwqODM+d/CuJLh/md/hPP/9Pc4/FyD9N3y99XWn+MqMGzuA/cVHjnwLBOhu6/73T8TnOFPasVrrukdb026OzjBM6F+lvuZELw0+xKRymDlEyATmIb1EEcr8nWuZfHHSzPszgZ4oDMFG4Q5ZeSjlNwM7oGfYtfZ87x26TWCK1JWHBEC33yMo5U9tLLfw0r8DBM1uQ6cm5lFj6+BBWP6UWIVqc4N+WaYocxR5TCxyuasuetY/AFVqnaYuLJKolTABS5auzjgCzBRuUuei2qFlz71Z4TDCVK+HCutBY75H+Owey8kwR35de47Ncf4gUd567TGtz31BCv8GZXZDobT4oRPlsDlxx4n7z4MgIjUqZu/iFJUSS1UWGtnOTa2hyH3UbYhavHnq5+hri2TL/pQo1n+4ocfZyQeoGmPc/nf/BH3vGES/SbvOmi+yFXgrqHHCW649zv7j3CBXybcEKg1wZO+x/k58RPklDRKbZqpQ08R33ANmAeCnE/+MRPLLvGhST7yzNPwDFTWmpx/eYnzLy1R+OMqq38Cw/viHHzHEFP3bFA8hxXgN3m8MQSZh5jyX8C2XZ4JPcAf1J7DNhXeHXoEygX8dz3C0B2KKTp3tfhl/S9Inld454PPYPttXldex3EcwhiosTjvig5ex69krrC4uMhd+bu4N3Tvtr+fTZ/lEpewKyrPhJ7hamOJqt7hg+lJngn1VSor4PITvMZaSMVtCfaP7OJ+b7+dbrR4ce0M//Nohg/G7qJt1jllPQ+AW63xwLu/lSO3eCzcgMNZ5dfYk0oR+9YpHKvBIvDUyHsJeeub87En+b2zP4GvWqLtiwHQ9Hq+nsnfzTtDmR3e/QYQ+S8w96dgtxmd+CCjW35Hc+8Yl/k1Ds8t8crkPjmqQi+x/1yUZeC+J34APdTvi56JPceX65eJXniMy5+TYbaqK+R2Rxh6Twz9E/+ZtqUR14rMMo+h2tgNjSd2fytC3Vw++VepX4HZAsNfXqAOREf30lmd58jTHyQR8MOLv8oz/sdB1XkmBB9OtBnxGfDpn4XY1MD18UvxX0ZdkC6y973vhwh58ctnRz7LyYWTPPWOp1jyT0MVIktNCloT1RhjlE+SSv4gJ7a855eHL3Dy1FUmU+O8IySNv17Z3+Jzz/8KD7buIuIZCL4ReBOwCLhwsJXgVV3n2ewHtlWIOA89zIH/9uNkf+AfY4S2q9CXxi/y0um3eOpAhtnlZRQhTe/eNXqEZ0IjXNgT5Y95Di30KL6LX+JdQw/wX7Q/AGAi+hCd4n/jwNBdPLTldyzqL/OHK/8Wt9ohmTyAf8Ae+kfqP2NGqwMd1gIygXE49SDPhJ7h7KOLfPrXT3No/h5G9ie2vfbrBV/HnPZ/HETNKH/vxN/j5x/5+R4pBFBME3NykuaZMxiqQdsXRnVdaCtgaghDPlcogsDRNM2zaziNfnOsU2nj1CyMvKxbCqfSGP4AK9OXCXs3smH6qZdko24gGuXBWIiW4/JqpU7eM/iYb8n8dKFj0c1tj+zQ63AtBO+7n1CtQ93q5yuKjo9ANAbzJ8EXhfjOgdxGBKIxAE6kVT5xapFSo8NiucnuqAquiz8sU8XBYBBb0agV1ze93rYs6uUSjqoRDvcD4GQyiSM6WG0Hu+3iKG2SyQEEOOwFoeV5KHvzfCLXNtS4HtIb7BPzprKJFHZ/S7VaJZRM0bR1GraG6vPj9w92grsedqWCXFrpq77FujzPscDmcxvLDlFc3GxNXS7I/oZwUl5HpqIQ1VTaSpyyuYpdS2EXx3CwWclnSBn9c57IByku1bHtzXLcyrTMfGbGNxMSfWQENZFA+HyEHnlk2+/IhKVaWG5FaDb7s5XmipIIpvwVZud+i7Gp96BqGma7RbxU5Nc/8BHOpuLsm5shmhvihw/sviVSCPDgB/fwzPcf7v1/2mvkWmnL+/H9R+W1YV5ZR7hwILO9PLkLc1e/KV7bUjr2Vk0qfQdCN3bOA2GDugOi3sFeb1J3XAKRwfeuaabJ5z5IJHJ8ICkEMAx5vt8Ts/jTu6URheVKQ423/voiIhLGf+IElc98pveazpw8J4W6zELn9uy7oe8+ZBqsWzZ1e2fZdqXdwQVy5uBS6mshHdQo1PvrpahYKA2b1FBg23OrI+9k8cGfAVUnHpdSz9VVGXiNmyrVFW+uoHkIwt8BgNNxaK62ISyV/ECkL18NxUxCpkrEvz13O6apGLisujJocdtvAjDtpJjy7iPbsnj9i5/DdR2OPvoEWW/WW2ZDCRjHTyBee5UnDmQ4M19mTQRBCNZqHUJOE1/ZUxpG+6Vwrh4g6FVjTFyW10liarO5Rhejib0I79TEKzr/5NsfYyQuj525dy9qLEbtued7z7fXZOm9ltwcUGnZLBgGkRoslxcpLi5Q89lkbXmP+PZvvl7u3X2COa+0bXj8WO/xcMLHXc+M89GfvI9v+z/v5+73TFBebfJX//EUs2c3rP9p7/08h8Zhn85ss03NstFqFkpIh7XLgAvJa8ypuUnohsnwvoNMv/EqAKqq9vYWpd0kGN850ZrNSmIb80Y7bUV3D6uUK1iOS6FcpmGYPBjbXC+nKYJRv0E9K9fMWLZ/rf+HmRVUIfiBUXndGf4APlM+T+m02HVic2/3zUAoCsFojEalyLEnR6mtr6KoKoENv0dRVd77936coNOg4sj7ueVVKo0mtt+TNwV/HLptBiPbibU+Isu0pxYlERivWyjpJLUvP4exaxf60Oa9/X0P/QAPLT/Bg+F38uAHJ/nwP7qbH/jXj/LN//Au7nv/bkYOpKhXNOJGg8OWLN0UWnQbKQRQvGug/tJLAFgZefxTY+OQPw52C1bO9p7fi73K8xDZwTE3LdfpcsBHcHyi9/DT409TaBR4dflVAqb83MWli6xEBRP+MAoOo4nt5zmek8c/FOs74uanZLns4oX+d8tG5H51UGhU11YJJ1ID2waUYJDR//DvMcYHlyYfGpJrZcBQN73vVEZe5+kx+bqC4/UW1i7w0R/7+/I3WwFwXWLZ7clPJaDjeg7ISnjwPpg3U8zpGkTLXNakec9k9rj894k0hl/j9JcWBr726wVvE8OvE3z86Mc5lNruruY7cIDmaemKhd/rLWspKJHNC77/WBosl8apvgFHe0EG/XpePlcIQXp8gpWrV3oBfWllkXpZ1oIHIlHui8rN+PliFb+qkNQ15r2eiMVWP4U+egvEMPDwoyguVEryta4NZdeQJG7+JAyduOF+jkBUBs8H4worlRa//7Is5xzznBr93kYZDAaxFJXq+tqm19dLRXBdOkLZTgyVfrCoGPamv/fQJYHlefmPUCC0vQ/nZjDhBfuKXWM4uD0bFQqFqNVqhOIJKpZBzTJxVe2WieFEKsh8qUGzI8sp1uvy/Ea3jL6I5fLUS0Xajb7RT2V1BTMQxAz0N+yUrlEVMSq+VZRGCrU4SsVcYj0eJ6lvJIYBHNulvLK5PG15uowZ0IikNv8eIQSxD3+YxHd8O0pwO6HKeJtGqR3fTAzXG8QCOisL/zeuazM5+feJ54fxmw4f/6Pf5SOf+jOSn7pIfm2O4b37t73v7SChq6iiTwzHkgGOjcZgTgYnR/M7Z7+NDcRQ3UIMz1QlMdwfHNxrtBWqrtBSBWrbwS21aTgugch2u/su9u//We65+/d2fj/VRNMitNrLvcdK5ZNoSprqcoPzLz5H+MknaZ05Q3tWnov23BwoCvOFJeL5YXyhAc0dA5D3+k82rjtb0f1b1rh5YpgKaqzU+vf6y9NVENDJXPvYJhLy3lxdW0cFxqIa7bpDu765LKmx3AYXHL2BZpgYZv9933skxc9+YHJgn6kqBLs0hQXhrTGOJDXrJJjSVVzX5cyLX6JaXOPQQ48RCEfI+kdQUEj6NlxXx+9CVCs87pc9ip8/t4YvGqemBoibIGZncDUNtljoB1Nyn0ksRtCFTXDq+MDjEIgkiNbkcY+XDUYm+gY1QlEI3H8/tRde6BnDWB6RVrck2oSiYIyNEavDWmuN5dlpGqZNriHnj5hTm+fmBfQAb9w1xr99n8LY1OZ+4y7iuSD3v383f+en7yOUMHnuDy7ger3oREfACPWC7RHTYKHV4WKjRbDp4ovosOr1dSUHm63cKsaPnqBw9UovUZn2Ani7ViWU2JkY5nIyyI1GB88sjXhJB7PVYK7Vpl6rYZt+DgxYJ3b5TUpxed66xLDQtvgvC6t8OBsnb/b39mhMfl4ynSYUvz2FJBhP9H53pbBCMJ5AUTYTpUg6w969u6kKuUY1wnJPHY7d2h7XQ9fh2xcdeE7VUBA1FmdkRZrz7Wqs48amqL/0EsGHH972/OzwEL/yv/4CH/77D3HXu8bJ7Y6ibmjk9+3fR9sjhvusKwAYofy29wFQM949a3lVVDF5LlOjE5D3Eh8Lr25+kWNDZWFHYqh510ttOL+JmD068iiGYvCp6U8R80kCWg4rLMdgwpAJrGj02Lb3S3izBsMb9qP0+G5UTWPhQr+XOOslho7pBtW1AqFBSfUbwKEhed31blm/jhAw6Y14iqQy6KaPQskCPQAzLxIx5fpbaslrKpLZHo8pftknCKCGBu8ZQ8EROkJQeKTEFWcZ03HZk5VrkGao7L0vy6WTKzRrO+9LX+t4mxh+ncN38AD2SoHO8jKqRzzstoIW3yyBG6Nh1ISP+msrvcc68x4xHOoH0+nxXRSuXiYYT4AQLF++1DOKCESixHWNA0Efzxfla4dNnbmmDGaX2v0bYWgHs5NrIXD33bgCagX5WqulYIdCKK4FS6clMbxBGD4/mmky7LMxNIVf+YI0QMj5usSwrxi6mk6zUsa2+t+/ui6z1y2HbcTQFf1gMRTzDTbK6BLDikcMQ1lQb/6YbEQ+EEfYdTS7QC6wPdsVDAZpNpsousEnVk7wUvtuWu32bSmGrgvTq5LwlRodIj4NdUsjf9wLHItLi73HyoWVnurcRdrQWLMU2noR4eiESlPU1VnWDXOTYhj3FOy1hc09qsvTFdJj4YHHO/Nj/wuZH//xgb8j7c31qjujNJt9ZXOu2GAoojE3/3vk8x/G7x8jMTJGwKnx5Itf5gf/9PcRloVbr5CfurPEUBGCtK6zvOGeef/RPN4cbfYP71wurcVM1IQPJaSjGJsDpzO1BqM+g/AAN7edYPnksReWQ92BQHTnpI4QKkJc+70NI017w2iQUukkidR9RNJZXv/UXxJ+8gkAqp+VqmFnbg4tm2Xx0nlye27MXApgaEvFwiAsesf3VhTDVEBjrW5jOS6u6/LFKzUiKR9Xr5OcMk2TQCBAs7jOkCqIe8PlKyubA4X6oiTxbadGILy52c3UFJI7BCYAe02DOa0f9DUJIoTOuK5y9a1TLE1fZvLoXaSGZB/nU/kP8fHJn0TfUHHCcbmeps69zrGxGJ89vYwvkaaqBUlF/HB1GoZHQNusWgZyk2iKjbBVhgJlnNh2R1IAzecnXpWfl7fj+IKbCX/wwQewFhboTEsHUHttFRQFdQC5MSbGSdah4ta5NHsaBKTXOuhjowOTQXun7uGLRxR253Y2QwHQdJX7P7Cb5ekKF17xkhlCQGrvBsXQwAFeKNYINRwiMXMDMbxziiHA+JHjAD3VMJWS+3inuHZNYnjixAne//7394jkVgQCAYSiEGo1uFRvQrNBIhIemHjY5TdZ0lze8dEpMmNy7/v1uRUajssPjW1OWI0OD6NWS+w7evwmf+l2BGNxal6CtrJa6CWnt2JqcpyGFsBBUPMnyUV8+PQbX+8Gwu81dA7fAwPGfQDo42OkViUx3Fu5SqMUwW02CT780E1/nLl/P3ZJIay3mVLknqSnB6/5xhY1sthpYfj9RNIZSWKNECy8tvlFlUWZWY/uQAz376Nm6HSOHt70eFAP8tDwQ3xq+lPEPWJYTxosJfyMKfM0tVF0Pb7t/TLjYd77w0eZONaPOzVdJzMxycL5vmK4ZyyGcOGBfIzq2iqha6jg10IiaDAU9VGs99fUsUQAv7cfCkUhNTpOYeYqDN8NM8/LYwKUqpIgxjKDFMP+WqeEBu+DI97c7rn180zbFYY7gsSGpMjBh4ewLYfzLy3d0m/7WsDbxPDrHL6DsoyndeYMPi871G4raFsWVSEEgWNpWheK2BUZSHUWqqhxE8XXvxnSY7toNxrUi+sEY3EWL/azPd3yzAdiIV4s17AclyGfztwWxTBtaJg7LK7XghIM4iQM3ILcrOymCrE4LJ0CpyPLJm4CgUiMTrXMo1NpViotDFUh6tkybCWGALVisffaroJYt2xCGxSMQCCA4e9vQtEdBicTTIOiSVJYmb/tMlKAhC+BZs2gti+RCw4mhgC1Wg0nOkZwZD+NRuOWieFu77ddLkiCtl5vbysjBYjl5G8rLvXLJyqFlV5fQRdJQ6PQttBMGRCrroHtzrImFFIbFMN4Tv6O9Q3E0O44rM5Vt5WR3ggyngJWtYe3KYZRXZaC7Jr4Efkdh0fQ6+vMhpKUI0kmHElwhu6wYgiQMTSWW/0kw/uODgEuqmIzFNu++W5E8L4cgaPbA6fT1eZAFeCa2EBAmoAZ0HZ+7g3ANNI9xbDZWqTVWiAaPcHRp97NzOk3qGgK5tQUlc98FoDO3DxKNkutuE7+poihvBbnb0AxzN9iKakLrNUtLq21ma902DcaYNZ2aXRT1TsgkUiglYuMaIJQSn52tbCFGC610MMazVplGzG8HqYMlVXRD8LWSDGhq5QXF7jw2lfIjI4zfrCvlkWNOPsiWzL9uTxuLg+vnuTJQ1kWS02WIhPU1QDZdAxmrsLYZkdFADu2i6Qhk0X5aBtXHawwCyEYrscw2wq7ohPb/h64X/YR1p5/AZCKoRqPDyynM8bHSRYtLMXhrUVZIRO7sopv7+Cy448e/xbeNfEuhnZQYTZi7305kiMhnv+ji9iWl5lJ7+8phsPetfOl9TLhpkMy5oPVixDKgXnz69G1kJnYjT8cYfp1OdJlamqKXC6HVVy7piLn8/m4++67d3TzVRSFUDhMsNXgbxZXUVyXsfhgdXFXwKTmOOQfyiEUQc22+bXZAu9KRdi7ZW3ZdeAggZnz7Lv/5snRVoTiyb5iuFognBzcI50Om7gImoqPqhljNHGbaiH0ieGAMtIujLExIqUFfvWFOveVTlO70gRdJ3jfzfsG6MPDOG25z4365W9WRwbvMf58no2rzXKlSHJ0XJ5rRYHcUZh/dfOLyl4CdAfFMDA6yucPjOE/tL0M/JnxZ1iqL1FsFQFoxTUWU2Ps4TxGeLtaCPJenziSQt3SapGb2svS5Qs4nonLrniALz9wgPfuSslS0h3O8Y3g4FCU+VKD73logpbl9MpIu0iNjbMyM407ej8svimTOYpOcb2MphsEB+yxile6LwwFxRycbJjISDK9UL3KFcUiaxn4fBuU0rEwqdEQp780P/D1Xw94mxh+ncM8IG3Pm2fOEIzJ7Gi7o6LGti/6geNpcKHxulQNOwu1XhlpF6mxCQDZZ5hMsTLdH7jrj8j3fCAWpG47vFFtMGQazHuKYTcIG7uFMtIutNEohucWabUU1FRSlpHCTSmGAMFojHqpyLOHJYnalQrS9vqYNhJDp0sMN5ST1tbkf1tbSkkBIhvmFqZyscEfrqgycCgveLX+t08Mk/4k0eV/QXDtNwcSwy6BrdVqvOdHfozHv/cHb4sYTqRk2UeXGBbrHeKB7QF2t1a/uLiBGA7I+KZ0jUKnQzDY7wkTYoWOy6ZSUt1UCSd9rHW91YHV+SqO7ZIeu7kAGiARMFAVQcXK9Iih67rMFesExSmGhz6KzyfPT2J4FFyXz48e5i/yxzmkF9FMk9TotZWHW0Ha0FnZoBjmoj7uGXWZSjko17FXj7xzlNgHNqsVLcfhYqN5w/2FXSjRfmDv+LUbGhVxLRhmmnZbrjHl0qsARCMnOPzOp1BUlTc+8wlCTz5B/eWXsdbX6czN0fbGwuRvsL8Q+mRvobkzMVxqW6hi8/V1o0gH5WtWahZfvFJFEfDIeAgXuGxdmxjGYjGC9SqjroURUDGCCtXC5uHHjcUWvoxKq1EnGBkcpO+EKUNjjT5RWCTDbuHw5pc/TzAS5cD977ix83jsOLx6kof2JDE1hRcYxREqQ7kUzM1u6i/sohMdJ2nKezOTuXZv1/HqLr7lc8Oks9tVRWNiAi2Xo/a87DO011bREoPJjzE+TtRzRX5j5XUAopeWMfcNvl6OpY/xLx/7l6jK9ZUkRRE89MFJyoUmb37BSxyl98lSvEaRYW8/+0qhim5DIu6H1fN3vIwUpNIxdvgY02+8iuu6jI6O8rFv/iaE61xTMbwRxCIRIu0mn5iV6/SB1OBjvcsv14PLDVk6+LsLa6xbNj88mtn23Kl7H+S7/8Uvkd11+8ppMB6nXipiWx0qa9cghl4FyLt+6p+zUHNuv78QoGvAM3oNYjg6gtOocHythSHmqb55lcDx4wMV6+tBdFVpYDRQomWpGGOD/RP8MTl3EABVZWlxnvToRP8J+WOw+IYsH+2iLBOeOxLDSAxgYJ/dY6OPoSkaryw8j4VGMyYIBrLEKDIcv74p2Ebk9+zDarUozEz3HtsVMGlWK9iWRShx68Tw8HCEy4Ua//Cpvcys1ZnKbo9lm5UytfgRqZ6+9RcQzlNaXiKSziAGiBddYriTWggwNnIXiusy3ZxjUVPIuttjkoMPD1GYqbJydbsj7NcD3iaGX+dQQyH08TGap04Ti8vF2WmpqAOa0PVsED0XpP7aCk7bxio00PObF7WU17S7cvUykWS6l+kRQuAPSYL0gDdz6PlilWGfQcV2qFg2S+0OKrfWX9hFYP8QTlPBdcFqKmjpjCSG/gTEtgcp14I/GqVeKvLUgSy6KtiTCdGoSF/PQYphtdgnhtX1NYSi4G4xnwGIp+RrXVwy+Wv0VUTy/VLSnZrAbwJJfxLhthBY11QMq9Uq2d17iOeGaDabm7JZN4OwTycVMrlckGS62OgQHaAYGv4AgWisZ0DTbjZoVisDSkl11jo20ZgP16uZVKMywN5YSgrSgGZjKenyDsYzNwJFEaRCBuVWnFZ7CcexKDU61NsOKX+JiYm/23tuclgGsK/k9/Cf9zxJurFIbnIKZYCKcbvImBrL7c1k4Ve/51385vffvIMswIV6C9vlphVDI25ieeXi4hr9hTf8fkaadlsqraXySRTFIBw+SDAWZ899D3Hqrz+D/7FHwbapfPrTWEtL1BSBqmmkxm/MXArAryokdJW5a5WStjpkDX1gydz1kApsJoZHc36OhuRjFzrXnlOixuS6kK/L9Sac0jcphlbDpl2yUBLyMf9NKoZJRdDeQAxXSKGfPwWuy9FHnkDTb1AhPXEXoriOf2GGh6ZSvFaSr0u5bUS7DWPbEyLtyATjwXUSRp348LXXNTMYQbcV4rntiTEhBMH776f+wgu4jiMVwx16jozxCaLecrASkP+RLLnbjGduFaMHE4zsj/PyX1yh1bCkYghQOMew1xbhVOS9GogaUn1I3XliCLLPsLa+xuqsnKVY9Ux5bpcYRiIRou0mzZok9fuSg6sSdnvE8FKjheW4/IeZZe6LBrkvtr06RihKL5l8uwh698zq7Ax2p3NNxRCgJAIslpuMxu8AMdz9OHzkN2H3Ezs+RR8dA9fFra8iOtO0zl8a2F94o1AnjgMQ0Do0Wjr6yMjA5wUiMZpeYktNJmjWa704DYCh42A1oNCv7qLkJTh2KCVNj0+QHptg5MD2HtyIEeGB/AN8euavqBHGDrtMmPLzR5M3TwyBTeWkIBPHAOHbuKYPDUVxXfjLNxewHJe9W4mhR54LtrdOlmchnKO0skR0ACEGaT4DO/cXAvh9IbKWw1ccmfzM6tt7FafuzaJqytetavg2MfwGgO/AQZpnzpCOjnNa1xEtBvZpAPiPp2lfrdA8swouPUfSLgyfn1g2T2H6CuFUf2H2R6K9DEvW1NntN3m+VO2V2cy12iw02zjcHjGMHtuHjWDtfJDKrA8zl5VlEjdhPNNFIBKjXi4RDej8wsdO8CNP7KFRKaPqOprnpraplHS970xXXV/FDIVBiG3EMJmVG6qjtEmlr5HxigzByjlole+MYujrL6LXUwwBOp0OlmXdsmIIsDsV3KAYtgcqhgCxbL6nGFYKctGPbNnYu+QvEslRNUpUzFXMVHbT37qI54MUF+s4XsneynQZX1AnnLw1kpsJ+yi2griuTau1xIV52SO0d/gIptlf2OP5YYRQSHTWUR0LVucYusP9hb3vZOisdDo4G4a9x4NGzyznZnGmKs16blYxDERM6o5sb9Su0V94ozCNNLZdx7KqlEqvEg4dQlHk+x576lmatSoz5XW0bJb13/ptcF1WW3UyE5M3Tmg85E2dhWuUki55xPBWkPIUw5fn6syWOzwyESKnCoICLl6HGFY9BTBSKQIQSulUVzu967mx5M0UDXiOpDdJDIUQZIy+grNGksjiLIcfevTm3uuYV4Xx6kmePNR/v1TZ60UfoJS3o+McjK7wvZNfuW6yzvC+Syw/eP0LPPgA9vo6rXPnsFevpRiOEavJY7cabWM6KoEWOyqGNwshBA99aA/NaoeTn5ze5EwaVFUSukqwKc95wGxBffWrohgCjHv9etOvvwpAxet3v11zl0gkgtlqEGjLUv7IINM0pKulKuByvcWfrBSZbXb44bHtauGdRtD7fYueWcn1iOFrM0Vc9w44koKs8Dn4TTv2FwIYYzJpGGn9DB3Poft2iKF58AiNplxj2k11Z2IYjVL14izHM6LZRMZ7BjQb+gzL89J0xRvrsf09Y3zXv/glEkODiePT408zV52jISIoQYcJvU4Hg2Dw5u63aDaHPxxh4cJmYlhdkzHCrZrPgFQMAf7wpCTBg0pJAQqLhV6ixw1lKS0tEh3QXwj9HsNrKYYAOUswo8n1aCi0fR3wBXV2n0hz7sUlrPbX38D7t4nhNwB8Bw/SmZ0l64T53lQO4TJQMQQIHPNsiv9KSvv60PYsYHp8l+dMKhchRVV7/YVdPBAL8kKxRs4L6OebHeZa0hr+VkZVdBEc3kUx4GP5lSiFpZB0D105I7NiN/tesRiNcgnXcXjPkTwH8hEalTL+cKRXZmUYBqpPBtK1DYphbX0NwzNLCG1xSczm5Ya146iKLsJDUjGEO6YYdnE9xRCg0ZBE4XaI4a5UkMsFmWEu1jvE/DsQw1ye9aUuMZT9ZVsVw24fYSA8wkzsNJcSr6Ondm/6WxeJfADbcnrOpMtXK2TGBxvP3AgyYZP1hrwum805Tp7/QwCOTb130/M0wyCazZJ3y+Q7BVzHvuPGM12kDQ3bhbXOndk4TlebGEL0Mv43ikDEoGq71G2XQOzOKIYAzeY8lcobRKL9EvDRQ0eI54d57dOfkO6kZ2XAsFReJzd14/2FXQx5jpE7YbHduSXjGYCQoeDTBH99qYIi4OHxIEIIdusKFzrXLiVd0HzUDB9qqSjfK63j2lBfk6pTfVESQkuR1/fNEkOASV+QEpKAVqwIx/ftJzk0OLjcESOjuMkUvPoKx8biJILyHkmueIrDoB5DfxJbl2tNJ3ztz9ODMlgbpBgCBB94AIDa889jre2sGGqZDFFbXps1v02qbaIGg+jXUSxvBumxMFP3ZnntMzNUyYLm39BnaBD2iGHQ9Uy2vkrEMJLKEM8PM/2GbKGo3UHFULFtYnVZfRHcoQRSVwRjPoNLjRa/fHWJqYDJ08mbvz5vFiGv56vrYhneocww5ZWSvnJVJnLH7gQxvAF0R1Y49QK15SBqLIbv4IFbfj/f/v3Ua/J+s9rGzjFbNEbL2x/bPvnbNxHD1F55rW7sMyzPypjjFvfLx0cfRxUqNQIYfodJZY6m7wCKcnMl+UIIcnv29sh+F3dCBc9FfCSCBi9cXkMI2JPZHKcFIlGCsbg0oBmVfaBNI0O7UR9YQgv9UlI1fO09I+ONS9Fcl3xqsPPxwYfztBsWF0+uDPz71zLeJobfAPB5fYbBy8vkbbkRq1uIXBda3IcxHsFabSJMFTW+PRBMjU2wvjjfI4NCVTfN2AJpQFO0bJpeBnyu1WbRM9K4HcVQi49Q9ubHtHSNgKiBY910fyHIhcGxbZq1au+xRqXcK4kFr5wpFEL1+Tf1GFbX11A8wrhVMUylUziig2I41yZdG1XCO6gYBrQAYX17ttcwDHRd7ymGd4QYpoMUqi2K9Tbl5uBSUpDEsLpaoNNuUV6VC2EktTnLnPaSCHp0lC9M/leem/gjyMjgKrmtlFQu8msLNay2zdpcjfQtlJH2PjtsUqjJTXJ19XNcXJQutRPp7eYUieFR0naJuwOyDDA/dWdUia3I9GYZ3hlb6zO1BlNBE/06/Ylb4Y8YnGravFy3dpxheDMwTXne19a+iOO0iG4ghkIIjj71bubPncE+0h+/UxXuTfUXdpE39Wu7krY6ZG+RGAohSAU1Og4czvqJe0HDHk1w0XI2Kb1bMWM5rIWi1D0zja0GNPXFFmZCp1kv4wsEUbWbC7hAGtCsIdcE3QozMaAs7LoQQrqTvvYqqoCnDmcJmiqx+Su4obA0/xrwmk5UZuOvRwx9sTgoSs+gaiv0XA5jYoLaF76AU6mgJQaXNwpFIZXqk9RkVWDu3TuwT+h28MA37cZxXV7682lITW2aZRhseO7c7Svel/jqEEOQquHs6TexrQ7V9VU008QM3Hwv20Z097F0pYiiqtdsMdjlN/nMaplT1SY/NJa5pVLsm0VXMVzyDO+2JhZ7zzM1gobKazNFgDtjPnMD0DJphK7SqWrULtcJPPjAQKOkG4U5NYVV9lw0RWTHpKc/HKHp7Y814RKKJzbFMCgq5I5sVgxLczuWkd4I4r449+bupWgLwhSZ4DLh8M3HYCDLSVfnZmjVN46zWpWzK69jsnYtCCF68wzHEoGBzrSpsQkKM1dgVBpdlRz5/EGjKqBfSno9xTCNTEaMdSxC2cEJzeG9cSIpH2e+/PVXTvo2MfwGQDdr1X7rLP/u3p8HGGg+00XguFxw9Xxw4GKUHp8A18XuyIBLAH6vWbmLB7x5hhfqLRTgSqNN2etHvB3FkHCOVkze4E1dJdCdh3YrxNAjtvVSqfdYs1LBv4XkhkIhhGFuGnJfW19DGCaGYWCam8lzIpHA1uqYsWurBneaGEaMCLqikw/md9xEurMM4c4Qw4mkPM+vzZZwXXYuJfUCv/LyEpXVAkIovY2+i265qBvokzHHs+jeag4Sz8uFd32xRmGuiuO4ZG7BeKaLTNhkvW7juIKrM7/GeiuDT1d6CslGJIdHCTTWeCRcIZLO3tbmdc3v5B2PrX2Gt4q3ak0OBG/+XHeH3JdsCN4BYmgYMtO/vPJXAEQjxzf9/dBjT6LqOmdW5lHCYVxFoalrNzWqooshU/atNgYMuW/YDkXL7lU13Aq6fYaPTPSD8kldoeHCgr3z/T9ruXQiMSrlMpZlEUxoCEUSQ9d1aSy1CORM6pXyLamFALt1jVWPGI7EJ2/dNOj4CcTKMszP8R0PjfPvv+ce1JlpaTyzw3u2I11ieO3gc+yRpzn+Iz+5aZ7pVgQeuL/nTKpeQ0EIjE0QbsqQJbHSxLxD/YUbEUn5OfLoCGe+vMCa/75tiqHQBGb1PAgVYnfekKqL8SMn6LSazJ97i8qadCS9XVOo7izDyWaFcCh0zffb5TdpOC45Q+dD2a/O+rcVgWgMhKAwcxVF1Qhcw5ApFTaptW0MVSEbvrXS+5uFEAI9m6Q678MqNwndRhkpgOLzoSpyrTRDgxUskBVbdlgmStc7rcE9nUPHYfF1cLx18A74Gjw9/jRFyyVFAQ2LXantg+1vBPk9e8F1NzncV9cKA+dU3iy68wy3lpF2kRodZ3XmKs7ogyBUSq58/qBRFdAvJVWvsw+m1BgAox2X6A4jN4QiOPDQEHNni5RW6gOf87WKt4nhNwC0ZBItm6V5+jQRb+PcSTEE8B9JgSIwhgePWkh77lhdpc2x7d7A+C5GfQbDps6L5Ro5U+fVcv/CH76FGYY9hPMQc7EUQVPXCNSvytEPt7DI9Ylhn/A1KmV84c2/RfYZGr0RFVanQ6NSxlH1gcPrNU0jcGSFifuvM4h7IxkMX982/XoQQpDwJQaWkXYRDAbvaCnp7rQMiE96ZTuxHYhhPCt/3/righxOnEhsU0G65aIdRQYavjZUjShRTcXYkvk3fBqhuMnaQo0Vz3jmthTDiA/HhaY7geta1DnOcMw/MDhKjozh2Bazb7zyVRlT0ftOPWJ4+4rhesdiodW56f5CAH+kf06vNdz+RtFVDEulr2CauZ7ja+/zwhH2PvAOznz58wSffIJOPIYZiRLL3vw9MuQloQYNuV++jRmGXaSDGgJ4eLx/r+/R5bV68RrlpLOWix6P47ouxWIRRRUEExqVQgerYmHVbXwZg3qldM0A+FrwK4KOF1iODZhresPY0GeoqQqpsLnjqIou2jeoGOqBINHd1yb8wQce7AW0WnLnPjpjYpxITT4vsdbBd4f6C7finvdMoPs0nrv6MJRmoFVhzG8Qajj4wwZi7QLEx0G7/STKThg9dAShKEy/fpLa+uptl5FCnxh2Go1t7RFbsSsg14GPj6ZvafTUrUDVNPzhCK7nwHotNbjrTDoS91/XwflOwhifoF2R63bwodsf0UFaqs4ifu1eXTudxgWWmrXBxDB/DNpVWLsItgXVxdsmhk+MPUHV7h/b4cRdt/Q+Oa8SZGM5aWVtlfAtzjDciK5iuNV4povU2ARWp02x7YMffZWiN/s1uoNiqCZ8xD881Wu52gkpQ74+11GJ7VACDLD/wTxCwOXXCjs+52sRbxPDbxD4DhygeeY0tjeLb6d6dQA1ZJD++BHCjw8eTBzNZNF9fkrLSxj+gCSGWxRDIQQPxEI8X6ySNzRerUhiGFEVgrfj4BhIEDBtXtw9xIVsnED5rJxfeAvZ0m7AVS/3FcNGtbK5DANJpmxV7ZWSdsu/OkLZcQP9vu/7Pp5++qlrf4EuGQymQbv9gBvg+498Px/d99Ed/36nFcOxRAAh4OTVIsDAOYYA0e6Q+8V5Odx+gHFARFMxhKDoKETbGknbT6Fj7ThKIJEPsr5QZ3m6jD+sExpQ9nyjyHiGBXV3Ek2LsN7OMRQbfFwSwzLYtS3rq1ZGCv1S0juhGJ6pSkOJm55hCJvKR6813P5GoWlRhNABl8gWtbCLY089S7vRYO2xh3nj7kPkJ6duSREZ2mB+tRVdsng7xPADB6L8yINpkhtmO+7SBAo7O5Narsu87faGHq95o29CKZ3qikXD6y/UkzIJdauKIcCS8Sy/yfex27iNPqtdu3FjMXj1Ffn/jQZieWngqIou1o5+H7PP/BKOcZ3k2A0gcH9/Dty1FEN9bIyYN7IiWXYxd5hheLvwhXTuetcYV+ZizLcPQuEcfyef5H7NJBwzoXDhq1pGCmAGguT37GP69ZO3NQh8IzbuZdcjhs8kI3wsl+C7hm7/c28GXYOd68236xrQjPwt9Rd2YeyRiUJj9270oduvAmL3EyydjOCOveOaTxMjw3z5gaOsmdrg0UndGc/zr0pS6Dq3VUoKkPKn8BkyiVsiscmk7WbgC4WI54c3GdBUVwu3ZTzTxYmxGLoqODE2WNVOeyS6MHMFYmOUVpbwhyMY/sHXjRCC4L25TbO9B2E4OMH+Vpv99cA176VQ3OTb/s8HOPbk4Fj7axVvE8NvEPgOHqR96TLWkmyMv1YpKYA5EUXdoY5aWlCPU5i5wjf9rz8FsE0xBGlAs9y2iOoaNa+U63aCMPnhglDQoBj0yR7D8lu3VEYKEPBKAOueAYTj2DSr20tJg8EgbVdQL5VwHJuq5wLXdNyBiiFI1VC5Xia1SwzvQBlpFx/b/zEeH3t8x7/facXQp6sMx/y86vVz7GQ+4w+F8QVDFD3FMJLcnnETQpAyNFbaFiOZPYyOHabQtrY5knYRzwdZX6ixdKVCZnznHowbQTeQCCS+m6NH/j0LpTYj8R2I4VB/Ef9qEsOQquBXxB1RDM/Uuo6kN08MNV3F8Prn7kSPoRAKhiE3/Wj0+MDnDO07QGp0nFc+/ZcsLS/cUhkpbJhlOEAxXPSO6626kgLsTfl43/7Na59PEYx4fYaDsGi72MBwKIBpmqx7bsehtE6ralObriMUcHRJ5m+HGD4W3c+hxLcSvB3VRAg4ehxe9ebFzs7Ifw8YVdGFFR6ivPebb/0zN0CLx3vzeK+pGI6P90ZWJCtg7r21a+ZGcOyJUYIRlS9Xvgt3+SwRTcXfcOT9sXYRklNftc/uYvzocRYvXaCyWrgjiqGmaT3DmZ2MZ7oY85v8mwNjhLQ7P6bnWgjeJDEc+1vqL+yia0BzO26kG+E7dJS1syGMiWsnGgKRKKWGvPgHKobpfaCasPBqf1TFHTC8G43K71XWd9/W++T37GXh/Flcry+7sra6o7nQzWAkHuD5n3iSpw4Mds1NDI/I8uSrVwAoLe88quJmEIiO8fvzi4yTvW4cGMsGbrsM/G8bbxPDbxD4Dh4Ax6H2wosAqJFbDzZAZloK01cwvczKVsUQ+vMM7Q0mDOM36Yg4CKGw3LQURcEUnVsmhr5QCCGUHjFs1WrgugMVQ0fVcF2HeqnUKymtd6wdieENQfdBIHlHFugbRSgUol6vY9s2jUYDRVEwjNsL9nelgpQaMsjeSTEEz5l0cZ7K6sqOxgEpQ6PQtvjZR3+O//3h/4PVjrXNkbSLRD6I1XFYX7g94xnYoBg6I/iC97JaazO8g2JoBgKEEklUXSczcXsb4rUghCBt6BTugGL4Vq1JTFPJ3SIJ6hJC/x0ghgCmN0ohGhl873ZNaFZnr4J7a8YzAHlTft9BxHDpDiiGO2FS29mZdMaSj4/qCvF4vKcYhj0DmsrZKr60SdObcXirpaQAWU3lQf8dOGfH70IszMPSElz1hlFfgxjeaQQfeACE2NGVFGQZX8TrWMgEsqih2zNjuRY0Q+W+90+y1NnHxVdlorBebhPwd6BTh+TtD3S/HsaPnADXxbHtO6IYQr+c9HqK4X8vdPu5d9o/uuiWkt6RGYY3AXNS7gehR66t8N0ogg8/xMgv/xLBh69dlur31gihKL1Zu5ug6pA7LA1orjPc/mbw5MiDAEwk772t98lN7aNeKlIprNCq1+k0G3ck2QGQDJk7Ei/d9BHP5Sl4a1ppeedRFTcDJS7Xxlbwby+2+9vE28TwGwS+gwcBqL/8Mko4jLgFl7uNSI/tolmrsnT5ItBfmDZiT8AkqWuUrL7d/s1a5Q9CyFM7A35DVpDeIjFUFBV/JNIzn9k63L6LzbMM16h6gZwllNsjhgCP/Bjc9d239x43gW4muNFo0Gg08PsH99HdDHal+gHYTuYzIA1oFi+cw7YsIjsRQ12j0OmwJ76HXdFd11UMu8iM32aiwyOGy+UWc0Wprg3voBgCDE3tZ/TgEVTtzpOKjcgY2h1RDE9XGxwI+W75XPvDOoZPRTfujEJgmGmE0AiHD+/4nIOPPtGbJ3qrimFAVYhrKnPN7aWkC60OpiKIfRVUj0ldsGi7VJ3t5LBLDEdUSQxLpRK2bfecSZ2OSyBnUiuXEYqC7zbdJu8Ijntr7GsnZX8hwMjfXvlT8uM/wMgv/xLqNQiLlkmTbOoI12Vk+Kun5Hex/+FhEuYSz782Qqdl06x2CKpl7wt/dUtJQd4ThlftcaeC6K91YtgrJb3O7+2u53dkhuFNIPDgg4z9xm8QfOSRO/J+QlEIP/nkdd11uxVb8dwQ2k6J3vwxSQxLHjG8zVJSgL2Zh8hk3sMDu7/ttt6nN+j+wtkNMwxvXzG8EaRGpTOpY9uUV5Z3HFVxMzBSE/wnPkJh6Mk78A2/9vA2MfwGgZbPo0ajuI3GNfsLbxSp8QkArr7xKjC4lFT2GQaZbfYD27E7kL0OefMT/boNoSxEbt24JRCNUfMUw0ZZbuq+AcTQ8QZr14rr1NZXUVQVV9VufwN98Idh37tv7z1uAhtnGTabzWtakt8ousRQCAhfw1golsvTbsiUfjg1uLSjqxgCOK7L2jV6DOO5/qafGbs9gm5qKlG/znJlAzGM7RxUPPsjP8YHfvwnb+szbwQZQ7/tHkPHdW/ZkbSLaCZANHPngqxM5j2Mjn4Pqrrz9WcGghx98t3k9uzdlqy5Gew05H6pbZE19K9KGU/fgGZ7Oems5RAWEFWkg7HrupRKJYyggu6Xr/NnTWk8E4rc8ZELt4TJPbihEJx8BWau4mZzcAfWjhuFFo8TfuKJaz5HCMGzxTF+4r86pCZ3TjjcKSiK4MH9pyg1o7z8F1cACODNJPtbIIaqpjF66CjwPw4x7CmGA1oRNmIqG0ZVBAfyX/35ihshhCB4/31/66WB3YqtgWWkXeSPQ6sM018GIwTm7R8bTQty5PC/3WYgdrNIj0+g6joL589S8WYY3gnzmRtBamyc9cUF1hfmcB2HSPrWeiU3wu/3M8MwkcS1r9OvV9yerPQ2vmYghMA8eID6c8+jDiBxN4tu0+7VN+VsnEGlpAAPxkL8+Urf3OV2Zhh2EUzngSsE3PItq4VdBCJR6uUiII1n/r/27jTIsfM67/j/4GLrRjd6mQZmumflLJzhZu5azFhiRFqWJYWkZC1WFJO2pJLlskI6H6IwUaXocpwqWVKVq2xKSWSFNmVHlhMlsZjINkNTUpQvSkhKtLgMyRnSJGeGs3fPTO8NNN58uPd2Y4YAegMutudX1dVYLtFv91wCODjvOQdqZwynJsaZmhgn1Z8Fs41nDCMWvuBPT08vZQw3KgwMB3oSeDVqmcq7SlarEcklE5wpFHHOMVFYpMSbZxiG0pkEvQNJDMjUYfB6vj/F6cl5jk2snDGs+qlsneWScX50fmrlA2s4MrfA9GJpXfWFoX/w4X0sVmmmsh6jW+4C7lrxuFvv/tSGf9ZYuvKQ+xPz6x9uv5I9YWBYdFx7yal5tOjYHje/i/DwcgOa4eFh+kcSjB8JRlW8eoHMBraR1pXnwc9c62cMM5majWeaadPoZVz3vw41ZFRFJTsP9DP2/LP85DH/em/xKCR669JlejV2X38zrzz1BAO5yh+0rVUYGK5UY9gs4dijodHa2a4bdw7x43/98wxUqXnvNOEH8yO1tnePXut/f/n7MLRr3cPtG8GLJ8hftofjh19aap4TWcZwxy5wjpef8sus6pExzGazeJ5HPl+f/y9bTQt8VCn1Em4nrUfGMNWbIZvbzOzkBbxEYmlLy6XCeYahDc0wDPTmt2O4+gSGA4PMLm0l9b+vuJV0Ypxkxg+w2i0wLM8Y1isw3D3i/y2qNZ4JlQeGtbaSzpcck4slzhSKS7dV/dnX5thzY32efPPZFKcm5zh2bgYvZmzur0+n2A2tKenP4VsorT8oe2E67Ei6/n/rVE+8Lo1n1srMNvzp+1gqUbEr6ckGBoa5GGStcmfSI4uObXH/pTWTyZBIJJYa0AyMJfF6PRKDHrNTkxtqPFN3192Avf4avHw40vrCtUju9NfVqFEVl7L8fn62/xu44J85M/8yDO+BiLK817zr3dzz5a/ULWM4MjKCmdVssd9Mu669gXu+9CCbVrGNuVuCQljOGNesec9fCbEELM7XZRtpvY3u3c+pVw5z/rQ/m7pvqHqjqXoa2b4LgJef9Gel1qPGMJPJcN9993Fl8J670ygw7CDpK4LAsA4ZQwgG3eNnC6u9ebuir4est3wa1SMwjA2McSB7ml19E3UJDMOtpHOTYcbw4mCvt7cXLIaXTjN9bpzpiXG8tL+trt0Cw0ZkDMcG0yQ8Y6BG4xnwt5ICxFMp0n1VBs4G2cEzC0XOBLV11WoMAd75j/fzcx+pT/fBXF/K30o6McuWbJq41/ynv3xq+e+xXs9P+RnQA+sYVdEJRoMh93OXDLk/sVBYdzOelZgZexKxN20lnSs5Ti36GcPwuPIGNJe9tZ/d92xnfmYaVyrR298iGUNYmmdoCwstmzEc+MBdbPqNz5DYHlH9Y+4Am5OH2LvHHzGSmX42ksYzIYvFVhUkrdaBAwe49957GajTe4R6M7Pa2yW71Oi+A3zg/gfYfX2NJjDxJGwOApU6dkKvl9G9l1MsLPDq3z1FT382sl05g1u2EE+meOPQC35NZ50yldlsduXO9G2qM3+rLlXPjCEsbyetVF8Y8sx4y2CQXfNiZOvR6KF/lPdufZErB04vz+dZp96BQQpzsxTm5/zsZzxOIn1xsOR5Hj09PXjpXqYmJvxxFckkiUSCVKr5WaW1SKVSeJ5X18Aw7sW4bCRDrsp4k1DvwCCJdA/ZTbmqHyTklgLDwlLGsFqNYb3ls2l/K+m52aodSaNWj1mGB6fn2JFORt5avlWMBZ1JT5Q18ZkqLjK9WGJzgzKGAHsTxisFR7GsK/OxxaDxTHz5/B8eHubcuXOUSiVinuGlPWYmw46kLZQx3H8AFz5f1Bhu30yp3bvJ33dfdDVew7shFucdV/2E2+++nMzUMzDS+FEVjRJ+UCHtxczYff3NK9cjh++Xstsavqa1Ckc/nTj8UmTbSMFvQrhp23ZwjmwuT2wjc7a7hALDDpLctZPk7t2krzhQl8cb2XEZsHI79bcHgWE9RlUAy/Ub/WPQv7FC4TConTl/ntnJSdL9lefh9fX1YckU50+dYH56mkUv0XbZQgiK4zMZJicnmZ+fr0tgCPD7H72Of/XeK1b82SPbdjA4Wv3TynDb6OlCkbNBMFQrY1hP+f4U88USL5yYrFlfGKUwUN5IZ9KDQUfSbrU05L6sM2kYJG5p4Lm1NxFjAb+mMBReDreSAgwNDVEqlTh/frkWe+aCf7mlMobxOFztNztp1a2kkYsnYXgPPReeY//ls+AWI2k8I7IuY9f531twK2k2t3mpjGelrrP1Fm4nrcc20m6g5jMdxGIx9vzVd+v2eOFW0kqjKsq9Pagz3FajY+Wa9AyBl9zwNlJYbpozc+Ecs5MXqnY/zGQyTMYT/lw1oED7NZ4J9fX1ceaM3xK6XoHhVWOrewP7/n92P16NUSm5IEN2ZqHImUIRA4YjyhiGLc4n54otlzE8vc6M4dxiiVdm53lfbrCOq2ovo+k3D7k/EVxuZMZwuQFNiV3B5SPB0Ptt3sUZQ4CJiYmlbM3M5AXiySSJVtuR8M5bcUdfh/zGO/d1jNx+OPU8nD3sX1dgKK1q5y1+neHmxnftXSszY3Tffl758RN1q5ldrbBpz6ACw1VRxlCqGtwySk9/9qKmIpVc09/LYNxjX2+dshZm8M7PwVs/veGHygwMAmHG8MKbhtsvHZfJUIx5uKAJyLxrv/rCUCaTqXtguFrZkdxSy/FKwiDQrzEsMpTw8CLaFpYrazbTKhnDMIO63ozhoZk5Fh1dnTEcTVUPDBvVfAZgZ9zwgJfLBt0fKTpGYtBb1r23v7+feDy+VGcIfmDYW2X3QlPd+UH4L9/xu5SKL3cAxl+Bk8/514drNAARaabcfviXR2DrDc1eSUXhvNr+4ei2ksLymI+sPvBaFWUMpapYzOPuLz1IOlN75lEiZjx2836G61nj9I5/XpeH6V0KDM8xN3lhqVXypTKZDAXnv9EDmCkUW3bW00r6+vpYWPC31UUdGK4kETOG4p6/lbRQZCQRXWe5fP9y8NQqGcO0F2Mg7q27xvBgHTqStruM5zEY9zhWKTBsUPMZgKQZO+N2UWfSo0V30TZSWK7rCjuTAsxMnmcoH83IgzVptUC1FeT2gyvBS49C7ybojaabosi6JFr3tSAcdB91xnDLnn2M7NjFjmAuqNSmjKHU1Dc0vKruUdvTSTIt2PyiZ6nGMNhKWqXZQyaTobzh/UIbbyUtn1HVaoEhhEPuC5xdKEZWXwj+uIpQq2QMAfLJ+LozhgenZknFjN31qu9tU/6Q++X/g08uFOjzYg1vyHNpZ9Iji6WljqTlwsCwVCqxWCwwPzPTWo1npLpcULN/9P9pG6nIBmy/6hre9ksfY8/Nb4v056YzfdzzpQeXGuBIbQoMpaMlkimSPT1Mn5tgbmqKdF/1wDCcZeglEhDz2jYwLM90tm5g6NcYRtWRFKA/FScVZHNaJWMIft3lesdVvDA9x77eNPFYd2d6xlJJjs+VZwyLDd1GGtqbMM6U4NyiY7LkOF+iYmA4PDzM4uIik5OTzAZjc1qq8YxUt2kvWGz5soisixdPcMtHPl61pEdagwJD6Xi92UEmjh/DuVLN5jOlIDBM9WfBOiNjmE63Xu3ZSCLBmYJfYxhlxtDMyGdTbMokSSdaJ7u9kYzh813ekTQ0lk5ctJX05EKBzQ3cRhraE19uQFOpI2kobDozPj7O7GTYkVQZw7aQSMOQ36FbgaGIdDoFhtLxegcGOXvsCPDm4fah8oxhstfPuLVrjWGrB4a5ZJzj8wXOFReXmq9EZTTbw7bh3kh/5kryycS6agzHC0VOLhS7ur4wNJpKcLZQXBpyf2K+EFHG0H8JPVwoVexIGspms3iex8TEBLMXFBi2nXA7qQJDEelwaj4jHa93YIA3XjoIUDNjSMwjnkoTS/tvtNs1YxgGtOGw+1YzkowzHbyBjzJjCPDAHVdSNo+8JeSCv8d0cXFNdboHp2YBuCLTesF/1MJZhicXCuxIJyPLGA55xnDM70y62fM/aR2rsJU0FosxODjoN6DpLZLqzdQc6yItJrcfXvyuAkMR6Xh6ZZKOF3YmBUjXyBgCbH3LLdCTIXHiNKlWmzG2SuHv0or1hcBFWcIoawxh9fMYo7Q0y7BQXFtgGHYk7WvNf+cojaX8BlnH5gr0xz3mS44tqWjOrb1BA5qCizHqGYkqnT2Hh4d59dVXSRVLyha2m6vugolXYWRfs1ciItJQ2koqHa88MOyp0vAhzK5lL78KBobp7+9vvRljq9TT04OZtWxgmCvLEkadMWxF+eBvcGp+bXWGB6dmGU54bNbfsGyW4QInIxhuX25PIsarRcffF0tsq5AtDA0NDVEoFJiaOEtvtvU+oJAaRq+FD/8xeNGN1xERaQYFhtLxyt+EVdtKamb09fUxPT3N5ORk29YXgr9tLZPJtGxgOFK2xU+BIeSDAGatdYYHp+c4kOlp2w8w6incSvrGfGFphuFoBFtJAfbEjSLw90VXsSNpKGxAg3PKGIqISEtSYCgdr3fAf0MW8zySNYKlTCazFBi2a31haPv27YyNjTV7GRWVZwyj3kraipYyhmvoTFpyjhem51RfGMjEPQbinh8YLkSbMQwb0EDljqShgYEBYjH/fgWGIiLSivSuTDpebzDkvqc/WzO7kslkmJqaYnJykssvvzyq5TXERz/60WYvoaqwxjBuMNDgAeTtYDgRJwacXkPG8MjcAjOLJdUXlgmH3Idba6NoPgP+3MIksEDljqQhz/MYHBxkfHycjLaSiohIC2pKxtDMhs3sMTM7FHwfqnLcPcExh8zsnrLbf2BmL5rZ08FXPrrVS7sJawzTKwxVzWQyjI+PUygU2j5j2MoyXox0zNiUiBPTNkg8M0bWOMvw+aAj6ZXKGC4ZSyWCjGGRobhH2ovm5S1uxmUJ/zyutZUU/AY0Mc8j3ZupeZyIiEgzNGsr6f3A4865fcDjwfWLmNkw8ADwVuAtwAOXBJAfd85dF3ydimLR0p7CwLAnW3v7ViaTYX5+HmjfGYbtwIJASPWFy3LJ+JpqDMOOpPsVGC4ZSyV5Y67AifmFyLaRhvYmYqQN8jUyhgBXX301V9/6biymKg4REWk9zXp1uhN4OLj8MHBXhWN+AXjMOTfunJsAHgPeE83ypJOkM33EPI+evpUDw5Ayho21LZVkazBiQMIh96vPGD51foZdPck1jbfodKOpBGcKRV6fXWBLRNtIQ7/Wn+CLw8kVM+A9PT0M5LdEtCoREZG1adZH9pudc8eDyyeAzRWO2QocKbt+NLgt9Mdmtgj8V+B3nWu1sdXSKsyMTVu3M7x1W83jFBhG5ytX7sTTNtIluWScl4Is4EoOTc/xvfEL/NbOSk+b3Wss7QeDL87McU1/b6Q/O+cZOU9BuoiItLeGBYZm9rdApY9GP19+xTnnzGytQd3HnXPHzKwfPzD8FeAbVdbxaeDTADt27Fjjj5FO8bHf/TJevHYWQYFhdLamlS0s52cMizjnVhw/8dUjp0jHjE9uy0W0uvYQDrlfdMtzDUVERGT1GhYYOudur3afmZ00s1Hn3HEzGwUq1QgeA24tu74N+EHw2MeC75Nm9k38GsSKgaFz7mvA1wBuuukmZRW7VCK1ci1WGBjG43FSqVSjlySyJJ+MU3COc8VFhmqM8HhjboFvn5jgV8Y2qUbzEuXBYNQ1hiIiIp2gWTWGjwBhl9F7gO9UOOZR4N1mNhQ0nXk38KiZxc1sBMDMEsD7gWcjWLN0uDAw7O/v19BwiVQ+uboh9187epoSjs9sV7bwUmNlweAWBc0iIiJr1qzA8AvAz5vZIeD24DpmdpOZfR3AOTcO/BvgieDrd4LbUvgB4k+Bp/Ezi38U+W8gHac8MBSJUi4IZE7XaEAzUSjyp2+c5a78EDt6lNG+VF/cIxsMmFfGUEREZO2a8rGqc+4scFuF258EPlV2/SHgoUuOmQZubPQapft4nkdPT49GVUjkVpMx/JNjZ5heLPHZHRrbWs1oKsmF4lzkXUlFREQ6gfbbiJS57bbbGBkZafYypMvkg4zhqfnKGcOZxRJ/dPQ0t2/KckVfT5RLaytjqQQvTc+RU2AoIiKyZgoMRcrcdNNNzV6CdKFs3CMVs6oZw28dP8t4YVHZwhVc3pvm1dl5EjHVCIuIiKyVAkMRkSYzM3LJeMUh94WS46tHTnFzNsNbBzIV/msJfW73Fj67U8GziIjIejSr+YyIiJTJJxOcrpAxfOTUBEfnCvzTnXl1y11BxvO0jVRERGSdFBiKiLSAShlD5xwPvn6K/Zk0t2/KNmllIiIi0g0UGIqItIB8MvGmGsPHxyc5OD3Hb+7IE1O2UERERBpIgaGISAvIJeOMF4oUS27ptgdfO8nWVIIP5IeauDIRERHpBgoMRURaQD6ZwAFnC37W8Inz0/zo/DS/sSOvLpsiIiLScAoMRURawNIsw6DO8MHXTzKc8PjY6HAzlyUiIiJdQoGhiEgLyAfdNE8tFHlhepZHz1zgE1tzZDyvySsTERGRbqA5hiIiLSBXljH8zqkJemIxPrFtpMmrEhERkW6hjKGISAsI5+/95MIM/+3kBP9kbJjhhD67ExERkWgoMBQRaQG9Xox+L8Y3j58F4Ne355u8IhEREekmCgxFRFpEPpmg6OCDm4fYlk42ezkiIiLSRRQYioi0iLDO8Dd3bG7ySkRERKTbqIBFRKRF3JEf5MaBDPsz6WYvRURERLqMAkMRkRbxiW25Zi9BREREupS2koqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIl1NgKCIiIiIi0uUUGIqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIl1NgKCIiIiIi0uUUGIqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIl1NgKCIiIiIi0uUUGIqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIl1NgKCIiIiIi0uUUGIqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIl1NgKCIiIiIi0uUUGIqIiIiIiHQ5BYYiIiIiIiJdToGhiIiIiIhIlzPnXLPXEBkzOw281ux1dLAR4EyzFyEdR+eVNILOK2kEnVfSKDq3pJ52Oudyl97YVYGhNJaZPemcu6nZ65DOovNKGkHnlTSCzitpFJ1bEgVtJRUREREREelyCgxFRERERES6nAJDqaevNXsB0pF0Xkkj6LySRtB5JY2ic0saTjWGIiIiIiIiXU4ZQxERERERkS6nwFDWzcw+bGbPmVnJzKp2yjKz95jZi2Z22Mzuj3KN0n7MbNjMHjOzQ8H3oSrHLZrZ08HXI1GvU9rDSs8/ZpYys78I7v+/ZrarCcuUNrOK8+pXzex02XPUp5qxTmkvZvaQmZ0ys2er3G9m9gfBefdTM7sh6jVKZ1NgKBvxLPBB4IfVDjAzD/gK8IvAlcDHzOzKaJYnbep+4HHn3D7g8YvAxwEAAAUaSURBVOB6JbPOueuCrzuiW560i1U+/3wSmHDO7QV+H/i9aFcp7WYNr2t/UfYc9fVIFynt6k+A99S4/xeBfcHXp4F/F8GapIsoMJR1c84ddM69uMJhbwEOO+decc4tAN8C7mz86qSN3Qk8HFx+GLireUuRNrea55/y8+3bwG1mZhGuUdqPXtekIZxzPwTGaxxyJ/AN5/sRMGhmo9GsTrqBAkNptK3AkbLrR4PbRKrZ7Jw7Hlw+AWyuclzazJ40sx+Z2V3RLE3azGqef5aOcc4VgfPApkhWJ+1qta9rvxRs9/u2mW2PZmnS4fSeShoq3uwFSGszs78FtlS46/POue9EvR7pDLXOq/IrzjlnZtVaJ+90zh0zs93A98zsGefcy/Veq4jIOvwP4M+dc/Nm9uv4Wel3NXlNIiI1KTCUmpxzt2/wIY4B5Z+Ubgtuky5W67wys5NmNuqcOx5skTlV5TGOBd9fMbMfANcDCgyl3Gqef8JjjppZHBgAzkazPGlTK55Xzrnyc+jrwBcjWJd0Pr2nkobSVlJptCeAfWZ2mZklgV8G1EFSankEuCe4fA/wpsy0mQ2ZWSq4PALcAjwf2QqlXazm+af8fPsQ8D2nAb9S24rn1SV1X3cAByNcn3SuR4C7g+6kbwPOl5VeiGyYMoaybmb2AeAPgRzwXTN72jn3C2Y2BnzdOfde51zRzD4LPAp4wEPOueeauGxpfV8A/rOZfRJ4DfgIQDAS5TPOuU8BVwD/wcxK+B9wfcE5p8BQLlLt+cfMfgd40jn3CPAfgT81s8P4TR9+uXkrlnawyvPqXjO7Ayjin1e/2rQFS9swsz8HbgVGzOwo8ACQAHDO/Xvgr4D3AoeBGeDXmrNS6VSmD0ZFRERERES6m7aSioiIiIiIdDkFhiIiIiIiIl1OgaGIiIiIiEiXU2AoIiIiIiLS5RQYioiIiIiIdDkFhiIiIlWY2SYzezr4OmFmx4LLU2b21Qb9zN8ys7tr3P/+YDSCiIhI3WhchYiIyCqY2W8DU865LzfwZ8SBHwM3OOeKVY6x4JhbnHMzjVqLiIh0F2UMRURE1sjMbjWz/xlc/m0ze9jM/o+ZvWZmHzSzL5rZM2b2N2aWCI670cz+t5k9ZWaPmtlohYd+F/DjMCg0s3vN7Hkz+6mZfQvA+Z/o/gB4fyS/rIiIdAUFhiIiIhu3Bz+ouwP4M+D7zrlrgFngfUFw+IfAh5xzNwIPAf+2wuPcAjxVdv1+4Hrn3M8Anym7/Ung5+r+W4iISNeKN3sBIiIiHeCvnXMFM3sG8IC/CW5/BtgF7AeuBh7zd4LiAccrPM4ocLDs+k+B/2Rmfwn8Zdntp4Cx+i1fRES6nQJDERGRjZsHcM6VzKzglgv4S/ivtQY855x7+wqPMwuky66/D3gH8I+Az5vZNcE203RwrIiISF1oK6mIiEjjvQjkzOztAGaWMLOrKhx3ENgbHBMDtjvnvg/8C2AA6AuOuxx4tuGrFhGRrqHAUEREpMGccwvAh4DfM7O/A54GfrbCoX+NnyEEf7vpnwXbU38C/IFz7lxw3z8EvtvINYuISHfRuAoREZEWYmb/Hficc+5Qlfs3A990zt0W7cpERKSTKTAUERFpIWa2H9jsnPthlftvBgrOuacjXZiIiHQ0BYYiIiIiIiJdTjWGIiIiIiIiXU6BoYiIiIiISJdTYCgiIiIiItLlFBiKiIiIiIh0OQWGIiIiIiIiXU6BoYiIiIiISJf7/+tnEI9ZPOTyAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -265,52 +470,223 @@ } ], "source": [ - "polarity = 'ON' # 'ON' or 'OFF'. The polarity of the responses to be plotted.\n", - "cell_idx = 0 # The cell index to be plotted.\n", + "plt.figure(figsize=(15,10))\n", + "polarity = 'OFF' # 'ON' or 'OFF'. The polarity of the responses to be plotted.\n", + "cell_idx = 1 #next(idx) # The cell index to be plotted.\n", "num_std = 2 # int or float. Number of standard deviation from mean for plotting the horizontal span.\n", - "ax = LSN_data.plot_pixel_avg_dff_traces(polarity, cell_idx, num_std)" + "save_fig = False\n", + "ax = LSN_data.plot_pixel_avg_dff_traces(polarity, cell_idx, num_std)\n", + "if save_fig:\n", + " fig = ax.get_figure()\n", + " fig.savefig(os.path.join(save_dir, 'cell_{}_{}_responses'.format(cell_idx, polarity)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### To plot the RFs\n", + "### 3.2 To plot the RFs\n", "\n", - "- To plot the RF of selected cells using the integration window set above.\n", - "- Choose the polarity (ON, OFF, or both) to be plotted." + "- To plot the RF of selected cells using the integration window (if used trial averaged RF) set above.\n", + "- Choose the polarity (ON, OFF, or both) to be plotted.\n", + "- The RFs are being normalized to range [-1, 1] for plotting." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-07-30T04:27:27.146884Z", - "start_time": "2020-07-30T04:27:19.503583Z" + "end_time": "2021-05-04T16:19:11.594557Z", + "start_time": "2021-05-04T16:19:10.751819Z" }, - "scrolled": false + "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "fig_title = \"Receptive fields\" # The title of the figure.\n", - "cell_idx_lst = np.arange(100) # list or np.array. The cell numbers to be plotted.\n", - "polarity = 'both' # 'ON', 'OFF', or 'both'. The polarity of the RFs to be plotted.\n", - "num_cols = 10 # int. The number of columns of the subplots.\n", + "cell_idx_lst = np.arange(LSN_data.num_cells) # list or np.array. The cell numbers to be plotted.\n", + "polarity = 'ON' # 'ON', 'OFF', or 'both'. The polarity of the RFs to be plotted.\n", + "num_cols = 4 # int. The number of columns of the subplots.\n", "label_peak = True # bool. If True, the pixel with max response will be labeled. The ON peaks are labeled with red dots and OFF peaks with blue dots.\n", + "show_CS_center = True # bool. If True, the CS center will be plotted.\n", "contour_levels = [0.6] # list or array-like. The contour levels to be plotted. Examples: [], [0.5], [0.6, 0.8].\n", - "fig = LSN_data.plot_RFs(fig_title, cell_idx_lst, polarity, num_cols, label_peak, contour_levels)" + "fig = LSN_data.plot_RFs(fig_title, cell_idx_lst, polarity, num_cols, label_peak, show_CS_center, contour_levels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyze multiple sessions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-03T10:58:34.826537Z", + "start_time": "2021-05-03T10:58:34.812736Z" + } + }, + "outputs": [], + "source": [ + "def analyze_RFs_all_sessions(datadir_path, savedir_path, LSN_stim_path, num_baseline_frames,\n", + " use_dff_z_score=False, correct_LSN=False, use_only_valid_eye_pos=False,\n", + " use_only_positive_responses=False, RF_type=\"Greedy pixelwise RF\", \n", + " RF_loc_thresh=0.8):\n", + " \"\"\"To analyze the RFs for all sessions within a folder.\n", + " \n", + " Parameters:\n", + " -----------\n", + " datadir_path : str\n", + " The path to the folder containing the data.\n", + " savedir_path : str\n", + " The path to the folder for saving the outputs.\n", + " LSN_stim_path : str\n", + " The path to the LSN stimulus npy file.\n", + " num_baseline_frames : int\n", + " The number of baseline frames before the start and after the end of a trial.\n", + " use_dff_z_score : bool\n", + " If True, the cell responses will be converted to z-score before analysis.\n", + " correct_LSN : bool\n", + " If True, the LSN stimulus corrected by eye positions will be used. Otherwise, the original LSN \n", + " stimulus will be used. The stimulus wlll remain unchanged for those frames without valid eye positions.\n", + " use_only_valid_eye_pos : bool\n", + " If True, only stimuli with valid eye positions are used. Otherwise, all stimuli will be used.\n", + " use_only_positive_responses : bool\n", + " If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses.\n", + " RF_type : str\n", + " \"Greedy pixelwise RF\" or \"Trial averaged RF\". The type of RFs to be computed.\n", + " RF_loc_thresh : float\n", + " The threshold for deciding whether the RF is located within the center or surround or not.\n", + " \n", + " Returns\n", + " -------\n", + " chi_square_pvals_dict : dict\n", + " Dictionary containing the Chi-square p-values for all sessions.\n", + " RFs_dict : dict\n", + " Dictionary containing the ON and OFF RFs for all sessions.\n", + " ovl_idx_dict : dict\n", + " Dictionary containing the ON and OFF overlapping index for all sessions.\n", + " RF_loc_mask_dict : dict\n", + " Dictionary containing the RF location masks for different conditions for all sessions.\n", + " \"\"\"\n", + " from oscopetools import read_data as rd\n", + " chi_square_pvals_dict = {}\n", + " RFs_dict = {}\n", + " ovl_idx_dict = {}\n", + " RF_loc_mask_dict = {}\n", + " files = os.listdir(datadir_path)\n", + " for i, file in enumerate(files):\n", + " datafile_path = os.path.join(datadir_path, file)\n", + " metadata = rd.get_metadata(datafile_path)\n", + " LSN_data = LSN_analysis(datafile_path, LSN_stim_path, num_baseline_frames, use_dff_z_score, \n", + " correct_LSN, use_only_valid_eye_pos, use_only_positive_responses, \n", + " RF_type, RF_loc_thresh, verbose=False)\n", + " stim_sess = 'CS' if LSN_data._is_CS_session else 'Session'\n", + " session = '{} {}, ({}, {})'.format(stim_sess, metadata['session_ID'], metadata['area'], metadata['cre'])\n", + " chi_square_pvals_dict[session] = LSN_data.chi_square_pvals\n", + " RFs_dict[session] = {}\n", + " RFs_dict[session]['ON'] = LSN_data.ON_RFs\n", + " RFs_dict[session]['OFF'] = LSN_data.OFF_RFs\n", + " ovl_idx_dict[session] = {}\n", + " ovl_idx_dict[session]['ON'] = LSN_data.ON_overlap_idx\n", + " ovl_idx_dict[session]['OFF'] = LSN_data.OFF_overlap_idx\n", + " RF_loc_mask_dict[session] = LSN_data.location_mask_dict\n", + " print(\"{} ({}/{}) done.\".format(file, i+1, len(files)))\n", + " np.save(os.path.join(savedir_path, 'Chi_squares_p_val_all_sessions'), chi_square_pvals_dict)\n", + " np.save(os.path.join(savedir_path, 'final_RFs_all_sessions'), RFs_dict)\n", + " np.save(os.path.join(savedir_path, 'overlapping_index_all_sessions'), ovl_idx_dict)\n", + " np.save(os.path.join(savedir_path, 'RF_location_masks_thresh_{}'.format(RF_loc_thresh)), RF_loc_mask_dict)\n", + " return chi_square_pvals_dict, RFs_dict, ovl_idx_dict, RF_loc_mask_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-03T17:49:04.455440Z", + "start_time": "2021-05-03T11:08:08.757422Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Center_Surround_1010436210_data.h5 (1/37) done.\n", + "Center_Surround_989418742_data.h5 (2/37) done.\n", + "Center_Surround_986765043_data.h5 (3/37) done.\n", + "Center_Surround_1005201417_data.h5 (4/37) done.\n", + "Center_Surround_992742223_data.h5 (5/37) done.\n", + "Center_Surround_981714380_data.h5 (6/37) done.\n", + "Center_Surround_993230912_data.h5 (7/37) done.\n", + "Center_Surround_992260410_data.h5 (8/37) done.\n", + "Center_Surround_978206308_data.h5 (9/37) done.\n", + "Center_Surround_993675703_data.h5 (10/37) done.\n", + "Center_Surround_993777805_data.h5 (11/37) done.\n", + "Center_Surround_1012864690_data.h5 (12/37) done.\n", + "Center_Surround_990815631_data.h5 (13/37) done.\n", + "Center_Surround_1013163234_data.h5 (14/37) done.\n", + "Center_Surround_976085882_data.h5 (15/37) done.\n", + "Center_Surround_994732235_data.h5 (16/37) done.\n", + "Center_Surround_979264183_data.h5 (17/37) done.\n", + "Center_Surround_991976591_data.h5 (18/37) done.\n", + "Center_Surround_993944623_data.h5 (19/37) done.\n", + "Center_Surround_993256153_data.h5 (20/37) done.\n", + "Center_Surround_993994146_data.h5 (21/37) done.\n", + "Center_Surround_1006636506_data.h5 (22/37) done.\n", + "Center_Surround_993269234_data.h5 (23/37) done.\n", + "Center_Surround_992419828_data.h5 (24/37) done.\n", + "Center_Surround_995545810_data.h5 (25/37) done.\n", + "Center_Surround_974290613_data.h5 (26/37) done.\n", + "Center_Surround_1010368135_data.h5 (27/37) done.\n", + "Center_Surround_1004747593_data.h5 (28/37) done.\n", + "Center_Surround_1012847933_data.h5 (29/37) done.\n", + "Center_Surround_1002937736_data.h5 (30/37) done.\n", + "Center_Surround_992698474_data.h5 (31/37) done.\n", + "Center_Surround_990548570_data.h5 (32/37) done.\n", + "Center_Surround_1010686440_data.h5 (33/37) done.\n", + "Center_Surround_1011892173_data.h5 (34/37) done.\n", + "Center_Surround_978322303_data.h5 (35/37) done.\n", + "Center_Surround_994865495_data.h5 (36/37) done.\n", + "Center_Surround_976474801_data.h5 (37/37) done.\n" + ] + } + ], + "source": [ + "data_dir = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/new_data/Soma Data/Center_Surround'\n", + "LSN_stim_path = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/openscope_surround-master/stimulus/sparse_noise_8x14.npy'\n", + "save_dir = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/analysed_data/greedy_RFs'\n", + "num_baseline_frames = 10 # int or None. The number of baseline frames before the start and after the end of a trial.\n", + "use_dff_z_score = False\n", + "correct_LSN = False # If True, the LSN stimulus corrected by eye positions will be used.\n", + "use_only_valid_eye_pos = False # Use False for greedy pixelwise RF.\n", + "use_only_positive_responses = False # If True, the fluorescence responses less than 0 will be set to 0 when computing the avg_responses.\n", + "RF_type = \"Greedy pixelwise RF\" # \"Greedy pixelwise RF\" or \"Trial averaged RF\". The type of RFs to be computed.\n", + "RF_loc_thresh = 0.8 # The threshold for deciding whether the RF is located within the center or surround or not.\n", + "\n", + "(chi_square_pvals_dict, RFs_dict, ovl_idx_dict, \n", + " RF_loc_mask_dict) = analyze_RFs_all_sessions(data_dir, save_dir, LSN_stim_path, num_baseline_frames, \n", + " use_dff_z_score, correct_LSN, use_only_valid_eye_pos, \n", + " use_only_positive_responses, RF_type, RF_loc_thresh)" ] } ], @@ -330,7 +706,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.8.5" }, "varInspector": { "cols": { From e8264a424005122ada0c8c36faa89317a98fb594 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Tue, 4 May 2021 20:46:01 +0200 Subject: [PATCH 49/68] Corrected overlapping index equation --- analysis/compute_and_plot_RFs.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb index 95136ae..ea10997 100644 --- a/analysis/compute_and_plot_RFs.ipynb +++ b/analysis/compute_and_plot_RFs.ipynb @@ -328,7 +328,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "$$ S_i^{P} (\\vec x_c, r_c) = \\frac {\\sum_{\\vec x} R(\\vec x, \\vec x_c, r_c) \\Psi_i^P(\\vec x)} {\\sum_{\\vec x} \\Psi_i^P(\\vec x)}, P \\in \\{ \\text{ON}, \\text{OFF} \\} $$\n", + "$$ S_i^{P} (\\vec x_c, r_c) = \\frac {\\sum_{\\vec x} R(\\vec x, \\vec x_c, r_c) \\left| \\Psi_i^P(\\vec x) \\right|} {\\sum_{\\vec x} \\left| \\Psi_i^P(\\vec x) \\right|}, P \\in \\{ \\text{ON}, \\text{OFF} \\} $$\n", "\n", "\\begin{split}\n", "R(\\vec x, \\vec x_c, r_c) &= \n", From 07145695cdd0af92536bd6233e1e3b847dcd61d4 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Tue, 4 May 2021 21:55:56 +0200 Subject: [PATCH 50/68] Corrected overlapping index equation --- analysis/compute_and_plot_RFs.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb index ea10997..655edfc 100644 --- a/analysis/compute_and_plot_RFs.ipynb +++ b/analysis/compute_and_plot_RFs.ipynb @@ -389,7 +389,7 @@ "\\text{OFF center alone}, & \\text{if } S_i^{\\text{OFF}} \\geq \\vartheta \\text{ and no ON subfield} \\\\\n", "\\text{ON center OFF surround}, & \\text{if } S_i^{\\text{ON}} \\geq \\vartheta \\text{ and } S_i^{\\text{OFF}} \\leq 1 - \\vartheta \\\\\n", "\\text{OFF center ON surround}, & \\text{if } S_i^{\\text{OFF}} \\geq \\vartheta \\text{ and } S_i^{\\text{ON}} \\leq 1 - \\vartheta \\\\\n", - "\\text{No RF}, & \\text{otherwise}\n", + "\\text{No RF}, & \\text{if no ON subfield and no OFF subfield}\n", "\\end{cases}\n", "\\end{split}\n", "\n", From 987b17e318cbd92168e661f222a4cef0e78c1129 Mon Sep 17 00:00:00 2001 From: Kai Lun Date: Wed, 5 May 2021 23:25:20 +0200 Subject: [PATCH 51/68] Merging PR from kt1524: Added gag and save_data (#9) --- analysis/compute_and_plot_RFs.ipynb | 44 ++++++++++++++++--- oscopetools/LSN_analysis.py | 68 +++++++++++++++++++++-------- 2 files changed, 89 insertions(+), 23 deletions(-) diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb index 655edfc..ddfbbe0 100644 --- a/analysis/compute_and_plot_RFs.ipynb +++ b/analysis/compute_and_plot_RFs.ipynb @@ -5,8 +5,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-05-04T17:10:51.084430Z", - "start_time": "2021-05-04T17:10:50.376025Z" + "end_time": "2021-05-04T23:25:54.739372Z", + "start_time": "2021-05-04T23:25:53.998040Z" } }, "outputs": [], @@ -15,6 +15,7 @@ "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "from oscopetools.LSN_analysis import LSN_analysis\n", + "from oscopetools import read_data as rd\n", "import os, warnings\n", "warnings.filterwarnings('ignore')\n", "%matplotlib inline" @@ -62,8 +63,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-05-04T17:12:27.030614Z", - "start_time": "2021-05-04T17:10:56.022181Z" + "end_time": "2021-05-04T23:27:26.475435Z", + "start_time": "2021-05-04T23:25:58.780122Z" }, "scrolled": true }, @@ -89,7 +90,7 @@ ], "source": [ "CS_dir = '/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/new_data/Soma Data/Center_Surround'\n", - "file= 'Center_Surround_1010436210_data.h5'\n", + "file = 'Center_Surround_1010436210_data.h5'\n", "\n", "# The path to the data file.\n", "datafile_path = os.path.join(CS_dir, file)\n", @@ -413,6 +414,38 @@ "LSN_data.get_RF_loc_masks(loc_thresh, RF_thresh, bin_num)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4 Save data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-04T23:27:26.547864Z", + "start_time": "2021-05-04T23:27:26.529207Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data saved!\n" + ] + } + ], + "source": [ + "save_dir = \"/home/kailun/Desktop/PhD/other_projects/surround_suppression_neural_code/analysed_data/greedy_RFs\"\n", + "metadata = rd.get_metadata(datafile_path)\n", + "save_filepath = os.path.join(save_dir, \"outputs_{}.npy\".format(metadata['session_ID']))\n", + "LSN_data.save_data(save_filepath)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -586,7 +619,6 @@ " RF_loc_mask_dict : dict\n", " Dictionary containing the RF location masks for different conditions for all sessions.\n", " \"\"\"\n", - " from oscopetools import read_data as rd\n", " chi_square_pvals_dict = {}\n", " RFs_dict = {}\n", " ovl_idx_dict = {}\n", diff --git a/oscopetools/LSN_analysis.py b/oscopetools/LSN_analysis.py index aa40943..3fba996 100644 --- a/oscopetools/LSN_analysis.py +++ b/oscopetools/LSN_analysis.py @@ -15,8 +15,6 @@ from enum import Enum import warnings, sys, os -sys.__stdout__ = sys.stdout - class LSN_analysis: _ON_stim_value = 255 @@ -313,9 +311,8 @@ def _get_chi_square_pvals(self, frame_shift, num_shuffles=1000): ] responses = stim_trial.mean(2) LSN_template = self.LSN_stim[self._trial_mask] - self._allow_print(False) - self.chi_square_pvals = chi_square_RFs(responses, LSN_template, num_shuffles) - self._allow_print(True) + with gag(): + self.chi_square_pvals = chi_square_RFs(responses, LSN_template, num_shuffles) @staticmethod def _remove_non_significant(RF, p_values, significant_lvl=0.05): @@ -609,9 +606,8 @@ def _get_CS_center_shift(self): _center_shift_xy_deg, center_shift_xy_pix : array-like, 1D The x- and y-shifts of the CS center relative to the center of the monitor in degrees and LSN pixels. """ - self._allow_print(False) - stim_table = rd.get_stimulus_table(self.datafile_path, "center_surround") - self._allow_print(True) + with gag(): + stim_table = rd.get_stimulus_table(self.datafile_path, "center_surround") center_xs = np.array(stim_table.Center_x) center_ys = np.array(stim_table.Center_y) is_same_x = center_xs.min() == center_xs.max() @@ -648,7 +644,6 @@ def _get_CS_center_info(self): self.CS_center_radius_pix = CS_center_radius_deg / self._stim_size_deg self._is_CS_session = True except KeyError: - self._allow_print(True) print("This is not a center-surround session!") self._is_CS_session = False @@ -931,14 +926,44 @@ def plot_pixel_avg_dff_traces( return ax def save_data(self, save_path): - raise NotImplementedError - - @staticmethod - def _allow_print(allowed=True): - if allowed: - sys.stdout = sys.__stdout__ - else: - sys.stdout = open(os.devnull, "w") + data_dict = {} + data_dict['cell IDs'] = self.cell_ids + data_dict['Chi-square p-values'] = self.chi_square_pvals + data_dict['CS center pos xy (pix)'] = self.CS_center_pos_xy_pix + data_dict['CS center radius (pix)'] = self.CS_center_radius_pix + data_dict['analyzed data file'] = self.datafile_path + data_dict['is use corrected LSN'] = self.is_use_corrected_LSN + data_dict['is use DFF z-score'] = self.is_use_dff_z_score + data_dict['is use positive fluo'] = self.is_use_positive_fluo + data_dict['is use valid eye pos'] = self.is_use_valid_eye_pos + data_dict['location masks'] = self.location_mask_dict + data_dict['LSN stimuli'] = self.LSN_stim + data_dict['monitor center xy (pix)'] = self.monitor_center_pix_xy + data_dict['num baseline frames'] = self.num_baseline_frames + data_dict['number of cells'] = self.num_cells + data_dict['OFF averaged responses'] = self.OFF_avg_responses + data_dict['OFF overlapping index'] = self.OFF_overlap_idx + data_dict['OFF RFs'] = self.OFF_RFs + data_dict['ON averaged responses'] = self.ON_avg_responses + data_dict['ON overlapping index'] = self.ON_overlap_idx + data_dict['ON RFs'] = self.ON_RFs + data_dict['RF location threshold'] = self.RF_loc_thresh + data_dict['RF type'] = self.RF_type + data_dict['valid eye pos masks'] = self.valid_eye_pos + data_dict['ref pos for LSN stim correction'] = self.yx_ref + data_dict['CS center xy shifts (deg)'] = self._center_shift_xy_deg + data_dict['CS center xy shifts (pix)'] = self._center_shift_xy_pix + data_dict['corrected LSN stim by eye pos'] = self._corrected_LSN_stim + data_dict['CS center diametere (deg)'] = self._CS_center_diameter_deg + data_dict['Fluo frame rate (Hz)'] = self._frame_rate_Hz + data_dict['Original full LSN stim'] = self._full_LSN_stim + data_dict['RF integration window length'] = self._integration_window_len + data_dict['RF integration window start'] = self._integration_window_start + data_dict['is CS session'] = self._is_CS_session + data_dict['LSN grid size (deg)'] = self._stim_size_deg + data_dict['LSN trial masks'] = self._trial_mask + np.save(save_path, data_dict) + print("Data saved!") class ReceptiveFieldPolarity(Enum): @@ -969,3 +994,12 @@ def from_(polarity): def _get_any(): return np.random.randint(1, 3) + + +class gag: + def __enter__(self): + self._original_stdout = sys.stdout + sys.stdout = open(os.devnull, 'w') + + def __exit__(self, exc_type, exc_val, exc_tb): + sys.stdout = self._original_stdout \ No newline at end of file From 5faf45d204e8981bbd1fa6208cd204f59f92cc7f Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 11:20:58 -0400 Subject: [PATCH 52/68] Squashed merge of PR #12 from kt1524 Several commits are squashed because the changes from the "Added gag and save_data" commits are already in 987b17e in nauralcodinglab/master, and 674bbcb reverses 953bdba. The remaining commits resolve trivial conflicts between kt1524/master and nauralcodinglab/master. Squashed commit of the following: commit adc23dfa6fa6a7f24314b15b5d4f1e45908a0015 Author: Kai Lun Date: Wed May 19 01:11:01 2021 +0200 Resolve conflicts commit 62b15a18e2bb4c07b7add9f934f5b76ae60ae81b Merge: 674bbcb 987b17e Author: Kai Lun Date: Wed May 19 00:36:42 2021 +0200 resolve conflicts commit 674bbcb32811f93caa26ab1f4e028af44674e53b Author: Kai Lun Date: Tue May 18 23:29:19 2021 +0200 Remove path appending commit 953bdba87e1af62c45239d8adfc4cdec3daabdaf Author: Kai Lun Date: Mon May 17 17:29:54 2021 +0200 Appended oscopetools directory to sys commit 58c006e6b19f3ce90c1b73bb05b03dd117ab8143 Author: Kai Lun Date: Wed May 5 01:37:09 2021 +0200 Added gag and save_data commit b66c92fa3f7d7e6c6f9f7da014da521b2aef8c83 Author: Kai Lun Date: Wed May 5 01:32:24 2021 +0200 Added gag and save_data commit c12e3c5f233ee7df7c4db24ad095c73305255403 Author: Kai Lun Date: Wed May 5 01:30:58 2021 +0200 Added gag and save_data --- analysis/compute_and_plot_RFs.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/analysis/compute_and_plot_RFs.ipynb b/analysis/compute_and_plot_RFs.ipynb index ddfbbe0..7c0b4db 100644 --- a/analysis/compute_and_plot_RFs.ipynb +++ b/analysis/compute_and_plot_RFs.ipynb @@ -5,8 +5,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-05-04T23:25:54.739372Z", - "start_time": "2021-05-04T23:25:53.998040Z" + "end_time": "2021-05-17T15:15:07.613022Z", + "start_time": "2021-05-17T15:15:06.893308Z" } }, "outputs": [], @@ -63,8 +63,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-05-04T23:27:26.475435Z", - "start_time": "2021-05-04T23:25:58.780122Z" + "end_time": "2021-05-17T15:17:07.797613Z", + "start_time": "2021-05-17T15:15:36.660662Z" }, "scrolled": true }, From a04c4c8ad374d0ce28db438853c4fa074425f4e1 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 11:59:02 -0400 Subject: [PATCH 53/68] Add autoformat script Add shell script for autoformatting Python files with consistent settings. --- autoformat.sh | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100755 autoformat.sh diff --git a/autoformat.sh b/autoformat.sh new file mode 100755 index 0000000..85a822b --- /dev/null +++ b/autoformat.sh @@ -0,0 +1,6 @@ +#!/bin/sh + +# Autoformat one or more Python files using Black with consistent settings. +# -S disables string normalization (leave single quotes as single quotes) +# -l 80 sets line length to 80 characters +black -S -l 80 "$@" From 5d124efa4045467515d7db988cc030a2e732ad28 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 18:22:14 -0400 Subject: [PATCH 54/68] Merge Saskia's stim_table.py updates into oscopetools At the time of this commit, there are two important differences between analysis/stim_table.py from Saskia's current master (9e5c7b4) and oscopetools/stim_table.py from nauralcodinglab/master.py (5faf45d): 1. analysis/stim_table.py stores the center coordinates of the stimulus, but oscopetools/stim_table.py does not. 2. analysis/stim_table.py:get_attribute_by_sweep() contains a try/except block to handle attribute_by_sweep being a list rather than a scalar. (The rest of the differences between oscopetools/stim_table.py and analysis/stim_table.py are due to formatting or Python 2 syntax in analysis/stim_table.py.) This commit incorporates these two changes from Saskia into oscopetools/stim_table.py. Anyone with the oscopetools package installed can now use analysis/stim_table.py by adding `from oscopetools import stim_table` to their scripts. --- analysis/RunningData.py | 2 +- analysis/get_all_data.py | 2 +- analysis/stim_table.py | 530 -------------------------------------- oscopetools/stim_table.py | 19 +- 4 files changed, 18 insertions(+), 535 deletions(-) delete mode 100644 analysis/stim_table.py diff --git a/analysis/RunningData.py b/analysis/RunningData.py index 70e8040..a7aff33 100644 --- a/analysis/RunningData.py +++ b/analysis/RunningData.py @@ -6,7 +6,7 @@ @author: saskiad """ -from stim_table import load_stim, load_alignment +from oscopetools.stim_table import load_stim, load_alignment import numpy as np diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 9e86971..d4bc181 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -11,7 +11,7 @@ import json import h5py from PIL import Image -from stim_table import create_stim_tables, get_center_coordinates +from oscopetools.stim_table import create_stim_tables, get_center_coordinates from RunningData import get_running_data from get_eye_tracking import align_eye_tracking diff --git a/analysis/stim_table.py b/analysis/stim_table.py deleted file mode 100644 index f62be7a..0000000 --- a/analysis/stim_table.py +++ /dev/null @@ -1,530 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Mon Apr 22 17:33:28 2019 - -@author: danielm -additions from saskiad Jun 7 2020 -""" -import os -import warnings - -import numpy as np -import pandas as pd -import h5py - -from sync import Dataset - - -# Generic interface for creating stim tables. PREFERRED. -def create_stim_tables( - exptpath, - stimulus_names = ['locally_sparse_noise', - 'center_surround', 'drifting_gratings_grid', 'drifting_gratings_size'], - verbose = True): - """Create a stim table from data located in folder exptpath. - - Tries to extract a stim_table for each stim type in stimulus_names and - continues if KeyErrors are produced. - - Inputs: - exptpath (str) - -- Path to directory in which to look for experiment-related files. - stimulus_names (list of strs) - -- Types of stimuli to try extracting. - verbose (bool, default True) - -- Print information about progress. - - Returns: - Dict of DataFrames with information about start and end times of each - stimulus presented in a given experiment. - - """ - data = load_stim(exptpath) -# twop_frames, _, _, _ = load_sync(exptpath) - twop_frames = load_alignment(exptpath) - - stim_table_funcs = { - 'locally_sparse_noise': locally_sparse_noise_table, - 'center_surround': center_surround_table, - 'drifting_gratings_grid': DGgrid_table, - 'drifting_gratings_size': DGsize_table - } - stim_table = {} - for stim_name in stimulus_names: - try: - stim_table[stim_name] = stim_table_funcs[stim_name]( - data, twop_frames - ) - except KeyError: - if verbose: - print( - 'Could not locate stimulus type {} in {}'.format( - stim_name, exptpath - ) - ) - continue - - return stim_table - - -# DEPRECATED. Use `create_stim_tables(exptpath, ['locally_sparse_noise', 'drifting_gratings_grid'])` instead. -def coarse_mapping_create_stim_table(exptpath): - """Return stim_tables for locally sparse noise and drifting gratings grid. - - Input: - exptpath (str) - - Returns: - Dict of locally_sparse_noise and drifting_gratings_grid stim tables. - - """ - data = load_stim(exptpath) - twop_frames, _, _, _ = load_sync(exptpath) - - stim_table = {} - stim_table['locally_sparse_noise'] = locally_sparse_noise_table( - data, twop_frames - ) - stim_table['drifting_gratings_grid'] = DGgrid_table(data, twop_frames) - - return stim_table - - -# DEPRECATED. Use `create_stim_tables(exptpath, ['locally_sparse_noise', 'center_surround'])` instead. -def lsnCS_create_stim_table(exptpath): - """Return stim_tables for locally sparse noise and center surround stimuli. - - Input: - exptpath (str) - - Returns: - Dict of center_surround and locally_sparse_noise stim tables. - - """ - data = load_stim(exptpath) - twop_frames, _, _, _ = load_sync(exptpath) - - stim_table = {} - stim_table['center_surround'] = center_surround_table(data, twop_frames) - stim_table['locally_sparse_noise'] = locally_sparse_noise_table( - data, twop_frames - ) - - return stim_table - - -def DGgrid_table(data, twop_frames, verbose = True): - - DG_idx = get_stimulus_index(data, 'drifting_gratings_grid_5.stim') - - timing_table, actual_sweeps, expected_sweeps = get_sweep_frames( - data, DG_idx - ) - - if verbose: - print 'Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - ) - - stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') - ) - - for attribute in ['TF', 'SF', 'Contrast', 'Ori', 'PosX', 'PosY']: - stim_table[attribute] = get_attribute_by_sweep( - data, DG_idx, attribute - )[:len(stim_table)] - - return stim_table - -def DGsize_table(data, twop_frames, verbose = True): - - DGs_idx = get_stimulus_index(data, 'drifting_gratings_size.stim') - - timing_table, actual_sweeps, expected_sweeps = get_sweep_frames( - data, DGs_idx - ) - - if verbose: - print 'Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - ) - - stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') - ) - - for attribute in ['TF', 'SF', 'Contrast', 'Ori', 'Size']: - stim_table[attribute] = get_attribute_by_sweep( - data, DGs_idx, attribute - )[:len(stim_table)] - - x_corr, y_corr = get_center_coordinates(data, DGs_idx) - stim_table['Center_x'] = x_corr - stim_table['Center_y'] = y_corr - - return stim_table - - -def locally_sparse_noise_table(data, twop_frames, verbose = True): - """Return stim table for locally sparse noise stimulus. - - """ - lsn_idx = get_stimulus_index(data, 'locally_sparse_noise.stim') - - timing_table, actual_sweeps, expected_sweeps = get_sweep_frames( - data, lsn_idx - ) - if verbose: - print 'Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - ) - - stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') - ) - - stim_table['Frame'] = np.array( - data['stimuli'][lsn_idx]['sweep_order'][:len(stim_table)] - ) - - return stim_table - - -def center_surround_table(data, twop_frames, verbose = True): - - center_idx = get_stimulus_index(data, 'center') - surround_idx = get_stimulus_index(data, 'surround') - - timing_table, actual_sweeps, expected_sweeps = get_sweep_frames( - data, center_idx - ) - if verbose: - print 'Found {} of {} expected sweeps'.format( - actual_sweeps, expected_sweeps - ) - - stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') - ) - - x_corr, y_corr = get_center_coordinates(data, center_idx) - stim_table['Center_x'] = x_corr - stim_table['Center_y'] = y_corr - - # TODO: make this take either center or surround SF and TF depending on which is not NaN - for attribute in ['TF', 'SF', 'Contrast']: - stim_table[attribute] = get_attribute_by_sweep( - data, center_idx, attribute - )[:len(stim_table)] - stim_table['Center_Ori'] = get_attribute_by_sweep( - data, center_idx, 'Ori' - )[:len(stim_table)] - stim_table['Surround_Ori'] = get_attribute_by_sweep( - data, surround_idx, 'Ori' - )[:len(stim_table)] - - return stim_table - - -def get_stimulus_index(data, stim_name): - """Return the index of stimulus in data. - - Returns the position of the first occurrence of stim_name in data. Raises a - KeyError if a stimulus with a name containing stim_name is not found. - - Inputs: - data (dict-like) - -- Object in which to search for a named stimulus. - stim_name (str) - - Returns: - Index of stimulus stim_name in data. - - """ - for i_stim, stim_data in enumerate(data['stimuli']): - if stim_name in stim_data['stim_path']: - return i_stim - - raise KeyError('Stimulus with stim_name={} not found!'.format(stim_name)) - - -def get_display_sequence(data, stimulus_idx): - - display_sequence = np.array( - data['stimuli'][stimulus_idx]['display_sequence'] - ) - pre_blank_sec = int(data['pre_blank_sec']) - display_sequence += pre_blank_sec - display_sequence *= int(data['fps']) # in stimulus frames - - return display_sequence - - -def get_sweep_frames(data, stimulus_idx): - - sweep_frames = data['stimuli'][stimulus_idx]['sweep_frames'] - timing_table = pd.DataFrame( - np.array(sweep_frames).astype(np.int), - columns=('start', 'end') - ) - timing_table['dif'] = timing_table['end']-timing_table['start'] - - display_sequence = get_display_sequence(data, stimulus_idx) - - timing_table.start += display_sequence[0, 0] - for seg in range(len(display_sequence)-1): - for index, row in timing_table.iterrows(): - if row.start >= display_sequence[seg, 1]: - timing_table.start[index] = ( - timing_table.start[index] - - display_sequence[seg, 1] - + display_sequence[seg+1, 0] - ) - timing_table.end = timing_table.start+timing_table.dif - expected_sweeps = len(timing_table) - timing_table = timing_table[timing_table.end <= display_sequence[-1, 1]] - timing_table = timing_table[timing_table.start <= display_sequence[-1, 1]] - actual_sweeps = len(timing_table) - - return timing_table, actual_sweeps, expected_sweeps - - -def get_attribute_by_sweep(data, stimulus_idx, attribute): - - attribute_idx = get_attribute_idx(data, stimulus_idx, attribute) - - sweep_order = data['stimuli'][stimulus_idx]['sweep_order'] - sweep_table = data['stimuli'][stimulus_idx]['sweep_table'] - - num_sweeps = len(sweep_order) - - attribute_by_sweep = np.zeros((num_sweeps,)) - attribute_by_sweep[:] = np.NaN - - unique_conditions = np.unique(sweep_order) - for i_condition, condition in enumerate(unique_conditions): - sweeps_with_condition = np.argwhere(sweep_order == condition)[:, 0] - - if condition > 0: # blank sweep is -1 - try: - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx] - except: - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx][0] - - return attribute_by_sweep - - -def get_attribute_idx(data, stimulus_idx, attribute): - """Return the index of attribute in data for the given stimulus. - - Returns the position of the first occurrence of attribute. Raises a - KeyError if not found. - """ - attribute_names = data['stimuli'][stimulus_idx]['dimnames'] - for attribute_idx, attribute_str in enumerate(attribute_names): - if attribute_str == attribute: - return attribute_idx - - raise KeyError('Attribute {} for stimulus_ids {} not found!'.format( - attribute, stimulus_idx - )) - - -def load_stim(exptpath, verbose = True): - """Load stim.pkl file into a DataFrame. - - Inputs: - exptpath (str) - -- Directory in which to search for files with _stim.pkl suffix. - verbose (bool) - -- Print filename (if found). - - Returns: - DataFrame with contents of stim pkl. - - """ - # Look for a file with the suffix '_stim.pkl' - pklpath = None - for f in os.listdir(exptpath): - if f.endswith('_stim.pkl'): - pklpath = os.path.join(exptpath, f) - if verbose: - print "Pkl file:", f - - if pklpath is None: - raise IOError( - 'No files with the suffix _stim.pkl were found in {}'.format( - exptpath - ) - ) - - return pd.read_pickle(pklpath) - -def load_alignment(exptpath): - for f in os.listdir(exptpath): - if f.startswith('ophys_experiment'): - ophys_path = os.path.join(exptpath, f) - for f in os.listdir(ophys_path): - if f.endswith('time_synchronization.h5'): - temporal_alignment_file = os.path.join(ophys_path, f) - f = h5py.File(temporal_alignment_file, 'r') - twop_frames = f['stimulus_alignment'].value - f.close() - return twop_frames - - -def load_sync(exptpath, verbose = True): - - #verify that sync file exists in exptpath - syncpath = None - for f in os.listdir(exptpath): - if f.endswith('_sync.h5'): - syncpath = os.path.join(exptpath, f) - if verbose: - print "Sync file:", f - if syncpath is None: - raise IOError( - 'No files with the suffix _sync.h5 were found in {}'.format( - exptpath - ) - ) - - #load the sync data from .h5 and .pkl files - d = Dataset(syncpath) - #print d.line_labels - - #set the appropriate sample frequency - sample_freq = d.meta_data['ni_daq']['counter_output_freq'] - - #get sync timing for each channel - twop_vsync_fall = d.get_falling_edges('2p_vsync')/sample_freq - stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse - photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq - - #make sure all of the sync data are available - channels = { - 'twop_vsync_fall': twop_vsync_fall, - 'stim_vsync_fall': stim_vsync_fall, - 'photodiode_rise': photodiode_rise - } - channel_test = [] - for chan in channels.keys(): - # Check that signal is high at least once in each channel. - channel_test.append(any(channels[chan])) - if not all(channel_test): - raise RuntimeError('Not all channels present. Sync test failed.') - elif verbose: - print "All channels present." - - #test and correct for photodiode transition errors - ptd_rise_diff = np.ediff1d(photodiode_rise) - short = np.where(np.logical_and(ptd_rise_diff > 0.1, ptd_rise_diff < 0.3))[0] - medium = np.where(np.logical_and(ptd_rise_diff > 0.5, ptd_rise_diff < 1.5))[0] - ptd_start = 3 - for i in medium: - if set(range(i-2, i)) <= set(short): - ptd_start = i+1 - ptd_end = np.where(photodiode_rise > stim_vsync_fall.max())[0][0] - 1 - - if ptd_start > 3 and verbose: - print 'ptd_start: ' + str(ptd_start) - print "Photodiode events before stimulus start. Deleted." - - ptd_errors = [] - while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): - error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end] < 1.8)[0] + ptd_start - print "Photodiode error detected. Number of frames:", len(error_frames) - photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) - ptd_errors.append(photodiode_rise[error_frames[-1]]) - ptd_end -= 1 - ptd_rise_diff = np.ediff1d(photodiode_rise) - - first_pulse = ptd_start - stim_on_photodiode_idx = 60 + 120 * np.arange(0, ptd_end - ptd_start, 1) - - stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] - photodiode_on = photodiode_rise[first_pulse + np.arange(0, ptd_end - ptd_start, 1)] - delay_rise = photodiode_on - stim_on_photodiode - - delay = np.mean(delay_rise[:-1]) - if verbose: - print "monitor delay: ", delay - - #adjust stimulus time to incorporate monitor delay - stim_time = stim_vsync_fall + delay - - #convert stimulus frames into twop frames - twop_frames = np.empty((len(stim_time), 1)) - for i in range(len(stim_time)): - # crossings = np.nonzero(np.ediff1d(np.sign(twop_vsync_fall - stim_time[i]))>0) - crossings = np.searchsorted(twop_vsync_fall, stim_time[i], side='left') - 1 - if crossings < (len(twop_vsync_fall)-1): - twop_frames[i] = crossings - else: - twop_frames[i:len(stim_time)] = np.NaN - warnings.warn( - 'Acquisition ends before stimulus.', RuntimeWarning - ) - break - - return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise - -def get_center_coordinates(data, idx): - -# center_idx = get_stimulus_index(data,'center') -# stim_definition = data['stimuli'][center_idx]['stim'] - stim_definition = data['stimuli'][idx]['stim'] - - position_idx = stim_definition.find('pos=array(') - coor_start = position_idx + stim_definition[position_idx:].find('[') + 1 - coor_end = position_idx + stim_definition[position_idx:].find(']') - comma_idx = position_idx + stim_definition[position_idx:].find(',') - - x_coor = float(stim_definition[coor_start:comma_idx]) - y_coor = float(stim_definition[(comma_idx+1):coor_end]) - - return x_coor, y_coor - - -def print_summary(stim_table): - """Print summary of generated stim_table. - - Print column names, number of 'unique' conditions per column (treating - nans as equal), and average number of samples per condition. - """ - print( - '{:<20}{:>15}{:>15}\n'.format('Colname', 'No. conditions', 'Mean N/cond') - ) - for colname in stim_table.columns: - conditions, occurrences = np.unique( - np.nan_to_num(stim_table[colname]), return_counts = True - ) - print( - '{:<20}{:>15}{:>15.1f}'.format( - colname, len(conditions), np.mean(occurrences) - ) - ) - - -if __name__ == '__main__': -# exptpath = r'\\allen\programs\braintv\production\neuralcoding\prod55\specimen_859061987\ophys_session_882666374\\' - exptpath = r'/Volumes/New Volume/994901365' - stim_table = create_stim_tables(exptpath) -# stim_table = lsnCS_create_stim_table(exptpath) diff --git a/oscopetools/stim_table.py b/oscopetools/stim_table.py index fb79ac9..c80e71e 100644 --- a/oscopetools/stim_table.py +++ b/oscopetools/stim_table.py @@ -183,6 +183,10 @@ def DGsize_table(data, twop_frames, verbose=True): data, DGs_idx, attribute )[: len(stim_table)] + x_corr, y_corr = get_center_coordinates(data, DGs_idx) + stim_table['Center_x'] = x_corr + stim_table['Center_y'] = y_corr + return stim_table @@ -244,6 +248,10 @@ def center_surround_table(data, twop_frames, verbose=True): columns=('Start', 'End'), ) + x_corr, y_corr = get_center_coordinates(data, center_idx) + stim_table['Center_x'] = x_corr + stim_table['Center_y'] = y_corr + # TODO: make this take either center or surround SF and TF depending on which is not NaN for attribute in ['TF', 'SF', 'Contrast']: stim_table[attribute] = get_attribute_by_sweep( @@ -338,9 +346,14 @@ def get_attribute_by_sweep(data, stimulus_idx, attribute): sweeps_with_condition = np.argwhere(sweep_order == condition)[:, 0] if condition > 0: # blank sweep is -1 - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][ - attribute_idx - ] + try: + attribute_by_sweep[sweeps_with_condition] = sweep_table[ + condition + ][attribute_idx] + except: + attribute_by_sweep[sweeps_with_condition] = sweep_table[ + condition + ][attribute_idx][0] return attribute_by_sweep From 0520bf2865c4b9697086094e726d6280167635ef Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 19:55:03 -0400 Subject: [PATCH 55/68] Remove duplicate RunningData.py analysis/RunningData.py and oscopetools/RunningData.py are functionally identical as of 5d124efa4045467515d7db988cc030a2e732ad28. The only difference between them is the syntax used to import oscopetools/stim_table.py: from oscopetools.stim_table import xyz # analysis/RunningData.py from .stim_table import xyz # oscopetools/RunningData.py This commit removes the copy from the analysis directory and adjusts imports accordingly. --- analysis/RunningData.py | 49 ---------------------------------------- analysis/get_all_data.py | 2 +- 2 files changed, 1 insertion(+), 50 deletions(-) delete mode 100644 analysis/RunningData.py diff --git a/analysis/RunningData.py b/analysis/RunningData.py deleted file mode 100644 index a7aff33..0000000 --- a/analysis/RunningData.py +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Sat Jun 6 20:29:20 2020 - -@author: saskiad -""" - -from oscopetools.stim_table import load_stim, load_alignment -import numpy as np - - -def get_running_data(expt_path): - '''gets running data from stimulus log and downsamples to match imaging''' - print("Getting running speed") - data = load_stim(expt_path) - dx = data['items']['foraging']['encoders'][0]['dx'] - vsync_intervals = data['intervalsms'] - while len(vsync_intervals) < len(dx): - vsync_intervals = np.insert(vsync_intervals, 0, vsync_intervals[0]) - vsync_intervals /= 1000 - if len(dx) == 0: - print("No running data") - dxcm = ( - (dx / 360) * 5.5036 * np.pi * 2 - ) / vsync_intervals # 6.5" wheel which mouse at 2/3 r - twop_frames = load_alignment(expt_path) - start = np.nanmin(twop_frames) - endframe = int(np.nanmax(twop_frames) + 1) - dxds = np.empty((endframe, 1)) - for i in range(endframe): - try: - temp = np.where(twop_frames == i)[0] - dxds[i] = np.mean(dxcm[temp[0] : temp[-1] + 1]) - if np.isinf(dxds[i]): - dxds[i] = 0 - except: - if i < start: - dxds[i] = np.NaN - else: - dxds[i] = dxds[i - 1] # corrects for dropped frames - - startdatetime = data['startdatetime'] - return dxds, startdatetime - - -if __name__ == '__main__': - exptpath = r'/Volumes/New Volume/988763069' - dxds, startdate = get_running_data(exptpath) diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index d4bc181..263efae 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -12,7 +12,7 @@ import h5py from PIL import Image from oscopetools.stim_table import create_stim_tables, get_center_coordinates -from RunningData import get_running_data +from oscopetools.RunningData import get_running_data from get_eye_tracking import align_eye_tracking def get_all_data(path_name, save_path, expt_name, row): From 6aaa1ebdd7ad286959f63470d40ae3907ad4c7ec Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 20:05:29 -0400 Subject: [PATCH 56/68] Remove duplicate get_eye_tracking.py analysis/get_eye_tracking.py and oscopetools/get_eye_tracking.py are completely identical as of 0520bf2865c4b9697086094e726d6280167635ef. Remove the copy from analysis and adjust imports accordingly. --- analysis/get_all_data.py | 2 +- analysis/get_eye_tracking.py | 54 ------------------------------------ 2 files changed, 1 insertion(+), 55 deletions(-) delete mode 100644 analysis/get_eye_tracking.py diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 263efae..21ea694 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -13,7 +13,7 @@ from PIL import Image from oscopetools.stim_table import create_stim_tables, get_center_coordinates from oscopetools.RunningData import get_running_data -from get_eye_tracking import align_eye_tracking +from oscopetools.get_eye_tracking import align_eye_tracking def get_all_data(path_name, save_path, expt_name, row): diff --git a/analysis/get_eye_tracking.py b/analysis/get_eye_tracking.py deleted file mode 100644 index 6da346f..0000000 --- a/analysis/get_eye_tracking.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Mon Jun 8 16:28:23 2020 - -@author: saskiad -""" -import pandas as pd -import numpy as np -import h5py - - -def align_eye_tracking(dlc_file, temporal_alignment_file): - pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas').values - eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas').values - pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') - - ##temporal alignment - f = h5py.File(temporal_alignment_file, 'r') - eye_frames = f['eye_tracking_alignment'][()] - f.close() - eye_frames = eye_frames.astype(int) - eye_frames = eye_frames[np.where(eye_frames > 0)] - - eye_area_sync = eye_area[eye_frames] - pupil_area_sync = pupil_area[eye_frames] - x_pos_sync = pos.x_pos_deg.values[eye_frames] - y_pos_sync = pos.y_pos_deg.values[eye_frames] - - ##correcting dropped camera frames - test = eye_frames[np.isfinite(eye_frames)] - test = test.astype(int) - temp2 = np.bincount(test) - dropped_camera_frames = np.where(temp2 > 2)[0] - for a in dropped_camera_frames: - null_2p_frames = np.where(eye_frames == a)[0] - eye_area_sync[null_2p_frames] = np.NaN - pupil_area_sync[null_2p_frames] = np.NaN - x_pos_sync[null_2p_frames] = np.NaN - y_pos_sync[null_2p_frames] = np.NaN - - eye_sync = pd.DataFrame( - data=np.vstack( - (eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync) - ).T, - columns=('eye_area', 'pupil_area', 'x_pos_deg', 'y_pos_deg'), - ) - return eye_sync - - -if __name__ == '__main__': - dlc_file = r'/Volumes/New Volume/1010368135/eye_tracking/1010368135_eyetracking_dlc_to_screen_mapping.h5' - temporal_alignment_file = r'/Volumes/New Volume/1010368135/ophys_experiment_1010535819/1010535819_time_synchronization.h5' - eye_sync = (dlc_file, temporal_alignment_file) From 05960f7d3dd7bf8ba9f9d92c07a39d1e22d84f2e Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 20:23:32 -0400 Subject: [PATCH 57/68] Remove commented duplicate of align_eye_tracking analysis/get_all_data.py:get_all_data() contains commented-out code that is virtually identical to oscopetools/get_eye_tracking.py:align_eye_tracking(). The only differences are that the `.values` attributes are missing in the following lines of commented-out code: pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas').values eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas').values Since this code already exists in oscopetools/get_eye_tracking.py, I don't see a reason to keep the commented out copy. This commit removes the commented-out code and makes no other changes. --- analysis/get_all_data.py | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-) diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 21ea694..a58f139 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -73,36 +73,7 @@ def get_all_data(path_name, save_path, expt_name, row): if f.endswith('time_synchronization.h5'): temporal_alignment_file = os.path.join(expt_path, f) eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) -# pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas') -# eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas') -# pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') -# -# ##temporal alignment -# f = h5py.File(temporal_alignment_file, 'r') -# eye_frames = f['eye_tracking_alignment'].value -# f.close() -# eye_frames = eye_frames.astype(int) -# eye_frames = eye_frames[np.where(eye_frames>0)] -# -# eye_area_sync = eye_area[eye_frames] -# pupil_area_sync = pupil_area[eye_frames] -# x_pos_sync = pos.x_pos_deg.values[eye_frames] -# y_pos_sync = pos.y_pos_deg.values[eye_frames] -# -# ##correcting dropped camera frames -# test = eye_frames[np.isfinite(eye_frames)] -# test = test.astype(int) -# temp2 = np.bincount(test) -# dropped_camera_frames = np.where(temp2>2)[0] -# for a in dropped_camera_frames: -# null_2p_frames = np.where(eye_frames==a)[0] -# eye_area_sync[null_2p_frames] = np.NaN -# pupil_area_sync[null_2p_frames] = np.NaN -# x_pos_sync[null_2p_frames] = np.NaN -# y_pos_sync[null_2p_frames] = np.NaN -# -# eye_sync = pd.DataFrame(data=np.vstack((eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync)).T, columns=('eye_area','pupil_area','x_pos_deg','y_pos_deg')) - + #max projection mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') mp = Image.open(mp_path) From d4702c4401fa72a3d8dba75ac91332ee65382769 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 20:46:20 -0400 Subject: [PATCH 58/68] Autoformat analysis/get_all_data.py Autoformatting using Black. See autoformat.sh in the project root for autoformatting settings. Changes are mainly wrapping long lines and making consistent spacing around function arguments and operators. This commit does not change the function of analysis/get_all_data.py in any way. --- analysis/get_all_data.py | 119 ++++++++++++++++++++------------------- 1 file changed, 60 insertions(+), 59 deletions(-) diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index a58f139..d576585 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -15,9 +15,10 @@ from oscopetools.RunningData import get_running_data from oscopetools.get_eye_tracking import align_eye_tracking + def get_all_data(path_name, save_path, expt_name, row): - - #get access to sub folders + + # get access to sub folders for f in os.listdir(path_name): if f.startswith('ophys_experiment'): expt_path = os.path.join(path_name, f) @@ -29,25 +30,25 @@ def get_all_data(path_name, save_path, expt_name, row): for f in os.listdir(proc_path): if f.startswith('ophys_cell_segmentation_run'): roi_path = os.path.join(proc_path, f) - - #ROI table + + # ROI table for fname in os.listdir(expt_path): if fname.endswith('output_cell_roi_creation.json'): - jsonpath= os.path.join(expt_path, fname) + jsonpath = os.path.join(expt_path, fname) with open(jsonpath, 'r') as f: jin = json.load(f) f.close() break - roi_locations = pd.DataFrame.from_dict(data = jin['rois'], orient='index') - roi_locations.drop(columns=['exclude_code','mask_page'], inplace=True) #removing columns I don't think we need - roi_locations.reset_index(inplace=True) - - session_id = int( - path_name.split('/')[-1] - ) + roi_locations = pd.DataFrame.from_dict(data=jin['rois'], orient='index') + roi_locations.drop( + columns=['exclude_code', 'mask_page'], inplace=True + ) # removing columns I don't think we need + roi_locations.reset_index(inplace=True) + + session_id = int(path_name.split('/')[-1]) roi_locations['session_id'] = session_id - - #dff traces + + # dff traces for f in os.listdir(expt_path): if f.endswith('_dff.h5'): dff_path = os.path.join(expt_path, f) @@ -55,58 +56,60 @@ def get_all_data(path_name, save_path, expt_name, row): dff = f['data'].value f.close() - #raw fluorescence & cell ids + # raw fluorescence & cell ids for f in os.listdir(proc_path): - if f.endswith('roi_traces.h5'): - traces_path = os.path.join(proc_path, f) - f = h5py.File(traces_path, 'r') - raw_traces = f['data'][()] - cell_ids = f['roi_names'][()].astype(str) - f.close() - roi_locations['cell_id'] = cell_ids - - #eyetracking + if f.endswith('roi_traces.h5'): + traces_path = os.path.join(proc_path, f) + f = h5py.File(traces_path, 'r') + raw_traces = f['data'][()] + cell_ids = f['roi_names'][()].astype(str) + f.close() + roi_locations['cell_id'] = cell_ids + + # eyetracking for fn in os.listdir(eye_path): if fn.endswith('mapping.h5'): dlc_file = os.path.join(eye_path, fn) for f in os.listdir(expt_path): if f.endswith('time_synchronization.h5'): - temporal_alignment_file = os.path.join(expt_path, f) + temporal_alignment_file = os.path.join(expt_path, f) eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) - #max projection + # max projection mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') mp = Image.open(mp_path) mp_array = np.array(mp) - #ROI masks outlines + # ROI masks outlines boundary_path = os.path.join(roi_path, 'maxInt_boundary.png') boundary = Image.open(boundary_path) boundary_array = np.array(boundary) - - #stimulus table - stim_table = create_stim_tables(path_name) #returns dictionary. Not sure how to save dictionary so pulling out each dataframe - #running speed + # stimulus table + stim_table = create_stim_tables( + path_name + ) # returns dictionary. Not sure how to save dictionary so pulling out each dataframe + + # running speed dxds, startdate = get_running_data(path_name) - #pad end with NaNs to match length of dff + # pad end with NaNs to match length of dff nframes = dff.shape[1] - dxds.shape[0] dx = np.append(dxds, np.repeat(np.NaN, nframes)) - - #remove traces with NaNs from dff, roi_table, and roi_masks + + # remove traces with NaNs from dff, roi_table, and roi_masks roi_locations['roi_mask_id'] = range(len(roi_locations)) - to_keep = np.where(np.isfinite(dff[:,0]))[0] - to_del = np.where(np.isnan(dff[:,0]))[0] - roi_locations['finite'] = np.isfinite(dff[:,0]) + to_keep = np.where(np.isfinite(dff[:, 0]))[0] + to_del = np.where(np.isnan(dff[:, 0]))[0] + roi_locations['finite'] = np.isfinite(dff[:, 0]) roi_trimmed = roi_locations[roi_locations.finite] roi_trimmed.reset_index(inplace=True) - - new_dff = dff[to_keep,:] - + + new_dff = dff[to_keep, :] + for i in to_del: - boundary_array[np.where(boundary_array==i)] = 0 - - #meta data + boundary_array[np.where(boundary_array == i)] = 0 + + # meta data meta_data = {} meta_data['mouse_id'] = row.Mouse_ID meta_data['area'] = row.Area @@ -115,16 +118,18 @@ def get_all_data(path_name, save_path, expt_name, row): meta_data['container_ID'] = row.Container_ID meta_data['session_ID'] = session_id meta_data['startdate'] = startdate - - #Save Data - save_file = os.path.join(save_path, expt_name+'_'+str(session_id)+'_data.h5') + + # Save Data + save_file = os.path.join( + save_path, expt_name + '_' + str(session_id) + '_data.h5' + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['roi_table'] = roi_trimmed for key in stim_table.keys(): store[key] = stim_table[key] store['eye_tracking'] = eye_sync - + store.close() f = h5py.File(save_file, 'r+') dset = f.create_dataset('dff_traces', data=new_dff) @@ -134,16 +139,18 @@ def get_all_data(path_name, save_path, expt_name, row): dset4 = f.create_dataset('roi_outlines', data=boundary_array) dset5 = f.create_dataset('running_speed', data=dx) dset6 = f.create_dataset('meta_data', data=str(meta_data)) - f.close() + f.close() return -if __name__=='__main__': - manifest = pd.read_csv(r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset/data manifest.csv') +if __name__ == '__main__': + manifest = pd.read_csv( + r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset/data manifest.csv' + ) save_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim' - soma = manifest[manifest.Target=='soma'] + soma = manifest[manifest.Target == 'soma'] for index, row in soma.iterrows(): - if np.mod(index, 10)==0: + if np.mod(index, 10) == 0: print(index) expt_id = row.Center_Surround_Expt_ID if np.isfinite(expt_id): @@ -160,16 +167,10 @@ def get_all_data(path_name, save_path, expt_name, row): expt_name = 'Size_Tuning' path_name = os.path.join(r'/Volumes/New Volume', str(int(expt_id))) get_all_data(path_name, save_path, expt_name, row) -# +# # row = manifest.loc[27] # expt_id = row.Center_Surround_Expt_ID # path_name = os.path.join(r'/Volumes/New Volume', str(int(expt_id)))#975348996' # expt_name = 'Multiplex' # save_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim' # get_all_data(path_name, save_path, expt_name, row) - - - - - - From 01c1703f380455926f68aa338c594df7011f7580 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 20:51:07 -0400 Subject: [PATCH 59/68] Clean up oscopetools/get_all_data.py to prepare for removal oscopetools/get_all_data.py will be superseded by analysis/get_all_data.py, but we need to make sure oscopetools/get_all_data.py doesn't have any important changes before it is removed (ideally, in the next commit). This commit incorporates three features of analysis/get_all_data.py into oscopetools/get_all_data.py so that diffs of these two files will be easier to read. 1. Remove code to load ellipse.h5, which is never used. 2. Remove code for aligning eye tracking and use the basically-identical align_eye_tracking() instead. 3. Change `for key in list(stim_table.keys())` -> `for key in stim_table.keys()` --- oscopetools/get_all_data.py | 40 ++----------------------------------- 1 file changed, 2 insertions(+), 38 deletions(-) diff --git a/oscopetools/get_all_data.py b/oscopetools/get_all_data.py index eb1fcbd..8d7727f 100644 --- a/oscopetools/get_all_data.py +++ b/oscopetools/get_all_data.py @@ -66,49 +66,13 @@ def get_all_data(path_name, save_path, expt_name, row): roi_locations['cell_id'] = cell_ids # eyetracking - eye_data = pd.DataFrame() for fn in os.listdir(eye_path): - if fn.endswith('ellipse.h5'): - eye_file = os.path.join(eye_path, fn) if fn.endswith('mapping.h5'): dlc_file = os.path.join(eye_path, fn) - pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas') - eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas') - pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') - - ##temporal alignment for f in os.listdir(expt_path): if f.endswith('time_synchronization.h5'): temporal_alignment_file = os.path.join(expt_path, f) - f = h5py.File(temporal_alignment_file, 'r') - eye_frames = f['eye_tracking_alignment'].value - f.close() - eye_frames = eye_frames.astype(int) - eye_frames = eye_frames[np.where(eye_frames > 0)] - - eye_area_sync = eye_area[eye_frames] - pupil_area_sync = pupil_area[eye_frames] - x_pos_sync = pos.x_pos_deg.values[eye_frames] - y_pos_sync = pos.y_pos_deg.values[eye_frames] - - ##correcting dropped camera frames - test = eye_frames[np.isfinite(eye_frames)] - test = test.astype(int) - temp2 = np.bincount(test) - dropped_camera_frames = np.where(temp2 > 2)[0] - for a in dropped_camera_frames: - null_2p_frames = np.where(eye_frames == a)[0] - eye_area_sync[null_2p_frames] = np.NaN - pupil_area_sync[null_2p_frames] = np.NaN - x_pos_sync[null_2p_frames] = np.NaN - y_pos_sync[null_2p_frames] = np.NaN - - eye_sync = pd.DataFrame( - data=np.vstack( - (eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync) - ).T, - columns=('eye_area', 'pupil_area', 'x_pos_deg', 'y_pos_deg'), - ) + eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) # max projection mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') @@ -148,7 +112,7 @@ def get_all_data(path_name, save_path, expt_name, row): print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['roi_table'] = roi_locations - for key in list(stim_table.keys()): + for key in stim_table.keys(): store[key] = stim_table[key] store['eye_tracking'] = eye_sync From 1bd20d8505c7e43021043d80e2cad4e1f8c16a89 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 19 May 2021 21:01:16 -0400 Subject: [PATCH 60/68] Remove oscopetools/get_all_data.py oscopetools/get_all_data.py is out of date compared with analysis/get_all_data.py. I'm removing oscopetools/get_all_data.py and leaving the version in analysis because get_all_data.py will probably only ever be used as a script, so it doesn't make sense to include in the oscopetools package. Summary of differences between analysis and oscopetools versions ---------------------------------------------------------------- The version of get_all_data.py in oscopetools is missing code to drop ROIs with NaN values in the fluorescence trace. The two versions are otherwise almost identical apart from the code behind the `if __name__ == '__main__'` guard. This part of analysis/get_all_data.py actually contains all of the corresponding code from oscopetools/get_all_data.py in comments, so there's no reason to keep oscopetools/get_all_data.py around. --- oscopetools/get_all_data.py | 144 ------------------------------------ 1 file changed, 144 deletions(-) delete mode 100644 oscopetools/get_all_data.py diff --git a/oscopetools/get_all_data.py b/oscopetools/get_all_data.py deleted file mode 100644 index 8d7727f..0000000 --- a/oscopetools/get_all_data.py +++ /dev/null @@ -1,144 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Mon Mar 09 20:46:47 2020 - -@author: saskiad -""" - -import os -import numpy as np -import pandas as pd -import json -import h5py -from PIL import Image -from .stim_table import create_stim_tables, get_center_coordinates -from .RunningData import get_running_data - - -def get_all_data(path_name, save_path, expt_name, row): - - # get access to sub folders - for f in os.listdir(path_name): - if f.startswith('ophys_experiment'): - expt_path = os.path.join(path_name, f) - elif f.startswith('eye_tracking'): - eye_path = os.path.join(path_name, f) - for f in os.listdir(expt_path): - if f.startswith('processed'): - proc_path = os.path.join(expt_path, f) - for f in os.listdir(proc_path): - if f.startswith('ophys_cell_segmentation_run'): - roi_path = os.path.join(proc_path, f) - - # ROI table - for fname in os.listdir(expt_path): - if fname.endswith('output_cell_roi_creation.json'): - jsonpath = os.path.join(expt_path, fname) - with open(jsonpath, 'r') as f: - jin = json.load(f) - f.close() - break - roi_locations = pd.DataFrame.from_dict(data=jin['rois'], orient='index') - roi_locations.drop( - columns=['exclude_code', 'mask_page'], inplace=True - ) # removing columns I don't think we need - roi_locations.reset_index(inplace=True) - - session_id = int(path_name.split('/')[-1]) - roi_locations['session_id'] = session_id - - # dff traces - for f in os.listdir(expt_path): - if f.endswith('_dff.h5'): - dff_path = os.path.join(expt_path, f) - f = h5py.File(dff_path, 'r') - dff = f['data'].value - f.close() - - # raw fluorescence & cell ids - for f in os.listdir(proc_path): - if f.endswith('roi_traces.h5'): - traces_path = os.path.join(proc_path, f) - f = h5py.File(traces_path, 'r') - raw_traces = f['data'][()] - cell_ids = f['roi_names'][()].astype(str) - f.close() - roi_locations['cell_id'] = cell_ids - - # eyetracking - for fn in os.listdir(eye_path): - if fn.endswith('mapping.h5'): - dlc_file = os.path.join(eye_path, fn) - for f in os.listdir(expt_path): - if f.endswith('time_synchronization.h5'): - temporal_alignment_file = os.path.join(expt_path, f) - eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) - - # max projection - mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') - mp = Image.open(mp_path) - mp_array = np.array(mp) - - # ROI masks outlines - boundary_path = os.path.join(roi_path, 'maxInt_boundary.png') - boundary = Image.open(boundary_path) - boundary_array = np.array(boundary) - - # stimulus table - stim_table = create_stim_tables( - path_name - ) # returns dictionary. Not sure how to save dictionary so pulling out each dataframe - - # running speed - dxds, startdate = get_running_data(path_name) - # pad end with NaNs to match length of dff - nframes = dff.shape[1] - dxds.shape[0] - dx = np.append(dxds, np.repeat(np.NaN, nframes)) - - # meta data - meta_data = {} - meta_data['mouse_id'] = row.Mouse_ID - meta_data['area'] = row.Area - meta_data['imaging_depth'] = row.Depth - meta_data['cre'] = row.Cre - meta_data['container_ID'] = row.Container_ID - meta_data['session_ID'] = session_id - meta_data['startdate'] = startdate - - # Save Data - save_file = os.path.join( - save_path, expt_name + '_' + str(session_id) + '_data.h5' - ) - print("Saving data to: ", save_file) - store = pd.HDFStore(save_file) - store['roi_table'] = roi_locations - for key in stim_table.keys(): - store[key] = stim_table[key] - store['eye_tracking'] = eye_sync - - store.close() - f = h5py.File(save_file, 'r+') - dset = f.create_dataset('dff_traces', data=dff) - dset1 = f.create_dataset('raw_traces', data=raw_traces) - dset2 = f.create_dataset('cell_ids', data=cell_ids) - dset3 = f.create_dataset('max_projection', data=mp_array) - dset4 = f.create_dataset('roi_outlines', data=boundary_array) - dset5 = f.create_dataset('running_speed', data=dx) - dset6 = f.create_dataset('meta_data', data=str(meta_data)) - f.close() - - return - - -if __name__ == '__main__': - manifest = pd.read_csv( - r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset/data manifest.csv' - ) - row = manifest.loc[27] - expt_id = row.Size_Tuning_Expt_ID - path_name = os.path.join( - r'/Volumes/New Volume', str(int(expt_id)) - ) # 975348996' - expt_name = 'Multiplex' - save_path = r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset' - get_all_data(path_name, save_path, expt_name, row) From 446cfcc106544964d41f1730241d1cd1fb8da98d Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Tue, 25 May 2021 14:34:51 -0400 Subject: [PATCH 61/68] Remove get_all_data import in oscopetools/__init__.py --- oscopetools/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/oscopetools/__init__.py b/oscopetools/__init__.py index cd1650d..e2e72c0 100644 --- a/oscopetools/__init__.py +++ b/oscopetools/__init__.py @@ -1,6 +1,5 @@ from . import chi_square_lsn from . import chisq_categorical -from . import get_all_data from . import read_data from . import locally_sparse_noise from . import nd2_zstack From b641ee640e08c034b77d842094d29b473301f5cf Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 13:21:00 -0400 Subject: [PATCH 62/68] Add Saskia's WIP from 2021-06-03 This commit captures the state of Saskia's working directory as sent to me over Slack on June 3, 2021. Note that the following files are broken due to unresolved merge conflicts: analysis/example_code/locally_sparse_noise_events.py oscopetools/locally_sparse_noise.py The following files are broken due to Python 2 print statements: analysis/stim_table.py analysis/locally_sparse_noise.py analysis/DGgrid_analysis_5x5_nikon_SdV.py oscopetools/locally_sparse_noise.py --- .../Untitled-checkpoint.ipynb | 6 + .../plotting_size_tuning-checkpoint.ipynb | 233 +++++++++ analysis/DGgrid_analysis_5x5_nikon_SdV.py | 475 ++++++++++++++++++ analysis/Untitled.ipynb | 6 + analysis/center_surround.py | 358 +++++++++++++ .../locally_sparse_noise_events.py | 31 +- analysis/locally_sparse_noise.py | 174 +++++++ analysis/plotting_size_tuning.ipynb | 449 +++++++++++++++++ analysis/size_tuning.py | 3 +- analysis/stim_table.py | 2 +- analysis/sync/dataset.py | 408 +++++++++++++++ analysis/sync/gui/__init__.py | 0 analysis/sync/gui/res/record.png | Bin 0 -> 142112 bytes analysis/sync/gui/res/stop.png | Bin 0 -> 29169 bytes analysis/sync/gui/sync_gui.py | 297 +++++++++++ analysis/sync/gui/sync_gui.ui | 267 ++++++++++ analysis/sync/gui/sync_gui_layout.py | 173 +++++++ analysis/sync/scripts/analysis_example.py | 24 + analysis/sync/scripts/sample_signal.py | 32 ++ analysis/sync/scripts/sample_signal_fast.py | 19 + analysis/sync/sync.py | 446 ++++++++++++++++ analysis/sync/tango/sync_device.py | 239 +++++++++ analysis/test.py | 13 + oscopetools/locally_sparse_noise.py | 145 +++++- oscopetools/sync/gui/__init__.py | 0 25 files changed, 3791 insertions(+), 9 deletions(-) create mode 100644 analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb create mode 100644 analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb create mode 100644 analysis/DGgrid_analysis_5x5_nikon_SdV.py create mode 100644 analysis/Untitled.ipynb create mode 100644 analysis/center_surround.py create mode 100644 analysis/locally_sparse_noise.py create mode 100644 analysis/plotting_size_tuning.ipynb create mode 100755 analysis/sync/dataset.py create mode 100644 analysis/sync/gui/__init__.py create mode 100755 analysis/sync/gui/res/record.png create mode 100755 analysis/sync/gui/res/stop.png create mode 100755 analysis/sync/gui/sync_gui.py create mode 100755 analysis/sync/gui/sync_gui.ui create mode 100755 analysis/sync/gui/sync_gui_layout.py create mode 100755 analysis/sync/scripts/analysis_example.py create mode 100755 analysis/sync/scripts/sample_signal.py create mode 100755 analysis/sync/scripts/sample_signal_fast.py create mode 100755 analysis/sync/sync.py create mode 100755 analysis/sync/tango/sync_device.py create mode 100644 analysis/test.py mode change 100755 => 100644 oscopetools/sync/gui/__init__.py diff --git a/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb b/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb new file mode 100644 index 0000000..cd71389 --- /dev/null +++ b/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import os\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "metrics = pd.read_csv(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf/size_metrics_all.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "analysis_file_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "session_id = 976843461" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "analysis_file = os.path.join(analysis_file_path, str(session_id)+'_st_analysis.h5')\n", + "expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(session_id)+'_data.h5'" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "f = h5py.File(analysis_file, 'r')\n", + "response = f['response'][()]\n", + "f.close()\n", + "sweep_response = pd.read_hdf(analysis_file, 'sweep_response')\n", + "stim_table = pd.read_hdf(expt_path, 'drifting_gratings_size')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(8, 2, 6, 112, 4)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "response.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(response[:,0,:,1,0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "valid = metrics_rf#[metrics_rf.valid]\n", + "for index, row in valid.iterrows():\n", + " cell_id = row.cell_id\n", + " session_id = row.session_id\n", + " cell_index = row.cell_index\n", + " pref_ori = orivals[int(row.center_dir)]\n", + " \n", + " analysis_file = os.path.join(analysis_file_path, str(session_id)+'_st_analysis.h5')\n", + " expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(session_id)+'_data.h5'\n", + " \n", + " f = h5py.File(analysis_file, 'r')\n", + " response = f['response'][()]\n", + " f.close()\n", + " sweep_response = pd.read_hdf(analysis_file, 'sweep_response')\n", + " stim_table = pd.read_hdf(expt_path, 'drifting_gratings_size')\n", + " \n", + "\n", + " f = h5py.File(expt_path, 'r')\n", + " mp = f['max_projection'][()]\n", + " rois = f['roi_outlines'][()]\n", + " f.close()\n", + " rois = rois.astype(float)\n", + " rois[rois==0] = np.NaN\n", + " roi_table = pd.read_hdf(expt_path, 'roi_table')\n", + " \n", + " plt.figure(figsize=(25,15))\n", + "\n", + " ax1 = plt.subplot2grid((3,3),(0,0))\n", + " ax2 = plt.subplot2grid((3,3),(1,0))\n", + " ax3 = plt.subplot2grid((3,3),(0,1), rowspan=2)\n", + " ax6 = plt.subplot2grid((3,3),(0,2), rowspan=2)\n", + " ax4 = plt.subplot2grid((3,3), (2,0))\n", + " ax5 = plt.subplot2grid((3,3), (2,1))\n", + " ax7 = plt.subplot2grid((3,3),(2,2))\n", + " \n", + " #Tuning curve\n", + " ax1.errorbar(range(0,360,45),response[:,0,cell_index,0], yerr=response[:,0,cell_index,1]/np.sqrt(response[:,0,cell_index,2]), fmt='o-', color='k', label='center')\n", + " ax1.errorbar(range(0,360,45),response[:,1,cell_index,0], yerr=response[:,1,cell_index,1]/np.sqrt(response[:,1,cell_index,2]), fmt='o-', color='r', label='iso')\n", + " ax1.errorbar(range(0,360,45),response[:,2,cell_index,0], yerr=response[:,2,cell_index,1]/np.sqrt(response[:,2,cell_index,2]), fmt='o-', color='b', label='ortho')\n", + " ax1.set_xticks(range(0,360,45));\n", + " ax1.set_xlabel(\"Direction (deg)\", fontsize=16)\n", + " ax1.set_ylabel(\"DF/F\", fontsize=16)\n", + " ax2.set_title(str(pref_tf)+\" Hz\", fontsize=16)\n", + "\n", + " ax1.axhline(y=response[0,3,cell_index,0], ls='--', color='gray')\n", + " ax1.legend()\n", + " sns.despine()\n", + "\n", + " #Preferred direction\n", + " ax2.plot(sweep_response[(stim_table.condition=='center')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='k')\n", + " ax2.plot(sweep_response[(stim_table.condition=='ortho')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='b')\n", + " ax2.plot(sweep_response[(stim_table.condition=='iso')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='r')\n", + " ax2.plot(sweep_response[(stim_table.condition=='blank')][str(cell_index)].mean(), color='gray')\n", + " # ax2.plot(sweep_response[(stim_table.condition=='surround')&(stim_table.Surround_Ori==90)][str(cell_index)].mean(), color='purple')\n", + " ax2.axvspan(30,90, color='gray', alpha=0.1)\n", + " ax2.set_xticks([30,60,90,120],[0,1,2,3])\n", + " ax2.set_xlabel(\"Time (s)\", fontsize=18)\n", + " ax2.set_ylabel(\"DFF\", fontsize=18)\n", + " ax2.set_title(str(pref_ori)+\" Deg\"+\" \"+str(pref_tf)+\" Hz\", fontsize=16)\n", + "\n", + " sns.despine()\n", + "\n", + " \n", + " #ROI mask\n", + " plt.imshow(mp, cmap='gray')\n", + " plt.imshow(rois, cmap='Reds')\n", + " plt.plot(roi_table.x[cell_index], roi_table.y[cell_index], 'yo')\n", + " plt.xlim(roi_table.x[cell_index]-100, roi_table.x[cell_index]+100)\n", + " plt.ylim(roi_table.y[cell_index]+100, roi_table.y[cell_index]-100)\n", + " \n", + " plt.suptitle(\"Session: \"+str(expt_id)+\" Cell: \"+str(cell_id), fontsize=18)\n", + " plt.tight_layout()\n", + " plt.savefig(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/ST_figures/'+str(cell_id)+'.png')\n", + " plt.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/DGgrid_analysis_5x5_nikon_SdV.py b/analysis/DGgrid_analysis_5x5_nikon_SdV.py new file mode 100644 index 0000000..1e7b79d --- /dev/null +++ b/analysis/DGgrid_analysis_5x5_nikon_SdV.py @@ -0,0 +1,475 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jul 28 14:06:37 2016 + +@author: danielm +""" +import os, sys + +import numpy as np +import pandas as pd +import h5py + +import cPickle as pickle +from sync import Dataset +import tifffile as tiff +import matplotlib.pyplot as plt + +import nd2reader + +def run_analysis(): + + exp_date = '20190605' + mouse_ID = '462046' + im_filetype = 'nd2'#'h5' + + + #DON'T MODIFY CODE BELOW THIS POINT!!!!!!!! + + exp_superpath = r'C:\\CAM\\data\\' + im_superpath = r'E:\\' + exptpath = find_exptpath(exp_superpath,exp_date,mouse_ID) + im_directory = find_impath(im_superpath,exp_date,mouse_ID) + savepath = r'\\allen\\programs\\braintv\\workgroups\\ophysdev\\OPhysCore\\OpenScope\\Multiplex\\coordinates\\' + + stim_table = create_stim_table(exptpath) + + fluorescence = get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath) + + mean_sweep_response, sweep_response = get_mean_sweep_response(fluorescence,stim_table) + + best_location = plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,savepath) + + write_text_file(best_location,exp_date+'_'+mouse_ID,savepath) + +def find_exptpath(exp_superpath,exp_date,mouse_ID): + + exptpath = None + for f in os.listdir(exp_superpath): + if f.lower().find(mouse_ID+'_'+exp_date)!=-1: + exptpath = exp_superpath+f+'\\' + return exptpath + +def find_impath(im_superpath,exp_date,mouse_ID): + + im_path = None + for f in os.listdir(im_superpath): + if f.lower().find(exp_date+'_'+mouse_ID)!=-1: + im_path = im_superpath+f+'\\' + return im_path + +def write_text_file(best_location,save_name,savepath): + + f = open(savepath+save_name+'_coordinates.txt','w') + f.write(str(best_location[0])) + f.write(',') + f.write(str(best_location[1])) + f.close() + +def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): + + x_pos = np.unique(stim_table['PosX'].values) + x_pos = x_pos[np.argwhere(np.isfinite(x_pos))] + y_pos = np.unique(stim_table['PosY'].values) + y_pos = y_pos[np.argwhere(np.isfinite(y_pos))] + ori = np.unique(stim_table['Ori'].values) + ori = ori[np.argwhere(np.isfinite(ori))] + + num_x = len(x_pos) + num_y = len(y_pos) + num_sweeps = len(sweep_response) + + plt.figure(figsize=(20,20)) + ax = [] + for x in range(num_x): + for y in range(num_y): + ax.append(plt.subplot2grid((num_x,num_y), (x,y), colspan=1) ) + + ori_colors=['k','b','m','r','y','g'] + + #convert fluorescence to dff + baseline_frames = 28 + weighted_average = np.zeros((2,)) + summed_response = 0 + for i in range(num_sweeps): + baseline = np.mean(sweep_response[i,:baseline_frames]) + sweep_response[i,:] = sweep_response[i,:] - baseline + + y_max = np.max(sweep_response.flatten()) + y_min = np.min(sweep_response.flatten()) + + for x in range(len(x_pos)): + is_x = stim_table['PosX'] == x_pos[x][0] + for y in range(len(y_pos)): + is_y = stim_table['PosY'] == y_pos[y][0] + this_ax = ax[num_x*(num_y-1-y)+x] + position_average = np.zeros((np.shape(sweep_response)[1],)) + num_at_position = 0 + for o in range(len(ori)): + is_ori = stim_table['Ori'] == ori[o][0] + is_repeat = (is_x & is_y & is_ori).values + repetition_idx = np.argwhere(is_repeat) + if any(repetition_idx==0): + repetition_idx = repetition_idx[1:] + for rep in range(len(repetition_idx)): + this_response = sweep_response[repetition_idx[rep]] + this_response = this_response[0,:] + this_ax.plot(this_response,ori_colors[o]) + this_ax.set_ylim([y_min, y_max]) + num_at_position += 1 + position_average = np.add(position_average,this_response) + position_average = np.divide(position_average,num_at_position) + position_response = np.mean(position_average[(baseline_frames+5):(baseline_frames+27)]) + summed_response += np.max([0.0,position_response]) + weighted_average[0] += x_pos[x][0] * np.max([0.0,position_response]) + weighted_average[1] += y_pos[y][0] * np.max([0.0,position_response]) + this_ax.plot(position_average,linewidth=3.0,color='k') + this_ax.plot([baseline_frames, baseline_frames],[y_min,y_max],'k--') + this_ax.set_title('X: ' + str(x_pos[x][0]) + ', Y: ' + str(y_pos[y][0])) + plt.savefig(exptpath+exp_date+'_'+mouse_ID+'_DGgrid_traces.png',dpi=300) + plt.close() + + weighted_average = weighted_average / summed_response + + best_location = (round(weighted_average[0],1),round(weighted_average[1],1)) + + return best_location + + +def plot_grid_response(mean_sweep_response,stim_table,exptpath): + + x_pos = np.unique(stim_table['PosX'].values) + x_pos = x_pos[np.argwhere(np.isfinite(x_pos))] + y_pos = np.unique(stim_table['PosY'].values) + y_pos = y_pos[np.argwhere(np.isfinite(y_pos))] + ori = np.unique(stim_table['Ori'].values) + ori = ori[np.argwhere(np.isfinite(ori))] + + response_grid = np.zeros((len(y_pos),len(x_pos))) + for o in range(len(ori)): + is_ori = stim_table['Ori'] == ori[o][0] + ori_responses = np.zeros((len(y_pos),len(x_pos))) + for x in range(len(x_pos)): + is_x = stim_table['PosX'] == x_pos[x][0] + for y in range(len(y_pos)): + is_y = stim_table['PosY'] == y_pos[y][0] + is_repeat = (is_x & is_y & is_ori).values + repetition_idx = np.argwhere(is_repeat) + if any(repetition_idx==0): + repetition_idx = repetition_idx[1:] + repetition_responses = np.zeros((len(repetition_idx),)) + for rep in range(len(repetition_idx)): + repetition_responses[rep] = mean_sweep_response[repetition_idx[rep]] + ori_responses[y,x] = np.mean(repetition_responses) + ori_responses = np.subtract(ori_responses,np.mean(ori_responses.flatten())) + response_grid = np.add(response_grid,ori_responses) + + plt.figure() + plt.imshow(response_grid,vmax=np.max(response_grid),vmin=-np.max(response_grid),cmap=u'bwr',interpolation='none',origin='lower') + plt.colorbar() + plt.xlabel('X Pos') + plt.ylabel('Y Pos') + + x_tick_labels = range(len(x_pos)) + for i in range(len(x_pos)): + x_tick_labels[i] = str(x_pos[i][0]) + y_tick_labels = range(len(y_pos)) + for i in range(len(y_pos)): + y_tick_labels[i] = str(y_pos[i][0]) + plt.xticks(np.arange(len(x_pos)),x_tick_labels) + plt.yticks(np.arange(len(y_pos)),y_tick_labels) + + plt.savefig(exptpath+'/DGgrid_response') + +def get_mean_sweep_response(fluorescence,stim_table): + + sweeplength = int(stim_table.End[1] - stim_table.Start[1]) + interlength = 28 + extralength = 7 + + num_stim_presentations = len(stim_table['Start']) + mean_sweep_response = np.zeros((num_stim_presentations,)) + sweep_response = np.zeros((num_stim_presentations,sweeplength+interlength)) + for i in range(num_stim_presentations): + start = stim_table['Start'][i]-interlength + end = stim_table['Start'][i] + sweeplength + sweep_f = fluorescence[int(start):int(end)] + sweep_dff = 100*((sweep_f/np.mean(sweep_f[:interlength]))-1) + sweep_response[i,:] = sweep_f + mean_sweep_response[i] = np.mean(sweep_dff[interlength:(interlength+sweeplength)]) + + return mean_sweep_response, sweep_response + +def load_single_tif(file_path): + return tiff.imread(file_path) + +def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath): + + if os.path.isfile(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy'): + avg_fluorescence = np.load(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy') + else: + + im_path = None + if im_filetype=='nd2': + for f in os.listdir(im_directory): + if f.endswith(im_filetype) and f.lower().find('local') == -1: + im_path = im_directory + f + print im_path + elif im_filetype=='h5': + #find experiment directory: + for f in os.listdir(im_directory): + if f.lower().find('ophys_experiment_')!=-1: + exp_path = im_directory+f+'\\' + session_ID = f[17:] + print session_ID + else: + print 'im_filetype not recognized!' + sys.exit(1) + + if im_filetype=='nd2': + print 'Reading nd2...' + read_obj = nd2reader.Nd2(im_path) + num_frames = len(read_obj.frames) + avg_fluorescence = np.zeros((num_frames,)) + + sweep_starts = stim_table['Start'].values + block_bounds = [] + block_bounds.append((np.min(sweep_starts)-30,np.max(sweep_starts[sweep_starts<50000])+100)) + block_bounds.append((np.min(sweep_starts[sweep_starts>50000])-30,np.max(sweep_starts)+100)) + + for block in block_bounds: + frame_start = int(block[0]) + frame_end = int(block[1]) + for f in np.arange(frame_start,frame_end): + this_frame = read_obj.get_image(f,0,read_obj.channels[0],0) + print 'Loaded frame ' + str(f) + ' of ' + str(num_frames) + avg_fluorescence[f] = np.mean(this_frame) + elif im_filetype=='h5': + f = h5py.File(exp_path+session_ID+'.h5') + data = np.array(f['data']) + avg_fluorescence = np.mean(data,axis=(1,2)) + f.close() + np.save(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy',avg_fluorescence) + + return avg_fluorescence + +def create_stim_table(exptpath): + + #load stimulus and sync data + data = load_pkl(exptpath) + twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise = load_sync(exptpath) + + display_sequence = data['stimuli'][0]['display_sequence'] + display_sequence += data['pre_blank_sec'] + display_sequence *= int(data['fps']) #in stimulus frames + + sweep_frames = data['stimuli'][0]['sweep_frames'] + stimulus_table = pd.DataFrame(sweep_frames,columns=('start','end')) + stimulus_table['dif'] = stimulus_table['end']-stimulus_table['start'] + stimulus_table.start += display_sequence[0,0] + for seg in range(len(display_sequence)-1): + for index, row in stimulus_table.iterrows(): + if row.start >= display_sequence[seg,1]: + stimulus_table.start[index] = stimulus_table.start[index] - display_sequence[seg,1] + display_sequence[seg+1,0] + stimulus_table.end = stimulus_table.start+stimulus_table.dif + print len(stimulus_table) + stimulus_table = stimulus_table[stimulus_table.end <= display_sequence[-1,1]] + stimulus_table = stimulus_table[stimulus_table.start <= display_sequence[-1,1]] + print len(stimulus_table) + sync_table = pd.DataFrame(np.column_stack((twop_frames[stimulus_table['start']],twop_frames[stimulus_table['end']])), columns=('Start', 'End')) + + #populate stimulus parameters + print data['stimuli'][0]['stim_path'] + + #get center parameters + sweep_order = data['stimuli'][0]['sweep_order'] + sweep_order = sweep_order[:len(stimulus_table)] + sweep_table = data['stimuli'][0]['sweep_table'] + dimnames = data['stimuli'][0]['dimnames'] + sweep_table = pd.DataFrame(sweep_table, columns=dimnames) + + #populate sync_table + sync_table['SF'] = np.NaN + sync_table['TF'] = np.NaN + sync_table['Contrast'] = np.NaN + sync_table['Ori'] = np.NaN + sync_table['PosX'] = np.NaN + sync_table['PosY'] = np.NaN + for index in np.arange(len(stimulus_table)): + if (not np.isnan(stimulus_table['end'][index])) & (sweep_order[index] >= 0): + sync_table['SF'][index] = sweep_table['SF'][int(sweep_order[index])] + sync_table['TF'][index] = sweep_table['TF'][int(sweep_order[index])] + sync_table['Contrast'][index] = sweep_table['Contrast'][int(sweep_order[index])] + sync_table['Ori'][index] = sweep_table['Ori'][int(sweep_order[index])] + sync_table['PosX'][index] = sweep_table['PosX'][int(sweep_order[index])] + sync_table['PosY'][index] = sweep_table['PosY'][int(sweep_order[index])] + + return sync_table + +def load_sync(exptpath): + + #verify that sync file exists in exptpath + syncMissing = True + for f in os.listdir(exptpath): + if f.endswith('_sync.h5'): + syncpath = os.path.join(exptpath, f) + syncMissing = False + print "Sync file:", f + if syncMissing: + print "No sync file" + sys.exit() + + #load the sync data from .h5 and .pkl files + d = Dataset(syncpath) + print d.line_labels + #set the appropriate sample frequency + sample_freq = d.meta_data['ni_daq']['counter_output_freq'] + + #get sync timing for each channel + twop_vsync_fall = d.get_falling_edges('2p_vsync')/sample_freq + #stim_vsync_fall = d.get_falling_edges('vsync_stim')[1:]/sample_freq #eliminating the DAQ pulse + stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse + photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq + + print 'num stim vsyncs: ' + str(len(stim_vsync_fall)) + print 'num 2p frames: ' + str(len(twop_vsync_fall)) + print 'num photodiode flashes: ' + str(len(photodiode_rise)) + + #make sure all of the sync data are available + channels = {'twop_vsync_fall': twop_vsync_fall, 'stim_vsync_fall':stim_vsync_fall, 'photodiode_rise': photodiode_rise} + channel_test = [] + for i in channels: + channel_test.append(any(channels[i])) + if all(channel_test): + print "All channels present." + else: + print "Not all channels present. Sync test failed." + sys.exit() + + #test and correct for photodiode transition errors + ptd_rise_diff = np.ediff1d(photodiode_rise) + short = np.where(np.logical_and(ptd_rise_diff>0.1, ptd_rise_diff<0.3))[0] + medium = np.where(np.logical_and(ptd_rise_diff>0.5, ptd_rise_diff<1.5))[0] + + + #find three consecutive pulses at the start of session: + two_back_lag = photodiode_rise[2:20] - photodiode_rise[:18] + ptd_start = np.argmin(two_back_lag) + 3 + print 'ptd_start: ' + str(ptd_start) + + #ptd_start = 3 + #for i in medium: + # if set(range(i-2,i)) <= set(short): + # ptd_start = i+1 + ptd_end = np.where(photodiode_rise>stim_vsync_fall.max())[0][0] - 1 + + # plt.figure() + # plt.hist(ptd_rise_diff) + # plt.show() + + # plt.figure() + # plt.plot(stim_vsync_fall[:300]) + # plt.title('stim vsync start') + # plt.show() + + # plt.figure() + # plt.plot(photodiode_rise[:10]) + # plt.title('photodiode start') + # plt.show() + + # plt.figure() + # plt.plot(stim_vsync_fall[-300:]) + # plt.title('stim vsync end') + # plt.show() + + # plt.figure() + # plt.plot(photodiode_rise[-10:]) + # plt.title('photodiode end') + # plt.show() + + print 'ptd_start: ' + str(ptd_start) + if ptd_start > 3: + print "Photodiode events before stimulus start. Deleted." + +# ptd_errors = [] +# while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): +# error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end]<1.8)[0] + ptd_start +# #print "Photodiode error detected. Number of frames:", len(error_frames) +# photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) +# ptd_errors.append(photodiode_rise[error_frames[-1]]) +# ptd_end-=1 +# ptd_rise_diff = np.ediff1d(photodiode_rise) + + first_pulse = ptd_start + stim_on_photodiode_idx = 60+120*np.arange(0,ptd_end+1-ptd_start-1,1) + + #stim_vsync_fall = stim_vsync_fall[0] + np.arange(stim_on_photodiode_idx.max()+481) * 0.0166666 + +# stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] +# photodiode_on = photodiode_rise[first_pulse + np.arange(0,ptd_end+1-ptd_start-1,1)] +# +# plt.figure() +# plt.plot(stim_on_photodiode[:4]) +# plt.title('stim start') +# plt.show() +# +# plt.figure() +# plt.plot(photodiode_on[:4]) +# plt.title('photodiode start') +# plt.show() +# +# delay_rise = photodiode_on - stim_on_photodiode +# init_delay_period = delay_rise < 0.025 +# init_delay = np.mean(delay_rise[init_delay_period]) +# +# plt.figure() +# plt.plot(delay_rise[:10]) +# plt.title('delay rise') +# plt.show() + + delay = 0.0#init_delay + print "monitor delay: " , delay + + #adjust stimulus time with monitor delay + stim_time = stim_vsync_fall + delay + + #convert stimulus frames into twop frames + twop_frames = np.empty((len(stim_time),1)) + acquisition_ends_early = 0 + for i in range(len(stim_time)): + # crossings = np.nonzero(np.ediff1d(np.sign(twop_vsync_fall - stim_time[i]))>0) + crossings = np.searchsorted(twop_vsync_fall,stim_time[i],side='left') -1 + if crossings < (len(twop_vsync_fall)-1): + twop_frames[i] = crossings + else: + twop_frames[i:len(stim_time)]=np.NaN + acquisition_ends_early = 1 + break + + if acquisition_ends_early>0: + print "Acquisition ends before stimulus" + + return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise + +def load_pkl(exptpath): + + #verify that pkl file exists in exptpath + logMissing = True + for f in os.listdir(exptpath): + if f.endswith('.pkl'): + logpath = os.path.join(exptpath, f) + logMissing = False + print "Stimulus log:", f + if logMissing: + print "No pkl file" + sys.exit() + + #load data from pkl file + f = open(logpath, 'rb') + data = pickle.load(f) + f.close() + + return data + +if __name__=='__main__': + run_analysis() \ No newline at end of file diff --git a/analysis/Untitled.ipynb b/analysis/Untitled.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/analysis/Untitled.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/center_surround.py b/analysis/center_surround.py new file mode 100644 index 0000000..903b031 --- /dev/null +++ b/analysis/center_surround.py @@ -0,0 +1,358 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +""" +Created on Wed Aug 22 10:59:54 2018 + +@author: saskiad +""" + +import numpy as np +import pandas as pd +import os, h5py +import matplotlib.pyplot as plt + +def do_sweep_mean(x): + return x[30:90].mean() + +def do_sweep_mean_shifted(x): + return x[30:40].mean() + +def do_eye(x): + return x[30:35].mean() + +class CenterSurround: + def __init__(self, expt_path, eye_thresh, cre, area, depth): + + self.expt_path = expt_path + self.session_id = self.expt_path.split('/')[-1].split('_')[-2] + + self.eye_thresh = eye_thresh + self.cre = cre + self.area = area + self.depth = depth + + self.orivals = range(0,360,45) + self.tfvals = [1,2] + self.conditions = ['center','iso','ortho','blank'] + + #load dff traces + f = h5py.File(self.expt_path, 'r') + self.dff = f['dff_traces'][()] + f.close() + + #load raw traces + f = h5py.File(self.expt_path, 'r') + self.traces = f['raw_traces'][()] + f.close() + + self.numbercells = self.dff.shape[0] + + #load roi_table + self.roi = pd.read_hdf(self.expt_path, 'roi_table') + + + #get stimulus table for center surround + self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') + #add condition column + self.stim_table['condition'] = 'ortho' + self.stim_table.loc[self.stim_table.Center_Ori==self.stim_table.Surround_Ori, 'condition'] = 'iso' + self.stim_table.loc[np.isfinite(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'center' + self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'blank' + self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' + #get spontaneous window + self.stim_table_spont = self.get_spont_table() + + #load eyetracking + self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') + + #run analysis + self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() + +# self.first, self.second = self.cross_validate_response() + self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT = self.get_metrics() + + #save outputs +# self.save_data() + + #plot traces + + def get_spont_table(self): + '''finds the window of spotaneous activity during the session''' + stim_table_lsn = pd.read_hdf(self.expt_path, 'locally_sparse_noise') + stim_all = self.stim_table[['Start','End']] + stim_all = stim_all.append(stim_table_lsn[['Start','End']]) + stim_all.sort_values(by='Start', inplace=True) + stim_all.reset_index(inplace=True) + spont_start = np.where(np.ediff1d(stim_all.Start)>8000)[0][0] + stim_table_spont = pd.DataFrame(columns=('Start','End'), index=[0]) + stim_table_spont.Start = stim_all.End[spont_start]+1 + stim_table_spont.End = stim_all.Start[spont_start+1]-1 + return stim_table_spont + + def get_stimulus_response(self): + '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. + Only uses trials when the eye position is within eye_thresh degrees of the mean eye position. Default eye_thresh is 10. + +Returns +------- +sweep response: full trial for each trial +mean sweep response: mean response for each trial +sweep_eye: eye position across the full trial +mean_sweep_eye: mean of first three time points of eye position for each trial +response_mean: mean response for each stimulus condition +response_std: std of response to each stimulus condition + + + ''' + sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + + for index,row in self.stim_table.iterrows(): + for nc in range(self.numbercells): + #uses the global dff trace + sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] + + #computes DF/F using the mean of the inter-sweep gray for the Fo +# temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] +# sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-30:int(row.Start+90)].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-30:int(row.Start+90)].values + + mean_sweep_response = sweep_response.applymap(do_sweep_mean) + mean_sweep_eye = sweep_eye.applymap(do_eye) + mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) + + #make spontaneous p_values + shuffled_responses = np.empty((self.numbercells, 10000, 60)) +# idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) + idx = np.random.choice(range(int(self.stim_table_spont.Start), int(self.stim_table_spont.End)), 10000) + for i in range(60): + shuffled_responses[:,:,i] = self.dff[:,idx+i] + shuffled_mean = shuffled_responses.mean(axis=2) + sweep_p_values = pd.DataFrame(index = self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + for nc in range(self.numbercells): + subset = mean_sweep_response[str(nc)].values + null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) + actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat + p_values = np.mean(actual_is_less, axis=1) + sweep_p_values[str(nc)] = p_values + + #compute mean response across trials, only use trials within eye_thresh of mean eye position + response = np.empty((8,4,self.numbercells, 4)) #center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials + + for oi, cori in enumerate(self.orivals): + for ci, cond in enumerate(self.conditions): + if cond=='blank': + subset = mean_sweep_response[(self.stim_table.condition==cond)&(mean_sweep_eye.total0, tuning, 0) + CV_top_os = np.empty((8, tuning.shape[1]), dtype=np.complex128) + for i in range(8): + CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) + return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) + + + def get_metrics(self): + '''creates a table of metrics for each cell. We can make this more useful in the future + +Returns +------- +metrics dataframe + ''' + + n_iter = 50 + n_trials = int(self.response[:,:,:,2].min()) + print("Number of trials for cross-validation: " + str(n_trials)) +# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + cell_index = np.array(range(self.numbercells)) + response_first, response_second = self.cross_validate_response(n_iter, n_trials) + + metrics = pd.DataFrame(columns=('center_dir','center_osi','center_dsi','iso','ortho', + 'suppression_strength','suppression_tuning','cmi'), index=cell_index) + + #cross-validated metrics + DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + ISO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + ORTHO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + STRENGTH = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + + for ni in range(n_iter): + #find pref direction for each cell for center only condition + response_first = response_first[:,:,cell_index,:] + response_second = response_second[:,:,cell_index,:] + sort = np.where(response_first[:,0,:,ni]==np.nanmax(response_first[:,0,:,ni], axis=(0))) + sortind = np.argsort(sort[1]) + pref_ori = sort[0][sortind] + cell_index = sort[1][sortind] + inds = np.vstack((pref_ori, cell_index)) + + #osi + OSI.loc[ni] = self.get_osi(response_second[:, 0, inds[1], ni]) + + #dsi + null_ori= np.mod(pref_ori+4, 8) + pref = response_second[inds[0], 0, inds[1], ni] + null = response_second[null_ori, 0, inds[1], ni] + null = np.where(null>0, null, 0) + DSI.loc[ni] = (pref-null)/(pref+null) + + center = response_second[inds[0], 0, inds[1], ni] + iso = response_second[inds[0], 1, inds[1], ni] + ortho = response_second[inds[0], 2, inds[1], ni] + #suppression strength + STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center + + #suppression tuning + TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) + + #iso + ISO.loc[ni] = (center - iso) / (center + iso) + + #ortho + ORTHO.loc[ni] = (center - ortho) / (center + ortho) + + #context modulation index (Keller et al) + #TODO: right now we're using the center to identify the preferred direction. Might not be ideal + CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) + + metrics['center_osi'] = OSI.mean().values + metrics['center_dsi'] = DSI.mean().values + metrics['iso'] = ISO.mean().values + metrics['ortho'] = ORTHO.mean().values + metrics['suppression_strength'] = STRENGTH.mean().values + metrics['suppression_tuning'] = TUNING.mean().values + metrics['cmi'] = CONTEXT.mean().values + + #non cross-validated metrics +# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + cell_index = np.array(range(self.numbercells)) + sort = np.where(self.response[:,0,cell_index,0] == np.nanmax(self.response[:,0,cell_index,0], axis=0)) + sortind = np.argsort(sort[1]) + metrics['center_dir'] = sort[0][sortind] + metrics['center_mean'] = self.response[sort[0][sortind],0,cell_index,0] + metrics['center_std'] = self.response[sort[0][sortind],0,cell_index,1] + metrics['center_percent_trials'] = self.response[sort[0][sortind],0,cell_index,3] + metrics['blank_mean'] = self.response[0,3,cell_index,0] + metrics['blank_std'] = self.response[0,3,cell_index,1] + metrics['iso_mean'] = self.response[sort[0][sortind],1,cell_index,0] + metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] + metrics['ortho_mean'] = self.response[sort[0][sortind],2,cell_index,0] + metrics['ortho_std'] = self.response[sort[0][sortind],2,cell_index,1] + + metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) + metrics['cre'] = self.cre + metrics['area'] = self.area + metrics['depth'] = self.depth + + return metrics, OSI, DSI, ISO, ORTHO, STRENGTH, TUNING, CONTEXT + + def save_data(self): + '''saves intermediate analysis files in an h5 file''' + save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis_py3', str(self.session_id)+"_cs_analysis.h5") + print("Saving data to: ", save_file) + store = pd.HDFStore(save_file) + store['sweep_response'] = self.sweep_response + store['mean_sweep_response'] = self.mean_sweep_response + store['sweep_p_values'] = self.sweep_p_values + store['sweep_eye'] = self.sweep_eye + store['mean_sweep_eye'] = self.mean_sweep_eye + store['metrics'] = self.metrics + store.close() + f = h5py.File(save_file, 'r+') + dset = f.create_dataset('response', data=self.response) + f.close() + + +if __name__=='__main__': + expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_989418742_data.h5' + eye_thresh = 10 + cre = 'test' + area = 'area test' + depth = '33' + cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) + +# manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') +# subset = manifest[manifest.Target=='soma'] +# print(len(subset)) +# count = 0 +# failed = [] +# for index, row in subset.iterrows(): +# if np.isfinite(row.Center_Surround_Expt_ID): +# count+=1 +# cre = row.Cre +# area = row.Area +# depth = row.Depth +# expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' +# eye_thresh = 10 +# try: +# cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) +# if count==1: +# metrics_all = cs.metrics.copy() +# print("reached here") +# else: +# metrics_all = metrics_all.append(cs.metrics) +# except: +# print(expt_path + " FAILED") +# failed.append(int(row.Center_Surround_Expt_ID)) + + + \ No newline at end of file diff --git a/analysis/example_code/locally_sparse_noise_events.py b/analysis/example_code/locally_sparse_noise_events.py index fdcc35a..06affad 100644 --- a/analysis/example_code/locally_sparse_noise_events.py +++ b/analysis/example_code/locally_sparse_noise_events.py @@ -24,8 +24,9 @@ class LocallySparseNoise: def __init__(self, session_id): self.session_id = session_id - save_path_head = core.get_save_path() + save_path_head = #TODO self.save_path = os.path.join(save_path_head, 'LocallySparseNoise') +<<<<<<< Updated upstream self.l0_events = core.get_L0_events(self.session_id) self.stim_table_sp, _, _ = core.get_stim_table( self.session_id, 'spontaneous' @@ -81,6 +82,19 @@ def __init__(self, session_id): self.response_events_on_8deg, self.response_events_off_8deg, ) = self.get_stimulus_response(self.LSN_8deg) +======= + + f = h5py.File(dff_path, 'r') + self.dff = f['data'][()] + f.close() + + self.stim_table_sp, _, _ = core.get_stim_table(self.session_id, 'spontaneous') + + lsn_name = 'locally_sparse_noise' + self.stim_table, self.numbercells, self.specimen_ids = core.get_stim_table(self.session_id, lsn_name) + self.LSN = core.get_stimulus_template(self.session_id, lsn_name) + self.sweep_events, self.mean_sweep_events, self.sweep_p_values, self.running_speed, self.response_events_on, self.response_events_off = self.get_stimulus_response(self.LSN) +>>>>>>> Stashed changes self.peak = self.get_peak(lsn_name) self.save_data(lsn_name) @@ -98,6 +112,7 @@ def get_stimulus_response(self, LSN): ''' +<<<<<<< Updated upstream sweep_events = pd.DataFrame( index=self.stim_table.index.values, columns=np.array(list(range(self.numbercells))).astype(str), @@ -114,6 +129,14 @@ def get_stimulus_response(self, LSN): running_speed.running_speed[index] = self.dxcm[ int(row.start) : int(row.start) + 7 ].mean() +======= + sweep_events = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + + for index,row in self.stim_table.iterrows(): + for nc in range(self.numbercells): + sweep_events[str(nc)][index] = self.l0_events[nc, int(row.start)-28:int(row.start)+35] + +>>>>>>> Stashed changes mean_sweep_events = sweep_events.applymap(do_sweep_mean_shifted) @@ -284,4 +307,10 @@ def save_data(self, lsn_name): if __name__ == '__main__': session_id = 569611979 +<<<<<<< Updated upstream + lsn = LocallySparseNoise(session_id=session_id) +======= + + dff_path = r'/Volumes/My Passport/Openscope Multiplex/891653201/892006924_dff.h5 lsn = LocallySparseNoise(session_id=session_id) +>>>>>>> Stashed changes diff --git a/analysis/locally_sparse_noise.py b/analysis/locally_sparse_noise.py new file mode 100644 index 0000000..0fb97e0 --- /dev/null +++ b/analysis/locally_sparse_noise.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +""" +Created on Wed Aug 22 10:59:54 2018 + +@author: saskiad +""" + +import numpy as np +import pandas as pd +import os, h5py +import matplotlib.pyplot as plt + +def do_sweep_mean(x): + return x[28:35].mean() + +def do_sweep_mean_shifted(x): + return x[30:40].mean() + +def do_eye(x): + return x[28:32].mean() + +class LocallySparseNoise: + def __init__(self, expt_path): + + self.expt_path = expt_path + self.session_id = self.expt_path.split('/')[-1].split('_')[-2] + + #load dff traces + f = h5py.File(self.expt_path, 'r') + self.dff = f['dff_traces'][()] + f.close() + + self.numbercells = self.dff.shape[0] + + #create stimulus table for locally sparse noise + self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') + + #load stimulus template + self.LSN = np.load(lsn_path) + + #load eyetracking + self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') + + #run analysis + self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) + self.peak = self.get_peak() + + #save outputs +# self.save_data() + + #plot traces + self.plot_LSN_Traces() + + def get_stimulus_response(self, LSN): + '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. + +Returns +------- +sweep response: full trial for each trial +mean sweep response: mean response for each trial +sweep p values: p value of each trial compared measured relative to distribution of spontaneous activity +response_on: mean response, s.e.m., and number of responsive trials for each white square +response_off: mean response, s.e.m., and number of responsive trials for each black square + + + ''' + sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + + for index,row in self.stim_table.iterrows(): + for nc in range(self.numbercells): + sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-28:int(row.Start+35)].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-28:int(row.Start+35)].values + + mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) + mean_sweep_eye = sweep_eye.applymap(do_eye) + + + + x_shape = LSN.shape[1] + y_shape = LSN.shape[2] + response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) + response_off = np.empty((x_shape, y_shape, self.numbercells, 2)) + for xp in range(x_shape): + for yp in range(y_shape): + on_frame = np.where(LSN[:,xp,yp]==255)[0] + off_frame = np.where(LSN[:,xp,yp]==0)[0] + subset_on = mean_sweep_response[self.stim_table.Frame.isin(on_frame)] + subset_off = mean_sweep_response[self.stim_table.Frame.isin(off_frame)] + response_on[xp,yp,:,0] = subset_on.mean(axis=0) + response_on[xp,yp,:,1] = subset_on.std(axis=0)/np.sqrt(len(subset_on)) + response_off[xp,yp,:,0] = subset_off.mean(axis=0) + response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) + return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye + + def get_peak(self): + '''creates a table of metrics for each cell. We can make this more useful in the future + +Returns +------- +peak dataframe + ''' + peak = pd.DataFrame(columns=('rf_on','rf_off'), index=range(self.numbercells)) + peak['rf_on'] = False + peak['rf_off'] = False + on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] + off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] + peak.rf_on.loc[on_rfs] = True + peak.rf_off.loc[off_rfs] = True + return peak + + def save_data(self): + '''saves intermediate analysis files in an h5 file''' + save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") + print "Saving data to: ", save_file + store = pd.HDFStore(save_file) + store['sweep_response'] = self.sweep_response + store['mean_sweep_response'] = self.mean_sweep_response + store['sweep_p_values'] = self.sweep_p_values + store['peak'] = self.peak + store.close() + f = h5py.File(save_file, 'r+') + dset = f.create_dataset('response_on', data=self.response_on) + dset1 = f.create_dataset('response_off', data=self.response_off) + f.close() + + def plot_LSN_Traces(self): + '''plots ON and OFF traces for each position for each cell''' + print "Plotting LSN traces for all cells" + + for nc in range(self.numbercells): + if np.mod(nc,100)==0: + print "Cell #", str(nc) + plt.figure(nc, figsize=(24,20)) + vmax=0 + vmin=0 + one_cell = self.sweep_response[str(nc)] + for yp in range(8): + for xp in range(14): + sp_pt = (yp*14)+xp+1 + on_frame = np.where(self.LSN[:,yp,xp]==255)[0] + off_frame = np.where(self.LSN[:,yp,xp]==0)[0] + subset_on = one_cell[self.stim_table.Frame.isin(on_frame)] + subset_off = one_cell[self.stim_table.Frame.isin(off_frame)] + ax = plt.subplot(8,14,sp_pt) + ax.plot(subset_on.mean(), color='r', lw=2) + ax.plot(subset_off.mean(), color='b', lw=2) + ax.axvspan(28,35 ,ymin=0, ymax=1, facecolor='gray', alpha=0.3) + vmax = np.where(np.amax(subset_on.mean())>vmax, np.amax(subset_on.mean()), vmax) + vmax = np.where(np.amax(subset_off.mean())>vmax, np.amax(subset_off.mean()), vmax) + vmin = np.where(np.amin(subset_on.mean())" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(response[:,0,:,1,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "orivals = range(0,360,45)\n", + "tfvals = [1.,2.]\n", + "sizevals = [30,52,67,79,120]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from allensdk.brain_observatory.observatory_plots import plot_mask_outline" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/saskiad/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: \n", + ".ix is deprecated. Please use\n", + ".loc for label based indexing or\n", + ".iloc for positional indexing\n", + "\n", + "See the documentation here:\n", + "http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#ix-indexer-is-deprecated\n", + " \n", + "/Users/saskiad/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:6: FutureWarning: \n", + ".ix is deprecated. Please use\n", + ".loc for label based indexing or\n", + ".iloc for positional indexing\n", + "\n", + "See the documentation here:\n", + "http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#ix-indexer-is-deprecated\n", + " \n" + ] + } + ], + "source": [ + "metrics['responsive'] = False\n", + "metrics.ix[metrics.peak_percent_trials>0.25, 'responsive'] = True\n", + "\n", + "metrics.dir_percent/=50.\n", + "metrics['responsive_2'] = False\n", + "metrics.ix[metrics.dir_percent>0.6, 'responsive_2'] = True" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Unnamed: 0', 'cell_index', 'dir', 'tf', 'prefsize', 'osi', 'dsi',\n", + " 'dir_percent', 'peak_mean', 'peak_std', 'blank_mean', 'blank_std',\n", + " 'peak_percent_trials', 'cell_id', 'session_id', 'valid', 'cre', 'area',\n", + " 'depth', 'responsive', 'responsive_2'],\n", + " dtype='object')" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metrics.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "keys1 = ['valid','responsive','responsive_2','cell_index','cell_id', 'session_id', 'cre', 'area', 'depth', \n", + " 'dir', 'tf', 'prefsize', 'osi', 'dsi', 'peak_mean','peak_std','blank_mean','blank_std', 'peak_percent_trials','dir_percent']\n", + "\n", + "valid = metrics#[metrics_rf.valid]\n", + "for index, row in valid.iterrows():\n", + " cell_id = row.cell_id\n", + " session_id = row.session_id\n", + " cell_index = row.cell_index\n", + " pref_ori = orivals[int(row.dir)]\n", + " pref_tf = tfvals[int(row.tf)]\n", + " pref_size = sizevals[int(row.prefsize-1)]\n", + "# print(row.prefsize, pref_size)\n", + " \n", + " analysis_file = os.path.join(analysis_file_path, str(session_id)+'_st_analysis.h5')\n", + " expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(session_id)+'_data.h5'\n", + " \n", + " f = h5py.File(analysis_file, 'r')\n", + " response = f['response'][()]\n", + " f.close()\n", + " sweep_response = pd.read_hdf(analysis_file, 'sweep_response')\n", + " stim_table = pd.read_hdf(expt_path, 'drifting_gratings_size')\n", + " \n", + " f = h5py.File(expt_path, 'r')\n", + " mp = f['max_projection'][()]\n", + " rois = f['roi_outlines'][()]\n", + " f.close()\n", + " rois = rois.astype(float)\n", + " rois[rois==0] = np.NaN\n", + " roi_table = pd.read_hdf(expt_path, 'roi_table')\n", + " \n", + " plt.figure(figsize=(25,15))\n", + "\n", + " ax1 = plt.subplot2grid((3,3),(0,0))\n", + " ax2 = plt.subplot2grid((3,3),(1,0))\n", + " ax3 = plt.subplot2grid((3,3),(0,1), rowspan=2)\n", + "# ax6 = plt.subplot2grid((3,3),(0,2), rowspan=2)\n", + " ax4 = plt.subplot2grid((3,3), (2,0))\n", + " ax5 = plt.subplot2grid((3,3), (2,1))\n", + " ax7 = plt.subplot2grid((3,3),(2,2))\n", + " \n", + " #Tuning curve\n", + " ax1.errorbar(range(5), response[row.dir,row.tf,1:,cell_index,0], \n", + " yerr=response[row.dir,row.tf,1:,cell_index,1]/np.sqrt(response[row.dir,row.tf,1:,cell_index,2]), fmt='o-')\n", + " ax1.fill_between(range(5), response[0,0,0,cell_index,0]+(response[0,0,0,cell_index,1]/np.sqrt(response[0,0,0,cell_index,2])), \n", + " response[0,0,0,cell_index,0]-(response[0,0,0,cell_index,1]/np.sqrt(response[0,0,0,cell_index,2])), \n", + " color='k', alpha=0.3)\n", + " ax1.axhline(y=response[0,0,0,cell_index,0], color='k', ls='--',lw=2)\n", + " \n", + " ax1.set_xticks(range(5));\n", + " ax1.set_xticklabels(sizevals)\n", + " ax1.set_xlabel(\"Size (deg)\", fontsize=16)\n", + " ax1.set_ylabel(\"DF/F\", fontsize=16)\n", + " ax1.set_title(str(pref_ori)+\" Deg\"+\" \"+str(pref_tf)+\" Hz\", fontsize=16)\n", + " sns.despine()\n", + "\n", + " #Preferred direction\n", + " ax2.plot(sweep_response[(stim_table.Ori==pref_ori)&(stim_table.TF==pref_tf)&(stim_table.Size==pref_size)][str(cell_index)].mean())\n", + " ax2.plot(sweep_response[np.isnan(stim_table.Ori)][str(cell_index)].mean(), color='gray')\n", + " ax2.axvspan(30,90, color='gray', alpha=0.1)\n", + " ax2.set_xticks([30,60,90,120],[0,1,2,3])\n", + " ax2.set_xlabel(\"Time (s)\", fontsize=18)\n", + " ax2.set_ylabel(\"DFF\", fontsize=18)\n", + " ax2.set_title(str(pref_ori)+\" Deg\"+\" \"+str(pref_tf)+\" Hz\"+\" \"+str(pref_size), fontsize=16)\n", + " sns.despine()\n", + " \n", + " #Heatmap\n", + " ax4.imshow(response[:,0,1:,cell_index,0], vmin=0, vmax=row.peak_mean)\n", + " ax4.set_yticks(range(8))\n", + " ax4.set_yticklabels(orivals)\n", + " ax4.set_xticks(range(5))\n", + " ax4.set_xticklabels(sizevals)\n", + " ax4.set_xlabel(\"Size\")\n", + " ax4.set_ylabel(\"Direction\")\n", + " ax4.set_title(\"1 Hz\", fontsize=16)\n", + " \n", + " ax5.imshow(response[:,1,1:,cell_index,0], vmin=0, vmax=row.peak_mean)\n", + " ax5.set_yticks(range(8))\n", + " ax5.set_yticklabels(orivals)\n", + " ax5.set_xticks(range(5))\n", + " ax5.set_xticklabels(sizevals)\n", + " ax5.set_title(\"2 Hz\", fontsize=16)\n", + " \n", + " #ROI mask\n", + " mask_test = np.zeros((512,512))\n", + " x_start = roi_table.x[cell_index]\n", + " y_start = roi_table.y[cell_index]\n", + " x_delta = np.array(roi_table['mask'][cell_index]).shape[1]\n", + " y_delta = np.array(roi_table['mask'][cell_index]).shape[0]\n", + " mask_test[y_start:y_start+y_delta, x_start:x_start+x_delta] = np.array(roi_table['mask'][cell_index])\n", + " # mask_test[mask_test==0] = np.NaN\n", + "\n", + " ax7.imshow(mp, cmap='gray')\n", + " # plt.imshow(rois)\n", + " # plt.imshow(mask_test, cmap='viridis_r')\n", + " plot_mask_outline(mask_test, ax7, color='y')\n", + " ax7.set_xlim(x_start-90, x_start+90)\n", + " ax7.set_ylim(y_start+90, y_start-90)\n", + " \n", + " #metrics\n", + " table_data = []\n", + " for key in keys1:\n", + " table_data.append([key, valid[valid.cell_id==cell_id][key].values[0]])\n", + " table = ax3.table(cellText=table_data, loc='center')\n", + " table.set_fontsize(12)\n", + "# table.scale(1,2)\n", + " ax3.axis('off')\n", + "\n", + " \n", + " plt.suptitle(\"Session: \"+str(session_id)+\" Cell: \"+str(cell_id), fontsize=18)\n", + " plt.tight_layout()\n", + " plt.savefig(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/ST_figures/'+str(cell_id)+'.png')\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "row.tf" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.0, 2.0]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tfvals" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.0" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tfvals[int(row.tf)]" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "row.prefsize" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/size_tuning.py b/analysis/size_tuning.py index 0cf2ddf..8354a13 100644 --- a/analysis/size_tuning.py +++ b/analysis/size_tuning.py @@ -132,7 +132,8 @@ def get_stimulus_response(self): #compute mean response across trials, only use trials within eye_thresh of mean eye position response = np.empty((8, 2, 6, self.numbercells, 4)) #ori X TF x size X cells X mean, std, #trials, % significant trials - + response[:] = np.NaN + for oi, ori in enumerate(self.orivals): for ti, tf in enumerate(self.tfvals): for si, size in enumerate(self.sizevals): diff --git a/analysis/stim_table.py b/analysis/stim_table.py index f62be7a..c540b9e 100644 --- a/analysis/stim_table.py +++ b/analysis/stim_table.py @@ -322,7 +322,7 @@ def get_attribute_by_sweep(data, stimulus_idx, attribute): for i_condition, condition in enumerate(unique_conditions): sweeps_with_condition = np.argwhere(sweep_order == condition)[:, 0] - if condition > 0: # blank sweep is -1 + if condition >= 0: # blank sweep is -1 try: attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx] except: diff --git a/analysis/sync/dataset.py b/analysis/sync/dataset.py new file mode 100755 index 0000000..c411977 --- /dev/null +++ b/analysis/sync/dataset.py @@ -0,0 +1,408 @@ +""" +dataset.py + +Dataset object for loading and unpacking a sync dataset. + +""" + +import datetime +import pprint + +import h5py as h5 +import numpy as np + +dset_version = 1.0 + + +def unpack_uint32(uint32_array, endian='L'): + """ + Unpacks an array of 32-bit unsigned integers into bits. + + Default is least significant bit first. + + """ + if not uint32_array.dtype == np.uint32: + raise TypeError("Must be uint32 ndarray.") + buff = np.getbuffer(uint32_array) + uint8_array = np.frombuffer(buff, dtype=np.uint8) + uint8_array = np.fliplr(uint8_array.reshape(-1, 4)) + bits = np.unpackbits(uint8_array).reshape(-1, 32) + if endian.upper() == 'B': + bits = np.fliplr(bits) + return bits + + +def get_bit(uint_array, bit): + """ + Returns a bool array for a specific bit in a uint ndarray. + """ + return np.bitwise_and(uint_array, 2 ** bit).astype(bool).astype(np.uint8) + + +class Dataset(object): + """ + A sync dataset. Contains methods for loading + and parsing the binary data. + + """ + + def __init__(self, path): + self.load(path) + + self.times = self._process_times() + + def _process_times(self): + times = self.get_all_events()[:, 0:1].astype(np.int64) + + intervals = np.ediff1d(times, to_begin=0) + rollovers = np.where(intervals < 0)[0] + + for i in rollovers: + times[i:] += 4294967296 + + return times + + def load(self, path): + """ + Loads an hdf5 sync dataset. + """ + self.dfile = h5.File(path, 'r') + self.meta_data = eval(self.dfile['meta'].value) + self.line_labels = self.meta_data['line_labels'] + return self.dfile + + def get_bit(self, bit): + """ + Returns the values for a specific bit. + """ + return get_bit(self.get_all_bits(), bit) + + def get_line(self, line): + """ + Returns the values for a specific line. + """ + bit = self._line_to_bit(line) + return self.get_bit(bit) + + def get_bit_changes(self, bit): + """ + Returns the first derivative of a specific bit. + Data points are 1 on rizing edges and 255 on falling edges. + """ + bit_array = self.get_bit(bit) + return np.ediff1d(bit_array, to_begin=0) + + def get_all_bits(self): + """ + Returns the data for all bits. + """ + return self.dfile['data'].value[:, -1] + + def get_all_times(self): + """ + Returns all counter values. + """ + if self.meta_data['ni_daq']['counter_bits'] == 32: + return self.get_all_events()[:, 0] + else: + """ + + #this doesn't work because actually the rollover isn't a pulse + #it goes high after the first rollover then low after the second + + times = self.get_all_events()[:, 0:2].astype(np.uint64) + times = times[:, 0] + times[:, 1]*np.uint64(4294967296) + return times + """ + return self.times + + def get_all_events(self): + """ + Returns all counter values and their cooresponding IO state. + """ + return self.dfile['data'].value + + def get_events_by_bit(self, bit): + """ + Returns all counter values for transitions (both rising and falling) + for a specific bit. + """ + changes = self.get_bit_changes(bit) + return self.get_all_times()[np.where(changes != 0)] + + def get_events_by_line(self, line): + """ + Returns all counter values for transitions (both rising and falling) + for a specific line. + """ + line = self._line_to_bit(line) + return self.get_events_by_bit(line) + + def _line_to_bit(self, line): + """ + Returns the bit for a specified line. Either line name and number is + accepted. + """ + if type(line) is int: + return line + elif type(line) is str: + return self.line_labels.index(line) + else: + raise TypeError("Incorrect line type. Try a str or int.") + + def get_rising_edges(self, line): + """ + Returns the counter values for the rizing edges for a specific bit. + """ + bit = self._line_to_bit(line) + changes = self.get_bit_changes(bit) + return self.get_all_times()[np.where(changes == 1)] + + def get_falling_edges(self, line): + """ + Returns the counter values for the falling edges for a specific bit. + """ + bit = self._line_to_bit(line) + changes = self.get_bit_changes(bit) + return self.get_all_times()[np.where(changes == 255)] + + def line_stats(self, line, print_results=True): + """ + Quick-and-dirty analysis of a bit. + + ##TODO: Split this up into smaller functions. + + """ + # convert to bit + bit = self._line_to_bit(line) + + # get the bit's data + bit_data = self.get_bit(bit) + total_data_points = len(bit_data) + + # get the events + events = self.get_events_by_bit(bit) + total_events = len(events) + + # get the rising edges + rising = self.get_rising_edges(bit) + total_rising = len(rising) + + # get falling edges + falling = self.get_falling_edges(bit) + total_falling = len(falling) + + if total_events <= 0: + if print_results: + print(("*" * 70)) + print(("No events on line: %s" % line)) + print(("*" * 70)) + return None + elif total_events <= 10: + if print_results: + print(("*" * 70)) + print(("Sparse events on line: %s" % line)) + print(("Rising: %s" % total_rising)) + print(("Falling: %s" % total_falling)) + print(("*" * 70)) + return { + 'line': line, + 'bit': bit, + 'total_rising': total_rising, + 'total_falling': total_falling, + 'avg_freq': None, + 'duty_cycle': None, + } + else: + + # period + period = self.period(line) + + avg_period = period['avg'] + max_period = period['max'] + min_period = period['min'] + period_sd = period['sd'] + + # freq + avg_freq = self.frequency(line) + + # duty cycle + duty_cycle = self.duty_cycle(line) + + if print_results: + print(("*" * 70)) + + print(("Quick stats for line: %s" % line)) + print(("Bit: %i" % bit)) + print(("Data points: %i" % total_data_points)) + print(("Total transitions: %i" % total_events)) + print(("Rising edges: %i" % total_rising)) + print(("Falling edges: %i" % total_falling)) + print(("Average period: %s" % avg_period)) + print(("Minimum period: %s" % min_period)) + print(("Max period: %s" % max_period)) + print(("Period SD: %s" % period_sd)) + print(("Average freq: %s" % avg_freq)) + print(("Duty cycle: %s" % duty_cycle)) + + print(("*" * 70)) + + return { + 'line': line, + 'bit': bit, + 'total_data_points': total_data_points, + 'total_events': total_events, + 'total_rising': total_rising, + 'total_falling': total_falling, + 'avg_period': avg_period, + 'min_period': min_period, + 'max_period': max_period, + 'period_sd': period_sd, + 'avg_freq': avg_freq, + 'duty_cycle': duty_cycle, + } + + def period(self, line, edge="rising"): + """ + Returns a dictionary with avg, min, max, and sd of period for a line. + """ + bit = self._line_to_bit(line) + + if edge.lower() == "rising": + edges = self.get_rising_edges(bit) + elif edge.lower() == "falling": + edges = self.get_falling_edges(bit) + + if len(edges) > 1: + + timebase_freq = self.meta_data['ni_daq']['counter_output_freq'] + avg_period = np.mean(np.ediff1d(edges)) / timebase_freq + max_period = np.max(np.ediff1d(edges)) / timebase_freq + min_period = np.min(np.ediff1d(edges)) / timebase_freq + period_sd = np.std(avg_period) + + else: + raise IndexError("Not enough edges for period: %i" % len(edges)) + + return { + 'avg': avg_period, + 'max': max_period, + 'min': min_period, + 'sd': period_sd, + } + + def frequency(self, line, edge="rising"): + """ + Returns the average frequency of a line. + """ + + period = self.period(line, edge) + return 1.0 / period['avg'] + + def duty_cycle(self, line): + """ + Doesn't work right now. Freezes python for some reason. + + Returns the duty cycle of a line. + + """ + raise NotImplementedError + + bit = self._line_to_bit(line) + + rising = self.get_rising_edges(bit) + falling = self.get_falling_edges(bit) + + total_rising = len(rising) + total_falling = len(falling) + + if total_rising > total_falling: + rising = rising[:total_falling] + elif total_rising < total_falling: + falling = falling[:total_rising] + else: + pass + + if rising[0] < falling[0]: + # line starts low + high = falling - rising + else: + # line starts high + high = np.concatenate( + falling, self.get_all_events()[-1, 0] + ) - np.concatenate(0, rising) + + total_high_time = np.sum(high) + all_events = self.get_events_by_bit(bit) + total_time = all_events[-1] - all_events[0] + return 1.0 * total_high_time / total_time + + def stats(self): + """ + Quick-and-dirty analysis of all bits. Prints a few things about each + bit where events are found. + """ + bits = [] + for i in range(32): + bits.append(self.line_stats(i, print_results=False)) + active_bits = [x for x in bits if x is not None] + print(("Active bits: ", len(active_bits))) + for bit in active_bits: + print(("*" * 70)) + print(("Bit: %i" % bit['bit'])) + print(("Label: %s" % self.line_labels[bit['bit']])) + print(("Rising edges: %i" % bit['total_rising'])) + print(("Falling edges: %i" % bit["total_falling"])) + print(("Average freq: %s" % bit['avg_freq'])) + print(("Duty cycle: %s" % bit['duty_cycle'])) + print(("*" * 70)) + return active_bits + + def plot_all(self): + """ + Plot all active bits. + + Yikes. Come up with a better way to show this. + + """ + import matplotlib.pyplot as plt + + for bit in range(32): + if len(self.get_events_by_bit(bit)) > 0: + data = self.get_bit(bit) + plt.plot(data) + plt.show() + + def plot_bits(self, bits): + """ + Plots a list of bits. + """ + import matplotlib.pyplot as plt + + for bit in bits: + data = self.get_bit(bit) + plt.plot(data) + plt.show() + + def close(self): + """ + Closes the dataset. + """ + self.dfile.close() + + +def main(): + path = r"\\aibsdata\mpe\CAM\testdata\test.h5" + dset = Dataset(path) + + # pprint.pprint(dset.meta_data) + + dset.stats() + + # print dset.duty_cycle(2) + + # dset.plot_bits([2, 4]) + + +if __name__ == '__main__': + main() diff --git a/analysis/sync/gui/__init__.py b/analysis/sync/gui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/analysis/sync/gui/res/record.png b/analysis/sync/gui/res/record.png new file mode 100755 index 0000000000000000000000000000000000000000..cbcf5053e8f7159b4464ac284c80f97a9c857e54 GIT binary patch literal 142112 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%0DB_*B8zgI#ZQN=a&I8SW&4uAbcBjGo^^Q0 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 z

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 literal 0 HcmV?d00001 diff --git a/analysis/sync/gui/res/stop.png b/analysis/sync/gui/res/stop.png new file mode 100755 index 0000000000000000000000000000000000000000..38f12bec35ca832417908accaf5f6f4273ef602a GIT binary patch literal 29169 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 Pz>lTb8Pj(sJYxO_@5XMA literal 0 HcmV?d00001 diff --git a/analysis/sync/gui/sync_gui.py b/analysis/sync/gui/sync_gui.py new file mode 100755 index 0000000..536ca9d --- /dev/null +++ b/analysis/sync/gui/sync_gui.py @@ -0,0 +1,297 @@ +''' +Created on Oct 18, 2014 + +@author: derricw +''' + + +import sys +import os +import datetime +import pickle as pickle + +from PyQt4 import QtCore, QtGui + +from .sync_gui_layout import Ui_MainWindow +from sync.sync import Sync +from sync.dataset import Dataset + +LAST_SESSION = "C:/sync/last.pkl" +DEFAULT_OUTPUT = "C:/sync/output/test" + + +class MyForm(QtGui.QMainWindow): + """ + Simple GUI for testing the Sync program. + + Remembers state of all widgets between sessions. + + """ + + def __init__(self, parent=None): + QtGui.QWidget.__init__(self, parent) + self.ui = Ui_MainWindow() + self.ui.setupUi(self) + + self._setup_table() + self._setup_buttons() + + self._load_state() + self._calculate_rollover() + + self.running = False + self.sync_thread = None + + self.ui.plainTextEdit.appendPlainText("Ready...") + + def _setup_table(self): + """ + Sets up the tablewidget so that the numbering is 0:31 + """ + # set vertical labels to 0:31 + labels_int = list(range(32)) + labels_str = [str(i) for i in labels_int] + self.ui.tableWidget_labels.setVerticalHeaderLabels(labels_str) + # set horizontal labels + self.ui.tableWidget_labels.setHorizontalHeaderLabels(['line ']) + + def _setup_buttons(self): + """ + Setup button callbacks and icons. + """ + self.ui.pushButton_start.clicked.connect(self._start_stop) + self.ui.pushButton_start.setIcon(QtGui.QIcon("res/record.png")) + self.ui.lineEdit_pulse_freq.textChanged.connect( + self._calculate_rollover + ) + self.ui.lineEdit_counter_bits.textChanged.connect( + self._calculate_rollover + ) + + def _start_stop(self): + """ + Callback for start/stop button press. + """ + if not self.running: + # get configuration from gui + self._start_session() + self.running = True + self._disable_ui() + self.ui.pushButton_start.setIcon(QtGui.QIcon("res/stop.png")) + + else: + self._stop_session() + self.running = False + self._enable_ui() + self.ui.pushButton_start.setIcon(QtGui.QIcon("res/record.png")) + + def _disable_ui(self): + """ + Disables the ui. + """ + self.ui.tableWidget_labels.setEnabled(False) + self.ui.groupBox.setEnabled(False) + + def _enable_ui(self): + """ + Enables the UI. + """ + self.ui.tableWidget_labels.setEnabled(True) + self.ui.groupBox.setEnabled(True) + + def _start_session(self): + """ + Starts a session. + """ + now = datetime.datetime.now() + self.output_dir = str(self.ui.lineEdit_output_path.text()) + if self.ui.checkBox_timestamp.isChecked(): + self.output_dir += now.strftime('%y%m%d%H%M%S') + basedir = os.path.dirname(self.output_dir) + try: + os.makedirs(basedir) + except: + pass + device = str(self.ui.lineEdit_device.text()) + counter = str(self.ui.lineEdit_counter.text()) + counter_bits = int(self.ui.lineEdit_counter_bits.text()) + if not counter_bits in [32, 64]: + raise ValueError("Counter must be 64 or 32 bits.") + data_bits = int(self.ui.lineEdit_data_bits.text()) + pulse = str(self.ui.lineEdit_pulse_out.text()) + freq = float(str(self.ui.lineEdit_pulse_freq.text())) + + # add labels + labels = self._getLabels() + + # #create Sync object + params = { + 'device': device, + 'counter': counter, + 'pulse': pulse, + 'output_dir': self.output_dir, + 'counter_bits': counter_bits, + 'event_bits': data_bits, + 'freq': freq, + 'labels': labels, + } + + self.sync = SyncObject(params=params) + if self.sync_thread: + self.sync_thread.terminate() + self.sync_thread = QtCore.QThread() + self.sync.moveToThread(self.sync_thread) + self.sync_thread.start() + self.sync_thread.setPriority(QtCore.QThread.TimeCriticalPriority) + + QtCore.QTimer.singleShot(100, self.sync.start) + + self.ui.plainTextEdit.appendPlainText( + "***Starting session at \ + %s on %s ***" + % (str(now), device) + ) + + def _stop_session(self): + """ + Ends the session. + """ + now = datetime.datetime.now() + # self.sync.clear() + QtCore.QTimer.singleShot(100, self.sync.clear) + # self.sync = None + + self.ui.plainTextEdit.appendPlainText( + "***Ending session at \ + %s ***" + % str(now) + ) + + def _getLabels(self): + """ + Gets all of the line labels. + """ + labels = [] + for i in range(self.ui.tableWidget_labels.rowCount()): + item = self.ui.tableWidget_labels.item(i, 0) + if item is not None: + labels.append(str(item.text())) + else: + labels.append("") + return labels + + def _save_state(self): + """ + Saves widget states. + """ + state = { + 'output_dir': str(self.ui.lineEdit_output_path.text()), + 'device': str(self.ui.lineEdit_device.text()), + 'counter': str(self.ui.lineEdit_counter.text()), + 'counter_bits': str(self.ui.lineEdit_counter_bits.text()), + 'event_bits': str(self.ui.lineEdit_data_bits.text()), + 'pulse': str(self.ui.lineEdit_pulse_out.text()), + 'freq': str(self.ui.lineEdit_pulse_freq.text()), + 'labels': self._getLabels(), + 'timestamp': self.ui.checkBox_timestamp.isChecked(), + } + with open(LAST_SESSION, 'wb') as f: + pickle.dump(state, f) + + def _load_state(self): + """ + Loads previous widget states. + """ + try: + with open(LAST_SESSION, 'rb') as f: + data = pickle.load(f) + self.ui.lineEdit_output_path.setText(data['output_dir']) + self.ui.lineEdit_device.setText(data['device']) + self.ui.lineEdit_counter.setText(data['counter']) + self.ui.lineEdit_counter_bits.setText(data['counter_bits']) + self.ui.lineEdit_data_bits.setText(data['event_bits']) + self.ui.lineEdit_pulse_out.setText(data['pulse']) + self.ui.lineEdit_pulse_freq.setText(data['freq']) + self.ui.checkBox_timestamp.setChecked(data['timestamp']) + for index, label in enumerate(data['labels']): + self.ui.tableWidget_labels.setItem( + index, 0, QtGui.QTableWidgetItem(label) + ) + self.ui.plainTextEdit.appendPlainText( + "Loaded previous config successfully." + ) + except Exception as e: + print(e) + self.ui.plainTextEdit.appendPlainText( + "Couldn't load previous session. Using defaults." + ) + + def _calculate_rollover(self): + """ + Calculates the rollover time for the current freqency. + """ + counter_bits_str = str(self.ui.lineEdit_counter_bits.text()) + if counter_bits_str: + counter_bits = int(counter_bits_str) + else: + return + if counter_bits == 32: + freq = float(str(self.ui.lineEdit_pulse_freq.text())) + try: + seconds = 4294967295 / freq # max unsigned + timestr = str(datetime.timedelta(seconds=seconds)) + except: + timestr = "???" + elif counter_bits == 64: + timestr = "~FOREVER" + else: + timestr = "???" + self.ui.label_rollover.setText(timestr) + + def closeEvent(self, event): + self._save_state() + if self.sync_thread: + self.sync_thread.terminate() + + +class SyncObject(QtCore.QObject): + """ + Thread for controlling sync. + + ##TODO: Fix params argument to not be stupid. + """ + + def __init__(self, parent=None, params={}): + + QtCore.QObject.__init__(self, parent) + + self.params = params + + def start(self): + # create Sync object + self.sync = Sync( + self.params['device'], + self.params['counter'], + self.params['pulse'], + self.params['output_dir'], + counter_bits=self.params['counter_bits'], + event_bits=self.params['event_bits'], + freq=self.params['freq'], + verbose=True, + force_sync_callback=False, + ) + + for i, label in enumerate(self.params['labels']): + self.sync.add_label(i, label) + + self.sync.start() + + def clear(self): + self.sync.clear() + + +if __name__ == "__main__": + app = QtGui.QApplication(sys.argv) + myapp = MyForm() + myapp.show() + sys.exit(app.exec_()) diff --git a/analysis/sync/gui/sync_gui.ui b/analysis/sync/gui/sync_gui.ui new file mode 100755 index 0000000..ac213da --- /dev/null +++ b/analysis/sync/gui/sync_gui.ui @@ -0,0 +1,267 @@ + + + MainWindow + + + + 0 + 0 + 844 + 543 + + + + Sync + + + + + + + Setup + + + + + + 64 + + + + + + + Counter Bits + + + + + + + Output path: + + + + + + + C:/sync/output/test + + + + + + + Timestamp + + + true + + + + + + + Pulse Freq (Hz): + + + + + + + 100000.0 + + + + + + + Rollover + + + + + + + Device: + + + + + + + Dev1 + + + + + + + Counter: + + + + + + + ctr0 + + + + + + + Pulse Out: + + + + + + + ctr2 + + + + + + + false + + + Aux Counter + + + + + + + false + + + + + + + Data Bits + + + + + + + 32 + + + + + + + + + + + 200 + 150 + + + + + + + + 128 + 128 + + + + + + + + + + + + 150 + 0 + + + + + 200 + 16777215 + + + + true + + + Qt::DashDotLine + + + true + + + 32 + + + 1 + + + 200 + + + 30 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 0 + 844 + 21 + + + + + + + + diff --git a/analysis/sync/gui/sync_gui_layout.py b/analysis/sync/gui/sync_gui_layout.py new file mode 100755 index 0000000..316e796 --- /dev/null +++ b/analysis/sync/gui/sync_gui_layout.py @@ -0,0 +1,173 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'sync_gui.ui' +# +# Created: Thu Nov 13 13:55:31 2014 +# by: PyQt4 UI code generator 4.9.6 +# +# WARNING! All changes made in this file will be lost! + +from PyQt4 import QtCore, QtGui + +try: + _fromUtf8 = QtCore.QString.fromUtf8 +except AttributeError: + + def _fromUtf8(s): + return s + + +try: + _encoding = QtGui.QApplication.UnicodeUTF8 + + def _translate(context, text, disambig): + return QtGui.QApplication.translate(context, text, disambig, _encoding) + + +except AttributeError: + + def _translate(context, text, disambig): + return QtGui.QApplication.translate(context, text, disambig) + + +class Ui_MainWindow(object): + def setupUi(self, MainWindow): + MainWindow.setObjectName(_fromUtf8("MainWindow")) + MainWindow.resize(844, 543) + self.centralwidget = QtGui.QWidget(MainWindow) + self.centralwidget.setObjectName(_fromUtf8("centralwidget")) + self.gridLayout_2 = QtGui.QGridLayout(self.centralwidget) + self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2")) + self.groupBox = QtGui.QGroupBox(self.centralwidget) + self.groupBox.setObjectName(_fromUtf8("groupBox")) + self.gridLayout = QtGui.QGridLayout(self.groupBox) + self.gridLayout.setObjectName(_fromUtf8("gridLayout")) + self.lineEdit_counter_bits = QtGui.QLineEdit(self.groupBox) + self.lineEdit_counter_bits.setObjectName( + _fromUtf8("lineEdit_counter_bits") + ) + self.gridLayout.addWidget(self.lineEdit_counter_bits, 1, 1, 1, 1) + self.label_6 = QtGui.QLabel(self.groupBox) + self.label_6.setObjectName(_fromUtf8("label_6")) + self.gridLayout.addWidget(self.label_6, 1, 0, 1, 1) + self.label = QtGui.QLabel(self.groupBox) + self.label.setObjectName(_fromUtf8("label")) + self.gridLayout.addWidget(self.label, 0, 0, 1, 1) + self.lineEdit_output_path = QtGui.QLineEdit(self.groupBox) + self.lineEdit_output_path.setObjectName( + _fromUtf8("lineEdit_output_path") + ) + self.gridLayout.addWidget(self.lineEdit_output_path, 0, 1, 1, 1) + self.checkBox_timestamp = QtGui.QCheckBox(self.groupBox) + self.checkBox_timestamp.setChecked(True) + self.checkBox_timestamp.setObjectName(_fromUtf8("checkBox_timestamp")) + self.gridLayout.addWidget(self.checkBox_timestamp, 0, 2, 1, 1) + self.label_2 = QtGui.QLabel(self.groupBox) + self.label_2.setObjectName(_fromUtf8("label_2")) + self.gridLayout.addWidget(self.label_2, 3, 0, 1, 1) + self.lineEdit_pulse_freq = QtGui.QLineEdit(self.groupBox) + self.lineEdit_pulse_freq.setObjectName(_fromUtf8("lineEdit_pulse_freq")) + self.gridLayout.addWidget(self.lineEdit_pulse_freq, 3, 1, 1, 1) + self.label_rollover = QtGui.QLabel(self.groupBox) + self.label_rollover.setObjectName(_fromUtf8("label_rollover")) + self.gridLayout.addWidget(self.label_rollover, 3, 2, 1, 1) + self.label_5 = QtGui.QLabel(self.groupBox) + self.label_5.setObjectName(_fromUtf8("label_5")) + self.gridLayout.addWidget(self.label_5, 4, 0, 1, 1) + self.lineEdit_device = QtGui.QLineEdit(self.groupBox) + self.lineEdit_device.setObjectName(_fromUtf8("lineEdit_device")) + self.gridLayout.addWidget(self.lineEdit_device, 4, 1, 1, 1) + self.label_4 = QtGui.QLabel(self.groupBox) + self.label_4.setObjectName(_fromUtf8("label_4")) + self.gridLayout.addWidget(self.label_4, 5, 0, 1, 1) + self.lineEdit_counter = QtGui.QLineEdit(self.groupBox) + self.lineEdit_counter.setObjectName(_fromUtf8("lineEdit_counter")) + self.gridLayout.addWidget(self.lineEdit_counter, 5, 1, 1, 1) + self.label_3 = QtGui.QLabel(self.groupBox) + self.label_3.setObjectName(_fromUtf8("label_3")) + self.gridLayout.addWidget(self.label_3, 6, 0, 1, 1) + self.lineEdit_pulse_out = QtGui.QLineEdit(self.groupBox) + self.lineEdit_pulse_out.setObjectName(_fromUtf8("lineEdit_pulse_out")) + self.gridLayout.addWidget(self.lineEdit_pulse_out, 6, 1, 1, 1) + self.checkBox_aux_counter = QtGui.QCheckBox(self.groupBox) + self.checkBox_aux_counter.setEnabled(False) + self.checkBox_aux_counter.setObjectName( + _fromUtf8("checkBox_aux_counter") + ) + self.gridLayout.addWidget(self.checkBox_aux_counter, 7, 0, 1, 1) + self.lineEdit_aux_counter = QtGui.QLineEdit(self.groupBox) + self.lineEdit_aux_counter.setEnabled(False) + self.lineEdit_aux_counter.setObjectName( + _fromUtf8("lineEdit_aux_counter") + ) + self.gridLayout.addWidget(self.lineEdit_aux_counter, 7, 1, 1, 1) + self.label_data_bits = QtGui.QLabel(self.groupBox) + self.label_data_bits.setObjectName(_fromUtf8("label_data_bits")) + self.gridLayout.addWidget(self.label_data_bits, 2, 0, 1, 1) + self.lineEdit_data_bits = QtGui.QLineEdit(self.groupBox) + self.lineEdit_data_bits.setObjectName(_fromUtf8("lineEdit_data_bits")) + self.gridLayout.addWidget(self.lineEdit_data_bits, 2, 1, 1, 1) + self.gridLayout_2.addWidget(self.groupBox, 0, 1, 1, 1) + self.pushButton_start = QtGui.QPushButton(self.centralwidget) + self.pushButton_start.setMinimumSize(QtCore.QSize(200, 150)) + self.pushButton_start.setText(_fromUtf8("")) + self.pushButton_start.setIconSize(QtCore.QSize(128, 128)) + self.pushButton_start.setObjectName(_fromUtf8("pushButton_start")) + self.gridLayout_2.addWidget(self.pushButton_start, 1, 1, 1, 1) + self.plainTextEdit = QtGui.QPlainTextEdit(self.centralwidget) + self.plainTextEdit.setObjectName(_fromUtf8("plainTextEdit")) + self.gridLayout_2.addWidget(self.plainTextEdit, 2, 1, 1, 1) + self.tableWidget_labels = QtGui.QTableWidget(self.centralwidget) + self.tableWidget_labels.setMinimumSize(QtCore.QSize(150, 0)) + self.tableWidget_labels.setMaximumSize(QtCore.QSize(200, 16777215)) + self.tableWidget_labels.setShowGrid(True) + self.tableWidget_labels.setGridStyle(QtCore.Qt.DashDotLine) + self.tableWidget_labels.setCornerButtonEnabled(True) + self.tableWidget_labels.setRowCount(32) + self.tableWidget_labels.setColumnCount(1) + self.tableWidget_labels.setObjectName(_fromUtf8("tableWidget_labels")) + self.tableWidget_labels.horizontalHeader().setDefaultSectionSize(200) + self.tableWidget_labels.verticalHeader().setDefaultSectionSize(30) + self.gridLayout_2.addWidget(self.tableWidget_labels, 0, 0, 3, 1) + MainWindow.setCentralWidget(self.centralwidget) + self.menubar = QtGui.QMenuBar(MainWindow) + self.menubar.setGeometry(QtCore.QRect(0, 0, 844, 21)) + self.menubar.setObjectName(_fromUtf8("menubar")) + MainWindow.setMenuBar(self.menubar) + self.statusbar = QtGui.QStatusBar(MainWindow) + self.statusbar.setObjectName(_fromUtf8("statusbar")) + MainWindow.setStatusBar(self.statusbar) + + self.retranslateUi(MainWindow) + QtCore.QMetaObject.connectSlotsByName(MainWindow) + + def retranslateUi(self, MainWindow): + MainWindow.setWindowTitle(_translate("MainWindow", "Sync", None)) + self.groupBox.setTitle(_translate("MainWindow", "Setup", None)) + self.lineEdit_counter_bits.setText(_translate("MainWindow", "64", None)) + self.label_6.setText(_translate("MainWindow", "Counter Bits", None)) + self.label.setText(_translate("MainWindow", "Output path:", None)) + self.lineEdit_output_path.setText( + _translate("MainWindow", "C:/sync/output/test", None) + ) + self.checkBox_timestamp.setText( + _translate("MainWindow", "Timestamp", None) + ) + self.label_2.setText(_translate("MainWindow", "Pulse Freq (Hz):", None)) + self.lineEdit_pulse_freq.setText( + _translate("MainWindow", "100000.0", None) + ) + self.label_rollover.setText(_translate("MainWindow", "Rollover", None)) + self.label_5.setText(_translate("MainWindow", "Device:", None)) + self.lineEdit_device.setText(_translate("MainWindow", "Dev1", None)) + self.label_4.setText(_translate("MainWindow", "Counter:", None)) + self.lineEdit_counter.setText(_translate("MainWindow", "ctr0", None)) + self.label_3.setText(_translate("MainWindow", "Pulse Out:", None)) + self.lineEdit_pulse_out.setText(_translate("MainWindow", "ctr2", None)) + self.checkBox_aux_counter.setText( + _translate("MainWindow", "Aux Counter", None) + ) + self.label_data_bits.setText( + _translate("MainWindow", "Data Bits", None) + ) + self.lineEdit_data_bits.setText(_translate("MainWindow", "32", None)) diff --git a/analysis/sync/scripts/analysis_example.py b/analysis/sync/scripts/analysis_example.py new file mode 100755 index 0000000..1c85121 --- /dev/null +++ b/analysis/sync/scripts/analysis_example.py @@ -0,0 +1,24 @@ +""" +Simple use case for Dataset class. This should be expanded and show all + features of Dataset at some point. + +""" +from sync.dataset import Dataset + + +def main(): + """simple data example""" + dset = Dataset("C:/sync/output/test.h5") + events = dset.get_all_events() + print(("Events:", events)) + + b0 = dset.get_bit(0) + print(b0[:20]) + + import ipdb + + ipdb.set_trace() + + +if __name__ == '__main__': + main() diff --git a/analysis/sync/scripts/sample_signal.py b/analysis/sync/scripts/sample_signal.py new file mode 100755 index 0000000..ad57318 --- /dev/null +++ b/analysis/sync/scripts/sample_signal.py @@ -0,0 +1,32 @@ +""" +Just flips two Digital IO lines at different rates. + +This should be expanded to generate different types of signals and perhaps be + part of a testing suite. + +""" +from toolbox.IO.nidaq import DigitalOutput +import numpy as np +import time + +do = DigitalOutput("Dev2", port=1) +do.start() + + +counter = 0 +counter_2 = 0 +print("Running...") +while True: + to_write = counter % 2 + do.writeBit(0, to_write) + if counter % 2 == 0: + to_write = counter_2 % 2 + do.writeBit(1, to_write) + counter_2 += 1 + counter += 1 + if counter % 1000 == 0: + print(counter) + # time.sleep(0.1) + +do.stop() +do.clear() diff --git a/analysis/sync/scripts/sample_signal_fast.py b/analysis/sync/scripts/sample_signal_fast.py new file mode 100755 index 0000000..eae1b73 --- /dev/null +++ b/analysis/sync/scripts/sample_signal_fast.py @@ -0,0 +1,19 @@ +""" +Sample signal. High speed pulse output for benchmarking. +""" +import time + +from toolbox.IO.nidaq import CounterOutputFreq + + +def main(): + co = CounterOutputFreq( + 'Dev2', 'ctr3', init_delay=0.0, freq=1000.0, duty_cycle=0.50 + ) + co.start() + time.sleep(10) + co.clear() + + +if __name__ == '__main__': + main() diff --git a/analysis/sync/sync.py b/analysis/sync/sync.py new file mode 100755 index 0000000..31ee897 --- /dev/null +++ b/analysis/sync/sync.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python +""" +sync.py + +Allen Instute of Brain Science + +created on Oct 10 2014 + +@author: derricw + +""" + +import datetime +import time + +import h5py as h5 +import numpy as np + +from toolbox.IO.nidaq import ( + EventInput, + CounterInputU32, + CounterInputU64, + CounterOutputFreq, + DigitalInput, +) +from toolbox.misc.timer import timeit +from .dataset import Dataset + +sync_version = 1.0 + + +class Sync(object): + """ + Sets up a combination of a single EventInput, counter input/ + output pair to record IO events in a compact binary file. + + Parameters + ---------- + device : str + NI DAQ Device, ex: 'Dev1' + counter_input : str + NI Counter terminal, ex: 'ctr0' + counter_output : str + NI Counter terminal, ex: 'ctr0' + output_path : str + Output file path, optional + event_bits : int (32) + Event Input bits + counter_bits : int (32) + 32 or 64 + freq : float (100000.0) + Pulse generator frequency + verbose : bool (False) + Verbose mode prints a lot of stuff. + + + Example + ------- + >>> from sync import Sync + >>> import time + >>> s = Sync('Dev1','ctr0','ctr2,'C:/output.sync', freq=100000.0) + >>> s.start() + >>> time.sleep(5) # collect events for 5 seconds + >>> s.stop() # can be restarted + >>> s.clear() # cannot be restarted + + """ + + def __init__( + self, + device, + counter_input, + counter_output, + output_path, + event_bits=32, + counter_bits=32, + freq=100000.0, + verbose=False, + force_sync_callback=False, + ): + + self.device = device + self.counter_input = counter_input + self.counter_output = counter_output + self.counter_bits = counter_bits + self.output_path = output_path + self.event_bits = event_bits + self.freq = freq + self.verbose = verbose + + # Configure input counter + if self.counter_bits == 32: + self.ci = CounterInputU32(device=device, counter=counter_input) + callback = self._EventCallback32bit + elif self.counter_bits == 64: + self.ci = CounterInputU64(device=device, lsb_counter=counter_input,) + callback = self._EventCallback64bit + else: + raise ValueError("Counter can only be 32 or 64 bits.") + + output_terminal_str = "Ctr%sInternalOutput" % counter_output[-1] + self.ci.setCountEdgesTerminal(output_terminal_str) + + # Configure Pulse Generator + if self.verbose: + print(("Counter input terminal", self.ci.getCountEdgesTerminal())) + + self.co = CounterOutputFreq( + device=device, + counter=counter_output, + init_delay=0.0, + freq=freq, + duty_cycle=0.50, + ) + + if self.verbose: + print(("Counter output terminal: ", self.co.getPulseTerminal())) + + # Configure Event Input + self.ei = EventInput( + device=device, + bits=self.event_bits, + buffer_size=200, + force_synchronous_callback=force_sync_callback, + buffer_callback=callback, + timeout=0.01, + ) + + # Configure Optional Counters + ## TODO: ADD THIS + self.optional_counters = [] + + self.line_labels = ["" for x in range(32)] + + self.bin = open(self.output_path, 'wb') + + def add_counter(self, counter_input): + """ + Add an extra counter to this dataset. + """ + pass + + def add_label(self, bit, name): + self.line_labels[bit] = name + + def start(self): + """ + Starts all tasks. They don't necessarily have to all + start simultaneously. + + """ + self.start_time = str(datetime.datetime.now()) # get a timestamp + + self.ci.start() + self.co.start() + self.ei.start() + + def stop(self): + """ + Stops all tasks. They can be restarted. + + ***This doesn't seem to work sometimes. I don't know why.*** + + #should we just use clear? + """ + self.ei.stop() + self.co.stop() + self.ci.stop() + + def clear(self, out_file=None): + """ + Clears all tasks. They cannot be restarted. + """ + self.ei.clear() + self.ci.clear() + self.co.clear() + + self.timeouts = self.ei.timeouts[:] + + self.ei = None + self.ci = None + self.co = None + + self.bin.flush() + time.sleep(0.2) + self.bin.close() + + self.bin = None + + self.stop_time = str(datetime.datetime.now()) + + self._save_hdf5(out_file) + + def _save_hdf5(self, output_file_path=None): + # save sync data + if output_file_path: + filename = output_file_path + else: + filename = self.output_path + ".h5" + data = np.fromfile(self.output_path, dtype=np.uint32) + if self.counter_bits == 32: + data = data.reshape(-1, 2) + else: + data = data.reshape(-1, 3) + h5_output = h5.File(filename, 'w') + h5_output.create_dataset("data", data=data) + # save meta data + meta_data = str(self._get_meta_data()) + meta_data_np = np.string_(meta_data) + h5_output.create_dataset("meta", data=meta_data_np) + h5_output.close() + if self.verbose: + print(("Recorded %i events." % len(data))) + print(("Metadata: %s" % meta_data)) + print(("Saving to %s" % filename)) + try: + ds = Dataset(filename) + ds.stats() + ds.close() + except Exception as e: + print(("Failed to print quick stats: %s" % e)) + + def _get_meta_data(self): + """ + + """ + from .dataset import dset_version + + meta_data = { + 'ni_daq': { + 'device': self.device, + 'counter_input': self.counter_input, + 'counter_output': self.counter_output, + 'counter_output_freq': self.freq, + 'event_bits': self.event_bits, + 'counter_bits': self.counter_bits, + }, + 'start_time': self.start_time, + 'stop_time': self.stop_time, + 'line_labels': self.line_labels, + 'timeouts': self.timeouts, + 'version': {'dataset': dset_version, 'sync': sync_version,}, + } + return meta_data + + # @timeit + def _EventCallback32bit(self, data): + """ + Callback for change event. + + Writing is already buffered by open(). OS handles it. + """ + self.bin.write(np.ctypeslib.as_array(self.ci.read())) + self.bin.write(np.ctypeslib.as_array(data)) + + # @timeit + def _EventCallback64bit(self, data): + """ + Callback for change event for 64-bit counter. + """ + (lsb, msb) = self.ci.read() + self.bin.write(np.ctypeslib.as_array(lsb)) + self.bin.write(np.ctypeslib.as_array(msb)) + self.bin.write(np.ctypeslib.as_array(data)) + + +if __name__ == "__main__": + + import signal + import argparse + import sys + + from PyQt4 import QtCore + + description = """ + + sync.py\n + + This program creates a process that controls three NIDAQmx tasks.\n + + 1) An event input task monitors all digital lines for rising or falling + edges.\n + 2) A pulse generator task creates a timebase for the events.\n + 3) A counter counts pulses on the timebase.\n + + """ + + parser = argparse.ArgumentParser( + description=description, + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument("output_path", type=str, help="output data path") + parser.add_argument( + "-d", "--device", type=str, help="NIDAQ Device to use.", default="Dev1" + ) + parser.add_argument( + "-c", + "--counter_bits", + type=int, + default=64, + help="Counter timebase bits.", + ) + parser.add_argument( + "-b", + "--event_bits", + type=int, + default=32, + help="Change detection bits.", + ) + parser.add_argument( + "-v", + "--verbose", + action="store_true", + default=False, + help="Print a bunch of crap.", + ) + parser.add_argument( + "-f", + "--force", + action="store_true", + help="Force synchronous callbacks.", + ) + parser.add_argument( + "-hz", + "--frequency", + type=float, + default=10000000.0, + help="Pulse (timebase) frequency.", + ) + + args = parser.parse_args() + + output_path = args.output_path + force_sync_callback = args.force + device = args.device + counter_bits = args.counter_bits + event_bits = args.event_bits + verbose = args.verbose + freq = args.frequency + + print("Starting task...") + + # print(args.__dict__) + + if force_sync_callback: + + """ + Using the force_sync_callback option in NIDAQmx. Have to create a + thread to handle the sync object or it will lock up this thread + when signal gets fast. + + """ + + class SyncObject(QtCore.QObject): + """ + Thread for sync control. We use Qt because it has a really + nice event loop. + """ + + cleared = QtCore.pyqtSignal() + + def __init__(self, parent=None, params={}): + QtCore.QObject.__init__(self, parent) + self.params = params + + def start(self): + # create Sync objects + self.sync = Sync( + device, + "ctr0", + "ctr2", + output_path, + counter_bits=counter_bits, + event_bits=event_bits, + freq=freq, + verbose=verbose, + force_sync_callback=True, + ) + + self.sync.start() + + def clear(self): + self.sync.clear() + print("Cleared...") + self.cleared.emit() + + app = QtCore.QCoreApplication(sys.argv) + + s_obj = SyncObject() + s_thr = QtCore.QThread() + + s_obj.moveToThread(s_thr) + s_thr.start() + s_thr.setPriority(QtCore.QThread.TimeCriticalPriority) + + # starts sync object within thread + QtCore.QTimer.singleShot(100, s_obj.start) + + timer = QtCore.QTimer() + timer.start(500) + # check for python signals every 500ms + timer.timeout.connect(lambda: None) + + def sigint_handler(*args): + print("Shutting down...") + QtCore.QTimer.singleShot(100, s_obj.clear) + + def finished(*args): + s_thr.terminate() + QtCore.QCoreApplication.quit() + + s_obj.cleared.connect(finished) + + signal.signal(signal.SIGINT, sigint_handler) + + sys.exit(app.exec_()) + + else: + + """ + In this mode, NIDAQmx creates and handles its own threading. + It is unclear how/if this is better. + """ + sync = Sync( + device, + "ctr0", + "ctr2", + counter_bits=counter_bits, + event_bits=event_bits, + freq=freq, + output_path=output_path, + verbose=verbose, + force_sync_callback=False, + ) + + def signal_handler(signal, frame): + sync.clear() + print('Shutting down...') + sys.exit(0) + + signal.signal(signal.SIGINT, signal_handler) + + sync.start() + + while True: + time.sleep(1) diff --git a/analysis/sync/tango/sync_device.py b/analysis/sync/tango/sync_device.py new file mode 100755 index 0000000..26fdcae --- /dev/null +++ b/analysis/sync/tango/sync_device.py @@ -0,0 +1,239 @@ +""" +sync_device.py + +Allen Institute for Brain Science + +created on 22 Oct 2014 + +@author: derricw + +Tango device for controlling the sync program. Creates attributes for + experiment setup and commands for starting/stopping. + +""" + +import time +import pickle as pickle +from shutil import copyfile +import os + +from PyTango.server import server_run +from PyTango.server import Device, DeviceMeta +from PyTango.server import attribute, command +from PyTango import DevState, AttrWriteType + +from sync import Sync + + +class SyncDevice(Device, metaclass=DeviceMeta): + + """ + Tango Sync device class. + + Parameters + ---------- + None + + Examples + -------- + + >>> from PyTango.server import server_run + >>> server_run((SyncDevice,)) + + """ + + time = attribute() # read only is default + + error_handler = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + device = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + counter_input = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + counter_output = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + pulse_freq = attribute(dtype=float, access=AttrWriteType.READ_WRITE,) + + output_path = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + line_labels = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) + + # ------------------------------------------------------------------------------ + # INIT + # ------------------------------------------------------------------------------ + + def init_device(self): + """ + Device constructor. Automatically run by Tango upon device export. + """ + self.set_state(DevState.ON) + self.set_status("READY") + self.attr_error_handler = "" + self.attr_device = 'Dev1' + self.attr_counter_input = 'ctr0' + self.attr_counter_output = 'ctr2' + self.attr_counter_bits = 64 + self.attr_event_bits = 24 + self.attr_pulse_freq = 10000000.0 + self.attr_output_path = "C:/sync/output/test.h5" + self.attr_line_labels = "[]" + print("Device initialized...") + + # ------------------------------------------------------------------------------ + # Attribute R/W + # ------------------------------------------------------------------------------ + + def read_time(self): + return time.time() + + def read_error_handler(self): + return self.attr_error_handler + + def write_error_handler(self, data): + self.attr_error_handler = data + + def read_device(self): + return self.attr_device + + def write_device(self, data): + self.attr_device = data + + def read_counter_input(self): + return self.attr_counter_input + + def write_counter_input(self, data): + self.attr_counter_input = data + + def read_counter_output(self): + return self.attr_counter_output + + def write_counter_output(self, data): + self.attr_counter_output = data + + def read_pulse_freq(self): + return self.attr_pulse_freq + + def write_pulse_freq(self, data): + self.attr_pulse_freq = data + + def read_output_path(self): + return self.attr_output_path + + def write_output_path(self, data): + self.attr_output_path = data + + def read_line_labels(self): + return self.attr_line_labels + + def write_line_labels(self, data): + self.attr_line_labels = data + + # ------------------------------------------------------------------------------ + # Commands + # ------------------------------------------------------------------------------ + + @command(dtype_in=str, dtype_out=str) + def echo(self, data): + """ + For testing. Just echos whatever string you send. + """ + return data + + @command(dtype_in=str, dtype_out=None) + def throw(self, msg): + print(("Raising exception:", msg)) + # Send to error handler or sequencing engine + + @command(dtype_in=None, dtype_out=None) + def start(self): + """ + Starts an experiment. + """ + print("Starting experiment...") + + self.sync = Sync( + device=self.attr_device, + counter_input=self.attr_counter_input, + counter_output=self.attr_counter_output, + counter_bits=self.attr_counter_bits, + event_bits=self.attr_event_bits, + output_path=self.attr_output_path, + freq=self.attr_pulse_freq, + verbose=True, + force_sync_callback=False, + ) + + lines = eval(self.attr_line_labels) + for index, line in enumerate(lines): + self.sync.add_label(index, line) + + self.sync.start() + + @command(dtype_in=None, dtype_out=None) + def stop(self): + """ + Stops an experiment and clears the NIDAQ tasks. + """ + print("Stopping experiment...") + try: + self.sync.stop() + except Exception as e: + print(e) + + self.sync.clear(self.attr_output_path) + self.sync = None + del self.sync + + @command(dtype_in=str, dtype_out=None) + def load_config(self, path): + """ + Loads a configuration from a .pkl file. + """ + print(("Loading configuration: %s" % path)) + + with open(path, 'rb') as f: + config = pickle.load(f) + + self.attr_device = config['device'] + self.attr_counter_input = config['counter'] + self.attr_counter_output = config['pulse'] + self.attr_counter_bits = int(config['counter_bits']) + self.attr_event_bits = int(config['event_bits']) + self.attr_pulse_freq = float(config['freq']) + self.attr_output_path = config['output_dir'] + self.attr_line_labels = str(config['labels']) + + @command(dtype_in=str, dtype_out=None) + def save_config(self, path): + """ + Saves a configuration to a .pkl file. + """ + print(("Saving configuration: %s" % path)) + + config = { + 'device': self.attr_device, + 'counter': self.attr_counter_input, + 'pulse': self.attr_counter_output, + 'freq': self.attr_pulse_freq, + 'output_dir': self.attr_output_path, + 'labels': eval(self.attr_line_labels), + 'counter_bits': self.attr_counter_bits, + 'event_bits': self.attr_event_bits, + } + + with open(path, 'wb') as f: + pickle.dump(config, f) + + @command(dtype_in=str, dtype_out=None) + def copy_dataset(self, folder): + """ + Copies last dataset to specified folder. + """ + source = self.attr_output_path + dest = os.path.join(folder, os.path.basename(source)) + + copyfile(source, dest) + + +if __name__ == "__main__": + server_run((SyncDevice,)) diff --git a/analysis/test.py b/analysis/test.py new file mode 100644 index 0000000..8c44f3f --- /dev/null +++ b/analysis/test.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 14 14:37:00 2021 + +@author: saskiad +""" + +import os +#print(os.listdir('/Volumes')) +#print(os.listdir(r'/Volumes/New Volume')) +#print(os.listdir(r'/Users/saskiad/Documents/Data/New_Volume')) +print(os.listdir(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_New')) \ No newline at end of file diff --git a/oscopetools/locally_sparse_noise.py b/oscopetools/locally_sparse_noise.py index 9b70891..fc6c3df 100644 --- a/oscopetools/locally_sparse_noise.py +++ b/oscopetools/locally_sparse_noise.py @@ -9,10 +9,14 @@ import numpy as np import pandas as pd import os, h5py +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py # import core from .stim_table import * +======= +import matplotlib.pyplot as plt +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py def do_sweep_mean(x): return x[28:35].mean() @@ -21,11 +25,17 @@ def do_sweep_mean(x): def do_sweep_mean_shifted(x): return x[30:40].mean() +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py +======= +def do_eye(x): + return x[28:32].mean() +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py class LocallySparseNoise: def __init__(self, expt_path): self.expt_path = expt_path +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py self.session_id = self.expt_path.split('/')[ -1 ] # this might need to be modified for where the data is for you. @@ -36,15 +46,30 @@ def __init__(self, expt_path): dff_path = os.path.join(self.expt_path, f) f = h5py.File(dff_path, 'r') self.dff = f['data'][()] +======= + self.session_id = self.expt_path.split('/')[-1].split('_')[-2] + + #load dff traces + f = h5py.File(self.expt_path, 'r') + self.dff = f['dff_traces'][()] +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py f.close() + self.numbercells = self.dff.shape[0] +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py # create stimulus table for locally sparse noise stim_dict = lsnCS_create_stim_table(self.expt_path) self.stim_table = stim_dict['locally_sparse_noise'] +======= + + #create stimulus table for locally sparse noise + self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py # load stimulus template self.LSN = np.load(lsn_path) +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py # run analysis ( @@ -58,6 +83,21 @@ def __init__(self, expt_path): # save outputs self.save_data() +======= + + #load eyetracking + self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') + + #run analysis + self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) + self.peak = self.get_peak() + + #save outputs +# self.save_data() + + #plot traces + self.plot_LSN_Traces() +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py def get_stimulus_response(self, LSN): '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. @@ -72,6 +112,7 @@ def get_stimulus_response(self, LSN): ''' +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py sweep_response = pd.DataFrame( index=self.stim_table.index.values, columns=np.array(list(range(self.numbercells))).astype(str), @@ -82,9 +123,23 @@ def get_stimulus_response(self, LSN): sweep_response[str(nc)][index] = self.dff[ nc, int(row.Start) - 28 : int(row.Start) + 35 ] +======= + sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + + for index,row in self.stim_table.iterrows(): + for nc in range(self.numbercells): + sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-28:int(row.Start+35)].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-28:int(row.Start+35)].values +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) + mean_sweep_eye = sweep_eye.applymap(do_eye) + +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py # make spontaneous p_values # TODO: pilot stimulus does not have spontaneous activity. But real data will and we shoudl re-implement this # shuffled_responses = np.empty((self.numbercells, 10000,10)) @@ -103,12 +158,16 @@ def get_stimulus_response(self, LSN): # p_values = np.mean(actual_is_less, axis=1) # sweep_p_values[str(nc)] = p_values +======= + +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py x_shape = LSN.shape[1] y_shape = LSN.shape[2] - response_on = np.empty((x_shape, y_shape, self.numbercells, 3)) - response_off = np.empty((x_shape, y_shape, self.numbercells, 3)) + response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) + response_off = np.empty((x_shape, y_shape, self.numbercells, 2)) for xp in range(x_shape): for yp in range(y_shape): +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py on_frame = np.where(LSN[:, xp, yp] == 255)[0] off_frame = np.where(LSN[:, xp, yp] == 0)[0] subset_on = mean_sweep_response[ @@ -137,6 +196,18 @@ def get_stimulus_response(self, LSN): response_off, ) +======= + on_frame = np.where(LSN[:,xp,yp]==255)[0] + off_frame = np.where(LSN[:,xp,yp]==0)[0] + subset_on = mean_sweep_response[self.stim_table.Frame.isin(on_frame)] + subset_off = mean_sweep_response[self.stim_table.Frame.isin(off_frame)] + response_on[xp,yp,:,0] = subset_on.mean(axis=0) + response_on[xp,yp,:,1] = subset_on.std(axis=0)/np.sqrt(len(subset_on)) + response_off[xp,yp,:,0] = subset_off.mean(axis=0) + response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) + return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye + +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py def get_peak(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -149,6 +220,7 @@ def get_peak(self): ) peak['rf_on'] = False peak['rf_off'] = False +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py on_rfs = np.where(self.response_events_on[:, :, :, 2] > 0.25)[2] off_rfs = np.where(self.response_events_off[:, :, :, 2] > 0.25)[2] peak.rf_on.loc[on_rfs] = True @@ -160,19 +232,80 @@ def save_data(self): self.expt_path, str(self.session_id) + "_lsn_analysis.h5" ) print("Saving data to: ", save_file) +======= + on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] + off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] + peak.rf_on.loc[on_rfs] = True + peak.rf_off.loc[off_rfs] = True + return peak + + def save_data(self): + '''saves intermediate analysis files in an h5 file''' + save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") + print "Saving data to: ", save_file +>>>>>>> Stashed changes:analysis/locally_sparse_noise.py store = pd.HDFStore(save_file) - store['sweep_response'] = self.sweep_events - store['mean_sweep_response'] = self.mean_sweep_events + store['sweep_response'] = self.sweep_response + store['mean_sweep_response'] = self.mean_sweep_response store['sweep_p_values'] = self.sweep_p_values store['peak'] = self.peak store.close() f = h5py.File(save_file, 'r+') - dset = f.create_dataset('response_on', data=self.response_events_on) - dset1 = f.create_dataset('response_off', data=self.response_events_off) + dset = f.create_dataset('response_on', data=self.response_on) + dset1 = f.create_dataset('response_off', data=self.response_off) f.close() +<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py if __name__ == '__main__': lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' # update this to local path the the stimulus array expt_path = r'/Volumes/My Passport/Openscope Multiplex/891653201' lsn = LocallySparseNoise(expt_path=expt_path) +======= + + def plot_LSN_Traces(self): + '''plots ON and OFF traces for each position for each cell''' + print "Plotting LSN traces for all cells" + + for nc in range(self.numbercells): + if np.mod(nc,100)==0: + print "Cell #", str(nc) + plt.figure(nc, figsize=(24,20)) + vmax=0 + vmin=0 + one_cell = self.sweep_response[str(nc)] + for yp in range(8): + for xp in range(14): + sp_pt = (yp*14)+xp+1 + on_frame = np.where(self.LSN[:,yp,xp]==255)[0] + off_frame = np.where(self.LSN[:,yp,xp]==0)[0] + subset_on = one_cell[self.stim_table.Frame.isin(on_frame)] + subset_off = one_cell[self.stim_table.Frame.isin(off_frame)] + ax = plt.subplot(8,14,sp_pt) + ax.plot(subset_on.mean(), color='r', lw=2) + ax.plot(subset_off.mean(), color='b', lw=2) + ax.axvspan(28,35 ,ymin=0, ymax=1, facecolor='gray', alpha=0.3) + vmax = np.where(np.amax(subset_on.mean())>vmax, np.amax(subset_on.mean()), vmax) + vmax = np.where(np.amax(subset_off.mean())>vmax, np.amax(subset_off.mean()), vmax) + vmin = np.where(np.amin(subset_on.mean())>>>>>> Stashed changes:analysis/locally_sparse_noise.py diff --git a/oscopetools/sync/gui/__init__.py b/oscopetools/sync/gui/__init__.py old mode 100755 new mode 100644 From e27ba01a6c1c6cc84e0b33c69fb90ce1ca0c9902 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 13:33:23 -0400 Subject: [PATCH 63/68] Clean up Saskia's working directory - Remove analysis/sync since it's identical to oscopetools/sync and edit imports in analysis/stim_table.py and analysis/DGgrid_analysis_5x5_nikon_SdV.py accordingly. - Restore executable permissions on oscopetools/sync/gui/__init__.py. Not sure whether executable permissions were removed accidentally, nor why this file was executable in the first place. - Remove analysis/.ipynb_checkpoints, which shouldn't be tracked. (.ipynb_checkpoints is in .gitignore on another branch.) - Remove analysis/test.py, which just prints the contents of some directories and probably shouldn't be tracked. --- .../CS_RF_centershifted-checkpoint.ipynb | 6 - .../Untitled-checkpoint.ipynb | 6 - .../center surround plotting-checkpoint.ipynb | 1109 ----------------- .../plotting_size_tuning-checkpoint.ipynb | 233 ---- analysis/DGgrid_analysis_5x5_nikon_SdV.py | 2 +- analysis/stim_table.py | 2 +- analysis/sync/dataset.py | 408 ------ analysis/sync/gui/__init__.py | 0 analysis/sync/gui/res/record.png | Bin 142112 -> 0 bytes analysis/sync/gui/res/stop.png | Bin 29169 -> 0 bytes analysis/sync/gui/sync_gui.py | 297 ----- analysis/sync/gui/sync_gui.ui | 267 ---- analysis/sync/gui/sync_gui_layout.py | 173 --- analysis/sync/scripts/analysis_example.py | 24 - analysis/sync/scripts/sample_signal.py | 32 - analysis/sync/scripts/sample_signal_fast.py | 19 - analysis/sync/sync.py | 446 ------- analysis/sync/tango/sync_device.py | 239 ---- analysis/test.py | 13 - oscopetools/sync/gui/__init__.py | 0 20 files changed, 2 insertions(+), 3274 deletions(-) delete mode 100644 analysis/.ipynb_checkpoints/CS_RF_centershifted-checkpoint.ipynb delete mode 100644 analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb delete mode 100644 analysis/.ipynb_checkpoints/center surround plotting-checkpoint.ipynb delete mode 100644 analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb delete mode 100755 analysis/sync/dataset.py delete mode 100644 analysis/sync/gui/__init__.py delete mode 100755 analysis/sync/gui/res/record.png delete mode 100755 analysis/sync/gui/res/stop.png delete mode 100755 analysis/sync/gui/sync_gui.py delete mode 100755 analysis/sync/gui/sync_gui.ui delete mode 100755 analysis/sync/gui/sync_gui_layout.py delete mode 100755 analysis/sync/scripts/analysis_example.py delete mode 100755 analysis/sync/scripts/sample_signal.py delete mode 100755 analysis/sync/scripts/sample_signal_fast.py delete mode 100755 analysis/sync/sync.py delete mode 100755 analysis/sync/tango/sync_device.py delete mode 100644 analysis/test.py mode change 100644 => 100755 oscopetools/sync/gui/__init__.py diff --git a/analysis/.ipynb_checkpoints/CS_RF_centershifted-checkpoint.ipynb b/analysis/.ipynb_checkpoints/CS_RF_centershifted-checkpoint.ipynb deleted file mode 100644 index 2fd6442..0000000 --- a/analysis/.ipynb_checkpoints/CS_RF_centershifted-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb deleted file mode 100644 index 2fd6442..0000000 --- a/analysis/.ipynb_checkpoints/Untitled-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/analysis/.ipynb_checkpoints/center surround plotting-checkpoint.ipynb b/analysis/.ipynb_checkpoints/center surround plotting-checkpoint.ipynb deleted file mode 100644 index 8e02785..0000000 --- a/analysis/.ipynb_checkpoints/center surround plotting-checkpoint.ipynb +++ /dev/null @@ -1,1109 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "metrics = pd.read_csv(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis/metrics_all.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(4023, 24)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "metrics.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['Unnamed: 0', 'center_dir', 'center_osi', 'center_dsi', 'iso', 'ortho',\n", - " 'suppression_strength', 'suppression_tuning', 'cmi', 'center_mean',\n", - " 'center_std', 'center_percent_trials', 'blank_mean', 'blank_std',\n", - " 'iso_mean', 'iso_std', 'ortho_mean', 'ortho_std', 'cell_id',\n", - " 'session_id', 'valid', 'cre', 'area', 'depth'],\n", - " dtype='object')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "metrics.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/saskiad/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: \n", - ".ix is deprecated. Please use\n", - ".loc for label based indexing or\n", - ".iloc for positional indexing\n", - "\n", - "See the documentation here:\n", - "http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#ix-indexer-is-deprecated\n", - " \n" - ] - } - ], - "source": [ - "#adding a responsive boolean based on percent trials for center condition\n", - "metrics['responsive'] = False\n", - "metrics.ix[metrics.center_percent_trials>0.25, 'responsive'] = True" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.16266343615696666" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "metrics[(metrics.area=='VISp')&(metrics.cre=='Cux2:Ai93')&(metrics.valid)&(metrics.responsive)].cmi.median()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "responsive = metrics[(metrics.valid)&(metrics.responsive)]" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Unnamed: 0center_dircenter_osicenter_dsiisoorthosuppression_strengthsuppression_tuningcmicenter_mean...iso_stdortho_meanortho_stdcell_idsession_idvalidcreareadepthresponsive
5052420.3223710.3331680.7921670.4837720.7619370.3095670.5244570.073867...0.0235400.0356200.02637410123228141011892173TrueSst:Ai148VISp250True
5102920.605475-0.0880100.670755-0.1133050.214989-7.3603720.7358520.240265...0.0738850.2212140.19003310123228221011892173TrueSst:Ai148VISp250True
5454030.419653-0.1028140.731528-0.0669630.2825945.3868810.7650180.030349...0.0069800.0196210.02007810130033181012864690TrueSst:Ai148VISp300True
597320.546138-0.0353610.706295-0.0157140.3271172.4276890.6896580.076672...0.0170570.0706270.10757910053447751005201417TrueSst:Ai148VISp330True
6081420.4767210.6956140.691701-0.066996-0.2481392.1020610.6375770.048733...0.0122300.0974730.22296310053447881005201417TrueSst:Ai148VISp330True
..................................................................
400418160.649730-0.1928140.672246-0.135953-0.6996760.1575310.6842210.052858...0.0101720.1030630.331968989651515989418742TrueCux2:Ai93VISp175True
400718460.508828-0.0457400.772790-0.560674-1.218666-2.8909030.9184270.035130...0.0064160.0773400.163312989651518989418742TrueCux2:Ai93VISp175True
400818560.6190120.8044560.9642830.135832-0.1253550.3575591.0799910.119870...0.0106730.0670540.167311989651519989418742TrueCux2:Ai93VISp175True
401719920.7656640.9716160.7127920.1130170.469048-1.9814290.6534870.540616...0.1459590.4375720.423561989651536989418742TrueCux2:Ai93VISp175True
402020260.267467-0.0983060.660191-0.0742320.1504940.7048550.6312410.016297...0.0202700.0094580.009718989651539989418742TrueCux2:Ai93VISp175True
\n", - "

155 rows × 25 columns

\n", - "
" - ], - "text/plain": [ - " Unnamed: 0 center_dir center_osi center_dsi iso ortho \\\n", - "505 24 2 0.322371 0.333168 0.792167 0.483772 \n", - "510 29 2 0.605475 -0.088010 0.670755 -0.113305 \n", - "545 40 3 0.419653 -0.102814 0.731528 -0.066963 \n", - "597 3 2 0.546138 -0.035361 0.706295 -0.015714 \n", - "608 14 2 0.476721 0.695614 0.691701 -0.066996 \n", - "... ... ... ... ... ... ... \n", - "4004 181 6 0.649730 -0.192814 0.672246 -0.135953 \n", - "4007 184 6 0.508828 -0.045740 0.772790 -0.560674 \n", - "4008 185 6 0.619012 0.804456 0.964283 0.135832 \n", - "4017 199 2 0.765664 0.971616 0.712792 0.113017 \n", - "4020 202 6 0.267467 -0.098306 0.660191 -0.074232 \n", - "\n", - " suppression_strength suppression_tuning cmi center_mean ... \\\n", - "505 0.761937 0.309567 0.524457 0.073867 ... \n", - "510 0.214989 -7.360372 0.735852 0.240265 ... \n", - "545 0.282594 5.386881 0.765018 0.030349 ... \n", - "597 0.327117 2.427689 0.689658 0.076672 ... \n", - "608 -0.248139 2.102061 0.637577 0.048733 ... \n", - "... ... ... ... ... ... \n", - "4004 -0.699676 0.157531 0.684221 0.052858 ... \n", - "4007 -1.218666 -2.890903 0.918427 0.035130 ... \n", - "4008 -0.125355 0.357559 1.079991 0.119870 ... \n", - "4017 0.469048 -1.981429 0.653487 0.540616 ... \n", - "4020 0.150494 0.704855 0.631241 0.016297 ... \n", - "\n", - " iso_std ortho_mean ortho_std cell_id session_id valid \\\n", - "505 0.023540 0.035620 0.026374 1012322814 1011892173 True \n", - "510 0.073885 0.221214 0.190033 1012322822 1011892173 True \n", - "545 0.006980 0.019621 0.020078 1013003318 1012864690 True \n", - "597 0.017057 0.070627 0.107579 1005344775 1005201417 True \n", - "608 0.012230 0.097473 0.222963 1005344788 1005201417 True \n", - "... ... ... ... ... ... ... \n", - "4004 0.010172 0.103063 0.331968 989651515 989418742 True \n", - "4007 0.006416 0.077340 0.163312 989651518 989418742 True \n", - "4008 0.010673 0.067054 0.167311 989651519 989418742 True \n", - "4017 0.145959 0.437572 0.423561 989651536 989418742 True \n", - "4020 0.020270 0.009458 0.009718 989651539 989418742 True \n", - "\n", - " cre area depth responsive \n", - "505 Sst:Ai148 VISp 250 True \n", - "510 Sst:Ai148 VISp 250 True \n", - "545 Sst:Ai148 VISp 300 True \n", - "597 Sst:Ai148 VISp 330 True \n", - "608 Sst:Ai148 VISp 330 True \n", - "... ... ... ... ... \n", - "4004 Cux2:Ai93 VISp 175 True \n", - "4007 Cux2:Ai93 VISp 175 True \n", - "4008 Cux2:Ai93 VISp 175 True \n", - "4017 Cux2:Ai93 VISp 175 True \n", - "4020 Cux2:Ai93 VISp 175 True \n", - "\n", - "[155 rows x 25 columns]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "responsive[(responsive.iso>0.5)&(responsive.cmi>0.5)]" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4017 0.443688\n", - "Name: center_std, dtype: float64" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "responsive[responsive.cell_id==989651536].center_std" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "analysis_file_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis_py3/989418742_cs_analysis.h5'" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "import h5py" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "f = h5py.File(analysis_file_path, 'r')" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "response = f['response'][()]" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "f.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(8, 4, 206, 4)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "response.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6,5))\n", - "plt.errorbar(range(0,360,45),response[:,0,199,0], yerr=response[:,0,199,1]/np.sqrt(response[:,0,199,2]), fmt='o-', color='k')\n", - "plt.errorbar(range(0,360,45),response[:,1,199,0], yerr=response[:,1,199,1]/np.sqrt(response[:,1,199,2]), fmt='o-', color='r')\n", - "plt.errorbar(range(0,360,45),response[:,2,199,0], yerr=response[:,2,199,1]/np.sqrt(response[:,2,199,2]), fmt='o-', color='b')\n", - "plt.xticks(range(0,360,45));\n", - "plt.xlabel(\"Direction (deg)\", fontsize=18)\n", - "plt.ylabel(\"Mean DF/F\", fontsize=18)\n", - "plt.tick_params(labelsize=16)\n", - "plt.text(270,0.6, \"center\", color='k', fontsize=14)\n", - "plt.text(270,0.56, \"iso\", color='r', fontsize=14)\n", - "plt.text(270,0.52, \"ortho\", color='b', fontsize=14)\n", - "plt.axhline(y=response[0,3,199,0], ls='--', color='gray')\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "sweep_response = pd.read_hdf(analysis_file_path, 'sweep_response')" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [], - "source": [ - "expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(989418742)+'_data.h5'\n", - "stim_table = pd.read_hdf(expt_path, 'center_surround')" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "stim_table['condition'] = 'ortho'\n", - "stim_table.loc[stim_table.Center_Ori==stim_table.Surround_Ori, 'condition'] = 'iso'\n", - "stim_table.loc[np.isfinite(stim_table.Center_Ori)&np.isnan(stim_table.Surround_Ori), 'condition'] = 'center'\n", - "stim_table.loc[np.isnan(stim_table.Center_Ori)&np.isnan(stim_table.Surround_Ori), 'condition'] = 'blank'\n", - "stim_table.loc[np.isnan(stim_table.Center_Ori)&np.isfinite(stim_table.Surround_Ori), 'condition'] = 'surround'" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAFOCAYAAAC/qdtaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3hUVfrA8e+ZmXRaCDWQAgECgQQJgUiviggIKyuKFOvaV9afLrbVZdct7OpaV1l117YiYgFEQERKQpMS6lKkhBRSICEFhNSZOb8/biYJEJJJ5k5uyvk8T54hd+aeeaNJ3pxz3nOOkFKiKIqiKO5iMjoARVEUpWlTiUZRFEVxK5VoFEVRFLdSiUZRFEVxK5VoFEVRFLdSiUZRFEVxK0MTjRCiqxDiLSHEj0KIAiGEFEKEOnFfLyHEG0KIg0KIi0KITCHESiFEf/dHrSiKotSG0T2aHsAMIA/YUov7bgTGAB8DU4BHgPbATiHEQL2DVBRFUepOGLlgUwhhklLay/59P/A+0E1KmVzDfe2AHFkpeCFEayAZ+FZKOddtQSuKoii1YjHyzR1Jpg73navi2nkhxHGgi8uBKYqiKLoxNNHoSQjRFugHfOjM62+66Sa5du1a9wallMvPz8dqtRodhtKEWSwW2rRpY3QYzYGo7Q1NJtEAb6H9B3jdmRefO3dVp0hxI6vVipeXl9FhKE1YcXGx0SEo12B0MYAuhBDPAncCj0kpT1bzugeEEAlCiITs7Oz6C1BRFKUBuvvuu5k8ebLb36fRJxohxEPAX4DfSSk/qO61Usr3pJQxUsqY9u3b10+AiqIoTZwQwiKEuOaQWqNONEKIOcA7wD+klH82Oh5FURQ9SSn5xz/+Qc+ePfHy8qJr1648++yzAKSnp3PHHXfg7++Pv78/kyZN4sSJE+X3LliwgH79+vH5558TFhZGy5YtmTZtWvm0wYIFC/j4449ZvXo1QgiEEMTFxTnVthBigRDikBDibiFEIlAM+F3r62i0iUYI8Qu0if9/SymfMjoeRVEUvT333HO89NJLPPvssxw+fJgvv/ySoKAgCgoKGDNmDN7e3sTHx/Pjjz/SuXNnxo8fT0FBQfn9ycnJLF26lOXLl7Nu3Tr27dvH888/D8BTTz3FjBkzGD9+PJmZmWRmZjJ06FCn2wa6oU1Z3Ab0B4qu9XUYXgwghPhl2T8dCy0nCiGygWwpZXzZa6zAx1LK+8o+HwksAQ4CHwkhrq/UZLGUcl/9RK8oiuIeFy9e5LXXXuP111/n3nvvBaBHjx4MGTKEDz74ACklH374IY4Rq3fffZcOHTqwatUqZsyYAWhFOB999BGtW7cG4IEHHuDDD7XC3BYtWuDj44OXlxedOnUqf99PP/3UqbYBT2COlPJsTV+L4YkG+PKKz98pe4wHRpf921z24TAW8AIGANuuuD8FCNU1QkVRlHp25MgRiouLGTdu3FXP7dmzh6SkJFq2bHnZ9YKCAhITE8s/DwkJKU8yAIGBgWRlZVX7vs62DaQ5k2SgASQaKWWNNdlXvkZKuQBY4KaQFEVRDFfdri12u53rrruOzz///Krn2rZtW/5vDw+Py54TQmC3V79O3tm2gUvVNlSJ4YlGURRFuVpERAReXl5s2LCBnj17XvZcdHQ0S5YsoV27di4tUvX09MRms7ml7coabTGAoihKU9ayZUvmzZvHs88+y4cffkhiYiK7du1i0aJFzJo1i44dOzJ16lTi4+NJSkpi8+bNPPnkk5dVh9UkNDSUQ4cOcezYMc6dO0dpaalubVemEo2iKA1KZmYm8fHxRofRIPz1r3/l6aef5qWXXqJPnz5Mnz6dtLQ0fH192bx5M927d+e2226jd+/e3HXXXeTl5eHv7+90+7/61a/o06cPMTExtG/fnm3btunWdmWG7t5spJiYGJmQkGB0GM3GuXPn1BY0SrVycnJ49dVXef/99ykqKmLLli307+/8EVPFxcW0a9fOjREqZWq915nq0SiKYrjCwkKGDh3K22+/zbRp0/Dx8eGDD6rd6ENpRFSiURTFcN9++y2ZmZksWbKE9957j+nTp/PFF19w4cIFo0NTdKASjaIohlu8eDEhISFMmDABgPvuu49Lly6xdOlSgyMz2N13Qz1seuluKtEoimKo06dPExcXx8yZMzGZtF9J0dHRXHfddeUr4JutN96ATz81OgqXqUSjKIqhlixZgpSSO++8s/yaEIJ7772Xw4cPs3PnTgOjM1jr1tAEDnNTiUZRFMNIKVm8eDEjRowgNDT0suduu+02WrVqxauvvtp8ezWVh842b4brr4cWLbQEFBsLhw5VvHbZMoiMBC8vCAqCP/8ZGsh/N5VoFEUxzI8//khSUhKzZs266jk/Pz/mz5/P2rVrWbFihQHRNSBWK0ydCsOHw4EDsHMnzJsH5rItIPfsgdtug1tvhf/9DxYuhL/+Ff75T2PjLqPW0Sj1Qq2jUUDbR8sxDwNwzz33sG7dOo4fP46f39XHmVitVsaNG0daWhq7d+++cq+tyzTJdTR33w3nzsEnn0BAAMTFwahRV79u1izIzISNGyuuLVgA//43pKXpHZVaR6MoSsM0f/58Ro0aRUlJCQAnT55k+fLl3HfffVUmGQCLxcJbb71Fbm4uv/vd7+oz3IalbVst6UyYAJMmwauvwunTFc8fPQrDhl1+z/DhkJ4ODaBEXCUaRVHqxdq1azlw4ACvv/46AK+99hqenp489thj1d4XFRXFvHnz+PTTT9m27cpTQZqRDz/UhsxGjoSVK6FXL/j+e+05KeFaJylf+4TleqMSjaIobnfmzBmSk5Np1aoVL7/8MvHx8SxZsoS5c+fSoUOHGu+fP38+Xbt25Zlnnrlqt+FmpX9/ePppbQht9Gj4+GPtekQEbN16+Wu3boWuXeGKc2WMoBKNoihu5yhRXrRoEV5eXkyfPh2AefPmOXW/r68vf/jDHzhw4ACLFy92W5wNVlISPPMMbN8OKSmwaRMcPKglGIAnn4T4eG1e5vhxWLwY/vEPmD/f0LAdVKJRFMXtdu7ciZeXFxMmTGDBggWUlJQwc+ZMgoKCnG7jl7/8JYMHD+aPf/xj89uaxtdXSyC33aYNmd11l1YA8PTT2vPR0fDll/D119Cvn5aUnnkGahiWrC+q6kypF6rqrHkbN24cFouF77//HrvdzpIlS5g4cWK1VWRV2bNnD2PGjOGJJ57gD3/4w2XPNcmqs4ZJVZ0pitKwFBYWsn//fmJjYwEwmUzMmjWr1kkGYODAgcycOZO3336b5ORknSNV3EUlGkVR3Gr//v2UlpZy/fXX69Leiy++iNlsZsGCBbq0p7ifSjSKoriVoxBg8ODBurTXpUsXHn/8cZYtW9a890GrJSHgq6+MeW+VaBRFcasdO3YQFham6/zJvHnz6NixI88991zz3QftGhYs0OoBGhKVaBRFcRspJTt37tRt2MyhRYsWvPDCC+zevZvNmzfr2nZjVlpqdARVU4lGURS3SUxMJCcnp7wQQE833ngjAMeOHdO97YaiuBh+8xvo2BG8vbXNmx3rMuPitOGwNWtg8GDw9IR334U//AEOH9aeEwI++qiivdxcrULazw+6d7/6qJv//Q/Gjwcfn4pdb86fd/3rUIlGURS3OXXqFAB9+vTRve0OHTrg5eVFSkqK7m03FPPnw9Kl8MEHsG+fdgrATTdp+2c6PP00/OlP8NNP2gbPTz4J4eHaazIz4fbbK177xz9qrzlwQLt+773a+k+AggKt7RYtYNcuWL5cWx96772ufx0W15tQFEWp2pkzZwDo3Lmzbm3u3Kn9fRwbC8HBwaSmpurWdkNy6RIsWqRtwDxpknbtX//SNmh++22t5wHanExZ5w7QEoXFAp06Xd3mnDkwe7b275de0g7w3LIFQkK0zQQuXoT//rdi15r33oMxY+DkSejRo+5fi+rRKIriNhkZGQB07NhRl/Z+/NHM5Mm+3HSTLx9/7NGkE01iojbnUnlTZrMZhgyBI0cqrsXEON9mVFTFvy0WaN8esrK0z48e1Z6vvDXa0KFgMl3+fnVhaKIRQnQVQrwlhPhRCFEghJBCiFAn7zUJIZ4VQiQLIYqEEAeEENPdG7GiKLVx5swZAgICdNkV4vhxE7ff7kNQkGT0aBu//rU3OTmPk5SU7HqgDZCjmK6qzZcrX7vGCQtV8vC4uh27veL93LUBtNE9mh7ADCAP2FLLe18CFgD/BCYCO4AvhRA36xmgoih1l5mZSWBgoMvt5ObC9Ok+eHhIli0r4IsvCpk9u5T9+28hP39gk9z7rEcPbYK/8qbMNhv8+GPFXppV8fTUXldbERHa3M3PP1dc275dS0SuTrEZnWg2Syk7SilvBr509iYhRAfgKWChlPIVKeUmKeWDwCZgoZtiVRSlljIzM+lU1WRBLa1fbyElxcSHHxYRGirx8IC//KWo7NnrmuTwmZ8fPPywtjfmmjXa0NbDD8PZs/DII9e+LzRUm+Dfu1c7nLO42Ln3mzVLe8+5c7Xqs82b4cEHtdOhXZmfAYMTjZTSXsdbJwCewBXFeXwKRAohurkUmKIousjMzNSlECAjQ/tVNWBAxZ/qbdqAv38JEN4kEw3A3/4GM2bAPffAdddpJwOsXQvV/SedPh1uvhnGjdPmYJYsce69fH21c9QuXNDKpadO1eaDPvjA9a+jsVad9QWKgZNXXD9c9hgBJNVrRIqiXMZqtZKVlaVTohG0aiWvOsOrRw8bu3eHk5Lyo8vv0RB5ecHrr2sfVxo9umIe58p7qtpqpqrXXrkvaWQkbNhQl0irZ/TQWV21BfLl1XtP5FZ6XlEUA509exYppW6JpnPnqwdAIiLMQO8mvZamKWisiUYAVW1wVG1thBDiASFEghAiITs72z2RKYoCaMNmoM8amowME4GBV//I9+plB9pz8mTu1TcpDUZjTTS5gL8QVxXd+Vd6/ipSyveklDFSypj27du7NUBFae4cizX1KAbIzBRVJpoePbRezsmTZpffQ3GfxppoDgNeQNgV1x1Ffy4uL1IUxVWOxZquljfbbHDmTNVDZz17atcyM1u59B6KezXWRLMWKAFmXXF9NnBISqkKARTFYGfOnMFsNrt8PEBWlsBmq7pHExoqMZttFBYGc16P3R8VtzC86kwI8cuyfw4se5wohMgGsqWU8WWvsQIfSynvA5BSZgkhXgOeFUL8DOwFbgfGAlPr9QtQFKVKmZmZdOzYEbPZtWGt9HRthLxLl6t7NBYLdOz4MxkZ4aSkpBAWduUgh9IQGJ5ouHqh5jtlj/HA6LJ/m8s+KnseuAjMAzoBx4AZUspv3ROmoii1odcamsxMbeClc+eqDzjr3t1KRkY4p0/vdvm9FPcwPNFIKWvcRaeq10gpbcCfyj4URWlgMjMzdelhZGRoP/5VDZ0B9OvnwdatPUhKWubyeynu0VjnaBRFaeD02n4mI0Pg4SFp167qRBMV5Ql4cuRIgcvvpbiHSjSKouiusLCQ/Px83dbQdO4sMV3jt5Wj8uzkScMHaJRrUIlGURTdORZr6rFzc2amuOb8DFQkmrS0WuyXr9QrlWgURdGdnos109NNVVacObRtC76+l8jO9ufs2bMuv5+iP5VoFEXRnV7bz0hZc48GoEcPKxDO999/79L7Ke6hEo2iKLrTK9GcPw8FBYLAwOpPFBkwwAch+rFmzXcuvZ/iHirRKIqiu8zMTLy9vWnTpo1L7TjOoampRxMVZUfKANauPYTVanXpPRX9qUSjKIruHKXNV+97WzuONTRdutSUaLQD0c6f78auXbtcek9FfyrRKIqiu/T0dJ12BdASTVUbalbWr58dISRCDOS779TwWUOjEo2iKLq6ePEie/bsYeDAgTW/uAbp6c4Nnfn5aadt+vuPZc2aNS6/r6IvlWgURdFVfHw8JSUlTJgwweW2MjMF7drZ8fKq+bWRkVbs9ij27t1bXl6tNAwq0SiKoqu1a9fSsmVLhgwZ4nJb6elVn6xZlchIG/n5rYG2rFu3zuX3VvSjEo2iKLqRUrJu3TrGjh2Lp6eny+05s4bGITJSqzbz8RmqCgIaGJVoFEXRzcGDB8nMzOSmm27Spb3Tp0107Vp9IYBDv35aounUaSJ79uzR5f0VfahEoyiKbhwr82+44QaX28rLg/x8QbduziWagABJ167g5RXLgQMH1HqaBkQlGkVRdPP9998THR1Nhw4dXG4rJUX79RQa6tzQGcCAAXDhQhiFhYX89NNPLseg6EMlGkVRdHHu3DkSEhJ0qTYDSE52JBrnejSgJZozZ1oDPmr4rAFRiUZRFF1s374dKSXjx4/XpT1HogkJqV2isdsF3t6xKtE0ICrRKIqiC8cW/cHBwbq0l5wsaNvWTuvWzt8THa09dup0K3v37tUlDsV1KtEoiqKLnJwcANq2batLe0lJplrNzwAEB2vJ5tKlaezbtw+bzaZLLIprVKJRFEUXOTk5tG7dGg8PD13aS0kx1Wp+xuGeeyA7O4iCgh4cO3ZMl1gU16hEoygu+vbbb9m5c2eVz5WWlrJ69WpKSkrqOar6l5OTo1tvxmaD1FTnS5srmzkTLBY7cJcaPmsgVKJRFBfs2bOHuXPn8vjjjyPl5cM8p0+fZuLEicycOZMPPvjAoAjrT25urm6JJj1dYLWKWg+dAQQEwC23AMxm1659usSjuEYlGkWpo6KiIh566CGklBw9epT9+/eXPxcXF8fw4cM5evQoHTt25NtvvzUw0vqRm5tLQECALm3VpbS5snvuMQEd2LDBid04FbdTiUZR6ugvf/kLx44d4z//+Q9eXl589tlnAFy6dIn777+fDh06EB8fz5w5c9i2bVv5ZHlTlZOT02ASzU03gY/PBY4dG4LdXrc2FP2oRKModbBv3z7efPNN7r77bqZPn86kSZP48ssvKSkpYdGiRWRlZfHPf/6THj16MGXKFOx2O2vXrjU6bLfSN9EILBZZ48ma12KxwLBhp7HZJnDkyHFdYlLqTiUaRamDzz//HE9PT1566SUAZs6cSW5uLkuXLuWNN97g5ptvJjY2FoDrrruOoKCgJj18VlhYSEFBgW6JJinJRFCQxGKpexvDhrUCPFm/XlWeGc3QRCOECBJCfCWEOC+EuCCEWCaEcGq1lxAiWAjxsRAiVQhRIIQ4LoT4kxDCz91xK8qGDRsYOnQorctWE44bN46OHTvyxBNPcOHCBV588cXy1wohmDRpEhs3buTSpUtGhexWubm5gH5raJKT61baXNnw4YEAbNuWqUdIigsMSzRCCF9gI9AbuAuYA/QENtWULMqeXw+MBF4AJgH/Bp4Emn55j2Ko06dPc/z48cu2WrFYLMyYMYOSkhJmzJhBRETEZfdMnjyZoqIiNmzYUN/h1gvH/JOeQ2d1KW2urGdPMwAHD/6sR0iKC1zomLrsV0B3IFxKeRJACHEQOAE8CLxazb3D0JLSBCml4yi9TUKItsBTQghfKWWB+0JXmjNHshg3btxl1++//37279/PCy+8cNU9Q4cOpW3btnz77bfcotXeNil6JpoLFyAnp/a7Alypa1cwmawkJ5ux2+2YTGqmwChG/pe/BdjhSDIAUsokYBswtYZ7HUf3Xbjiej7a1yT0ClJRrrRhwwYCAwPp3bv3Zde7devG6tWrq9zry2KxMGXKFFasWHHNxZ2NmWPoTI9EU3E8gGs9GrMZ2re/RElJV06ePFnzDYrbGJlo+gKHqrh+GIio4npl69F6Pn8TQkQIIVoIIcYC84B/SSmb5kC4Yjir1UpcXBzjxo1DiNr9PbNgwQK6dOnCHXfcwalTp9wUoTH03OfM1dLmysLCBNBd7eRsMCMTTVsgr4rruYB/dTdKKYuA4WjxHwZ+BjYAq4DH9A1TUSrs2bOH8+fPXzVs5oyAgAC++uor7HY7v/zlL5vUuhrH1+LvX+2PrlNSUrQEHhzseqKJivIDuqutaAxm9KBlVYOwNf6ZKITwBpYCHdCKCEYBvwVuB96u5r4HhBAJQoiE7OzsukWsNGvr16/HZDIxevToOt3fo0cPPv/8c1JTU/n1r3991bY1jVVOTg5t2rTRZUPNtDQTfn4SHXIWPXqYgbbs2KFKnI1kZKLJQ+vVXMmfqns6ld0HjAZullJ+KqXcLKV8Ba3q7CEhRP+qbpJSvieljJFSxrRv396F0JXmasOGDURHR7s0RDRkyBBefPFFVq1axZIlS3SMzjh67nOWkSEIDLRTy5HJKnXvrj3u33++yST1xsjIRHMYbZ7mShHAkRrujQTypJSJV1zfVfbYx8XYFOUqVquV/fv3M2LECJfbevTRRxk6dCjz588nLS1Nh+iMpeeuAGlpJrp21ScphIVpjxcvdiAx8cpfF0p9MTLRrASuF0J0d1wQQoSilS6vrOHeM4C/EKLHFddjyx7TdYpRUcqdPn0aq9VKmOO3lwvMZjOLFi3CZrPx6KOP6hCdsfTv0eiTaLp1c/wrTBUEGMjIRPM+kAx8I4SYKoS4BfgGOA2863iRECJECGEVQrxY6d6P0AoA1ggh7hJCjBFC/BZ4BdiDViKtKLpKTk4GtDJmPXTr1o2nnnqKTZs2kZ7euP820qtHY7XCmTOCLl302QizZUto315iMvVk9+7durSp1J5hiaasBHkscBz4L7AYSALGSikvVnqpAMxUilVKmQxcD+wH/gSsQVsA+h5wg5RSbdeq6C4pKQnQL9EAjBo1CoCEhATd2jSCXkcEnDkjsNtFnTfTrEpYmKBlyyi2b9+uW5tK7Ri5MwBSylRgeg2vSaaKSjQp5RFghnsiU5SrJSUl4enpSWBgoG5tRkZG4unpSUJCAlOn1rROuWEqKCjQbUPN9HTtR12vHg1oBQFHj2pDZ0VFRXh7e+vWtuIco8ubFaXRSEpKIiQkRNetTLy8vIiKimrUwzp6bqiZnq79t9WrGAC0RPPzz/6UlNgbfc+xsVKJRlGclJycrOuwmcOgQYPYv38/VqtV97brg577nDl6NIGB+vVowsLAbhdAMNu2qelbI6hEoyhOkFKSlJTklkQTExNDQUEBR47UVNXfMOm5z1l6uokWLSRlpy/owrGWpmvXUSrRGEQlGkVxQk5ODj///LPbEg3QaIfP9O7R6LVY08GRaIKDx7Bt2zZ1tLMBVKJRFCc4NsF0R6IJDQ2lXbt2jXb+QN9EY9K14gwgMBC8vaFFiwHk5uZy7Jjajqa+qUSjKE7Qew1NZUIIYmJiGn2iadOmjcttpafrW9oMYDJB375w6ZL2/04Nn9U/lWgUxQmONTQhISG6tLdzp4n8/IrPY2JiOHbsGPmVLzYSubm5tGnTBovFtdUSpaX6LtasLCoKTp70pX379irRGEAlGkVxQlJSEoGBgfj4+LjcVnKy4IYb/PjFL3wpLNSuDRo0CKBRbmev164AZ84IpNS/RwNaojl7VjBw4M1s3bpV9/aV6qlEoyhO0LPi7LvvtL/89+wx88gj3kgJ0dHRCCEa5fCZXrsCZGTov1jTISpKewwKupmTJ0+SlZWl+3so16YSjaI4Qc81NGvXWujVy8aCBcV8/bUHCxd60rp1a0JCQhpliXNOTo4uizXT0rRfR+7o0URGao+enlrPsbFW+DVWKtEoSg0KCwvJzMzUJdFcuABbt5qZONHGE0+UMGNGKQsXepKZKejZs2ejO9teSklmZibt2rVzuS139mjat4fOnSEvrytms5ldu3bVfJOiG5VoFKUGjoqz0NBQl9vasMFCaalg4kQrQsD8+SVIKVixwlKeaBrTOo+DBw+SnZ3NkCFDXG4rLU1brNmqlQ6BVaF/fzhyxIN+/fqxc+dO97yJUiWVaBSlBnru2vzddxb8/SWDB9sA6NXLTr9+NpYt86Bnz54UFBSQkZHh8vvUl9WrVyOE4KabbnK5rYwMreJMz8WalUVFwZEjEBMzhF27dqkTN+uRSjSKUgO9Eo3NBuvWmbnxRiuVK4FvvdXKzp1mWrfuB8CJEydcep/6tGbNGmJjY7nW0ehnzwpmz/Yu38OsOmlpJt0OPKtKVBSUlEBQ0Hjy8vLUiZv1SCUaRalBRkYGvr6+Lk9479plJjfXxMSJl2+eeeutpQD89JNWGtVY5mlSU1M5ePAgkyZNuuZrXnvNk5UrPViyxKPG9jIyBF27um/Y0FF55uWlFQSoeZr6oxKNotQgKyuLDh06IFwc01m3zozFIhk37vJE0727ZMAAG+vXB9CiRYtG06NZs2YNADfffHOVz587J/jwQ4+y11a/mHPHDjOZmSZ69nRfjyY8HDw8IDe3K76+virR1COVaBSlBtnZ2bpUVf30k4mePe1V7kx8662l7N1rJihoVKNJNN999x29evWiZ8+eVT7/zjseFBXB7beXkpBg5syZqhN1URE8+qgXwcF27r+/xG3xenpCnz5w6JCJgQMHqkRTj1SiUZQanDt37ppzELWRlmYiKKjqv9inTdN6OWbzHY1i7iA/P58tW7ZcszeTnw/vvefJ1KlWfvMbLXmsXVt1r2bhQk9OnDDz5ptFtGjhtpABrfLs4EEYPHgwe/fupbS01L1vqAAq0ShKjbKzs3VJNKdPC4KCqp6DCAmRhIbasdv7kZKSQlFRkcvv507r16/HarVec37m/fc9uXBB8OSTJURE2AkJsbN69dWJZt8+E2+84cncuSWMHWtzd9j07w/p6dqRAcXFxRw8eNDt76moRKMo1ZJSkp2dTYcOHVxq59IlyM01VXtEcVCQnZKSzkgpy48laKg2btxImzZtys/SqezoUROvvOLJxIlW+vfXypUnTrQSF2fm0qXLX/vKK560aSP505+K6yXuO+7QjgzYtGkUoAoC6otKNIpSjby8PKxWq8tzNOnp2o9adVVVQUGS8+e1rfYb+jzNli1bGD58OGaz+bLrly7BXXd506KF5I03KnplkyZZKS4WbNpU0avJydGG02bOtKLDCQNO6dIFfvMbWLGiBf7+Y9m+fXv9vHEzpxKNolTj3LlzAC4PnZ0+rU2EX2uORnvOzrlznoBHgy5xTklJISUlhREjRlz13G9/682xYyb+/e8iOnWq+FqHDrXRurW8bPjs6689KC0VzJxZv/MkTz8N/v7g4/MaqxEe84EAACAASURBVFatoqTEfQUIikYlGkWpRnZ2NuB6onFsGFldjyY42I6Ugvbtoxt0j8axzf7IkSMvu75smYVPP/Xgt78tYcyYy+dbPDy0Xs2yZRYSE7Wku2SJB/362YiMrN8td9q0geefh4yMKPLzB7Bp06Z6ff/mSCUaRamGXonm9GmBySTp3Lm6Ho32XOfO1zfoRLN582YCAgLo06dP+bW8PPjtb70YMMDGM89U3UN48cViPDzg17/Wej179pjrvTfj8Oij0KmTxGL5NV999ZUhMTQnKtEoSjUc55a4WgyQlmaic2eJRzUL5B0Vaa1bRzXYoTMpJVu2bGHEiBGYTBW/Pl54wYvcXMFbbxVxrYM2AwMlf/lLMVu3Wpg92xuTSTJjhrXqF7uZtzcMHSrw8bme5cuXY7UaE0dzoRKNolQjOzsbIYTL28+kpYlqK86A8uc9PXuSl5fH448/zsqVKykoKHDpvfWUlJREWloaffpM4aWXPPnmGwvffGPhk088+fWvS4iKqn4YbM6cUsaMsXLsmJlx42x07GjcxpaRkXDxYidycgqIj483LI7mQCUaRanGuXPnCAgIuKq6qrZOnzbVuI+Xlxd06mSnVatIJk+ezNdff83s2bN57LHHXHpvPW3ZsgWwsGzZ7bz8shdz5vgwZ44PoaH2aw6ZVSYEvPVWEd2723noIWMn4SMjQUqBt/dANXzmZoYmGiFEkBDiKyHEeSHEBSHEMiFEcC3u7yOE+FIIcU4IUSiEOCaEmOfOmJXmRY/FmnY7pKdfe7FmZUFBktzcFnz22WckJydzww03cODAAZfeX0+bN2/Gz+/PHDvmx4cfFrJx4yVeeaWIzz8vxNfXuTaCgyX791/ihhvcv0CzOo5TNyMj72TZsmXYbMbG05QZlmiEEL7ARqA3cBcwB+gJbBJC+DlxfwywE/AC7gduBv4BuPanp6JUokeiyc4WlJTUPHQG2jxNaqr2Y+nh4UH//v05depUgyjBtdlsbNyYT0HB/zFjRinTp1uJibHzwAOlREQ0nsPaHMLCwMcHOnQYS1ZWFjt27DA6pCbLyB7Nr4DuwDQp5Qop5TfALUAI8GB1NwohTMDHwAYp5S1l92+SUr4npXzV7ZErzUZWVpaOa2hq/mUcHGwnPV3gOGQzPDwcm81W7zsFFBfD4497ceJExUaYn3zyKTk5L9O6dQkvv9ywt8hxhtkMERFw8aJ2zlBcXJyxATVhRiaaW4AdUsry8hopZRKwDZhaw72jgQhAJRXFrfTYUNOxhqa6xZoOQUGSkhLB2bPaL/jw8HAAjh075lIMtbVxo5mPPvLkjTc8Abhw4QIvvrgR6M/f/y7w96/XcNwmMhJ++smTqKgolWjcyMhE0xc4VMX1w2hJpDrDyx69hRA7hBClQogsIcSbQggfXaNUmq3i4mLOnz+vQ6LRkoYzh3o5ej2pqdo9ji346zvROHZaXrbMg0uX4JVXXuH8+Wn4+VmZOrXplAJHRsLZszB48CS2bdvWIIYomyIjE01bIK+K67lATX8vBZY9LgXWATcAf0ebq/lMrwCV5k2/7WdMtGwpqzyH5krBwbL8HgA/Pz+Cg4P56aefXIqhNqTUEk1oqJ2LFwX//nceb7/9X8zm27n9djs+TehPOUdBQFDQRAoLC9m9e7exATVRTiUaIcQMIUSQG96/qrEEZ44xdMT9qZTyRSllnJTyFeAPwDQhRJU9IiHEA0KIBCFEgmPFt6Jci2Oxph49mq5dtV2Ma+Lo0TgSDUCvXr04fvy4SzHUxoEDJjIzTTz9dDHdutn517+KkHI6NpsXs2Y1rfNbHInGYokG1DyNuzjbo1kClO+gJ4RoJYTYLoQY6MJ756H1aq7kT9U9ncpyyh5/uOL6urLH66q6qaxYIEZKGaPH+SJK06bnPmfOVJwBtGwJbdrI8qEzgN69e3PixAns9vqp7PruOwtCSCZMsDFrVinp6b0wm5+hVy8bMTGNr7qsOh07Qrt2cOqUn5qncSNnE82Vf4t5ANcDTgwGXNNhtHmaK0UAR5y4F67uETnibFo/DYoh9NznzJmKM4fgYPtlPZrw8HAKCwtJTU11KQ5nrV1rYdAgO+3aSe68sxSwU1zcjVmzrE71yhoTIbRezf/+B6NHj1bzNG5i5BzNSuB6IUR3xwUhRCgwrOy56nwHFAM3XXF9Qtljgj4hKs2ZHnM0hYVw7pzzPRrQhs8cJdFQv5VnmZmCffvMTJyoTfh37FgCbEAIO7ff3rSGzRwiI+HQIRg5crSap3ETIxPN+0Ay8I0QYqoQ4hbgG+A08K7jRUKIECGEVQjxouOalDIH+CvwkBDiL0KI8UKIZ4AXgY8rl0wrSl1lZ2fj4+ODn1+N64evKSWl5uMBrhQUJDl92oQsy029evUC6ifRfP+9Vm12001aoklJSQF+zX33rScw0Lh9ydwpMhIKCiAoaDSg5mncwbBEI6W8BIwFjgP/BRYDScBYKeXFSi8VaKv9r4z1j8B8YAawBngYeBltIaiiuCwrK4sOHTogXBgv2rtX+7a97rraDZ1dvCjIzdU+b9u2Le3bt6+XRBMXZ6ZrV3v5Sv/ExETgGDNmNLExs0ocx+ps3+5PVFQUP/xw5dSv4qprbOhdpblCiOvL/u2NNj/ymBBiWhWvlVLKGvcck1KmAtNreE0yVVSiSSkl2oJNtWhTcYvs7GyXj3DevdtMq1aSXr2cTzR9+2qv3bPHzI03avtvhYeH10uiOXXKRO/eFRVyWqKBsLAwt7+3UXr1guuug6VL4bbbbuOFF17g5MmT9OjRw+jQmoza9GhuBB4r+7gf7Zf/tErXrvxQlEZNj10BEhLMDBxow1SLn7Trr7fh5SWJi6v4OzA8PJzjx48jpXuHr1JTBSEhFUnx1KlTtGrVyuWE29Ddfjvs2AE33vgrzGYz//73v40OqUlx9tu/Wy0/ulfdjKI0Hq5uqHnpEhw6ZCImpna7Avv4wJAhNjZtqtgfNjw8nPz8/PK1Pe5w8SLk5pou2yonMTGR7t27uzR82BjMmKE9xsd3ZMqUKXz44Yeq+kxHTiUaKWVKbT/cHbiiuJOU0uVEs3+/GZtNMGhQ7befHz3axuHD5vI9z/r21VYCbNu2rc7x1MRRUh0cXNGjcSSapq57dxg0SBs+e+CBB8jKyuKbb74xOqwmw9mdAToIITzdHYyiNBT5+fmUlpa6NGS0e7fWIxk0qPbLusaM0aq+4uK0NoYOHUpoaCj/+te/6hxPTRyLRB1rfkpKSkhNTW3S8zOV3X477NkD3bvfSEhICO+++27NNylOcXboLBP4peMTIYRPWVlx0/9TR2mWHIs1O3bsWOc2du820b27nYCA2s+rREXZ8fevmKcxm8089NBD7Nixg4QE9ywTc5yDExKixZuSkoLdbm8WPRqoGD776isz999/Pxs2bODkSbVSQg913RnAF3gaCNU1GkVpIM6ePQtAhw4d6nS/lLBrl7lOw2agnZUyerSVTZvM5etp5syZQ6tWrXj77bfr1GZNTp8WeHpKOnTQ3tBRcdZcqq+CgmDIEFixAubOnQvAqlWrDI6qaXBlHU3Tnh1UmjVHoqlrjyYtTXD2rKnOiQa0eZqMDBMnTmg/pi1btmTu3LmsWLGCtLS0Ord7LampWiGAo0LOcdhacxk6Axg/HvbuhTZtggkLC1OLN3Vi5M4AitJgOaq76tqjqZifqXuicczTbNxYUX320EMPIaV0y/xBaqrpqkKAVq1aERAQoPt7NVQjR4LdDtu3w6hRo9i8eXO9bWbalKlEoyhVyMrKwsPDA/86HiW5e7cZb29Jv351/yUVGioJDbUTH1+RaIKDg7nxxhvdMqSTmnr55p+JiYmEhYU1+dLmyoYMAYsFNm/WNtnMy8vjf//7n9FhNXq12RkgRgjhOCi8ZdnjcCFEm6peLKVc5lJkimIgZ7efKSqC997zICxMMmmS1gNJTRV89pkHQ4bY8PBwLY7hw22sXm3Bbqd8SKt///6sW7eOoqIivL29XXuDMkVFkJVlKj94DbShs+joaF3abyz8/CAmBuLj4aGHRgEQHx9P//79DY6scatNj2Ye8GXZxwdl1xZUuub4+KrsUVEarbNnz9Y4bLZunZnYWD9+9ztv7rzTm8WLLRQVwZw5Pths8I9/FFV7vzOGDrWSlyc4dqziR7V3797Y7XZdK6Icu0U7ejQFBQXNqrS5spEjYfduaNcumG7duql5Gh0426O5x61RKEoDk52dXW0hwKpVFu6804eePW188UUBixZ58vDDPnz4oY19+8wsWVJIjx6ubxczdKg2x7N9u5k+fbQk0Lt3bwCOHj1Kv379XH4PqCht7tSpiHfeeY8333wTu93O4MGDdWm/MRk5Ev7+d9i5U5un+fbbb7Hb7Zhqs4+QchmnEo2U8mN3B6IoDcnZs2eJioq65vMrV1oICLCzfXsBXl4wenQhs2f7sG6dhSeeKC4fRnNVt26STp3sbN9u5r77tPNgevTogdls5qefftLlPaBiV4D33/8dq1a9w/Dhw3nnnXcYO3asbu/RWAwfrh2Itnmzlmg++ugjDh8+TKTj3Gel1mozRwOAEGIoMAnoBbQCLgDHgNVSyh/1DU9R6p/dbic7O/uaQ2dSQny8mVGjbHh5ade8vWHx4kK2bDEzZkzdK82uJITWq/nxx4qCAC8vL7p3767rbs6pqQKLRRIX9xmzZs1i0aJFurXd2LRure3mHB8PH3wwGtDOqFGJpu6c7gsKIVoLIVYDW4Bn0bb3v6Hs8TlgqxBipRCiZTXNKEqDl5eXh9VqvWaiOXlSkJlpYtSoyxOKlxeMH2/DbK7ytjobMsRGWpqpfIsY0IbP9OzRpKaaCAgo5OLFfCZOnKhbu43VyJHw448QGBhKcHAw8fHxRofUqNVm0PFLYCKwDW3OZiDQs+zxHmA7MBlYqnOMilKvatoVwLEtzMiR+gyP1aTyPI1DeHg4iYmJFBcX6/Ie2q4AGZjNZkaNGqVLm43ZyJFaJd7u3TBmzBg2btxIaWnTPMq6Pji7qeYEYDzwDynlSCnlx1LKfVLKxLLHj6WUI9AOIZsghLjBnUErijs5Fmteqxhg82YzQUF2unevn6ONIyLstG4tLxs+6927NzabrXybGFelppq4ePEIsbGxtG7dWpc2G7MRI7THrVth6tSp5OXlqV6NC5zt0cwEUtCOTq7OfCAVuNOVoBTFSNX1aOx22LzZwqhRNuprHaPZDLGxNrZtq0g0ffr0AdBl+KykBDIzBXl5exk/frzL7TUF7dtDeLiWaCZMmICvry9fffWV0WE1Ws4mmoHAClnD8X5SSjuwAohxNTBFMYpj5+aqEs3Bgyby8kS9DZs5DBtm4/hxM+fOadmtR48emEwmXRJNerrAbhdACuPGjXO5vaZi+HDYtg28vX2ZNGkSy5cvx2bTr9CjOXE20XRBqyxzxjGga93CURTjnT17Fm9vb1q1anXVc5s3a72KKwsB3G34cC2xrV+vvb+Pjw+hoaG6JJq0NO3XQKtW59UK+EpGjIC8PDhyBKZPn05WVpZbD55rypxNNK2An5187c9Ai7qFoyjGq277mbg4C+HhNjp3rp/5GYeBA+106WJnxYqKFQl6VZ5lZmqPw4aFqkWJlQwfrj1u3Qo333wzXl5efP3118YG1Ug5+11lAmrzk6W+W5VG61rbz6SkCLZuNTN6dP0Pn5hMMG2alfXrLZw/r13r06cPJ0+edLkaat++MwBMmKB6M5V17w6dO8OWLdoRDRMmTGDZsmVqN+c6qM2CzZuFEJ2ceN3AugajKA1BVlYWwcHBl12TEv7v/7yxWGDevBJD4vrFL0p5+21P1qyxMHOmlfDwcKxWK6dOnSI8PLzO7R47dgEoZMSIa++E0BwJofVqtm7VPp8+fTorV65k9+7dxMbGGhtcI1ObRHMnzleT1e+4gqLoKCsri0GDBl12bflyCz/8YGHhwiK6djXm23vQIDtBQXaWL/dg5kxr+Z5nhw4dcinRpKVZgTN06xaqR5hNyvDh8OWXkJoKU6ZMAWDDhg0q0dSSs4lmjFujUJQGwmazce7cOdq3b19+LT8fnn7aiwEDbDz4oHGL9oSAqVOtvPuuB/n50LdvX1q2bMnmzZuZPn16ndvNyrLg45OPxdJOx2ibBsd6mm3bYOZMf7p06aLr1j/NhbObaqqVSkqzkJOTg91uv2yx5nvveZKVJfjii0Ldt5eprV/8opR//lMbPrvzTu1wrh9++AEpZZ0PKPv5Zz/atz+nc6RNQ2QktGypzdPMnKn/1j/NhZq0V5RKHIs1KyeaXbvM9O5tZ8AA4yeBY2K04bMVK7QT1W644QbS0tLq/MuvoKCA0tJ2dO6sZ5RNh8Winbrp2BTAkWhqWFKoXMHQRCOECBJCfCWEOC+EuCCEWCaECK75zqvaeVYIIYUQW90Rp9J8OLafcVSdSQn795u47jrjkwxow2fjx1vZscOMlJSv5F+/fn2d2jt0KBHwp1s3fU7qbIomTdLW0hw+rCWaCxculP9BojjHsEQjhPAFNgK9gbuAOWibdG4SQvjVop3uwPNAljviVJqXK7efycwUZGWZuO66hrMifMAAO/n5gqQkQdeuXenTpw8//PBDndratSsVgD59qjyRXQFuv13bBmjxYsqLLtTwWe0Y2aP5FdAdmCalXCGl/Aa4BQgBHqxFO4uAxcBR/UNUmpsrt5/Zv1/7EWkIw2YOAwZoSW/fPm3C6IYbbmD79u1cvHix1m3973/a3Ey/fgH6BdjEdOwIN96oJZpevbRKP5VoasfIRHMLsENKWX7wuZQyCe0YgqnONCCEuBOIRjsfR1FcdvbsWfz8/GjRQtvcYt8+MyaTJDKy4fRoIiLseHlJ9u6tSDQlJSVs2bKl1m0dP65t+NGli8FVDg3c7NlaiXNSUhf8/PxU5VktGZlo+gKHqrh+GIio6WYhhD/wGjBfSpmrc2xKM3X69Gk6V5oZ37/fTK9edvycHsx1Pw8PiIy0s2+f9uN7/fXX4+fnx7p162rdVmqqVq7dqZOa3K7O1Kng5weffWaiV69eqkdTS0YmmrZAXhXXcwF/J+5/GTgOfKRjTEozd/jwYSIiKv7OaUiFAJUNGGBj/34zdrt2tPOoUaPYsGFDrdooLi7m3DkLQtho104lmur4+cGtt8IXX0DPnpEq0dSS0eXNVX1317gYQAgxApgLPFzT0QVX3PeAECJBCJHgGItXFIeCggISExPp27cvoBUCnD3bsAoBHKKjbVy8KDh5UvsRHjt2LMnJySQlJTndRmJiIlJ2pHXrItRemjWbNQvOnwchJpGSkkJhYaHRITUaRn575aH1aq7kT9U9ncreBf4DpAkh2ggh2qAtPjWXfe5V1U1SyveklDFSypjKK78VBeDo0aNIKenXrx/QMAsBHBwx7d2rxTh69GgA4uLinG5D+6u8Mx07qt6MM8aNgw4dIDl5CFJKTpw4YXRIjYaRieYw2jzNlSKAIzXc2wd4CC0hOT6GAdeX/fth/cJUmovDhw8DlPdo9u0zI0TDKgRw6NXLjq+vLK8869mzJ4GBgbU6btiRaIKDPdwUZdNiscCMGbB/fxegpRo+qwUjE81K4PqydTAACCFC0RLGyhruHVPFxwG04oIxgDpzVeH0acHf/+6Js4ciHjp0CD8/P0JDQ4GKQoAWDfB0JYsFoqJs5QUBQghGjRpFfHy809vYHz9+HLO5K1261NOZ1E3AzJlQXGwCpqnKs1owMtG8DyQD3wghpgohbgG+AU6jDY0BIIQIEUJYhRAvOq5JKeOu/ADygfNln6fV61eiNEhffOHBn/7kVX4qZk0chQCOw78aaiGAw4ABdg4eNGMtO1V61KhR5OTkcOhQVcWcV/vpp5PYbAFq6KwWhgyBkBDw8blH9WhqwbBEI6W8BIxFqxz7L9qiyyRgrJSy8sozAZgxvnBBaWQSE7VvmS++qHloSErJoUOHyudnkpMFZ86YiI5ueMNmDgMG2CgoEBw/fvk8jTPDZ3a7ncTEnwGTKm2uBSHgjjugqGgEhw6dMTqcRsPQX95SylQp5XQpZSspZUsp5TQpZfIVr0mWUgop5YIa2hotpRzuzniVxuXUKW1IaOVKCzUVCGVmZpKXl1c+P7Nqlbax+U03Wd0aoysGDtSS4K5dWo8tMDCQXr16sWnTphrvzcjIoLhYW0WgEk3tzJwJUlo4eLAXXbp0ISIiguXLlxsdVoOmeglKk5WYaCI01M7PPwu+/776EzEcw02OHs2qVRb69bPRrVvD/SXco4ckMNDOxo0VQ4OjRo1i+/btlJRUfwpoYmIioC1M7dix4Q4PNkRRURAWVkK7di8QGrqQ3Nwp3H//s5x3nLGtXEUlGqVJ+vlnOHvWxOzZpXTsaOfLL6tPNI6Ksz59+pCdLfjxRzOTJzfc3gxowzhjx9qIi7OUz9OMGTOGgoICEhISqr23cqJRPZraEQIeecSTc+cC2b59DmfP/o3c3MdZuHCh0aE1WCrRKE1SUpL2rd2zp53p0618/72FvGpWZx06dIiuXbvi7+/PmjUWpBQNPtEAjBtnJT9fsGeP9vUOHz4cIUSN8zQnT57EYgkCoEMHlWhq6//+D/LyICMDxowBf//JvPbaa6SmphodWoOkEo3SJDkKAcLC7Nx2WyklJYI33vDk4EETFy5c/frDhw+Xz898+62FkBA7kZENf0hp9GgrQkg2bNB6bG3atCEiIoJdu3ZVe19iYiItW/YiIMCOp2d9RNr0tGkDnTvDqFGQnx+ElC15/vnnjQ6rQVKJRmmSTp3SvrW7dbMTHW0nIsLGq696MXy4H+HhLcrXn4C259fx48fp168fFy5AXJw2bFbHk5HrVUAAREfbyxMNQGxsLAkJCdWup0lMTMTLK1QNm+lgyBCQUvCLX/yVTz/9tFbbADUXKtEoTVJioomOHe20bKmNqW/YUEB8/CU++aQQT0946aWKXYqOHz+O1WolIiKC9estlJQIpkxp+MNmDuPHW9mzx1Q+NDho0CDOnz9/zQWFNput7Jeh2n5GD7Gx2vdYp063ArByZU3rzZsflWiUJunUKUFYWMVf9H5+2gLHadOs/OY3Jaxfb2HnTu3b/+DBgwBERfXnP//xoH17O7GxDXf9zJXGj7ditwvi4rReTWxsLAA7d+6s8vWpqamUlpZy6VJ7goMb/vBgQ9e6NfTtC8eOtSUiIkIlmiqoRKM0SYmJJrp3r/qv9QceKKF9ezt//rPWqzlw4AC+vr4kJPRmyxYLzz1XgrkRnQM2cKCd1q0lGzZoQYeFhREQEHDNeRqt4syXn3/2JSRE9Wj0MHQo/PgjTJkylc2bN5Ofn290SA2KSjRKk3PxolbaXLlHU5mfHzzxRAlxcRa2bjVz8OBBwsOH8fzzPgwebOOee0rrOWLXWCxaUcDGjRak1PY9Gzx48DV7NFqiCQUgJET1aPQwZIh2hEBU1AysVitr1641OqQGRSUapclxFAJ0737tX6L33VdKp052Zs/2ZvfuOeTmLuTCBcEbbzTOs1lGjrSRlmYiJUWrYIiNjeXEiRPk5ORc9drExES8vbUKO5Vo9DF0qPZ48WIUHTp0UMNnV2iEP1KKUr3Kpc3X4uMDS5cWEh19gdLSu0lJiebxx0vo27dx/uIdNkybU9q2TRs+Gzx4MAC7d+++6rUnT56kbduBAISGqqEzPfTsqVUA7txpYvLkyaxZs4bS0sbVM3YnlWiUJseZHg1oxQFz5qwEOrFw4SGef776bVsast697fj7S7Zv1xJNdHQ0ZrO5ynmaxMREfH0j8PWV6ghnnQihDZ9t3w5Tpkzh/PnzbNmyxeiwGgyVaJQmx1Ha7Mw5MgcPHsRiucR993XCoxGf/2UywdChVrZt0yrPfH19iYqKYsuWLXz22WfMmjWLN954g+Li4rLV690ICbE3irVCjcWQIfDTT9Cr1414eXnx+eefGx1Sg6ESjdLkXFnaXJ0DBw7Qu3dvvLyqPP27URk2zMapUyYyM7Xs4SgIeOihh9i+fTsvvPACkydPxmazUVjYWQ2b6WzWLEehiS/33HMv77//PqtWrTI6rAZBJRqlyamutLkyKSUHDhwgKiqqHqJyv6FDtXkax/DZgw8+yJNPPskPP/zAqVOnePnll9mzZw8AubmtVSGAzkJCYOFCWLcOBgx4nQEDBjBnzhxOnTpldGiGU4lGaVKKirTSZmd+iZ45c4bs7Owmk2iiouy0aCHLCwJ69OjB73//e2JjYxFC8OCDD7JmzRruuee3FBZaVKJxg0cegeHD4emnPVm0aAUA06dPJ6+6HV2bAZVolCbFMWzUpUvNv0QPHDgAQP/+/d0aU32xWCA21lbeo6nK9ddfz9y5vwdUxZk7mEzwn/9of/C8/XYwixcv5tChQ/Tt27dZD6OpRKM0KZmZ2rd0YGDNv0QdW89ERka6Nab6NGyYjSNHzOTkXHuWPyVF+2+kejTu0asXPPAAfP45DBx4Mzt37qRdu3ZMmTKF5557zujwDKESjdKkpKdrv2BrSjRSSrZt20a3bt1o1apVfYRWL4YPv3yepioq0bjfI49AaanWu4mOjiYhIYEZM2bw6quvNsthNJVolCbFMXQWGFj9L9HXX3+dTZs2MXv27PoIq94MGGCjXTs7L73kycWLVb8mJUUQEKDtbK24R3g4jBsH//oXWK3g6enJ/PnzKS4uZunSpUaHV+9UolGalPR0Ey1aSKrrpKxYsYLf//73TJ8+naeeeqr+gqsHXl7wn/8Ucfy4iUcf9UZW0bFLSjKpzTTrwaOPwunTsHq19nl0dDR9+/bl448/NjYwA6hEozQpmZmi2t7Mt99+ywMPPMDgwYNZtGgRogmuWBwzxsYf/lDM8uUevPnm1atQU1JMhIaqYTN3mzIFunaFt9/WPhdCcPfdd7Njx45rnhXUVKlEozQp6emmKudno2+1xAAAIABJREFUCgoK+M1vfsOsWbPo06cPS5Yswdvb24AI68fjj5cybVopCxZ4ceJERTK12eD0aaHmZ+qBxQIPPgg//ADff69dmzVrFiaTiU8++cTY4OqZSjRKk6L1aK5ONHfeeScffPAB8+bN44cffqB9+/YGRFd/hIBXXinGywsWLqzY9SAzU1BaKtTQWT155BGIjITJk+G//4XOnTszYcIEPvnkE2y2xnO4nqtUolGaDJut6qGzvLw8Nm3axFNPPcVLL72Ep6enQRHWrw4dJA8+WMJXX1k4elT7UVcVZ/WrbVvYsgVGjIC5c+Gtt+Duu+8mLS2NuLg4o8OrNyrRKE1GdrbAZru6R7Njxw6klIwdO9agyIzz+OMltGgBf/mLJ2lpguee88JkkvTurRJNfWndGr77DiZMgOeeg1GjJuPl5cVqR5VAM6ASjdJkVKyhufyX6NatW/Hy8iImJsaIsAwVEACPPFLCN994MHy4LydPmvj00yK6dFFDZ/XJywsWLNBOf12xwpcRI0bwvWPiphkwNNEIIYKEEF8JIc4LIS4IIZYJIYKduC9GCPGeEOInIUSBECJVCLFYCNGtPuJWGqaMjKp3Bdi6dSsxMTFNevK/Oo89VkJAgJ2AAMnGjQVMnmw1OiSXeHzwAR6NcDI9Nhb694dFi+DGGydw5MgRTp8+bXRY9cKwRCOE8AU2Ar2Bu4A5QE9gkxDCr4bb7wD6Am8CE4FngGggQQgR5LaglQYtI+PqXQHOnz/PgQMHGDZsmFFhGa51a0hIKGDbtgLCwxv5kFlODl7PPIPXM8/AhQtGR1MrQsDDD8OBAxAY+AsA1q1bZ3BU9cPIHs2vgO7ANCnlCinlN8AtQAjwYA33/k1KOUxK+Y6UMl5K+RlwE+Bf1q7SDGVkCDw8Lj81cseOHdjtdkaMGGFgZMYLCJA0hQ6d50cfIYqKEBcv4rFkidHh1Nqdd0KLFvDDD93p0qVLsxk+MzLR3ALskFKedFyQUiYB24Cp1d0opcyu4loKkA100TlOpZHIyDDRubPEVOm7etu2bXh4eDBo0CDjAlP0UVqKx/vvYx0zBtvAgXi8/z5Vbn3QgLVsCbNnw9KlglGjfsH69euxWhv3UKYzjEw0fYFDVVw/DETUtjEhRB+gA3DUxbiURioj4+rS5q1btzJw4EB8fX0NikrRi+WbbzBlZFDy8MOU/OpXmI8fxxwfb3RYtfbgg9oxAj4+d5GXl8fu3buNDsntjEw0bYGqtjHNRRsCc5oQwgL8C61H8x/XQ1Mao4yMy3cFuHjxIvv27WP48OEGRqXoxfOdd7CHhWG78Uast96KPSBA69U0Mv37Q1gYpKREIYRoFsNnRpc3V9XvrcvmU/8EhgKzpZTX3INbCPGAECJBCJGQnX3V6JvSiEnp6NFUfEvt3LkTm83WrAsBmgrTzp2YExIoefhh7XQxb29K77oLy+rVmLduNTq8WhECbrkFNm/2JDp6JMuWLePSpUtGh+VWRiaaPLRezZX8qbqnUyUhxF+BB4B7pZTVlnBIKd+TUsZIKWOa+hYkzU1+PhQWXj50tmPHDkwmE7GxsQZGpujB8623/r+9846Oqlr78LNnMqkQlR7p0kE60qRIpN4AoiBNIyABARGighSVzhUR9RMRpYk0g/Su0kSU4iUEAqFIEULEAAEJIXWSyf7+2AkkIZA6mRnYz1pZSU7Z551Zc+Z39ts28vHHSezb9862xEGDkCVL4v6f/+DWvTvGU47jNe/aFcxmaN58EiEhITRt2pQzZ87Y2iyrYUuhOYGK02SkJnAyOwMIId5HpTaPlFIuy0fbNA5GZjU0gYGB1KxZk0KFCtnKLE0+IM6dw2nzZsx+fiplKwVZujQxQUEkTJmCMTAQz969Idkx0reffRaeeAKiop7jxx9/JDw8nEaNGvHOO++wdetWou+3mJCDYkuh2QQ0FUI8lbpBCFEBeDZl3wMRQowApgHvSym/tJKNGgchYw2NlJLDhw8/kt0AHjac58wBZ2cS38ik6sHDA7O/P/EzZ2L85x9wkMC6yQT/+Q9s2QJt23YgKCiI1q1bM3fuXDp37kyVKlV4mNz7thSaBcBFYKMQ4gUhRFdgIxAGzEs9SAhRXgiRJISYkGZbb+D/gJ+A3UKIpml+cpyxpnF87s5o1BPtuXPniIyM1ELjiERHY9y2DeLiEBERmFasILFPH2TJkvc9JaldO6TRCJuyfEa1G7p2hRs34MABKFeuHJs3b+bmzZts3LiRiIgIJk6caGsT8w2bCY2UMgbwBs4Ay4AVwAXAW0qZdt4oACPpbe2Ysr0jcCDDz1yrG6+xO1JnNKVKqRlNYGAggBYaB8Rl+nTce/fGo0YNXF99FcxmzG+99eCTihQhsVkz2LixYIzMBzp2VDObtNro5uZG165dGTp0KPPmzSMkJLMKEMfDpllnUspLUsruUkpPKWVhKWU3KeXFDMdclFIKKeWkNNv6p2zL7Oe5An4ZGjvgyhVB8eLJpK4AEBgYSKFChahWrZptDdPkjJgYTMuXk9SyJZbmzTH+8QdJL7yArFIly1PNHTrAiRNw/nwBGJp3PD2hTRvYsOHeutNJkybh6enJu+++i3SwotTMsHV6s0aTL4SHq64AqQQGBtKgQQOMRqMNrcoCKRGhoYgLF2xtid1gWr0acesW5g8+IP7774k5c4b4b77J1rnmTp3UHw7kPuvRA86ehaCg9NuLFi3KxIkT2b59O1u2bLGNcfmIFhrNQ8GVK+KO2yw+Pp6QkBD7c5tZLBh/+w3nadNw69iRQmXLUqh2bTyaNoXYWFtbV7Bk1nZFSkzz52OpXRtL06ZqU4kSkM2uDsnly6vlLB3IfdajBzg7w/Ll9+4bNmwYTz/9NL6+vgQHBxe8cfmIFhrNQ0F4uMDLSyUCBAcHk5iYaHdC4zJpEu4+PjjPmoWIjyexVy/MAwci4uIwPCS++OwgLl/Go0oVnD/9NN1244EDGENCSBw0SFU15oauXeH331WU3QF44gnw8YGVK+/VXmdnZ7Zu3UrhwoXp2LEjf/31l22MzAe00OSGh8Bn+jCRlATXrglKlrTjRAApcVqzhiRvb6JDQ4nds4eETz/F/PbbABiPHbOxgQWHadkyDDdu4DJ5Mk6bN6uNUmKaN08VZb78cu4Hf+EFtab39OkOU1Pzyitw5Qrs3n3vvnLlyvHzzz+TkJBAhw4dHLaDgBaanJCUxL993+Ta+P+ztSWaNERECKQUd2I0gYGBlClThlKlStnYsrsYTp/GcPkySd26qQViUpBlyyIffxzDoyI0FgumZctIevZZLI0a4Tp4ME7ff4+bjw+m9etJ7NcPPLJajuoBNGoEgwbB558rv5QDFD76+KiPxIoV6v+LF2Hnzrv7a9asSUBAAOfOnWP9+vU2sTGvaKHJAYkWA//bEE7RGaMwb9uZ9QmaAiE8XLlZUl1n9lioadyxA4Cktm3T7xACS926GB3cB59djHv2YAgLI9HPj7jvv0d6euI2ZAiGM2eInzmThA8/zNsFhIB585TQbNyo0roslvwx3kq4uipNXLcOZsyAmjWhXTs4maY/Svv27alYsSJLHXBlUdBCkyNMLgYs3y7hFDVI7N4LHNhn+jBx5crdGprr169z8eJFGjZsaGOr0uO0cyeWGjWQZcrcsy+5Th0MJ09CYqINLCtYTEuXklykCEmdOyNLlSJu0ybiP/+cmOBgEocM4U5+el4QAvz9YcECCAwEB+iO/MoravI1bhx4e4OLC3yZpt+JEAJfX1927tzJ5cuXbWdoLtFCk0N8ehdmZe+NmOOTiW77Aty6ZWuTHnnCw9XH2MtLtZ0BO4vPREdj3L8fS7t2me621KmDSEjA8BA3VQQQ16/jtGULSX36qG9SILlaNRIHDsybu+x+vPoqlCoFc+2/hrt1a3jvPVizBjZvVitxLl0KN9O0F/b19UVKyYpUH5sDoYUmF4xbWIlRZX7A5cJpklp7w/XrtjbpkSY8XCCEpHhxSVBQEAaDgbp169rarDsY9+5FmM33us1SSE6x1WBv7rOEhHwZRly9inHHDlzGj0ckJpL42mv5Mm6WODuDnx9s26YCH3aMwQAffwzdu6sJ2YgRKuP922/vHlO5cmWaN2/OkiVLHK6IUwtNLvDwgDfWtqcbG5AnTqrHEQeczj4sXL0qKFFC4uSk4jPVq1e3q47NTjt2ID08sDRrlun+5CpVkG5udpV5Zjx4kEIVK+KUh+Cz4c8/ce3fn0JVquDevTumlStJ7N6d5Bo18tHSLBg8+G7cxoGoVw9atYI5c9KHmHx9fTl58iRHjhyxnXG5QAtNLmncGMxtfej92E/IS5fUhl277h5w4YKqwpo5U82JdTzHaqR2BUjt2GxX8Rkpcdq5k6TWre+4i+7BaCS5Vi37yTy7cQPX119HREdjmj8/V0M4f/IJ7k2a4PTzzyS88w6xP/7I7dBQ4hcvzmdjs6BsWVVbs3Bhvs3QCoqRI9VEbNQoWLYMjhyBnj174uzszOTJk7nlQG57LTR54J13YN2N1mwd+7tqXNS2rVoQvH17eOop8PWFMWPgk0/Uj8YqpHYFCA0N5caNG3YlNMY9ezCEhmK5j9ssFUvduhiPH7d9jZaUuA0bhrh6lcSXXsJp376ct8iJicH500+xtG1LzPHjmCdNwpK6AIstGDpUubfXrLHN9XNJ167QpAn83//Ba69BgwZw+nQRJkyYwObNm6lWrRrLly93CDeaFpo80KED1KgBE9bWRQYeVh/o+fPhzz9h8mQICYGoKHjxRbXwhAN8IByR1K4AqYkADRo0sI0hCQk4bd0K8fEAiIgIXAcPxlK1Kol9+jzw1OQ6dRC3biFsHEswLViA048/kjB1KgnTpiGFwBQQkKMxnH78EREbi/ntt5HFilnJ0hzQti1UqaL8UA6Ek5NaQuDmTZXqXKwYTJsG77//PocOHaJ8+fL4+vo6RHKAFpo8YDDA22+rKe2vh9yRX83FHHZVuckmTIBataBwYejSBf7+G+wt2PsQkJgIEREGSpZUiQAuLi7UqpXZwq1WJjkZ1yFDcOvTB/dWrTAEBuI6aBDi1i3iv/suy6wqS506gO07BJgWLiSpaVMShw5FlimD5bnnMK1cmaMqe6e1a0n28rpvTKrAMRhg+HA4eNBhFkZLRQh4/HH1QPvOO/Djj3D4MDRs2JD9+/fTuHFjRo0aRWRkpK1NfSBaaPLIq69C8eJqdmMygWu5EqzbmKFjsI+P+sSkttvQ5BvXrqUWa6r4TN26dTGZTAVuh/OUKZjWrsXcrx8iKgoPb2+cdu8m4eOPSX766SzPT65VC2k04jJuHG49euAybhzi2rUCsPwuIjQU4+nTJHXteqfXWGLfvhguXsS4f3/2BomMxGnHDpJeekl9wdsL/furZaC/dNzFeN98U4nOtGnqf6PRyNy5c7l27ZrdL5JmR58Ex8TNDRYvVsktY8dC9eqqVixdM94SJZSzVQtNvpPaFaBEiSSOHj1aYPEZcfEiLqNH4zJ2LC4jRuDy2WeYBw4kYfZsYg4cwDxgAOZhw0js3z97A7q6kvDf/5Jcuzbi6lVM8+fj3rgxTqtXF5jL1Sm1e0GHDne2JXXpgixcGNP332dvjK1bEWYzid27W8XGXOPpCQMGqO6VV67Y2ppc4empEgQ2bIDjx9W2hg0bMmTIEObMmWPXHZ610OQDPj7qQWnaNPjmGwgLU8lm6ejSRU3bw8NtYuPDypUr6iMcH/8XsbGxBROfiYvDrW9fTN9+i2npUpy/+47EF18k4ZNP1EzgiSdI+OILEmbMyFEX4sShQ4n74Qdif/uN2P37kU89hdvAgbgOGgRmsxVfkMJp+3aSK1RAVq58d6O7O4ndu+O0Zg2GU6fubr95E+Mvv9wzhmnNGpIrVCDZjhIy7jB8uPK15jKTzh4YMUJNzHr3hu3b1TPI9OnTKVKkCA0bNsTT05OyZcuy0c6WStBCk8+0agU9e6riq0uX4N9/1UTm9nNd1AFbt9rWwIeM1BnNP/+ojs0FMaNxGT8eY0gIcd9/T/Q//3A7MpL4JUtU9DafSK5WjdgdO0h4/31Mq1bh1qsXWLNzb3w8xl9/Jal9+3vE0fz++8jChXF9/XWIi4N//8Xdxwf3F17AlKbqXly/jnHPHjWbyW2bf2tStapaP/nrrx0u1TmVIkXghx+Ux6RDB5XgajA8wc8//8x7772Hn58fRYsWpXfv3uzbt8/W5t4h/+4MzR0++USJS+PGEBGh4qgtnn2avWXLITZvVtXKmnzhyhWBwSA5dWovjz/+OJUqVbLq9ZzWrcN50SLMI0diSXUxWSsWYTRiHjMG6eWFy4gRuHfuTGKvXiRXrKiyuZycwM2N5CpV8vzFbvz9d0RcnBKaDMiSJYn/+mvce/TAZdQojCEhGM6cIalpU1zGjUOWLUtylSpKiJKTScpLm39rM2qUykKbO1dl8jgg//kPnD4NX30F776rXPf+/g3uzOavX79O8+bN6dKlC/v376d69eo2thiEI+RgW4NGjRrJ1HVLrMFXX8H336vPtKen+nxvr/YWbUMXIgIDVUZaKrGx2V5F0FG5fv06LvcrWMwDb77pws6dThQqVJ1KlSqxatWqfL/GHZKT8ahUCVmhArHbt6vsjwLCadMmXIcPR2SSXRT31Vck+frmaXyXMWMwLV5MdGioCjxmdsz48TjPmYN0ciJuxQosrVvj3qULhuPHQQikhwfxX399V4ALmISEBIplJ526Qwflxj5/3na1PflE48bKq3r0aPrtf/31F82aNaNQoUIEBwfnd6eMHD/VaNeZlXjzTdi3T5XTvPuu+v36n+8RbXpCTd8vX4bbt5WztVgxOHfO1iY7JOHhBooVS+Ts2bM0s3I6rbhwAcONGyrAX8CZbUlduxIdGkr0uXPE7NhB7A8/EBcQgKVWLZy//DLPCQNO27djadnyviIDkDBxIuYBA5TIdOoE7u7E/fADyZUqYWnZktgDB2wmMjli5kyIjISPPrK1JXmmf39VNZFRaJ566inWrl3LhQsXGDNmjE1sS4sWmgLiww+hVd+ytLz9I0n/3lJi88wzsHq1eiRxsF5M9sKVKwJn5wgAqwtNao1Las1LgSMEskQJkps0wdKpE0k+Ppjfegvj6dOZBuazPey5cxjOn8/UbZYOFxcSvvhCiUwKslgxYvfvJ27NGmTJkrm2oUCpW1eV2s+eDaGhtrYmT/TurXqHfved+l9KtWjavn3w9NMt8Pf3Z+7cufyS8vmIjo7mZxssm6CFpoAQQiW7xFWty6tu65CnT6slBnbvVp0DFi++U1GeKeHhanWktKshaQgPF5jNF3FxcaF+/fpWvZbh2DGkkxPJNWta9To5Ial7d5JLlMA5D63wTZs2qbE6dszdAPYY+M+KqVOV3R98YGtL8kSRImr16hUrVH7DiBFq0bQWLZRX8MiRT6hcuRqvv/46I0eOpHTp0vj4+BBewNmvWmhySFJSUq6rcD08VNxm7a22vOMdjDweojo/v/EG3LihltgDlT0QGHi3GttiUQtUrF2re6alwWyGGzcM3LhxggYNGlglBpQWY3Cw6jxs5evkCBcXEgcOxGn7dsTZs7kawmndOiyNGiHLl89n4+yYsmVVUcqKFQ7fsaN/f9XKzdtbddkZOVJ1vBoxAvbsMdKv33pCQ0P55ptv6NKlC3v37i3wZc610OQAi8VCgwYNeDsP2SoNG6p6m//bXpPnexalZ0/4YLc3slJlVYRjsaistGeeUe61q1dhyhTYs0f1a1qzxrpprg5EWJh6kr569ZDV3WZIiSE4mGRbuc0eQOLAgUhnZ1xmzFC1LtHR2T5XnD2L8dgxEl96yYoW2iljxsBjj6llLR2Y9u3V+m7796t48Oefq9q+zz5TXxnr19cgMPAwYWFhLF++nObNmyMKeBaqhSYHGI1GvL29Wb58OaF58O2OGqWSBaKi1MPU9I8MHKg9GH77TeUuLl6s3GS//QZPP62m+f36waJF6kskdebziHP2rPr4WiynaNKkiVWvJa5cwRARYbv4zAOQJUqQ6OuLafVqPJo0oVDp0piy2Y7flPJZSnrxRWuaaJ888QSMH68aiO3Zo27IyZNVu2QHysZ1clKlQbNnK4dHqoYYjapbSVAQRETUp0SJEjazUac355CwsDAqVarEG2+8wZcpfZOuX7/OkSNHMBgMFC5cmGeeeSbbTwxSwnPPwY3TERyPLIMwm+G//1VPWSEhKtpnNKrHFXd3qFwZKlZUET8HwhrpzXPmmBg/3hUoxsWLhylSpEi+jp8W408/4d6zJ7E//YSleXOrXSfXWCwYAgMxXLqEacECjKdOEXP0KLJo0Qee5t60KfKxx4izQYA4v8l2enNa4uJUIaerq4qZRqjEEiZPVo1x78eff6p7cNgwu45Rmc1QqZJateTXX/NtWMdKbxZClBVCrBFC3BJCRAkh1gkhymXzXFchxCdCiHAhRJwQ4oAQopW1bS5btiy+vr4sXLiQa9eucf78eerUqUP79u1p27YtTZo0yVGDOyFg+nQ4ca04P3eeo9JHUqfyTz8Nx46peI2Hhzr4tddUAkFYWPqBDhxQ7QgeoTTps2cNmExR1KhRIkuRMe7dm76FSg65k3GWjQaZNsFoJLlJE5JefpmE2bMhOhrnLNJ3DadPYzx5UjXAfFRxc1Meg3PnVG3b//6ngh4TJ8KMGZmfI6XqmzZ8uIqb2jHOzjB6NOzdq742bIXNhEYI4Q7sBqoD/QBfoArwixDiwT3VFYuAQcAEoDMQDvwshKhnHYvv8t5775GQkMCYMWN4/vnnMZvNbN68mb1799K7d2+mT5/O77//nu3xWrRQHrO+vwziVrd+6XcaDOlrNl57TX3Qly1T///7r+ro2by5midXqaKqRDdsSL8GbH4TEQEBATlqH5/fnDljIDn5VPr4TEwM7q1bp/uSNRw+jFu3brh36IDhzJlcXctw7BjJlSqp6ls7J7l6dRL798e0aNEDX6/T2rVIg4Gkbt0K0Do7pH9/tSLu7t0qNrpwoUq+GTdOJQtkZNcu9WDn7q5699t5zNTPTzlBunWzndjYckYzCHgK6Cal3CCl3Ah0BcoDbzzoRCFEXaAv8LaUcoGUchfQE7gETLGu2VCtWjV69OjBd999R2RkJNu3b6dz5860bNmSefPmUaFCBXx9fXO01Oq0aWqBI19f2LFD9f7LlIoVVUO1CRPUB714cfj2WxUFPHNGDXT2rEqZrlEDFizIf3/z9u1Qp466GXO7przZnGe7wk/+y8+WAbycRoidP/8c45EjuHz0EU4BARAdjZufH7JkSaTJhFv37rlqv288dgxL3bp5srcgMY8fDx4euIwZc8+HSZw/j+vQoTjPmoWldWvHqX+xJhUqpA9uLFmingCHDUtfayOlcquVLq36TIWFKZeEHePursK95cur/CJrNs+4H7YUmq7AQSnlHV+PlPICsA94IRvnJgI/pDk3CVgJdBBCWD3/dNKkSTRr1oxt27al6xjs6enJ8uXLCQsLw8/Pj4RsNu+rX18Vde7apbJISpSAl15SrWxOnrz7nXzsGIxx/oy1T76FedCbKph5+DDMmqVmM++/r1prrFqlFq8YPFiln2QXsxke9EU8YYJq4VG0KJQpowzMKdHReNSqhXNO7MpAVBQMufkJz3OKtkuXIs6eRVy6hPPs2SR260ZSy5a4jhiB26uvIv76i/gFC4hbtQpx7RpuL76Iyzvv4Dp4sGrDnxWRkRguXrTLjLP7IYsXJ2H8eJx27VILsR06hOF//8O1f388GjXCae1aEt94g/hFi2xtqn3i5ARLl6oZe79+d2fuv/4Kv/+uvAfe3srDMGuW+r9tW5VWGhVlW9szoXRp5T5r2lStoXXpUsFe32bJAEKIK8BGKeUbGbbPBV6WUhZ/wLkrgfpSymoZtvdEic/TUsoTD7q+tXudzZo1i9GjR1O3bl0CAgKoUaNGts6Li1MThk2blOikPkwVLap05OBBtWhnTIyatKxerR7E1q9X53z4oQr8AUqdXn5ZudF27VI1O2kJDFStOFLXs5dSVX9t3arOGz1a3TipbNigLtqvn0pz+eKLu0kLWaxqmTYZwLR0Ka7Dh5NcqhQxJ07kqp3Lia1h1O9Tn58pQueiiciSJUl+6imcdu0iJjAQ3N1xb9MGw8WLJLz7LuaUuJlx2zZchw+/88UhIiOJ27btgQF+42+/4e7jQ+y6dVhS3ysHwWnrVlzefRfDP/8AIB97jMR+/TAPH44s4FoKa5OrZICsWLwYXn9d1brVrq1iqJcvq1V0XV3V2jY1aihxqVpVdbsMCFBJPDlBSnXftWihHhCtRFyc0sl27fI0TI6TAWwpNGbgMynl2AzbpwFjpZT37SwthNgOeEopm2bY3hbYAbSSUv72oOtbW2gAtm7dSv/+/YmJiaF9+/ZUrVqVBg0a0L1792ytAiml+jzv3as+HMHBKj/e3195y0aNUhOMqCiVkQkqtjl5smpM6+SE2tm4sRKUoCB48kl14K+/QqdOqpx41Sro3l0Jh78/dO6sLhoVpWZEX36p/q5VS53/xx8qyhgRoQrfBg7McmaTVmjc27TBcOoUIjaWuBUrSOrSJcfv7dW2g3jyf5vwLt2E3XNG4vbSSwgpSRg7VrmNUDUipvXrMfv7K3szcvs2Hi1aQFISMfv2ZX6Dx8fj6u+P6fvviT5/Hln8vs8/9svt2zh/8w3S05PEvn3Vk8pDiFWERkp45RUlHqnMnQtDh979//p1VcTr7q7uj+efV5XZOWH1arW+yMCBKkZk3zic0HwqpRyXYft0YEwWQrMDKCSlbJZheztgO/cRGiHEYGAwQLly5RrmpRYmu4SHhzN27FgCAwM5d+4cZrOZ8uXLM27cODw9PdmzZw/h4eEsX74czxwEmqVUs/bly9X/b72lNOLtt9WOuLk1AAAV3UlEQVTMplQp9VDVty80cj+JaNJYfZGOGaOy2bp0gXLlVMFaUJDKWHvvPSU+GzYoYZk+XSXmP/ecCoKnLlheu/ZdQ/r1U3U9ly8/MFCeKjSGY8fwaNGC+P/+F+c5c0iuUYO41DhPdLR6SsxiXRfDkSN4tG7NdMbyv67nWb58EabZszFt2kTspk056oRtCAzEvX17krp2JX7x4nSpqsZ9+3AZMQLj2bOYBw0i4dNPsz2upuCxitCAutkiItRnw2R68Ixj4ECViRYRkf2Z+o0bULOmOsfFBf7+W7kw7BeHSm++CWSWk/pEyr4H8e8Dzk3dfw9SyvlSykZSykbFC+jJ1MvLiyVLlnDixAliY2PZsmULJUuWZMiQIfTt25eVK1eyefNm5mVoqpnVA4AQKs4/dKhqFjB7tnKZbdigZuDNmqkHr8aNocoLNfmm+w7iSz+l+lJ4e4OXl3Knbd2qfHJvvw0lS6qpkhBKgGbOVNlt+/cr9ZoyJb3IgErxjI6+/1PYmTPw+ecYzp8HwLR4MdLVlcRXXiHxtdcw7t6NuHgRQ1AQHk8/rRb4yuK1u0yZwi3nYnxMT+rUUd7TxBEjiN25M8fLLSQ3aoT5gw8wrVuHe7t2OAUEYPzpJ9w6d8a9UyeE2Uzs+vVaZB5lhFBB0+LFs3Zrde2q6nH27s3++O+8o7JHly1T/Q7tf0aTY2w5o9kNOEspW2TYvifFrtaZnqiOmQB8ADwupYxNs30SMA7lVntgFL4gXGf3Q0rJgQMHcHZ2pn79+nTs2JETJ05w4cIFXFxc2L17N7169WLkyJGMHTsWp1yu3Hjzppps/PCDSmv08oKjX/xK0V2rVPCybFl14OXLSoBGj1bRwoz88Qf8/LNKPMjMlpYtlW/vhRfUjCkhQcVt1q+/k08p3d1JmDIFl8mTSercmfh58xCXL+NRqxaW9u0x7tsHQiCiooj/4gsSBwzI9DUZAgPx8Pbm4yJTGPtvAwICbuPj45Or9+cOycmY5s/Hef58DCl1SMlPPol52DASBw5UNUwau8dqM5qcEBurZiODBytX9IOIiVHZbW++qZp7Tp0Kbdoof/n58/m6Yms+41CuM39gFlBVSvlXyrYKwFlUjOa+j5AptTJHgP5SyiUp25yA48A5KWWWTn9bCk1Gdu7cSbt27ViwYAE9evSgdu3aREZGEh0dTdOmTVm2bBmV067jnguOHFFxxnr11Hd/vhbpR0WpKdWnn6pYUCrly8OgQdCpE2Z/f5x/U97M2O3bsaQImmvv3pi2bcNStSpxGzfiOnQoxsBAYg4cQHp54bRxI7JYMSxt2tw53njgAMVun+Nm0ncEB7elYsWK+fM6pMS4dy8iMpKkTp0yj+to7Ba7EBpQs5rjx5VgZOwaEBmpHto2blRegpgYlXCzb5+6KdevV+mm69apxBv7xKGExgMIBuJQsxMJTAUKA3WklNEpx5UHzgNTpJRT0py/EugAjAYuAENRhZvNpZRBWV3fnoRGSskzzzxDVFQUjRo1YtWqVRw8eJCzZ88ybNgwPDw8CAkJ4fE8ZqOkxhv9/FTSWL4/MEVGqhvIy0vFgby87txo169do9CiRRjOnyfhs8/ubDccP47z11+TMGUKslgxxKVLeDRrRnKZMoibNzFcuYI0GolfuJDkqlXxePZZrg3/gJJzpuLiMoKrV6disNZSyhqHwm6EZuFC9YAVHKzqzRISlKgsWqTa1lgsatbTvTv06aM8AkajOjcp6W7PmDysMWRlHCdGI6WMAbyBM8AyYAVKMLxTRSYFARi519YBwGJgGrAVKAt0zI7I2BtCCMaMGcPZs2cJCAjgww8/pFGjRvTp04cdO3Zw5coVRo4cme3x4uPjSc6kYv/ll1WZzcKFKgTz3HMqYaB1a5VQNmLEg5e72bdPhXPu22Hn8cdVckD79ir7Ju3TnMFA4vDhJHz+ebrtybVrEz93LjLlC0KWK0f8xx9jPHWK5Bo1iF25EkvTprgOHIirnx/S05NDTVXGT4UKZi0yGvujc2f1e+BAJSJeXuoJ78QJlSq6b5/qyj5vnroJU0UG1NPfyJGqyWdqpg+oc7p3V5WXqRw5AkOGwLPPKuF6/vl7u4GEhqqU1I4dldjZCN1U006wWCzUq1ePQoUKsXfv3nTpzx9++CHTpk1j48aNdO3a9b5jJCUl8fXXX/Phhx9StWpVli5dSvXq1dMdExR0lIkTg3jyyb4EBbly86Yq5nJ3Vy41s1nl2H/xhSoPULap5LMPPlB/lyqlEmPS3h9Zcb+mmuvWrWPmzJls3LiRkmkr1G/dUmoIqrq/Z0+cfv+dhFGjmF1iCu+950bPnv4sXDg1+0ZoHmrsZkYD0KuXalNTsaJqhPvyy+rGys5Nk5SkEnaCglStW0yMit3cvq32v/yyOmb9epWq3qCBWgFt/Xq1RoC/v0qo8fdXLm1QGaFms5olZRaHzRmO4zqzNfYmNKCWWXVxcbmnxsZsNtO4cWOuXLnCggULaNSoEV5eXnf2WywWtmzZwoQJEzh27BitW7cmJCSEmJgYJk6cSPPmzSlevDjz589n9uzZJCcnM2PGjHvWEo+IULP7mTNVItm776rPc0CAyhfo2VN9/ocMUUk1derc4rFUMciCzITm9u3b1K9fn2vXruHr68tXaWpxrl69SokSJe52wY6JwbRyJYm9euHn78aqVQZmzpzPkCEP7FakeYSwK6HJK5cvq4BqsWLqxixUSFVyBwSoUgSTSWWr+furBzIp1Uzql19UfGjlSvVkOHiwSvJ57DGVihoVpQSwUqW8WKeFJrvYo9A8iODgYFq1akVUSnuLUqVKUa9ePapUqcKWLVu4cOECFSpU4NNPP+XFF1/k6tWrDBo0iC1bttwZQwjBG2+8QVBQEFFRUZw8eTLT5QyuXVMis3y5msl36qSa1XbrpgSoeHFo2vQo+/Y9w65du2jVKuum2ZkJzZQpU5g1axZt2rzAnj2b2LNnD/Xq1WPy5Ml89tn/UaFCOXx8fPD19aVmyvLJwcEG2rRxIykpgG3bitCiRYvMLqd5BHmohAbgp5/UzVeqlHKZpSYE3bqlZkaFCqU//u+/lQ+8WDGViPDqq6qNTuo9fuaMEptixZTY5H5ZDS002cXRhAbUjOfo0aMcPnyYoKAggoODOXXqFI0bN2bkyJF069YtXSq0lJI///yTsLAwwsPDqV27NvXr12fRokX4+flx8OBBmjRpQkJCAjNmzCAmJoYnn3ySypUr06pVK8LDPSlW7N7asXbtotm58xZQlvr163Ho0CGMKS6B2FjVlePaNfWQVbq0clHfupVeaMLCwmjYsCGVKi3m3LleuLm1o3r1GFq0aMGsWZcwmRZQv/5Ejh6di5SSyZMnM2DAMJ57rhD//BPL7dsVuHgxyKpr0Ggci4dOaEB12E1dgyo7zJ+v2uW0batq5DJmTv7+u3KvLVlyr1BlHy002cURhSYzpJQ5XpY1KiqKUqVK0b9/f+bOncu4ceOYMWMGLi4ud5qAGo1GmjRpwtSpU/H29r5zbnJyMjVqTOPMmQkMHx7AnDl9WbRoEa+88jpTp6pZfVJS+usZjZLu3ROYODGJsmXV583Pz4+NG48Cp0hIMODldYPw8NJASUymUyQmulOpUjKbN4cxevSbbN26FS+v1YSH98Bk8qFECSWyGk0qD6XQ5BQpVfp0ixZ5EZKscJysM03+kJu1vz09PXnppZcICAjg119/ZebMmfj5+REXF8eNGzf45ZdfGDt2LFevXqVTp05sSslWkVLy2WefcebMpzg5WXBy6k2zZs0ZNWoz9epZmD5dxUAXL4Zq1d4GOgF+uLouZv16Ew0aeDB5sjOrV29i1apVlC+/CoNBMHt2POHhRalYcQVeXjtwcXHjyy/jOX/ewJw5XixZ8j1t2vxBeHgPihdfwRtvPMWy1PV4NBrNXYRQGWbWE5lcoWc0jyipRaIeHh4UKVKEkJCQe3qt3bx5k06dOhEYGMioUaP46aefCA4OxsfHB4NhM3/8IShSJIbTpz0oXDiSH354nE6d4NChQzRu3JjRo0dTrlw5vv32W0JConj22V/Ys6csBsMxypbdQmjoeMaPT2DsWDMjR7qweLGa5n/9dRyvvJLEO++4sGiRiRo1kjl50siAAWZmzkzI32JTzUODntEUGNp1ll0edaGxWCxUrFiRsLAwduzYQdv7tL+/ffs2nTt3Zu/evdSuXZu33nqLV199lY0b3ejTR8UeCxX6jqCgtzl58hCVK1emf//+rF27lsuXL+Pp6cnNmzdp0aIFoaGhFC7ch6tXP0LKYpQtm8yhQzG4u6vMzeefd6dOnWQWLIhHCJV40Ly5B5GRatbTrVtSpjZqNKCFpgDRQpNdHnWhAVi/fj1///03b7311gOPS0hI4PTp09SpU+eOq05Ktcx65cpw5Uo4VatWxdvbm0WLFlGmTBkGDhyYLl05JCSELl26EBoayrffbmPPHm969kyiZcu7BWZJSSqZJq038MYN9du+m9lq7AEtNAWGFprsooUmf5kxYwbjxo2jU6dO/Pjjj5w4ceJOSjKo9OZbt25x4cIFmjRpYkNLNQ8rWmgKDC002UULTf6SkJBArVq1OH/+PG3atGF3StfmVO7XGUCjyS+00BQYOutMYxtcXFz4/PPPAfD397exNRqNxp6w2wUPNI5Hly5duHz5Mk+mLhet0Wg06BmNJp/RIqPRaDKihUaj0Wg0VkULjUaj0WisihYajUaj0VgVLTQajUajsSpaaDQajUZjVbTQaDQajcaqaKHRaDQajVXRQqPRaDQaq6KFRqPRaDRWRQuNRqPRaKzKI9u9WQgRAYTa2o5HiGLAdVsb4UDo9yvn6Pcs5+TmPbsupeyYkxMeWaHRFCxCiEApZSNb2+Eo6Pcr5+j3LOcU1HumXWcajUajsSpaaDQajUZjVbTQaAqK+bY2wMHQ71fO0e9ZzimQ90zHaDQajUZjVfSMRqPRaDRWRQuNxmoIIcoKIdYIIW4JIaKEEOuEEOVsbZe9IoQoI4T4UghxQAgRK4SQQogKtrbLXhFC9BBCrBVChAoh4oQQfwohPhJCFLa1bfaKEKKDEGK3EOKKECJBCPG3EGKVEKKmVa+rXWcaayCEcAeCgQTgA0AC0wB3oI6UMsaG5tklQojngB+Aw4ARaA9UlFJetKFZdosQ4iBwCdgI/A3UByYBp4HmUspk21lnnwgh+gANgD+ACKAcMBYoC9SWUlqltlALjcYqCCFGAp8B1aSU51K2VQTOAu9JKT+zpX32iBDCkPrlKITwAxaghea+CCGKSykjMmx7DVgCPC+l3G0byxwLIUQ1lDiPklJ+ao1raNeZxlp0BQ6migyAlPICsA94wWZW2TH6CTxnZBSZFA6l/C5dkLY4ODdSfida6wJaaDTWohYQksn2E4BV/cGaR5rWKb9P2dQKO0cIYRRCOAshqgDzgCvASmtdz8laA2seeYoANzPZ/i/wRAHbonkEEEKUBqYAO6WUgba2x875A2iY8vc5wFtKec1aF9MzGo01ySwAKArcCs1DjxCiECopIAkYYGNzHAFfoCnQF4gCdlgzw1ELjcZa3ETNajLyBJnPdDSaXCGEcAU2AU8BHaSUf9vYJLtHSnlKSvmHlDIAeB4ohMo+swradaaxFidQcZqM1AROFrAtmocUIYQJWAs0BtpKKY/b2CSHQ0oZKYQ4B1S21jX0jEZjLTYBTYUQT6VuSJmaP5uyT6PJE0IIA7AC9UT+gpTyoI1NckiEECWB6sB5q11D19ForIEQwgNVsBnH3YLNqUBhVMFmtA3Ns1uEED1S/nweGAIMQxXWRUgpf7WZYXaIEOJr1Hs0HdiSYfff2oV2L0KI9UAQcAwVm6kKvA2UAhpLKc9Y5bpaaDTWIqXdzOdAO1QSwC7AXxcg3h8hxP1uyF+llM8VpC32jhDiIlD+PrsnSyknFZw1joEQYgzQE6gEOANhwB7gI2vel1poNBqNRmNVdIxGo9FoNFZFC41Go9ForIoWGo1Go9FYFS00Go1Go7EqWmg0Go1GY1W00Gg0Go3Gqmih0WhygBCiQsoSy5NsbcuDEEJ8LIS4kNKiJSfndRNCmFPax2s0+YIWGs0jTYpoZPengq3tzQ4pK5mOBKZIKXO0mJWUcgNwHPjYGrZpHk10U03No45vhv9bAoOB+cBvGfZFALGAG6odvb0yFtVeZHkuz/8CWCKEqCWlPJF/ZmkeVXRnAI0mDUKI/sBiYICU8jvbWpNzhBCewGXgWynlyFyOUQi4mjLGW/lpn+bRRLvONJockFmMJu02IURPIcRRIUScEOKcEGJAyjHlhBBrhBD/CiFuCyGWCyEKZzK+lxDiayHEpZRYyT9CiPlCiBLZNPE/qLVFtmUydi0hxGohxGUhRIIQ4ooQ4hchhE/a41Ianv4GvJz9d0ajuT/adabR5B+dUd2E56KWrB4IfCuEMAP/BXYD44FngNeBeMAv9eSUJqQHUM0OF6HatlcGhgJthBCNpJS3srChdcrvQ2k3CiGKplwf4BsgFCgGNAKaAFszjHMA6CCEqC6lPJ2dF6/R3A8tNBpN/lEDqCmlDAUQQvyA6o67DBglpfws5bhvhBBPAK8JIfzTLJnwJWAC6qdtcS+EWA0cRLVzn5SFDTWBm1LKfzNsfxYoAfSSUq7KxmtJXZukFqCFRpMntOtMo8k/NqSKDICUMgL4E0gGvspw7G8oUakAIIR4DDUj2gTECyGKpf4AF4FzQPts2FAcNZvKSOpMqFNKHCcrbqT8zq7LTqO5L1poNJr8469Mtt0EwqWUCZlsByia8rsa6n4cSMpCZxl+qgEls2GDRK39k36jWjRtKdAfuC6E2CeEmCyEqHmfcVLH0NlCmjyjXWcaTf5hyeF2uPuFnvp7ObDkPsfGZcOGCKBuZjuklP2EEJ+gEgZaAO8C76e47+ZkOLxImvE0mjyhhUajsQ/OoWYPzlLKnXkYJwRoLYQoJqW8nnGnlDIk5ZiZQojHgT+AGUKIr2T6WofKacbTaPKEdp1pNHaAlPIGKiX5JSFE04z7haJ4Nobak/I73RhCiCJCiHT3u5QyErgAuAOuGcZpClyVUv6ZvVeg0dwfPaPRaOyHocDvwF4hxFLgCOph8CngBVSMZVIWY/wE3Ea5x7ak2f4a8LYQYj1q9pSISoXuAKySUt5xy6UUbLYEvs37S9JotNBoNHaDlDJMCNEQGIMSlldRtTZhwGYgy7RkKWW0EGI50Csl9mJO2bUHqI/KbPNCxY0uAKOAjPGZ7qhZzry8viaNBnQLGo3moSOl+edpYLiUcmEuzj8MhEopX8pn0zSPKFpoNJqHECHEDKA3UDXNrCY753VDzZxqSSnPWss+zaOFFhqNRqPRWBWddabRaDQaq6KFRqPRaDRWRQuNRqPRaKyKFhqNRqPRWBUtNBqNRqOxKlpoNBqNRmNVtNBoNBqNxqpoodFoNBqNVfl/JOb7k7AM1OgAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6,5))\n", - "plt.plot(sweep_response[(stim_table.condition=='center')&(stim_table.Center_Ori==90)]['199'].mean(), color='k')\n", - "plt.plot(sweep_response[(stim_table.condition=='ortho')&(stim_table.Center_Ori==90)]['199'].mean(), color='b')\n", - "plt.plot(sweep_response[(stim_table.condition=='iso')&(stim_table.Center_Ori==90)]['199'].mean(), color='r')\n", - "# plt.plot(sweep_response[(stim_table.condition=='surround')&(stim_table.Surround_Ori==90)]['199'].mean(), color='purple')\n", - "plt.axvspan(30,90, color='gray', alpha=0.1)\n", - "plt.tick_params(labelsize=16)\n", - "plt.xticks([30,60,90,120],[0,1,2,3])\n", - "plt.xlabel(\"Time (s)\", fontsize=18)\n", - "plt.ylabel(\"DFF\", fontsize=18)\n", - "plt.text(110,1.15, \"center\", color='k', fontsize=14)\n", - "plt.text(110,1.08, \"iso\", color='r', fontsize=14)\n", - "plt.text(110,1.01, \"ortho\", color='b', fontsize=14)\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(sweep_response[(stim_table.condition=='surround')&(stim_table.Surround_Ori==90)]['199'].mean(), color='purple')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## new example" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Unnamed: 0center_dircenter_osicenter_dsiisoorthosuppression_strengthsuppression_tuningcmicenter_mean...iso_stdortho_meanortho_stdcell_idsession_idvalidcreareadepthresponsive
5102920.605475-0.088010.670755-0.1133050.214989-7.3603720.7358520.240265...0.0738850.2212140.19003310123228221011892173TrueSst:Ai148VISp250True
\n", - "

1 rows × 25 columns

\n", - "
" - ], - "text/plain": [ - " Unnamed: 0 center_dir center_osi center_dsi iso ortho \\\n", - "510 29 2 0.605475 -0.08801 0.670755 -0.113305 \n", - "\n", - " suppression_strength suppression_tuning cmi center_mean ... \\\n", - "510 0.214989 -7.360372 0.735852 0.240265 ... \n", - "\n", - " iso_std ortho_mean ortho_std cell_id session_id valid \\\n", - "510 0.073885 0.221214 0.190033 1012322822 1011892173 True \n", - "\n", - " cre area depth responsive \n", - "510 Sst:Ai148 VISp 250 True \n", - "\n", - "[1 rows x 25 columns]" - ] - }, - "execution_count": 92, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "responsive[responsive.cell_id==1012322822]" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [], - "source": [ - "cell_id = 1012322822\n", - "expt_id = 1011892173\n", - "cell_index = responsive[responsive.cell_id==cell_id]['Unnamed: 0'].values[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [], - "source": [ - "analysis_file_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis_py3/'+str(expt_id)+'_cs_analysis.h5'\n", - "expt_path = expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(expt_id)+'_data.h5'" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [], - "source": [ - "f = h5py.File(analysis_file_path, 'r')\n", - "response = f['response'][()]\n", - "f.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "29" - ] - }, - "execution_count": 102, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cell_index" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6,5))\n", - "plt.errorbar(range(0,360,45),response[:,0,cell_index,0], yerr=response[:,0,cell_index,1]/np.sqrt(response[:,0,cell_index,2]), fmt='o-', color='k')\n", - "plt.errorbar(range(0,360,45),response[:,1,cell_index,0], yerr=response[:,1,cell_index,1]/np.sqrt(response[:,1,cell_index,2]), fmt='o-', color='r')\n", - "plt.errorbar(range(0,360,45),response[:,2,cell_index,0], yerr=response[:,2,cell_index,1]/np.sqrt(response[:,2,cell_index,2]), fmt='o-', color='b')\n", - "plt.xticks(range(0,360,45));\n", - "plt.xlabel(\"Direction (deg)\", fontsize=18)\n", - "plt.ylabel(\"Mean DF/F\", fontsize=18)\n", - "plt.tick_params(labelsize=16)\n", - "plt.text(270,0.27, \"center\", color='k', fontsize=14)\n", - "plt.text(270,0.25, \"iso\", color='r', fontsize=14)\n", - "plt.text(270,0.23, \"ortho\", color='b', fontsize=14)\n", - "plt.axhline(y=response[0,3,cell_index,0], ls='--', color='gray')\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [], - "source": [ - "sweep_response = pd.read_hdf(analysis_file_path, 'sweep_response')\n", - "stim_table = pd.read_hdf(expt_path, 'center_surround')" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [], - "source": [ - "stim_table['condition'] = 'ortho'\n", - "stim_table.loc[stim_table.Center_Ori==stim_table.Surround_Ori, 'condition'] = 'iso'\n", - "stim_table.loc[np.isfinite(stim_table.Center_Ori)&np.isnan(stim_table.Surround_Ori), 'condition'] = 'center'\n", - "stim_table.loc[np.isnan(stim_table.Center_Ori)&np.isnan(stim_table.Surround_Ori), 'condition'] = 'blank'\n", - "stim_table.loc[np.isnan(stim_table.Center_Ori)&np.isfinite(stim_table.Surround_Ori), 'condition'] = 'surround'" - ] - }, - { - "cell_type": "code", - "execution_count": 113, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6,5))\n", - "plt.plot(sweep_response[(stim_table.condition=='center')&(stim_table.Center_Ori==90)][str(cell_index)].mean(), color='k')\n", - "plt.plot(sweep_response[(stim_table.condition=='ortho')&(stim_table.Center_Ori==90)][str(cell_index)].mean(), color='b')\n", - "plt.plot(sweep_response[(stim_table.condition=='iso')&(stim_table.Center_Ori==90)][str(cell_index)].mean(), color='r')\n", - "# plt.plot(sweep_response[(stim_table.condition=='surround')&(stim_table.Surround_Ori==90)][str(cell_index)].mean(), color='purple')\n", - "plt.axvspan(30,90, color='gray', alpha=0.1)\n", - "plt.tick_params(labelsize=16)\n", - "plt.xticks([30,60,90,120],[0,1,2,3])\n", - "plt.xlabel(\"Time (s)\", fontsize=18)\n", - "plt.ylabel(\"DFF\", fontsize=18)\n", - "# plt.text(110,1.15, \"center\", color='k', fontsize=14)\n", - "# plt.text(110,1.08, \"iso\", color='r', fontsize=14)\n", - "# plt.text(110,1.01, \"ortho\", color='b', fontsize=14)\n", - "sns.despine()" - ] - }, - { - "cell_type": "code", - "execution_count": 176, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/saskiad/anaconda3/lib/python3.7/site-packages/pandas/core/frame.py:4238: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " return super().rename(**kwargs)\n" - ] - } - ], - "source": [ - "responsive.rename(columns={'Unnamed: 0':'cell_index'}, inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 177, - "metadata": {}, - "outputs": [], - "source": [ - "table_data = []\n", - "for key in responsive.keys():\n", - " table_data.append([key, responsive[responsive.cell_id==cell_id][key].values[0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 1.0, 0.0, 1.0)" - ] - }, - "execution_count": 179, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax = fig.add_subplot(1,1,1)\n", - "table = ax.table(cellText=table_data, loc='center')\n", - "table.set_fontsize(14)\n", - "table.scale(1,2)\n", - "ax.axis('off')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb b/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb deleted file mode 100644 index cd71389..0000000 --- a/analysis/.ipynb_checkpoints/plotting_size_tuning-checkpoint.ipynb +++ /dev/null @@ -1,233 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "import os\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "metrics = pd.read_csv(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf/size_metrics_all.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "analysis_file_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf'" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import h5py" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "session_id = 976843461" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "analysis_file = os.path.join(analysis_file_path, str(session_id)+'_st_analysis.h5')\n", - "expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(session_id)+'_data.h5'" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "f = h5py.File(analysis_file, 'r')\n", - "response = f['response'][()]\n", - "f.close()\n", - "sweep_response = pd.read_hdf(analysis_file, 'sweep_response')\n", - "stim_table = pd.read_hdf(expt_path, 'drifting_gratings_size')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(8, 2, 6, 112, 4)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "response.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(response[:,0,:,1,0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "valid = metrics_rf#[metrics_rf.valid]\n", - "for index, row in valid.iterrows():\n", - " cell_id = row.cell_id\n", - " session_id = row.session_id\n", - " cell_index = row.cell_index\n", - " pref_ori = orivals[int(row.center_dir)]\n", - " \n", - " analysis_file = os.path.join(analysis_file_path, str(session_id)+'_st_analysis.h5')\n", - " expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(session_id)+'_data.h5'\n", - " \n", - " f = h5py.File(analysis_file, 'r')\n", - " response = f['response'][()]\n", - " f.close()\n", - " sweep_response = pd.read_hdf(analysis_file, 'sweep_response')\n", - " stim_table = pd.read_hdf(expt_path, 'drifting_gratings_size')\n", - " \n", - "\n", - " f = h5py.File(expt_path, 'r')\n", - " mp = f['max_projection'][()]\n", - " rois = f['roi_outlines'][()]\n", - " f.close()\n", - " rois = rois.astype(float)\n", - " rois[rois==0] = np.NaN\n", - " roi_table = pd.read_hdf(expt_path, 'roi_table')\n", - " \n", - " plt.figure(figsize=(25,15))\n", - "\n", - " ax1 = plt.subplot2grid((3,3),(0,0))\n", - " ax2 = plt.subplot2grid((3,3),(1,0))\n", - " ax3 = plt.subplot2grid((3,3),(0,1), rowspan=2)\n", - " ax6 = plt.subplot2grid((3,3),(0,2), rowspan=2)\n", - " ax4 = plt.subplot2grid((3,3), (2,0))\n", - " ax5 = plt.subplot2grid((3,3), (2,1))\n", - " ax7 = plt.subplot2grid((3,3),(2,2))\n", - " \n", - " #Tuning curve\n", - " ax1.errorbar(range(0,360,45),response[:,0,cell_index,0], yerr=response[:,0,cell_index,1]/np.sqrt(response[:,0,cell_index,2]), fmt='o-', color='k', label='center')\n", - " ax1.errorbar(range(0,360,45),response[:,1,cell_index,0], yerr=response[:,1,cell_index,1]/np.sqrt(response[:,1,cell_index,2]), fmt='o-', color='r', label='iso')\n", - " ax1.errorbar(range(0,360,45),response[:,2,cell_index,0], yerr=response[:,2,cell_index,1]/np.sqrt(response[:,2,cell_index,2]), fmt='o-', color='b', label='ortho')\n", - " ax1.set_xticks(range(0,360,45));\n", - " ax1.set_xlabel(\"Direction (deg)\", fontsize=16)\n", - " ax1.set_ylabel(\"DF/F\", fontsize=16)\n", - " ax2.set_title(str(pref_tf)+\" Hz\", fontsize=16)\n", - "\n", - " ax1.axhline(y=response[0,3,cell_index,0], ls='--', color='gray')\n", - " ax1.legend()\n", - " sns.despine()\n", - "\n", - " #Preferred direction\n", - " ax2.plot(sweep_response[(stim_table.condition=='center')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='k')\n", - " ax2.plot(sweep_response[(stim_table.condition=='ortho')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='b')\n", - " ax2.plot(sweep_response[(stim_table.condition=='iso')&(stim_table.Center_Ori==pref_ori)][str(cell_index)].mean(), color='r')\n", - " ax2.plot(sweep_response[(stim_table.condition=='blank')][str(cell_index)].mean(), color='gray')\n", - " # ax2.plot(sweep_response[(stim_table.condition=='surround')&(stim_table.Surround_Ori==90)][str(cell_index)].mean(), color='purple')\n", - " ax2.axvspan(30,90, color='gray', alpha=0.1)\n", - " ax2.set_xticks([30,60,90,120],[0,1,2,3])\n", - " ax2.set_xlabel(\"Time (s)\", fontsize=18)\n", - " ax2.set_ylabel(\"DFF\", fontsize=18)\n", - " ax2.set_title(str(pref_ori)+\" Deg\"+\" \"+str(pref_tf)+\" Hz\", fontsize=16)\n", - "\n", - " sns.despine()\n", - "\n", - " \n", - " #ROI mask\n", - " plt.imshow(mp, cmap='gray')\n", - " plt.imshow(rois, cmap='Reds')\n", - " plt.plot(roi_table.x[cell_index], roi_table.y[cell_index], 'yo')\n", - " plt.xlim(roi_table.x[cell_index]-100, roi_table.x[cell_index]+100)\n", - " plt.ylim(roi_table.y[cell_index]+100, roi_table.y[cell_index]-100)\n", - " \n", - " plt.suptitle(\"Session: \"+str(expt_id)+\" Cell: \"+str(cell_id), fontsize=18)\n", - " plt.tight_layout()\n", - " plt.savefig(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/ST_figures/'+str(cell_id)+'.png')\n", - " plt.close()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/analysis/DGgrid_analysis_5x5_nikon_SdV.py b/analysis/DGgrid_analysis_5x5_nikon_SdV.py index 1e7b79d..f953136 100644 --- a/analysis/DGgrid_analysis_5x5_nikon_SdV.py +++ b/analysis/DGgrid_analysis_5x5_nikon_SdV.py @@ -11,7 +11,7 @@ import h5py import cPickle as pickle -from sync import Dataset +from oscopetools.sync import Dataset import tifffile as tiff import matplotlib.pyplot as plt diff --git a/analysis/stim_table.py b/analysis/stim_table.py index c540b9e..25a15c3 100644 --- a/analysis/stim_table.py +++ b/analysis/stim_table.py @@ -12,7 +12,7 @@ import pandas as pd import h5py -from sync import Dataset +from oscopetools.sync import Dataset # Generic interface for creating stim tables. PREFERRED. diff --git a/analysis/sync/dataset.py b/analysis/sync/dataset.py deleted file mode 100755 index c411977..0000000 --- a/analysis/sync/dataset.py +++ /dev/null @@ -1,408 +0,0 @@ -""" -dataset.py - -Dataset object for loading and unpacking a sync dataset. - -""" - -import datetime -import pprint - -import h5py as h5 -import numpy as np - -dset_version = 1.0 - - -def unpack_uint32(uint32_array, endian='L'): - """ - Unpacks an array of 32-bit unsigned integers into bits. - - Default is least significant bit first. - - """ - if not uint32_array.dtype == np.uint32: - raise TypeError("Must be uint32 ndarray.") - buff = np.getbuffer(uint32_array) - uint8_array = np.frombuffer(buff, dtype=np.uint8) - uint8_array = np.fliplr(uint8_array.reshape(-1, 4)) - bits = np.unpackbits(uint8_array).reshape(-1, 32) - if endian.upper() == 'B': - bits = np.fliplr(bits) - return bits - - -def get_bit(uint_array, bit): - """ - Returns a bool array for a specific bit in a uint ndarray. - """ - return np.bitwise_and(uint_array, 2 ** bit).astype(bool).astype(np.uint8) - - -class Dataset(object): - """ - A sync dataset. Contains methods for loading - and parsing the binary data. - - """ - - def __init__(self, path): - self.load(path) - - self.times = self._process_times() - - def _process_times(self): - times = self.get_all_events()[:, 0:1].astype(np.int64) - - intervals = np.ediff1d(times, to_begin=0) - rollovers = np.where(intervals < 0)[0] - - for i in rollovers: - times[i:] += 4294967296 - - return times - - def load(self, path): - """ - Loads an hdf5 sync dataset. - """ - self.dfile = h5.File(path, 'r') - self.meta_data = eval(self.dfile['meta'].value) - self.line_labels = self.meta_data['line_labels'] - return self.dfile - - def get_bit(self, bit): - """ - Returns the values for a specific bit. - """ - return get_bit(self.get_all_bits(), bit) - - def get_line(self, line): - """ - Returns the values for a specific line. - """ - bit = self._line_to_bit(line) - return self.get_bit(bit) - - def get_bit_changes(self, bit): - """ - Returns the first derivative of a specific bit. - Data points are 1 on rizing edges and 255 on falling edges. - """ - bit_array = self.get_bit(bit) - return np.ediff1d(bit_array, to_begin=0) - - def get_all_bits(self): - """ - Returns the data for all bits. - """ - return self.dfile['data'].value[:, -1] - - def get_all_times(self): - """ - Returns all counter values. - """ - if self.meta_data['ni_daq']['counter_bits'] == 32: - return self.get_all_events()[:, 0] - else: - """ - - #this doesn't work because actually the rollover isn't a pulse - #it goes high after the first rollover then low after the second - - times = self.get_all_events()[:, 0:2].astype(np.uint64) - times = times[:, 0] + times[:, 1]*np.uint64(4294967296) - return times - """ - return self.times - - def get_all_events(self): - """ - Returns all counter values and their cooresponding IO state. - """ - return self.dfile['data'].value - - def get_events_by_bit(self, bit): - """ - Returns all counter values for transitions (both rising and falling) - for a specific bit. - """ - changes = self.get_bit_changes(bit) - return self.get_all_times()[np.where(changes != 0)] - - def get_events_by_line(self, line): - """ - Returns all counter values for transitions (both rising and falling) - for a specific line. - """ - line = self._line_to_bit(line) - return self.get_events_by_bit(line) - - def _line_to_bit(self, line): - """ - Returns the bit for a specified line. Either line name and number is - accepted. - """ - if type(line) is int: - return line - elif type(line) is str: - return self.line_labels.index(line) - else: - raise TypeError("Incorrect line type. Try a str or int.") - - def get_rising_edges(self, line): - """ - Returns the counter values for the rizing edges for a specific bit. - """ - bit = self._line_to_bit(line) - changes = self.get_bit_changes(bit) - return self.get_all_times()[np.where(changes == 1)] - - def get_falling_edges(self, line): - """ - Returns the counter values for the falling edges for a specific bit. - """ - bit = self._line_to_bit(line) - changes = self.get_bit_changes(bit) - return self.get_all_times()[np.where(changes == 255)] - - def line_stats(self, line, print_results=True): - """ - Quick-and-dirty analysis of a bit. - - ##TODO: Split this up into smaller functions. - - """ - # convert to bit - bit = self._line_to_bit(line) - - # get the bit's data - bit_data = self.get_bit(bit) - total_data_points = len(bit_data) - - # get the events - events = self.get_events_by_bit(bit) - total_events = len(events) - - # get the rising edges - rising = self.get_rising_edges(bit) - total_rising = len(rising) - - # get falling edges - falling = self.get_falling_edges(bit) - total_falling = len(falling) - - if total_events <= 0: - if print_results: - print(("*" * 70)) - print(("No events on line: %s" % line)) - print(("*" * 70)) - return None - elif total_events <= 10: - if print_results: - print(("*" * 70)) - print(("Sparse events on line: %s" % line)) - print(("Rising: %s" % total_rising)) - print(("Falling: %s" % total_falling)) - print(("*" * 70)) - return { - 'line': line, - 'bit': bit, - 'total_rising': total_rising, - 'total_falling': total_falling, - 'avg_freq': None, - 'duty_cycle': None, - } - else: - - # period - period = self.period(line) - - avg_period = period['avg'] - max_period = period['max'] - min_period = period['min'] - period_sd = period['sd'] - - # freq - avg_freq = self.frequency(line) - - # duty cycle - duty_cycle = self.duty_cycle(line) - - if print_results: - print(("*" * 70)) - - print(("Quick stats for line: %s" % line)) - print(("Bit: %i" % bit)) - print(("Data points: %i" % total_data_points)) - print(("Total transitions: %i" % total_events)) - print(("Rising edges: %i" % total_rising)) - print(("Falling edges: %i" % total_falling)) - print(("Average period: %s" % avg_period)) - print(("Minimum period: %s" % min_period)) - print(("Max period: %s" % max_period)) - print(("Period SD: %s" % period_sd)) - print(("Average freq: %s" % avg_freq)) - print(("Duty cycle: %s" % duty_cycle)) - - print(("*" * 70)) - - return { - 'line': line, - 'bit': bit, - 'total_data_points': total_data_points, - 'total_events': total_events, - 'total_rising': total_rising, - 'total_falling': total_falling, - 'avg_period': avg_period, - 'min_period': min_period, - 'max_period': max_period, - 'period_sd': period_sd, - 'avg_freq': avg_freq, - 'duty_cycle': duty_cycle, - } - - def period(self, line, edge="rising"): - """ - Returns a dictionary with avg, min, max, and sd of period for a line. - """ - bit = self._line_to_bit(line) - - if edge.lower() == "rising": - edges = self.get_rising_edges(bit) - elif edge.lower() == "falling": - edges = self.get_falling_edges(bit) - - if len(edges) > 1: - - timebase_freq = self.meta_data['ni_daq']['counter_output_freq'] - avg_period = np.mean(np.ediff1d(edges)) / timebase_freq - max_period = np.max(np.ediff1d(edges)) / timebase_freq - min_period = np.min(np.ediff1d(edges)) / timebase_freq - period_sd = np.std(avg_period) - - else: - raise IndexError("Not enough edges for period: %i" % len(edges)) - - return { - 'avg': avg_period, - 'max': max_period, - 'min': min_period, - 'sd': period_sd, - } - - def frequency(self, line, edge="rising"): - """ - Returns the average frequency of a line. - """ - - period = self.period(line, edge) - return 1.0 / period['avg'] - - def duty_cycle(self, line): - """ - Doesn't work right now. Freezes python for some reason. - - Returns the duty cycle of a line. - - """ - raise NotImplementedError - - bit = self._line_to_bit(line) - - rising = self.get_rising_edges(bit) - falling = self.get_falling_edges(bit) - - total_rising = len(rising) - total_falling = len(falling) - - if total_rising > total_falling: - rising = rising[:total_falling] - elif total_rising < total_falling: - falling = falling[:total_rising] - else: - pass - - if rising[0] < falling[0]: - # line starts low - high = falling - rising - else: - # line starts high - high = np.concatenate( - falling, self.get_all_events()[-1, 0] - ) - np.concatenate(0, rising) - - total_high_time = np.sum(high) - all_events = self.get_events_by_bit(bit) - total_time = all_events[-1] - all_events[0] - return 1.0 * total_high_time / total_time - - def stats(self): - """ - Quick-and-dirty analysis of all bits. Prints a few things about each - bit where events are found. - """ - bits = [] - for i in range(32): - bits.append(self.line_stats(i, print_results=False)) - active_bits = [x for x in bits if x is not None] - print(("Active bits: ", len(active_bits))) - for bit in active_bits: - print(("*" * 70)) - print(("Bit: %i" % bit['bit'])) - print(("Label: %s" % self.line_labels[bit['bit']])) - print(("Rising edges: %i" % bit['total_rising'])) - print(("Falling edges: %i" % bit["total_falling"])) - print(("Average freq: %s" % bit['avg_freq'])) - print(("Duty cycle: %s" % bit['duty_cycle'])) - print(("*" * 70)) - return active_bits - - def plot_all(self): - """ - Plot all active bits. - - Yikes. Come up with a better way to show this. - - """ - import matplotlib.pyplot as plt - - for bit in range(32): - if len(self.get_events_by_bit(bit)) > 0: - data = self.get_bit(bit) - plt.plot(data) - plt.show() - - def plot_bits(self, bits): - """ - Plots a list of bits. - """ - import matplotlib.pyplot as plt - - for bit in bits: - data = self.get_bit(bit) - plt.plot(data) - plt.show() - - def close(self): - """ - Closes the dataset. - """ - self.dfile.close() - - -def main(): - path = r"\\aibsdata\mpe\CAM\testdata\test.h5" - dset = Dataset(path) - - # pprint.pprint(dset.meta_data) - - dset.stats() - - # print dset.duty_cycle(2) - - # dset.plot_bits([2, 4]) - - -if __name__ == '__main__': - main() diff --git a/analysis/sync/gui/__init__.py b/analysis/sync/gui/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/analysis/sync/gui/res/record.png b/analysis/sync/gui/res/record.png deleted file mode 100755 index cbcf5053e8f7159b4464ac284c80f97a9c857e54..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 142112 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%0DB_*B8zgI#ZQN=a&I8SW&4uAbcBjGo^^Q0 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 z

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 diff --git a/analysis/sync/gui/res/stop.png b/analysis/sync/gui/res/stop.png deleted file mode 100755 index 38f12bec35ca832417908accaf5f6f4273ef602a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29169 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 Pz>lTb8Pj(sJYxO_@5XMA diff --git a/analysis/sync/gui/sync_gui.py b/analysis/sync/gui/sync_gui.py deleted file mode 100755 index 536ca9d..0000000 --- a/analysis/sync/gui/sync_gui.py +++ /dev/null @@ -1,297 +0,0 @@ -''' -Created on Oct 18, 2014 - -@author: derricw -''' - - -import sys -import os -import datetime -import pickle as pickle - -from PyQt4 import QtCore, QtGui - -from .sync_gui_layout import Ui_MainWindow -from sync.sync import Sync -from sync.dataset import Dataset - -LAST_SESSION = "C:/sync/last.pkl" -DEFAULT_OUTPUT = "C:/sync/output/test" - - -class MyForm(QtGui.QMainWindow): - """ - Simple GUI for testing the Sync program. - - Remembers state of all widgets between sessions. - - """ - - def __init__(self, parent=None): - QtGui.QWidget.__init__(self, parent) - self.ui = Ui_MainWindow() - self.ui.setupUi(self) - - self._setup_table() - self._setup_buttons() - - self._load_state() - self._calculate_rollover() - - self.running = False - self.sync_thread = None - - self.ui.plainTextEdit.appendPlainText("Ready...") - - def _setup_table(self): - """ - Sets up the tablewidget so that the numbering is 0:31 - """ - # set vertical labels to 0:31 - labels_int = list(range(32)) - labels_str = [str(i) for i in labels_int] - self.ui.tableWidget_labels.setVerticalHeaderLabels(labels_str) - # set horizontal labels - self.ui.tableWidget_labels.setHorizontalHeaderLabels(['line ']) - - def _setup_buttons(self): - """ - Setup button callbacks and icons. - """ - self.ui.pushButton_start.clicked.connect(self._start_stop) - self.ui.pushButton_start.setIcon(QtGui.QIcon("res/record.png")) - self.ui.lineEdit_pulse_freq.textChanged.connect( - self._calculate_rollover - ) - self.ui.lineEdit_counter_bits.textChanged.connect( - self._calculate_rollover - ) - - def _start_stop(self): - """ - Callback for start/stop button press. - """ - if not self.running: - # get configuration from gui - self._start_session() - self.running = True - self._disable_ui() - self.ui.pushButton_start.setIcon(QtGui.QIcon("res/stop.png")) - - else: - self._stop_session() - self.running = False - self._enable_ui() - self.ui.pushButton_start.setIcon(QtGui.QIcon("res/record.png")) - - def _disable_ui(self): - """ - Disables the ui. - """ - self.ui.tableWidget_labels.setEnabled(False) - self.ui.groupBox.setEnabled(False) - - def _enable_ui(self): - """ - Enables the UI. - """ - self.ui.tableWidget_labels.setEnabled(True) - self.ui.groupBox.setEnabled(True) - - def _start_session(self): - """ - Starts a session. - """ - now = datetime.datetime.now() - self.output_dir = str(self.ui.lineEdit_output_path.text()) - if self.ui.checkBox_timestamp.isChecked(): - self.output_dir += now.strftime('%y%m%d%H%M%S') - basedir = os.path.dirname(self.output_dir) - try: - os.makedirs(basedir) - except: - pass - device = str(self.ui.lineEdit_device.text()) - counter = str(self.ui.lineEdit_counter.text()) - counter_bits = int(self.ui.lineEdit_counter_bits.text()) - if not counter_bits in [32, 64]: - raise ValueError("Counter must be 64 or 32 bits.") - data_bits = int(self.ui.lineEdit_data_bits.text()) - pulse = str(self.ui.lineEdit_pulse_out.text()) - freq = float(str(self.ui.lineEdit_pulse_freq.text())) - - # add labels - labels = self._getLabels() - - # #create Sync object - params = { - 'device': device, - 'counter': counter, - 'pulse': pulse, - 'output_dir': self.output_dir, - 'counter_bits': counter_bits, - 'event_bits': data_bits, - 'freq': freq, - 'labels': labels, - } - - self.sync = SyncObject(params=params) - if self.sync_thread: - self.sync_thread.terminate() - self.sync_thread = QtCore.QThread() - self.sync.moveToThread(self.sync_thread) - self.sync_thread.start() - self.sync_thread.setPriority(QtCore.QThread.TimeCriticalPriority) - - QtCore.QTimer.singleShot(100, self.sync.start) - - self.ui.plainTextEdit.appendPlainText( - "***Starting session at \ - %s on %s ***" - % (str(now), device) - ) - - def _stop_session(self): - """ - Ends the session. - """ - now = datetime.datetime.now() - # self.sync.clear() - QtCore.QTimer.singleShot(100, self.sync.clear) - # self.sync = None - - self.ui.plainTextEdit.appendPlainText( - "***Ending session at \ - %s ***" - % str(now) - ) - - def _getLabels(self): - """ - Gets all of the line labels. - """ - labels = [] - for i in range(self.ui.tableWidget_labels.rowCount()): - item = self.ui.tableWidget_labels.item(i, 0) - if item is not None: - labels.append(str(item.text())) - else: - labels.append("") - return labels - - def _save_state(self): - """ - Saves widget states. - """ - state = { - 'output_dir': str(self.ui.lineEdit_output_path.text()), - 'device': str(self.ui.lineEdit_device.text()), - 'counter': str(self.ui.lineEdit_counter.text()), - 'counter_bits': str(self.ui.lineEdit_counter_bits.text()), - 'event_bits': str(self.ui.lineEdit_data_bits.text()), - 'pulse': str(self.ui.lineEdit_pulse_out.text()), - 'freq': str(self.ui.lineEdit_pulse_freq.text()), - 'labels': self._getLabels(), - 'timestamp': self.ui.checkBox_timestamp.isChecked(), - } - with open(LAST_SESSION, 'wb') as f: - pickle.dump(state, f) - - def _load_state(self): - """ - Loads previous widget states. - """ - try: - with open(LAST_SESSION, 'rb') as f: - data = pickle.load(f) - self.ui.lineEdit_output_path.setText(data['output_dir']) - self.ui.lineEdit_device.setText(data['device']) - self.ui.lineEdit_counter.setText(data['counter']) - self.ui.lineEdit_counter_bits.setText(data['counter_bits']) - self.ui.lineEdit_data_bits.setText(data['event_bits']) - self.ui.lineEdit_pulse_out.setText(data['pulse']) - self.ui.lineEdit_pulse_freq.setText(data['freq']) - self.ui.checkBox_timestamp.setChecked(data['timestamp']) - for index, label in enumerate(data['labels']): - self.ui.tableWidget_labels.setItem( - index, 0, QtGui.QTableWidgetItem(label) - ) - self.ui.plainTextEdit.appendPlainText( - "Loaded previous config successfully." - ) - except Exception as e: - print(e) - self.ui.plainTextEdit.appendPlainText( - "Couldn't load previous session. Using defaults." - ) - - def _calculate_rollover(self): - """ - Calculates the rollover time for the current freqency. - """ - counter_bits_str = str(self.ui.lineEdit_counter_bits.text()) - if counter_bits_str: - counter_bits = int(counter_bits_str) - else: - return - if counter_bits == 32: - freq = float(str(self.ui.lineEdit_pulse_freq.text())) - try: - seconds = 4294967295 / freq # max unsigned - timestr = str(datetime.timedelta(seconds=seconds)) - except: - timestr = "???" - elif counter_bits == 64: - timestr = "~FOREVER" - else: - timestr = "???" - self.ui.label_rollover.setText(timestr) - - def closeEvent(self, event): - self._save_state() - if self.sync_thread: - self.sync_thread.terminate() - - -class SyncObject(QtCore.QObject): - """ - Thread for controlling sync. - - ##TODO: Fix params argument to not be stupid. - """ - - def __init__(self, parent=None, params={}): - - QtCore.QObject.__init__(self, parent) - - self.params = params - - def start(self): - # create Sync object - self.sync = Sync( - self.params['device'], - self.params['counter'], - self.params['pulse'], - self.params['output_dir'], - counter_bits=self.params['counter_bits'], - event_bits=self.params['event_bits'], - freq=self.params['freq'], - verbose=True, - force_sync_callback=False, - ) - - for i, label in enumerate(self.params['labels']): - self.sync.add_label(i, label) - - self.sync.start() - - def clear(self): - self.sync.clear() - - -if __name__ == "__main__": - app = QtGui.QApplication(sys.argv) - myapp = MyForm() - myapp.show() - sys.exit(app.exec_()) diff --git a/analysis/sync/gui/sync_gui.ui b/analysis/sync/gui/sync_gui.ui deleted file mode 100755 index ac213da..0000000 --- a/analysis/sync/gui/sync_gui.ui +++ /dev/null @@ -1,267 +0,0 @@ - - - MainWindow - - - - 0 - 0 - 844 - 543 - - - - Sync - - - - - - - Setup - - - - - - 64 - - - - - - - Counter Bits - - - - - - - Output path: - - - - - - - C:/sync/output/test - - - - - - - Timestamp - - - true - - - - - - - Pulse Freq (Hz): - - - - - - - 100000.0 - - - - - - - Rollover - - - - - - - Device: - - - - - - - Dev1 - - - - - - - Counter: - - - - - - - ctr0 - - - - - - - Pulse Out: - - - - - - - ctr2 - - - - - - - false - - - Aux Counter - - - - - - - false - - - - - - - Data Bits - - - - - - - 32 - - - - - - - - - - - 200 - 150 - - - - - - - - 128 - 128 - - - - - - - - - - - - 150 - 0 - - - - - 200 - 16777215 - - - - true - - - Qt::DashDotLine - - - true - - - 32 - - - 1 - - - 200 - - - 30 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - 0 - 844 - 21 - - - - - - - - diff --git a/analysis/sync/gui/sync_gui_layout.py b/analysis/sync/gui/sync_gui_layout.py deleted file mode 100755 index 316e796..0000000 --- a/analysis/sync/gui/sync_gui_layout.py +++ /dev/null @@ -1,173 +0,0 @@ -# -*- coding: utf-8 -*- - -# Form implementation generated from reading ui file 'sync_gui.ui' -# -# Created: Thu Nov 13 13:55:31 2014 -# by: PyQt4 UI code generator 4.9.6 -# -# WARNING! All changes made in this file will be lost! - -from PyQt4 import QtCore, QtGui - -try: - _fromUtf8 = QtCore.QString.fromUtf8 -except AttributeError: - - def _fromUtf8(s): - return s - - -try: - _encoding = QtGui.QApplication.UnicodeUTF8 - - def _translate(context, text, disambig): - return QtGui.QApplication.translate(context, text, disambig, _encoding) - - -except AttributeError: - - def _translate(context, text, disambig): - return QtGui.QApplication.translate(context, text, disambig) - - -class Ui_MainWindow(object): - def setupUi(self, MainWindow): - MainWindow.setObjectName(_fromUtf8("MainWindow")) - MainWindow.resize(844, 543) - self.centralwidget = QtGui.QWidget(MainWindow) - self.centralwidget.setObjectName(_fromUtf8("centralwidget")) - self.gridLayout_2 = QtGui.QGridLayout(self.centralwidget) - self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2")) - self.groupBox = QtGui.QGroupBox(self.centralwidget) - self.groupBox.setObjectName(_fromUtf8("groupBox")) - self.gridLayout = QtGui.QGridLayout(self.groupBox) - self.gridLayout.setObjectName(_fromUtf8("gridLayout")) - self.lineEdit_counter_bits = QtGui.QLineEdit(self.groupBox) - self.lineEdit_counter_bits.setObjectName( - _fromUtf8("lineEdit_counter_bits") - ) - self.gridLayout.addWidget(self.lineEdit_counter_bits, 1, 1, 1, 1) - self.label_6 = QtGui.QLabel(self.groupBox) - self.label_6.setObjectName(_fromUtf8("label_6")) - self.gridLayout.addWidget(self.label_6, 1, 0, 1, 1) - self.label = QtGui.QLabel(self.groupBox) - self.label.setObjectName(_fromUtf8("label")) - self.gridLayout.addWidget(self.label, 0, 0, 1, 1) - self.lineEdit_output_path = QtGui.QLineEdit(self.groupBox) - self.lineEdit_output_path.setObjectName( - _fromUtf8("lineEdit_output_path") - ) - self.gridLayout.addWidget(self.lineEdit_output_path, 0, 1, 1, 1) - self.checkBox_timestamp = QtGui.QCheckBox(self.groupBox) - self.checkBox_timestamp.setChecked(True) - self.checkBox_timestamp.setObjectName(_fromUtf8("checkBox_timestamp")) - self.gridLayout.addWidget(self.checkBox_timestamp, 0, 2, 1, 1) - self.label_2 = QtGui.QLabel(self.groupBox) - self.label_2.setObjectName(_fromUtf8("label_2")) - self.gridLayout.addWidget(self.label_2, 3, 0, 1, 1) - self.lineEdit_pulse_freq = QtGui.QLineEdit(self.groupBox) - self.lineEdit_pulse_freq.setObjectName(_fromUtf8("lineEdit_pulse_freq")) - self.gridLayout.addWidget(self.lineEdit_pulse_freq, 3, 1, 1, 1) - self.label_rollover = QtGui.QLabel(self.groupBox) - self.label_rollover.setObjectName(_fromUtf8("label_rollover")) - self.gridLayout.addWidget(self.label_rollover, 3, 2, 1, 1) - self.label_5 = QtGui.QLabel(self.groupBox) - self.label_5.setObjectName(_fromUtf8("label_5")) - self.gridLayout.addWidget(self.label_5, 4, 0, 1, 1) - self.lineEdit_device = QtGui.QLineEdit(self.groupBox) - self.lineEdit_device.setObjectName(_fromUtf8("lineEdit_device")) - self.gridLayout.addWidget(self.lineEdit_device, 4, 1, 1, 1) - self.label_4 = QtGui.QLabel(self.groupBox) - self.label_4.setObjectName(_fromUtf8("label_4")) - self.gridLayout.addWidget(self.label_4, 5, 0, 1, 1) - self.lineEdit_counter = QtGui.QLineEdit(self.groupBox) - self.lineEdit_counter.setObjectName(_fromUtf8("lineEdit_counter")) - self.gridLayout.addWidget(self.lineEdit_counter, 5, 1, 1, 1) - self.label_3 = QtGui.QLabel(self.groupBox) - self.label_3.setObjectName(_fromUtf8("label_3")) - self.gridLayout.addWidget(self.label_3, 6, 0, 1, 1) - self.lineEdit_pulse_out = QtGui.QLineEdit(self.groupBox) - self.lineEdit_pulse_out.setObjectName(_fromUtf8("lineEdit_pulse_out")) - self.gridLayout.addWidget(self.lineEdit_pulse_out, 6, 1, 1, 1) - self.checkBox_aux_counter = QtGui.QCheckBox(self.groupBox) - self.checkBox_aux_counter.setEnabled(False) - self.checkBox_aux_counter.setObjectName( - _fromUtf8("checkBox_aux_counter") - ) - self.gridLayout.addWidget(self.checkBox_aux_counter, 7, 0, 1, 1) - self.lineEdit_aux_counter = QtGui.QLineEdit(self.groupBox) - self.lineEdit_aux_counter.setEnabled(False) - self.lineEdit_aux_counter.setObjectName( - _fromUtf8("lineEdit_aux_counter") - ) - self.gridLayout.addWidget(self.lineEdit_aux_counter, 7, 1, 1, 1) - self.label_data_bits = QtGui.QLabel(self.groupBox) - self.label_data_bits.setObjectName(_fromUtf8("label_data_bits")) - self.gridLayout.addWidget(self.label_data_bits, 2, 0, 1, 1) - self.lineEdit_data_bits = QtGui.QLineEdit(self.groupBox) - self.lineEdit_data_bits.setObjectName(_fromUtf8("lineEdit_data_bits")) - self.gridLayout.addWidget(self.lineEdit_data_bits, 2, 1, 1, 1) - self.gridLayout_2.addWidget(self.groupBox, 0, 1, 1, 1) - self.pushButton_start = QtGui.QPushButton(self.centralwidget) - self.pushButton_start.setMinimumSize(QtCore.QSize(200, 150)) - self.pushButton_start.setText(_fromUtf8("")) - self.pushButton_start.setIconSize(QtCore.QSize(128, 128)) - self.pushButton_start.setObjectName(_fromUtf8("pushButton_start")) - self.gridLayout_2.addWidget(self.pushButton_start, 1, 1, 1, 1) - self.plainTextEdit = QtGui.QPlainTextEdit(self.centralwidget) - self.plainTextEdit.setObjectName(_fromUtf8("plainTextEdit")) - self.gridLayout_2.addWidget(self.plainTextEdit, 2, 1, 1, 1) - self.tableWidget_labels = QtGui.QTableWidget(self.centralwidget) - self.tableWidget_labels.setMinimumSize(QtCore.QSize(150, 0)) - self.tableWidget_labels.setMaximumSize(QtCore.QSize(200, 16777215)) - self.tableWidget_labels.setShowGrid(True) - self.tableWidget_labels.setGridStyle(QtCore.Qt.DashDotLine) - self.tableWidget_labels.setCornerButtonEnabled(True) - self.tableWidget_labels.setRowCount(32) - self.tableWidget_labels.setColumnCount(1) - self.tableWidget_labels.setObjectName(_fromUtf8("tableWidget_labels")) - self.tableWidget_labels.horizontalHeader().setDefaultSectionSize(200) - self.tableWidget_labels.verticalHeader().setDefaultSectionSize(30) - self.gridLayout_2.addWidget(self.tableWidget_labels, 0, 0, 3, 1) - MainWindow.setCentralWidget(self.centralwidget) - self.menubar = QtGui.QMenuBar(MainWindow) - self.menubar.setGeometry(QtCore.QRect(0, 0, 844, 21)) - self.menubar.setObjectName(_fromUtf8("menubar")) - MainWindow.setMenuBar(self.menubar) - self.statusbar = QtGui.QStatusBar(MainWindow) - self.statusbar.setObjectName(_fromUtf8("statusbar")) - MainWindow.setStatusBar(self.statusbar) - - self.retranslateUi(MainWindow) - QtCore.QMetaObject.connectSlotsByName(MainWindow) - - def retranslateUi(self, MainWindow): - MainWindow.setWindowTitle(_translate("MainWindow", "Sync", None)) - self.groupBox.setTitle(_translate("MainWindow", "Setup", None)) - self.lineEdit_counter_bits.setText(_translate("MainWindow", "64", None)) - self.label_6.setText(_translate("MainWindow", "Counter Bits", None)) - self.label.setText(_translate("MainWindow", "Output path:", None)) - self.lineEdit_output_path.setText( - _translate("MainWindow", "C:/sync/output/test", None) - ) - self.checkBox_timestamp.setText( - _translate("MainWindow", "Timestamp", None) - ) - self.label_2.setText(_translate("MainWindow", "Pulse Freq (Hz):", None)) - self.lineEdit_pulse_freq.setText( - _translate("MainWindow", "100000.0", None) - ) - self.label_rollover.setText(_translate("MainWindow", "Rollover", None)) - self.label_5.setText(_translate("MainWindow", "Device:", None)) - self.lineEdit_device.setText(_translate("MainWindow", "Dev1", None)) - self.label_4.setText(_translate("MainWindow", "Counter:", None)) - self.lineEdit_counter.setText(_translate("MainWindow", "ctr0", None)) - self.label_3.setText(_translate("MainWindow", "Pulse Out:", None)) - self.lineEdit_pulse_out.setText(_translate("MainWindow", "ctr2", None)) - self.checkBox_aux_counter.setText( - _translate("MainWindow", "Aux Counter", None) - ) - self.label_data_bits.setText( - _translate("MainWindow", "Data Bits", None) - ) - self.lineEdit_data_bits.setText(_translate("MainWindow", "32", None)) diff --git a/analysis/sync/scripts/analysis_example.py b/analysis/sync/scripts/analysis_example.py deleted file mode 100755 index 1c85121..0000000 --- a/analysis/sync/scripts/analysis_example.py +++ /dev/null @@ -1,24 +0,0 @@ -""" -Simple use case for Dataset class. This should be expanded and show all - features of Dataset at some point. - -""" -from sync.dataset import Dataset - - -def main(): - """simple data example""" - dset = Dataset("C:/sync/output/test.h5") - events = dset.get_all_events() - print(("Events:", events)) - - b0 = dset.get_bit(0) - print(b0[:20]) - - import ipdb - - ipdb.set_trace() - - -if __name__ == '__main__': - main() diff --git a/analysis/sync/scripts/sample_signal.py b/analysis/sync/scripts/sample_signal.py deleted file mode 100755 index ad57318..0000000 --- a/analysis/sync/scripts/sample_signal.py +++ /dev/null @@ -1,32 +0,0 @@ -""" -Just flips two Digital IO lines at different rates. - -This should be expanded to generate different types of signals and perhaps be - part of a testing suite. - -""" -from toolbox.IO.nidaq import DigitalOutput -import numpy as np -import time - -do = DigitalOutput("Dev2", port=1) -do.start() - - -counter = 0 -counter_2 = 0 -print("Running...") -while True: - to_write = counter % 2 - do.writeBit(0, to_write) - if counter % 2 == 0: - to_write = counter_2 % 2 - do.writeBit(1, to_write) - counter_2 += 1 - counter += 1 - if counter % 1000 == 0: - print(counter) - # time.sleep(0.1) - -do.stop() -do.clear() diff --git a/analysis/sync/scripts/sample_signal_fast.py b/analysis/sync/scripts/sample_signal_fast.py deleted file mode 100755 index eae1b73..0000000 --- a/analysis/sync/scripts/sample_signal_fast.py +++ /dev/null @@ -1,19 +0,0 @@ -""" -Sample signal. High speed pulse output for benchmarking. -""" -import time - -from toolbox.IO.nidaq import CounterOutputFreq - - -def main(): - co = CounterOutputFreq( - 'Dev2', 'ctr3', init_delay=0.0, freq=1000.0, duty_cycle=0.50 - ) - co.start() - time.sleep(10) - co.clear() - - -if __name__ == '__main__': - main() diff --git a/analysis/sync/sync.py b/analysis/sync/sync.py deleted file mode 100755 index 31ee897..0000000 --- a/analysis/sync/sync.py +++ /dev/null @@ -1,446 +0,0 @@ -#!/usr/bin/env python -""" -sync.py - -Allen Instute of Brain Science - -created on Oct 10 2014 - -@author: derricw - -""" - -import datetime -import time - -import h5py as h5 -import numpy as np - -from toolbox.IO.nidaq import ( - EventInput, - CounterInputU32, - CounterInputU64, - CounterOutputFreq, - DigitalInput, -) -from toolbox.misc.timer import timeit -from .dataset import Dataset - -sync_version = 1.0 - - -class Sync(object): - """ - Sets up a combination of a single EventInput, counter input/ - output pair to record IO events in a compact binary file. - - Parameters - ---------- - device : str - NI DAQ Device, ex: 'Dev1' - counter_input : str - NI Counter terminal, ex: 'ctr0' - counter_output : str - NI Counter terminal, ex: 'ctr0' - output_path : str - Output file path, optional - event_bits : int (32) - Event Input bits - counter_bits : int (32) - 32 or 64 - freq : float (100000.0) - Pulse generator frequency - verbose : bool (False) - Verbose mode prints a lot of stuff. - - - Example - ------- - >>> from sync import Sync - >>> import time - >>> s = Sync('Dev1','ctr0','ctr2,'C:/output.sync', freq=100000.0) - >>> s.start() - >>> time.sleep(5) # collect events for 5 seconds - >>> s.stop() # can be restarted - >>> s.clear() # cannot be restarted - - """ - - def __init__( - self, - device, - counter_input, - counter_output, - output_path, - event_bits=32, - counter_bits=32, - freq=100000.0, - verbose=False, - force_sync_callback=False, - ): - - self.device = device - self.counter_input = counter_input - self.counter_output = counter_output - self.counter_bits = counter_bits - self.output_path = output_path - self.event_bits = event_bits - self.freq = freq - self.verbose = verbose - - # Configure input counter - if self.counter_bits == 32: - self.ci = CounterInputU32(device=device, counter=counter_input) - callback = self._EventCallback32bit - elif self.counter_bits == 64: - self.ci = CounterInputU64(device=device, lsb_counter=counter_input,) - callback = self._EventCallback64bit - else: - raise ValueError("Counter can only be 32 or 64 bits.") - - output_terminal_str = "Ctr%sInternalOutput" % counter_output[-1] - self.ci.setCountEdgesTerminal(output_terminal_str) - - # Configure Pulse Generator - if self.verbose: - print(("Counter input terminal", self.ci.getCountEdgesTerminal())) - - self.co = CounterOutputFreq( - device=device, - counter=counter_output, - init_delay=0.0, - freq=freq, - duty_cycle=0.50, - ) - - if self.verbose: - print(("Counter output terminal: ", self.co.getPulseTerminal())) - - # Configure Event Input - self.ei = EventInput( - device=device, - bits=self.event_bits, - buffer_size=200, - force_synchronous_callback=force_sync_callback, - buffer_callback=callback, - timeout=0.01, - ) - - # Configure Optional Counters - ## TODO: ADD THIS - self.optional_counters = [] - - self.line_labels = ["" for x in range(32)] - - self.bin = open(self.output_path, 'wb') - - def add_counter(self, counter_input): - """ - Add an extra counter to this dataset. - """ - pass - - def add_label(self, bit, name): - self.line_labels[bit] = name - - def start(self): - """ - Starts all tasks. They don't necessarily have to all - start simultaneously. - - """ - self.start_time = str(datetime.datetime.now()) # get a timestamp - - self.ci.start() - self.co.start() - self.ei.start() - - def stop(self): - """ - Stops all tasks. They can be restarted. - - ***This doesn't seem to work sometimes. I don't know why.*** - - #should we just use clear? - """ - self.ei.stop() - self.co.stop() - self.ci.stop() - - def clear(self, out_file=None): - """ - Clears all tasks. They cannot be restarted. - """ - self.ei.clear() - self.ci.clear() - self.co.clear() - - self.timeouts = self.ei.timeouts[:] - - self.ei = None - self.ci = None - self.co = None - - self.bin.flush() - time.sleep(0.2) - self.bin.close() - - self.bin = None - - self.stop_time = str(datetime.datetime.now()) - - self._save_hdf5(out_file) - - def _save_hdf5(self, output_file_path=None): - # save sync data - if output_file_path: - filename = output_file_path - else: - filename = self.output_path + ".h5" - data = np.fromfile(self.output_path, dtype=np.uint32) - if self.counter_bits == 32: - data = data.reshape(-1, 2) - else: - data = data.reshape(-1, 3) - h5_output = h5.File(filename, 'w') - h5_output.create_dataset("data", data=data) - # save meta data - meta_data = str(self._get_meta_data()) - meta_data_np = np.string_(meta_data) - h5_output.create_dataset("meta", data=meta_data_np) - h5_output.close() - if self.verbose: - print(("Recorded %i events." % len(data))) - print(("Metadata: %s" % meta_data)) - print(("Saving to %s" % filename)) - try: - ds = Dataset(filename) - ds.stats() - ds.close() - except Exception as e: - print(("Failed to print quick stats: %s" % e)) - - def _get_meta_data(self): - """ - - """ - from .dataset import dset_version - - meta_data = { - 'ni_daq': { - 'device': self.device, - 'counter_input': self.counter_input, - 'counter_output': self.counter_output, - 'counter_output_freq': self.freq, - 'event_bits': self.event_bits, - 'counter_bits': self.counter_bits, - }, - 'start_time': self.start_time, - 'stop_time': self.stop_time, - 'line_labels': self.line_labels, - 'timeouts': self.timeouts, - 'version': {'dataset': dset_version, 'sync': sync_version,}, - } - return meta_data - - # @timeit - def _EventCallback32bit(self, data): - """ - Callback for change event. - - Writing is already buffered by open(). OS handles it. - """ - self.bin.write(np.ctypeslib.as_array(self.ci.read())) - self.bin.write(np.ctypeslib.as_array(data)) - - # @timeit - def _EventCallback64bit(self, data): - """ - Callback for change event for 64-bit counter. - """ - (lsb, msb) = self.ci.read() - self.bin.write(np.ctypeslib.as_array(lsb)) - self.bin.write(np.ctypeslib.as_array(msb)) - self.bin.write(np.ctypeslib.as_array(data)) - - -if __name__ == "__main__": - - import signal - import argparse - import sys - - from PyQt4 import QtCore - - description = """ - - sync.py\n - - This program creates a process that controls three NIDAQmx tasks.\n - - 1) An event input task monitors all digital lines for rising or falling - edges.\n - 2) A pulse generator task creates a timebase for the events.\n - 3) A counter counts pulses on the timebase.\n - - """ - - parser = argparse.ArgumentParser( - description=description, - formatter_class=argparse.RawDescriptionHelpFormatter, - ) - parser.add_argument("output_path", type=str, help="output data path") - parser.add_argument( - "-d", "--device", type=str, help="NIDAQ Device to use.", default="Dev1" - ) - parser.add_argument( - "-c", - "--counter_bits", - type=int, - default=64, - help="Counter timebase bits.", - ) - parser.add_argument( - "-b", - "--event_bits", - type=int, - default=32, - help="Change detection bits.", - ) - parser.add_argument( - "-v", - "--verbose", - action="store_true", - default=False, - help="Print a bunch of crap.", - ) - parser.add_argument( - "-f", - "--force", - action="store_true", - help="Force synchronous callbacks.", - ) - parser.add_argument( - "-hz", - "--frequency", - type=float, - default=10000000.0, - help="Pulse (timebase) frequency.", - ) - - args = parser.parse_args() - - output_path = args.output_path - force_sync_callback = args.force - device = args.device - counter_bits = args.counter_bits - event_bits = args.event_bits - verbose = args.verbose - freq = args.frequency - - print("Starting task...") - - # print(args.__dict__) - - if force_sync_callback: - - """ - Using the force_sync_callback option in NIDAQmx. Have to create a - thread to handle the sync object or it will lock up this thread - when signal gets fast. - - """ - - class SyncObject(QtCore.QObject): - """ - Thread for sync control. We use Qt because it has a really - nice event loop. - """ - - cleared = QtCore.pyqtSignal() - - def __init__(self, parent=None, params={}): - QtCore.QObject.__init__(self, parent) - self.params = params - - def start(self): - # create Sync objects - self.sync = Sync( - device, - "ctr0", - "ctr2", - output_path, - counter_bits=counter_bits, - event_bits=event_bits, - freq=freq, - verbose=verbose, - force_sync_callback=True, - ) - - self.sync.start() - - def clear(self): - self.sync.clear() - print("Cleared...") - self.cleared.emit() - - app = QtCore.QCoreApplication(sys.argv) - - s_obj = SyncObject() - s_thr = QtCore.QThread() - - s_obj.moveToThread(s_thr) - s_thr.start() - s_thr.setPriority(QtCore.QThread.TimeCriticalPriority) - - # starts sync object within thread - QtCore.QTimer.singleShot(100, s_obj.start) - - timer = QtCore.QTimer() - timer.start(500) - # check for python signals every 500ms - timer.timeout.connect(lambda: None) - - def sigint_handler(*args): - print("Shutting down...") - QtCore.QTimer.singleShot(100, s_obj.clear) - - def finished(*args): - s_thr.terminate() - QtCore.QCoreApplication.quit() - - s_obj.cleared.connect(finished) - - signal.signal(signal.SIGINT, sigint_handler) - - sys.exit(app.exec_()) - - else: - - """ - In this mode, NIDAQmx creates and handles its own threading. - It is unclear how/if this is better. - """ - sync = Sync( - device, - "ctr0", - "ctr2", - counter_bits=counter_bits, - event_bits=event_bits, - freq=freq, - output_path=output_path, - verbose=verbose, - force_sync_callback=False, - ) - - def signal_handler(signal, frame): - sync.clear() - print('Shutting down...') - sys.exit(0) - - signal.signal(signal.SIGINT, signal_handler) - - sync.start() - - while True: - time.sleep(1) diff --git a/analysis/sync/tango/sync_device.py b/analysis/sync/tango/sync_device.py deleted file mode 100755 index 26fdcae..0000000 --- a/analysis/sync/tango/sync_device.py +++ /dev/null @@ -1,239 +0,0 @@ -""" -sync_device.py - -Allen Institute for Brain Science - -created on 22 Oct 2014 - -@author: derricw - -Tango device for controlling the sync program. Creates attributes for - experiment setup and commands for starting/stopping. - -""" - -import time -import pickle as pickle -from shutil import copyfile -import os - -from PyTango.server import server_run -from PyTango.server import Device, DeviceMeta -from PyTango.server import attribute, command -from PyTango import DevState, AttrWriteType - -from sync import Sync - - -class SyncDevice(Device, metaclass=DeviceMeta): - - """ - Tango Sync device class. - - Parameters - ---------- - None - - Examples - -------- - - >>> from PyTango.server import server_run - >>> server_run((SyncDevice,)) - - """ - - time = attribute() # read only is default - - error_handler = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - device = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - counter_input = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - counter_output = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - pulse_freq = attribute(dtype=float, access=AttrWriteType.READ_WRITE,) - - output_path = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - line_labels = attribute(dtype=str, access=AttrWriteType.READ_WRITE,) - - # ------------------------------------------------------------------------------ - # INIT - # ------------------------------------------------------------------------------ - - def init_device(self): - """ - Device constructor. Automatically run by Tango upon device export. - """ - self.set_state(DevState.ON) - self.set_status("READY") - self.attr_error_handler = "" - self.attr_device = 'Dev1' - self.attr_counter_input = 'ctr0' - self.attr_counter_output = 'ctr2' - self.attr_counter_bits = 64 - self.attr_event_bits = 24 - self.attr_pulse_freq = 10000000.0 - self.attr_output_path = "C:/sync/output/test.h5" - self.attr_line_labels = "[]" - print("Device initialized...") - - # ------------------------------------------------------------------------------ - # Attribute R/W - # ------------------------------------------------------------------------------ - - def read_time(self): - return time.time() - - def read_error_handler(self): - return self.attr_error_handler - - def write_error_handler(self, data): - self.attr_error_handler = data - - def read_device(self): - return self.attr_device - - def write_device(self, data): - self.attr_device = data - - def read_counter_input(self): - return self.attr_counter_input - - def write_counter_input(self, data): - self.attr_counter_input = data - - def read_counter_output(self): - return self.attr_counter_output - - def write_counter_output(self, data): - self.attr_counter_output = data - - def read_pulse_freq(self): - return self.attr_pulse_freq - - def write_pulse_freq(self, data): - self.attr_pulse_freq = data - - def read_output_path(self): - return self.attr_output_path - - def write_output_path(self, data): - self.attr_output_path = data - - def read_line_labels(self): - return self.attr_line_labels - - def write_line_labels(self, data): - self.attr_line_labels = data - - # ------------------------------------------------------------------------------ - # Commands - # ------------------------------------------------------------------------------ - - @command(dtype_in=str, dtype_out=str) - def echo(self, data): - """ - For testing. Just echos whatever string you send. - """ - return data - - @command(dtype_in=str, dtype_out=None) - def throw(self, msg): - print(("Raising exception:", msg)) - # Send to error handler or sequencing engine - - @command(dtype_in=None, dtype_out=None) - def start(self): - """ - Starts an experiment. - """ - print("Starting experiment...") - - self.sync = Sync( - device=self.attr_device, - counter_input=self.attr_counter_input, - counter_output=self.attr_counter_output, - counter_bits=self.attr_counter_bits, - event_bits=self.attr_event_bits, - output_path=self.attr_output_path, - freq=self.attr_pulse_freq, - verbose=True, - force_sync_callback=False, - ) - - lines = eval(self.attr_line_labels) - for index, line in enumerate(lines): - self.sync.add_label(index, line) - - self.sync.start() - - @command(dtype_in=None, dtype_out=None) - def stop(self): - """ - Stops an experiment and clears the NIDAQ tasks. - """ - print("Stopping experiment...") - try: - self.sync.stop() - except Exception as e: - print(e) - - self.sync.clear(self.attr_output_path) - self.sync = None - del self.sync - - @command(dtype_in=str, dtype_out=None) - def load_config(self, path): - """ - Loads a configuration from a .pkl file. - """ - print(("Loading configuration: %s" % path)) - - with open(path, 'rb') as f: - config = pickle.load(f) - - self.attr_device = config['device'] - self.attr_counter_input = config['counter'] - self.attr_counter_output = config['pulse'] - self.attr_counter_bits = int(config['counter_bits']) - self.attr_event_bits = int(config['event_bits']) - self.attr_pulse_freq = float(config['freq']) - self.attr_output_path = config['output_dir'] - self.attr_line_labels = str(config['labels']) - - @command(dtype_in=str, dtype_out=None) - def save_config(self, path): - """ - Saves a configuration to a .pkl file. - """ - print(("Saving configuration: %s" % path)) - - config = { - 'device': self.attr_device, - 'counter': self.attr_counter_input, - 'pulse': self.attr_counter_output, - 'freq': self.attr_pulse_freq, - 'output_dir': self.attr_output_path, - 'labels': eval(self.attr_line_labels), - 'counter_bits': self.attr_counter_bits, - 'event_bits': self.attr_event_bits, - } - - with open(path, 'wb') as f: - pickle.dump(config, f) - - @command(dtype_in=str, dtype_out=None) - def copy_dataset(self, folder): - """ - Copies last dataset to specified folder. - """ - source = self.attr_output_path - dest = os.path.join(folder, os.path.basename(source)) - - copyfile(source, dest) - - -if __name__ == "__main__": - server_run((SyncDevice,)) diff --git a/analysis/test.py b/analysis/test.py deleted file mode 100644 index 8c44f3f..0000000 --- a/analysis/test.py +++ /dev/null @@ -1,13 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Thu Jan 14 14:37:00 2021 - -@author: saskiad -""" - -import os -#print(os.listdir('/Volumes')) -#print(os.listdir(r'/Volumes/New Volume')) -#print(os.listdir(r'/Users/saskiad/Documents/Data/New_Volume')) -print(os.listdir(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_New')) \ No newline at end of file diff --git a/oscopetools/sync/gui/__init__.py b/oscopetools/sync/gui/__init__.py old mode 100644 new mode 100755 From 3746c81c85af39e9432dc658e5bb8eb49d9d10b0 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 13:43:39 -0400 Subject: [PATCH 64/68] Strip trailing whitespace from all .py files Remove spaces at the end of each line and on blank lines. No other changes are made. --- analysis/DGgrid_analysis_5x5_nikon_SdV.py | 176 +++++++++--------- analysis/center_surround.py | 101 +++++----- analysis/center_surround_previous.py | 111 ++++++----- analysis/center_surround_tf.py | 107 ++++++----- .../locally_sparse_noise_events.py | 8 +- analysis/get_all_data.py | 58 +++--- analysis/locally_sparse_noise.py | 40 ++-- analysis/read_data.py | 10 +- analysis/size_tuning.py | 101 +++++----- analysis/stim_table.py | 8 +- oscopetools/locally_sparse_noise.py | 40 ++-- oscopetools/sync/sync.py | 2 +- 12 files changed, 379 insertions(+), 383 deletions(-) diff --git a/analysis/DGgrid_analysis_5x5_nikon_SdV.py b/analysis/DGgrid_analysis_5x5_nikon_SdV.py index f953136..5a8af81 100644 --- a/analysis/DGgrid_analysis_5x5_nikon_SdV.py +++ b/analysis/DGgrid_analysis_5x5_nikon_SdV.py @@ -18,7 +18,7 @@ import nd2reader def run_analysis(): - + exp_date = '20190605' mouse_ID = '462046' im_filetype = 'nd2'#'h5' @@ -31,17 +31,17 @@ def run_analysis(): exptpath = find_exptpath(exp_superpath,exp_date,mouse_ID) im_directory = find_impath(im_superpath,exp_date,mouse_ID) savepath = r'\\allen\\programs\\braintv\\workgroups\\ophysdev\\OPhysCore\\OpenScope\\Multiplex\\coordinates\\' - + stim_table = create_stim_table(exptpath) - + fluorescence = get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath) - + mean_sweep_response, sweep_response = get_mean_sweep_response(fluorescence,stim_table) - + best_location = plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,savepath) write_text_file(best_location,exp_date+'_'+mouse_ID,savepath) - + def find_exptpath(exp_superpath,exp_date,mouse_ID): exptpath = None @@ -59,34 +59,34 @@ def find_impath(im_superpath,exp_date,mouse_ID): return im_path def write_text_file(best_location,save_name,savepath): - + f = open(savepath+save_name+'_coordinates.txt','w') f.write(str(best_location[0])) f.write(',') f.write(str(best_location[1])) f.close() - + def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): - + x_pos = np.unique(stim_table['PosX'].values) x_pos = x_pos[np.argwhere(np.isfinite(x_pos))] y_pos = np.unique(stim_table['PosY'].values) y_pos = y_pos[np.argwhere(np.isfinite(y_pos))] ori = np.unique(stim_table['Ori'].values) ori = ori[np.argwhere(np.isfinite(ori))] - + num_x = len(x_pos) num_y = len(y_pos) num_sweeps = len(sweep_response) - + plt.figure(figsize=(20,20)) ax = [] for x in range(num_x): for y in range(num_y): - ax.append(plt.subplot2grid((num_x,num_y), (x,y), colspan=1) ) + ax.append(plt.subplot2grid((num_x,num_y), (x,y), colspan=1) ) + + ori_colors=['k','b','m','r','y','g'] - ori_colors=['k','b','m','r','y','g'] - #convert fluorescence to dff baseline_frames = 28 weighted_average = np.zeros((2,)) @@ -94,10 +94,10 @@ def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): for i in range(num_sweeps): baseline = np.mean(sweep_response[i,:baseline_frames]) sweep_response[i,:] = sweep_response[i,:] - baseline - + y_max = np.max(sweep_response.flatten()) - y_min = np.min(sweep_response.flatten()) - + y_min = np.min(sweep_response.flatten()) + for x in range(len(x_pos)): is_x = stim_table['PosX'] == x_pos[x][0] for y in range(len(y_pos)): @@ -127,12 +127,12 @@ def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): this_ax.plot([baseline_frames, baseline_frames],[y_min,y_max],'k--') this_ax.set_title('X: ' + str(x_pos[x][0]) + ', Y: ' + str(y_pos[y][0])) plt.savefig(exptpath+exp_date+'_'+mouse_ID+'_DGgrid_traces.png',dpi=300) - plt.close() - + plt.close() + weighted_average = weighted_average / summed_response - + best_location = (round(weighted_average[0],1),round(weighted_average[1],1)) - + return best_location @@ -144,7 +144,7 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): y_pos = y_pos[np.argwhere(np.isfinite(y_pos))] ori = np.unique(stim_table['Ori'].values) ori = ori[np.argwhere(np.isfinite(ori))] - + response_grid = np.zeros((len(y_pos),len(x_pos))) for o in range(len(ori)): is_ori = stim_table['Ori'] == ori[o][0] @@ -152,7 +152,7 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): for x in range(len(x_pos)): is_x = stim_table['PosX'] == x_pos[x][0] for y in range(len(y_pos)): - is_y = stim_table['PosY'] == y_pos[y][0] + is_y = stim_table['PosY'] == y_pos[y][0] is_repeat = (is_x & is_y & is_ori).values repetition_idx = np.argwhere(is_repeat) if any(repetition_idx==0): @@ -162,14 +162,14 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): repetition_responses[rep] = mean_sweep_response[repetition_idx[rep]] ori_responses[y,x] = np.mean(repetition_responses) ori_responses = np.subtract(ori_responses,np.mean(ori_responses.flatten())) - response_grid = np.add(response_grid,ori_responses) - + response_grid = np.add(response_grid,ori_responses) + plt.figure() plt.imshow(response_grid,vmax=np.max(response_grid),vmin=-np.max(response_grid),cmap=u'bwr',interpolation='none',origin='lower') plt.colorbar() plt.xlabel('X Pos') - plt.ylabel('Y Pos') - + plt.ylabel('Y Pos') + x_tick_labels = range(len(x_pos)) for i in range(len(x_pos)): x_tick_labels[i] = str(x_pos[i][0]) @@ -178,17 +178,17 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): y_tick_labels[i] = str(y_pos[i][0]) plt.xticks(np.arange(len(x_pos)),x_tick_labels) plt.yticks(np.arange(len(y_pos)),y_tick_labels) - + plt.savefig(exptpath+'/DGgrid_response') - + def get_mean_sweep_response(fluorescence,stim_table): sweeplength = int(stim_table.End[1] - stim_table.Start[1]) interlength = 28 extralength = 7 - + num_stim_presentations = len(stim_table['Start']) - mean_sweep_response = np.zeros((num_stim_presentations,)) + mean_sweep_response = np.zeros((num_stim_presentations,)) sweep_response = np.zeros((num_stim_presentations,sweeplength+interlength)) for i in range(num_stim_presentations): start = stim_table['Start'][i]-interlength @@ -197,18 +197,18 @@ def get_mean_sweep_response(fluorescence,stim_table): sweep_dff = 100*((sweep_f/np.mean(sweep_f[:interlength]))-1) sweep_response[i,:] = sweep_f mean_sweep_response[i] = np.mean(sweep_dff[interlength:(interlength+sweeplength)]) - + return mean_sweep_response, sweep_response -def load_single_tif(file_path): +def load_single_tif(file_path): return tiff.imread(file_path) - -def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath): - + +def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath): + if os.path.isfile(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy'): avg_fluorescence = np.load(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy') else: - + im_path = None if im_filetype=='nd2': for f in os.listdir(im_directory): @@ -225,18 +225,18 @@ def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mou else: print 'im_filetype not recognized!' sys.exit(1) - + if im_filetype=='nd2': print 'Reading nd2...' read_obj = nd2reader.Nd2(im_path) num_frames = len(read_obj.frames) avg_fluorescence = np.zeros((num_frames,)) - + sweep_starts = stim_table['Start'].values block_bounds = [] block_bounds.append((np.min(sweep_starts)-30,np.max(sweep_starts[sweep_starts<50000])+100)) block_bounds.append((np.min(sweep_starts[sweep_starts>50000])-30,np.max(sweep_starts)+100)) - + for block in block_bounds: frame_start = int(block[0]) frame_end = int(block[1]) @@ -250,21 +250,21 @@ def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mou avg_fluorescence = np.mean(data,axis=(1,2)) f.close() np.save(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy',avg_fluorescence) - + return avg_fluorescence - + def create_stim_table(exptpath): - + #load stimulus and sync data data = load_pkl(exptpath) twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise = load_sync(exptpath) - + display_sequence = data['stimuli'][0]['display_sequence'] display_sequence += data['pre_blank_sec'] display_sequence *= int(data['fps']) #in stimulus frames - + sweep_frames = data['stimuli'][0]['sweep_frames'] - stimulus_table = pd.DataFrame(sweep_frames,columns=('start','end')) + stimulus_table = pd.DataFrame(sweep_frames,columns=('start','end')) stimulus_table['dif'] = stimulus_table['end']-stimulus_table['start'] stimulus_table.start += display_sequence[0,0] for seg in range(len(display_sequence)-1): @@ -274,21 +274,21 @@ def create_stim_table(exptpath): stimulus_table.end = stimulus_table.start+stimulus_table.dif print len(stimulus_table) stimulus_table = stimulus_table[stimulus_table.end <= display_sequence[-1,1]] - stimulus_table = stimulus_table[stimulus_table.start <= display_sequence[-1,1]] + stimulus_table = stimulus_table[stimulus_table.start <= display_sequence[-1,1]] print len(stimulus_table) sync_table = pd.DataFrame(np.column_stack((twop_frames[stimulus_table['start']],twop_frames[stimulus_table['end']])), columns=('Start', 'End')) - + #populate stimulus parameters print data['stimuli'][0]['stim_path'] - + #get center parameters sweep_order = data['stimuli'][0]['sweep_order'] - sweep_order = sweep_order[:len(stimulus_table)] + sweep_order = sweep_order[:len(stimulus_table)] sweep_table = data['stimuli'][0]['sweep_table'] - dimnames = data['stimuli'][0]['dimnames'] - sweep_table = pd.DataFrame(sweep_table, columns=dimnames) - - #populate sync_table + dimnames = data['stimuli'][0]['dimnames'] + sweep_table = pd.DataFrame(sweep_table, columns=dimnames) + + #populate sync_table sync_table['SF'] = np.NaN sync_table['TF'] = np.NaN sync_table['Contrast'] = np.NaN @@ -303,11 +303,11 @@ def create_stim_table(exptpath): sync_table['Ori'][index] = sweep_table['Ori'][int(sweep_order[index])] sync_table['PosX'][index] = sweep_table['PosX'][int(sweep_order[index])] sync_table['PosY'][index] = sweep_table['PosY'][int(sweep_order[index])] - + return sync_table - + def load_sync(exptpath): - + #verify that sync file exists in exptpath syncMissing = True for f in os.listdir(exptpath): @@ -324,28 +324,28 @@ def load_sync(exptpath): print d.line_labels #set the appropriate sample frequency sample_freq = d.meta_data['ni_daq']['counter_output_freq'] - + #get sync timing for each channel twop_vsync_fall = d.get_falling_edges('2p_vsync')/sample_freq - #stim_vsync_fall = d.get_falling_edges('vsync_stim')[1:]/sample_freq #eliminating the DAQ pulse - stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse + #stim_vsync_fall = d.get_falling_edges('vsync_stim')[1:]/sample_freq #eliminating the DAQ pulse + stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq - + print 'num stim vsyncs: ' + str(len(stim_vsync_fall)) print 'num 2p frames: ' + str(len(twop_vsync_fall)) print 'num photodiode flashes: ' + str(len(photodiode_rise)) #make sure all of the sync data are available channels = {'twop_vsync_fall': twop_vsync_fall, 'stim_vsync_fall':stim_vsync_fall, 'photodiode_rise': photodiode_rise} - channel_test = [] + channel_test = [] for i in channels: channel_test.append(any(channels[i])) if all(channel_test): print "All channels present." else: print "Not all channels present. Sync test failed." - sys.exit() - + sys.exit() + #test and correct for photodiode transition errors ptd_rise_diff = np.ediff1d(photodiode_rise) short = np.where(np.logical_and(ptd_rise_diff>0.1, ptd_rise_diff<0.3))[0] @@ -366,12 +366,12 @@ def load_sync(exptpath): # plt.figure() # plt.hist(ptd_rise_diff) # plt.show() - + # plt.figure() # plt.plot(stim_vsync_fall[:300]) # plt.title('stim vsync start') # plt.show() - + # plt.figure() # plt.plot(photodiode_rise[:10]) # plt.title('photodiode start') @@ -381,16 +381,16 @@ def load_sync(exptpath): # plt.plot(stim_vsync_fall[-300:]) # plt.title('stim vsync end') # plt.show() - + # plt.figure() # plt.plot(photodiode_rise[-10:]) # plt.title('photodiode end') # plt.show() - + print 'ptd_start: ' + str(ptd_start) if ptd_start > 3: print "Photodiode events before stimulus start. Deleted." - + # ptd_errors = [] # while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): # error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end]<1.8)[0] + ptd_start @@ -399,40 +399,40 @@ def load_sync(exptpath): # ptd_errors.append(photodiode_rise[error_frames[-1]]) # ptd_end-=1 # ptd_rise_diff = np.ediff1d(photodiode_rise) - + first_pulse = ptd_start stim_on_photodiode_idx = 60+120*np.arange(0,ptd_end+1-ptd_start-1,1) - + #stim_vsync_fall = stim_vsync_fall[0] + np.arange(stim_on_photodiode_idx.max()+481) * 0.0166666 - + # stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] # photodiode_on = photodiode_rise[first_pulse + np.arange(0,ptd_end+1-ptd_start-1,1)] -# +# # plt.figure() # plt.plot(stim_on_photodiode[:4]) # plt.title('stim start') # plt.show() -# +# # plt.figure() # plt.plot(photodiode_on[:4]) # plt.title('photodiode start') # plt.show() -# +# # delay_rise = photodiode_on - stim_on_photodiode # init_delay_period = delay_rise < 0.025 # init_delay = np.mean(delay_rise[init_delay_period]) -# +# # plt.figure() # plt.plot(delay_rise[:10]) # plt.title('delay rise') # plt.show() - - delay = 0.0#init_delay + + delay = 0.0#init_delay print "monitor delay: " , delay - + #adjust stimulus time with monitor delay stim_time = stim_vsync_fall + delay - + #convert stimulus frames into twop frames twop_frames = np.empty((len(stim_time),1)) acquisition_ends_early = 0 @@ -445,14 +445,14 @@ def load_sync(exptpath): twop_frames[i:len(stim_time)]=np.NaN acquisition_ends_early = 1 break - + if acquisition_ends_early>0: - print "Acquisition ends before stimulus" - + print "Acquisition ends before stimulus" + return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise def load_pkl(exptpath): - + #verify that pkl file exists in exptpath logMissing = True for f in os.listdir(exptpath): @@ -463,13 +463,13 @@ def load_pkl(exptpath): if logMissing: print "No pkl file" sys.exit() - + #load data from pkl file f = open(logpath, 'rb') data = pickle.load(f) f.close() - + return data - -if __name__=='__main__': + +if __name__=='__main__': run_analysis() \ No newline at end of file diff --git a/analysis/center_surround.py b/analysis/center_surround.py index 903b031..bce2b7d 100644 --- a/analysis/center_surround.py +++ b/analysis/center_surround.py @@ -25,32 +25,32 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - + self.eye_thresh = eye_thresh self.cre = cre self.area = area self.depth = depth - + self.orivals = range(0,360,45) self.tfvals = [1,2] self.conditions = ['center','iso','ortho','blank'] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - + #load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - + #load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - + + #get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') #add condition column @@ -61,19 +61,19 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' #get spontaneous window self.stim_table_spont = self.get_spont_table() - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() # self.first, self.second = self.cross_validate_response() self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT = self.get_metrics() - + #save outputs # self.save_data() - + #plot traces def get_spont_table(self): @@ -97,7 +97,7 @@ def get_stimulus_response(self): ------- sweep response: full trial for each trial mean sweep response: mean response for each trial -sweep_eye: eye position across the full trial +sweep_eye: eye position across the full trial mean_sweep_eye: mean of first three time points of eye position for each trial response_mean: mean response for each stimulus condition response_std: std of response to each stimulus condition @@ -105,14 +105,14 @@ def get_stimulus_response(self): ''' sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): #uses the global dff trace sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - + #computes DF/F using the mean of the inter-sweep gray for the Fo # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) @@ -122,7 +122,7 @@ def get_stimulus_response(self): mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - + #make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) @@ -138,9 +138,9 @@ def get_stimulus_response(self): p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position + #compute mean response across trials, only use trials within eye_thresh of mean eye position response = np.empty((8,4,self.numbercells, 4)) #center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials - + for oi, cori in enumerate(self.orivals): for ci, cond in enumerate(self.conditions): if cond=='blank': @@ -151,22 +151,22 @@ def get_stimulus_response(self): (mean_sweep_eye.total0, tuning, 0) @@ -206,7 +206,7 @@ def get_osi(self, tuning): for i in range(8): CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -215,17 +215,17 @@ def get_metrics(self): ------- metrics dataframe ''' - + n_iter = 50 n_trials = int(self.response[:,:,:,2].min()) print("Number of trials for cross-validation: " + str(n_trials)) # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] cell_index = np.array(range(self.numbercells)) response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('center_dir','center_osi','center_dsi','iso','ortho', + + metrics = pd.DataFrame(columns=('center_dir','center_osi','center_dsi','iso','ortho', 'suppression_strength','suppression_tuning','cmi'), index=cell_index) - + #cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) @@ -234,7 +234,7 @@ def get_metrics(self): STRENGTH = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - + for ni in range(n_iter): #find pref direction for each cell for center only condition response_first = response_first[:,:,cell_index,:] @@ -244,7 +244,7 @@ def get_metrics(self): pref_ori = sort[0][sortind] cell_index = sort[1][sortind] inds = np.vstack((pref_ori, cell_index)) - + #osi OSI.loc[ni] = self.get_osi(response_second[:, 0, inds[1], ni]) @@ -252,24 +252,24 @@ def get_metrics(self): null_ori= np.mod(pref_ori+4, 8) pref = response_second[inds[0], 0, inds[1], ni] null = response_second[null_ori, 0, inds[1], ni] - null = np.where(null>0, null, 0) + null = np.where(null>0, null, 0) DSI.loc[ni] = (pref-null)/(pref+null) - + center = response_second[inds[0], 0, inds[1], ni] iso = response_second[inds[0], 1, inds[1], ni] - ortho = response_second[inds[0], 2, inds[1], ni] + ortho = response_second[inds[0], 2, inds[1], ni] #suppression strength STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center - + #suppression tuning TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) - + #iso ISO.loc[ni] = (center - iso) / (center + iso) - + #ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - + #context modulation index (Keller et al) #TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) @@ -294,10 +294,10 @@ def get_metrics(self): metrics['blank_mean'] = self.response[0,3,cell_index,0] metrics['blank_std'] = self.response[0,3,cell_index,1] metrics['iso_mean'] = self.response[sort[0][sortind],1,cell_index,0] - metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] + metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] metrics['ortho_mean'] = self.response[sort[0][sortind],2,cell_index,0] metrics['ortho_std'] = self.response[sort[0][sortind],2,cell_index,1] - + metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) metrics['cre'] = self.cre metrics['area'] = self.area @@ -321,7 +321,7 @@ def save_data(self): dset = f.create_dataset('response', data=self.response) f.close() - + if __name__=='__main__': expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_989418742_data.h5' eye_thresh = 10 @@ -329,7 +329,7 @@ def save_data(self): area = 'area test' depth = '33' cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - + # manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') # subset = manifest[manifest.Target=='soma'] # print(len(subset)) @@ -354,5 +354,4 @@ def save_data(self): # print(expt_path + " FAILED") # failed.append(int(row.Center_Surround_Expt_ID)) - - \ No newline at end of file + diff --git a/analysis/center_surround_previous.py b/analysis/center_surround_previous.py index 3d3c4d3..9e11040 100644 --- a/analysis/center_surround_previous.py +++ b/analysis/center_surround_previous.py @@ -25,32 +25,32 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - + self.eye_thresh = eye_thresh self.cre = cre self.area = area self.depth = depth - + self.orivals = range(0,360,45) self.tfvals = [1,2] self.conditions = ['center','iso','ortho','blank'] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - + #load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - + #load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - + + #get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') #add condition column @@ -61,19 +61,19 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' #get spontaneous window self.stim_table_spont = self.get_spont_table() - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() # self.first, self.second = self.cross_validate_response() self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT, self.DIR = self.get_metrics() - + #save outputs self.save_data() - + #plot traces def get_spont_table(self): @@ -97,7 +97,7 @@ def get_stimulus_response(self): ------- sweep response: full trial for each trial mean sweep response: mean response for each trial -sweep_eye: eye position across the full trial +sweep_eye: eye position across the full trial mean_sweep_eye: mean of first three time points of eye position for each trial response_mean: mean response for each stimulus condition response_std: std of response to each stimulus condition @@ -105,14 +105,14 @@ def get_stimulus_response(self): ''' sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): #uses the global dff trace sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - + #computes DF/F using the mean of the inter-sweep gray for the Fo # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) @@ -122,7 +122,7 @@ def get_stimulus_response(self): mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - + #make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) @@ -138,10 +138,10 @@ def get_stimulus_response(self): p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position + #compute mean response across trials, only use trials within eye_thresh of mean eye position response = np.empty((8,4,self.numbercells, 4)) #center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials - - + + for oi, cori in enumerate(self.orivals): for ci, cond in enumerate(self.conditions): if cond=='blank': @@ -152,22 +152,22 @@ def get_stimulus_response(self): (mean_sweep_eye.total0, tuning, 0) @@ -207,7 +207,7 @@ def get_osi(self, tuning): for i in range(8): CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + def get_metrics(self): @@ -217,18 +217,18 @@ def get_metrics(self): ------- metrics dataframe ''' - + n_iter = 50 n_trials = int(self.response[:,:,:,2].min()) print("Number of trials for cross-validation: " + str(n_trials)) # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] cell_index = np.array(range(self.numbercells)) response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('cell_index','center_dir','center_osi','center_dsi','iso','ortho', + + metrics = pd.DataFrame(columns=('cell_index','center_dir','center_osi','center_dsi','iso','ortho', 'suppression_strength','suppression_tuning','cmi','dir_percent'), index=cell_index) metrics.cell_index = cell_index - + #cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) @@ -238,7 +238,7 @@ def get_metrics(self): TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - + for ni in range(n_iter): #find pref direction for each cell for center only condition # response_first = response_first[:,:,cell_index,:] @@ -248,9 +248,9 @@ def get_metrics(self): pref_ori = sort[0][sortind] cell_index = sort[1][sortind] inds = np.vstack((pref_ori, cell_index)) - + DIR.loc[ni] = pref_ori - + #osi OSI.loc[ni] = self.get_osi(response_second[:, 0, inds[1], ni]) @@ -258,28 +258,28 @@ def get_metrics(self): null_ori= np.mod(pref_ori+4, 8) pref = response_second[inds[0], 0, inds[1], ni] null = response_second[null_ori, 0, inds[1], ni] - null = np.where(null>0, null, 0) + null = np.where(null>0, null, 0) DSI.loc[ni] = (pref-null)/(pref+null) - + center = response_second[inds[0], 0, inds[1], ni] iso = response_second[inds[0], 1, inds[1], ni] - ortho = response_second[inds[0], 2, inds[1], ni] + ortho = response_second[inds[0], 2, inds[1], ni] center = np.where(center>0, center, 0) iso = np.where(iso>0, iso, 0) ortho = np.where(ortho>0, ortho, 0) - + #suppression strength STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center - + #suppression tuning TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) - + #iso ISO.loc[ni] = (center - iso) / (center + iso) - + #ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - + #context modulation index (Keller et al) #TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) @@ -291,7 +291,7 @@ def get_metrics(self): metrics['suppression_strength'] = STRENGTH.mean().values metrics['suppression_tuning'] = TUNING.mean().values metrics['cmi'] = CONTEXT.mean().values - + #how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() @@ -310,10 +310,10 @@ def get_metrics(self): metrics['blank_mean'] = self.response[0,3,cell_index,0] metrics['blank_std'] = self.response[0,3,cell_index,1] metrics['iso_mean'] = self.response[sort[0][sortind],1,cell_index,0] - metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] + metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] metrics['ortho_mean'] = self.response[sort[0][sortind],2,cell_index,0] metrics['ortho_std'] = self.response[sort[0][sortind],2,cell_index,1] - + b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) @@ -323,7 +323,7 @@ def get_metrics(self): newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - + metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) metrics['cre'] = self.cre metrics['area'] = self.area @@ -347,7 +347,7 @@ def save_data(self): dset = f.create_dataset('response', data=self.response) f.close() - + if __name__=='__main__': # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_993269234_data.h5' ## expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex New/Center Surround/Center_Surround_993269234_data.h5' @@ -356,7 +356,7 @@ def save_data(self): # area = 'area test' # depth = '33' # cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - + manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') subset = manifest[manifest.Target=='soma'] print(len(subset)) @@ -382,5 +382,4 @@ def save_data(self): print(expt_path + " FAILED") failed.append(int(row.Center_Surround_Expt_ID)) - - \ No newline at end of file + diff --git a/analysis/center_surround_tf.py b/analysis/center_surround_tf.py index 3489918..864b16a 100644 --- a/analysis/center_surround_tf.py +++ b/analysis/center_surround_tf.py @@ -25,32 +25,32 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - + self.eye_thresh = eye_thresh self.cre = cre self.area = area self.depth = depth - + self.orivals = range(0,360,45) self.tfvals = [1.,2.] self.conditions = ['center','iso','ortho','blank'] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - + #load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - + #load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - + + #get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') #add condition column @@ -61,19 +61,19 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' #get spontaneous window self.stim_table_spont = self.get_spont_table() - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() # self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT = self.get_metrics() - + #save outputs self.save_data() - + #plot traces def get_spont_table(self): @@ -97,7 +97,7 @@ def get_stimulus_response(self): ------- sweep response: full trial for each trial mean sweep response: mean response for each trial -sweep_eye: eye position across the full trial +sweep_eye: eye position across the full trial mean_sweep_eye: mean of first three time points of eye position for each trial response_mean: mean response for each stimulus condition response_std: std of response to each stimulus condition @@ -105,14 +105,14 @@ def get_stimulus_response(self): ''' sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): #uses the global dff trace sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - + #computes DF/F using the mean of the inter-sweep gray for the Fo # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) @@ -122,7 +122,7 @@ def get_stimulus_response(self): mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - + #make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) @@ -138,9 +138,9 @@ def get_stimulus_response(self): p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position + #compute mean response across trials, only use trials within eye_thresh of mean eye position response = np.empty((8, 2, 4, self.numbercells, 4)) #center_ori X TF x center/iso/ortho/blank X cells X mean, std, #trials, % significant trials - + for oi, cori in enumerate(self.orivals): for ti, tf in enumerate(self.tfvals): for ci, cond in enumerate(self.conditions): @@ -152,22 +152,22 @@ def get_stimulus_response(self): (self.stim_table.condition==cond)&(mean_sweep_eye.total0, tuning, 0) @@ -209,7 +209,7 @@ def get_osi(self, tuning): for i in range(8): CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -218,17 +218,17 @@ def get_metrics(self): ------- metrics dataframe ''' - + n_iter = 50 n_trials = int(self.response[:,:,:,:,2].min()) print("Number of trials for cross-validation: " + str(n_trials)) cell_index = np.array(range(self.numbercells)) response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('cell_index','center_dir','center_tf','center_osi','center_dsi','iso','ortho', + + metrics = pd.DataFrame(columns=('cell_index','center_dir','center_tf','center_osi','center_dsi','iso','ortho', 'suppression_strength','suppression_tuning','cmi','dir_percent'), index=cell_index) metrics.cell_index = cell_index - + #cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) @@ -238,7 +238,7 @@ def get_metrics(self): TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - + for ni in range(n_iter): #find pref direction for each cell for center only condition # response_first = response_first[:,:,:,cell_index,:] @@ -250,9 +250,9 @@ def get_metrics(self): pref_tf = sort[1][sortind] cell_index = sort[2][sortind] inds = np.vstack((pref_ori, pref_tf, cell_index)) - + DIR.loc[ni] = pref_ori - + #osi OSI.loc[ni] = self.get_osi(response_second[:, inds[1], 0, inds[2], ni]) @@ -260,24 +260,24 @@ def get_metrics(self): null_ori= np.mod(pref_ori+4, 8) pref = response_second[inds[0], inds[1], 0, inds[2], ni] null = response_second[null_ori, inds[1], 0, inds[2], ni] - null = np.where(null>0, null, 0) + null = np.where(null>0, null, 0) DSI.loc[ni] = (pref-null)/(pref+null) - + center = response_second[inds[0], inds[1], 0, inds[2], ni] iso = response_second[inds[0], inds[1], 1, inds[2], ni] - ortho = response_second[inds[0], inds[1], 2, inds[2], ni] + ortho = response_second[inds[0], inds[1], 2, inds[2], ni] #suppression strength STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center - + #suppression tuning TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) - + #iso ISO.loc[ni] = (center - iso) / (center + iso) - + #ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - + #context modulation index (Keller et al) #TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) @@ -289,7 +289,7 @@ def get_metrics(self): metrics['suppression_strength'] = STRENGTH.mean().values metrics['suppression_tuning'] = TUNING.mean().values metrics['cmi'] = CONTEXT.mean().values - + #how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() @@ -310,10 +310,10 @@ def get_metrics(self): metrics['blank_mean'] = self.response[0,0,3,cell_index,0] metrics['blank_std'] = self.response[0,0,3,cell_index,1] metrics['iso_mean'] = self.response[pref_ori,pref_tf,1,cell_index,0] - metrics['iso_std'] = self.response[pref_ori,pref_tf,1,cell_index,1] + metrics['iso_std'] = self.response[pref_ori,pref_tf,1,cell_index,1] metrics['ortho_mean'] = self.response[pref_ori,pref_tf,2,cell_index,0] metrics['ortho_std'] = self.response[pref_ori,pref_tf,2,cell_index,1] - + b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) @@ -323,7 +323,7 @@ def get_metrics(self): newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - + metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) metrics['cre'] = self.cre metrics['area'] = self.area @@ -347,7 +347,7 @@ def save_data(self): dset = f.create_dataset('response', data=self.response) f.close() - + if __name__=='__main__': # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_1006636506_data.h5' # eye_thresh = 10 @@ -355,7 +355,7 @@ def save_data(self): # area = 'area test' # depth = '33' # cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - + manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') subset = manifest[manifest.Target=='soma'] print(len(subset)) @@ -381,5 +381,4 @@ def save_data(self): print(expt_path + " FAILED") failed.append(int(row.Center_Surround_Expt_ID)) - - \ No newline at end of file + diff --git a/analysis/example_code/locally_sparse_noise_events.py b/analysis/example_code/locally_sparse_noise_events.py index 06affad..91da1ca 100644 --- a/analysis/example_code/locally_sparse_noise_events.py +++ b/analysis/example_code/locally_sparse_noise_events.py @@ -83,11 +83,11 @@ def __init__(self, session_id): self.response_events_off_8deg, ) = self.get_stimulus_response(self.LSN_8deg) ======= - + f = h5py.File(dff_path, 'r') self.dff = f['data'][()] f.close() - + self.stim_table_sp, _, _ = core.get_stim_table(self.session_id, 'spontaneous') lsn_name = 'locally_sparse_noise' @@ -131,7 +131,7 @@ def get_stimulus_response(self, LSN): ].mean() ======= sweep_events = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): sweep_events[str(nc)][index] = self.l0_events[nc, int(row.start)-28:int(row.start)+35] @@ -310,7 +310,7 @@ def save_data(self, lsn_name): <<<<<<< Updated upstream lsn = LocallySparseNoise(session_id=session_id) ======= - + dff_path = r'/Volumes/My Passport/Openscope Multiplex/891653201/892006924_dff.h5 lsn = LocallySparseNoise(session_id=session_id) >>>>>>> Stashed changes diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 9e86971..3987700 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -16,7 +16,7 @@ from get_eye_tracking import align_eye_tracking def get_all_data(path_name, save_path, expt_name, row): - + #get access to sub folders for f in os.listdir(path_name): if f.startswith('ophys_experiment'): @@ -29,7 +29,7 @@ def get_all_data(path_name, save_path, expt_name, row): for f in os.listdir(proc_path): if f.startswith('ophys_cell_segmentation_run'): roi_path = os.path.join(proc_path, f) - + #ROI table for fname in os.listdir(expt_path): if fname.endswith('output_cell_roi_creation.json'): @@ -40,13 +40,13 @@ def get_all_data(path_name, save_path, expt_name, row): break roi_locations = pd.DataFrame.from_dict(data = jin['rois'], orient='index') roi_locations.drop(columns=['exclude_code','mask_page'], inplace=True) #removing columns I don't think we need - roi_locations.reset_index(inplace=True) - + roi_locations.reset_index(inplace=True) + session_id = int( path_name.split('/')[-1] ) roi_locations['session_id'] = session_id - + #dff traces for f in os.listdir(expt_path): if f.endswith('_dff.h5'): @@ -63,46 +63,46 @@ def get_all_data(path_name, save_path, expt_name, row): raw_traces = f['data'][()] cell_ids = f['roi_names'][()].astype(str) f.close() - roi_locations['cell_id'] = cell_ids - + roi_locations['cell_id'] = cell_ids + #eyetracking for fn in os.listdir(eye_path): if fn.endswith('mapping.h5'): dlc_file = os.path.join(eye_path, fn) for f in os.listdir(expt_path): if f.endswith('time_synchronization.h5'): - temporal_alignment_file = os.path.join(expt_path, f) + temporal_alignment_file = os.path.join(expt_path, f) eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) # pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas') # eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas') # pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') -# -# ##temporal alignment +# +# ##temporal alignment # f = h5py.File(temporal_alignment_file, 'r') # eye_frames = f['eye_tracking_alignment'].value # f.close() # eye_frames = eye_frames.astype(int) # eye_frames = eye_frames[np.where(eye_frames>0)] -# +# # eye_area_sync = eye_area[eye_frames] # pupil_area_sync = pupil_area[eye_frames] # x_pos_sync = pos.x_pos_deg.values[eye_frames] # y_pos_sync = pos.y_pos_deg.values[eye_frames] -# +# # ##correcting dropped camera frames # test = eye_frames[np.isfinite(eye_frames)] # test = test.astype(int) # temp2 = np.bincount(test) -# dropped_camera_frames = np.where(temp2>2)[0] +# dropped_camera_frames = np.where(temp2>2)[0] # for a in dropped_camera_frames: # null_2p_frames = np.where(eye_frames==a)[0] # eye_area_sync[null_2p_frames] = np.NaN # pupil_area_sync[null_2p_frames] = np.NaN # x_pos_sync[null_2p_frames] = np.NaN # y_pos_sync[null_2p_frames] = np.NaN -# +# # eye_sync = pd.DataFrame(data=np.vstack((eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync)).T, columns=('eye_area','pupil_area','x_pos_deg','y_pos_deg')) - + #max projection mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') mp = Image.open(mp_path) @@ -112,7 +112,7 @@ def get_all_data(path_name, save_path, expt_name, row): boundary_path = os.path.join(roi_path, 'maxInt_boundary.png') boundary = Image.open(boundary_path) boundary_array = np.array(boundary) - + #stimulus table stim_table = create_stim_tables(path_name) #returns dictionary. Not sure how to save dictionary so pulling out each dataframe @@ -121,7 +121,7 @@ def get_all_data(path_name, save_path, expt_name, row): #pad end with NaNs to match length of dff nframes = dff.shape[1] - dxds.shape[0] dx = np.append(dxds, np.repeat(np.NaN, nframes)) - + #remove traces with NaNs from dff, roi_table, and roi_masks roi_locations['roi_mask_id'] = range(len(roi_locations)) to_keep = np.where(np.isfinite(dff[:,0]))[0] @@ -129,12 +129,12 @@ def get_all_data(path_name, save_path, expt_name, row): roi_locations['finite'] = np.isfinite(dff[:,0]) roi_trimmed = roi_locations[roi_locations.finite] roi_trimmed.reset_index(inplace=True) - + new_dff = dff[to_keep,:] - + for i in to_del: boundary_array[np.where(boundary_array==i)] = 0 - + #meta data meta_data = {} meta_data['mouse_id'] = row.Mouse_ID @@ -144,7 +144,7 @@ def get_all_data(path_name, save_path, expt_name, row): meta_data['container_ID'] = row.Container_ID meta_data['session_ID'] = session_id meta_data['startdate'] = startdate - + #Save Data save_file = os.path.join(save_path, expt_name+'_'+str(session_id)+'_data.h5') print("Saving data to: ", save_file) @@ -153,7 +153,7 @@ def get_all_data(path_name, save_path, expt_name, row): for key in stim_table.keys(): store[key] = stim_table[key] store['eye_tracking'] = eye_sync - + store.close() f = h5py.File(save_file, 'r+') dset = f.create_dataset('dff_traces', data=new_dff) @@ -163,7 +163,7 @@ def get_all_data(path_name, save_path, expt_name, row): dset4 = f.create_dataset('roi_outlines', data=boundary_array) dset5 = f.create_dataset('running_speed', data=dx) dset6 = f.create_dataset('meta_data', data=str(meta_data)) - f.close() + f.close() return @@ -189,16 +189,16 @@ def get_all_data(path_name, save_path, expt_name, row): expt_name = 'Size_Tuning' path_name = os.path.join(r'/Volumes/New Volume', str(int(expt_id))) get_all_data(path_name, save_path, expt_name, row) -# +# # row = manifest.loc[27] # expt_id = row.Center_Surround_Expt_ID # path_name = os.path.join(r'/Volumes/New Volume', str(int(expt_id)))#975348996' # expt_name = 'Multiplex' # save_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim' # get_all_data(path_name, save_path, expt_name, row) - - - - - + + + + + diff --git a/analysis/locally_sparse_noise.py b/analysis/locally_sparse_noise.py index 0fb97e0..e97e3a3 100644 --- a/analysis/locally_sparse_noise.py +++ b/analysis/locally_sparse_noise.py @@ -25,30 +25,30 @@ def __init__(self, expt_path): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() self.numbercells = self.dff.shape[0] - + #create stimulus table for locally sparse noise self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') #load stimulus template self.LSN = np.load(lsn_path) - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) self.peak = self.get_peak() - + #save outputs # self.save_data() - + #plot traces self.plot_LSN_Traces() @@ -66,9 +66,9 @@ def get_stimulus_response(self, LSN): ''' sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] @@ -77,9 +77,9 @@ def get_stimulus_response(self, LSN): mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) mean_sweep_eye = sweep_eye.applymap(do_eye) - - + + x_shape = LSN.shape[1] y_shape = LSN.shape[2] response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) @@ -95,7 +95,7 @@ def get_stimulus_response(self, LSN): response_off[xp,yp,:,0] = subset_off.mean(axis=0) response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye - + def get_peak(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -108,8 +108,8 @@ def get_peak(self): peak['rf_off'] = False on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] - peak.rf_on.loc[on_rfs] = True - peak.rf_off.loc[off_rfs] = True + peak.rf_on.loc[on_rfs] = True + peak.rf_off.loc[off_rfs] = True return peak def save_data(self): @@ -126,7 +126,7 @@ def save_data(self): dset = f.create_dataset('response_on', data=self.response_on) dset1 = f.create_dataset('response_off', data=self.response_off) f.close() - + def plot_LSN_Traces(self): '''plots ON and OFF traces for each position for each cell''' print "Plotting LSN traces for all cells" @@ -158,16 +158,16 @@ def plot_LSN_Traces(self): for i in range(1,sp_pt+1): ax = plt.subplot(8,14,i) ax.set_ylim(vmin, vmax) - + plt.tight_layout() plt.suptitle("Cell " + str(nc+1), fontsize=20) plt.subplots_adjust(top=0.9) filename = 'Traces LSN Cell_'+str(nc+1)+'.png' - fullfilename = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', filename) - plt.savefig(fullfilename) - plt.close() + fullfilename = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', filename) + plt.savefig(fullfilename) + plt.close() + - if __name__=='__main__': lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' #update this to local path the the stimulus array expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_1010436210_data.h5' diff --git a/analysis/read_data.py b/analysis/read_data.py index 8b4c620..fa1c03e 100644 --- a/analysis/read_data.py +++ b/analysis/read_data.py @@ -71,16 +71,16 @@ def get_stimulus_epochs(file_path, session_type): stim_epoch.sort_values(by='Start', inplace=True) stim_epoch.reset_index(inplace=True) stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start - + elif session_type=='drifting_gratings_grid': stim_name_1 = 'drifting_gratings_grid' stim_epoch = get_epochs(file_path, stim_name_1) elif session_type=='center_surround': stim_name_1 = 'center_surround' stim_epoch = get_epochs(file_path, stim_name_1) - + return stim_epoch - + def get_epochs(file_path, stim_name_1): stim1 = get_stimulus_table(file_path, stim_name_1) stim2 = get_stimulus_table(file_path, 'locally_sparse_noise') @@ -99,7 +99,7 @@ def get_epochs(file_path, stim_name_1): stim_epoch.reset_index(inplace=True) stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start return stim_epoch - - + + diff --git a/analysis/size_tuning.py b/analysis/size_tuning.py index 8354a13..321fba3 100644 --- a/analysis/size_tuning.py +++ b/analysis/size_tuning.py @@ -25,49 +25,49 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - + self.eye_thresh = eye_thresh self.cre = cre self.area = area self.depth = depth - + self.orivals = range(0,360,45) self.tfvals = [1.,2.] self.sizevals = [30,52,67,79,120] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - + #load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - + #load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - + + #get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'drifting_gratings_size') #get spontaneous window self.stim_table_spont = self.get_spont_table() - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() # self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) self.metrics, self.OSI, self.DSI, self.DIR = self.get_metrics() - + #save outputs self.save_data() - + #plot traces def get_spont_table(self): @@ -78,8 +78,8 @@ def get_spont_table(self): stim_table_spont.Start = self.stim_table.End[spont_start]+1 stim_table_spont.End = self.stim_table.Start[spont_start+1]-1 return stim_table_spont - - + + def get_stimulus_response(self): '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. @@ -89,7 +89,7 @@ def get_stimulus_response(self): ------- sweep response: full trial for each trial mean sweep response: mean response for each trial -sweep_eye: eye position across the full trial +sweep_eye: eye position across the full trial mean_sweep_eye: mean of first three time points of eye position for each trial response_mean: mean response for each stimulus condition response_std: std of response to each stimulus condition @@ -97,14 +97,14 @@ def get_stimulus_response(self): ''' sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): #uses the global dff trace sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - + #computes DF/F using the mean of the inter-sweep gray for the Fo # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) @@ -114,7 +114,7 @@ def get_stimulus_response(self): mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - + #make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) @@ -130,10 +130,10 @@ def get_stimulus_response(self): p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position + #compute mean response across trials, only use trials within eye_thresh of mean eye position response = np.empty((8, 2, 6, self.numbercells, 4)) #ori X TF x size X cells X mean, std, #trials, % significant trials - response[:] = np.NaN - + response[:] = np.NaN + for oi, ori in enumerate(self.orivals): for ti, tf in enumerate(self.tfvals): for si, size in enumerate(self.sizevals): @@ -141,12 +141,12 @@ def get_stimulus_response(self): (self.stim_table.Size==size)&(mean_sweep_eye.total0, tuning, 0) @@ -207,7 +207,7 @@ def get_osi(self, tuning): for i in range(8): CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -216,23 +216,23 @@ def get_metrics(self): ------- metrics dataframe ''' - + n_iter = 50 n_trials = int(np.nanmin(self.response[:,:,1:,:,2])) print("Number of trials for cross-validation: " + str(n_trials)) cell_index = np.array(range(self.numbercells)) response_first, response_second = self.cross_validate_response(n_iter, n_trials) - + metrics = pd.DataFrame(columns=('cell_index','dir','tf','prefsize','osi','dsi','dir_percent', 'peak_mean','peak_std','blank_mean','blank_std', 'peak_percent_trials'), index=cell_index) metrics.cell_index = cell_index - + #cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - + for ni in range(n_iter): #find pref direction for each cell for center only condition # response_first = response_first[:,:,:,cell_index,:] @@ -246,9 +246,9 @@ def get_metrics(self): pref_size = sort[2][sortind] cell_index = sort[3][sortind] inds = np.vstack((pref_ori, pref_tf, pref_size,cell_index)) - + DIR.loc[ni] = pref_ori - + #osi OSI.loc[ni] = self.get_osi(response_second[:, inds[1], inds[2], inds[3], ni]) @@ -256,12 +256,12 @@ def get_metrics(self): null_ori= np.mod(pref_ori+4, 8) pref = response_second[inds[0], inds[1], inds[2], inds[3], ni] null = response_second[null_ori, inds[1], inds[2], inds[3], ni] - null = np.where(null>0, null, 0) - DSI.loc[ni] = (pref-null)/(pref+null) + null = np.where(null>0, null, 0) + DSI.loc[ni] = (pref-null)/(pref+null) metrics['osi'] = OSI.mean().values metrics['dsi'] = DSI.mean().values - + #how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() @@ -282,7 +282,7 @@ def get_metrics(self): metrics['peak_percent_trials'] = self.response[pref_ori, pref_tf,pref_size,cell_index,3] metrics['blank_mean'] = self.response[0,0,0,cell_index,0] metrics['blank_std'] = self.response[0,0,0,cell_index,1] - + b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) @@ -292,7 +292,7 @@ def get_metrics(self): newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - + metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) metrics['cre'] = self.cre metrics['area'] = self.area @@ -316,7 +316,7 @@ def save_data(self): dset = f.create_dataset('response', data=self.response) f.close() - + if __name__=='__main__': # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_976843461_data.h5' # eye_thresh = 10 @@ -324,7 +324,7 @@ def save_data(self): # area = 'area test' # depth = '33' # szt = SizeTuning(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - + manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') subset = manifest[manifest.Target=='soma'] print(len(subset)) @@ -349,5 +349,4 @@ def save_data(self): print(expt_path + " FAILED") failed.append(int(row.Size_Tuning_Expt_ID)) - - \ No newline at end of file + diff --git a/analysis/stim_table.py b/analysis/stim_table.py index 25a15c3..f2752c9 100644 --- a/analysis/stim_table.py +++ b/analysis/stim_table.py @@ -166,7 +166,7 @@ def DGsize_table(data, twop_frames, verbose = True): stim_table[attribute] = get_attribute_by_sweep( data, DGs_idx, attribute )[:len(stim_table)] - + x_corr, y_corr = get_center_coordinates(data, DGs_idx) stim_table['Center_x'] = x_corr stim_table['Center_y'] = y_corr @@ -223,7 +223,7 @@ def center_surround_table(data, twop_frames, verbose = True): )), columns=('Start', 'End') ) - + x_corr, y_corr = get_center_coordinates(data, center_idx) stim_table['Center_x'] = x_corr stim_table['Center_y'] = y_corr @@ -326,7 +326,7 @@ def get_attribute_by_sweep(data, stimulus_idx, attribute): try: attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx] except: - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx][0] + attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx][0] return attribute_by_sweep @@ -383,7 +383,7 @@ def load_alignment(exptpath): ophys_path = os.path.join(exptpath, f) for f in os.listdir(ophys_path): if f.endswith('time_synchronization.h5'): - temporal_alignment_file = os.path.join(ophys_path, f) + temporal_alignment_file = os.path.join(ophys_path, f) f = h5py.File(temporal_alignment_file, 'r') twop_frames = f['stimulus_alignment'].value f.close() diff --git a/oscopetools/locally_sparse_noise.py b/oscopetools/locally_sparse_noise.py index fc6c3df..fc5d3cb 100644 --- a/oscopetools/locally_sparse_noise.py +++ b/oscopetools/locally_sparse_noise.py @@ -48,8 +48,8 @@ def __init__(self, expt_path): self.dff = f['data'][()] ======= self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - - #load dff traces + + #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] >>>>>>> Stashed changes:analysis/locally_sparse_noise.py @@ -62,7 +62,7 @@ def __init__(self, expt_path): stim_dict = lsnCS_create_stim_table(self.expt_path) self.stim_table = stim_dict['locally_sparse_noise'] ======= - + #create stimulus table for locally sparse noise self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') >>>>>>> Stashed changes:analysis/locally_sparse_noise.py @@ -84,17 +84,17 @@ def __init__(self, expt_path): # save outputs self.save_data() ======= - + #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - + #run analysis self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) self.peak = self.get_peak() - + #save outputs # self.save_data() - + #plot traces self.plot_LSN_Traces() >>>>>>> Stashed changes:analysis/locally_sparse_noise.py @@ -125,9 +125,9 @@ def get_stimulus_response(self, LSN): ] ======= sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - + sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - + for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] @@ -137,7 +137,7 @@ def get_stimulus_response(self, LSN): mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) mean_sweep_eye = sweep_eye.applymap(do_eye) - + <<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py # make spontaneous p_values @@ -159,7 +159,7 @@ def get_stimulus_response(self, LSN): # sweep_p_values[str(nc)] = p_values ======= - + >>>>>>> Stashed changes:analysis/locally_sparse_noise.py x_shape = LSN.shape[1] y_shape = LSN.shape[2] @@ -206,7 +206,7 @@ def get_stimulus_response(self, LSN): response_off[xp,yp,:,0] = subset_off.mean(axis=0) response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye - + >>>>>>> Stashed changes:analysis/locally_sparse_noise.py def get_peak(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -235,8 +235,8 @@ def save_data(self): ======= on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] - peak.rf_on.loc[on_rfs] = True - peak.rf_off.loc[off_rfs] = True + peak.rf_on.loc[on_rfs] = True + peak.rf_off.loc[off_rfs] = True return peak def save_data(self): @@ -262,7 +262,7 @@ def save_data(self): expt_path = r'/Volumes/My Passport/Openscope Multiplex/891653201' lsn = LocallySparseNoise(expt_path=expt_path) ======= - + def plot_LSN_Traces(self): '''plots ON and OFF traces for each position for each cell''' print "Plotting LSN traces for all cells" @@ -294,16 +294,16 @@ def plot_LSN_Traces(self): for i in range(1,sp_pt+1): ax = plt.subplot(8,14,i) ax.set_ylim(vmin, vmax) - + plt.tight_layout() plt.suptitle("Cell " + str(nc+1), fontsize=20) plt.subplots_adjust(top=0.9) filename = 'Traces LSN Cell_'+str(nc+1)+'.png' - fullfilename = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', filename) - plt.savefig(fullfilename) - plt.close() + fullfilename = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', filename) + plt.savefig(fullfilename) + plt.close() + - if __name__=='__main__': lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' #update this to local path the the stimulus array expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_1010436210_data.h5' diff --git a/oscopetools/sync/sync.py b/oscopetools/sync/sync.py index 31ee897..0d9c3eb 100755 --- a/oscopetools/sync/sync.py +++ b/oscopetools/sync/sync.py @@ -158,7 +158,7 @@ def start(self): def stop(self): """ Stops all tasks. They can be restarted. - + ***This doesn't seem to work sometimes. I don't know why.*** #should we just use clear? From 578470976cd8b3408582cc8aa71e0822074e1b58 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 14:37:41 -0400 Subject: [PATCH 65/68] Resolve merge conflicts from ad507cd This fixes the files that were broken by merge of pull request #5 from efharkin/master into saskiad/master (ad507cd): analysis/example_code/locally_sparse_noise_events.py oscopetools/locally_sparse_noise.py Files were fixes by choosing Saskia's version of analysis/example_code/locally_sparse_noise_events.py and moving analysis/locally_sparse_noise.py into oscopetools, since the analysis version contains changes from Saskia. These files were broken by the merge because uncommitted changes in Saskia's working directory were auto-stashed (stash 37aec39 on top of commit 1ae1800) before the merge and couldn't be re-applied cleanly. This happened because my branch (ending in c6d2628) auto-formatted some blocks that Saskia had been working on. This commit keeps Saskia's changes without applying auto-formatting (that will happen in a future commit). --- .../locally_sparse_noise_events.py | 83 --------- analysis/locally_sparse_noise.py | 174 ------------------ oscopetools/locally_sparse_noise.py | 147 +-------------- 3 files changed, 5 insertions(+), 399 deletions(-) delete mode 100644 analysis/locally_sparse_noise.py diff --git a/analysis/example_code/locally_sparse_noise_events.py b/analysis/example_code/locally_sparse_noise_events.py index 91da1ca..3ed7ab0 100644 --- a/analysis/example_code/locally_sparse_noise_events.py +++ b/analysis/example_code/locally_sparse_noise_events.py @@ -26,63 +26,6 @@ def __init__(self, session_id): self.session_id = session_id save_path_head = #TODO self.save_path = os.path.join(save_path_head, 'LocallySparseNoise') -<<<<<<< Updated upstream - self.l0_events = core.get_L0_events(self.session_id) - self.stim_table_sp, _, _ = core.get_stim_table( - self.session_id, 'spontaneous' - ) - self.dxcm = core.get_running_speed(self.session_id) - try: - lsn_name = 'locally_sparse_noise' - ( - self.stim_table, - self.numbercells, - self.specimen_ids, - ) = core.get_stim_table(self.session_id, lsn_name) - self.LSN = core.get_stimulus_template(self.session_id, lsn_name) - ( - self.sweep_events, - self.mean_sweep_events, - self.sweep_p_values, - self.running_speed, - self.response_events_on, - self.response_events_off, - ) = self.get_stimulus_response(self.LSN) - except: - lsn_name = 'locally_sparse_noise_4deg' - ( - self.stim_table, - self.numbercells, - self.specimen_ids, - ) = core.get_stim_table(self.session_id, lsn_name) - self.LSN_4deg = core.get_stimulus_template( - self.session_id, lsn_name - ) - ( - self.sweep_events_4deg, - self.mean_sweep_events_4deg, - self.sweep_p_values_4deg, - self.running_speed_4deg, - self.response_events_on_4deg, - self.response_events_off_4deg, - ) = self.get_stimulus_response(self.LSN_4deg) - - lsn_name = 'locally_sparse_noise_8deg' - self.stim_table, _, _ = core.get_stim_table( - self.session_id, lsn_name - ) - self.LSN_8deg = core.get_stimulus_template( - self.session_id, lsn_name - ) - ( - self.sweep_events_8deg, - self.mean_sweep_events_8deg, - self.sweep_p_values_8deg, - self.running_speed_8deg, - self.response_events_on_8deg, - self.response_events_off_8deg, - ) = self.get_stimulus_response(self.LSN_8deg) -======= f = h5py.File(dff_path, 'r') self.dff = f['data'][()] @@ -94,7 +37,6 @@ def __init__(self, session_id): self.stim_table, self.numbercells, self.specimen_ids = core.get_stim_table(self.session_id, lsn_name) self.LSN = core.get_stimulus_template(self.session_id, lsn_name) self.sweep_events, self.mean_sweep_events, self.sweep_p_values, self.running_speed, self.response_events_on, self.response_events_off = self.get_stimulus_response(self.LSN) ->>>>>>> Stashed changes self.peak = self.get_peak(lsn_name) self.save_data(lsn_name) @@ -112,32 +54,12 @@ def get_stimulus_response(self, LSN): ''' -<<<<<<< Updated upstream - sweep_events = pd.DataFrame( - index=self.stim_table.index.values, - columns=np.array(list(range(self.numbercells))).astype(str), - ) - running_speed = pd.DataFrame( - index=self.stim_table.index.values, - columns=('running_speed', 'null'), - ) - for index, row in self.stim_table.iterrows(): - for nc in range(self.numbercells): - sweep_events[str(nc)][index] = self.l0_events[ - nc, int(row.start) - 28 : int(row.start) + 35 - ] - running_speed.running_speed[index] = self.dxcm[ - int(row.start) : int(row.start) + 7 - ].mean() -======= sweep_events = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) for index,row in self.stim_table.iterrows(): for nc in range(self.numbercells): sweep_events[str(nc)][index] = self.l0_events[nc, int(row.start)-28:int(row.start)+35] ->>>>>>> Stashed changes - mean_sweep_events = sweep_events.applymap(do_sweep_mean_shifted) # make spontaneous p_values @@ -307,10 +229,5 @@ def save_data(self, lsn_name): if __name__ == '__main__': session_id = 569611979 -<<<<<<< Updated upstream - lsn = LocallySparseNoise(session_id=session_id) -======= - dff_path = r'/Volumes/My Passport/Openscope Multiplex/891653201/892006924_dff.h5 lsn = LocallySparseNoise(session_id=session_id) ->>>>>>> Stashed changes diff --git a/analysis/locally_sparse_noise.py b/analysis/locally_sparse_noise.py deleted file mode 100644 index e97e3a3..0000000 --- a/analysis/locally_sparse_noise.py +++ /dev/null @@ -1,174 +0,0 @@ -#!/usr/bin/env python2 -# -*- coding: utf-8 -*- -""" -Created on Wed Aug 22 10:59:54 2018 - -@author: saskiad -""" - -import numpy as np -import pandas as pd -import os, h5py -import matplotlib.pyplot as plt - -def do_sweep_mean(x): - return x[28:35].mean() - -def do_sweep_mean_shifted(x): - return x[30:40].mean() - -def do_eye(x): - return x[28:32].mean() - -class LocallySparseNoise: - def __init__(self, expt_path): - - self.expt_path = expt_path - self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - - #load dff traces - f = h5py.File(self.expt_path, 'r') - self.dff = f['dff_traces'][()] - f.close() - - self.numbercells = self.dff.shape[0] - - #create stimulus table for locally sparse noise - self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') - - #load stimulus template - self.LSN = np.load(lsn_path) - - #load eyetracking - self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - - #run analysis - self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) - self.peak = self.get_peak() - - #save outputs -# self.save_data() - - #plot traces - self.plot_LSN_Traces() - - def get_stimulus_response(self, LSN): - '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. - -Returns -------- -sweep response: full trial for each trial -mean sweep response: mean response for each trial -sweep p values: p value of each trial compared measured relative to distribution of spontaneous activity -response_on: mean response, s.e.m., and number of responsive trials for each white square -response_off: mean response, s.e.m., and number of responsive trials for each black square - - - ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) - - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) - - for index,row in self.stim_table.iterrows(): - for nc in range(self.numbercells): - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-28:int(row.Start+35)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-28:int(row.Start+35)].values - - mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) - mean_sweep_eye = sweep_eye.applymap(do_eye) - - - - x_shape = LSN.shape[1] - y_shape = LSN.shape[2] - response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) - response_off = np.empty((x_shape, y_shape, self.numbercells, 2)) - for xp in range(x_shape): - for yp in range(y_shape): - on_frame = np.where(LSN[:,xp,yp]==255)[0] - off_frame = np.where(LSN[:,xp,yp]==0)[0] - subset_on = mean_sweep_response[self.stim_table.Frame.isin(on_frame)] - subset_off = mean_sweep_response[self.stim_table.Frame.isin(off_frame)] - response_on[xp,yp,:,0] = subset_on.mean(axis=0) - response_on[xp,yp,:,1] = subset_on.std(axis=0)/np.sqrt(len(subset_on)) - response_off[xp,yp,:,0] = subset_off.mean(axis=0) - response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) - return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye - - def get_peak(self): - '''creates a table of metrics for each cell. We can make this more useful in the future - -Returns -------- -peak dataframe - ''' - peak = pd.DataFrame(columns=('rf_on','rf_off'), index=range(self.numbercells)) - peak['rf_on'] = False - peak['rf_off'] = False - on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] - off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] - peak.rf_on.loc[on_rfs] = True - peak.rf_off.loc[off_rfs] = True - return peak - - def save_data(self): - '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") - print "Saving data to: ", save_file - store = pd.HDFStore(save_file) - store['sweep_response'] = self.sweep_response - store['mean_sweep_response'] = self.mean_sweep_response - store['sweep_p_values'] = self.sweep_p_values - store['peak'] = self.peak - store.close() - f = h5py.File(save_file, 'r+') - dset = f.create_dataset('response_on', data=self.response_on) - dset1 = f.create_dataset('response_off', data=self.response_off) - f.close() - - def plot_LSN_Traces(self): - '''plots ON and OFF traces for each position for each cell''' - print "Plotting LSN traces for all cells" - - for nc in range(self.numbercells): - if np.mod(nc,100)==0: - print "Cell #", str(nc) - plt.figure(nc, figsize=(24,20)) - vmax=0 - vmin=0 - one_cell = self.sweep_response[str(nc)] - for yp in range(8): - for xp in range(14): - sp_pt = (yp*14)+xp+1 - on_frame = np.where(self.LSN[:,yp,xp]==255)[0] - off_frame = np.where(self.LSN[:,yp,xp]==0)[0] - subset_on = one_cell[self.stim_table.Frame.isin(on_frame)] - subset_off = one_cell[self.stim_table.Frame.isin(off_frame)] - ax = plt.subplot(8,14,sp_pt) - ax.plot(subset_on.mean(), color='r', lw=2) - ax.plot(subset_off.mean(), color='b', lw=2) - ax.axvspan(28,35 ,ymin=0, ymax=1, facecolor='gray', alpha=0.3) - vmax = np.where(np.amax(subset_on.mean())>vmax, np.amax(subset_on.mean()), vmax) - vmax = np.where(np.amax(subset_off.mean())>vmax, np.amax(subset_off.mean()), vmax) - vmin = np.where(np.amin(subset_on.mean())>>>>>> Stashed changes:analysis/locally_sparse_noise.py def do_sweep_mean(x): return x[28:35].mean() - def do_sweep_mean_shifted(x): return x[30:40].mean() -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py -======= def do_eye(x): return x[28:32].mean() ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py class LocallySparseNoise: def __init__(self, expt_path): self.expt_path = expt_path -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - self.session_id = self.expt_path.split('/')[ - -1 - ] # this might need to be modified for where the data is for you. - - # load dff traces - for f in os.listdir(self.expt_path): - if f.endswith('_dff.h5'): - dff_path = os.path.join(self.expt_path, f) - f = h5py.File(dff_path, 'r') - self.dff = f['data'][()] -======= self.session_id = self.expt_path.split('/')[-1].split('_')[-2] #load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py f.close() self.numbercells = self.dff.shape[0] -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - - # create stimulus table for locally sparse noise - stim_dict = lsnCS_create_stim_table(self.expt_path) - self.stim_table = stim_dict['locally_sparse_noise'] -======= #create stimulus table for locally sparse noise self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py - # load stimulus template + #load stimulus template self.LSN = np.load(lsn_path) -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - - # run analysis - ( - self.sweep_response, - self.mean_sweep_response, - self.sweep_p_values, - self.response_on, - self.response_off, - ) = self.get_stimulus_response(self.LSN) - self.peak = self.get_peak() - - # save outputs - self.save_data() -======= #load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') @@ -97,7 +51,6 @@ def __init__(self, expt_path): #plot traces self.plot_LSN_Traces() ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py def get_stimulus_response(self, LSN): '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. @@ -112,18 +65,6 @@ def get_stimulus_response(self, LSN): ''' -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - sweep_response = pd.DataFrame( - index=self.stim_table.index.values, - columns=np.array(list(range(self.numbercells))).astype(str), - ) - - for index, row in self.stim_table.iterrows(): - for nc in range(self.numbercells): - sweep_response[str(nc)][index] = self.dff[ - nc, int(row.Start) - 28 : int(row.Start) + 35 - ] -======= sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) @@ -133,70 +74,18 @@ def get_stimulus_response(self, LSN): sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-28:int(row.Start+35)].values sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-28:int(row.Start+35)].values ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) mean_sweep_eye = sweep_eye.applymap(do_eye) -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - # make spontaneous p_values - # TODO: pilot stimulus does not have spontaneous activity. But real data will and we shoudl re-implement this - # shuffled_responses = np.empty((self.numbercells, 10000,10)) - # idx = np.random.choice(range(self.stim_table_sp.start[0], self.stim_table_sp.end[0]), 10000) - # for i in range(10): - # shuffled_responses[:,:,i] = self.l0_events[:,idx+i] - # shuffled_mean = shuffled_responses.mean(axis=2) - sweep_p_values = pd.DataFrame( - index=self.stim_table.index.values, - columns=np.array(list(range(self.numbercells))).astype(str), - ) - # for nc in range(self.numbercells): - # subset = mean_sweep_events[str(nc)].values - # null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) - # actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat - # p_values = np.mean(actual_is_less, axis=1) - # sweep_p_values[str(nc)] = p_values - -======= - ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py + x_shape = LSN.shape[1] y_shape = LSN.shape[2] response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) response_off = np.empty((x_shape, y_shape, self.numbercells, 2)) for xp in range(x_shape): for yp in range(y_shape): -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - on_frame = np.where(LSN[:, xp, yp] == 255)[0] - off_frame = np.where(LSN[:, xp, yp] == 0)[0] - subset_on = mean_sweep_response[ - self.stim_table.Frame.isin(on_frame) - ] - # subset_on_p = sweep_p_values[self.stim_table.frame.isin(on_frame)] - subset_off = mean_sweep_response[ - self.stim_table.Frame.isin(off_frame) - ] - # subset_off_p = sweep_p_values[self.stim_table.frame.isin(off_frame)] - response_on[xp, yp, :, 0] = subset_on.mean(axis=0) - response_on[xp, yp, :, 1] = subset_on.std(axis=0) / np.sqrt( - len(subset_on) - ) - # response_on[xp,yp,:,2] = subset_on_p[subset_on_p<0.05].count().values/float(len(subset_on_p)) - response_off[xp, yp, :, 0] = subset_off.mean(axis=0) - response_off[xp, yp, :, 1] = subset_off.std(axis=0) / np.sqrt( - len(subset_off) - ) - # response_off[xp,yp,:,2] = subset_off_p[subset_off_p<0.05].count().values/float(len(subset_off_p)) - return ( - sweep_response, - mean_sweep_response, - sweep_p_values, - response_on, - response_off, - ) - -======= on_frame = np.where(LSN[:,xp,yp]==255)[0] off_frame = np.where(LSN[:,xp,yp]==0)[0] subset_on = mean_sweep_response[self.stim_table.Frame.isin(on_frame)] @@ -207,7 +96,6 @@ def get_stimulus_response(self, LSN): response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py def get_peak(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -215,24 +103,9 @@ def get_peak(self): ------- peak dataframe ''' - peak = pd.DataFrame( - columns=('rf_on', 'rf_off'), index=list(range(self.numbercells)) - ) + peak = pd.DataFrame(columns=('rf_on','rf_off'), index=range(self.numbercells)) peak['rf_on'] = False peak['rf_off'] = False -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - on_rfs = np.where(self.response_events_on[:, :, :, 2] > 0.25)[2] - off_rfs = np.where(self.response_events_off[:, :, :, 2] > 0.25)[2] - peak.rf_on.loc[on_rfs] = True - peak.rf_off.loc[off_rfs] = True - return peak - - def save_data(self): - save_file = os.path.join( - self.expt_path, str(self.session_id) + "_lsn_analysis.h5" - ) - print("Saving data to: ", save_file) -======= on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] peak.rf_on.loc[on_rfs] = True @@ -243,7 +116,6 @@ def save_data(self): '''saves intermediate analysis files in an h5 file''' save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") print "Saving data to: ", save_file ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response store['mean_sweep_response'] = self.mean_sweep_response @@ -254,14 +126,6 @@ def save_data(self): dset = f.create_dataset('response_on', data=self.response_on) dset1 = f.create_dataset('response_off', data=self.response_off) f.close() -<<<<<<< Updated upstream:oscopetools/locally_sparse_noise.py - - -if __name__ == '__main__': - lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' # update this to local path the the stimulus array - expt_path = r'/Volumes/My Passport/Openscope Multiplex/891653201' - lsn = LocallySparseNoise(expt_path=expt_path) -======= def plot_LSN_Traces(self): '''plots ON and OFF traces for each position for each cell''' @@ -307,5 +171,4 @@ def plot_LSN_Traces(self): if __name__=='__main__': lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' #update this to local path the the stimulus array expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_1010436210_data.h5' - lsn = LocallySparseNoise(expt_path=expt_path) ->>>>>>> Stashed changes:analysis/locally_sparse_noise.py + lsn = LocallySparseNoise(expt_path=expt_path) \ No newline at end of file From 59b2ddf6e2b96d30caff14fa3e97d67a8cba75fb Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 14:59:25 -0400 Subject: [PATCH 66/68] Upgrade to python3 Upgrading to python 3 since 2 is deprecated. - Changed shebang line from python2 to python3 in all scripts - Ran scripts with python 2 print statements through 2to3 - analysis/stim_table.py - analysis/DGgrid_analysis_5x5_nikon_SdV.py - oscopetools/locally_sparse_noise.py --- analysis/DGgrid_analysis_5x5_nikon_SdV.py | 54 +++++++++++------------ analysis/center_surround.py | 2 +- analysis/center_surround_previous.py | 2 +- analysis/center_surround_tf.py | 2 +- analysis/read_data.py | 2 +- analysis/size_tuning.py | 2 +- analysis/stim_table.py | 44 +++++++++--------- oscopetools/locally_sparse_noise.py | 12 ++--- 8 files changed, 60 insertions(+), 60 deletions(-) diff --git a/analysis/DGgrid_analysis_5x5_nikon_SdV.py b/analysis/DGgrid_analysis_5x5_nikon_SdV.py index 5a8af81..54808f8 100644 --- a/analysis/DGgrid_analysis_5x5_nikon_SdV.py +++ b/analysis/DGgrid_analysis_5x5_nikon_SdV.py @@ -10,7 +10,7 @@ import pandas as pd import h5py -import cPickle as pickle +import pickle as pickle from oscopetools.sync import Dataset import tifffile as tiff import matplotlib.pyplot as plt @@ -165,15 +165,15 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): response_grid = np.add(response_grid,ori_responses) plt.figure() - plt.imshow(response_grid,vmax=np.max(response_grid),vmin=-np.max(response_grid),cmap=u'bwr',interpolation='none',origin='lower') + plt.imshow(response_grid,vmax=np.max(response_grid),vmin=-np.max(response_grid),cmap='bwr',interpolation='none',origin='lower') plt.colorbar() plt.xlabel('X Pos') plt.ylabel('Y Pos') - x_tick_labels = range(len(x_pos)) + x_tick_labels = list(range(len(x_pos))) for i in range(len(x_pos)): x_tick_labels[i] = str(x_pos[i][0]) - y_tick_labels = range(len(y_pos)) + y_tick_labels = list(range(len(y_pos))) for i in range(len(y_pos)): y_tick_labels[i] = str(y_pos[i][0]) plt.xticks(np.arange(len(x_pos)),x_tick_labels) @@ -214,20 +214,20 @@ def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mou for f in os.listdir(im_directory): if f.endswith(im_filetype) and f.lower().find('local') == -1: im_path = im_directory + f - print im_path + print(im_path) elif im_filetype=='h5': #find experiment directory: for f in os.listdir(im_directory): if f.lower().find('ophys_experiment_')!=-1: exp_path = im_directory+f+'\\' session_ID = f[17:] - print session_ID + print(session_ID) else: - print 'im_filetype not recognized!' + print('im_filetype not recognized!') sys.exit(1) if im_filetype=='nd2': - print 'Reading nd2...' + print('Reading nd2...') read_obj = nd2reader.Nd2(im_path) num_frames = len(read_obj.frames) avg_fluorescence = np.zeros((num_frames,)) @@ -242,7 +242,7 @@ def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mou frame_end = int(block[1]) for f in np.arange(frame_start,frame_end): this_frame = read_obj.get_image(f,0,read_obj.channels[0],0) - print 'Loaded frame ' + str(f) + ' of ' + str(num_frames) + print('Loaded frame ' + str(f) + ' of ' + str(num_frames)) avg_fluorescence[f] = np.mean(this_frame) elif im_filetype=='h5': f = h5py.File(exp_path+session_ID+'.h5') @@ -272,14 +272,14 @@ def create_stim_table(exptpath): if row.start >= display_sequence[seg,1]: stimulus_table.start[index] = stimulus_table.start[index] - display_sequence[seg,1] + display_sequence[seg+1,0] stimulus_table.end = stimulus_table.start+stimulus_table.dif - print len(stimulus_table) + print(len(stimulus_table)) stimulus_table = stimulus_table[stimulus_table.end <= display_sequence[-1,1]] stimulus_table = stimulus_table[stimulus_table.start <= display_sequence[-1,1]] - print len(stimulus_table) + print(len(stimulus_table)) sync_table = pd.DataFrame(np.column_stack((twop_frames[stimulus_table['start']],twop_frames[stimulus_table['end']])), columns=('Start', 'End')) #populate stimulus parameters - print data['stimuli'][0]['stim_path'] + print(data['stimuli'][0]['stim_path']) #get center parameters sweep_order = data['stimuli'][0]['sweep_order'] @@ -314,14 +314,14 @@ def load_sync(exptpath): if f.endswith('_sync.h5'): syncpath = os.path.join(exptpath, f) syncMissing = False - print "Sync file:", f + print("Sync file:", f) if syncMissing: - print "No sync file" + print("No sync file") sys.exit() #load the sync data from .h5 and .pkl files d = Dataset(syncpath) - print d.line_labels + print(d.line_labels) #set the appropriate sample frequency sample_freq = d.meta_data['ni_daq']['counter_output_freq'] @@ -331,9 +331,9 @@ def load_sync(exptpath): stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq - print 'num stim vsyncs: ' + str(len(stim_vsync_fall)) - print 'num 2p frames: ' + str(len(twop_vsync_fall)) - print 'num photodiode flashes: ' + str(len(photodiode_rise)) + print('num stim vsyncs: ' + str(len(stim_vsync_fall))) + print('num 2p frames: ' + str(len(twop_vsync_fall))) + print('num photodiode flashes: ' + str(len(photodiode_rise))) #make sure all of the sync data are available channels = {'twop_vsync_fall': twop_vsync_fall, 'stim_vsync_fall':stim_vsync_fall, 'photodiode_rise': photodiode_rise} @@ -341,9 +341,9 @@ def load_sync(exptpath): for i in channels: channel_test.append(any(channels[i])) if all(channel_test): - print "All channels present." + print("All channels present.") else: - print "Not all channels present. Sync test failed." + print("Not all channels present. Sync test failed.") sys.exit() #test and correct for photodiode transition errors @@ -355,7 +355,7 @@ def load_sync(exptpath): #find three consecutive pulses at the start of session: two_back_lag = photodiode_rise[2:20] - photodiode_rise[:18] ptd_start = np.argmin(two_back_lag) + 3 - print 'ptd_start: ' + str(ptd_start) + print('ptd_start: ' + str(ptd_start)) #ptd_start = 3 #for i in medium: @@ -387,9 +387,9 @@ def load_sync(exptpath): # plt.title('photodiode end') # plt.show() - print 'ptd_start: ' + str(ptd_start) + print('ptd_start: ' + str(ptd_start)) if ptd_start > 3: - print "Photodiode events before stimulus start. Deleted." + print("Photodiode events before stimulus start. Deleted.") # ptd_errors = [] # while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): @@ -428,7 +428,7 @@ def load_sync(exptpath): # plt.show() delay = 0.0#init_delay - print "monitor delay: " , delay + print("monitor delay: " , delay) #adjust stimulus time with monitor delay stim_time = stim_vsync_fall + delay @@ -447,7 +447,7 @@ def load_sync(exptpath): break if acquisition_ends_early>0: - print "Acquisition ends before stimulus" + print("Acquisition ends before stimulus") return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise @@ -459,9 +459,9 @@ def load_pkl(exptpath): if f.endswith('.pkl'): logpath = os.path.join(exptpath, f) logMissing = False - print "Stimulus log:", f + print("Stimulus log:", f) if logMissing: - print "No pkl file" + print("No pkl file") sys.exit() #load data from pkl file diff --git a/analysis/center_surround.py b/analysis/center_surround.py index bce2b7d..a19f3de 100644 --- a/analysis/center_surround.py +++ b/analysis/center_surround.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 22 10:59:54 2018 diff --git a/analysis/center_surround_previous.py b/analysis/center_surround_previous.py index 9e11040..9bf618d 100644 --- a/analysis/center_surround_previous.py +++ b/analysis/center_surround_previous.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 22 10:59:54 2018 diff --git a/analysis/center_surround_tf.py b/analysis/center_surround_tf.py index 864b16a..c66280c 100644 --- a/analysis/center_surround_tf.py +++ b/analysis/center_surround_tf.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 22 10:59:54 2018 diff --git a/analysis/read_data.py b/analysis/read_data.py index fa1c03e..9fd4e63 100644 --- a/analysis/read_data.py +++ b/analysis/read_data.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat Jun 6 21:59:56 2020 diff --git a/analysis/size_tuning.py b/analysis/size_tuning.py index 321fba3..4efb2a3 100644 --- a/analysis/size_tuning.py +++ b/analysis/size_tuning.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 22 10:59:54 2018 diff --git a/analysis/stim_table.py b/analysis/stim_table.py index f2752c9..a98deae 100644 --- a/analysis/stim_table.py +++ b/analysis/stim_table.py @@ -57,11 +57,11 @@ def create_stim_tables( ) except KeyError: if verbose: - print( + print(( 'Could not locate stimulus type {} in {}'.format( stim_name, exptpath ) - ) + )) continue return stim_table @@ -122,9 +122,9 @@ def DGgrid_table(data, twop_frames, verbose = True): ) if verbose: - print 'Found {} of {} expected sweeps.'.format( + print('Found {} of {} expected sweeps.'.format( actual_sweeps, expected_sweeps - ) + )) stim_table = pd.DataFrame( np.column_stack(( @@ -150,9 +150,9 @@ def DGsize_table(data, twop_frames, verbose = True): ) if verbose: - print 'Found {} of {} expected sweeps.'.format( + print('Found {} of {} expected sweeps.'.format( actual_sweeps, expected_sweeps - ) + )) stim_table = pd.DataFrame( np.column_stack(( @@ -184,9 +184,9 @@ def locally_sparse_noise_table(data, twop_frames, verbose = True): data, lsn_idx ) if verbose: - print 'Found {} of {} expected sweeps.'.format( + print('Found {} of {} expected sweeps.'.format( actual_sweeps, expected_sweeps - ) + )) stim_table = pd.DataFrame( np.column_stack(( @@ -212,9 +212,9 @@ def center_surround_table(data, twop_frames, verbose = True): data, center_idx ) if verbose: - print 'Found {} of {} expected sweeps'.format( + print('Found {} of {} expected sweeps'.format( actual_sweeps, expected_sweeps - ) + )) stim_table = pd.DataFrame( np.column_stack(( @@ -366,7 +366,7 @@ def load_stim(exptpath, verbose = True): if f.endswith('_stim.pkl'): pklpath = os.path.join(exptpath, f) if verbose: - print "Pkl file:", f + print("Pkl file:", f) if pklpath is None: raise IOError( @@ -398,7 +398,7 @@ def load_sync(exptpath, verbose = True): if f.endswith('_sync.h5'): syncpath = os.path.join(exptpath, f) if verbose: - print "Sync file:", f + print("Sync file:", f) if syncpath is None: raise IOError( 'No files with the suffix _sync.h5 were found in {}'.format( @@ -425,13 +425,13 @@ def load_sync(exptpath, verbose = True): 'photodiode_rise': photodiode_rise } channel_test = [] - for chan in channels.keys(): + for chan in list(channels.keys()): # Check that signal is high at least once in each channel. channel_test.append(any(channels[chan])) if not all(channel_test): raise RuntimeError('Not all channels present. Sync test failed.') elif verbose: - print "All channels present." + print("All channels present.") #test and correct for photodiode transition errors ptd_rise_diff = np.ediff1d(photodiode_rise) @@ -444,13 +444,13 @@ def load_sync(exptpath, verbose = True): ptd_end = np.where(photodiode_rise > stim_vsync_fall.max())[0][0] - 1 if ptd_start > 3 and verbose: - print 'ptd_start: ' + str(ptd_start) - print "Photodiode events before stimulus start. Deleted." + print('ptd_start: ' + str(ptd_start)) + print("Photodiode events before stimulus start. Deleted.") ptd_errors = [] while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end] < 1.8)[0] + ptd_start - print "Photodiode error detected. Number of frames:", len(error_frames) + print("Photodiode error detected. Number of frames:", len(error_frames)) photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) ptd_errors.append(photodiode_rise[error_frames[-1]]) ptd_end -= 1 @@ -465,7 +465,7 @@ def load_sync(exptpath, verbose = True): delay = np.mean(delay_rise[:-1]) if verbose: - print "monitor delay: ", delay + print("monitor delay: ", delay) #adjust stimulus time to incorporate monitor delay stim_time = stim_vsync_fall + delay @@ -509,18 +509,18 @@ def print_summary(stim_table): Print column names, number of 'unique' conditions per column (treating nans as equal), and average number of samples per condition. """ - print( + print(( '{:<20}{:>15}{:>15}\n'.format('Colname', 'No. conditions', 'Mean N/cond') - ) + )) for colname in stim_table.columns: conditions, occurrences = np.unique( np.nan_to_num(stim_table[colname]), return_counts = True ) - print( + print(( '{:<20}{:>15}{:>15.1f}'.format( colname, len(conditions), np.mean(occurrences) ) - ) + )) if __name__ == '__main__': diff --git a/oscopetools/locally_sparse_noise.py b/oscopetools/locally_sparse_noise.py index e97e3a3..5c349cd 100644 --- a/oscopetools/locally_sparse_noise.py +++ b/oscopetools/locally_sparse_noise.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 22 10:59:54 2018 @@ -65,7 +65,7 @@ def get_stimulus_response(self, LSN): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(list(range(self.numbercells))).astype(str)) sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) @@ -103,7 +103,7 @@ def get_peak(self): ------- peak dataframe ''' - peak = pd.DataFrame(columns=('rf_on','rf_off'), index=range(self.numbercells)) + peak = pd.DataFrame(columns=('rf_on','rf_off'), index=list(range(self.numbercells))) peak['rf_on'] = False peak['rf_off'] = False on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] @@ -115,7 +115,7 @@ def get_peak(self): def save_data(self): '''saves intermediate analysis files in an h5 file''' save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") - print "Saving data to: ", save_file + print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response store['mean_sweep_response'] = self.mean_sweep_response @@ -129,11 +129,11 @@ def save_data(self): def plot_LSN_Traces(self): '''plots ON and OFF traces for each position for each cell''' - print "Plotting LSN traces for all cells" + print("Plotting LSN traces for all cells") for nc in range(self.numbercells): if np.mod(nc,100)==0: - print "Cell #", str(nc) + print("Cell #", str(nc)) plt.figure(nc, figsize=(24,20)) vmax=0 vmin=0 From 201717f7fa1cd679bb302ba2352810fbd785f0ac Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 15:05:39 -0400 Subject: [PATCH 67/68] Autoformat using black Autoformatted all python files (outside of oscopetools/sync) using black with linewidth=80 and leaving quotes as-is. Command: black -S -l 80 --- analysis/DGgrid_analysis_5x5_nikon_SdV.py | 439 ++++++++++------- analysis/center_surround.py | 399 ++++++++++------ analysis/center_surround_previous.py | 441 ++++++++++++------ analysis/center_surround_tf.py | 440 +++++++++++------ .../locally_sparse_noise_events.py | 36 +- analysis/get_all_data.py | 145 +++--- analysis/read_data.py | 93 ++-- analysis/size_tuning.py | 365 ++++++++++----- analysis/stim_table.py | 255 +++++----- oscopetools/locally_sparse_noise.py | 164 +++++-- 10 files changed, 1804 insertions(+), 973 deletions(-) diff --git a/analysis/DGgrid_analysis_5x5_nikon_SdV.py b/analysis/DGgrid_analysis_5x5_nikon_SdV.py index 54808f8..e80723d 100644 --- a/analysis/DGgrid_analysis_5x5_nikon_SdV.py +++ b/analysis/DGgrid_analysis_5x5_nikon_SdV.py @@ -17,56 +17,68 @@ import nd2reader + def run_analysis(): exp_date = '20190605' mouse_ID = '462046' - im_filetype = 'nd2'#'h5' - + im_filetype = 'nd2' #'h5' - #DON'T MODIFY CODE BELOW THIS POINT!!!!!!!! + # DON'T MODIFY CODE BELOW THIS POINT!!!!!!!! exp_superpath = r'C:\\CAM\\data\\' im_superpath = r'E:\\' - exptpath = find_exptpath(exp_superpath,exp_date,mouse_ID) - im_directory = find_impath(im_superpath,exp_date,mouse_ID) + exptpath = find_exptpath(exp_superpath, exp_date, mouse_ID) + im_directory = find_impath(im_superpath, exp_date, mouse_ID) savepath = r'\\allen\\programs\\braintv\\workgroups\\ophysdev\\OPhysCore\\OpenScope\\Multiplex\\coordinates\\' stim_table = create_stim_table(exptpath) - fluorescence = get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath) + fluorescence = get_wholefield_fluorescence( + stim_table, im_filetype, im_directory, exp_date, mouse_ID, savepath + ) - mean_sweep_response, sweep_response = get_mean_sweep_response(fluorescence,stim_table) + mean_sweep_response, sweep_response = get_mean_sweep_response( + fluorescence, stim_table + ) - best_location = plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,savepath) + best_location = plot_sweep_response( + sweep_response, stim_table, exp_date, mouse_ID, savepath + ) - write_text_file(best_location,exp_date+'_'+mouse_ID,savepath) + write_text_file(best_location, exp_date + '_' + mouse_ID, savepath) -def find_exptpath(exp_superpath,exp_date,mouse_ID): + +def find_exptpath(exp_superpath, exp_date, mouse_ID): exptpath = None for f in os.listdir(exp_superpath): - if f.lower().find(mouse_ID+'_'+exp_date)!=-1: - exptpath = exp_superpath+f+'\\' + if f.lower().find(mouse_ID + '_' + exp_date) != -1: + exptpath = exp_superpath + f + '\\' return exptpath -def find_impath(im_superpath,exp_date,mouse_ID): + +def find_impath(im_superpath, exp_date, mouse_ID): im_path = None for f in os.listdir(im_superpath): - if f.lower().find(exp_date+'_'+mouse_ID)!=-1: - im_path = im_superpath+f+'\\' + if f.lower().find(exp_date + '_' + mouse_ID) != -1: + im_path = im_superpath + f + '\\' return im_path -def write_text_file(best_location,save_name,savepath): - f = open(savepath+save_name+'_coordinates.txt','w') +def write_text_file(best_location, save_name, savepath): + + f = open(savepath + save_name + '_coordinates.txt', 'w') f.write(str(best_location[0])) f.write(',') f.write(str(best_location[1])) f.close() -def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): + +def plot_sweep_response( + sweep_response, stim_table, exp_date, mouse_ID, exptpath +): x_pos = np.unique(stim_table['PosX'].values) x_pos = x_pos[np.argwhere(np.isfinite(x_pos))] @@ -79,21 +91,21 @@ def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): num_y = len(y_pos) num_sweeps = len(sweep_response) - plt.figure(figsize=(20,20)) + plt.figure(figsize=(20, 20)) ax = [] for x in range(num_x): for y in range(num_y): - ax.append(plt.subplot2grid((num_x,num_y), (x,y), colspan=1) ) + ax.append(plt.subplot2grid((num_x, num_y), (x, y), colspan=1)) - ori_colors=['k','b','m','r','y','g'] + ori_colors = ['k', 'b', 'm', 'r', 'y', 'g'] - #convert fluorescence to dff + # convert fluorescence to dff baseline_frames = 28 weighted_average = np.zeros((2,)) summed_response = 0 for i in range(num_sweeps): - baseline = np.mean(sweep_response[i,:baseline_frames]) - sweep_response[i,:] = sweep_response[i,:] - baseline + baseline = np.mean(sweep_response[i, :baseline_frames]) + sweep_response[i, :] = sweep_response[i, :] - baseline y_max = np.max(sweep_response.flatten()) y_min = np.min(sweep_response.flatten()) @@ -102,41 +114,56 @@ def plot_sweep_response(sweep_response,stim_table,exp_date,mouse_ID,exptpath): is_x = stim_table['PosX'] == x_pos[x][0] for y in range(len(y_pos)): is_y = stim_table['PosY'] == y_pos[y][0] - this_ax = ax[num_x*(num_y-1-y)+x] + this_ax = ax[num_x * (num_y - 1 - y) + x] position_average = np.zeros((np.shape(sweep_response)[1],)) num_at_position = 0 for o in range(len(ori)): is_ori = stim_table['Ori'] == ori[o][0] is_repeat = (is_x & is_y & is_ori).values repetition_idx = np.argwhere(is_repeat) - if any(repetition_idx==0): + if any(repetition_idx == 0): repetition_idx = repetition_idx[1:] for rep in range(len(repetition_idx)): this_response = sweep_response[repetition_idx[rep]] - this_response = this_response[0,:] - this_ax.plot(this_response,ori_colors[o]) + this_response = this_response[0, :] + this_ax.plot(this_response, ori_colors[o]) this_ax.set_ylim([y_min, y_max]) num_at_position += 1 - position_average = np.add(position_average,this_response) - position_average = np.divide(position_average,num_at_position) - position_response = np.mean(position_average[(baseline_frames+5):(baseline_frames+27)]) - summed_response += np.max([0.0,position_response]) - weighted_average[0] += x_pos[x][0] * np.max([0.0,position_response]) - weighted_average[1] += y_pos[y][0] * np.max([0.0,position_response]) - this_ax.plot(position_average,linewidth=3.0,color='k') - this_ax.plot([baseline_frames, baseline_frames],[y_min,y_max],'k--') - this_ax.set_title('X: ' + str(x_pos[x][0]) + ', Y: ' + str(y_pos[y][0])) - plt.savefig(exptpath+exp_date+'_'+mouse_ID+'_DGgrid_traces.png',dpi=300) + position_average = np.add(position_average, this_response) + position_average = np.divide(position_average, num_at_position) + position_response = np.mean( + position_average[(baseline_frames + 5) : (baseline_frames + 27)] + ) + summed_response += np.max([0.0, position_response]) + weighted_average[0] += x_pos[x][0] * np.max( + [0.0, position_response] + ) + weighted_average[1] += y_pos[y][0] * np.max( + [0.0, position_response] + ) + this_ax.plot(position_average, linewidth=3.0, color='k') + this_ax.plot( + [baseline_frames, baseline_frames], [y_min, y_max], 'k--' + ) + this_ax.set_title( + 'X: ' + str(x_pos[x][0]) + ', Y: ' + str(y_pos[y][0]) + ) + plt.savefig( + exptpath + exp_date + '_' + mouse_ID + '_DGgrid_traces.png', dpi=300 + ) plt.close() weighted_average = weighted_average / summed_response - best_location = (round(weighted_average[0],1),round(weighted_average[1],1)) + best_location = ( + round(weighted_average[0], 1), + round(weighted_average[1], 1), + ) return best_location -def plot_grid_response(mean_sweep_response,stim_table,exptpath): +def plot_grid_response(mean_sweep_response, stim_table, exptpath): x_pos = np.unique(stim_table['PosX'].values) x_pos = x_pos[np.argwhere(np.isfinite(x_pos))] @@ -145,27 +172,38 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): ori = np.unique(stim_table['Ori'].values) ori = ori[np.argwhere(np.isfinite(ori))] - response_grid = np.zeros((len(y_pos),len(x_pos))) + response_grid = np.zeros((len(y_pos), len(x_pos))) for o in range(len(ori)): is_ori = stim_table['Ori'] == ori[o][0] - ori_responses = np.zeros((len(y_pos),len(x_pos))) + ori_responses = np.zeros((len(y_pos), len(x_pos))) for x in range(len(x_pos)): is_x = stim_table['PosX'] == x_pos[x][0] for y in range(len(y_pos)): is_y = stim_table['PosY'] == y_pos[y][0] is_repeat = (is_x & is_y & is_ori).values repetition_idx = np.argwhere(is_repeat) - if any(repetition_idx==0): + if any(repetition_idx == 0): repetition_idx = repetition_idx[1:] repetition_responses = np.zeros((len(repetition_idx),)) for rep in range(len(repetition_idx)): - repetition_responses[rep] = mean_sweep_response[repetition_idx[rep]] - ori_responses[y,x] = np.mean(repetition_responses) - ori_responses = np.subtract(ori_responses,np.mean(ori_responses.flatten())) - response_grid = np.add(response_grid,ori_responses) + repetition_responses[rep] = mean_sweep_response[ + repetition_idx[rep] + ] + ori_responses[y, x] = np.mean(repetition_responses) + ori_responses = np.subtract( + ori_responses, np.mean(ori_responses.flatten()) + ) + response_grid = np.add(response_grid, ori_responses) plt.figure() - plt.imshow(response_grid,vmax=np.max(response_grid),vmin=-np.max(response_grid),cmap='bwr',interpolation='none',origin='lower') + plt.imshow( + response_grid, + vmax=np.max(response_grid), + vmin=-np.max(response_grid), + cmap='bwr', + interpolation='none', + origin='lower', + ) plt.colorbar() plt.xlabel('X Pos') plt.ylabel('Y Pos') @@ -176,12 +214,13 @@ def plot_grid_response(mean_sweep_response,stim_table,exptpath): y_tick_labels = list(range(len(y_pos))) for i in range(len(y_pos)): y_tick_labels[i] = str(y_pos[i][0]) - plt.xticks(np.arange(len(x_pos)),x_tick_labels) - plt.yticks(np.arange(len(y_pos)),y_tick_labels) + plt.xticks(np.arange(len(x_pos)), x_tick_labels) + plt.yticks(np.arange(len(y_pos)), y_tick_labels) - plt.savefig(exptpath+'/DGgrid_response') + plt.savefig(exptpath + '/DGgrid_response') -def get_mean_sweep_response(fluorescence,stim_table): + +def get_mean_sweep_response(fluorescence, stim_table): sweeplength = int(stim_table.End[1] - stim_table.Start[1]) interlength = 28 @@ -189,44 +228,54 @@ def get_mean_sweep_response(fluorescence,stim_table): num_stim_presentations = len(stim_table['Start']) mean_sweep_response = np.zeros((num_stim_presentations,)) - sweep_response = np.zeros((num_stim_presentations,sweeplength+interlength)) + sweep_response = np.zeros( + (num_stim_presentations, sweeplength + interlength) + ) for i in range(num_stim_presentations): - start = stim_table['Start'][i]-interlength + start = stim_table['Start'][i] - interlength end = stim_table['Start'][i] + sweeplength - sweep_f = fluorescence[int(start):int(end)] - sweep_dff = 100*((sweep_f/np.mean(sweep_f[:interlength]))-1) - sweep_response[i,:] = sweep_f - mean_sweep_response[i] = np.mean(sweep_dff[interlength:(interlength+sweeplength)]) + sweep_f = fluorescence[int(start) : int(end)] + sweep_dff = 100 * ((sweep_f / np.mean(sweep_f[:interlength])) - 1) + sweep_response[i, :] = sweep_f + mean_sweep_response[i] = np.mean( + sweep_dff[interlength : (interlength + sweeplength)] + ) return mean_sweep_response, sweep_response + def load_single_tif(file_path): return tiff.imread(file_path) -def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath): - if os.path.isfile(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy'): - avg_fluorescence = np.load(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy') +def get_wholefield_fluorescence( + stim_table, im_filetype, im_directory, exp_date, mouse_ID, savepath +): + + if os.path.isfile(savepath + exp_date + '_' + mouse_ID + '_wholefield.npy'): + avg_fluorescence = np.load( + savepath + exp_date + '_' + mouse_ID + '_wholefield.npy' + ) else: im_path = None - if im_filetype=='nd2': + if im_filetype == 'nd2': for f in os.listdir(im_directory): if f.endswith(im_filetype) and f.lower().find('local') == -1: im_path = im_directory + f print(im_path) - elif im_filetype=='h5': - #find experiment directory: + elif im_filetype == 'h5': + # find experiment directory: for f in os.listdir(im_directory): - if f.lower().find('ophys_experiment_')!=-1: - exp_path = im_directory+f+'\\' + if f.lower().find('ophys_experiment_') != -1: + exp_path = im_directory + f + '\\' session_ID = f[17:] print(session_ID) else: print('im_filetype not recognized!') sys.exit(1) - if im_filetype=='nd2': + if im_filetype == 'nd2': print('Reading nd2...') read_obj = nd2reader.Nd2(im_path) num_frames = len(read_obj.frames) @@ -234,61 +283,95 @@ def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mou sweep_starts = stim_table['Start'].values block_bounds = [] - block_bounds.append((np.min(sweep_starts)-30,np.max(sweep_starts[sweep_starts<50000])+100)) - block_bounds.append((np.min(sweep_starts[sweep_starts>50000])-30,np.max(sweep_starts)+100)) + block_bounds.append( + ( + np.min(sweep_starts) - 30, + np.max(sweep_starts[sweep_starts < 50000]) + 100, + ) + ) + block_bounds.append( + ( + np.min(sweep_starts[sweep_starts > 50000]) - 30, + np.max(sweep_starts) + 100, + ) + ) for block in block_bounds: frame_start = int(block[0]) frame_end = int(block[1]) - for f in np.arange(frame_start,frame_end): - this_frame = read_obj.get_image(f,0,read_obj.channels[0],0) + for f in np.arange(frame_start, frame_end): + this_frame = read_obj.get_image( + f, 0, read_obj.channels[0], 0 + ) print('Loaded frame ' + str(f) + ' of ' + str(num_frames)) avg_fluorescence[f] = np.mean(this_frame) - elif im_filetype=='h5': - f = h5py.File(exp_path+session_ID+'.h5') + elif im_filetype == 'h5': + f = h5py.File(exp_path + session_ID + '.h5') data = np.array(f['data']) - avg_fluorescence = np.mean(data,axis=(1,2)) + avg_fluorescence = np.mean(data, axis=(1, 2)) f.close() - np.save(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy',avg_fluorescence) + np.save( + savepath + exp_date + '_' + mouse_ID + '_wholefield.npy', + avg_fluorescence, + ) return avg_fluorescence + def create_stim_table(exptpath): - #load stimulus and sync data + # load stimulus and sync data data = load_pkl(exptpath) - twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise = load_sync(exptpath) + twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise = load_sync( + exptpath + ) display_sequence = data['stimuli'][0]['display_sequence'] display_sequence += data['pre_blank_sec'] - display_sequence *= int(data['fps']) #in stimulus frames + display_sequence *= int(data['fps']) # in stimulus frames sweep_frames = data['stimuli'][0]['sweep_frames'] - stimulus_table = pd.DataFrame(sweep_frames,columns=('start','end')) - stimulus_table['dif'] = stimulus_table['end']-stimulus_table['start'] - stimulus_table.start += display_sequence[0,0] - for seg in range(len(display_sequence)-1): + stimulus_table = pd.DataFrame(sweep_frames, columns=('start', 'end')) + stimulus_table['dif'] = stimulus_table['end'] - stimulus_table['start'] + stimulus_table.start += display_sequence[0, 0] + for seg in range(len(display_sequence) - 1): for index, row in stimulus_table.iterrows(): - if row.start >= display_sequence[seg,1]: - stimulus_table.start[index] = stimulus_table.start[index] - display_sequence[seg,1] + display_sequence[seg+1,0] - stimulus_table.end = stimulus_table.start+stimulus_table.dif + if row.start >= display_sequence[seg, 1]: + stimulus_table.start[index] = ( + stimulus_table.start[index] + - display_sequence[seg, 1] + + display_sequence[seg + 1, 0] + ) + stimulus_table.end = stimulus_table.start + stimulus_table.dif print(len(stimulus_table)) - stimulus_table = stimulus_table[stimulus_table.end <= display_sequence[-1,1]] - stimulus_table = stimulus_table[stimulus_table.start <= display_sequence[-1,1]] + stimulus_table = stimulus_table[ + stimulus_table.end <= display_sequence[-1, 1] + ] + stimulus_table = stimulus_table[ + stimulus_table.start <= display_sequence[-1, 1] + ] print(len(stimulus_table)) - sync_table = pd.DataFrame(np.column_stack((twop_frames[stimulus_table['start']],twop_frames[stimulus_table['end']])), columns=('Start', 'End')) - - #populate stimulus parameters + sync_table = pd.DataFrame( + np.column_stack( + ( + twop_frames[stimulus_table['start']], + twop_frames[stimulus_table['end']], + ) + ), + columns=('Start', 'End'), + ) + + # populate stimulus parameters print(data['stimuli'][0]['stim_path']) - #get center parameters + # get center parameters sweep_order = data['stimuli'][0]['sweep_order'] - sweep_order = sweep_order[:len(stimulus_table)] + sweep_order = sweep_order[: len(stimulus_table)] sweep_table = data['stimuli'][0]['sweep_table'] dimnames = data['stimuli'][0]['dimnames'] sweep_table = pd.DataFrame(sweep_table, columns=dimnames) - #populate sync_table + # populate sync_table sync_table['SF'] = np.NaN sync_table['TF'] = np.NaN sync_table['Contrast'] = np.NaN @@ -296,19 +379,30 @@ def create_stim_table(exptpath): sync_table['PosX'] = np.NaN sync_table['PosY'] = np.NaN for index in np.arange(len(stimulus_table)): - if (not np.isnan(stimulus_table['end'][index])) & (sweep_order[index] >= 0): + if (not np.isnan(stimulus_table['end'][index])) & ( + sweep_order[index] >= 0 + ): sync_table['SF'][index] = sweep_table['SF'][int(sweep_order[index])] sync_table['TF'][index] = sweep_table['TF'][int(sweep_order[index])] - sync_table['Contrast'][index] = sweep_table['Contrast'][int(sweep_order[index])] - sync_table['Ori'][index] = sweep_table['Ori'][int(sweep_order[index])] - sync_table['PosX'][index] = sweep_table['PosX'][int(sweep_order[index])] - sync_table['PosY'][index] = sweep_table['PosY'][int(sweep_order[index])] + sync_table['Contrast'][index] = sweep_table['Contrast'][ + int(sweep_order[index]) + ] + sync_table['Ori'][index] = sweep_table['Ori'][ + int(sweep_order[index]) + ] + sync_table['PosX'][index] = sweep_table['PosX'][ + int(sweep_order[index]) + ] + sync_table['PosY'][index] = sweep_table['PosY'][ + int(sweep_order[index]) + ] return sync_table + def load_sync(exptpath): - #verify that sync file exists in exptpath + # verify that sync file exists in exptpath syncMissing = True for f in os.listdir(exptpath): if f.endswith('_sync.h5'): @@ -319,24 +413,30 @@ def load_sync(exptpath): print("No sync file") sys.exit() - #load the sync data from .h5 and .pkl files + # load the sync data from .h5 and .pkl files d = Dataset(syncpath) print(d.line_labels) - #set the appropriate sample frequency + # set the appropriate sample frequency sample_freq = d.meta_data['ni_daq']['counter_output_freq'] - #get sync timing for each channel - twop_vsync_fall = d.get_falling_edges('2p_vsync')/sample_freq - #stim_vsync_fall = d.get_falling_edges('vsync_stim')[1:]/sample_freq #eliminating the DAQ pulse - stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse - photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq + # get sync timing for each channel + twop_vsync_fall = d.get_falling_edges('2p_vsync') / sample_freq + # stim_vsync_fall = d.get_falling_edges('vsync_stim')[1:]/sample_freq #eliminating the DAQ pulse + stim_vsync_fall = ( + d.get_falling_edges('stim_vsync')[1:] / sample_freq + ) # eliminating the DAQ pulse + photodiode_rise = d.get_rising_edges('stim_photodiode') / sample_freq print('num stim vsyncs: ' + str(len(stim_vsync_fall))) print('num 2p frames: ' + str(len(twop_vsync_fall))) print('num photodiode flashes: ' + str(len(photodiode_rise))) - #make sure all of the sync data are available - channels = {'twop_vsync_fall': twop_vsync_fall, 'stim_vsync_fall':stim_vsync_fall, 'photodiode_rise': photodiode_rise} + # make sure all of the sync data are available + channels = { + 'twop_vsync_fall': twop_vsync_fall, + 'stim_vsync_fall': stim_vsync_fall, + 'photodiode_rise': photodiode_rise, + } channel_test = [] for i in channels: channel_test.append(any(channels[i])) @@ -346,22 +446,25 @@ def load_sync(exptpath): print("Not all channels present. Sync test failed.") sys.exit() - #test and correct for photodiode transition errors + # test and correct for photodiode transition errors ptd_rise_diff = np.ediff1d(photodiode_rise) - short = np.where(np.logical_and(ptd_rise_diff>0.1, ptd_rise_diff<0.3))[0] - medium = np.where(np.logical_and(ptd_rise_diff>0.5, ptd_rise_diff<1.5))[0] - - - #find three consecutive pulses at the start of session: + short = np.where(np.logical_and(ptd_rise_diff > 0.1, ptd_rise_diff < 0.3))[ + 0 + ] + medium = np.where(np.logical_and(ptd_rise_diff > 0.5, ptd_rise_diff < 1.5))[ + 0 + ] + + # find three consecutive pulses at the start of session: two_back_lag = photodiode_rise[2:20] - photodiode_rise[:18] ptd_start = np.argmin(two_back_lag) + 3 print('ptd_start: ' + str(ptd_start)) - #ptd_start = 3 - #for i in medium: + # ptd_start = 3 + # for i in medium: # if set(range(i-2,i)) <= set(short): # ptd_start = i+1 - ptd_end = np.where(photodiode_rise>stim_vsync_fall.max())[0][0] - 1 + ptd_end = np.where(photodiode_rise > stim_vsync_fall.max())[0][0] - 1 # plt.figure() # plt.hist(ptd_rise_diff) @@ -391,69 +494,74 @@ def load_sync(exptpath): if ptd_start > 3: print("Photodiode events before stimulus start. Deleted.") -# ptd_errors = [] -# while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): -# error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end]<1.8)[0] + ptd_start -# #print "Photodiode error detected. Number of frames:", len(error_frames) -# photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) -# ptd_errors.append(photodiode_rise[error_frames[-1]]) -# ptd_end-=1 -# ptd_rise_diff = np.ediff1d(photodiode_rise) + # ptd_errors = [] + # while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): + # error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end]<1.8)[0] + ptd_start + # #print "Photodiode error detected. Number of frames:", len(error_frames) + # photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) + # ptd_errors.append(photodiode_rise[error_frames[-1]]) + # ptd_end-=1 + # ptd_rise_diff = np.ediff1d(photodiode_rise) first_pulse = ptd_start - stim_on_photodiode_idx = 60+120*np.arange(0,ptd_end+1-ptd_start-1,1) - - #stim_vsync_fall = stim_vsync_fall[0] + np.arange(stim_on_photodiode_idx.max()+481) * 0.0166666 - -# stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] -# photodiode_on = photodiode_rise[first_pulse + np.arange(0,ptd_end+1-ptd_start-1,1)] -# -# plt.figure() -# plt.plot(stim_on_photodiode[:4]) -# plt.title('stim start') -# plt.show() -# -# plt.figure() -# plt.plot(photodiode_on[:4]) -# plt.title('photodiode start') -# plt.show() -# -# delay_rise = photodiode_on - stim_on_photodiode -# init_delay_period = delay_rise < 0.025 -# init_delay = np.mean(delay_rise[init_delay_period]) -# -# plt.figure() -# plt.plot(delay_rise[:10]) -# plt.title('delay rise') -# plt.show() - - delay = 0.0#init_delay - print("monitor delay: " , delay) - - #adjust stimulus time with monitor delay + stim_on_photodiode_idx = 60 + 120 * np.arange( + 0, ptd_end + 1 - ptd_start - 1, 1 + ) + + # stim_vsync_fall = stim_vsync_fall[0] + np.arange(stim_on_photodiode_idx.max()+481) * 0.0166666 + + # stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] + # photodiode_on = photodiode_rise[first_pulse + np.arange(0,ptd_end+1-ptd_start-1,1)] + # + # plt.figure() + # plt.plot(stim_on_photodiode[:4]) + # plt.title('stim start') + # plt.show() + # + # plt.figure() + # plt.plot(photodiode_on[:4]) + # plt.title('photodiode start') + # plt.show() + # + # delay_rise = photodiode_on - stim_on_photodiode + # init_delay_period = delay_rise < 0.025 + # init_delay = np.mean(delay_rise[init_delay_period]) + # + # plt.figure() + # plt.plot(delay_rise[:10]) + # plt.title('delay rise') + # plt.show() + + delay = 0.0 # init_delay + print("monitor delay: ", delay) + + # adjust stimulus time with monitor delay stim_time = stim_vsync_fall + delay - #convert stimulus frames into twop frames - twop_frames = np.empty((len(stim_time),1)) + # convert stimulus frames into twop frames + twop_frames = np.empty((len(stim_time), 1)) acquisition_ends_early = 0 for i in range(len(stim_time)): # crossings = np.nonzero(np.ediff1d(np.sign(twop_vsync_fall - stim_time[i]))>0) - crossings = np.searchsorted(twop_vsync_fall,stim_time[i],side='left') -1 - if crossings < (len(twop_vsync_fall)-1): + crossings = ( + np.searchsorted(twop_vsync_fall, stim_time[i], side='left') - 1 + ) + if crossings < (len(twop_vsync_fall) - 1): twop_frames[i] = crossings else: - twop_frames[i:len(stim_time)]=np.NaN + twop_frames[i : len(stim_time)] = np.NaN acquisition_ends_early = 1 break - if acquisition_ends_early>0: + if acquisition_ends_early > 0: print("Acquisition ends before stimulus") return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise + def load_pkl(exptpath): - #verify that pkl file exists in exptpath + # verify that pkl file exists in exptpath logMissing = True for f in os.listdir(exptpath): if f.endswith('.pkl'): @@ -464,12 +572,13 @@ def load_pkl(exptpath): print("No pkl file") sys.exit() - #load data from pkl file + # load data from pkl file f = open(logpath, 'rb') data = pickle.load(f) f.close() return data -if __name__=='__main__': - run_analysis() \ No newline at end of file + +if __name__ == '__main__': + run_analysis() diff --git a/analysis/center_surround.py b/analysis/center_surround.py index a19f3de..8fc4981 100644 --- a/analysis/center_surround.py +++ b/analysis/center_surround.py @@ -11,15 +11,19 @@ import os, h5py import matplotlib.pyplot as plt + def do_sweep_mean(x): return x[30:90].mean() + def do_sweep_mean_shifted(x): return x[30:40].mean() + def do_eye(x): return x[30:35].mean() + class CenterSurround: def __init__(self, expt_path, eye_thresh, cre, area, depth): @@ -31,62 +35,93 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.area = area self.depth = depth - self.orivals = range(0,360,45) - self.tfvals = [1,2] - self.conditions = ['center','iso','ortho','blank'] + self.orivals = range(0, 360, 45) + self.tfvals = [1, 2] + self.conditions = ['center', 'iso', 'ortho', 'blank'] - #load dff traces + # load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - #load raw traces + # load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - #load roi_table + # load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - #get stimulus table for center surround + # get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') - #add condition column + # add condition column self.stim_table['condition'] = 'ortho' - self.stim_table.loc[self.stim_table.Center_Ori==self.stim_table.Surround_Ori, 'condition'] = 'iso' - self.stim_table.loc[np.isfinite(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'center' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'blank' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' - #get spontaneous window + self.stim_table.loc[ + self.stim_table.Center_Ori == self.stim_table.Surround_Ori, + 'condition', + ] = 'iso' + self.stim_table.loc[ + np.isfinite(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'center' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'blank' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isfinite(self.stim_table.Surround_Ori), + 'condition', + ] = 'surround' + # get spontaneous window self.stim_table_spont = self.get_spont_table() - #load eyetracking + # load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - #run analysis - self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() - -# self.first, self.second = self.cross_validate_response() - self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT = self.get_metrics() - - #save outputs -# self.save_data() - - #plot traces + # run analysis + ( + self.sweep_response, + self.mean_sweep_response, + self.sweep_eye, + self.mean_sweep_eye, + self.sweep_p_values, + self.response, + ) = self.get_stimulus_response() + + # self.first, self.second = self.cross_validate_response() + ( + self.metrics, + self.OSI, + self.DSI, + self.ISO, + self.ORTHO, + self.STRENGTH, + self.TUNING, + self.CONTEXT, + ) = self.get_metrics() + + # save outputs + + # self.save_data() + + # plot traces def get_spont_table(self): '''finds the window of spotaneous activity during the session''' stim_table_lsn = pd.read_hdf(self.expt_path, 'locally_sparse_noise') - stim_all = self.stim_table[['Start','End']] - stim_all = stim_all.append(stim_table_lsn[['Start','End']]) + stim_all = self.stim_table[['Start', 'End']] + stim_all = stim_all.append(stim_table_lsn[['Start', 'End']]) stim_all.sort_values(by='Start', inplace=True) stim_all.reset_index(inplace=True) - spont_start = np.where(np.ediff1d(stim_all.Start)>8000)[0][0] - stim_table_spont = pd.DataFrame(columns=('Start','End'), index=[0]) - stim_table_spont.Start = stim_all.End[spont_start]+1 - stim_table_spont.End = stim_all.Start[spont_start+1]-1 + spont_start = np.where(np.ediff1d(stim_all.Start) > 8000)[0][0] + stim_table_spont = pd.DataFrame(columns=('Start', 'End'), index=[0]) + stim_table_spont.Start = stim_all.End[spont_start] + 1 + stim_table_spont.End = stim_all.Start[spont_start + 1] - 1 return stim_table_spont def get_stimulus_response(self): @@ -104,60 +139,109 @@ def get_stimulus_response(self): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_response = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + sweep_eye = pd.DataFrame( + index=self.stim_table.index.values, + columns=('x_pos_deg', 'y_pos_deg'), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - #uses the global dff trace - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - - #computes DF/F using the mean of the inter-sweep gray for the Fo -# temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] -# sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-30:int(row.Start+90)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-30:int(row.Start+90)].values + # uses the global dff trace + sweep_response[str(nc)][index] = self.dff[ + nc, int(row.Start) - 30 : int(row.Start) + 90 + ] + + # computes DF/F using the mean of the inter-sweep gray for the Fo + # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] + # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) - mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - - #make spontaneous p_values + mean_sweep_eye['total'] = np.sqrt( + ((mean_sweep_eye.x_pos_deg - mean_sweep_eye.x_pos_deg.mean()) ** 2) + + ( + (mean_sweep_eye.y_pos_deg - mean_sweep_eye.y_pos_deg.mean()) + ** 2 + ) + ) + + # make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) -# idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) - idx = np.random.choice(range(int(self.stim_table_spont.Start), int(self.stim_table_spont.End)), 10000) + # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) + idx = np.random.choice( + range( + int(self.stim_table_spont.Start), int(self.stim_table_spont.End) + ), + 10000, + ) for i in range(60): - shuffled_responses[:,:,i] = self.dff[:,idx+i] + shuffled_responses[:, :, i] = self.dff[:, idx + i] shuffled_mean = shuffled_responses.mean(axis=2) - sweep_p_values = pd.DataFrame(index = self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_p_values = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) for nc in range(self.numbercells): subset = mean_sweep_response[str(nc)].values - null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) - actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat + null_dist_mat = np.tile(shuffled_mean[nc, :], reps=(len(subset), 1)) + actual_is_less = subset.reshape(len(subset), 1) <= null_dist_mat p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position - response = np.empty((8,4,self.numbercells, 4)) #center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials + # compute mean response across trials, only use trials within eye_thresh of mean eye position + response = np.empty( + (8, 4, self.numbercells, 4) + ) # center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials for oi, cori in enumerate(self.orivals): for ci, cond in enumerate(self.conditions): - if cond=='blank': - subset = mean_sweep_response[(self.stim_table.condition==cond)&(mean_sweep_eye.total0, tuning, 0) + tuning = np.where(tuning > 0, tuning, 0) CV_top_os = np.empty((8, tuning.shape[1]), dtype=np.complex128) for i in range(8): - CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) - return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + CV_top_os[i] = tuning[i] * np.exp(1j * 2 * orivals_rad[i]) + return np.abs(CV_top_os.sum(axis=0)) / tuning.sum(axis=0) def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -217,61 +314,85 @@ def get_metrics(self): ''' n_iter = 50 - n_trials = int(self.response[:,:,:,2].min()) + n_trials = int(self.response[:, :, :, 2].min()) print("Number of trials for cross-validation: " + str(n_trials)) -# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] cell_index = np.array(range(self.numbercells)) - response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('center_dir','center_osi','center_dsi','iso','ortho', - 'suppression_strength','suppression_tuning','cmi'), index=cell_index) - - #cross-validated metrics + response_first, response_second = self.cross_validate_response( + n_iter, n_trials + ) + + metrics = pd.DataFrame( + columns=( + 'center_dir', + 'center_osi', + 'center_dsi', + 'iso', + 'ortho', + 'suppression_strength', + 'suppression_tuning', + 'cmi', + ), + index=cell_index, + ) + + # cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) ISO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - ORTHO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - STRENGTH = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + ORTHO = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + STRENGTH = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + TUNING = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + CONTEXT = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) for ni in range(n_iter): - #find pref direction for each cell for center only condition - response_first = response_first[:,:,cell_index,:] - response_second = response_second[:,:,cell_index,:] - sort = np.where(response_first[:,0,:,ni]==np.nanmax(response_first[:,0,:,ni], axis=(0))) + # find pref direction for each cell for center only condition + response_first = response_first[:, :, cell_index, :] + response_second = response_second[:, :, cell_index, :] + sort = np.where( + response_first[:, 0, :, ni] + == np.nanmax(response_first[:, 0, :, ni], axis=(0)) + ) sortind = np.argsort(sort[1]) pref_ori = sort[0][sortind] cell_index = sort[1][sortind] inds = np.vstack((pref_ori, cell_index)) - #osi + # osi OSI.loc[ni] = self.get_osi(response_second[:, 0, inds[1], ni]) - #dsi - null_ori= np.mod(pref_ori+4, 8) + # dsi + null_ori = np.mod(pref_ori + 4, 8) pref = response_second[inds[0], 0, inds[1], ni] - null = response_second[null_ori, 0, inds[1], ni] - null = np.where(null>0, null, 0) - DSI.loc[ni] = (pref-null)/(pref+null) + null = response_second[null_ori, 0, inds[1], ni] + null = np.where(null > 0, null, 0) + DSI.loc[ni] = (pref - null) / (pref + null) center = response_second[inds[0], 0, inds[1], ni] iso = response_second[inds[0], 1, inds[1], ni] ortho = response_second[inds[0], 2, inds[1], ni] - #suppression strength - STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center + # suppression strength + STRENGTH.loc[ni] = (center - ((iso + ortho) / 2)) / center - #suppression tuning - TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) + # suppression tuning + TUNING.loc[ni] = (ortho - iso) / (center - ((iso + ortho) / 2)) - #iso + # iso ISO.loc[ni] = (center - iso) / (center + iso) - #ortho + # ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - #context modulation index (Keller et al) - #TODO: right now we're using the center to identify the preferred direction. Might not be ideal + # context modulation index (Keller et al) + # TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) metrics['center_osi'] = OSI.mean().values @@ -282,23 +403,34 @@ def get_metrics(self): metrics['suppression_tuning'] = TUNING.mean().values metrics['cmi'] = CONTEXT.mean().values - #non cross-validated metrics -# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + # non cross-validated metrics + # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] cell_index = np.array(range(self.numbercells)) - sort = np.where(self.response[:,0,cell_index,0] == np.nanmax(self.response[:,0,cell_index,0], axis=0)) + sort = np.where( + self.response[:, 0, cell_index, 0] + == np.nanmax(self.response[:, 0, cell_index, 0], axis=0) + ) sortind = np.argsort(sort[1]) metrics['center_dir'] = sort[0][sortind] - metrics['center_mean'] = self.response[sort[0][sortind],0,cell_index,0] - metrics['center_std'] = self.response[sort[0][sortind],0,cell_index,1] - metrics['center_percent_trials'] = self.response[sort[0][sortind],0,cell_index,3] - metrics['blank_mean'] = self.response[0,3,cell_index,0] - metrics['blank_std'] = self.response[0,3,cell_index,1] - metrics['iso_mean'] = self.response[sort[0][sortind],1,cell_index,0] - metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] - metrics['ortho_mean'] = self.response[sort[0][sortind],2,cell_index,0] - metrics['ortho_std'] = self.response[sort[0][sortind],2,cell_index,1] - - metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) + metrics['center_mean'] = self.response[ + sort[0][sortind], 0, cell_index, 0 + ] + metrics['center_std'] = self.response[ + sort[0][sortind], 0, cell_index, 1 + ] + metrics['center_percent_trials'] = self.response[ + sort[0][sortind], 0, cell_index, 3 + ] + metrics['blank_mean'] = self.response[0, 3, cell_index, 0] + metrics['blank_std'] = self.response[0, 3, cell_index, 1] + metrics['iso_mean'] = self.response[sort[0][sortind], 1, cell_index, 0] + metrics['iso_std'] = self.response[sort[0][sortind], 1, cell_index, 1] + metrics['ortho_mean'] = self.response[ + sort[0][sortind], 2, cell_index, 0 + ] + metrics['ortho_std'] = self.response[sort[0][sortind], 2, cell_index, 1] + + metrics = metrics.join(self.roi[['cell_id', 'session_id', 'valid']]) metrics['cre'] = self.cre metrics['area'] = self.area metrics['depth'] = self.depth @@ -307,7 +439,10 @@ def get_metrics(self): def save_data(self): '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis_py3', str(self.session_id)+"_cs_analysis.h5") + save_file = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis_py3', + str(self.session_id) + "_cs_analysis.h5", + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response @@ -322,13 +457,19 @@ def save_data(self): f.close() -if __name__=='__main__': +if __name__ == '__main__': expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_989418742_data.h5' eye_thresh = 10 cre = 'test' area = 'area test' depth = '33' - cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) + cs = CenterSurround( + expt_path=expt_path, + eye_thresh=eye_thresh, + cre=cre, + area=area, + depth=depth, + ) # manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') # subset = manifest[manifest.Target=='soma'] @@ -353,5 +494,3 @@ def save_data(self): # except: # print(expt_path + " FAILED") # failed.append(int(row.Center_Surround_Expt_ID)) - - diff --git a/analysis/center_surround_previous.py b/analysis/center_surround_previous.py index 9bf618d..9974b71 100644 --- a/analysis/center_surround_previous.py +++ b/analysis/center_surround_previous.py @@ -11,15 +11,19 @@ import os, h5py import matplotlib.pyplot as plt + def do_sweep_mean(x): return x[30:90].mean() + def do_sweep_mean_shifted(x): return x[30:40].mean() + def do_eye(x): return x[30:35].mean() + class CenterSurround: def __init__(self, expt_path, eye_thresh, cre, area, depth): @@ -31,62 +35,93 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.area = area self.depth = depth - self.orivals = range(0,360,45) - self.tfvals = [1,2] - self.conditions = ['center','iso','ortho','blank'] + self.orivals = range(0, 360, 45) + self.tfvals = [1, 2] + self.conditions = ['center', 'iso', 'ortho', 'blank'] - #load dff traces + # load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - #load raw traces + # load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - #load roi_table + # load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - #get stimulus table for center surround + # get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') - #add condition column + # add condition column self.stim_table['condition'] = 'ortho' - self.stim_table.loc[self.stim_table.Center_Ori==self.stim_table.Surround_Ori, 'condition'] = 'iso' - self.stim_table.loc[np.isfinite(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'center' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'blank' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' - #get spontaneous window + self.stim_table.loc[ + self.stim_table.Center_Ori == self.stim_table.Surround_Ori, + 'condition', + ] = 'iso' + self.stim_table.loc[ + np.isfinite(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'center' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'blank' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isfinite(self.stim_table.Surround_Ori), + 'condition', + ] = 'surround' + # get spontaneous window self.stim_table_spont = self.get_spont_table() - #load eyetracking + # load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - #run analysis - self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() - -# self.first, self.second = self.cross_validate_response() - self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT, self.DIR = self.get_metrics() - - #save outputs + # run analysis + ( + self.sweep_response, + self.mean_sweep_response, + self.sweep_eye, + self.mean_sweep_eye, + self.sweep_p_values, + self.response, + ) = self.get_stimulus_response() + + # self.first, self.second = self.cross_validate_response() + ( + self.metrics, + self.OSI, + self.DSI, + self.ISO, + self.ORTHO, + self.STRENGTH, + self.TUNING, + self.CONTEXT, + self.DIR, + ) = self.get_metrics() + + # save outputs self.save_data() - #plot traces + # plot traces def get_spont_table(self): '''finds the window of spotaneous activity during the session''' stim_table_lsn = pd.read_hdf(self.expt_path, 'locally_sparse_noise') - stim_all = self.stim_table[['Start','End']] - stim_all = stim_all.append(stim_table_lsn[['Start','End']]) + stim_all = self.stim_table[['Start', 'End']] + stim_all = stim_all.append(stim_table_lsn[['Start', 'End']]) stim_all.sort_values(by='Start', inplace=True) stim_all.reset_index(inplace=True) - spont_start = np.where(np.ediff1d(stim_all.Start)>8000)[0][0] - stim_table_spont = pd.DataFrame(columns=('Start','End'), index=[0]) - stim_table_spont.Start = stim_all.End[spont_start]+1 - stim_table_spont.End = stim_all.Start[spont_start+1]-1 + spont_start = np.where(np.ediff1d(stim_all.Start) > 8000)[0][0] + stim_table_spont = pd.DataFrame(columns=('Start', 'End'), index=[0]) + stim_table_spont.Start = stim_all.End[spont_start] + 1 + stim_table_spont.End = stim_all.Start[spont_start + 1] - 1 return stim_table_spont def get_stimulus_response(self): @@ -104,61 +139,109 @@ def get_stimulus_response(self): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_response = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + sweep_eye = pd.DataFrame( + index=self.stim_table.index.values, + columns=('x_pos_deg', 'y_pos_deg'), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - #uses the global dff trace - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - - #computes DF/F using the mean of the inter-sweep gray for the Fo -# temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] -# sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-30:int(row.Start+90)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-30:int(row.Start+90)].values + # uses the global dff trace + sweep_response[str(nc)][index] = self.dff[ + nc, int(row.Start) - 30 : int(row.Start) + 90 + ] + + # computes DF/F using the mean of the inter-sweep gray for the Fo + # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] + # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) - mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - - #make spontaneous p_values + mean_sweep_eye['total'] = np.sqrt( + ((mean_sweep_eye.x_pos_deg - mean_sweep_eye.x_pos_deg.mean()) ** 2) + + ( + (mean_sweep_eye.y_pos_deg - mean_sweep_eye.y_pos_deg.mean()) + ** 2 + ) + ) + + # make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) -# idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) - idx = np.random.choice(range(int(self.stim_table_spont.Start), int(self.stim_table_spont.End)), 10000) + # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) + idx = np.random.choice( + range( + int(self.stim_table_spont.Start), int(self.stim_table_spont.End) + ), + 10000, + ) for i in range(60): - shuffled_responses[:,:,i] = self.dff[:,idx+i] + shuffled_responses[:, :, i] = self.dff[:, idx + i] shuffled_mean = shuffled_responses.mean(axis=2) - sweep_p_values = pd.DataFrame(index = self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_p_values = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) for nc in range(self.numbercells): subset = mean_sweep_response[str(nc)].values - null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) - actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat + null_dist_mat = np.tile(shuffled_mean[nc, :], reps=(len(subset), 1)) + actual_is_less = subset.reshape(len(subset), 1) <= null_dist_mat p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position - response = np.empty((8,4,self.numbercells, 4)) #center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials - + # compute mean response across trials, only use trials within eye_thresh of mean eye position + response = np.empty( + (8, 4, self.numbercells, 4) + ) # center_ori X center/iso/ortho/blank X cells X mean, std, #trials, % significant trials for oi, cori in enumerate(self.orivals): for ci, cond in enumerate(self.conditions): - if cond=='blank': - subset = mean_sweep_response[(self.stim_table.condition==cond)&(mean_sweep_eye.total0, tuning, 0) + tuning = np.where(tuning > 0, tuning, 0) CV_top_os = np.empty((8, tuning.shape[1]), dtype=np.complex128) for i in range(8): - CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) - return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - - + CV_top_os[i] = tuning[i] * np.exp(1j * 2 * orivals_rad[i]) + return np.abs(CV_top_os.sum(axis=0)) / tuning.sum(axis=0) def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -219,31 +314,57 @@ def get_metrics(self): ''' n_iter = 50 - n_trials = int(self.response[:,:,:,2].min()) + n_trials = int(self.response[:, :, :, 2].min()) print("Number of trials for cross-validation: " + str(n_trials)) -# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] cell_index = np.array(range(self.numbercells)) - response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('cell_index','center_dir','center_osi','center_dsi','iso','ortho', - 'suppression_strength','suppression_tuning','cmi','dir_percent'), index=cell_index) + response_first, response_second = self.cross_validate_response( + n_iter, n_trials + ) + + metrics = pd.DataFrame( + columns=( + 'cell_index', + 'center_dir', + 'center_osi', + 'center_dsi', + 'iso', + 'ortho', + 'suppression_strength', + 'suppression_tuning', + 'cmi', + 'dir_percent', + ), + index=cell_index, + ) metrics.cell_index = cell_index - #cross-validated metrics + # cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) ISO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - ORTHO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - STRENGTH = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + ORTHO = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + STRENGTH = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + TUNING = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + CONTEXT = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) for ni in range(n_iter): - #find pref direction for each cell for center only condition -# response_first = response_first[:,:,cell_index,:] -# response_second = response_second[:,:,cell_index,:] - sort = np.where(response_first[:,0,:,ni]==np.nanmax(response_first[:,0,:,ni], axis=(0))) + # find pref direction for each cell for center only condition + # response_first = response_first[:,:,cell_index,:] + # response_second = response_second[:,:,cell_index,:] + sort = np.where( + response_first[:, 0, :, ni] + == np.nanmax(response_first[:, 0, :, ni], axis=(0)) + ) sortind = np.argsort(sort[1]) pref_ori = sort[0][sortind] cell_index = sort[1][sortind] @@ -251,37 +372,37 @@ def get_metrics(self): DIR.loc[ni] = pref_ori - #osi + # osi OSI.loc[ni] = self.get_osi(response_second[:, 0, inds[1], ni]) - #dsi - null_ori= np.mod(pref_ori+4, 8) + # dsi + null_ori = np.mod(pref_ori + 4, 8) pref = response_second[inds[0], 0, inds[1], ni] - null = response_second[null_ori, 0, inds[1], ni] - null = np.where(null>0, null, 0) - DSI.loc[ni] = (pref-null)/(pref+null) + null = response_second[null_ori, 0, inds[1], ni] + null = np.where(null > 0, null, 0) + DSI.loc[ni] = (pref - null) / (pref + null) center = response_second[inds[0], 0, inds[1], ni] iso = response_second[inds[0], 1, inds[1], ni] ortho = response_second[inds[0], 2, inds[1], ni] - center = np.where(center>0, center, 0) - iso = np.where(iso>0, iso, 0) - ortho = np.where(ortho>0, ortho, 0) + center = np.where(center > 0, center, 0) + iso = np.where(iso > 0, iso, 0) + ortho = np.where(ortho > 0, ortho, 0) - #suppression strength - STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center + # suppression strength + STRENGTH.loc[ni] = (center - ((iso + ortho) / 2)) / center - #suppression tuning - TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) + # suppression tuning + TUNING.loc[ni] = (ortho - iso) / (center - ((iso + ortho) / 2)) - #iso + # iso ISO.loc[ni] = (center - iso) / (center + iso) - #ortho + # ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - #context modulation index (Keller et al) - #TODO: right now we're using the center to identify the preferred direction. Might not be ideal + # context modulation index (Keller et al) + # TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) metrics['center_osi'] = OSI.mean().values @@ -292,39 +413,50 @@ def get_metrics(self): metrics['suppression_tuning'] = TUNING.mean().values metrics['cmi'] = CONTEXT.mean().values - #how consistent is the selected preferred direction? + # how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() - #non cross-validated metrics -# cell_index = np.where(np.isfinite(self.dff[:,0]))[0] -# cell_index = np.array(range(self.numbercells)) - sort = np.where(self.response[:,0,:,0] == np.nanmax(self.response[:,0,:,0], axis=0)) -# sort = np.where(self.response[:,0,:,0] == np.nanmax(self.response[:,0,:,0], axis=0)) + # non cross-validated metrics + # cell_index = np.where(np.isfinite(self.dff[:,0]))[0] + # cell_index = np.array(range(self.numbercells)) + sort = np.where( + self.response[:, 0, :, 0] + == np.nanmax(self.response[:, 0, :, 0], axis=0) + ) + # sort = np.where(self.response[:,0,:,0] == np.nanmax(self.response[:,0,:,0], axis=0)) sortind = np.argsort(sort[1]) cell_index = sort[1][sortind] metrics['center_dir'] = sort[0][sortind] - metrics['center_mean'] = self.response[sort[0][sortind],0,cell_index,0] - metrics['center_std'] = self.response[sort[0][sortind],0,cell_index,1] - metrics['center_percent_trials'] = self.response[sort[0][sortind],0,cell_index,3] - metrics['blank_mean'] = self.response[0,3,cell_index,0] - metrics['blank_std'] = self.response[0,3,cell_index,1] - metrics['iso_mean'] = self.response[sort[0][sortind],1,cell_index,0] - metrics['iso_std'] = self.response[sort[0][sortind],1,cell_index,1] - metrics['ortho_mean'] = self.response[sort[0][sortind],2,cell_index,0] - metrics['ortho_std'] = self.response[sort[0][sortind],2,cell_index,1] + metrics['center_mean'] = self.response[ + sort[0][sortind], 0, cell_index, 0 + ] + metrics['center_std'] = self.response[ + sort[0][sortind], 0, cell_index, 1 + ] + metrics['center_percent_trials'] = self.response[ + sort[0][sortind], 0, cell_index, 3 + ] + metrics['blank_mean'] = self.response[0, 3, cell_index, 0] + metrics['blank_std'] = self.response[0, 3, cell_index, 1] + metrics['iso_mean'] = self.response[sort[0][sortind], 1, cell_index, 0] + metrics['iso_std'] = self.response[sort[0][sortind], 1, cell_index, 1] + metrics['ortho_mean'] = self.response[ + sort[0][sortind], 2, cell_index, 0 + ] + metrics['ortho_std'] = self.response[sort[0][sortind], 2, cell_index, 1] b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) - if len(toadd)>0: + if len(toadd) > 0: newdf = pd.DataFrame(columns=metrics.columns, index=toadd) newdf.cell_index = toadd newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) + metrics = metrics.join(self.roi[['cell_id', 'session_id', 'valid']]) metrics['cre'] = self.cre metrics['area'] = self.area metrics['depth'] = self.depth @@ -333,7 +465,10 @@ def get_metrics(self): def save_data(self): '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis', str(self.session_id)+"_cs_analysis.h5") + save_file = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis', + str(self.session_id) + "_cs_analysis.h5", + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response @@ -348,32 +483,44 @@ def save_data(self): f.close() -if __name__=='__main__': -# expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_993269234_data.h5' -## expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex New/Center Surround/Center_Surround_993269234_data.h5' -# eye_thresh = 10 -# cre = 'test' -# area = 'area test' -# depth = '33' -# cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) +if __name__ == '__main__': + # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_993269234_data.h5' + ## expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex New/Center Surround/Center_Surround_993269234_data.h5' + # eye_thresh = 10 + # cre = 'test' + # area = 'area test' + # depth = '33' + # cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') - subset = manifest[manifest.Target=='soma'] + manifest = pd.read_csv( + r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv' + ) + subset = manifest[manifest.Target == 'soma'] print(len(subset)) count = 0 failed = [] for index, row in subset.iterrows(): if np.isfinite(row.Center_Surround_Expt_ID): - count+=1 + count += 1 cre = row.Cre area = row.Area depth = row.Depth -# expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' - expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' + # expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' + expt_path = ( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_' + + str(int(row.Center_Surround_Expt_ID)) + + '_data.h5' + ) eye_thresh = 10 try: - cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - if count==1: + cs = CenterSurround( + expt_path=expt_path, + eye_thresh=eye_thresh, + cre=cre, + area=area, + depth=depth, + ) + if count == 1: metrics_all = cs.metrics.copy() print("reached here") else: @@ -381,5 +528,3 @@ def save_data(self): except: print(expt_path + " FAILED") failed.append(int(row.Center_Surround_Expt_ID)) - - diff --git a/analysis/center_surround_tf.py b/analysis/center_surround_tf.py index c66280c..a257e92 100644 --- a/analysis/center_surround_tf.py +++ b/analysis/center_surround_tf.py @@ -11,15 +11,19 @@ import os, h5py import matplotlib.pyplot as plt + def do_sweep_mean(x): return x[30:90].mean() + def do_sweep_mean_shifted(x): return x[30:40].mean() + def do_eye(x): return x[30:35].mean() + class CenterSurround: def __init__(self, expt_path, eye_thresh, cre, area, depth): @@ -31,62 +35,92 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.area = area self.depth = depth - self.orivals = range(0,360,45) - self.tfvals = [1.,2.] - self.conditions = ['center','iso','ortho','blank'] + self.orivals = range(0, 360, 45) + self.tfvals = [1.0, 2.0] + self.conditions = ['center', 'iso', 'ortho', 'blank'] - #load dff traces + # load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - #load raw traces + # load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - #load roi_table + # load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - #get stimulus table for center surround + # get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'center_surround') - #add condition column + # add condition column self.stim_table['condition'] = 'ortho' - self.stim_table.loc[self.stim_table.Center_Ori==self.stim_table.Surround_Ori, 'condition'] = 'iso' - self.stim_table.loc[np.isfinite(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'center' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isnan(self.stim_table.Surround_Ori), 'condition'] = 'blank' - self.stim_table.loc[np.isnan(self.stim_table.Center_Ori)&np.isfinite(self.stim_table.Surround_Ori), 'condition'] = 'surround' - #get spontaneous window + self.stim_table.loc[ + self.stim_table.Center_Ori == self.stim_table.Surround_Ori, + 'condition', + ] = 'iso' + self.stim_table.loc[ + np.isfinite(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'center' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isnan(self.stim_table.Surround_Ori), + 'condition', + ] = 'blank' + self.stim_table.loc[ + np.isnan(self.stim_table.Center_Ori) + & np.isfinite(self.stim_table.Surround_Ori), + 'condition', + ] = 'surround' + # get spontaneous window self.stim_table_spont = self.get_spont_table() - #load eyetracking + # load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - #run analysis - self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() - -# self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) - self.metrics, self.OSI, self.DSI, self.ISO, self.ORTHO, self.STRENGTH, self.TUNING, self.CONTEXT = self.get_metrics() - - #save outputs + # run analysis + ( + self.sweep_response, + self.mean_sweep_response, + self.sweep_eye, + self.mean_sweep_eye, + self.sweep_p_values, + self.response, + ) = self.get_stimulus_response() + + # self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) + ( + self.metrics, + self.OSI, + self.DSI, + self.ISO, + self.ORTHO, + self.STRENGTH, + self.TUNING, + self.CONTEXT, + ) = self.get_metrics() + + # save outputs self.save_data() - #plot traces + # plot traces def get_spont_table(self): '''finds the window of spotaneous activity during the session''' stim_table_lsn = pd.read_hdf(self.expt_path, 'locally_sparse_noise') - stim_all = self.stim_table[['Start','End']] - stim_all = stim_all.append(stim_table_lsn[['Start','End']]) + stim_all = self.stim_table[['Start', 'End']] + stim_all = stim_all.append(stim_table_lsn[['Start', 'End']]) stim_all.sort_values(by='Start', inplace=True) stim_all.reset_index(inplace=True) - spont_start = np.where(np.ediff1d(stim_all.Start)>8000)[0][0] - stim_table_spont = pd.DataFrame(columns=('Start','End'), index=[0]) - stim_table_spont.Start = stim_all.End[spont_start]+1 - stim_table_spont.End = stim_all.Start[spont_start+1]-1 + spont_start = np.where(np.ediff1d(stim_all.Start) > 8000)[0][0] + stim_table_spont = pd.DataFrame(columns=('Start', 'End'), index=[0]) + stim_table_spont.Start = stim_all.End[spont_start] + 1 + stim_table_spont.End = stim_all.Start[spont_start + 1] - 1 return stim_table_spont def get_stimulus_response(self): @@ -104,61 +138,112 @@ def get_stimulus_response(self): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_response = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + sweep_eye = pd.DataFrame( + index=self.stim_table.index.values, + columns=('x_pos_deg', 'y_pos_deg'), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - #uses the global dff trace - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - - #computes DF/F using the mean of the inter-sweep gray for the Fo -# temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] -# sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-30:int(row.Start+90)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-30:int(row.Start+90)].values + # uses the global dff trace + sweep_response[str(nc)][index] = self.dff[ + nc, int(row.Start) - 30 : int(row.Start) + 90 + ] + + # computes DF/F using the mean of the inter-sweep gray for the Fo + # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] + # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) - mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - - #make spontaneous p_values + mean_sweep_eye['total'] = np.sqrt( + ((mean_sweep_eye.x_pos_deg - mean_sweep_eye.x_pos_deg.mean()) ** 2) + + ( + (mean_sweep_eye.y_pos_deg - mean_sweep_eye.y_pos_deg.mean()) + ** 2 + ) + ) + + # make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) -# idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) - idx = np.random.choice(range(int(self.stim_table_spont.Start), int(self.stim_table_spont.End)), 10000) + # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) + idx = np.random.choice( + range( + int(self.stim_table_spont.Start), int(self.stim_table_spont.End) + ), + 10000, + ) for i in range(60): - shuffled_responses[:,:,i] = self.dff[:,idx+i] + shuffled_responses[:, :, i] = self.dff[:, idx + i] shuffled_mean = shuffled_responses.mean(axis=2) - sweep_p_values = pd.DataFrame(index = self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_p_values = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) for nc in range(self.numbercells): subset = mean_sweep_response[str(nc)].values - null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) - actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat + null_dist_mat = np.tile(shuffled_mean[nc, :], reps=(len(subset), 1)) + actual_is_less = subset.reshape(len(subset), 1) <= null_dist_mat p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position - response = np.empty((8, 2, 4, self.numbercells, 4)) #center_ori X TF x center/iso/ortho/blank X cells X mean, std, #trials, % significant trials + # compute mean response across trials, only use trials within eye_thresh of mean eye position + response = np.empty( + (8, 2, 4, self.numbercells, 4) + ) # center_ori X TF x center/iso/ortho/blank X cells X mean, std, #trials, % significant trials for oi, cori in enumerate(self.orivals): for ti, tf in enumerate(self.tfvals): for ci, cond in enumerate(self.conditions): - if cond=='blank': - subset = mean_sweep_response[(self.stim_table.condition==cond)&(mean_sweep_eye.total0, tuning, 0) + tuning = np.where(tuning > 0, tuning, 0) CV_top_os = np.empty((8, tuning.shape[1]), dtype=np.complex128) for i in range(8): - CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) - return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + CV_top_os[i] = tuning[i] * np.exp(1j * 2 * orivals_rad[i]) + return np.abs(CV_top_os.sum(axis=0)) / tuning.sum(axis=0) def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -220,31 +323,58 @@ def get_metrics(self): ''' n_iter = 50 - n_trials = int(self.response[:,:,:,:,2].min()) + n_trials = int(self.response[:, :, :, :, 2].min()) print("Number of trials for cross-validation: " + str(n_trials)) cell_index = np.array(range(self.numbercells)) - response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('cell_index','center_dir','center_tf','center_osi','center_dsi','iso','ortho', - 'suppression_strength','suppression_tuning','cmi','dir_percent'), index=cell_index) + response_first, response_second = self.cross_validate_response( + n_iter, n_trials + ) + + metrics = pd.DataFrame( + columns=( + 'cell_index', + 'center_dir', + 'center_tf', + 'center_osi', + 'center_dsi', + 'iso', + 'ortho', + 'suppression_strength', + 'suppression_tuning', + 'cmi', + 'dir_percent', + ), + index=cell_index, + ) metrics.cell_index = cell_index - #cross-validated metrics + # cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) ISO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - ORTHO = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - STRENGTH = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - TUNING = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) - CONTEXT = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) + ORTHO = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + STRENGTH = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + TUNING = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) + CONTEXT = pd.DataFrame( + columns=cell_index.astype(str), index=range(n_iter) + ) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) for ni in range(n_iter): - #find pref direction for each cell for center only condition -# response_first = response_first[:,:,:,cell_index,:] -# response_second = response_second[:,:,:,cell_index,:] - sort = np.where(response_first[:,:,0,:,ni]==np.nanmax(response_first[:,:,0,:,ni], axis=(0,1))) - #TODO: this is where the TF is going to add issues... + # find pref direction for each cell for center only condition + # response_first = response_first[:,:,:,cell_index,:] + # response_second = response_second[:,:,:,cell_index,:] + sort = np.where( + response_first[:, :, 0, :, ni] + == np.nanmax(response_first[:, :, 0, :, ni], axis=(0, 1)) + ) + # TODO: this is where the TF is going to add issues... sortind = np.argsort(sort[2]) pref_ori = sort[0][sortind] pref_tf = sort[1][sortind] @@ -253,33 +383,35 @@ def get_metrics(self): DIR.loc[ni] = pref_ori - #osi - OSI.loc[ni] = self.get_osi(response_second[:, inds[1], 0, inds[2], ni]) + # osi + OSI.loc[ni] = self.get_osi( + response_second[:, inds[1], 0, inds[2], ni] + ) - #dsi - null_ori= np.mod(pref_ori+4, 8) + # dsi + null_ori = np.mod(pref_ori + 4, 8) pref = response_second[inds[0], inds[1], 0, inds[2], ni] - null = response_second[null_ori, inds[1], 0, inds[2], ni] - null = np.where(null>0, null, 0) - DSI.loc[ni] = (pref-null)/(pref+null) + null = response_second[null_ori, inds[1], 0, inds[2], ni] + null = np.where(null > 0, null, 0) + DSI.loc[ni] = (pref - null) / (pref + null) center = response_second[inds[0], inds[1], 0, inds[2], ni] iso = response_second[inds[0], inds[1], 1, inds[2], ni] ortho = response_second[inds[0], inds[1], 2, inds[2], ni] - #suppression strength - STRENGTH.loc[ni] = (center - ((iso+ortho)/2)) / center + # suppression strength + STRENGTH.loc[ni] = (center - ((iso + ortho) / 2)) / center - #suppression tuning - TUNING.loc[ni] = (ortho - iso) / (center - ((iso+ortho)/2)) + # suppression tuning + TUNING.loc[ni] = (ortho - iso) / (center - ((iso + ortho) / 2)) - #iso + # iso ISO.loc[ni] = (center - iso) / (center + iso) - #ortho + # ortho ORTHO.loc[ni] = (center - ortho) / (center + ortho) - #context modulation index (Keller et al) - #TODO: right now we're using the center to identify the preferred direction. Might not be ideal + # context modulation index (Keller et al) + # TODO: right now we're using the center to identify the preferred direction. Might not be ideal CONTEXT.loc[ni] = (ortho - iso) / (ortho + iso) metrics['center_osi'] = OSI.mean().values @@ -290,41 +422,54 @@ def get_metrics(self): metrics['suppression_tuning'] = TUNING.mean().values metrics['cmi'] = CONTEXT.mean().values - #how consistent is the selected preferred direction? + # how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() - #non cross-validated metrics + # non cross-validated metrics cell_index = np.array(range(self.numbercells)) - sort = np.where(self.response[:,:,0,cell_index,0] == np.nanmax(self.response[:,:,0,cell_index,0], axis=(0,1))) -# sort = np.where(self.response[:,0,:,0] == np.nanmax(self.response[:,0,:,0], axis=0)) + sort = np.where( + self.response[:, :, 0, cell_index, 0] + == np.nanmax(self.response[:, :, 0, cell_index, 0], axis=(0, 1)) + ) + # sort = np.where(self.response[:,0,:,0] == np.nanmax(self.response[:,0,:,0], axis=0)) sortind = np.argsort(sort[2]) pref_ori = sort[0][sortind] pref_tf = sort[1][sortind] cell_index = sort[2][sortind] metrics['center_dir'] = pref_ori metrics['center_tf'] = pref_tf - metrics['center_mean'] = self.response[pref_ori,pref_tf,0,cell_index,0] - metrics['center_std'] = self.response[pref_ori,pref_tf,0,cell_index,1] - metrics['center_percent_trials'] = self.response[pref_ori, pref_tf,0,cell_index,3] - metrics['blank_mean'] = self.response[0,0,3,cell_index,0] - metrics['blank_std'] = self.response[0,0,3,cell_index,1] - metrics['iso_mean'] = self.response[pref_ori,pref_tf,1,cell_index,0] - metrics['iso_std'] = self.response[pref_ori,pref_tf,1,cell_index,1] - metrics['ortho_mean'] = self.response[pref_ori,pref_tf,2,cell_index,0] - metrics['ortho_std'] = self.response[pref_ori,pref_tf,2,cell_index,1] + metrics['center_mean'] = self.response[ + pref_ori, pref_tf, 0, cell_index, 0 + ] + metrics['center_std'] = self.response[ + pref_ori, pref_tf, 0, cell_index, 1 + ] + metrics['center_percent_trials'] = self.response[ + pref_ori, pref_tf, 0, cell_index, 3 + ] + metrics['blank_mean'] = self.response[0, 0, 3, cell_index, 0] + metrics['blank_std'] = self.response[0, 0, 3, cell_index, 1] + metrics['iso_mean'] = self.response[pref_ori, pref_tf, 1, cell_index, 0] + metrics['iso_std'] = self.response[pref_ori, pref_tf, 1, cell_index, 1] + metrics['ortho_mean'] = self.response[ + pref_ori, pref_tf, 2, cell_index, 0 + ] + metrics['ortho_std'] = self.response[ + pref_ori, pref_tf, 2, cell_index, 1 + ] b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) - if len(toadd)>0: + if len(toadd) > 0: newdf = pd.DataFrame(columns=metrics.columns, index=toadd) newdf.cell_index = toadd newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) + metrics = metrics.join(self.roi[['cell_id', 'session_id', 'valid']]) metrics['cre'] = self.cre metrics['area'] = self.area metrics['depth'] = self.depth @@ -333,7 +478,10 @@ def get_metrics(self): def save_data(self): '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf', str(self.session_id)+"_cs_analysis.h5") + save_file = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf', + str(self.session_id) + "_cs_analysis.h5", + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response @@ -348,31 +496,43 @@ def save_data(self): f.close() -if __name__=='__main__': -# expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_1006636506_data.h5' -# eye_thresh = 10 -# cre = 'test' -# area = 'area test' -# depth = '33' -# cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) +if __name__ == '__main__': + # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_1006636506_data.h5' + # eye_thresh = 10 + # cre = 'test' + # area = 'area test' + # depth = '33' + # cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') - subset = manifest[manifest.Target=='soma'] + manifest = pd.read_csv( + r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv' + ) + subset = manifest[manifest.Target == 'soma'] print(len(subset)) count = 0 failed = [] for index, row in subset.iterrows(): if np.isfinite(row.Center_Surround_Expt_ID): - count+=1 + count += 1 cre = row.Cre area = row.Area depth = row.Depth -# expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' - expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' + # expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_'+str(int(row.Center_Surround_Expt_ID))+'_data.h5' + expt_path = ( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Center_Surround_' + + str(int(row.Center_Surround_Expt_ID)) + + '_data.h5' + ) eye_thresh = 10 try: - cs = CenterSurround(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - if count==1: + cs = CenterSurround( + expt_path=expt_path, + eye_thresh=eye_thresh, + cre=cre, + area=area, + depth=depth, + ) + if count == 1: metrics_all = cs.metrics.copy() print("reached here") else: @@ -380,5 +540,3 @@ def save_data(self): except: print(expt_path + " FAILED") failed.append(int(row.Center_Surround_Expt_ID)) - - diff --git a/analysis/example_code/locally_sparse_noise_events.py b/analysis/example_code/locally_sparse_noise_events.py index 3ed7ab0..c71e5a4 100644 --- a/analysis/example_code/locally_sparse_noise_events.py +++ b/analysis/example_code/locally_sparse_noise_events.py @@ -24,19 +24,32 @@ class LocallySparseNoise: def __init__(self, session_id): self.session_id = session_id - save_path_head = #TODO + save_path_head = # TODO self.save_path = os.path.join(save_path_head, 'LocallySparseNoise') f = h5py.File(dff_path, 'r') self.dff = f['data'][()] f.close() - self.stim_table_sp, _, _ = core.get_stim_table(self.session_id, 'spontaneous') + self.stim_table_sp, _, _ = core.get_stim_table( + self.session_id, 'spontaneous' + ) lsn_name = 'locally_sparse_noise' - self.stim_table, self.numbercells, self.specimen_ids = core.get_stim_table(self.session_id, lsn_name) + ( + self.stim_table, + self.numbercells, + self.specimen_ids, + ) = core.get_stim_table(self.session_id, lsn_name) self.LSN = core.get_stimulus_template(self.session_id, lsn_name) - self.sweep_events, self.mean_sweep_events, self.sweep_p_values, self.running_speed, self.response_events_on, self.response_events_off = self.get_stimulus_response(self.LSN) + ( + self.sweep_events, + self.mean_sweep_events, + self.sweep_p_values, + self.running_speed, + self.response_events_on, + self.response_events_off, + ) = self.get_stimulus_response(self.LSN) self.peak = self.get_peak(lsn_name) self.save_data(lsn_name) @@ -54,11 +67,16 @@ def get_stimulus_response(self, LSN): ''' - sweep_events = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_events = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - sweep_events[str(nc)][index] = self.l0_events[nc, int(row.start)-28:int(row.start)+35] + sweep_events[str(nc)][index] = self.l0_events[ + nc, int(row.start) - 28 : int(row.start) + 35 + ] mean_sweep_events = sweep_events.applymap(do_sweep_mean_shifted) @@ -229,5 +247,7 @@ def save_data(self, lsn_name): if __name__ == '__main__': session_id = 569611979 - dff_path = r'/Volumes/My Passport/Openscope Multiplex/891653201/892006924_dff.h5 + dff_path = ( + r'/Volumes/My Passport/Openscope Multiplex/891653201/892006924_dff.h5' + ) lsn = LocallySparseNoise(session_id=session_id) diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 3987700..5df234c 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -15,9 +15,10 @@ from RunningData import get_running_data from get_eye_tracking import align_eye_tracking + def get_all_data(path_name, save_path, expt_name, row): - #get access to sub folders + # get access to sub folders for f in os.listdir(path_name): if f.startswith('ophys_experiment'): expt_path = os.path.join(path_name, f) @@ -30,24 +31,24 @@ def get_all_data(path_name, save_path, expt_name, row): if f.startswith('ophys_cell_segmentation_run'): roi_path = os.path.join(proc_path, f) - #ROI table + # ROI table for fname in os.listdir(expt_path): if fname.endswith('output_cell_roi_creation.json'): - jsonpath= os.path.join(expt_path, fname) + jsonpath = os.path.join(expt_path, fname) with open(jsonpath, 'r') as f: jin = json.load(f) f.close() break - roi_locations = pd.DataFrame.from_dict(data = jin['rois'], orient='index') - roi_locations.drop(columns=['exclude_code','mask_page'], inplace=True) #removing columns I don't think we need + roi_locations = pd.DataFrame.from_dict(data=jin['rois'], orient='index') + roi_locations.drop( + columns=['exclude_code', 'mask_page'], inplace=True + ) # removing columns I don't think we need roi_locations.reset_index(inplace=True) - session_id = int( - path_name.split('/')[-1] - ) + session_id = int(path_name.split('/')[-1]) roi_locations['session_id'] = session_id - #dff traces + # dff traces for f in os.listdir(expt_path): if f.endswith('_dff.h5'): dff_path = os.path.join(expt_path, f) @@ -55,17 +56,17 @@ def get_all_data(path_name, save_path, expt_name, row): dff = f['data'].value f.close() - #raw fluorescence & cell ids + # raw fluorescence & cell ids for f in os.listdir(proc_path): - if f.endswith('roi_traces.h5'): - traces_path = os.path.join(proc_path, f) - f = h5py.File(traces_path, 'r') - raw_traces = f['data'][()] - cell_ids = f['roi_names'][()].astype(str) - f.close() + if f.endswith('roi_traces.h5'): + traces_path = os.path.join(proc_path, f) + f = h5py.File(traces_path, 'r') + raw_traces = f['data'][()] + cell_ids = f['roi_names'][()].astype(str) + f.close() roi_locations['cell_id'] = cell_ids - #eyetracking + # eyetracking for fn in os.listdir(eye_path): if fn.endswith('mapping.h5'): dlc_file = os.path.join(eye_path, fn) @@ -73,69 +74,71 @@ def get_all_data(path_name, save_path, expt_name, row): if f.endswith('time_synchronization.h5'): temporal_alignment_file = os.path.join(expt_path, f) eye_sync = align_eye_tracking(dlc_file, temporal_alignment_file) -# pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas') -# eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas') -# pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') -# -# ##temporal alignment -# f = h5py.File(temporal_alignment_file, 'r') -# eye_frames = f['eye_tracking_alignment'].value -# f.close() -# eye_frames = eye_frames.astype(int) -# eye_frames = eye_frames[np.where(eye_frames>0)] -# -# eye_area_sync = eye_area[eye_frames] -# pupil_area_sync = pupil_area[eye_frames] -# x_pos_sync = pos.x_pos_deg.values[eye_frames] -# y_pos_sync = pos.y_pos_deg.values[eye_frames] -# -# ##correcting dropped camera frames -# test = eye_frames[np.isfinite(eye_frames)] -# test = test.astype(int) -# temp2 = np.bincount(test) -# dropped_camera_frames = np.where(temp2>2)[0] -# for a in dropped_camera_frames: -# null_2p_frames = np.where(eye_frames==a)[0] -# eye_area_sync[null_2p_frames] = np.NaN -# pupil_area_sync[null_2p_frames] = np.NaN -# x_pos_sync[null_2p_frames] = np.NaN -# y_pos_sync[null_2p_frames] = np.NaN -# -# eye_sync = pd.DataFrame(data=np.vstack((eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync)).T, columns=('eye_area','pupil_area','x_pos_deg','y_pos_deg')) - - #max projection + # pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas') + # eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas') + # pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') + # + # ##temporal alignment + # f = h5py.File(temporal_alignment_file, 'r') + # eye_frames = f['eye_tracking_alignment'].value + # f.close() + # eye_frames = eye_frames.astype(int) + # eye_frames = eye_frames[np.where(eye_frames>0)] + # + # eye_area_sync = eye_area[eye_frames] + # pupil_area_sync = pupil_area[eye_frames] + # x_pos_sync = pos.x_pos_deg.values[eye_frames] + # y_pos_sync = pos.y_pos_deg.values[eye_frames] + # + # ##correcting dropped camera frames + # test = eye_frames[np.isfinite(eye_frames)] + # test = test.astype(int) + # temp2 = np.bincount(test) + # dropped_camera_frames = np.where(temp2>2)[0] + # for a in dropped_camera_frames: + # null_2p_frames = np.where(eye_frames==a)[0] + # eye_area_sync[null_2p_frames] = np.NaN + # pupil_area_sync[null_2p_frames] = np.NaN + # x_pos_sync[null_2p_frames] = np.NaN + # y_pos_sync[null_2p_frames] = np.NaN + # + # eye_sync = pd.DataFrame(data=np.vstack((eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync)).T, columns=('eye_area','pupil_area','x_pos_deg','y_pos_deg')) + + # max projection mp_path = os.path.join(proc_path, 'max_downsample_4Hz_0.png') mp = Image.open(mp_path) mp_array = np.array(mp) - #ROI masks outlines + # ROI masks outlines boundary_path = os.path.join(roi_path, 'maxInt_boundary.png') boundary = Image.open(boundary_path) boundary_array = np.array(boundary) - #stimulus table - stim_table = create_stim_tables(path_name) #returns dictionary. Not sure how to save dictionary so pulling out each dataframe + # stimulus table + stim_table = create_stim_tables( + path_name + ) # returns dictionary. Not sure how to save dictionary so pulling out each dataframe - #running speed + # running speed dxds, startdate = get_running_data(path_name) - #pad end with NaNs to match length of dff + # pad end with NaNs to match length of dff nframes = dff.shape[1] - dxds.shape[0] dx = np.append(dxds, np.repeat(np.NaN, nframes)) - #remove traces with NaNs from dff, roi_table, and roi_masks + # remove traces with NaNs from dff, roi_table, and roi_masks roi_locations['roi_mask_id'] = range(len(roi_locations)) - to_keep = np.where(np.isfinite(dff[:,0]))[0] - to_del = np.where(np.isnan(dff[:,0]))[0] - roi_locations['finite'] = np.isfinite(dff[:,0]) + to_keep = np.where(np.isfinite(dff[:, 0]))[0] + to_del = np.where(np.isnan(dff[:, 0]))[0] + roi_locations['finite'] = np.isfinite(dff[:, 0]) roi_trimmed = roi_locations[roi_locations.finite] roi_trimmed.reset_index(inplace=True) - new_dff = dff[to_keep,:] + new_dff = dff[to_keep, :] for i in to_del: - boundary_array[np.where(boundary_array==i)] = 0 + boundary_array[np.where(boundary_array == i)] = 0 - #meta data + # meta data meta_data = {} meta_data['mouse_id'] = row.Mouse_ID meta_data['area'] = row.Area @@ -145,8 +148,10 @@ def get_all_data(path_name, save_path, expt_name, row): meta_data['session_ID'] = session_id meta_data['startdate'] = startdate - #Save Data - save_file = os.path.join(save_path, expt_name+'_'+str(session_id)+'_data.h5') + # Save Data + save_file = os.path.join( + save_path, expt_name + '_' + str(session_id) + '_data.h5' + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['roi_table'] = roi_trimmed @@ -167,12 +172,14 @@ def get_all_data(path_name, save_path, expt_name, row): return -if __name__=='__main__': - manifest = pd.read_csv(r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset/data manifest.csv') +if __name__ == '__main__': + manifest = pd.read_csv( + r'/Users/saskiad/Documents/Openscope/2019/Surround suppression/Final dataset/data manifest.csv' + ) save_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim' - soma = manifest[manifest.Target=='soma'] + soma = manifest[manifest.Target == 'soma'] for index, row in soma.iterrows(): - if np.mod(index, 10)==0: + if np.mod(index, 10) == 0: print(index) expt_id = row.Center_Surround_Expt_ID if np.isfinite(expt_id): @@ -196,9 +203,3 @@ def get_all_data(path_name, save_path, expt_name, row): # expt_name = 'Multiplex' # save_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim' # get_all_data(path_name, save_path, expt_name, row) - - - - - - diff --git a/analysis/read_data.py b/analysis/read_data.py index 9fd4e63..a359484 100644 --- a/analysis/read_data.py +++ b/analysis/read_data.py @@ -17,89 +17,124 @@ def get_dff_traces(file_path): f.close() return dff + def get_raw_traces(file_path): f = h5py.File(file_path) raw = f['raw_traces'][()] f.close() return raw + def get_running_speed(file_path): f = h5py.File(file_path) dx = f['running_speed'][()] f.close() return dx + def get_cell_ids(file_path): f = h5py.File(file_path) cell_ids = f['cell_ids'][()] f.close() return cell_ids + def get_max_projection(file_path): f = h5py.File(file_path) max_proj = f['max_projection'][()] f.close() return max_proj + def get_metadata(file_path): import ast + f = h5py.File(file_path) md = f.get('meta_data')[...].tolist() f.close() meta_data = ast.literal_eval(md) return meta_data + def get_roi_table(file_path): return pd.read_hdf(file_path, 'roi_table') + def get_stimulus_table(file_path, stimulus): return pd.read_hdf(file_path, stimulus) + def get_eye_tracking(file_path): return pd.read_hdf(file_path, 'eye_tracking') + def get_stimulus_epochs(file_path, session_type): - if session_type=='size_tuning': + if session_type == 'size_tuning': stim_name_1 = 'drifting_gratings_size' stim1 = get_stimulus_table(file_path, stim_name_1) - stim_epoch = pd.DataFrame(columns=('Start','End','Stimulus_name')) - break1 = np.where(np.ediff1d(stim1.Start)>1000)[0][0] + stim_epoch = pd.DataFrame(columns=('Start', 'End', 'Stimulus_name')) + break1 = np.where(np.ediff1d(stim1.Start) > 1000)[0][0] stim_epoch.loc[0] = [stim1.Start[0], stim1.End[break1], stim_name_1] - stim_epoch.loc[1] = [stim1.Start[break1+1], stim1.End.max(), stim_name_1] - stim_epoch.loc[2] = [0, stim_epoch.Start.iloc[0]-1, 'spontaneous_activity'] - stim_epoch.loc[3] = [stim_epoch.End.iloc[0]+1, stim_epoch.Start.iloc[1]-1, 'spontaneous_activity'] + stim_epoch.loc[1] = [ + stim1.Start[break1 + 1], + stim1.End.max(), + stim_name_1, + ] + stim_epoch.loc[2] = [ + 0, + stim_epoch.Start.iloc[0] - 1, + 'spontaneous_activity', + ] + stim_epoch.loc[3] = [ + stim_epoch.End.iloc[0] + 1, + stim_epoch.Start.iloc[1] - 1, + 'spontaneous_activity', + ] stim_epoch.sort_values(by='Start', inplace=True) stim_epoch.reset_index(inplace=True) stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start - elif session_type=='drifting_gratings_grid': + elif session_type == 'drifting_gratings_grid': stim_name_1 = 'drifting_gratings_grid' stim_epoch = get_epochs(file_path, stim_name_1) - elif session_type=='center_surround': + elif session_type == 'center_surround': stim_name_1 = 'center_surround' stim_epoch = get_epochs(file_path, stim_name_1) return stim_epoch -def get_epochs(file_path, stim_name_1): - stim1 = get_stimulus_table(file_path, stim_name_1) - stim2 = get_stimulus_table(file_path, 'locally_sparse_noise') - stim_epoch = pd.DataFrame(columns=('Start','End','Stimulus_name')) - break1 = np.where(np.ediff1d(stim1.Start)>1000)[0][0] - break2 = np.where(np.ediff1d(stim2.Start)>1000)[0][0] - stim_epoch.loc[0] = [stim1.Start[0], stim1.End[break1], stim_name_1] - stim_epoch.loc[1] = [stim1.Start[break1+1], stim1.End.max(), stim_name_1] - stim_epoch.loc[2] = [stim2.Start[0], stim2.End[break2], 'locally_sparse_noise'] - stim_epoch.loc[3] = [stim2.Start[break2+1], stim2.End.max(), 'locally_sparse_noise'] - stim_epoch.sort_values(by='Start', inplace=True) - stim_epoch.loc[4] = [0, stim_epoch.Start.iloc[0]-1, 'spontaneous_activity'] - for i in range(1,4): - stim_epoch.loc[4+i] = [stim_epoch.End.iloc[i-1]+1, stim_epoch.Start.iloc[i]-1, 'spontaneous_activity'] - stim_epoch.sort_values(by='Start', inplace=True) - stim_epoch.reset_index(inplace=True) - stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start - return stim_epoch - - - +def get_epochs(file_path, stim_name_1): + stim1 = get_stimulus_table(file_path, stim_name_1) + stim2 = get_stimulus_table(file_path, 'locally_sparse_noise') + stim_epoch = pd.DataFrame(columns=('Start', 'End', 'Stimulus_name')) + break1 = np.where(np.ediff1d(stim1.Start) > 1000)[0][0] + break2 = np.where(np.ediff1d(stim2.Start) > 1000)[0][0] + stim_epoch.loc[0] = [stim1.Start[0], stim1.End[break1], stim_name_1] + stim_epoch.loc[1] = [stim1.Start[break1 + 1], stim1.End.max(), stim_name_1] + stim_epoch.loc[2] = [ + stim2.Start[0], + stim2.End[break2], + 'locally_sparse_noise', + ] + stim_epoch.loc[3] = [ + stim2.Start[break2 + 1], + stim2.End.max(), + 'locally_sparse_noise', + ] + stim_epoch.sort_values(by='Start', inplace=True) + stim_epoch.loc[4] = [ + 0, + stim_epoch.Start.iloc[0] - 1, + 'spontaneous_activity', + ] + for i in range(1, 4): + stim_epoch.loc[4 + i] = [ + stim_epoch.End.iloc[i - 1] + 1, + stim_epoch.Start.iloc[i] - 1, + 'spontaneous_activity', + ] + stim_epoch.sort_values(by='Start', inplace=True) + stim_epoch.reset_index(inplace=True) + stim_epoch['Duration'] = stim_epoch.End - stim_epoch.Start + return stim_epoch diff --git a/analysis/size_tuning.py b/analysis/size_tuning.py index 4efb2a3..a067650 100644 --- a/analysis/size_tuning.py +++ b/analysis/size_tuning.py @@ -11,15 +11,19 @@ import os, h5py import matplotlib.pyplot as plt + def do_sweep_mean(x): return x[30:90].mean() + def do_sweep_mean_shifted(x): return x[30:40].mean() + def do_eye(x): return x[30:35].mean() + class SizeTuning: def __init__(self, expt_path, eye_thresh, cre, area, depth): @@ -31,56 +35,60 @@ def __init__(self, expt_path, eye_thresh, cre, area, depth): self.area = area self.depth = depth - self.orivals = range(0,360,45) - self.tfvals = [1.,2.] - self.sizevals = [30,52,67,79,120] + self.orivals = range(0, 360, 45) + self.tfvals = [1.0, 2.0] + self.sizevals = [30, 52, 67, 79, 120] - #load dff traces + # load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() - #load raw traces + # load raw traces f = h5py.File(self.expt_path, 'r') self.traces = f['raw_traces'][()] f.close() self.numbercells = self.dff.shape[0] - #load roi_table + # load roi_table self.roi = pd.read_hdf(self.expt_path, 'roi_table') - - #get stimulus table for center surround + # get stimulus table for center surround self.stim_table = pd.read_hdf(self.expt_path, 'drifting_gratings_size') - #get spontaneous window + # get spontaneous window self.stim_table_spont = self.get_spont_table() - #load eyetracking + # load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - #run analysis - self.sweep_response, self.mean_sweep_response, self.sweep_eye, self.mean_sweep_eye, self.sweep_p_values, self.response = self.get_stimulus_response() - -# self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) + # run analysis + ( + self.sweep_response, + self.mean_sweep_response, + self.sweep_eye, + self.mean_sweep_eye, + self.sweep_p_values, + self.response, + ) = self.get_stimulus_response() + + # self.first, self.second = self.cross_validate_response(n_trials=int(self.response[:,:,:,:,2].min())) self.metrics, self.OSI, self.DSI, self.DIR = self.get_metrics() - #save outputs + # save outputs self.save_data() - #plot traces + # plot traces def get_spont_table(self): '''finds the window of spotaneous activity during the session''' - spont_start = np.where(np.ediff1d(self.stim_table.Start)>8000)[0][0] - stim_table_spont = pd.DataFrame(columns=('Start','End'), index=[0]) - stim_table_spont.Start = self.stim_table.End[spont_start]+1 - stim_table_spont.End = self.stim_table.Start[spont_start+1]-1 + spont_start = np.where(np.ediff1d(self.stim_table.Start) > 8000)[0][0] + stim_table_spont = pd.DataFrame(columns=('Start', 'End'), index=[0]) + stim_table_spont.Start = self.stim_table.End[spont_start] + 1 + stim_table_spont.End = self.stim_table.Start[spont_start + 1] - 1 return stim_table_spont - - def get_stimulus_response(self): '''calculates the response to each stimulus trial. Calculates the mean response to each stimulus condition. Only uses trials when the eye position is within eye_thresh degrees of the mean eye position. Default eye_thresh is 10. @@ -96,66 +104,112 @@ def get_stimulus_response(self): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_response = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + sweep_eye = pd.DataFrame( + index=self.stim_table.index.values, + columns=('x_pos_deg', 'y_pos_deg'), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - #uses the global dff trace - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-30:int(row.Start)+90] - - #computes DF/F using the mean of the inter-sweep gray for the Fo -# temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] -# sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-30:int(row.Start+90)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-30:int(row.Start+90)].values + # uses the global dff trace + sweep_response[str(nc)][index] = self.dff[ + nc, int(row.Start) - 30 : int(row.Start) + 90 + ] + + # computes DF/F using the mean of the inter-sweep gray for the Fo + # temp = self.traces[nc, int(row.Start)-30:int(row.Start)+90] + # sweep_response[str(nc)][index] = ((temp/np.mean(temp[:30]))-1) + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[ + int(row.Start) - 30 : int(row.Start + 90) + ].values mean_sweep_response = sweep_response.applymap(do_sweep_mean) mean_sweep_eye = sweep_eye.applymap(do_eye) - mean_sweep_eye['total'] = np.sqrt(((mean_sweep_eye.x_pos_deg-mean_sweep_eye.x_pos_deg.mean())**2) + ((mean_sweep_eye.y_pos_deg-mean_sweep_eye.y_pos_deg.mean())**2)) - - #make spontaneous p_values + mean_sweep_eye['total'] = np.sqrt( + ((mean_sweep_eye.x_pos_deg - mean_sweep_eye.x_pos_deg.mean()) ** 2) + + ( + (mean_sweep_eye.y_pos_deg - mean_sweep_eye.y_pos_deg.mean()) + ** 2 + ) + ) + + # make spontaneous p_values shuffled_responses = np.empty((self.numbercells, 10000, 60)) -# idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) - idx = np.random.choice(range(int(self.stim_table_spont.Start), int(self.stim_table_spont.End)), 10000) + # idx = np.random.choice(range(self.stim_table_spont.Start, self.stim_table_spont.End), 10000) + idx = np.random.choice( + range( + int(self.stim_table_spont.Start), int(self.stim_table_spont.End) + ), + 10000, + ) for i in range(60): - shuffled_responses[:,:,i] = self.dff[:,idx+i] + shuffled_responses[:, :, i] = self.dff[:, idx + i] shuffled_mean = shuffled_responses.mean(axis=2) - sweep_p_values = pd.DataFrame(index = self.stim_table.index.values, columns=np.array(range(self.numbercells)).astype(str)) + sweep_p_values = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(range(self.numbercells)).astype(str), + ) for nc in range(self.numbercells): subset = mean_sweep_response[str(nc)].values - null_dist_mat = np.tile(shuffled_mean[nc,:], reps=(len(subset),1)) - actual_is_less = subset.reshape(len(subset),1) <= null_dist_mat + null_dist_mat = np.tile(shuffled_mean[nc, :], reps=(len(subset), 1)) + actual_is_less = subset.reshape(len(subset), 1) <= null_dist_mat p_values = np.mean(actual_is_less, axis=1) sweep_p_values[str(nc)] = p_values - #compute mean response across trials, only use trials within eye_thresh of mean eye position - response = np.empty((8, 2, 6, self.numbercells, 4)) #ori X TF x size X cells X mean, std, #trials, % significant trials + # compute mean response across trials, only use trials within eye_thresh of mean eye position + response = np.empty( + (8, 2, 6, self.numbercells, 4) + ) # ori X TF x size X cells X mean, std, #trials, % significant trials response[:] = np.NaN for oi, ori in enumerate(self.orivals): for ti, tf in enumerate(self.tfvals): for si, size in enumerate(self.sizevals): - subset = mean_sweep_response[(self.stim_table.Ori==ori)&(self.stim_table.TF==tf)& - (self.stim_table.Size==size)&(mean_sweep_eye.total0, tuning, 0) + tuning = np.where(tuning > 0, tuning, 0) CV_top_os = np.empty((8, tuning.shape[1]), dtype=np.complex128) for i in range(8): - CV_top_os[i] = (tuning[i]*np.exp(1j*2*orivals_rad[i])) - return np.abs(CV_top_os.sum(axis=0))/tuning.sum(axis=0) - + CV_top_os[i] = tuning[i] * np.exp(1j * 2 * orivals_rad[i]) + return np.abs(CV_top_os.sum(axis=0)) / tuning.sum(axis=0) def get_metrics(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -218,57 +290,81 @@ def get_metrics(self): ''' n_iter = 50 - n_trials = int(np.nanmin(self.response[:,:,1:,:,2])) + n_trials = int(np.nanmin(self.response[:, :, 1:, :, 2])) print("Number of trials for cross-validation: " + str(n_trials)) cell_index = np.array(range(self.numbercells)) - response_first, response_second = self.cross_validate_response(n_iter, n_trials) - - metrics = pd.DataFrame(columns=('cell_index','dir','tf','prefsize','osi','dsi','dir_percent', - 'peak_mean','peak_std','blank_mean','blank_std', - 'peak_percent_trials'), index=cell_index) + response_first, response_second = self.cross_validate_response( + n_iter, n_trials + ) + + metrics = pd.DataFrame( + columns=( + 'cell_index', + 'dir', + 'tf', + 'prefsize', + 'osi', + 'dsi', + 'dir_percent', + 'peak_mean', + 'peak_std', + 'blank_mean', + 'blank_std', + 'peak_percent_trials', + ), + index=cell_index, + ) metrics.cell_index = cell_index - #cross-validated metrics + # cross-validated metrics DSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) OSI = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) DIR = pd.DataFrame(columns=cell_index.astype(str), index=range(n_iter)) for ni in range(n_iter): - #find pref direction for each cell for center only condition -# response_first = response_first[:,:,:,cell_index,:] -# response_second = response_second[:,:,:,cell_index,:] - sort = np.where(response_first[:,:,:,:,ni]==np.nanmax(response_first[:,:,:,:,ni], axis=(0,1,2))) - #TODO: this is where the TF is going to add issues... + # find pref direction for each cell for center only condition + # response_first = response_first[:,:,:,cell_index,:] + # response_second = response_second[:,:,:,cell_index,:] + sort = np.where( + response_first[:, :, :, :, ni] + == np.nanmax(response_first[:, :, :, :, ni], axis=(0, 1, 2)) + ) + # TODO: this is where the TF is going to add issues... sortind = np.argsort(sort[3]) pref_ori = sort[0][sortind] -# print(len(pref_ori)) + # print(len(pref_ori)) pref_tf = sort[1][sortind] pref_size = sort[2][sortind] cell_index = sort[3][sortind] - inds = np.vstack((pref_ori, pref_tf, pref_size,cell_index)) + inds = np.vstack((pref_ori, pref_tf, pref_size, cell_index)) DIR.loc[ni] = pref_ori - #osi - OSI.loc[ni] = self.get_osi(response_second[:, inds[1], inds[2], inds[3], ni]) + # osi + OSI.loc[ni] = self.get_osi( + response_second[:, inds[1], inds[2], inds[3], ni] + ) - #dsi - null_ori= np.mod(pref_ori+4, 8) + # dsi + null_ori = np.mod(pref_ori + 4, 8) pref = response_second[inds[0], inds[1], inds[2], inds[3], ni] - null = response_second[null_ori, inds[1], inds[2], inds[3], ni] - null = np.where(null>0, null, 0) - DSI.loc[ni] = (pref-null)/(pref+null) + null = response_second[null_ori, inds[1], inds[2], inds[3], ni] + null = np.where(null > 0, null, 0) + DSI.loc[ni] = (pref - null) / (pref + null) metrics['osi'] = OSI.mean().values metrics['dsi'] = DSI.mean().values - #how consistent is the selected preferred direction? + # how consistent is the selected preferred direction? for nc in range(self.numbercells): metrics['dir_percent'].loc[nc] = DIR[str(nc)].value_counts().max() - #non cross-validated metrics + # non cross-validated metrics cell_index = np.array(range(self.numbercells)) - sort = np.where(self.response[:,:,:,cell_index,0] == np.nanmax(self.response[:,:,:,cell_index,0], axis=(0,1,2))) + sort = np.where( + self.response[:, :, :, cell_index, 0] + == np.nanmax(self.response[:, :, :, cell_index, 0], axis=(0, 1, 2)) + ) sortind = np.argsort(sort[3]) pref_ori = sort[0][sortind] pref_tf = sort[1][sortind] @@ -277,23 +373,29 @@ def get_metrics(self): metrics['dir'] = pref_ori metrics['tf'] = pref_tf metrics['prefsize'] = pref_size - metrics['peak_mean'] = self.response[pref_ori,pref_tf,pref_size,cell_index,0] - metrics['peak_std'] = self.response[pref_ori,pref_tf,pref_size,cell_index,1] - metrics['peak_percent_trials'] = self.response[pref_ori, pref_tf,pref_size,cell_index,3] - metrics['blank_mean'] = self.response[0,0,0,cell_index,0] - metrics['blank_std'] = self.response[0,0,0,cell_index,1] + metrics['peak_mean'] = self.response[ + pref_ori, pref_tf, pref_size, cell_index, 0 + ] + metrics['peak_std'] = self.response[ + pref_ori, pref_tf, pref_size, cell_index, 1 + ] + metrics['peak_percent_trials'] = self.response[ + pref_ori, pref_tf, pref_size, cell_index, 3 + ] + metrics['blank_mean'] = self.response[0, 0, 0, cell_index, 0] + metrics['blank_std'] = self.response[0, 0, 0, cell_index, 1] b = set(metrics.index) a = set(range(self.numbercells)) toadd = a.difference(b) - if len(toadd)>0: + if len(toadd) > 0: newdf = pd.DataFrame(columns=metrics.columns, index=toadd) newdf.cell_index = toadd newdf.valid = False metrics = metrics.append(newdf) metrics.sort_index(inplace=True) - metrics = metrics.join(self.roi[['cell_id','session_id','valid']]) + metrics = metrics.join(self.roi[['cell_id', 'session_id', 'valid']]) metrics['cre'] = self.cre metrics['area'] = self.area metrics['depth'] = self.depth @@ -302,7 +404,10 @@ def get_metrics(self): def save_data(self): '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf', str(self.session_id)+"_st_analysis.h5") + save_file = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/analysis/tf', + str(self.session_id) + "_st_analysis.h5", + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response @@ -317,30 +422,42 @@ def save_data(self): f.close() -if __name__=='__main__': -# expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_976843461_data.h5' -# eye_thresh = 10 -# cre = 'test' -# area = 'area test' -# depth = '33' -# szt = SizeTuning(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) +if __name__ == '__main__': + # expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_976843461_data.h5' + # eye_thresh = 10 + # cre = 'test' + # area = 'area test' + # depth = '33' + # szt = SizeTuning(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - manifest = pd.read_csv(r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv') - subset = manifest[manifest.Target=='soma'] + manifest = pd.read_csv( + r'/Users/saskiad/Dropbox/Openscope Multiplex/data manifest.csv' + ) + subset = manifest[manifest.Target == 'soma'] print(len(subset)) count = 0 failed = [] for index, row in subset.iterrows(): if np.isfinite(row.Size_Tuning_Expt_ID): - count+=1 + count += 1 cre = row.Cre area = row.Area depth = row.Depth - expt_path = r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_'+str(int(row.Size_Tuning_Expt_ID))+'_data.h5' + expt_path = ( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex_trim/Size_Tuning_' + + str(int(row.Size_Tuning_Expt_ID)) + + '_data.h5' + ) eye_thresh = 10 try: - szt = SizeTuning(expt_path=expt_path, eye_thresh=eye_thresh, cre=cre, area=area, depth=depth) - if count==1: + szt = SizeTuning( + expt_path=expt_path, + eye_thresh=eye_thresh, + cre=cre, + area=area, + depth=depth, + ) + if count == 1: metrics_all = szt.metrics.copy() print("reached here") else: @@ -348,5 +465,3 @@ def save_data(self): except: print(expt_path + " FAILED") failed.append(int(row.Size_Tuning_Expt_ID)) - - diff --git a/analysis/stim_table.py b/analysis/stim_table.py index a98deae..d329ef7 100644 --- a/analysis/stim_table.py +++ b/analysis/stim_table.py @@ -18,9 +18,14 @@ # Generic interface for creating stim tables. PREFERRED. def create_stim_tables( exptpath, - stimulus_names = ['locally_sparse_noise', - 'center_surround', 'drifting_gratings_grid', 'drifting_gratings_size'], - verbose = True): + stimulus_names=[ + 'locally_sparse_noise', + 'center_surround', + 'drifting_gratings_grid', + 'drifting_gratings_size', + ], + verbose=True, +): """Create a stim table from data located in folder exptpath. Tries to extract a stim_table for each stim type in stimulus_names and @@ -40,14 +45,14 @@ def create_stim_tables( """ data = load_stim(exptpath) -# twop_frames, _, _, _ = load_sync(exptpath) + # twop_frames, _, _, _ = load_sync(exptpath) twop_frames = load_alignment(exptpath) stim_table_funcs = { 'locally_sparse_noise': locally_sparse_noise_table, 'center_surround': center_surround_table, 'drifting_gratings_grid': DGgrid_table, - 'drifting_gratings_size': DGsize_table + 'drifting_gratings_size': DGsize_table, } stim_table = {} for stim_name in stimulus_names: @@ -57,11 +62,13 @@ def create_stim_tables( ) except KeyError: if verbose: - print(( - 'Could not locate stimulus type {} in {}'.format( - stim_name, exptpath + print( + ( + 'Could not locate stimulus type {} in {}'.format( + stim_name, exptpath + ) ) - )) + ) continue return stim_table @@ -113,7 +120,7 @@ def lsnCS_create_stim_table(exptpath): return stim_table -def DGgrid_table(data, twop_frames, verbose = True): +def DGgrid_table(data, twop_frames, verbose=True): DG_idx = get_stimulus_index(data, 'drifting_gratings_grid_5.stim') @@ -122,26 +129,31 @@ def DGgrid_table(data, twop_frames, verbose = True): ) if verbose: - print('Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - )) + print( + 'Found {} of {} expected sweeps.'.format( + actual_sweeps, expected_sweeps + ) + ) stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') + np.column_stack( + ( + twop_frames[timing_table['start']], + twop_frames[timing_table['end']], + ) + ), + columns=('Start', 'End'), ) for attribute in ['TF', 'SF', 'Contrast', 'Ori', 'PosX', 'PosY']: - stim_table[attribute] = get_attribute_by_sweep( - data, DG_idx, attribute - )[:len(stim_table)] + stim_table[attribute] = get_attribute_by_sweep(data, DG_idx, attribute)[ + : len(stim_table) + ] return stim_table -def DGsize_table(data, twop_frames, verbose = True): + +def DGsize_table(data, twop_frames, verbose=True): DGs_idx = get_stimulus_index(data, 'drifting_gratings_size.stim') @@ -150,22 +162,26 @@ def DGsize_table(data, twop_frames, verbose = True): ) if verbose: - print('Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - )) + print( + 'Found {} of {} expected sweeps.'.format( + actual_sweeps, expected_sweeps + ) + ) stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') + np.column_stack( + ( + twop_frames[timing_table['start']], + twop_frames[timing_table['end']], + ) + ), + columns=('Start', 'End'), ) for attribute in ['TF', 'SF', 'Contrast', 'Ori', 'Size']: stim_table[attribute] = get_attribute_by_sweep( data, DGs_idx, attribute - )[:len(stim_table)] + )[: len(stim_table)] x_corr, y_corr = get_center_coordinates(data, DGs_idx) stim_table['Center_x'] = x_corr @@ -174,7 +190,7 @@ def DGsize_table(data, twop_frames, verbose = True): return stim_table -def locally_sparse_noise_table(data, twop_frames, verbose = True): +def locally_sparse_noise_table(data, twop_frames, verbose=True): """Return stim table for locally sparse noise stimulus. """ @@ -184,26 +200,30 @@ def locally_sparse_noise_table(data, twop_frames, verbose = True): data, lsn_idx ) if verbose: - print('Found {} of {} expected sweeps.'.format( - actual_sweeps, expected_sweeps - )) + print( + 'Found {} of {} expected sweeps.'.format( + actual_sweeps, expected_sweeps + ) + ) stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') + np.column_stack( + ( + twop_frames[timing_table['start']], + twop_frames[timing_table['end']], + ) + ), + columns=('Start', 'End'), ) stim_table['Frame'] = np.array( - data['stimuli'][lsn_idx]['sweep_order'][:len(stim_table)] + data['stimuli'][lsn_idx]['sweep_order'][: len(stim_table)] ) return stim_table -def center_surround_table(data, twop_frames, verbose = True): +def center_surround_table(data, twop_frames, verbose=True): center_idx = get_stimulus_index(data, 'center') surround_idx = get_stimulus_index(data, 'surround') @@ -212,16 +232,20 @@ def center_surround_table(data, twop_frames, verbose = True): data, center_idx ) if verbose: - print('Found {} of {} expected sweeps'.format( - actual_sweeps, expected_sweeps - )) + print( + 'Found {} of {} expected sweeps'.format( + actual_sweeps, expected_sweeps + ) + ) stim_table = pd.DataFrame( - np.column_stack(( - twop_frames[timing_table['start']], - twop_frames[timing_table['end']] - )), - columns=('Start', 'End') + np.column_stack( + ( + twop_frames[timing_table['start']], + twop_frames[timing_table['end']], + ) + ), + columns=('Start', 'End'), ) x_corr, y_corr = get_center_coordinates(data, center_idx) @@ -232,13 +256,13 @@ def center_surround_table(data, twop_frames, verbose = True): for attribute in ['TF', 'SF', 'Contrast']: stim_table[attribute] = get_attribute_by_sweep( data, center_idx, attribute - )[:len(stim_table)] - stim_table['Center_Ori'] = get_attribute_by_sweep( - data, center_idx, 'Ori' - )[:len(stim_table)] + )[: len(stim_table)] + stim_table['Center_Ori'] = get_attribute_by_sweep(data, center_idx, 'Ori')[ + : len(stim_table) + ] stim_table['Surround_Ori'] = get_attribute_by_sweep( data, surround_idx, 'Ori' - )[:len(stim_table)] + )[: len(stim_table)] return stim_table @@ -281,23 +305,22 @@ def get_sweep_frames(data, stimulus_idx): sweep_frames = data['stimuli'][stimulus_idx]['sweep_frames'] timing_table = pd.DataFrame( - np.array(sweep_frames).astype(np.int), - columns=('start', 'end') + np.array(sweep_frames).astype(np.int), columns=('start', 'end') ) - timing_table['dif'] = timing_table['end']-timing_table['start'] + timing_table['dif'] = timing_table['end'] - timing_table['start'] display_sequence = get_display_sequence(data, stimulus_idx) timing_table.start += display_sequence[0, 0] - for seg in range(len(display_sequence)-1): + for seg in range(len(display_sequence) - 1): for index, row in timing_table.iterrows(): if row.start >= display_sequence[seg, 1]: timing_table.start[index] = ( timing_table.start[index] - display_sequence[seg, 1] - + display_sequence[seg+1, 0] + + display_sequence[seg + 1, 0] ) - timing_table.end = timing_table.start+timing_table.dif + timing_table.end = timing_table.start + timing_table.dif expected_sweeps = len(timing_table) timing_table = timing_table[timing_table.end <= display_sequence[-1, 1]] timing_table = timing_table[timing_table.start <= display_sequence[-1, 1]] @@ -324,9 +347,13 @@ def get_attribute_by_sweep(data, stimulus_idx, attribute): if condition >= 0: # blank sweep is -1 try: - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx] + attribute_by_sweep[sweeps_with_condition] = sweep_table[ + condition + ][attribute_idx] except: - attribute_by_sweep[sweeps_with_condition] = sweep_table[condition][attribute_idx][0] + attribute_by_sweep[sweeps_with_condition] = sweep_table[ + condition + ][attribute_idx][0] return attribute_by_sweep @@ -342,12 +369,14 @@ def get_attribute_idx(data, stimulus_idx, attribute): if attribute_str == attribute: return attribute_idx - raise KeyError('Attribute {} for stimulus_ids {} not found!'.format( + raise KeyError( + 'Attribute {} for stimulus_ids {} not found!'.format( attribute, stimulus_idx - )) + ) + ) -def load_stim(exptpath, verbose = True): +def load_stim(exptpath, verbose=True): """Load stim.pkl file into a DataFrame. Inputs: @@ -377,6 +406,7 @@ def load_stim(exptpath, verbose = True): return pd.read_pickle(pklpath) + def load_alignment(exptpath): for f in os.listdir(exptpath): if f.startswith('ophys_experiment'): @@ -390,9 +420,9 @@ def load_alignment(exptpath): return twop_frames -def load_sync(exptpath, verbose = True): +def load_sync(exptpath, verbose=True): - #verify that sync file exists in exptpath + # verify that sync file exists in exptpath syncpath = None for f in os.listdir(exptpath): if f.endswith('_sync.h5'): @@ -406,23 +436,25 @@ def load_sync(exptpath, verbose = True): ) ) - #load the sync data from .h5 and .pkl files + # load the sync data from .h5 and .pkl files d = Dataset(syncpath) - #print d.line_labels + # print d.line_labels - #set the appropriate sample frequency + # set the appropriate sample frequency sample_freq = d.meta_data['ni_daq']['counter_output_freq'] - #get sync timing for each channel - twop_vsync_fall = d.get_falling_edges('2p_vsync')/sample_freq - stim_vsync_fall = d.get_falling_edges('stim_vsync')[1:]/sample_freq #eliminating the DAQ pulse - photodiode_rise = d.get_rising_edges('stim_photodiode')/sample_freq + # get sync timing for each channel + twop_vsync_fall = d.get_falling_edges('2p_vsync') / sample_freq + stim_vsync_fall = ( + d.get_falling_edges('stim_vsync')[1:] / sample_freq + ) # eliminating the DAQ pulse + photodiode_rise = d.get_rising_edges('stim_photodiode') / sample_freq - #make sure all of the sync data are available + # make sure all of the sync data are available channels = { 'twop_vsync_fall': twop_vsync_fall, 'stim_vsync_fall': stim_vsync_fall, - 'photodiode_rise': photodiode_rise + 'photodiode_rise': photodiode_rise, } channel_test = [] for chan in list(channels.keys()): @@ -433,14 +465,18 @@ def load_sync(exptpath, verbose = True): elif verbose: print("All channels present.") - #test and correct for photodiode transition errors + # test and correct for photodiode transition errors ptd_rise_diff = np.ediff1d(photodiode_rise) - short = np.where(np.logical_and(ptd_rise_diff > 0.1, ptd_rise_diff < 0.3))[0] - medium = np.where(np.logical_and(ptd_rise_diff > 0.5, ptd_rise_diff < 1.5))[0] + short = np.where(np.logical_and(ptd_rise_diff > 0.1, ptd_rise_diff < 0.3))[ + 0 + ] + medium = np.where(np.logical_and(ptd_rise_diff > 0.5, ptd_rise_diff < 1.5))[ + 0 + ] ptd_start = 3 for i in medium: - if set(range(i-2, i)) <= set(short): - ptd_start = i+1 + if set(range(i - 2, i)) <= set(short): + ptd_start = i + 1 ptd_end = np.where(photodiode_rise > stim_vsync_fall.max())[0][0] - 1 if ptd_start > 3 and verbose: @@ -449,7 +485,9 @@ def load_sync(exptpath, verbose = True): ptd_errors = [] while any(ptd_rise_diff[ptd_start:ptd_end] < 1.8): - error_frames = np.where(ptd_rise_diff[ptd_start:ptd_end] < 1.8)[0] + ptd_start + error_frames = ( + np.where(ptd_rise_diff[ptd_start:ptd_end] < 1.8)[0] + ptd_start + ) print("Photodiode error detected. Number of frames:", len(error_frames)) photodiode_rise = np.delete(photodiode_rise, error_frames[-1]) ptd_errors.append(photodiode_rise[error_frames[-1]]) @@ -460,36 +498,39 @@ def load_sync(exptpath, verbose = True): stim_on_photodiode_idx = 60 + 120 * np.arange(0, ptd_end - ptd_start, 1) stim_on_photodiode = stim_vsync_fall[stim_on_photodiode_idx] - photodiode_on = photodiode_rise[first_pulse + np.arange(0, ptd_end - ptd_start, 1)] + photodiode_on = photodiode_rise[ + first_pulse + np.arange(0, ptd_end - ptd_start, 1) + ] delay_rise = photodiode_on - stim_on_photodiode delay = np.mean(delay_rise[:-1]) if verbose: print("monitor delay: ", delay) - #adjust stimulus time to incorporate monitor delay + # adjust stimulus time to incorporate monitor delay stim_time = stim_vsync_fall + delay - #convert stimulus frames into twop frames + # convert stimulus frames into twop frames twop_frames = np.empty((len(stim_time), 1)) for i in range(len(stim_time)): # crossings = np.nonzero(np.ediff1d(np.sign(twop_vsync_fall - stim_time[i]))>0) - crossings = np.searchsorted(twop_vsync_fall, stim_time[i], side='left') - 1 - if crossings < (len(twop_vsync_fall)-1): + crossings = ( + np.searchsorted(twop_vsync_fall, stim_time[i], side='left') - 1 + ) + if crossings < (len(twop_vsync_fall) - 1): twop_frames[i] = crossings else: - twop_frames[i:len(stim_time)] = np.NaN - warnings.warn( - 'Acquisition ends before stimulus.', RuntimeWarning - ) + twop_frames[i : len(stim_time)] = np.NaN + warnings.warn('Acquisition ends before stimulus.', RuntimeWarning) break return twop_frames, twop_vsync_fall, stim_vsync_fall, photodiode_rise + def get_center_coordinates(data, idx): -# center_idx = get_stimulus_index(data,'center') -# stim_definition = data['stimuli'][center_idx]['stim'] + # center_idx = get_stimulus_index(data,'center') + # stim_definition = data['stimuli'][center_idx]['stim'] stim_definition = data['stimuli'][idx]['stim'] position_idx = stim_definition.find('pos=array(') @@ -498,7 +539,7 @@ def get_center_coordinates(data, idx): comma_idx = position_idx + stim_definition[position_idx:].find(',') x_coor = float(stim_definition[coor_start:comma_idx]) - y_coor = float(stim_definition[(comma_idx+1):coor_end]) + y_coor = float(stim_definition[(comma_idx + 1) : coor_end]) return x_coor, y_coor @@ -509,22 +550,28 @@ def print_summary(stim_table): Print column names, number of 'unique' conditions per column (treating nans as equal), and average number of samples per condition. """ - print(( - '{:<20}{:>15}{:>15}\n'.format('Colname', 'No. conditions', 'Mean N/cond') - )) + print( + ( + '{:<20}{:>15}{:>15}\n'.format( + 'Colname', 'No. conditions', 'Mean N/cond' + ) + ) + ) for colname in stim_table.columns: conditions, occurrences = np.unique( - np.nan_to_num(stim_table[colname]), return_counts = True + np.nan_to_num(stim_table[colname]), return_counts=True ) - print(( - '{:<20}{:>15}{:>15.1f}'.format( - colname, len(conditions), np.mean(occurrences) + print( + ( + '{:<20}{:>15}{:>15.1f}'.format( + colname, len(conditions), np.mean(occurrences) + ) ) - )) + ) if __name__ == '__main__': -# exptpath = r'\\allen\programs\braintv\production\neuralcoding\prod55\specimen_859061987\ophys_session_882666374\\' + # exptpath = r'\\allen\programs\braintv\production\neuralcoding\prod55\specimen_859061987\ophys_session_882666374\\' exptpath = r'/Volumes/New Volume/994901365' stim_table = create_stim_tables(exptpath) # stim_table = lsnCS_create_stim_table(exptpath) diff --git a/oscopetools/locally_sparse_noise.py b/oscopetools/locally_sparse_noise.py index 5c349cd..afc3500 100644 --- a/oscopetools/locally_sparse_noise.py +++ b/oscopetools/locally_sparse_noise.py @@ -11,45 +11,56 @@ import os, h5py import matplotlib.pyplot as plt + def do_sweep_mean(x): return x[28:35].mean() + def do_sweep_mean_shifted(x): return x[30:40].mean() + def do_eye(x): return x[28:32].mean() + class LocallySparseNoise: def __init__(self, expt_path): self.expt_path = expt_path self.session_id = self.expt_path.split('/')[-1].split('_')[-2] - #load dff traces + # load dff traces f = h5py.File(self.expt_path, 'r') self.dff = f['dff_traces'][()] f.close() self.numbercells = self.dff.shape[0] - #create stimulus table for locally sparse noise + # create stimulus table for locally sparse noise self.stim_table = pd.read_hdf(self.expt_path, 'locally_sparse_noise') - #load stimulus template + # load stimulus template self.LSN = np.load(lsn_path) - #load eyetracking + # load eyetracking self.pupil_pos = pd.read_hdf(self.expt_path, 'eye_tracking') - #run analysis - self.sweep_response, self.mean_sweep_response, self.response_on, self.response_off, self.sweep_eye, self.mean_sweep_eye = self.get_stimulus_response(self.LSN) + # run analysis + ( + self.sweep_response, + self.mean_sweep_response, + self.response_on, + self.response_off, + self.sweep_eye, + self.mean_sweep_eye, + ) = self.get_stimulus_response(self.LSN) self.peak = self.get_peak() - #save outputs -# self.save_data() + # save outputs + # self.save_data() - #plot traces + # plot traces self.plot_LSN_Traces() def get_stimulus_response(self, LSN): @@ -65,36 +76,61 @@ def get_stimulus_response(self, LSN): ''' - sweep_response = pd.DataFrame(index=self.stim_table.index.values, columns=np.array(list(range(self.numbercells))).astype(str)) + sweep_response = pd.DataFrame( + index=self.stim_table.index.values, + columns=np.array(list(range(self.numbercells))).astype(str), + ) - sweep_eye = pd.DataFrame(index=self.stim_table.index.values, columns=('x_pos_deg','y_pos_deg')) + sweep_eye = pd.DataFrame( + index=self.stim_table.index.values, + columns=('x_pos_deg', 'y_pos_deg'), + ) - for index,row in self.stim_table.iterrows(): + for index, row in self.stim_table.iterrows(): for nc in range(self.numbercells): - sweep_response[str(nc)][index] = self.dff[nc, int(row.Start)-28:int(row.Start)+35] - sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[int(row.Start)-28:int(row.Start+35)].values - sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[int(row.Start)-28:int(row.Start+35)].values + sweep_response[str(nc)][index] = self.dff[ + nc, int(row.Start) - 28 : int(row.Start) + 35 + ] + sweep_eye.x_pos_deg[index] = self.pupil_pos.x_pos_deg[ + int(row.Start) - 28 : int(row.Start + 35) + ].values + sweep_eye.y_pos_deg[index] = self.pupil_pos.y_pos_deg[ + int(row.Start) - 28 : int(row.Start + 35) + ].values mean_sweep_response = sweep_response.applymap(do_sweep_mean_shifted) mean_sweep_eye = sweep_eye.applymap(do_eye) - - x_shape = LSN.shape[1] y_shape = LSN.shape[2] response_on = np.empty((x_shape, y_shape, self.numbercells, 2)) response_off = np.empty((x_shape, y_shape, self.numbercells, 2)) for xp in range(x_shape): for yp in range(y_shape): - on_frame = np.where(LSN[:,xp,yp]==255)[0] - off_frame = np.where(LSN[:,xp,yp]==0)[0] - subset_on = mean_sweep_response[self.stim_table.Frame.isin(on_frame)] - subset_off = mean_sweep_response[self.stim_table.Frame.isin(off_frame)] - response_on[xp,yp,:,0] = subset_on.mean(axis=0) - response_on[xp,yp,:,1] = subset_on.std(axis=0)/np.sqrt(len(subset_on)) - response_off[xp,yp,:,0] = subset_off.mean(axis=0) - response_off[xp,yp,:,1] = subset_off.std(axis=0)/np.sqrt(len(subset_off)) - return sweep_response, mean_sweep_response, response_on, response_off, sweep_eye, mean_sweep_eye + on_frame = np.where(LSN[:, xp, yp] == 255)[0] + off_frame = np.where(LSN[:, xp, yp] == 0)[0] + subset_on = mean_sweep_response[ + self.stim_table.Frame.isin(on_frame) + ] + subset_off = mean_sweep_response[ + self.stim_table.Frame.isin(off_frame) + ] + response_on[xp, yp, :, 0] = subset_on.mean(axis=0) + response_on[xp, yp, :, 1] = subset_on.std(axis=0) / np.sqrt( + len(subset_on) + ) + response_off[xp, yp, :, 0] = subset_off.mean(axis=0) + response_off[xp, yp, :, 1] = subset_off.std(axis=0) / np.sqrt( + len(subset_off) + ) + return ( + sweep_response, + mean_sweep_response, + response_on, + response_off, + sweep_eye, + mean_sweep_eye, + ) def get_peak(self): '''creates a table of metrics for each cell. We can make this more useful in the future @@ -103,18 +139,23 @@ def get_peak(self): ------- peak dataframe ''' - peak = pd.DataFrame(columns=('rf_on','rf_off'), index=list(range(self.numbercells))) + peak = pd.DataFrame( + columns=('rf_on', 'rf_off'), index=list(range(self.numbercells)) + ) peak['rf_on'] = False peak['rf_off'] = False - on_rfs = np.where(self.response_on[:,:,:,2]>0.25)[2] - off_rfs = np.where(self.response_off[:,:,:,2]>0.25)[2] + on_rfs = np.where(self.response_on[:, :, :, 2] > 0.25)[2] + off_rfs = np.where(self.response_off[:, :, :, 2] > 0.25)[2] peak.rf_on.loc[on_rfs] = True peak.rf_off.loc[off_rfs] = True return peak def save_data(self): '''saves intermediate analysis files in an h5 file''' - save_file = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', str(self.session_id)+"_lsn_analysis.h5") + save_file = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', + str(self.session_id) + "_lsn_analysis.h5", + ) print("Saving data to: ", save_file) store = pd.HDFStore(save_file) store['sweep_response'] = self.sweep_response @@ -132,43 +173,64 @@ def plot_LSN_Traces(self): print("Plotting LSN traces for all cells") for nc in range(self.numbercells): - if np.mod(nc,100)==0: + if np.mod(nc, 100) == 0: print("Cell #", str(nc)) - plt.figure(nc, figsize=(24,20)) - vmax=0 - vmin=0 + plt.figure(nc, figsize=(24, 20)) + vmax = 0 + vmin = 0 one_cell = self.sweep_response[str(nc)] for yp in range(8): for xp in range(14): - sp_pt = (yp*14)+xp+1 - on_frame = np.where(self.LSN[:,yp,xp]==255)[0] - off_frame = np.where(self.LSN[:,yp,xp]==0)[0] + sp_pt = (yp * 14) + xp + 1 + on_frame = np.where(self.LSN[:, yp, xp] == 255)[0] + off_frame = np.where(self.LSN[:, yp, xp] == 0)[0] subset_on = one_cell[self.stim_table.Frame.isin(on_frame)] subset_off = one_cell[self.stim_table.Frame.isin(off_frame)] - ax = plt.subplot(8,14,sp_pt) + ax = plt.subplot(8, 14, sp_pt) ax.plot(subset_on.mean(), color='r', lw=2) ax.plot(subset_off.mean(), color='b', lw=2) - ax.axvspan(28,35 ,ymin=0, ymax=1, facecolor='gray', alpha=0.3) - vmax = np.where(np.amax(subset_on.mean())>vmax, np.amax(subset_on.mean()), vmax) - vmax = np.where(np.amax(subset_off.mean())>vmax, np.amax(subset_off.mean()), vmax) - vmin = np.where(np.amin(subset_on.mean()) vmax, + np.amax(subset_on.mean()), + vmax, + ) + vmax = np.where( + np.amax(subset_off.mean()) > vmax, + np.amax(subset_off.mean()), + vmax, + ) + vmin = np.where( + np.amin(subset_on.mean()) < vmin, + np.amin(subset_on.mean()), + vmin, + ) + vmin = np.where( + np.amin(subset_off.mean()) < vmin, + np.amin(subset_off.mean()), + vmin, + ) ax.set_xticks([]) ax.set_yticks([]) - for i in range(1,sp_pt+1): - ax = plt.subplot(8,14,i) + for i in range(1, sp_pt + 1): + ax = plt.subplot(8, 14, i) ax.set_ylim(vmin, vmax) plt.tight_layout() - plt.suptitle("Cell " + str(nc+1), fontsize=20) + plt.suptitle("Cell " + str(nc + 1), fontsize=20) plt.subplots_adjust(top=0.9) - filename = 'Traces LSN Cell_'+str(nc+1)+'.png' - fullfilename = os.path.join(r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', filename) + filename = 'Traces LSN Cell_' + str(nc + 1) + '.png' + fullfilename = os.path.join( + r'/Users/saskiad/Documents/Data/Openscope_Multiplex/analysis', + filename, + ) plt.savefig(fullfilename) plt.close() -if __name__=='__main__': - lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' #update this to local path the the stimulus array +if __name__ == '__main__': + lsn_path = r'/Users/saskiad/Code/openscope_surround/stimulus/sparse_noise_8x14.npy' # update this to local path the the stimulus array expt_path = r'/Users/saskiad/Dropbox/Openscope Multiplex/Center Surround/Center_Surround_1010436210_data.h5' - lsn = LocallySparseNoise(expt_path=expt_path) \ No newline at end of file + lsn = LocallySparseNoise(expt_path=expt_path) From eb26c5c50e47ad22f3009a3ac298898cb4f3b9c5 Mon Sep 17 00:00:00 2001 From: Emerson Harkin Date: Wed, 16 Jun 2021 15:50:33 -0400 Subject: [PATCH 68/68] Remove duplicate get_eye_tracking.py analysis/get_eye_tracking.py and oscopetools/get_eye_tracking.py are identical. This commit removes the analysis version and adjusts the only place it is imported (analysis/get_all_data.py) accordingly. --- analysis/get_all_data.py | 2 +- analysis/get_eye_tracking.py | 54 ------------------------------------ 2 files changed, 1 insertion(+), 55 deletions(-) delete mode 100644 analysis/get_eye_tracking.py diff --git a/analysis/get_all_data.py b/analysis/get_all_data.py index 5df234c..a3cda31 100644 --- a/analysis/get_all_data.py +++ b/analysis/get_all_data.py @@ -13,7 +13,7 @@ from PIL import Image from stim_table import create_stim_tables, get_center_coordinates from RunningData import get_running_data -from get_eye_tracking import align_eye_tracking +from oscopetools.get_eye_tracking import align_eye_tracking def get_all_data(path_name, save_path, expt_name, row): diff --git a/analysis/get_eye_tracking.py b/analysis/get_eye_tracking.py deleted file mode 100644 index 6da346f..0000000 --- a/analysis/get_eye_tracking.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Mon Jun 8 16:28:23 2020 - -@author: saskiad -""" -import pandas as pd -import numpy as np -import h5py - - -def align_eye_tracking(dlc_file, temporal_alignment_file): - pupil_area = pd.read_hdf(dlc_file, 'raw_pupil_areas').values - eye_area = pd.read_hdf(dlc_file, 'raw_eye_areas').values - pos = pd.read_hdf(dlc_file, 'raw_screen_coordinates_spherical') - - ##temporal alignment - f = h5py.File(temporal_alignment_file, 'r') - eye_frames = f['eye_tracking_alignment'][()] - f.close() - eye_frames = eye_frames.astype(int) - eye_frames = eye_frames[np.where(eye_frames > 0)] - - eye_area_sync = eye_area[eye_frames] - pupil_area_sync = pupil_area[eye_frames] - x_pos_sync = pos.x_pos_deg.values[eye_frames] - y_pos_sync = pos.y_pos_deg.values[eye_frames] - - ##correcting dropped camera frames - test = eye_frames[np.isfinite(eye_frames)] - test = test.astype(int) - temp2 = np.bincount(test) - dropped_camera_frames = np.where(temp2 > 2)[0] - for a in dropped_camera_frames: - null_2p_frames = np.where(eye_frames == a)[0] - eye_area_sync[null_2p_frames] = np.NaN - pupil_area_sync[null_2p_frames] = np.NaN - x_pos_sync[null_2p_frames] = np.NaN - y_pos_sync[null_2p_frames] = np.NaN - - eye_sync = pd.DataFrame( - data=np.vstack( - (eye_area_sync, pupil_area_sync, x_pos_sync, y_pos_sync) - ).T, - columns=('eye_area', 'pupil_area', 'x_pos_deg', 'y_pos_deg'), - ) - return eye_sync - - -if __name__ == '__main__': - dlc_file = r'/Volumes/New Volume/1010368135/eye_tracking/1010368135_eyetracking_dlc_to_screen_mapping.h5' - temporal_alignment_file = r'/Volumes/New Volume/1010368135/ophys_experiment_1010535819/1010535819_time_synchronization.h5' - eye_sync = (dlc_file, temporal_alignment_file)