From d9638f56cfeadd1ae5f83b9485058d99bb0b197a Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Mon, 15 Jul 2024 15:21:42 -0400 Subject: [PATCH 01/14] added blink removal method --- .../pipelines/eeg_preprocessing_pipeline.py | 15 ++- .../preprocessing/tools/blinks_remover.py | 115 ++++++++++++++++++ 2 files changed, 129 insertions(+), 1 deletion(-) create mode 100644 src/eeg_research/preprocessing/tools/blinks_remover.py diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index b248d4b..316268c 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -41,7 +41,7 @@ import pandas as pd import pyprep as prep -from eeg_research.preprocessing.tools import utils +from eeg_research.preprocessing.tools import utils, blinks_remover ParamType = ParamSpec('ParamType') ReturnType = TypeVar('ReturnType') @@ -161,6 +161,19 @@ def set_montage(self, self.raw.set_montage(self.montage) return self + def remove_blinks(self) -> "EEGpreprocessing": + """remove blinks from the EEG signal by using SSP projector. + + Returns: + EEGpreprocessing instance + """ + if self.set_montage.has_been_called: # type: ignore[attr-defined] + remover = blinks_remover.BlinksRemover(self.raw) + remover.remove_blinks() + self.raw = remover.blink_removed_raw + + return self + def run_prep(self) -> "EEGpreprocessing": """Run the pyprep pipeline on the raw object. diff --git a/src/eeg_research/preprocessing/tools/blinks_remover.py b/src/eeg_research/preprocessing/tools/blinks_remover.py new file mode 100644 index 0000000..b81bc21 --- /dev/null +++ b/src/eeg_research/preprocessing/tools/blinks_remover.py @@ -0,0 +1,115 @@ +#!/usr/bin/env -S python # +# -*- coding: utf-8 -*- +# =============================================================================== +# Author: Dr. Samuel Louviot, PhD +# Dr. Alp Erkent, MD, MA +# Institution: Nathan Kline Institute +# Child Mind Institute +# Address: 140 Old Orangeburg Rd, Orangeburg, NY 10962, USA +# 215 E 50th St, New York, NY 10022 +# Date: 2024-02-27 +# email: samuel DOT louviot AT nki DOT rfmh DOT org +# alp DOT erkent AT childmind DOT org +# =============================================================================== +# LICENCE GNU GPLv3: +# Copyright (C) 2024 Dr. Samuel Louviot, PhD +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# =============================================================================== + +"""GENERAL DOCUMENTATION HERE.""" + +import os + +import mne + + +class BlinksRemover: + """Instance for removing blinks from EEG data.""" + + def __init__(self, raw: mne.io.Raw, # noqa: ANN204 + channels: list[str] = ['Fp1', 'Fp2']): + """Initialize BlinksRemover instance. + + Args: + raw (mne.io.Raw): The eeg signal + channels (list[str], optional): The channel name on which to base + the automatic detection. + Defaults to ['Fp1', 'Fp2']. + """ + self.raw = raw + self.channels = channels + + def _find_blinks(self) -> "BlinksRemover": + """Helper for automatically finding blinks using mne functions. + + Returns: + BlinksRemover: _description_ + """ + self.eog_evoked = mne.preprocessing.create_eog_epochs( + self.raw, ch_name = self.channels + ).average() + self.eog_evoked.apply_baseline((None, None)) + return self + + def plot_removal_results(self, + saving_filename: str | os.PathLike + ) ->"BlinksRemover": + """Plot the result after removing the blinks. + + Args: + saving_filename (str | os.PathLike): Where to save the figure + + Returns: + BlinksRemover instance + """ + figure = mne.viz.plot_projs_joint(self.eog_projs, self.eog_evoked) + figure.suptitle("EOG projectors") + if saving_filename: + figure.savefig(saving_filename) + return figure + + def plot_blinks_found(self, + saving_filename: str | os.PathLike + ) ->"BlinksRemover": + """Plot the blink automatically found. + + Args: + saving_filename (str | os.PathLike): Where to save teh figure + + Returns: + BlinksRemover instance + """ + self._find_blinks() + figure = self.eog_evoked.plot_joint(times = 0) + if saving_filename: + figure.savefig(saving_filename) + return figure + + def remove_blinks(self) -> mne.io.Raw: + """Remove the EOG artifacts from the raw data. + + Args: + raw (mne.io.Raw): The raw data from which the EOG artifacts will be removed. + + Returns: + mne.io.Raw: The raw data without the EOG artifacts. + """ + self.eog_projs, _ = mne.preprocessing.compute_proj_eog( + self.raw, + n_eeg=1, + reject=None, + no_proj=True, + ch_name = self.channels + ) + self.blink_removed_raw = self.raw.copy() + self.blink_removed_raw.add_proj(self.eog_projs).apply_proj() + return self \ No newline at end of file From 48cdf8809b58dfb88a115d86c9633a6496a0ceff Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Mon, 15 Jul 2024 15:22:44 -0400 Subject: [PATCH 02/14] Took care of tiny Ruff stuff --- .../preprocessing/pipelines/eeg_preprocessing_pipeline.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index 316268c..20f9fff 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -41,7 +41,7 @@ import pandas as pd import pyprep as prep -from eeg_research.preprocessing.tools import utils, blinks_remover +from eeg_research.preprocessing.tools import blinks_remover, utils ParamType = ParamSpec('ParamType') ReturnType = TypeVar('ReturnType') @@ -162,7 +162,7 @@ def set_montage(self, return self def remove_blinks(self) -> "EEGpreprocessing": - """remove blinks from the EEG signal by using SSP projector. + """Remove blinks from the EEG signal by using SSP projector. Returns: EEGpreprocessing instance From b1914f0da569d98868ef16adb4b9954abd54bbc0 Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Tue, 16 Jul 2024 09:04:27 -0400 Subject: [PATCH 03/14] started changes for muscl annotations --- .../pipelines/eeg_preprocessing_pipeline.py | 14 +++++++ .../preprocessing/tools/muscle_annotator.py | 40 +++++++++++++++++++ 2 files changed, 54 insertions(+) create mode 100644 src/eeg_research/preprocessing/tools/muscle_annotator.py diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index 20f9fff..976e85b 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -96,6 +96,20 @@ def __init__( channels_map = utils.map_channel_type(self.raw) self.raw = utils.set_channel_types(self.raw, channels_map) + def annotate_muscle(self): + """ + muscle_annotations, self.muscle_z_score = mne.preprocessing.annotate_muscle_zscore( + self.raw, + threshold=4, + ch_type='eeg', + min_length_good=0.1, + filter_freq=(110, 140), + n_jobs=None, + verbose=None + ) + self.raw.set_annotations(self.raw.annotations + muscle_annotations) + return self + def set_annotations_to_raw( self, events_filename: str | os.PathLike diff --git a/src/eeg_research/preprocessing/tools/muscle_annotator.py b/src/eeg_research/preprocessing/tools/muscle_annotator.py new file mode 100644 index 0000000..e8b2012 --- /dev/null +++ b/src/eeg_research/preprocessing/tools/muscle_annotator.py @@ -0,0 +1,40 @@ + +#!/usr/bin/env -S python # +# -*- coding: utf-8 -*- +# =============================================================================== +# Author: Dr. Samuel Louviot, PhD +# Dr. Alp Erkent, MD, MA +# Institution: Nathan Kline Institute +# Child Mind Institute +# Address: 140 Old Orangeburg Rd, Orangeburg, NY 10962, USA +# 215 E 50th St, New York, NY 10022 +# Date: 2024-02-27 +# email: samuel DOT louviot AT nki DOT rfmh DOT org +# alp DOT erkent AT childmind DOT org +# =============================================================================== +# LICENCE GNU GPLv3: +# Copyright (C) 2024 Dr. Samuel Louviot, PhD +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# =============================================================================== + +"""GENERAL DOCUMENTATION HERE.""" + +import os + +import mne + + +class MuscleAnnotator: + def __init__(self, raw: mne.io.Raw) -> None: + self.raw = raw + + From 0a6854d91c630c41c279513a4a380ed0044dd8be Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Thu, 18 Jul 2024 13:09:36 -0400 Subject: [PATCH 04/14] Finishing the annotator. A lot of improvement has to be done though --- poetry.lock | 87 +- pyproject.toml | 2 +- .../test_pipeline_blink_and_muscles.ipynb | 2345 +++++++++++++++++ .../tools/artifacts_annotator.py | 428 +++ .../preprocessing/tools/blinks_remover.py | 17 +- .../preprocessing/tools/muscle_annotator.py | 40 - 6 files changed, 2823 insertions(+), 96 deletions(-) create mode 100644 src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb create mode 100644 src/eeg_research/preprocessing/tools/artifacts_annotator.py delete mode 100644 src/eeg_research/preprocessing/tools/muscle_annotator.py diff --git a/poetry.lock b/poetry.lock index 24281b7..1c54882 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. [[package]] name = "appnope" @@ -1355,56 +1355,47 @@ docopt = ">=0.6.2" [[package]] name = "numpy" -version = "2.0.0" +version = "1.26.4" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.9" files = [ - {file = "numpy-2.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:04494f6ec467ccb5369d1808570ae55f6ed9b5809d7f035059000a37b8d7e86f"}, - {file = "numpy-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2635dbd200c2d6faf2ef9a0d04f0ecc6b13b3cad54f7c67c61155138835515d2"}, - {file = "numpy-2.0.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:0a43f0974d501842866cc83471bdb0116ba0dffdbaac33ec05e6afed5b615238"}, - {file = "numpy-2.0.0-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:8d83bb187fb647643bd56e1ae43f273c7f4dbcdf94550d7938cfc32566756514"}, - {file = "numpy-2.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79e843d186c8fb1b102bef3e2bc35ef81160ffef3194646a7fdd6a73c6b97196"}, - {file = "numpy-2.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7696c615765091cc5093f76fd1fa069870304beaccfd58b5dcc69e55ef49c1"}, - {file = "numpy-2.0.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b4c76e3d4c56f145d41b7b6751255feefae92edbc9a61e1758a98204200f30fc"}, - {file = "numpy-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:acd3a644e4807e73b4e1867b769fbf1ce8c5d80e7caaef0d90dcdc640dfc9787"}, - {file = "numpy-2.0.0-cp310-cp310-win32.whl", hash = "sha256:cee6cc0584f71adefe2c908856ccc98702baf95ff80092e4ca46061538a2ba98"}, - {file = "numpy-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:ed08d2703b5972ec736451b818c2eb9da80d66c3e84aed1deeb0c345fefe461b"}, - {file = "numpy-2.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ad0c86f3455fbd0de6c31a3056eb822fc939f81b1618f10ff3406971893b62a5"}, - {file = "numpy-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e7f387600d424f91576af20518334df3d97bc76a300a755f9a8d6e4f5cadd289"}, - {file = "numpy-2.0.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:34f003cb88b1ba38cb9a9a4a3161c1604973d7f9d5552c38bc2f04f829536609"}, - {file = "numpy-2.0.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:b6f6a8f45d0313db07d6d1d37bd0b112f887e1369758a5419c0370ba915b3871"}, - {file = "numpy-2.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f64641b42b2429f56ee08b4f427a4d2daf916ec59686061de751a55aafa22e4"}, - {file = "numpy-2.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7039a136017eaa92c1848152827e1424701532ca8e8967fe480fe1569dae581"}, - {file = "numpy-2.0.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:46e161722e0f619749d1cd892167039015b2c2817296104487cd03ed4a955995"}, - {file = "numpy-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0e50842b2295ba8414c8c1d9d957083d5dfe9e16828b37de883f51fc53c4016f"}, - {file = "numpy-2.0.0-cp311-cp311-win32.whl", hash = "sha256:2ce46fd0b8a0c947ae047d222f7136fc4d55538741373107574271bc00e20e8f"}, - {file = "numpy-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd6acc766814ea6443628f4e6751d0da6593dae29c08c0b2606164db026970c"}, - {file = "numpy-2.0.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:354f373279768fa5a584bac997de6a6c9bc535c482592d7a813bb0c09be6c76f"}, - {file = "numpy-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4d2f62e55a4cd9c58c1d9a1c9edaedcd857a73cb6fda875bf79093f9d9086f85"}, - {file = "numpy-2.0.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:1e72728e7501a450288fc8e1f9ebc73d90cfd4671ebbd631f3e7857c39bd16f2"}, - {file = "numpy-2.0.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:84554fc53daa8f6abf8e8a66e076aff6ece62de68523d9f665f32d2fc50fd66e"}, - {file = "numpy-2.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c73aafd1afca80afecb22718f8700b40ac7cab927b8abab3c3e337d70e10e5a2"}, - {file = "numpy-2.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49d9f7d256fbc804391a7f72d4a617302b1afac1112fac19b6c6cec63fe7fe8a"}, - {file = "numpy-2.0.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0ec84b9ba0654f3b962802edc91424331f423dcf5d5f926676e0150789cb3d95"}, - {file = "numpy-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:feff59f27338135776f6d4e2ec7aeeac5d5f7a08a83e80869121ef8164b74af9"}, - {file = "numpy-2.0.0-cp312-cp312-win32.whl", hash = "sha256:c5a59996dc61835133b56a32ebe4ef3740ea5bc19b3983ac60cc32be5a665d54"}, - {file = "numpy-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:a356364941fb0593bb899a1076b92dfa2029f6f5b8ba88a14fd0984aaf76d0df"}, - {file = "numpy-2.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e61155fae27570692ad1d327e81c6cf27d535a5d7ef97648a17d922224b216de"}, - {file = "numpy-2.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4554eb96f0fd263041baf16cf0881b3f5dafae7a59b1049acb9540c4d57bc8cb"}, - {file = "numpy-2.0.0-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:903703372d46bce88b6920a0cd86c3ad82dae2dbef157b5fc01b70ea1cfc430f"}, - {file = "numpy-2.0.0-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:3e8e01233d57639b2e30966c63d36fcea099d17c53bf424d77f088b0f4babd86"}, - {file = "numpy-2.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cde1753efe513705a0c6d28f5884e22bdc30438bf0085c5c486cdaff40cd67a"}, - {file = "numpy-2.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:821eedb7165ead9eebdb569986968b541f9908979c2da8a4967ecac4439bae3d"}, - {file = "numpy-2.0.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9a1712c015831da583b21c5bfe15e8684137097969c6d22e8316ba66b5baabe4"}, - {file = "numpy-2.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9c27f0946a3536403efb0e1c28def1ae6730a72cd0d5878db38824855e3afc44"}, - {file = "numpy-2.0.0-cp39-cp39-win32.whl", hash = "sha256:63b92c512d9dbcc37f9d81b123dec99fdb318ba38c8059afc78086fe73820275"}, - {file = "numpy-2.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:3f6bed7f840d44c08ebdb73b1825282b801799e325bcbdfa6bc5c370e5aecc65"}, - {file = "numpy-2.0.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9416a5c2e92ace094e9f0082c5fd473502c91651fb896bc17690d6fc475128d6"}, - {file = "numpy-2.0.0-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:17067d097ed036636fa79f6a869ac26df7db1ba22039d962422506640314933a"}, - {file = "numpy-2.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ecb5b0582cd125f67a629072fed6f83562d9dd04d7e03256c9829bdec027ad"}, - {file = "numpy-2.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cef04d068f5fb0518a77857953193b6bb94809a806bd0a14983a8f12ada060c9"}, - {file = "numpy-2.0.0.tar.gz", hash = "sha256:cf5d1c9e6837f8af9f92b6bd3e86d513cdc11f60fd62185cc49ec7d1aba34864"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, ] [[package]] @@ -2623,4 +2614,4 @@ files = [ [metadata] lock-version = "2.0" python-versions = "~3.12" -content-hash = "daf0c53c20bd812b0fc7eadae0b75e4598fdd78d40c3cc6f653d6a38fce18c8c" +content-hash = "9f6ab70ed9c53912e2418db2b1633fc43fa7f605e9c06918df4d573da00122c8" diff --git a/pyproject.toml b/pyproject.toml index a082395..d91ad45 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,7 @@ python = "~3.12" simple-term-menu = "^1.6.4" pybids = "^0.16.4" mne = "^1.7.1" -numpy = "^2.0.0" +numpy = "^1.26.0" scipy = "^1.14.0" matplotlib = "^3.8.4" asrpy = "^0.0.3" diff --git a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb new file mode 100644 index 0000000..59cbf7e --- /dev/null +++ b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb @@ -0,0 +1,2345 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting EDF parameters from /Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf...\n", + "EDF file detected\n", + "Setting channel info structure...\n", + "Creating raw.info structure...\n", + "Reading 0 ... 60499 = 0.000 ... 241.996 secs...\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "Using data from preloaded Raw for 106 events and 251 original time points ...\n", + "0 bad epochs dropped\n", + "Applying baseline correction (mode: mean)\n", + "No projector specified for this dataset. Please consider the method self.add_proj.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running EOG SSP computation\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Computing projector\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 1 - 35 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hamming window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 35.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 35.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "0 projection items activated\n", + "Using data from preloaded Raw for 106 events and 101 original time points ...\n", + "0 bad epochs dropped\n", + "No channels 'grad' found. Skipping.\n", + "No channels 'mag' found. Skipping.\n", + "Adding projection: eeg--0.200-0.200-PCA-01 (exp var=96.9%)\n", + "Done.\n", + "1 projection items deactivated\n", + "Created an SSP operator (subspace dimension = 1)\n", + "1 projection items activated\n", + "SSP projectors applied...\n", + "1 projection items deactivated\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA60AAADxCAYAAAAgAVHOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddXgURx/A8e+eRi4eSAiEIAnuDsGKe6BAiwan0AIVClRxWgoUad9SoAIUKFC8xZ1S3IJDcA1OQlzu5v3juCUXgdAGa+fzPPsktzszO3uXy97vxhQhhECSJEmSJEmSJEmSXkKaF10BSZIkSZIkSZIkScqMDFolSZIkSZIkSZKkl5YMWiVJkiRJkiRJkqSXlgxaJUmSJEmSJEmSpJeWDFolSZIkSZIkSZKkl5YMWiVJkiRJkiRJkqSXlgxaJUmSJEmSJEmSpJeWDFolSZIkSZIkSZKkl5YMWiVJkiRJkiRJkqSXlgxaJUmSJOk5ql27NrVr137R1ZAkSZKkV4YMWiVJkqRnZtasWSiKkum2e/duu/SxsbGMGjWKUqVK4eTkhJubGzVq1OCXX35BCJHhORITE/n222+pXr06Hh4eGAwG/Pz8aNGiBfPnz8dsNj+PS31pTJ06lVmzZr3oakiSJElSttG96ApIkiRJ/34jR44kf/786fYHBgaqv9+8eZO6dety8uRJ2rVrR79+/UhISGDJkiV06dKF1atXM2/ePLRarZrn9u3bNG7cmAMHDtCwYUM+++wzPD09uXHjBhs3bqRDhw6cPXuWzz///LlcZ1asX7/+mZY/depUvL296dq16zM9jyRJkiQ9LzJolSRJkp65xo0bU6FChcem6dKlCydPnmTZsmW0aNFC3T9gwAAGDRrEhAkTKFu2LEOGDFGPde7cmUOHDrFkyRJef/11u/I+/vhj9u/fz+nTp7P3YtKIjY3F2dk5y+kNBsMzrM2zkZCQgMFgQKORHbQkSZKk50/efSRJkqQXbvfu3axbt46uXbvaBaw2X375JUFBQXz11VfEx8cDsGvXLtatW0fv3r3TBaw2FSpUoGPHjk88v6Io9OvXj3nz5lG4cGEcHBwoX748f/75p1264cOHoygKJ06coEOHDnh4eFC9enUAUlJSGDVqFAULFsRoNJIvXz4++eQTEhMT7crIaExrYmIiw4YNIzAwEKPRiL+/P4MHD06XF2Du3LlUqlQJJycnPDw8qFmzptp6my9fPo4fP862bdvULtipz3X+/Hnatm2Lp6cnTk5OVKlShVWrVtmVv3XrVhRFYcGCBXz22Wfkzp0bJycnHjx4QHJyMiNGjCAoKAgHBwe8vLyoXr06GzZseOJzLEmSJEl/l2xplSRJkp65qKgo7ty5Y7dPURS8vLwA+OOPPwAIDQ3NML9Op6NDhw6MGDGCHTt2UK9ePTVPp06dsqWO27ZtY+HChQwYMACj0cjUqVNp1KgRe/fupUSJEnZp27ZtS1BQEF988YU61rZnz57Mnj2bNm3aMHDgQPbs2cOXX36pth5nxmKx0KJFC/766y969+5N0aJFOXr0KJMmTSI8PJzly5eraUeMGMHw4cOpVq0aI0eOxGAwsGfPHjZv3kyDBg2YPHky/fv3x2Qy8emnnwLg4+MDWLtfV6tWjbi4OAYMGICXlxezZ8+mRYsWLF68mFatWtnVa9SoURgMBj788EMSExMxGAwMHz6cL7/8kp49e1KpUiUePHjA/v37OXjwIPXr18+Ol0GSJEmS0hOSJEmS9IzMnDlTABluRqNRTdeyZUsBiPv372da1tKlSwUgvvnmGyGEEK1atRKAiIyMtEsXHx8vbt++rW6PK9PGVqf9+/er+y5duiQcHBxEq1at1H3Dhg0TgGjfvr1d/rCwMAGInj172u3/8MMPBSA2b96s7qtVq5aoVauW+njOnDlCo9GI7du32+WdNm2aAMSOHTuEEEKcOXNGaDQa0apVK2E2m+3SWiwW9ffixYvblW/z3nvvCcDuPNHR0SJ//vwiX758aplbtmwRgChQoICIi4uzK6N06dKiadOm6cqWJEmSpGdJdg+WJEmSnrnvvvuODRs22G1r1qxRj0dHRwPg4uKSaRm2Yw8ePLD7aTKZ7NJNmzaNHDlyqJut++6TVK1alfLly6uP8+bNS0hICOvWrUs3A3GfPn3sHq9evRqADz74wG7/wIEDAdJ1wU1t0aJFFC1alCJFinDnzh11q1OnDgBbtmwBYPny5VgsFoYOHZpubKmiKE+8vtWrV1OpUiW758NkMtG7d28uXrzIiRMn7NJ36dIFR0dHu33u7u4cP36cM2fOPPF8kiRJkpRdZPdgSZIk6ZmrVKnSYydisgWk0dHRuLu7Z5gmbWBr+xkTE4Obm5uarnXr1mp33oEDB2Z5yZugoKB0+woVKkRcXBy3b9/G19dX3Z92JuRLly6h0WjsZkMG8PX1xd3dnUuXLmV63jNnznDy5Ely5MiR4fFbt24BcO7cOTQaDcWKFcvS9aR16dIlKleunG5/0aJF1eOpu0FnNNvzyJEjCQkJoVChQpQoUYJGjRrRuXNnSpUq9bfqJEmSJElZIYNWSZIk6YUrWrQoy5cv58iRI9SsWTPDNEeOHAFQg7YiRYoAcOzYMYKDg9V0/v7++Pv7A+Dh4ZFuLG12SNsCaZOVFs+0LBYLJUuWZOLEiRket13L85bRNdasWZNz586xYsUK1q9fz48//sikSZOYNm0aPXv2fAG1lCRJkv4LZPdgSZIk6YVr1qwZAL/88kuGx81mM7/++iseHh5qgGrLM2/evGypQ0ZdXsPDw3Fycsq0FdQmICAAi8WSroybN28SGRlJQEBApnkLFizIvXv3qFu3LvXq1Uu3FS5cWE1nsVjSdeNNK7PAOSAgIMPlf06dOqUezwpPT0+6devG/PnzuXLlCqVKlWL48OFZyitJkiRJf4cMWiVJkqQXrlq1atSrV4+ZM2eycuXKdMc//fRTwsPDGTx4sNoCGBwcTP369ZkxYwYrVqzIsFzxcGbfrNi1axcHDx5UH1+5coUVK1bQoEEDtFrtY/M2adIEgMmTJ9vtt7WeNm3aNNO8b7zxBteuXeOHH35Idyw+Pp7Y2FgAWrZsiUajYeTIkVgsFrt0qa/T2dmZyMjIDOu4d+9edu3ape6LjY1lxowZ5MuXL0vdju/evWv32GQyERgYmOHSPJIkSZKUXWT3YEmSJOmZW7Nmjdqil1q1atUoUKAAYG1lrVu3LiEhIXTo0IEaNWqQmJjI0qVL2bp1K2+++SaDBg2yyz937lwaNWpEy5Ytady4MfXq1cPDw4MbN26wceNG/vzzTxo3bpylOpYoUYKGDRvaLXkD1mVmnqR06dJ06dKFGTNmEBkZSa1atdi7dy+zZ8+mZcuWvPbaa5nm7dy5M7/99ht9+vRhy5YtBAcHYzabOXXqFL/99hvr1q2jQoUKBAYG8umnnzJq1Chq1KjB66+/jtFoZN++ffj5+fHll18CUL58eb7//ntGjx5NYGAgOXPmpE6dOnz00UfMnz+fxo0bM2DAADw9PZk9ezYXLlxgyZIl6SZ3ykixYsWoXbs25cuXx9PTk/3797N48WL69euXpedYkiRJkv6WFz19sSRJkvTv9bglbwAxc+ZMu/TR0dFi+PDhonjx4sLR0VG4uLiI4OBgMWvWLLtlXVKLj48XkydPFlWrVhWurq5Cp9MJX19f0axZMzFv3jyRkpLyxHoC4p133hFz584VQUFBwmg0irJly4otW7bYpbMteXP79u10ZSQnJ4sRI0aI/PnzC71eL/z9/cXHH38sEhIS7NKlXfJGCCGSkpLEV199JYoXLy6MRqPw8PAQ5cuXFyNGjBBRUVF2aX/++WdRtmxZNV2tWrXEhg0b1OM3btwQTZs2FS4uLgKwO9e5c+dEmzZthLu7u3BwcBCVKlUSK1eutCvftuTNokWL0l3j6NGjRaVKlYS7u7twdHQURYoUEWPGjBFJSUmPe3olSZIk6R9RhHiKvlOSJEmS9C+kKArvvPMO//vf/575uWrUqIHRaGTjxo3P/FySJEmS9G8gx7RKkiRJ0nMUERGBt7f3i66GJEmSJL0yZNAqSZIkSc/Bzp07+fDDDzl37hx169Z90dWRJEmSpFeGnIhJkiRJkp6DH374gTVr1vDee+/RrVu3F10dSZIkSXplyDGtkiRJkiRJkiRJ0ktLdg+WJEmSJEmSJEmSXloyaJUkSZIkSZIkSZJeWjJolSRJkiRJkiRJkl5aMmiVJEmSJEmSJEmSXloyaJUkSZIkSZIkSZJeWjJolSRJkiRJkiRJkl5aMmiVJEmSJEmSJEmSXloyaP0XGz58OD4+PiiKwvLly5/7+e/evUvOnDm5ePEiAFu3bkVRFCIjIzPNM2vWLNzd3bOtDk865507d8iZMydXr17NtnM+rex4fU6dOkWVKlVwcHCgTJky2VKvrPj888/p3bv3czvfP/XRRx/Rv3//F10NSZKk52b48OHP9b7wNP5u3WrXrs17772X7fWRJOnlJYPWl0zXrl1RFEXdvLy8aNSoEUeOHHmqck6ePMmIESOYPn06ERERNG7c+BnVOHNjxowhJCSEfPnyPfdzZ5W3tzehoaEMGzbsRVflHxk2bBjOzs6cPn2aTZs2ZXvwn5EbN24wZcoUPv3002d6nuz04YcfMnv2bM6fP/+iqyJJkmQn9f3fYDAQGBjIyJEjSUlJ+Uflfvjhh2zatCmbavl8g+DMvnheunQpo0aNei51kCTp5SCD1pdQo0aNiIiIICIigk2bNqHT6WjWrNlTlXHu3DkAQkJC8PX1xWg0/q26JCcn/618cXFx/PTTT/To0eNv5X+eunXrxrx587h3796Lrsrfdu7cOapXr05AQABeXl7ZVq7ZbMZisWR47Mcff6RatWoEBAT8o3MkJSX9o/xPw9vbm4YNG/L9998/t3NKkiRlle3+f+bMGQYOHMjw4cMZP358hmmz+r/TZDJl633hZeDp6YmLi8uLrsZz8TzvkZL0MpNB60vIaDTi6+uLr68vZcqU4aOPPuLKlSvcvn1bTXPlyhXeeOMN3N3d8fT0JCQkRO2GO3z4cJo3bw6ARqNBURQALBYLI0eOJE+ePBiNRsqUKcPatWvVMi9evIiiKCxcuJBatWrh4ODAvHnzAGuAUrRoURwcHChSpAhTp0597DWsXr0ao9FIlSpV0h3bsWMHpUqVwsHBgSpVqnDs2LFMyzl37hwhISH4+PhgMpmoWLEiGzdutEuTmJjIkCFD8Pf3x2g0EhgYyE8//ZRheXFxcTRu3Jjg4GD1m9vixYvj5+fHsmXLMq3H3bt3ad++Pblz58bJyYmSJUsyf/58uzS1a9dmwIABDB48GE9PT3x9fRk+fLhdmjNnzlCzZk0cHBwoVqwYGzZsyPScNmvXrqV69eq4u7vj5eVFs2bN1C8lwNq9+MCBA4wcORJFUahduzbdunUjKipK/dbeVo/ExEQ+/PBDcufOjbOzM5UrV2br1q1qWbYW2t9//51ixYphNBq5fPlyhvVasGCB+ndmEx0dTceOHXF2diZXrlxMmjQpXTeufPnyMWrUKEJDQ3F1dVW7F//111/UqFEDR0dH/P39GTBgALGxsWq+rNZ93bp1FC1aFJPJpH4ATK158+YsWLDgic+7JEnS82a7/wcEBNC3b1/q1avH77//DlhbYlu2bMmYMWPw8/OjcOHCABw9epQ6derg6OiIl5cXvXv3JiYmRi0zo5bRJ93Tr169Svv27fH09MTZ2ZkKFSqwZ88eZs2axYgRIzh8+LB6f5k1axYAkZGR9OzZkxw5cuDq6kqdOnU4fPiwXbljx47Fx8cHFxcXevToQUJCQqbPxcWLF3nttdcA8PDwQFEUunbtCqTvHpwvXz5Gjx5NaGgoJpOJgIAAfv/9d27fvk1ISAgmk4lSpUqxf/9+u3M86b6TkT/++IOKFSvi4OCAt7c3rVq1Uo/dv3+f0NBQPDw8cHJyonHjxpw5c+axr8XkyZPteqRl9jpPnTqVoKAgHBwc8PHxoU2bNmoei8XCl19+Sf78+XF0dKR06dIsXrz4sdchSa8cIb1UunTpIkJCQtTH0dHR4q233hKBgYHCbDYLIYRISkoSRYsWFd27dxdHjhwRJ06cEB06dBCFCxcWiYmJIjo6WsycOVMAIiIiQkRERAghhJg4caJwdXUV8+fPF6dOnRKDBw8Wer1ehIeHCyGEuHDhggBEvnz5xJIlS8T58+fF9evXxdy5c0WuXLnUfUuWLBGenp5i1qxZmV7HgAEDRKNGjez2bdmyRQCiaNGiYv369eLIkSOiWbNmIl++fCIpKUkIIcTMmTOFm5ubmicsLExMmzZNHD16VISHh4vPPvtMODg4iEuXLqlp3njjDeHv7y+WLl0qzp07JzZu3CgWLFhgd8779++L+/fvi2rVqokGDRqI2NhYu7q9+eabokuXLplez9WrV8X48ePFoUOHxLlz58Q333wjtFqt2LNnj5qmVq1awtXVVQwfPlyEh4eL2bNnC0VRxPr164UQQpjNZlGiRAlRt25dERYWJrZt2ybKli0rALFs2bJMz7148WKxZMkScebMGXHo0CHRvHlzUbJkSfXvISIiQhQvXlwMHDhQREREiKioKDF58mTh6uqqvv7R0dFCCCF69uwpqlWrJv78809x9uxZMX78eGE0GtW/gZkzZwq9Xi+qVasmduzYIU6dOpXuuRJCiLt37wpFUcTu3bvt9vfs2VMEBASIjRs3iqNHj4pWrVoJFxcX8e6776ppAgIChKurq5gwYYI4e/asujk7O4tJkyaJ8PBwsWPHDlG2bFnRtWtXu7KzUvd69eqJffv2iQMHDoiiRYuKDh062NXx5MmTAhAXLlzI9DmXJEl63tLe/4UQokWLFqJcuXLqcZPJJDp37iyOHTsmjh07JmJiYkSuXLnE66+/Lo4ePSo2bdok8ufPb3c/GzZsmChdurT6+En39OjoaFGgQAFRo0YNsX37dnHmzBmxcOFCsXPnThEXFycGDhwoihcvrt5f4uLihBBC1KtXTzRv3lzs27dPhIeHi4EDBwovLy9x9+5dIYQQCxcuFEajUfz444/i1KlT4tNPPxUuLi52dUstJSVFLFmyRADi9OnTIiIiQkRGRgohrPfbtPcVT09PMW3aNBEeHi769u0rXF1dRaNGjcRvv/0mTp8+LVq2bCmKFi0qLBaLEEJk6b6T1sqVK4VWqxVDhw4VJ06cEGFhYeKLL76we72KFi0q/vzzTxEWFiYaNmwoAgMD1c84aV8LIYSYNGmSCAgIsPs7SPs679u3T2i1WvHrr7+KixcvioMHD4opU6aoeUaPHi2KFCki1q5dK86dOydmzpwpjEaj2Lp1a6bXIkmvGhm0vmS6dOkitFqtcHZ2Fs7OzgIQuXLlEgcOHFDTzJkzRxQuXFj9xyuEEImJicLR0VGsW7dOCCHEsmXLRNrvJPz8/MSYMWPs9lWsWFG8/fbbQohHQevkyZPt0hQsWFD8+uuvdvtGjRolqlatmul1hISEiO7du9vtswWQtoBSCGvw4+joKBYuXCiESB+0ZqR48eLi22+/FUIIcfr0aQGIDRs2ZJjWds6TJ0+KUqVKidatW4vExMR06d5//31Ru3btx543raZNm4qBAweqj2vVqiWqV69ul6ZixYpiyJAhQggh1q1bJ3Q6nbh27Zp6fM2aNU8MWtO6ffu2AMTRo0fVfaVLlxbDhg1TH2f0PF66dElotVq78wshRN26dcXHH3+s5gNEWFjYY+tw6NAhAYjLly+r+x48eCD0er1YtGiRui8yMlI4OTml+3DRsmVLu/J69Oghevfubbdv+/btQqPRiPj4+Keq+9mzZ9Xj3333nfDx8bHLExUVJQB5M5ck6aWSOmi1WCxiw4YNwmg0ig8//FA97uPjY3cPmzFjhvDw8BAxMTHqvlWrVgmNRiNu3LghhEgfKD3pnj59+nTh4uKiBptpZRR4bd++Xbi6uoqEhAS7/QULFhTTp08XQghRtWpV9fOGTeXKlTMNWoWw/+I5tYyC1k6dOqmPIyIiBCA+//xzdd+uXbvUL/OFePJ9JyNVq1YVHTt2zPBYeHi4AMSOHTvUfXfu3BGOjo7it99+E0JkPWhN+zovWbJEuLq6igcPHqQ7b0JCgnBychI7d+6029+jRw/Rvn37DOsqSa8i3XNs1JWy6LXXXlPH3N2/f5+pU6fSuHFj9u7dS0BAAIcPH+bs2bPpxnMkJCTYdRtN7cGDB1y/fp3g4GC7/cHBwem671SoUEH9PTY2lnPnztGjRw969eql7k9JScHNzS3Ta4iPj8fBwSHDY1WrVlV/9/T0pHDhwpw8eTLDtDExMQwfPpxVq1YRERFBSkoK8fHxapfVsLAwtFottWrVyrQuAPXr16dSpUosXLgQrVab7rijoyNxcXGZ5jebzXzxxRf89ttvXLt2jaSkJBITE3FycrJLV6pUKbvHuXLl4tatW4B1cix/f3/8/PwyfC4yc+bMGYYOHcqePXu4c+eOOsb08uXLlChR4on5bY4ePYrZbKZQoUJ2+xMTE+3GOxkMhnTXkVZ8fDyA3Wt8/vx5kpOTqVSpkrrPzc1N7dqUWuq/MYDDhw9z5MgRtTs6gBACi8XChQsXOH/+fJbq7uTkRMGCBdXHqZ9/G0dHR4DHvt6SJEkvwsqVKzGZTCQnJ2OxWOjQoYPdMJOSJUtiMBjUxydPnqR06dI4Ozur+4KDg7FYLJw+fRofHx+78rNyTw8LC6Ns2bJ4enpmud6HDx8mJiYm3djZ+Ph49XPJyZMn6dOnj93xqlWrsmXLliyf53FS37ds112yZMl0+27duoWvr+8T7ztFixZNd46wsDC75y21kydPotPpqFy5srrPy8vrsZ9xMpP2da5fvz4BAQEUKFCARo0a0ahRI1q1aoWTkxNnz54lLi6O+vXr25WRlJRE2bJln+q8kvQyk0HrS8jZ2ZnAwED18Y8//oibmxs//PADo0ePJiYmhvLly9v9o7XJkSNHtpzfxjYu5ocffrD7RwxkGPzZeHt7c//+/X9clw8//JANGzYwYcIEAgMDcXR0pE2bNurEBLYA5EmaNm3KkiVLOHHihN1NzObevXuPfe7Gjx/PlClTmDx5MiVLlsTZ2Zn33nsv3QQJer3e7rGiKJlOZJRVzZs3JyAggB9++AE/Pz8sFgslSpR46skZYmJi0Gq1HDhwIN1rZzKZ1N8dHR3VcdCZ8fb2Bqxfqvydv7nUf2O2ur311lsMGDAgXdq8efNy5MiRLNU9o+dfCGG3zzbhVna8VyRJkrKT7Utrg8GAn58fOp39x7S0/zufVlbu6Vm9r6YtN1euXHbzDNg865nsbVL//7fdwzLaZ7snP+m+k5G/89ykptFo0t2TMprwMu3r7OLiwsGDB9m6dSvr169n6NChDB8+nH379qmv6apVq8idO7ddvr87CackvYxk0PoKUBQFjUajtm6VK1eOhQsXkjNnTlxdXbNUhqurK35+fuzYscOuVXLHjh12LWNp+fj44Ofnx/nz5+nYsWOW61y2bFnmzp2b4bHdu3erN4T79+8THh6e4Teatvp17dpVneggJiZGnXAKrN9GWiwWtm3bRr169TKtz9ixYzGZTNStW5etW7dSrFgxu+PHjh2jdu3amebfsWMHISEhdOrUCbDe9MLDw9OV8zhFixblypUrREREkCtXLsD6XDzO3bt3OX36ND/88AM1atQArBNHPInBYMBsNtvtK1u2LGazmVu3bqll/V0FCxbE1dWVEydOqK2fBQoUQK/Xs2/fPvX1jYqKIjw8nJo1az62vHLlynHixAm7L2ueVd2PHTuGXq+nePHi/6gcSZKk7Jb2S+snKVq0KLNmzSI2NlYNdHbs2IFGo8mwl0tW7umlSpXixx9/5N69exm2tmZ0fylXrhw3btxAp9Nlusxd0aJF2bNnD6Ghoeq+J90Dba2Nac+XHZ5038lIqVKl2LRpE926dUt3rGjRoqSkpLBnzx6qVasGPLqH2z4r5MiRgxs3biCEUIPosLCwLJ1bp9NRr1496tWrx7Bhw3B3d2fz5s3Ur19fnTTxSb3OJOlVJmcPfgklJiZy48YNbty4wcmTJ+nfvz8xMTHqTK0dO3bE29ubkJAQtm/fzoULF9i6dSsDBgzg6tWrmZY7aNAgvvrqKxYuXMjp06f56KOPCAsL4913331sfUaMGMGXX37JN998Q3h4OEePHmXmzJlMnDgx0zwNGzbk+PHjGba2jhw5kk2bNnHs2DG6du2Kt7c3LVu2zLCcoKAgli5dSlhYGIcPH6ZDhw52LZf58uWjS5cudO/eneXLl6vPxW+//ZaurAkTJtCxY0fq1KnDqVOn1P1xcXEcOHCABg0aZHo9QUFBbNiwgZ07d3Ly5Eneeustbt68mWn6jNSrV49ChQrRpUsXDh8+zPbt25+4xqmHhwdeXl7MmDGDs2fPsnnzZj744IMnnitfvnzExMSwadMm7ty5Q1xcHIUKFaJjx46EhoaydOlSLly4wN69e/nyyy9ZtWrVU12LRqOhXr16dgG0i4sLXbp0YdCgQWzZsoXjx4/To0cPuxmsMzNkyBB27txJv379CAsL48yZM6xYsYJ+/foBZGvdt2/frs4WKUmS9Crr2LEjDg4OdOnShWPHjrFlyxb69+9P586d03UNtnnSPb19+/b4+vrSsmVLduzYwfnz51myZAm7du0CrPeXCxcuEBYWxp07d0hMTKRevXpUrVqVli1bsn79ei5evMjOnTv59NNP1Rl73333XX7++WdmzpxJeHg4w4YN4/jx44+9voCAABRFYeXKldy+fdtuVuR/6kn3nYwMGzaM+fPnM2zYME6ePMnRo0f56quvAOvnhJCQEHr16sVff/3F4cOH6dSpE7lz5yYkJASwznp8+/Ztxo0bx7lz5/juu+9Ys2bNE+u6cuVKvvnmG8LCwrh06RK//PILFouFwoUL4+Liwocffsj777/P7NmzOXfuHAcPHuTbb79l9uzZ2fNkSdLL4IWOqJXS6dKliwDUzcXFRVSsWFEsXrzYLl1ERIQIDQ0V3t7ewmg0igIFCohevXqJqKgoIUTGEzGZzWYxfPhwkTt3bqHX60Xp0qXFmjVr1OO2iZgOHTqUrl7z5s0TZcqUEQaDQXh4eIiaNWuKpUuXPvZaKlWqJKZNm6Y+tk2o8Mcff4jixYsLg8EgKlWqJA4fPqymSTuB0IULF8Rrr70mHB0dhb+/v/jf//6XbgKG+Ph48f7774tcuXIJg8EgAgMDxc8//2x3ztSTOPTv31/kypVLnD59WgghxK+//ioKFy782Gu5e/euCAkJESaTSeTMmVN89tlnIjQ01G6mx7T1EsI6IVXqWRxPnz4tqlevLgwGgyhUqJBYu3btEydi2rBhgyhatKgwGo2iVKlSYuvWrenypJ2ISQgh+vTpI7y8vASgHktKShJDhw4V+fLlE3q9XuTKlUu0atVKHDlyRAiRtYmwbFavXi1y586tzmIshHUypg4dOggnJyfh6+srJk6cKCpVqiQ++ugjNU1AQICYNGlSuvL27t0r6tevL0wmk3B2dhalSpWymzjs79Q9o/dB4cKFxfz587N0jZIkSc9LRrMHZ+X4kSNHxGuvvSYcHByEp6en6NWrlzpjvBAZT/7zpHv6xYsXRevWrYWrq6twcnISFSpUUGfLT0hIEK1btxbu7u4CEDNnzhRCWP//9+/fX/j5+Qm9Xi/8/f1Fx44d7SbsGzNmjPD29hYmk0l06dJFDB48+LETMQkhxMiRI4Wvr69QFEW9n2Y0EVPa+0ra+2RGn3GedN/JyJIlS9TnztvbW7z++uvqsXv37onOnTsLNzc34ejoKBo2bKjOcG/z/fffC39/f+Hs7CxCQ0PFmDFj0k3ElPZ13r59u6hVq5bw8PAQjo6OolSpUuoElkJYJ+6aPHmyKFy4sNDr9SJHjhyiYcOGYtu2bY+9Fkl6lShCpOlcL0nZZNWqVQwaNIhjx46h0by8jfpVqlRhwIABdOjQ4UVX5ZUihKBy5cq8//77tG/fPsM0sbGx5M6dm6+//poePXo85xqmt2bNGgYOHMiRI0fSjRWTJEn6N/r444/Zvn17loaWSJIkvazkpzbpmWnatClnzpzh2rVr+Pv7v+jqZOjOnTu8/vrrmQZdUuYURWHGjBkcPXpU3Xfo0CFOnTpFpUqViIqKYuTIkQBq16gXLTY2lpkzZ8qAVZKkfz0hBOfPn2fTpk1yFllJkl55sqVVkqRsc+jQIXr27Mnp06cxGAyUL1+eiRMnZjhjsyRJkvTsREZG4uPjQ8WKFZk3bx4BAQEvukqSJEl/mwxaJUmSJEmSJEmSpJfWyzvQUJIkSZIkSZIkSfrPk0GrJEmSJEmSJEmS9NKSQaskSZIkSZIkSZL00pJTaGYDi8XC9evXcXFxQVGUF10dSZKeEyEE0dHR+Pn5vdTLOknSv42870rSf5O87/53yaA1G1y/fv2lXdJFkqRn78qVK+TJk+dFV0OS/jPkfVeS/tvkffe/Rwat2cDFxQWwvoFcXV1fcG0kSXpeHjx4gL+/v/o/QJKk50PedyXpv0ned/+7ZNCaDWxdk1xdXeXNU5L+g2T3REl6vuR9V5L+2+R9979HdgaXJEmSJEmSJEmSXloyaJUkSZIkSZIkSZJeWrJ7sCT9TXFxcWzduhUHBwfy5ctHgQIFXnSVJOlf79q1a1y9epXKlSu/6KpIkvScXb9+nUOHDmEymShRogReXl4vukqSJD0nsqVVkp5CeHg4P/30E4sXL6ZZs2aEh4dz5MgRBgwYwOrVq1909STpX2379u2ULVuWKlWqMGbMGIQQL7pKkiQ9Yxs3bmT58uWMGTOGd955h8uXL7Nv3z7atGnDhQsXXnT1JEl6TmRLqyRl0YULF+jTpw9dunTh5MmTrF69GgcHBwD69u1LkyZNqFevHgaD4QXXVJL+fX788UfefvttgoODqVatGp999hlHjx7l559/xsnJ6UVXT5KkZ+CXX35h9+7dBAUFERAQwCeffKJOwNOqVSs+/fRTfv311xdcS0mSngcZtEpSFm3ZsoU+ffrwxhtvpDtmNBpp3bo1y5cvz/C4JEl/T0pKCh988AHffvstffv2ZcqUKej1esqVK0doaCg1atRg+fLlcs1OSfoXWr9+PZMnT8bb2zvdsYIFC2KxWIiIiCBXrlwvoHaSJD1PsnuwJGXRn3/+Sc2aNTM93qlTJ+bMmfMcayRJ/2737t2jUaNGfP/990ydOpWpU6ei1+sBaN26NTt27ODOnTtUrFiRXbt2veDaSpKUnYQQ3LlzJ8OA1aZnz578+OOPz7FWkiS9KDJolaQsunHjBr6+vpked3V1JU+ePJw4ceI51kqS/p1OnjxJ5cqVCQsLY/369fTt2zddmjJlyrBv3z6CgoKoXbs2s2fPfgE1lSTpWbhw4cITJzisU6cO27ZtIyUl5TnVSpKkF0UGrZKUBZcvXyZv3rxPTNe3b1++//7751AjSfr3WrVqFZUrV8bBwYG9e/fy2muvZZo2Z86cbNq0ic6dO9O1a1cGDhyI2Wx+jrWVJOlZ2LZtG7Vq1XpsGo1GQ9OmTVm5cuVzqpUkSS+KDFolKQtsXYOvXLlCnz59MkxjNpspVaoU58+fJyYm5jnXUJJefUIIxo0bR/PmzXnttdfYuXNnlpaSMhgM/PDDD3zzzTdMmTKFZs2aERkZ+ewrLEnSM2O77y5dupSffvop3XEhBBaLha5du8peFpL0HyCDVknKAts3vosWLSIsLIx169apx1auXEndunWpWbMmmzZtokOHDnI2Q0l6SgkJCXTp0oUhQ4bw8ccfs2zZMlxcXLKcX1EU+vfvz9q1a9m9ezdVqlQhPDz8GdZYkqRnyTbB0ty5c5k3bx63b98GrF8Qjx49mkaNGtGwYUOio6Px8vLizJkzL7jGkiQ9S3L2YEnKgitXruDv78/GjRtZtWoVbdu2xc3NjSVLlhAfH8+qVauwWCyEhIQwb948unTpQu/evV90tSXplXD9+nVatWrFkSNH+PXXX2natCmnTp3ixo0b3Lhxg1u3bhEfH09CQgIJCQmYzWYcHBzUzdPTE19fX3x9fSlevDh79uwhJCSESpUqsXDhQho2bPiiL1GSpKdw5coV8uTJQ2RkJIqiMGHCBLp3787IkSMZPnw4LVq0YO3atZw7d44BAwbwySef8NNPPzF27NgXXXVJkp4RGbRK0mMIIVi9ejV+fn7cvn0bT09PvLy8mDVrFuPGjaNZs2Y0atRITT9w4EC+++47fH19uXr1Knny5HmBtZekl5vFYmHRokX06dOH5ORkihUrxoAB79GhQwe7dBqdHo3WgKLRomh1gIKwpFg3cwrm5ES79E5OzhQoWBCTyUTjxo155513+Oqrr+R6rpL0CkhMTOS7776jdu3arF+/nqZNm1KuXDkGDBjAvHnz+OKLLyhevDgAgYGBBAUFER8fz6FDh15wzSVJepYUIYR40ZV41T148AA3NzeioqJwdXV90dWRsklsbCzdu3cnKCiIQYMGcfr0adauXcvQoUMzzSOEoGHDhrz11lvcvn070/Gv0r+DfO8/vfDwcFavXs3q1WvYuWsXsTHRABicPUnWu6IY3VCMbmAwoegdUQzOaAxOKMkxJF3aAeYk9Plrg8EFRVEQFjPCYsGS8ACREg/JsYjEB4iEKHTJ0aTE3EIICxqNluIlStC4UUOaNm1K1apV1eVzpFePfO/9O506dYp33nmH0NBQOnXqxLhx46hZsybBwcGZ5omIiGDIkCG4uLjw7rvvUqhQoedYY+l5k+/9/y7Z0ipJmVi/fj01a9bknXfeAeDatWtPbDlVFIVy5crh4+PD3LlzZdAq/ecJIThy5Ahz585l8ZKlXLxwHo1Gi2LyRZgC0Xg4o7j6I/QOGd6QNDo95oiD6LwL4Vi8FUJYEBYzSRf+RCRFo8tZEo2rHzi4ICzOgP2ajlphQUReRJiTOHbuHCcmTWHcuHGYXFxo1rQp7du3p1GjRhgMhufyfEiSlLn//e9/fPfddxQpUgTI2n03V65c3L59m3bt2vHHH38wcODA51FVSZKeMxm0SlImduzYQbdu3dTHV69ezdI3uE2aNGHr1q0AxMTEYDKZnlUVJemldfv2bX7++WdmzprN6VMn0RmdsJj80eavi2LKhaLNYiunOQlLzE20+WuiKAoKWoSiwSGwLpakWCyxdxGJ0QhNxkGnomhQPKwzEAvPQIQQaBMjiYu6ypKVG1mwYAGurm506tSRnj17UrZs2ex6CiRJekrnzp2jcOHC6uPr169j3L+V24cUvEM6oyhKhvkqVaqEs7MzW7ZskUGrJP1LydmDJSkTJ0+epGjRooC1tSirY1SrVavGrl27aNiwIevXr3/W1ZSkl0pYWBjdunUjd548fPLp55y9lYg2fz0o0hatfzU0bnmzHLAqGg2IFAz5aqLR6tDoDdZNZ920Dq7oPPJivhsOcXeyUJ4OceMgmJPR+JbG4lsJHL2I1uXgh5lzKFeuHNWCg1m8eDEpKSn/9KmQJOkpREdHYzKZrN3+H45cK3v/Ete+fJ/Lo9/jwic9OPPumxxpXJyTofW4t36pmrdp06Zs2rQJk8nE3bt3X9QlSJL0DMmgVZIykJCQgNFoRKPREB4ezptvvpmlbkoAOp0Og8FAvXr1+OOPP55DbSXpxdu9ezd169WnbNmyzJn/G2avkmiKtkGTtxYaN38U5W/cbuLuIOLvo3fPjUb/cCImjdb6u1arBrA6j3yImBtZKlKTsyQi5gbi/gUUrR5dYCN0eWsgCr2ONt9r7Dt2gbZt25I/fwF+/vlnkpOTn77ekiQ9tT179lClShUAfvjhB6ZN+poG0RfV4/c3LOfBjg0k344g7sRBLnzSk6tThgFQrlw5Dh06RJMmTVizZs2LqL4kSc+YDFolKQOHDh1SuwmePn2anTt3cv78+SwP+i9fvjy3bt3i3r17XL9+/VlWVZJeqEOHDtG4SROqVq3KX/uOYizSFCVPNbS+pVB0Dn+/4ORYUq4fQO8VaA1QNVq0OkO6TdFq0brlQeOZP0vFKnontLnKofEsiOLoiaK1ditWFA0a93woBRqhK9SC67E6evToQaFChZkzZw4Wi+XvX4skSU9kW18Z4MSJE2yZNR0dAoNfXvyHjMe5RAVcg+tTcPICfEIHAHBzzrfcXTkfnU6HEILGjRszd+5c+X6VpH8hGbRKUgaOHz9OyZIlAbhw4QLDhw/n6tWr6ngas9nMpEmTGD9+PElJSenyV61alZ07dzJy5Eg+/vjj51p3SXoebt++Tc+ePSlfvjzbdh/GrXJXXGq+j1NAJRxyl0XcPIzl/vm/WbpAowiMhRqidTSh1aXqEmxwtP/5cD9xdxCJkdlybYqTF9qA2ugKh3A1ShAaGkrFipXYu3dvtpQvSVJ6x48fp0SJEgBcvnyZ1iWDADD6FyRn2x64fTmbue5F2BARRZ4Bw8nZzroW+qUvPiDp1nVKlSrFlStXaNKkCbNmzXpRlyFJ0jMig1ZJysDx48fVdeAuXLhAcHAwiYmP1oLcvn07ly5dwt/fn0aNGjF8+HB+/PFHdRxOpUqV2LNnD6VLl8bd3Z1t27a9kOuQpOxmsViYOnUqBQOD+GXeQjyrdce7+Zc4FwxG5+CM1uCI3tGEQ2A9lJQ4RNSFpypfxN3CfHELWrfc6N18rS2qtgDV6IhG//BnqkBWozeg9SyA+do+hMi+FhbF0RMl4DW0gU04cvoSlStXpnv37ty58+Txs5IkPZ3o6Gjc3NwASEpKIkektcu/qVQlAKZOnUqxYsU4duwYISEh/BLnhNnbD5GUyKXR76nzSbz99tv8+uuv3Lt374VdiyRJ2U8GrZKUgXPnzlGggHXG0UuXLuHm5ma3JMayZcvo1asX7dq1Y+3atTRq1Ihr164xbtw4AFxcXIiLiyMhIYERI0bwxRdfIJdEll5158+fp1bt2rzzzjvo81UmX5epeJZths7BGZ3BEa3BAa3R8WHg6oxjUF0MfmURt49iuXkYkZKQadnCnIySEo+4fw7HYi1TlWkLWB3Q6PRgTsQSe9v6+OGYVq3OgM7ZC32u0iiW7B+DqjH5QGBTNHmqMmfeAooWLcbvv/+e7eeRpP+qlJQUtFotYJ34UFEUHO/fBMClfDXAOua1bdu2jBgxgp9//pk69eszS5cLATzYuZEKPu5s2rQJnU7HsGHDGDNmzIu6HEmSngEZtEpSBsxms3oDTUpK4uzZs2rQKoTg+PHjTJ8+nQEDBpCcnEyVKlUYNmwYW7ZsUYPTxo0bs2bNGtzd3SldujQHDhx4YdcjSf+EEILp06dTomQpDh4/S2Cnr8jb7D2Mrh7o9Bp0Bi1ag4Nd4KpzMKF3NKF3csFYoDY6j7wQdRFS4jDfCMMSeQGRkoCIvob54hbErTD07n44FW+JztkNvYMJrcERnaOzdTM4ojM4Erl7Jg8O/gaJ0WgN1sBVa3BEZ3TEmKskGkVgvrorW1tcwTrmVetdBIJaEJniSEhICF26dCEqKipbzyNJ/0Vnz56lYMGCANy7dw8/Fyf0iXEAOBUpzZkzZ8iRIwfdunVjypQpeHp6UrVqVYb/PI9LphwAJG5cik6n486dO9SoUYPjx49nOHxHkqRXkwxaJSmNyMhItYuSEIKYmBi6detGVFQUMTExnDlzBg8PD9zc3GjZsiUhISF07tyZJUuWUKBAAS5evAhA27ZtmTlzJrGxsXTu3Jk5c+a8wKuSpL8nJiaGN9u1o0+fPuh9Ayn29ve4FyyDVqtBp9ei1WnsAle9gwm9gzNao4M1cHUwYXBywSF3KRwL1kLv6os+RyG0eiM6vR6dmx8ORZrgVLQZOseHga6DCZ2jyS5Y1TmY0Dk44+RfBq2TO3o3X3QGR7tz6YyOGDwD0LrlwXL5r2fyfCh6Jwiog9a/OvPmL6RM2XIcPXr0mZxLkv4rTpw4YTckx/3WJQDuWDRoTa5s3LgRi8VCly5dMJvNNGjQgLfffptr166xSesFwL21i3kjpDnTp0/HbDbTqFEj1q5d+8KuSZKk7CWDVklKI/VkEPfu3UMIQZkyZTAYDFy7dk2djKVRo0bUqVOHjRs3MmnSJBYsWEC+fPn46y/rh2UfHx/at29Po0aN8PHx4dSpU3L5DOmVcurUKSpUrMjy31dStNNQgtp8SMKdy5ASh0anqIGrddNgMOrQGQxqsGprJdU7WVtO9Y4mjC6eEH8b863j6BxdMHrlxejmowaremc39M6u6B2crY+dXNE7OKJ30KMzaMlZuS25mw7B4OSM3sHR7lx6Jzf0jiYc81XGWLgRJD2wtromxQKQcmkbKec3/ONWWEVR0HgFoQQ24+qtKCpWrMS8efOy4ymXpP+kY8eOqffdCxcukDvWOh71QKK1x9PevXvVFtQPPviA9evXM3DgQAYOHEhcniA0OXJhiY2hpocDQgjatGnDm2++yfz581/YNUmSlL1k0CpJaRw4cIBy5coB1rGtWq2WhIQEcubMyfHjx9WbZ8WKFdU83t7efP3112zfvp0dO3ao+9u3b8+3337LwIEDadCgAevXr3/u1yNJf8eGDRuoWLESN6MTqTbkR/wq18clV14UzJxd9AW39/+BzvAwaDVoHwasGvRGLTqDDp0t6LQFlM6u1oDUyQ0So1G0OnRaLQYn6z6Diwd6Z1cMTq4P97licHLCYNRhcNRhMGoxGLXoDBoMRi1GR+t+o6MBg5MJg5MbBmdXDC4eGJzccHDLiUPOIPS5SmO5cdDaFTn2NiL+PiImIlueI8XoCgWbkGLyp1OnTgwZMkQutSFJf8Phw4cpVaoUAOfOniF/SjQA+2MtpKSkcP36dZydndHr9YD1i6OCBQvSq1cvkpKTicqZF4DorSv57LPPqFOnDn/88QeJiYlERka+kGuSJCl76V50BSTpZbN//37at28PWLssJScno9PpKFu2LH/99Rfh4eGYTCa7iZkA8ubNixBC7R5sU6ZMGWJjY2nZsiXDhg2jadOmz+tSJOlvmT17Nj179sSvZGWq9BmD0DsSn2QmSVHwKlwOj8AyxN2JIO76Ke4c/Qvf6m+i0zujaBQ0WgtanQVzigWzWYslxYA5xYywPNq8a/QmJT4SraM7gHW9VY324aRKWjQ6DVqtglanQaPVoNVpUDTW5aaE5dGEZsIisOgFOoOGFL2WFIMBTYJ1ciZzkiNaQzw6oyPmnIFYkpNILtIUkRiNQIGUWFIu70Rx9ETjVRi0RtDo1GWtskRR0GogKTkOnU9xxo0fz8VLl/hl9myMRmN2viSS9K8WHx+Pg9HIhc/fovbapeiFGYDzWmeOHj1KYmIiderUSZcvJCSEmTNnstfHhbpA9P6/EELQt29fWrVqRYcOHVi8eDE9e/Z8zlckSVJ2e6VbWv/880+aN2+On58fiqKwfPlyu+NCCIYOHUquXLlwdHSkXr16nDlzxi7NvXv36NixI66urri7u9OjRw9iYmKe41VIL5s7d+6QI4d1YoeTJ0+i0WjQ6/VUr16djRs3EhsbS/ny5TPMW6pUKRRF4d69eyQnJ9O8eXPMZjMVK1bk+vXrxMTE8ODBg+d5OZL0VL788ku6du1KibotafXZt3h6uOFo0KqbQa9Fb9Rh8smNZ2ApvIpV4tLvE9FqzZAcjcGoQ/9wMxi1qVpDHTA4OWE0ueDo7oVTjvwYTR4YTR4YnEwYTc44OBtwcNbj4KS3/u5kIOHqAe6FrSLq5Ba0ShJ3DyzlXtgqku5dgJQozA+uolWSrPmc9Ti6mB6V6+KB0c0bo8kTB7ccmPxL4xJYHVO+ijj6BOFU+k0MPsXRObpA9GUsFzdjvrwdFAXzjUNYbh9HxN1CpCRiibuNiL0JlmTEg8uYL23Fcm03WmdvnEu/iXOp1phKv8nixUupV78B0dHRL/qlfCbkfVfKbtevXydXrlzEHN7DvTWL0AszySicyV2UHAWC+Oyzz3BwcKBatWrp8jo5OaHT6dh+6wFotZgf3Gdk357odNYvoJo0aZLub1SSpFfTKx20xsbGUrp0ab777rsMj48bN45vvvmGadOmsWfPHpydnWnYsCEJCY+WXejYsSPHjx9nw4YNrFy5kj///JPevXs/r0uQXjLR0dGYTCbAOr3+tGnTiI+Px8XFRR2bWqNGDSpVqpRh/uDgYFxcXNi5cycrV67kzJkzrF+/nqpVq7Jz505at27NkiVLnuclSVKWjRw5kk8++YSG3QbwxuAxODs64GjQ4pQqaDU56HDUW4NXnUFLjuKVKNljDDqDjmsbZnB+8SgSb51GSXmAiL8N8TdxcNZiuX+a5Gt70CRcx9FkwMnFoAaatkDV6KhHscRyb/8iLvz2OZb42zi4ueOSKy+uuQtgcHLEPX9xXHL54+higsQHRJ3axrX136GxRBN/aS86TQJOLgYcXUw4unri4JoDBzdvHNy8cfTwwcnLD+cc/tbN2x9n/1I4egfgVLAGzmU74FSiFXonN4y5SqJzz4vOyQOtBpS4WyhJD9DqDeg9A3As1gKnYi3QO7lgMHmidzDhHBiMx2vvs3vvfuo3aPivDFzlfVfKbgcOHKBChQrc37AMgMMJMCZnZaKbdaVNmzYUKFAAnU6nDttJq0iRIiShwaFQSQCM+zYSGRlJ6dLWWYdz5syZrgeUJEmvnle6e3Djxo1p3LhxhseEEEyePJnPPvuMkJAQAH755Rd8fHxYvnw57dq14+TJk6xdu5Z9+/ZRoUIFAL799luaNGnChAkT8PPze27XIr0cUo9n3bx5M3ny5MFisdC1a1dy586NRqPh4sWLvP/++xnmr1q1Kt999x1//vknJ0+eZNmyZQwfPpyff/6Z//3vf8yaNYsOHTrQrVu353lZkvREI0eOZNiwYTRo351Wb71PQooFRVHQah5tcUlm9XeDTkNSigWzRWDWatDoNBTvMpTEmBjMSfHE3brCvaPbUbRa/OuEkqgkonXUIOIiIFbHg3NH8CjVEI1eT9zVE8RcPIii1eFTsTEeBUtSsHEoWoMejSYfloddgjUaBcfiFdTHAB4FigJgTrGQcPMs19dNwTWoMu7F62I2azGnWEhJ1iMsAkWjoNNrEBaBsEBSYgopCbEkJ8RgTkxAWMxYUpKsP51cABAWazdFcuRXz6lotGg0WrVLs20dWZ3BESfPSjh5DOPAHyOp36AhG9avw8XF5Tm9is+evO9K2W3v3r20aNGC6HGzAThk8EJnNFKnTh1MJhN//vknKSkpODs7Z5g/ODiYK1eucCm/Pz4nw6jtZmDe3LlUq1aNnTt30rFjR+bNm8enn376PC9LkqRs9koHrY9z4cIFbty4Qb169dR9bm5uVK5cmV27dtGuXTt27dqFu7u7euMEqFevHhqNhj179tCqVasMy05MTCQxMVF9LLt7/nv8+eef6t/Mrl27cHFxoXv37jRq1AiA6tWr8+uvv6rdh9Py9PRECMEff/zBRx99RMGCBYmJicHJyYm4uDicnZ0xmUzcuXMHb2/v53ZdkvQ4EyZMYNiwYbzeox8RVy/joFXQKFq7NFqNBq1GISnFQmKKhaQUizVwTYhH6HRY0JOUYsHR6I7Z4oa7jy9+JSs+zKvg5VNPzZ+UnEL8rXNc+eMrCrb+ECU5ihylgnHzL4zWaEDv749BZz3f45hTBa9mi8BQoRY+ZWqQFJ/AnWM7ublvNS4FK+FZqiECDeb4e2iSEoi+fJzI07vRGJzI1eBdkhJNpCSaMSfFY05JwpKShCU5+dE43JQkFN2jMeyKLWDV69HoDOr6tDrDw1mUPUug1O3B/vXTadykKRs3rMfBwSEbX7GXk7zvSn/HoUOH+KRfX05cCAfgvCkH30yYoK7beufOHfLmzZtp/uDgYGbNmsXQ5euZ5uKI/sFdDIunU3nxFubMmcM777zDhAkTnsu1SJL07Pxrg9YbN24A1mVHUvPx8VGP3bhxg5w5c9od1+l0eHp6qmky8uWXXzJixIhsrrH0Mti3bx9Dhgzh2LFjHD16lPz581OlShX1eNu2bbl8+fJjy/D392fGjBmYTCaKFy9O3bp1uXLlCoGBgZw7d06dRbhDhw7P+nIk6Ynmz5/PoEGD6Nj3Pbq89zGxSSns2bYJZ88c+BQsilaxb2VNSjFjeBi0xty/y8bx7+LkmZMa/cfZBZG2Flnb7zqNQlJcDMLkZA1uX2uJf/XmALj5NMCg1agtuKkDVq1GUctNHcSmPpftsdkirEGxUYexcl1ylqrG3ZP7cHRx4MyCUSDMFGzxFjnqtcZcsylJcQlYhIaTv4zApUBlTIVfwyJcSE5IVFtco89sJTZ8C6bC9XDMVxlFYw3mtQ9bWDU6/aNg1ahDq9Nw98ByUmLuUrrnGPb89CmhoaEsWLAAjeaVHpHzRPK+Kz2t+Ph4dDodMccOAHDVrCHSrFCgQAE1TevWrR/7pY+vry8pKSnsP3KMbUPfxbR6DuVirhE7ZxKRkZFotVpy5MjBjRs38PX1febXJEnSs/GvDVqfpY8//pgPPvhAffzgwQP8/f1fYI2k7JCQkIBGo2HZsmXMnj2bSpUqERcXpy54DtaxMzNmzHhsOcHBwezYsYNLly6pE40cPXpU7arUqFEjBg8eLINW6YXbunUrXbt2pWnrdrwz6DMSLQJHvZbiZcszYdDbNOr8FgXLVUPzMHC1trJauwUnpZhRnIzotFqcnE24O+nVclMHnNZNw4E/5nFs03Iqvt6dvJWsra7xSWa7dAadBuPDgDWzVlbbflvQmjZ4tbUCxyeZSTLqcKpYm2SzhVI9R2PQa/E0GUiKfcDWye+hN7lT+q1xlO0znuv7N6FNuo1ITsHZMx/mZEdSks0kmryIUzQYXKwTOikaDRqNYjfDsU6vJenuRa5tXopXsSrkb9Aek6MBk4OOHM5fsPjrDxk8eLBs7fkH5H3332n37t1UrVqVlRNGUQpwDgjEV+trN4t3r169nlhOjhw5uHnzJpOOXKKwzpc3Um5wa973lC70GlevXqVRo0asXbuWrl27PruLkSTpmfrXBq22b9Nu3rxJrly51P03b96kTJkyappbt27Z5UtJSeHevXuP/TbOaDTK5Qz+hfbu3UvlypX55Zdf6NChA0lJSaxYsQKt1r6b5JOWxKhWrRoDBw4kPj6e8ePHs2DBAo4dO0a7du348ssvCQ0N5datW1gsln99y4v08rp48SKtW7emXOWqjJzwDUKrQTFbA0Afb28+++ZnTh0/StydG5i8fdFqtBi0Ggw6ixq8Ohq86T55QbqWUFvQadRp1Mc5c3iiUQTeXh7kcHXAoNMQn2TGbBF2QastyE3dwpq67NQeBa4WtA/fS2aL5WFQbSEuyayOuwVwNGhxd9JjNjrj4GDE2d0DX3cHYhx0ONRsSmJiCle2L+fWjl/xq9sbRxcfDKVq41WiFoB1SR+NgqJR0Go1CEsi0eE78C5Zg8grBynYvAeefgGYHHSYHHS4OOgoUKcxhoT7fP31aIoXL/6vHs8u77vS09q6dSvBwcHEr5gKgAgqRXmPfHZpsrIMVbVq1fj000/Jly8f+hIluL59IX6xd6ltSGTXrl00bNiQfv36yaBVkl5h/9qgNX/+/Pj6+rJp0yb1ZvngwQP27NlD3759AeukOZGRkRw4cEBdwmTz5s1YLBYqV678oqouvSBbt24lICCAQoUKce3aNRRFsRt3lVWBgYGYTCamT5+Ol5cXX331FXFxcQwePFidwbBChQrs378/01mIJelZSkhIoE2bNjiZXJg0YzYODgbMFtAoD4NPBXAxUaZCZVYunMPBvzbTYeBwnL190SiKGrzauuQCdsGnuinKw1ZaqN28DbWbt8EiBMlmgVGnITohRc1vC1h1WWhltcmstTXlYTdhU4p90Gpy0D9sEXbk7W8XEJdkJj4pRZ0dOSpOQ8Brr+NZpBLx926TcC0MhILOxRPHnPlJuHOZxKjb6BwcsGgUbuxaineJ6ji6OlKsRXfrzMoGLS4OOkwOevX3Rh16EHXlLH379qVMmTKULVs2m17Jl4u870pP68CBA5hMJmorKQDsvRtD7Za1nrqcevXqERYWxvjx49m9ezfbDm7DL/YuOW6cZ82OHbRt25aoqChSUlLQ6f61H30l6V/tlX7nxsTEcPbsWfXxhQsXCAsLw9PTk7x58/Lee+8xevRogoKCyJ8/P59//jl+fn60bNkSgKJFi9KoUSN69erFtGnTSE5Opl+/frRr107OYPgftH//fgBef/11pk+fzpUrV1i3bt1Tl6MoCr/++qv6WK/Xc+/ePRRFIW/evJw9e5bGjRuzZs0aGbRKL0T//v05duwYC1dtwNPTAyEAjQAU0GkgBfXu0KJ9KCUqVOHcsUP4BRXFyc0TJxc39FoFswUs4mHgKIRdkKpRFGLu3iIx9gFRd26z7tefAEHokFEc27uDoIo1yOmRg6QUC4BdoJuWJtU+7cPOCWZrNvX8qZmFeBis6kh8WL5Oo+Bo0OJs0Kr5HQ1m4pO0xCWZ1aDZoNOgz5OXJJ/cxNy4wt3jO0m6cw6vAoW5vXM7BpM7zn5lcc0bRJ6ylTHoNOpyQE62JYEM1lZWR70WBw0c2PQHZarW4MKxg7R6/XUOHTyIh4fHP34dXwR535WyS0JCAnq9nkNbNlAnMR4BROicCQ4OfuqyAgMDmTZtGgAVK1ZkYpKORgB3bnD5yEEsFgtVqlRh9+7dVK9ePVuvQ5Kk5+OVDlr379/Pa6+9pj62jXfp0qULs2bNYvDgwcTGxtK7d28iIyOpXr06a9eutRvQP2/ePPr160fdunXRaDS0bt2ab7755rlfi/RiJSYmoigKe/fu5aOPPqJPnz5MmDABR0fHf1y2n58fN27cICoqitDQUH755ReGDh3KmDFjsqHmkvR0Fi9ezI8//shXk/9H6TJlMFtA8DBgTRW4ah4GhVqzIKhQIfIVDOLYwX3M+uYLnN086P75OG5cuYyXnz+KoqhBqxACvVbhl68+IyH6AQ3f7ELF4JpUqfGo9cQcF838CUMpU6sBlZtaW18RAr1WS8T5cFDA1dMbg9GBa+fPEBt1n7xBRbh19RLnjh1CUTQ06tSLA9s2oNXpyJk7L165A0iMi0Oj0eBoNOLkqCfZLEi2WKz1Sk7g4Npl5C9anON7/sIiBMEhHXBzdk3VLfnRlpSixTEgP57++TA/DIyLvd7HriuzLWB9tI6tTv3dSa/FQadh+qf9KVKmPPXadqJchYr0b92Avm+/zYL585//i58N5H1Xyi67d++mXLlyxP1l/XL4dgqMGf/Px307ODiQZHTiqs4Z/5RYmuX3Yfv27TRp0oRly5bJoFWSXlGKEBl8TS09lQcPHuDm5kZUVBSurq4vujrS37B9+3Y2btzI8ePHWbRoETlz5iQiIiJbuhFNnDiRixcvUr9+fZo1a0a9evVYuXIl3bp1Y9q0abi7u//zC5BeiFftvX/z5k1KlChBpSrVmD57LhahYEEghLWLrQVrC6T5YRfeZIvl4U9Bstmi/oyNiUHR65kzYRQ3r12mSoPmuHh6s37+TFKSk+g3ejJOTk64uLpaW181ClrF2mJqaxlNNgseREezfd0qdq3/HZ1Oz6DJP/H7rKnEPojCN29+Slauwdbff8PN04uy1etgMacQeec2QgiKlq/M/q0buHcrAlcPL/IXLcWi77/GYjFTv20o1y+dZ8/G1fgXKkbzbm/zvyF9qNn0dWo2ao6i1RO2609OHz1Egw69SFL0JJotRMYlE5OQTHySWZ3QKW3XY1uAa3wYtFoD10fBqoNOw/2rF1kxYyJv9nmfAkGFMeq16DUa9FqFTX8sZcR7b/Hbb7/Rtm3bF/BX8O/wqr33pPSGDx+Om5sbBQ+sJ/epPaxPduTjw9eypeyWLVtSO+YKNSIvoCsbzLg4V+bMmUOzZs1YvXp1tpxDejHke/+/Swat2UC+gV59o0aNwsHBAUdHRypVqkSnTp0IDw/PlrJXr17Nrl27iImJYdKkSaxZs4ZVq1ZRqFAhAgMDadKkSbacR3r+XqX3vhCC119/nb/+2sGWnXvw9M6BACzCGqQK8eh3W+BqEViD1VQBrHW/wCzAYhFqK6QtttMopAtU9Q/79Gof9vJNnTch2YxZCHSZTEqmecJarTaWtEvgCIHZbOZ8+EkKFimBQWsdL2sLnG3B+O7N69ixfhVvDhpFskZPdEKKdebhFHO6gBVSz3SsVWc7tgWrlqREDBr4ZeyndHx7IAEFCqjBql6jQaMBnaLwUd9uHNz9F8ePH0+3PIyUNa/Se0/KWPPmzSlQoABdru1FXDzNloJV+XDhqmwpe+DAgfglRVN712IUg5GFVdtTOdi6zvqsWbMwmUzZch7p+ZPv/f8uOXWpJGFdn9XWGvrHH39QokSJbCu7SJEi3L9/n5MnTwLQuHFjLBYLLi4ubN++PdvOI0mPs3TpUpYvX864SZPJkTMnGkVB4VGQaR2P+vB3Depjg9YamBl1Gpz01m6vRp0WB+2jx9ZNg5Neg8PDtA5ajTWdToNeo+Cg1VgDOI1Gzeug0+Bs0OFs0KUp659vLgYdLg4GSpYshcmgVc9hrc+ja6pWtyG1mrZi3cxvcH44u7CXyYCXyYhnBpuXyUhOVwdrGmcDHk56iI1izY+TmPFxX1yMOj6Z8B2BgYF29THqNDg8DHSHjv0aNBree++9F/1nIUkvREJCAjqdjgsnTyAuWb8gLtTk9Wwrv0iRIugDi5Gs0SGSEhn8ehOmTp1KmTJl2L17d7adR5Kk5+eVHtMqSdnBNp717NmzFCpUiB07dtCsWbNsKz8gIIBLly4REBDAmTNnCAoKYtSoUbRv3x69Xv/kAiTpH4qLi+ODDz6gYaPGNG8RAoBQQBEKQoCCwAxoUVAUARYFjUagEdaxqoqioNVorV2IhUAvBJaHrbGQ8WRIGlsg/DAATr3fRi8UkjWP7+zzNKtCWSz2j82p6qV/2MxreThLcrJFoFUEWgWq1qpD2eq1Wb3gFxzdPCgeXBdngyHddaWeZOrBnVscO7CDpPg4SlepToVqNegz8GMMWq3asqrXWlt2dRoFRXn0RUDOnDkY/PlIhgzoS58+fahV6+lnS5WkV9nu3bspWrQoxtNhcE/wwKJQqlbdbCu/SJEi/PXXX5zSmihpieT+op/45JNP+Pnnn0lOTqZevXrZdi5Jkp4P2dIq/eft3buXoKAg8ubNi6IoXLt2jSpVqmRb+VqtFrPZzBtvvMGCBQsA8PLyokiRIiQmJpKYmJht55KkjIwdO5YbN27wxVfj0D7sImtrZVUUW4BpnZlXg8K58JOsW7kCDcK6BI2ioNNYAz+D1tpiaGt5tbWspt0cdJpUwdujzbasjU5jLUuPmWVzfiDi4hmcHk5qlHpz0NlvB3dsY+GPUzFolHTHUucz6jQoKYksnTWdu9cuq628eq3ysF6KWj9by3DD19/k3tWL/PH9V4i4SJZNHMqGnydxK/ww14/tY8nEofzw0Vso8dHsXfUbBq2G+s1aEVSoMJWDa3LtzAkObF2vtqwatNbz6TTW81lbsEGvUWjTrj1lK1Skf//+pKSkvOg/EUl6rrZu3YpWq6WmkxmAo0ka8ubNm23llyhRgkOHDnG/vDUQfrB7EzUrlufWrVscOnQo284jSdLzI4NW6T9v9+7dWCwWGjZsyIMHD0hMTKRw4cLZeo6GDRsSFRXFn3/+iW0YeZ06ddDpdJw4cSJbzyVJqV29epVx48Yx4N33KFigABoeBappA1cFa+A6bMhAfps7mzOnTqBVFPQa1MBr5neT6Nu+FdGRd9Ug1jFN8Hj/5nXe6dCK3+f/8nAcKXabVvNo27N9Mwd3/cX/xo5Ep+GJ2/RJX7FjywaunD9jDaQf1kuvUezSGXUK29et5Mj+3fz0zbhHwePDbsqpuwnrtRpuXzrHmL4d8c8bQJ+PR5Irhzft+rxHrUbNyZ+/IEWKl6D9WwPw8fXjx5Ef0qlPf5q3aYdPDm9cDNbuyFOGf8TCn7/n1rXLGHWPgtXUz59Oa/0SQK/VMmbc1xw7dowff/zxBf+VSNLzFRYWxpkzZ3C/fh6AA1pXNE/TreIJPDw8EEJQuX1XYgxOiJQUbi+cQeHChXnw4AFyOhdJevXIoFX6zztw4ABnzpyhYcOG7N+/H0dHR7y8vJ66nEuXLhETE5PhsU6dOvHLL79QunRpwsLCAKhduzYPHjyQ3/pKz9SYMWMwmUx8MHAgiqKgKEq6wFWrBpLWgKprj94EFS5CoUKF7fZrFTh++CDJyUlE3bn9sAXW2oJoCxY1Cty8ehmNRuHQ3p1qS601+H3Y4qg8am2tVr0mgYUK89aAD9R9j9sGfjKUhs1aUKhwYfXcti1t2joNGpK/QEG69+n3MKh91GKs1z5qEXbQarh55TxGg5GzRw5Yx8Q6GMjrn4fiJUvh55sTH28vAvLm5dr5cB7cvYMmOdFuvKpRp+HN0O6UKlcBf/+8dsG+VvNonPCjMcNQtmw5WrZuy+jRo0lISHjRfyqS9FwIIUhISMAQeRtL1F0sKNz3KfDU5aSkpHD+/HmSk5MzPN6pUyd27NzJSoMvADdmTaFBxXJYLBYuX778j65BkqTnT45plf7z7t27h7OzMy4uLvz11194eno+VX6LxcKgQYOIiIjg8uXLLF++HG9vb7s0Xl5eNGnShF9//RUhBGXLlsXd3R29Xs/Bgwfp3r17dl6SJAFw8eJFfvrpJ4YOHYari4s6W7CiKGiEwPJwnKV15mCBRgELENLqdZq3bKWmF2Ad64rCxO9mcPPmTQLyF0AI6zI5YC0DrMFY5WrV8fLyJk/eAB5OHGz3DanycFyrRgE3FxODPxuW6TWknsBXo0Bw9RoEV6+Rpev39vRkyNCRgPWDslYBCwrmh+NaNYqCEAoaRVCvUVMC8hcgT0BBNHpthuNZAcbNmENiQiy+ObzV/bYxq63ebI9WsR+/qijWLtfKw1Zm5WEe2+PBH39McMXy/PDDD/Tv3z9L1yVJr7ILFy5gMBho7OsGd+C8xpGyVas9VRl3796lS5cu+Pv7c/PmTZYsWaL+X7Fp0qQJa9eu5bzBk9Z5degvhxO4ZyXx8fEcOnSIgICA7LwsSZKeMdnSKv2n3b59m4SEBBo1agTAzp07KVq06GPzxMXFqV16hRAMHjyYwoUL8+uvvzJlyhQ+/PDDDPP17t2bpk2bsnHjRqKjowEoX748R48ezcYrkqRHRo8ejcFgICLiOuaUZLU7sDWYsra4PrG7sK0V9mEroYvJRGDBgmoLbNqWU61izVO4SBFMzk6pWhetm06bqnVUUZ68peoCnKX0aTbbWFLreW37HnXX1T5seTXqtBQvXgKTkwMOurQzI2vVfTm8PAnwz4tB+2jMqu1abNevz6Rl9dHzYH2sAIWCCvFGu/Z88cUXsrVV+k/Yu3cvDx48oKiIAyAsxUDx4sUfm+f69etEREQA1ntwp06dGDVqFN9//z01atRg1qxZ6fLo9Xq+//57FI2Gn2MdrHn3bKGgJpkDBw5k70VJkvTMyaBV+k/bv38/d+/epX379pjNZu7du0fJkiUzTX///n2aNGnCZ599xuDBg+nZsye5cuWid+/egDUITU5O5sqVKxnm7927N87Ozrz11ltER0dTtWpVIiMjMZvNz+T6pP+uW7duMWfOHIYMHkzVqlVp27Yt169dRYFUwWn67sK2bsC2oNQueE09HlUN0lJNMvQwOLRtqbvuZhZMPm5T1EDvyekU5TFp0gTBqbs7q2NNU3Udtk2ilHozPpxYyjpW9VFXZL368+FzolWeGKxaW2Gt+xQFBg0azM2bN9WJ2iTp3+yvv/5Ch8BybB8A54weFCtWLNP027Zto2fPnnTu3JmJEyfSqlUrPvroI8qWLQtAv379mDdvXqbjVD/88EPOJmu45xcIQCuTmb1792bzVUmS9KzJoFX6T1u/fj2FCxfG1dWVY8eOodfrqVYt825KK1eupFWrVixZsoRWrVrRs2dPBg4caJemd+/e/PDDDxnmd3Nzo3z58gQHB9OwYUMKFiyIVqtl37592XpdkjRjxgy0Wi09unejzeutmPj11/Tt25fVq1YCZNjqqigZt7raWkk1doFn+iD2cZstqNQoj1oZM0z3sG52gfITW1QflWmfP4O6ZhK8pm59fRTE2mY5tu4zaJVUwSoPA9W0QemTg1XlYX00D+sYGBREg4YNmTJlipwgRvrX27JlC+81q49ITiJFZ+CyWfvYHk4//PADEyZM4Pfff6dEiRJMnTrVbpko2337zz//zDB/3bp1URSFS0EVAMgfe5s7t25mOhZWkqSXkwxapf+slJQUFi1axOeffw5Yv/1NTk6mTJkymeYZP34806ZNU1tJq1atmi5NzZo12bVrV6Y3xJ49exIeHs7YsWP57bffMBgMrFu3jsjISPmBVcoWSUlJTJ06lQ7t2uHp4Q5AwQL5WbJ4Mdu2beOjIYNJTkrENgLscd2FtRnM+ps6kLVrOVV47GYLJFO3Mqbd1HJTbY9rRU0XVKfJZzuerhU5VfBq6zqcOli1BaW2YDZ1q7I+1TnUFuWH5WmyEKxqH7ZwW+tl3deoYUPCwsLYvn37C/mbkaTn4dKlS9y+fZsSiXcBuKgz4Z0zJ1qtNsP0SUlJrFu3jhEjRuDk5ESDBg0oWLBgunS9evXK9MtiRVFo1qwZOarXI0WrR5uSRGm9mT179hAZGZlt1yZJ0rMlg1bpP2vYsGHkyJFDDVL/+usvPDw80Ov1GaY/e/YsEREReHp60rNnT6KiooiPj0+XTlEUWrRowYoVKzIsp3Tp0pw9e5ZixYoRFhZG4cKFWbNmDeXKlWPDhg3Zdn3Sf9eqVauIiIigz1s9QVjUzWjQM2H8eGrXqkXr1q05f+7sE7sL24K9jFtA0waR6QPOtMFk2hZX26bJZEsb8KZtlU2d31ZuhuVo0rciP67bctpuzk8cV6tJHZCmn3QpdbCqSXX84P59tG/3JqdPnyZ//vxMnz79Bf3VSNKzlZSURO/evalQoQLRu7cAsDNR/9h10UeNGkWOHDmIiopiwoQJxMfHZ/iFsL+/P0lJSdy8eTPDckJDQ5nx40+41mgAQCFzNNOmTSMoKIi7d+9mw9VJkvSsydmDpf+k9evXExUVRe7cudUZBy9dukSdOnUyzbNw4UJ8fHy4dOkSQ4cOpVu3biQlJVGsWDHGjh1rt8ZcaGgo7dq1o3Xr1ulmNAQYPnw4gwYNom7duhQsWJBu3bpRp04dxo8fT/369TPMI0lZNXfuXMqWKU0J2+QmwgKKxvoTaNqkMaVLl6Zfv360a9+etm+8qQZyYJ1h1za7sI021d9kZh0CFNIfENYDqdJYaTL4G089Y2/q45m9HWx1smVLO+NvWrbZkVPPmKy1la2g1l7L073/Ul+T2vX34e9ga71W1OdXAc6En2bMmDF4e3szZdIkcuXyZbyvD2PHjScmJgaTyfRUdZCkl92wYcOoX78+CbciSNq8G4CTOhdaBgdnmmfdunU4OztjNBpxcHCgc+fOREZG0r17dzp06GCXtkePHkydOpURI0akK8fLy4vXXnuN0/ev4A+8ltuL4YsX06tXL7766ivGjRuXrdcqvbzMZrPsGv4S0ev1mfa0SEsGrdJ/0rfffsvXX3/N2LFjAbhy5QpxcXG0aNEi0zwbN25Ep9PRt29fAJYuXQrA7Nmz6d27NzNmzFADVzc3N5o2bcrEiRPTjXkFqFixIlqtloIFC7Jnzx5u3brFihUrGDZsGBcvXiR//vzZfcnSf8T9+/dZuXIlo4cPRXkYpApbwJrqZ57cfixevJjRo0czeNCHjBs3DkXRILAFd9bANUMZxHS2YDC1tNmty+pY06QNRIWwD/RsMloq51EeodYn9fkzq7YtSBWZ1PdxeZ8ko9ZVW7AKj44lxMfxxRdfcPXqVUYMG0qBAgXUlvA32rZm6PARLF++nE6dOv29ikjSSygyMpJjx47Rvn17TDHW1tAETx9u3kwk+DFB66VLlyhXrhxarZauXbvSr18/LBYLb731FklJSXTt2lVN26BBA37++Wf27NlD5cqV05X13nvv0breawwFtNcvcPPCWYaOHc+6detk0PofIITgxo0bskv4S8jd3R1fX98nNtjIoFX6zzl8+DABAQFERESokz/YxrNWrFgx03ynTp2ibNmytG7dmu+++46GDRsC0KVLF4B0ges777zD0KFDCQkJ4euvvyYwMNCuvP79+zNjxgzOnTuH0WjkjTfeYMqUKWzbtk0GrdLftnTpUlJSUmj7ekt1nyIsjwLXVHRaDcOHD2fOnDn07duX7777Do1WZxe4ZsWSxYs5fDiMocOGo9Pp7IJJANtZUweJacemWJT0+1LfwDQZVUVR1HVctTwKYi2ZVFvzsEKpW1jTxaip8i5fspgjhw/zydBh6HSPbpeWNJlSt6CmDVhtwSrAoYMH+Oyzz3h3wAAaN2po13UbIJ9/HqoHV2PevHkyaJX+VWbOnEn37t05dOgQIQ+XujmdrKN48eIYDIYM88TGxpKcnEzt2rUxmUxs3LiRli1botFomD59On369AFQA1dFUfj+++/p378/7u7ufPXVV3Y9FnQ6HbVDXidxySWMCTFYToYxceJEfH19SU5OznRokPTvYAtYc+bMiZOTk+zR9hIQQhAXF8etW7cAyJUr12PT/6OgNTo62m7iGI1GI7s0SS+9ZcuW0alTJ8LCwihSpAhg/aBfs2bNTP+JpaSkkJiYSMmSJSlcuDCnT58mMTERg8FAZGQkXbp0QVEUGjduTIECBWjXrh21atVi1KhRXLp0idDQUFasWIG7u7taZunSpTl//jweHh7cunWLnDlzUr16dbZs2WL37bEkPY0//viDKpUrkcvXFywPw0WNJvNWV6Bzp47o9Hr69evHd999h6KxdtXJMFDMwA/Tv8dgMHLh/DkKFy6sNqNmFFCmpiiKuj91q2Tacz+uGraWU3gUZKdtIbYFzY+662btwn7+YQZ6g57LFy9QMDDI7pwZeVzA+vuK5SxcuJBf587B09PTLli1vTZYLLRs1pRPho0gNjYWZ2fnLNVTkl52GzduZMWKFcyfP583DbdJAPbdiqTHZz0yzfP777/j5uZGmTJlKFOmDAMGDKBly5YkJSWRlJTEtGnT6NOnDxs2bCB37tz06dOHAgUKMG/ePLZu3Urnzp1ZtmyZXZndunVj2bLplCKG20t+xqNOM3LlysWuXbuoWbPmM34WpBfFbDarAauXl9eLro6UiqOjI4D6OfhxXYWfaiKmsLAwmjRpoj728/PDw8ND3dzd3eXSHdJL79ChQ5QrV45Tp06pLa379u1Tu/3a7Nq1i8qVK3PkyBGWLFmCt7e32n2hVatWTJkyhQ4dOtCmTRvGjRtHaGgov/76K4MHD2b06NFER0cDEBAQwKeffsrXX3+dri41a9YkICCATZs2AdCwYUMOHTr0jJ8B6d8qMTGRjRs30rh+PftWVYtFDWDVACnNz/ZvvkHtWrXo06cPFnOKNe1jttiYGLZt2cwP06dRqlQpcuXy5dSJ4+nWgn00EZKiTvRk2wC7x6nT28pACPbs3sVHQwbzequWtG3TmjfatqFVyxB69ezB7yuWYzGb0y3hk/ocmjRbhrMWZ7CNmzCBnj17ERQUZDepVGZb2i7BNlu3bGbx4sXM/WW2dTbnhwGr8nBL/fo0blCXpKQk9X+CJL3qEhMT0el06HQ64mJjSbp0BoDj0UnUrl3bLu3YsWNp37499+/fZ/78+fj7+5MrVy58fHzQaDQsWrSIJk2a0KJFCzZv3sz06dOZOHEib775Ju+//75aTu3atSlUqBBbt261K9/d3Z3dTn4ARO/ZStKNq5QuXZrVq1c/0+dAerFsY1idnJxecE2kjNhelyeNNX6qoPXbb7+levXqdvvmzJnD5s2b2bRpEx06dOCbb755yqpK0vOTkpKCxWLBYDBw4cIF8uXLx/3790lISKBkyZJ2aRcsWMC4ceMYOHAgX3zxBfXq1VO7LnTo0IFLly7x+eefs2nTJi5evMjmzZvx8vIif/78dOvWjfnz56tl1a9fn3379hEXF2d3jjp16pCQkMD69esBqFChAnfu3HnGz4L0b/Xnn38SGxtLo/p1rTtSteYBdoHrxMnfUDW4OgcOHnwUuLZvT7OmTWnevDkN6tdj0sSv1RZPjQIR16/x808/0u7NN3irdy+OHj1Kgfz5ad++PT26dyc2JobRI0fSqmUI30/9jgeR9+0CXVtQKSxmfpj+PWGHDmQYqCpY0yxdsphWLUNYu2YN3bp2ZfmyZSxdsoQlixfz+4oVjP3yS65evUpIi+b88fsKECJdsGwLXiMjI/lmymSuXr1qF8A+Wkc2/Va6dBlatnodnUaTKn3GQe/+fXtp3rgR27ZuUZ8vBTh39gyTJ0/mzu3btG7TxtqybAtWU70mtteqYIECBBYsID9ES/8aBw8epFy5cqSkpOBBCpb4OAQKxgJF0rWqbN68md69e/Ppp5+yc+dOAgIC8PX1BeDdd9/l8OHDLFy4kDVr1jB27Fju3LmDj48P5cuXJ0eOHJw9e1Yta/DgwUyZMiVdffLVqk+MowsAR5uXplkBa0ur9O8nuwS/nLL6ujxV9+CdO3fSr18/u31VqlSxTiSBtYn3jTfeeJoiJem5Onr0qBqcms1mdDodP//8M2XKlLF701gsFk6cOMHkyZNp06YNn3zyCfny5VODVjc3N7777js1/bhx42jZsiXh4eEsWrSIvHnzEhERQe/evQHrG/L111/n999/p127dmq+8uXLM3LkSFJSUhBC4Orqik6n49q1a+TOnft5PCXSv8jGjRvJ5etDiWJFHnUBhkeBq6KxBkkaDVFRkWi0WhJsyzY9TNMypAU+Pj506NiRKVOmcObMGWJjY4mOjiZnzpw0adKEWTNnWruuphkjWz24GqGhoSQnJ7Nq1SreeustPD09GTJkCAH58qtdZffv28eG9etZ+cdKVq5aZVdGSnISs2fPZtmyZTRr1owF8+enOpewmykpZw5v+vfrR88ePZg0aRJz587liy++ULvy2sbmAiyc/yv79u7l5o0bfDH2K7WMrHaBTj1+NqMJqo4eDsPBwcj+/fupU6eOOunS+++/z/ff/Y8u3bphNputAautQ7MlTav3w98b1H2NtXL5K+lfYseOHQQHB3Px4kXKeDjBTbiHjk7dutulO336NEFBQbz22mtMmDCB/PnzExUVhbe3N2D9vJl6eZzx48cTGhpKcHAwW7ZsoXz58syYMUOdVMnLywsnJyciIiLsxsrVrVuXjWeOUfvYBoyWFAL/XEz0NblGuiS97J6qpfXSpUvkyJFDfTxy5Ej1nwlYB9BmtkYWWIMESXqRdu/eTdWqVYmJiVHHiy1btoz27dvbpdu3bx+VKlVCURTu3LnDwIEDuXnzZqaDxE0mEwsXLiQqKoo//viDyMhIihQpwv79+9U0bdu25bfffrPLp9PpcHBwIDAwkFOnTgHg7e3N2rVrs/Oypf+InTt3UrVSxUdfwKRtaU3Vujfi04/ZsOp3gqtVTddVuGqVyqxds4Yjhw8zfNgwpn3/PSuWL+eHGTNo1bIlzk6O9nnSbHqdlpYhLVj022988P77fPLJJwz9/DMi799Do0CF8uWoWKkSg4cMUVtEr165zPhxX9GqVSscHRz4fcUK3nn77Ufneszm6GDkk08+YeLEiXz88cfMmD4Ni8XyqIsx0KZNG4KCgujZq5ddSyxk3P1Zq4Awp5CUmJiupTijVtkePXvx+bDhfPDBBw+7NVt4++23GfzhQPL652Hd6lWs/mM5mswC1lSvVdVKFTl//rw6OYUkvcr27t1L5cqVOXnyJEU1SQCcjktJt2TNkiVLaN26NYmJiWg0GqZMmYIQwm45udTKli3L6NGjyZMnD+vWrePEiRMcPnyYxMRENU379u3tej0BlCtXjp23ohjjXhqHgkUhOpLXHRK4ePFi9l64JL3EateuzXvvvZfltLZ7XVhYWJbPMWvWLDVfVs/1OE8VtDo4OHDp0iX18fvvv4+rq6v6+MqVK4/tL547d24++ugjwsPD/0ZVJemfO3bsGKVKlSI8PNw6YQxw9uxZWrVqZZfOdvOcN28e9+/f5+OPP073bW1aXl5eDBkyBCcnJ8qUKUNwcDDffvstKSnW8YEeHh64uLjYdV8CqFGjBj4+Pmx42LKSL18+2TVQempJSUns37+fKpUqoAiBkro1MHXwahtPqSg4OzpmOsa1cKEgPNzdyJUr16MJ9jIoJ500aQoXLsyC+fNp2KAB/fr1o2XLlrz99tvcunmTJYsX8cYbbxASEsL4ceOoUL48K//4g86dO6PXadPNrpsuYE1T77z+/iz67TcU4PVWLdm9ayfiYZdhHx8fRo4cSVBgYLoA1UajwInjx+jzVm9atmxJhw4dCO3ciXZvvsH6dWtTrceavoVWp9VQvlw59DodCoIhQ4ZQu1YtatWqBYBBr8Oof9i5KaOA9SFFCKpWqgAguyxK/wqxsbG4uLhw6tQpvFKsQ2SOp+jSzdb7559/UrNmTfr160efPn2oVq3aE8suX748Xbt2VWf3DgkJYe7cueoEbw0bNmTVqlV2jSY6nQ6j0UiBwkVIqdEUgDIOFtasWZMt1ytJr4KlS5cyatSoLKfv1asXERERlChRQt13+fJlmjZtipOTEzlz5mTQoEHqZ16AN998k4iICKpWrZotdX6qoLVs2bIsX7480+NLly6lbNmymR5/5513WLx4MUWLFqVGjRrMmjUr3Rg/SXqWLl++jL+/P0ePHqVYsWKcP38eo9Fo9+WLEIJDhw7h6+vL3LlzGTt2LIqiEB0dneXZsStVqsSNGzcoX748jRs3VteD/fDDDxk/frxd2jp16nD37l11wohSpUpx6tQpdSInScqKI0eOkJCQQJUKFdR9TwxeASyWTANXuzwZtdhm1vqZQZqaNWsy/9dfWb5sGeMfjhX/+KOPmP/rr/y+YgX/+9//qFevnjUYzKQM6zWlqW+aTaNAnz59+Pmnn1i1ahUtQ1ow7fupXL1yOcOuwKnH2Y4bN47x48fz6SefsGL5chb99huLFy1i9qxZrFixgmnfT7ULdDMejyv4/PPPyZcvH926drGbdMn2fGf2XNteK//cucntl4udO3emr7AkvUJss+wDHDt6FMPNKwCk+AfZpbtw4QL+/v6sWbMGb29vmjZtSkpKit1SU09SpEgRKlWqxNGjR6lfvz6rV69Gr9fTokULFi9ebJe2Ro0a5MyZk533EwDwIZnf5vzyTy5Vkl4KSUlJWUrn6emJi4tLlst1cnLC19dXfU+azWaaNm1KUlISO3fuZPbs2cyaNYuhQ4eqeRwdHfH19c10Waun9VRB69tvv83kyZP57rvvsFge3WjNZjPffvst3377bboZWFP7/PPPOXv2LJs2baJAgQL069ePXLly0atXL/bs2fP3r0KSssjW1WjDhg3UqVOHsWPHqi2uNrt27aJMmTIsW7bM7hvc1LORPknFihXZu3cvAwYMYP369YSHh3Pq1ClKliyJoijMmjVLTVuiRAnCw8NJSkoiNjaWnTt3cu/ePUJDQzNcJkSSMnLkyBEURaFU8SLpgswMg9fUPzMLXLMQlNqCSCXV+R4X/CoIPD3cyZvHGpjptJrMW1QzOM+ja3pMsC0s5PD24osxY1iyeDF5/f0ZO3YsLVq04J23+zJr5s8c2L+PmzciiIqKYtmyZbRq1QqfnDmZPWsW+QLy2tXJydGB76dO5f79+3wxZrT1/KRvrb175zadO3fGP08e+r3dN8sBa7rXByhTsgRHjx5Fkl5ltl5NFouFhIgrWKLuYRZQPqStXbq5c+fSunVrZs+ezcCBA4FHS2BkVaVKlTh27BiTJ09m9erVfP3115jNZnr27MmMGTPsZua3fVm8avcBtK7u1onWLp1O15VYkl602rVr069fP/r164ebmxve3t58/vnn6ufDfPnyMWrUKEJDQ3F1dVXnUlmyZAnFixfHaDSSL1++dCtYpO0ePHXqVIKCgnBwcMDHx4c2bdo8tl7r16/nxIkTzJ07lzJlytC4cWNGjRrFd999l+XA+Wk9VdDaunVrPvjgA/r374+Hhwdly5albNmyeHp68t577/Huu+8+8SLB+kTNnj2bGzdu8PXXX3Py5EmqVq1K8eLFmThx4t++GEl6nNu3b+Pt7U1KSgr37t0jLCyMq1ev0rhxYzVNYmIin3/+OUOGDGH+/Pl/+wbm7e3NvXv3AGuw27t3b6ZPnw5Y/zHs2bOHuXPnAtb1jd3d3enevTstW7bE19eXqlWrcvfuXVasWCHHgksZmj9/PsHBwbi7u9OqVStOnDhBQF5/dc0zIF0waBccPSlwzajrb+pywT5QTfs4q2VlUte0rau2OtptqY9lEvAaDXqaN2/O91On8sfvv/PZp5+Sw9ubDevXM2b0aAYMGMCtmzeZPWsWXbt2fTRJUhqKovDZp58SFxfHr/Pm2s2qfCPiOl9+MYZu3boxeNAg+rzVO/11PyZgzeh5KBwUyMmTJ5k2bRo5c+akYMGCDB482G68niS97E6cOEGxYsU4ePAg1f19AIjWGQmu/Zqa5vTp0xw4cIDXXnuNQ4cOsWjRIoAnDslJq3LlyuzduxcAg8FAvXr1WLNmDc7OzixatIghQ4Zw4sQJwPpl8enTpylVujTH4qzvxXZBfkyaNIlz585ly7VLLzchBOb42Oe+/Z3GiNmzZ6PT6di7dy9Tpkxh4sSJ/Pjjj+rxCRMmULp0aQ4dOsTnn3/OgQMHeOONN2jXrh1Hjx5l+PDhfP7553YNJqnt37+fAQMGMHLkSE6fPs3atWufuG7xrl27KFmyJD4+Puq+hg0b8uDBA44fP/7U15gVTzV7MMBXX1knypg/fz5nzljX2qpZsybt27e3m9UtK0wmEz179qRnz56sWrWK0NBQBg0axAcffPC01ZKkJzp58iTFihVj9+7d+Pr6MmPGDOrUqUOxYsUA67ibTp06MXjwYJydnbl58yYxMTFERETg7u6Og4PDU53P3d2d+/fv4+LiwptvvkmOHDmIj4/H0dGR//3vfzRr1oyGDRuSI0cOdZB769atad26NR06dMDBwYHQ0FDmzZtH8+bNn8VTIr2iDh48SKdOnahTpw4DBgxg1KhRlChRgiJBgekDxAxmEFaEQCiKdZ+iefTTYnmU3LY/E2kD1tT7hZLB96FZDVwzO4clg/wPZ0JWz5nqGjP8HciT2488efLQokWLx58/o/oqGkaPGkXvt95i2bJluLu7c+fOHby9vQnt3JlPP/7I2hsjbcCdlYA1zfmKFAri4sXvef/992natCk5c+Zk8uTJODo6MmLEiPR1k6SX0IkTJ2jevDmrVq0i4MZ5AG4ZTFR/2MMpPDycvn37Mnv2bHbs2IFWq2XZsmX06dPnqYPWvHnzqvOuhIWFMW3aNIoXL06zZs3w9PRk7ty5dOnShTVr1qDRaHBzc+Pdd99lzYPrsPt3AuPv4uHuR8mSJbl+/Tru7u7Z/nxILw9LQhxhNfyf+3nLbL+C1tH5qfL4+/szadIkFEWhcOHCHD16lEmTJtGrVy/A2nPA1kMBoGPHjtStW5fPP/8cgEKFCnHixAnGjx9P165d05V/+fJlnJ2dadasGS4uLgQEBDx2uCfAjRs37AJWQH1848aNp7q+rHqqllabKlWqMGXKFFavXs3q1auZMmXKUwesAHFxccyaNYtatWrRokULvLy8GDNmzN+pkiQ90fHjxylevDiTJ08mIiKCadOmceXKFQIDAwEYNGgQffr0oWHDhmzZsgW9Xs/YsWOZPXs2ly9fJk+ePE91vooVK7Jv3z62bNlC9+7diYmJYd68eQBotVp69erFwoULAes/nE2bNtGnTx+EEOzYsYMDBw4QFBQkuytJdlJSUujduzclSpRg9erVjBw5km7dunHixAn8c2fwAS+T8aiPa3G1Hs9iwJqm5dPueEbdijOrX2Zdfy2WdGuZ2qVPVd8MW4ozOv/juj2nfi4yqKtWq+WnH39k8aJFTBg/nhXLl/PzTz9Ru1bNbAtYERYKFcwPgIuLCzNnzmTq1Kl89NFHfPnll2prkSS97E6ePImfnx9btmzB/W4EAOe1JoxGI4mJibz99tvMnTsXf39/lixZQoECBShbtiz79+9/6vuuoigYjUbi4+NZsGAB48eP5/jx42ogmzNnTgoUKMDJkycBa6+/nTt3EjrheywGB1zNidS4fIASgQVYsWJF9j8ZkvQ3ValSxW54WtWqVTlz5ozaE69CqrkswPq+Cw4OttsXHBxslye1+vXrExAQQIECBejcuTPz5s17Kecceqqgddy4ccTb1vTDuvZW6q5K0dHRvP32208sZ+fOnfTs2ZNcuXLxzjvvkC9fPrZs2UJ4eDgfffTR01RJkrLsxIkTXLlyhdy5c+Pu7o63tzeXLl0iICBAnfCkYcOGgHVSsfz58/Paa6+xa9cu9u7dS8WKFZ/qfJUqVWLv3r389ttvhIaG0qNHD/73v/+pM6s1bdqUVQ/XqAwMDFR7Lrz77rtUqVKF3Llz07RpU86ePSu7BEqq/fv3c+DAASZOnKjOvvnll19isVi4FnHj8YFYZoHTYwLXjDZV2tbPjALX1B4TKKYrP00gnGEgmUHaTCdqyuj8GXnS/od5NQp4erhbuxNnUG6WAtbHvEa2/xPdu3dXJ8v45JNP8PLy4qeffsq4jpL0komNjeXLL7+kRvXq+Gmsf9NXjW6AtUvjW2+9hZ+fH2D9bBgSEkKTJk3YvHkze/fuTfdh/EnKli3LoUOHOHDgAG3btiV//vxMmDBBPd6pUyd1aE7dunXZvHkzSSgcsliHVTQ2CcY53Gbzb7/+42uXXm4aByfKbL/y3DeNQ+arrPxdtiUc/y4XFxcOHjzI/PnzyZUrF0OHDqV06dJERkZmmsfX1zfdMqe2x76+vv+oPpl5qqD1448/tpvRtHHjxly7dk19HBcXp47by8i4ceMoWrQo1atX5+jRo4wfP54bN24we/bsJ/adlqR/6vjx42ow2q5dO8A6iZhOp+Prr79WZzwTQnDgwAGaNm2K0WjEbDbz119/PfWU3WXLllW/rcqfPz/t27fH3d2dTp06ceXKFYxGI35+fly+fFnt8vHzzz9jMBiYPn063t7euLi44OnpyebNm7P9+ZBeTbZvW1NPUGK7Yb0R0ix9hsxaEbMSuGbUJdfmccdsdX1M0PvYQDhtsPq4oDNtq2sGAXe6vGnLziyQzehcWTie5YA1o2t8+LhSudIAdhPFOTg44Orqmum6lZL0MklKSuLWrVsYDAaunTiCNjkRFA2agEBiY2PZtm2bOg/KuXPnMJvN1KlTR53I8NatW+m6Hz5JpUqVeOutt2jVqhWKotC9e3dOnTrF6NGjiYmJoUqVKuzbtw+wfll88uRJpkyZglP7t7mbvySJKLhYkmlw+6Scwf9fTlEUtI7Oz33L6oSeqaWdrHb37t0EBQWh1WozTF+0aFF27Nhht2/Hjh0UKlQo0zw6nY569eoxbtw4jhw5wsWLFx/72bNq1aocPXrUbj3xDRs24Orqqg67y25PdedLO3j4aQcTjx8/nkaNGnHkyBH27NlD79697aZbvn37tuwKKT0TFouFY8eO8dNPP3Hw4EGqVatGSkoKWq2WEydO4O3trX4zZOt6V6dOHcC6BM3WrVsJCAh4qnPaxp7ZBr7nyZMHT09P2rZty3vvvcfo0aPtWlu/+OILJk2axIABAyhYsCCJiYnExMSQkpIi122VVLax1QkJCeo+2/gRX5+cT9XS+sTAFdJPfpSVYPYJadK1wqbNk9Uuu5ldXwbdldNNEvWkVtfHtbg+5rn9WwFrBuUYjUY83N3TfZOdkJDw1OPrJelF2LVrF3fu3OGrr77CM9L6wdbsk4f8hYowc+ZMevTooX6AX7VqFTqdjkKFCuHk5MSDBw/w8PB46nNWr16d0aNHq73+QkJCsFgs5MuXj5CQENasWUOhQoUIDw9HURQmTpzIDz/8QJu33sHtw3HMcCoIQKAlls1r5X1XejlcvnyZDz74gNOnrTNcf/vtt7z77ruZph84cCCbNm1i1KhRhIeHM3v2bP73v//x4YcfZph+5cqVfPPNN4SFhXHp0iV++eUXLBZLutU1UmvQoAHFihWjc+fOHD58mHXr1vHZZ5/xzjvvYDQa//E1Z+SpJ2L6J65fv45er2fkyJEsXbo03fFz586xdOlS2rdv/zyrJf0HzJgxg4CAAPz9/blz5w45cuTgwoUL5M2bl/nz59OtWzc17erVq9HpdOqbNTg4mBMnTvytb8feeOMNu8eTJk2ia9eufPbZZ6xfvx6LxcKGDRvo27cvJpOJw4cPq60oLi4unDhxAqPRyOnTpxFC/K06SP8uGQWtd+/eBcDb0z39REi2oCj1hEypJ196+DPTyZmeJHXQlTZ9FlpjMy0ro8c8CvyE7b2Q0fXZHqc+/8MJm+yKz+h5ymrd0tUrVcCcOv3TBKxpfvfy9FBfWxsZtEqvCtt4+1u3blFRiQXgrrc/QUFBzJgxg+XLl6tp165dS5EiRdR7XMmSJcmfP/9Tn9PZ2ZmQkBD1sZubG/3792fBggVMnjyZQYMG0a1bN1auXMkHH3xAqVKlCA8PR6PRWH9P1pJkdMSQGM/JhbMIafvmP3sSJCkbhIaGEh8fT6VKldBqtbz77rvq0jYZKVeuHL/99htDhw5l1KhR5MqVi5EjR2Y4CRNYJw5dunQpw4cPJyEhQZ1PpXjx4pmeQ6vVsnLlSvr27UvVqlVxdnamS5cujBw58p9ebqaea9BqG3+1bNkyu/1ms5krV67w4MEDRo8e/TyrJP1HzJs3j2bNmhEVFYWrqysAZ8+eJTAwkFWrVtnNxrlp0yaCgoLUm2f16tXV8WX/VEBAAHPmzGHcuHG4u7szbdo03Nzc1PXoUnf7K1SoEEePHqVcuXLcunWLZcuWUbduXVxdXWXw+h+WUdBq+93RwfrtZurgTGQUzGUSuD7KlGr/00gbQD5tvkwep1sWhscEr7bzp62LLZhM9R57bBCbBRm2GKeuS1Zash/Tmuzo4GD3OoMMWqVXQ3x8PFeuXKFx48bs27OH/LG3ATihd6OCuzseHh7qZ8LY2Fju3Lljt2Ri27Zts2323pYtW5I3b14+/vhjmjZtyrZt2zh79izvv/8+iqKo911HR0ccnZwIN+amxK2z+Fw7zenTp/H19cXNzS1b6iJJf4der2fy5Ml8//336Y5dvHgxwzy21Sgyk5iYiMlkAqyfc7du3frU9QoICHiuPQGfemDMjz/+yDfffMM333xDSkoKs2bNUh+nXjPocQ4dOmS3HTlyhNu3b9O3b99ntraP9N91//59YmJiKFeuHAcOHKB8+fKAdW04V1dXAgIC1JtWZGQkFy5coEuXLmr+TZs28e6777Jv3z5u375tV+7Bgwefuj558uThm2++ISIigsDAQOrXr8/w4cPTpQsKCsJisVC3bl0KFizInj17CA0NZfDgwU99Tunf43FBq4PBkC592q6x8XFx1vQZBFCKEAghiIyKynLAGhX1AEvaFtWMut+m2oTFTGTk/cd3YSbNurIPpaSkEB0dky5Nutl4MxjLGh8fT0JcXKZdmDMbgxt57x5YzFkahxsfF2v3/KYNWIXFbH1+U+1L+7utfAejQQat0itpw4YNODk5UbRoUc6vW442JQnF6MCee3EcP37cbhm3devWER0dTbNmj8bkz507lz59+nDlyhViY2PV/WfOnFFnA34a5cqVY9GiRSxfvpyLFy9SvXp1lixZki6dm5sbfyZZ318lRBxjRwyjWbNmcoiO9K+RmJjI/v371RU1smrq1KmYTCaOHj2a5Tzz5s3DZDKxffv2v1PVdJ4qaM2bNy8//PADkyZNYtKkSfj6+jJnzhz18Y8//kjevHn/VkV0Oh3vvfdeht2GJemfWLlyJRaLhTp16nDw4EE1aD158iQRERE0atRITfvRRx/h5+enziIM1p4BK1eupH///lSrVo1Tp05x69YtmjVrxsiRIzO88WXF0KFDuXz5Mvv378fHx4cGDRowaNAgtVU3MDAQPz8/7ty5w+7du/nqq69YsWIFCQkJ2fYPQHr1PC5oNRoNmY7TVISFlJQUGrXpSKPWHayBZgZB0yfDRtKiTXv+2rX78WM+gcNHj9K8zZsMGPh0X6R8OmwkLdq0Y/uOXY/O/bhgNVU9OvZ4i8avv0FERETW82ENdhu3aEXjkNftg+wnjMHdsHETLV5vw+gvv0p/ME2+lOQkGoe0plFIaywWS4YtrB+PGEPzNzuzY9eeTK790e/7Dh22+zLYYrGQlJQkg1bppbdgwQJ8fHxwdnKi+KGNALhVb0BcYhLbt2+nQYMGgPV9+cknn/DOO++ok8tZLBbOnj1L//79ad++PW3atCEmJoaVK1cyZMgQunXrRnh4+FPXydHRkV69euHm5kbevHlZunQpdevW5ZdfflHTFChQgFsOrphdPdGkJDGh0+ts2LCBCRMmEBMT85jSJenVsGbNGurUqUOLFi3sejc8zrx58zhx4gRhYWGPHeeaVosWLQgLC+P06dN89tlnf7fKqqcKWi9evMiFCxeeuP1dly5d+ltjGCTpcRYvXkz58uVxdnbm2LFjlCxZEoArV65w5swZdY3hpUuXsmbNGrvu64mJidy+fZu4uDjOnDnD2LFjqVChAsuXL6d///4sWrSITZs28dZbb7Fx48Z0516/fn2mE5b5+/uTK1cuzp8/zzvvvMP69evJnTu3Oh1/wYIFyZEjB3PmzCFv3rzqTfr999+3u8lK/y22LnVJSUnqvky7i6cJiLQKuLq64OaWpot5qqDKJ2dOUlJScHnYbShdWak2Z0dHhMWCT84cmbesZsAnZw5SUpJxdXHOctBp4+3liV6vswbomaTLqByNAi6uLri7udkvU5NaBhNOubq4kJKSgk8O78wno3pYlkajwdXVBXc310c31zQt2tZrT8HFlPbaM5gsKo3k5GTg0d+AJL2MhBAcOnSIvqEdOTewI17meBS9gVzvjUav1xMVFaVOstSvXz9MJhP9+vVT8+/atYvChQujKAo3b97EYDBQtWpVFixYwPfff8/cuXN59913GTVqVLo1i2P/z95Zh0dxtW38NyvZjSeQhAgkhAT34O5WoEjx4tLitBSKFopDaXGKFneKO8GhuKQQJBAIIe6e9Z3vjyULgQRCX9ryfm/uXlzNzpwz58wZOXOf53nuJyODS5cu5dq3zp07ExUVxY4dO9i6dSsnTpzg0KFDPHv2DDDNu40aN+aJtYlAR6yYjUImpUePHhw6dOhjD1U+8vFenDt3jkWLFn2047Vv357U1FS2bNmS57nEw8MDX19ffH19scjBoys32Nramus5OTn91S6bIYgfIAH82WefsX37drNv/9y5cxk8eLA57iAhIYF69eq9N/H5kiVL3toWExPDunXraNu2LeXKlTNvHzlyZF67968hNTUVe3v7bPGS+fg0EBgYSIMGDbh8+TIlS5akTZs2HD58GIA2bdpgNBo5evQoer2eevXqUbp0adatWweYhCEWL16Mm5sbBw4cwMfHh+fPnxMXF0fRokWZPHkyiYmJdOzY0ZzMPCEhwRxzEBQURNOmTZkwYUKu+YuvXr3KihUrUKvVNGvWjA4dOtClSxdOnDiB0WikW7duNGrUiPv376PRaFi/fj1gSjd14MCBD3p55OPj49949iMjI/Hw8ODw4cO0bt0aMC2OtGjRguDrZ/H0MOU85M20KK/Fa5pjN9/3f16LGf0b8VbMak5kNzd35ZziUN/Y9tY55Ba7+pFicXONYc2BlL4VF/va79qtvqBytRqsXr3atEsUsbKyYt68ef8Vc+Pfifx599PF8uXLWT9/DuvKOqKLicCIQNGJC4gvXZ0lS5agVqtZv349T58+pXv37owePZpu3bohiiLz589n//79eHh4cPXqVdzc3Lhz5w5gSv80atQoRFGkY8eOPHz4kF9//ZWWLVuaQ3pWrFjBwoUL2bFjB35+fjn2b/bs2YSGhuLu7o6vry/ly5dn2bJlrF69Gn9/fx4+fMifF88xKPQicqOBQn2+werL4Xz99dfs3r37nxrGfOSCv/Lsq9VqQkJC8Pb2zvdU+QSR1+vzQTP08ePH0Wg05t+zZ88mMTHR/Fuv1xMUFPTe42S5E7/+b9u2bSiVSvz9/c3bPubKQj7+95CamspXX31FixYtKFmyJAaDwWxdSklJwdLS0pxy6cCBA+YcqitXrqRp06Z89913hIeHc/jwYVxdXZHJZKSnp2NjY4MoishkMipWrMioUaN48eIFM2eaVpF79uzJt99+y/Llyzlw4AB79+41W0jeRI0aNYiMjKRZs2YsXbqUGjVq0L59e7Zt24aFhQVarZYRI0bg5eVFYGAgT548AaBFixacPHnynxnIfHxSiI+PB8i2avnKZfjV+/ktd9ecXFBzI4I5WC1z+vef4L2xqK//fld8bU5lPsDdONdj5aXNHH7nqBKcU31427L6RpysWqPJNoELgoCTk5P5HshHPj413Lhxg02bNjG/uo+JsBZ05Xrjnjh37MOjR4+QSqXUqFEDgF9++QVLS0tq167NhAkT8PPz49SpU6jVas6ePYuLiwuRkZE4OjoiCAI+Pj4UKFAABwcHunbtioeHB1u3bmXNmjX06dOHNWvWsGfPHs6dO8fs2bNz7WPfvn2JiopCFEW+//57Zs6cSVpaGiEhIfj4+BAcHMyvW7Zz1K4YADGbl6BMisFoNJKUlPSPjGM+/h58aKrOfPwzyOt1+Y8ylP/Vi58XF+OQkBCzu0Y+8vFXMHHiRJo2bWqOT3327Bk+PqYcbI8ePcLa2ppq1aoBpvibZ8+eMWPGDARBQKvV8ssvv7Bq1SqqV6/OiRMniIyMRBAEfH19yczMxN/fnzJlyrBnzx62b9/Ojz/+yOPHj3nw4AEWFhb88ccf+Pn50bBhQ65cuZJjHwVB4KeffmLOnDlMnjwZR0dHHBwc2LhxIw8ePCA6OprExETGjx+Pvb09P/30E2BKpbNr165/YBTz8akhSwzM2dnZvM3S0hKATFV20Z4c3Vhzwjssge/Cuwjt+/691f67CFxe8ReEnd7ZVl5cnt84/pvbcrO2Zls4yPr7Dddjlept0SVnZ+dsgnD5yMenAoPBwIQJE6js7YldiElU81Ht9njWawqYdCRSU1OpUaMGer2egIAAkpOTGTp0KCVKlKBo0aIMGTKECRMmMHjwYBYsWEBqaqpZWV+v13P9+nU+//xzNmzYwKBBg1i2bBlpaWkoFAp+++03KlasiLu7O1qtNpuR5XW4u7vTvn17Nm7cyPnz5zlz5gzff/89kydPJi0tjatXr2JhYcE3u47xUCcFo5HwBZPp2LHjW9kv8vHfgSw32MzMzH+5J/nICVnX5X3uyv9oypt85OOfwrNnz4iPj0elUjFo0CAAczxrhjaT63duoNFoqFOnDikpKVy4cIFKlSqxZ88eevfuzfTp02nYsCG7d+/m888/p3Dhwuh0OjQaDZGRkSQmJtKzZ08GDhxIs2bN6N+/PxkZGXTt2pWbN28yceJE3NzcyMjIoFWrVuzZs4f69evn2NfKlSvz559/YmNjw507dzh27BgzZsxg3bp1yGQyevfuzcGDB9m8eTPlypVjxYoVuLu7k5SURGZmJlZWVv/k0ObjX0ZOltYsAhufkIsFzmh85S4sGl/mZX2Zz/XlbzNe//06+fpQ19m8IC9uwHkhr2/2LatOTul+yCFdzpvtfGh+Wv4Dwgq5WsXjEhLN4jRZyLe05uNTxdatW2nfvj3qHb+CaERZrBTX4lIZ81JH4t69eyQmJlK+fHn2799PUFAQ48ePp3PnzvTv359t27bh6urK4MGDGTNmDJ6enqhUKkJDQ5FKpVy4cIFBgwbRunVrevfuzbRp00hOTubEiRNMnDgRtVpNWFgYYErhcenSJZo0aZJjX/v370+XLl2wsbHBw8ODuLg4WrduzaZNm4iNjWXJkiUmV+Te38H2n0i7fo5WI6bRf/xk+vfv/4+NaT4+DqRSKQ4ODsTGxgJgZWWVnzrwE4AoimRmZhIbG4uDgwNSqfSd5T+ItAqC8NZFzr/o+fjUIIoi48eP54cffmDMmDEUKVIEgFu3btGhQwe+Xv0Nl4Ov4ZZoR5UqVejUqROOjo5MnDiRTp06MWrUKBo2bAiYlIOz3NQ1Gg22traoVCrApHBYvHhxNmzYwNmzZ8nIyGDHjh2kpKTQoEEDevTowYQJExg7diw3btxAFMVcn5esXFnt27enV69e1K5dm9q1a7N9+3Z2797NoUOHaNeuHZUrV2bOnDn88MMPdOnShaVLlzJu3Li/d0Dz8UkhLi4OCwsLs2s7QKFChQCIjo3PnXy9TlxzwptkNTcimNOx33XMvOKvkNWcyuZGwHP4nSN5zant9+Ss/WiE9bX6mSoVqWlpuLq6ZmvL2dmZiIiIXPuSj3z8G0hOTmbDhg389NNPpO38GQCnL/oSsukAnp6eDB8+nOvXr1OqVCm0Wi3ffvstnp6e1K5dm379+rF+/XpcXV0xGAyEhITg6+sLmKy3Xl5ehISEoNPpKFmyJNbW1ixcuBBfX18UCgW1atXCwcGBLl26kJCQwLZt26hTpw67d+/OlbTCq3m3du3a7Nmzh1WrVtGjRw9SUlI4cOAAPXr0oNd341m5bj7VLEVSd6/GycmJq1evmgUc8/Hfg6x3aRZxzcenAwcHh7fmupzwQaRVFEX69u2LQmFKYK9Wqxk8eDDW1tYAubpi5CMf/yR+++03/Pz8SEtLyzax/Pnnn/Tr34+AF3dxj3DkuTKc9u3bExcXR2pqKh07dqRChQr8+uuv7Nixg1GjRpGeno6LiwsajQaVSkWxYsWwtbUlPDyc7t27c/DgQRYuXMi8efMIDg6mTp066PV64uPjmTlzJgMGDDDnlNuzZ8975cUrVapESkoKer0emUzGZ599xrZt21i/fj3t2rVj5syZdO3alcmTJ9OzZ08GDBhA//79GTdu3AfJkOfjvxfx8fE4OTllWwCxtLTE3t6emLg3LHBvWhyziGtu1tacrKy5kdOciOJfdel91++/crw3iSq887xyJa/v6dNbcbJv/p1XwpqDi3FsrOlavjmROzk58eeff+bcz3zk41+AKIqMHDmSWbNmcXbf7zRWpQKgrNUM5a4THDhwgISEBMqVK8fdu3f57LPPsLS0NAsZVqtWja+//pp69epRrFgx6tevj06nM6emGj58OLNmzSI5OZlevXqxd+9eChYsSK9evbC2tsbPzw+pVIpKpWLZsmVMmDCBIkWKkJmZSXh4OIULF35n/9u0acP48ePNvzt06MD+/ftZt24d48aNI9WvITw8S+Kx3czfe4svevSkUqVKzJo1yxyakY9PH4Ig4ObmhouLS646I/n45yGXy99rYc3CB5HWLHW2LPTs2fOtMr179/6QQ+YjHx8V169f5+jRo+zevZuvv/7arLC5Y8cObt68yYApg7GysqCcc2mEwpbs+XYPrq6uWFpacvv2bby8vAC4efMmK1eupGLFiuzZs4fJkyebY2REUaRy5cocOXKEDh06oNfrKVCgAE5OTiQkJODs7IxWq2XAgAGMGTOGiIgIVCoVs2bN4tKlS3z33Xdm6++bsLCwwMHBgTNnztC8eXN2795NcnIyXl5e3Llzhxo1aiCVSjlx4gQtW7bkt99+4+bNmyxevJhff/31HxvnfPx7iIuLy1E63sPDnbCISARRzNly+CZxzQ25kT7IG4HNC/IgAJWnfe/rz/usrm+UeZ2Evks1+Z1qx3khrDlYV988ZthLa6q7u3u27U5OTvkxrfn4pLB48WLKlSuHn58fh8d8BYDSpxQjJk/l6dOnzJo1C61WS8OGDRk5ciQuLi5Uq1aNKlWqcPr0aZRKJaIosnPnTnbu3MmIESP49ttvuXPnDoIgsGjRIho0aMCFCxcIDAykYsWKGI1Gcyq45ORkKlSowJUrV1i2bBlt27alXr16zJ07ly+++IIOHTowcuTIXENpqlevTnJyMmlpadja2nLmzBmCgoJ48uQJw4YNo8fsRTz6vCKOWg3aU/s4ceIEixcv5ujRo3zxxRf/5FDn4yNAKpXmmSTl49PCB5HWrHQb+cjHp4pp06axfv16tm/fjpWVFRUqVMBoNDJ06FDs7Ox4kh5C4UQXDgYcoPLYugwYMhCVSsXJkyfNhBWgatWqdOjQgYSEBGrWrMnFixdxdnbm888/Z+vWrXh7e9OpUyeCg4OJjIw0E9OWLVty+PBhlEol9+7d49SpU7Rp04aVK1fSt29fOnfuzLBhwyhRogQvXrygUKFC/Pzzz2bvBYCyZcvy22+/0ahRI3bu3IlEIiE4OJg+ffqwZMkSOnbsyPTp02nZsiWCIFCtWjUmT55sts7m4/834uPjs4kwZaFkyVIEPTXlyc6RfOXiKptjbGtuVtb3WV9zQl4I7V8hsW/uz6lPeSCquZ1TntWR30VYzcfKYXtOAk6vbX8UHIJUKjW7SWbB2dmZhIQEjEZTXth85OPfRHJyMv7+/mzdupXvRo/mSwcpxIChZnN+n/QT3t7ehIaG0qpVK7Zu3UrXrl3p0qULEomEc+fOmYVXBEGgRYsW9O7dm8DAQKpWrUrnzp25cuUKlSpVIiQkBC8vL6pXr87z58959OgRQUFBVKpUCXd3d8LCwjAajVSsWJGpU6fSq1cvpk2bxr59+yhVqhRt27aldu3aBAYG0qhRo2wpo5ydnXF0dGTPnj3Uq1fPHHsrkUjo0aMHkydP5pysIB3EBGK2Lsfly6H06tWLb7/9Np+05iMf/yDyZ7x8/L/BvXv3sLCwoFu3bkRERDB37lxEUWTRokXIZDJ++uknRHsJVX39aNq0KXZpVoTqI3BycjJL8Gdhw4YNpKWlYTAY8Pb2Jjw8HIlEwv79+6lZsyaCILBjxw7WrFlDtWrVmDNnDra2tuzatYtixYqh0+lISEigSpUqlCxZksmTJ/P8+XPGjx+PRqPhypUrTJ48mZo1a/Lzzz9na7tx48aEhISYJ8/BgwdTpkwZChQowNGjR7lz5w6PHz/m8uXL5joNGjTg4sWL/8g45+PfRZZ78JsoXbq0mbS+jhxdWN8U/nlz/+u/cxNLyguh/Ktl8lL3PzlWXrd9SHvvIabZxv4162q2eNjXjhH09Bk+xYq9lYvZyckJg8FASkpK3vuaj3z8TdiwYQNubm5069aNJkVdsYh5gSC34NudR3F1daVz587o9XpEUWTChAls27aNlJQUOnbs+JZSaNeuXbG3tyckJIThw4dz//59JBIJz58/JyYmhn79+vH777/Tp08fvv/+e1q1akVUVBRPnjzB1dUVqVTKxo0bzR5Q69at448//mDhwoVIJBICAgJYv3499+/ff0vR38fHh1mzZtG2bVueP3/OgAEDGDhwIOHh4Rw8eBB/rRKdCLq4aFKvnKFQoUJkZGTkq9HmIx//IPJJaz7+KyGKIjNmzMg2YSxdupSoqCgOHz7MuHHjCAwMpEmTJkyaNImePXsSFBREAacC9Ovdl+XLlzN/1GzCxGj69u371vF//PFHKlasiEKh4Ma9m8ze+TNyuRw7OzsaNGiAUqnk/PnzjBkzhrVr1zJmzBiWLVvG7Nmz8fb2xtvbG1EUOXXqFBcuXGDXrl3Y29tTtGhRTpw4wdatW/nmm28oW7YsV69eJTo62tx2nTp1UCqV1KhRg0WLFrFv3z6Sk5OZNGkS6enp+Pv74+HhQZcuXYiJiTHXuXnz5t8+7h8T6enppKen/9vd+K9DfHw8jo6Ob20vXbo04ZHRpKamvrUvV6vhm66rWds+lLy+Ttj+abL6IcfO67b3nWte4nBzGtvXFgtyXEx47diPgkMoXabMW4fNuvb5CsL5+KeRnJzM3Llzs23bsmULUomE7eNHUvTQGgDuGiy4cOsOmzdv5ujRo8yYMYNvv/2W0aNHM336dJKSkpg+fXq246jVai5fvkzPnj2RSqX4+/tz+vRpbG1tKVCgAD///DNbt27l3LlznD59mh9++IFdu3YxZcoUli5dikqlwtvbG5VKxS+//EJgYCCnTp0iPj6e8ePH4+/vz9ChQ+nduzdjx45l+vTp2dI21qlThxIlSlCsWDEmTZqEXq/n0KFD9Oxpil89fOoMZ9NM5SPX/IRoMFCxYkUePnz4N4/6x0VCQkJ+PGc+/muRT1rz8V+JhQsXcuTIEc6cOWPeduTIEZYsWYKVlRVqtZrx48ezfv167O3tWbBgAdt2b6d08VJUrVoVW1tbYp9GY7SGb775BjAR4YyMDPr27UtERITZfTdGH8+NlD9RKBR06dKFb775hrlz5zJv3jyWLFlidtVs2bIl48aNY//+/TRq1AiJRMKRI0eoVq0aarUauVzOoUOHuHHjBkWLFmXXrl389NNPZGZm0qNHD44fP47RaMTHx4fAwEA2b95M+/btsbOzo0+fPsydO5dr164RExPDtWvXMBgMNGzYEJVKRenSpf+1yXPdunV/6QO6Xr16eHl5cfTo0Q+u+7+cILx06dKcP3/+rTGoWLEiAHcCH+RIrHJUuM22P+9ELEfklaj+XWQ1L8f8q4T8Xe7LORDOXIWXXv6dm3X1VREDt+89MF/T13H+/HlsbW3finXNRz7+bgwcOJDff//dbOUPDg4mIiKCse5yno3piTEznRSZJbL+4/Hz86NatWqEhoYyaNAgqlevjkQiYcWKFSgUCooVKwaY3uWhoaFUqlQJvV7Pnj178PDwYMuWLcTFxWFtbc20adNo3749gwcPZsuWLaxfvx5BEFAoFAwaNIghQ4Zw584d3Nzc0Gq1lC9fnrS0NJKTkylQoAADBgwgKSmJVq1a8eOPPzJ06FDi4uIYOXIkt2/fBsDW1pYbN27w4sULvvzyS44dO8ZXX33FsWPHmD9/Ps7OzrRasYNMg0jmvRtErJhF6dKlefTo0T9+HXQ6HUuWLMFgMHxwXV9fX4oWLUpaWtoH1ftfnnPz8ekgn7T+Q7h//36+4uNHxKlTp9i2bRuHDx8GTKu9jo6OVK9eHTAJQwwdOpTt27dTsmRJ0tPTSSKF+uXrEJseT5IqmalTpyKkigTHh9CjRw9atmxJ0aJFOXr0KGXLlsXb25ty5coh2MsQHSXI5XJzfFmxYsXM5XLCmDFjUCqVzJs3j+3btyOTybh58yYqlYqaNWvSoEEDUlJS2LZtGzt27CAjI4NTp04xZswY9uzZg5ubG3Xq1OH69evMmzePxYsXM2rUKGrUqEHDhg3JyMggMDCQ6OhoateuzdOnT/8VGXe1Ws3q1avp0qXLB02g9+7dMz8POVm63wV/f3+aNGnywWrl4eHh1KlT5y9N9J8SBg4cyMOHD99ybytTpgy2trZcvfXae+YNwpXNupejcu3f4Eb7RhsftO+1fuX27y+1/Z8Q55yIbA5/56gUnJs78Rt/Bz9/QXxiErVr187WtMFgYN26dfTo0cOs2p+P3HHw4MF8982PhKSkJBQKBV9//TUnT54EYNSoUUxpWIWUw9sBuGPtis/6kyzbsImePXuye/duihQpYr5X09PT2bhxI1WrVuXixYu0bt2ahg0bUqlSJVJTU6lWrRrNmzdHoVCQkJCAlZVVtrjuzp07s3bt2hw9TSQSCf3790cQBH755RdSU1MRBIHg4GBiYmIoVKgQX331Fb6+vpw8eZLVq1dz7do15syZw/79+7l8+TKpqak4OjpiNBqZNm0au3btYuTIkRgMBrp27UqFRs0Qu48AIGbDIooEXftXFosvX77M/v37zQvuecXXX39NWloaMTExjBo16oPqTpo0icmTJ39QHYADBw4wYsSID66Xj3zkhHzS+g8gIyODevXqffAL5j/BsUen0Bv1/1h7/yT0ej0pRdSMuzyTpy+ecfjwYX7++We+/fZbAFQqFadOnaJKlSps376dnj17smLFCrz8fLBV2NJt60A6r+xLbFwsXkY3xq3+gYEDBxIaGoq7uzuTJk3CysqKAQMG8P333yNztECml2Bhq8DX1xdjHj5ss1yEHzx4gFarpUePHnTt2hWpVIqFhQUXL16kePHi9OnTB2dnZ6ZOncrly5c5deoUy5YtY+3atXzzzTdcvHiRggULsmrVKoKCgggODsbKyorevXtjZ2fH8uXLycjIYMKECahUqv9oNfSvkLnz58/ToEEDqlSpwt27d/Ncr2nTpiiVStLT04mLi+PevXt5rrty5UrKlCnDjBkzPqiv48aNw8nJiePHj39QvejoaFq2bElkZOQH1fu70LhxY7y9vVmzZk227RkZGSiVSk6cyyG2OQfiqdFouf8w6K39gmgEo4Fjp87y9HlozvWztv1FN+D09AwGDP+WnXv251o1N2IaHRtHQOCD95Z7sx9PnoXQfcAQrt+68+7+v2lhfZ9b8MttmZkqft9/kNS0tBwJa2R0DNGxce9PkwNcuHoD4K2Yv+PHjxMREcHAgQNzP9d8AKYP+w4dOrBhw4Z/uyv/L3D37l0qVKjAZ599xtGjR/nhhx/IDAuhRrhpkczYvAv3KjXj1sMgMjMzadeuHcuXL2fIkCEApKamMmbMGADatWtntng+ffqU6tWr06NHD/R6PVOnTqV58+ZYWlpiZ2eHpaVljiQ1J/To0QO5XM7kyZMRBIHjx49TtGhRrKyskMvlrFmzhgIFCrBz5078/PyoWbMmYWFhjBkzhqSkJM6fP0/jxo25ffs29erVY+TIkZw+fZqSJUsSEhLCtGnTqP/9dK5Ym7wcJIe3EPTg/l8eU1EU/9K8e/jwYfPYGXPTJ3gDer2eNWvWmEUfN2zYkOe29Xo9/v7+hIeHc/bs2Tz3MyMjgwULFpiFrT4EV65coX379h9UJx///5FPWv8BVK5cGW0RuB2b9w/z/xTzLyxn5dUN/1h7RtFIhvafWdF+/PgxeleBkIuPsfKwZc6cOZQsWZLPPvsMURRp3bo18fHxTJw4EV9fX0qXLs2UKVOQuSqYe2ABmfdSSNamklpIQ/Uifmjs9XTs2hGNRkPpOuW4FxyIVCqlS5cu1KhRA4mDHOt4C6w8bJE6yum5cXCe+jljxgwEQUCr1bJ8+XK2bdvG0KFD+e6772jevDkuLi5s2rQJd3d3Dh8+zLVr14iIiCA6OpqoqCjKli3L9evXAShevDhjx45l/vz5CIJAoUKF+Oabb+jUqRPh4eHo9XpCQ0P/srX17t27tG3b9oPrrVixgsWLF7NhwwaOHDmSa7n09HQzoQ4MDCQ2NhaVSoVWqwVM+Wm/+uornj9//s72oqKiOHLkCMuXL2fr1q157mdiYiJnzpzh4MGDbwlfvQ9Dhw4lKSnpg9r7OyGRSBgwYAA7d+4kPDwcgIiICOrVq0daWhoBDx5j0Ove4QZsug7fTZ3F2B/ncOz0OdOO18rfffCIX9euZ+h3E19V/CskLyeIRh4GBZGQmMzmXXty6N+7CWjfYaP5bvIMnoW++KC6p86ex2g0svfQG+7of9Vy/EadVRs2sfvAERYsX5W9rNGIVqulU/9hdOw3zPSRmYsrdlb/L127g6WlJW3btjV7k2g0GpYvX06lSpWoUqXKh/X3fwyiKNKgQQNEUWTjxo3/dnf+X+Du3btIpVJGjhzJzRvXcX8eyHRFHKIqA2UZP77YdIj79+/j7++Ps7MzJ06c4NatWzx48IBmzZoxcOBA/Pz8kMlkPH36lLp169KxY0dKlCiBg4MDEomE4sWLU6RIEfr06YNUKkWv1+Po6Eh0dHQ23YfcIJfLqVatGhKJBCsrK5o2bcq9e/eoWbMmo0ePpkGDBigUCrp160b9+vW5efMmN2/eJCoqigIFCnD//n3q16/PhQsXAFMIy6JFi6hXrx5Go5HHjx+ze/duio2ZQ5pBRIERu6d//btu6dKlHzwfAezcuZOePXty9+7ddy74vq4ZMXToUERRJDMzE4PBgCiKFCpUiKlTp6JWq9/Z3vr167l9+zabN29m5cqVee7nnj17uHPnDleuXHlrkfVd0Ov1jBw5ksePH/8r7tf5+HSRT1o/Mu7evctvv/1GQkICYHJJfJ4ShmNTNxQVbT8oAN4oGrkSehOt4cOC5jO0mYRcf8LJe2fzZBV8HX3mfMWSHcs/qA6A/5PzzDy94IPr/RUEBASQkpJClWKVCQx/gCiKKJVK3NzcGD58ONevX0ehUHAh6ionbpyidevW2NrakqhNxqqgDXtnbad6ocqI5eRERkby4shj3PuWpPas5igq2HHT5iFfff01p06dYvbs2SitlYTdfo6tlwMbT23lWtgt4tLfH8P5+eefY2lpybZt27CxsQFg7ty5PH78mM8++4zHjx/Tpk0boqOjWb16NVWqVCEjIwO5XE7v3r2ZOXMmBoMBvf6VxbxixYoMGDCAq1ev4uDgwOeff06FChWIiYlBFEU69P6CE9f8MRgNqHXvnohex8SJE7l69ar5/szIyADg6O2TVJhTD4B9+/ZRpkwZczxTQkIChw4dwmAlEh8fz4IFCzAajcycOZNu3bqZV4HPnz9PxYoV6dOnD6NHj6Zq1aoA2NV1wX1kKeTulhiNRvbs2UO5cuXo1asXKpUqx3726NEDnUSPorAVoaGhXLp06a0yBoOBQ4cOZXPb+uGHH4hNjcPtqxJcuHDB/Hy+D0ajkePHj3Pz7i1++umnPI7m349+/fohl8vx8vKiQYMG1KxZk6SkJFavXk1aejo3/gw0FXz5/Ac9DWHIuKkEh4Saj1GzSiW0Oh0+nq/lDH5ZvkQxbwq7u9Gn2xd5i3XNK17WrVq5IkMG9ObXn2ebd+XV3bdZw3q4ODvhmkPan3cdq/+XXen+RTsmjh7+fvKdW9/fYW39rFljLOQyOrRume1cAeQyKcWLFaVsSV8ETIsGep2WCbMXsPPAUXOfwUS4zl69yYABA2jevDnt2rWjbdu2ODs7c+zYMb755huEd+SQ/V/E0aNH2blzp9nqtGfPHrNibdbC39+NkJAQXF1dc313vQu9evXKEyn7N3Hr1i1+//135HI5faVJVH94HivRgIVbEYbeeoFWbyA+Pp6dO3dy7do1Ro0ahYODAzKZjJMnT7Jr1y4iIiJwcHDgzz//ZM6cOSxYsIBNmzbRvHlzbty4wfjx45kyZQrx8fGo1WoyMzPx9vZm2rRpzJ49+/2dxJT2ztLS0uz5Y2Fhwbp167h06RJTp04lMDAQDw8P/vjjD65du0aLFi3QarWcPHmSUaNGkZ6eztWrV7Md8+uvv6ZIkSI8ffqUw4cPs2T5ci7rlQDU18czYsQI85yZV2i1WpYuXcq2bdsA01yTde+cO3eOzZs3m0WlPvvsM3O9tWvXEh4ejkajISIiglmzZpGUlMTgwYMZMmQIKpUKg8HAggUL8PX1ZdasWXTs2DFH0piQkMDKlStxdXVl6dKluXpqjRo1CqPRaJ6ncyK58fHx7Nu3L1sO6TFjxpCWloZWq2XWrFl5HpubN29y584dHj58+JbwVz7+tyGI+dHV/zFSU1Oxt7fn9u3b9OnTB3t7e4xGI40bN2bTpk1kVgGbygUQjdAwpGKe3ZVuBQfQeXkfPOzcuDgt7y6NV57c4IuZXyLTS7i64hzudq55ruv9dXkMgpHLP5ygsEfhPNcbtXMC18JucWn0UWSSvOcKzdSqOBV8ns/LtMxT+dWrV7Nh1yYSS6sxPlFjKAANLWvw3XffERoaymeffYaHhwceLX3wrVKCsNRInm24x6LZC/kh4CcqF6/IrScBaEUdUpkU1dF4Mh4lc+duAIO+GkTnDp1I99bjau/C+kmrEASB8BqpZBpVOKfbk15Ai05poHeJzkztOC5b3zR6LZdDr1PbqzoKmSlNxZQjc5jSamy2MRFFkV9++YXnz5+zePFis4XMaDQSHByMXq+nTLOKPLn4gKJFilKjRg02bNhg/lDNsiZnZmZy9uxZDhw6wLDhwxCMAtIGtpQrXpZSVcpw6flVulRsx3f1hwGQqk5j460daA06BlXvRWhyOPPPLaW6mx8/9p1IelQq58+f58mTJwwcOJDUtFRKza0JUgG/pJLs+dkUt+Tr68vgwYOZP38+MTExeIwqjTZKRdyu5/j5+fHVV1+xbNkyAgMDc7+QAnjP9gPAkKHnxcy7CIKATCZDp9MhCII5zU/Lli2ZOHEiOp0OCwsL7Go7Y1fLhYjFDyjkVIh79+4hlUoJCgqiYsWKfP/99xQsWJDz589z+vRpNBoNtra22DVywbKkHfH7XtC4QgOOHTv2VreePHmCr6+veaz37NlD1/7d8Rheiuh1wexcsY1KlSoRHh5O1apV0Wq12Nvbk5KSgp2dXZ7u4Y+F+Ph4Dhw4wJ49ezAYDKxfvx4XFxdcXFwY0rMz08YMN5edvnAFgUFPqFyuNBNGmtz1REHInpv0zZyfb+QtFXPKg/py2737D/l24lSGDuxDx7at3y73HjKap9jUv4gc+21uOPd9kdExDBg+mjYtmzJsYL8cDpy9z28pMEO2uOE3xZceP3vOsIkz0Op0XNi9zlz1zwePqNK6B/7+/jRq1IgJEyZw7tw5WrduzRdffEG5cuXeeb7/K8iad9etW8eyZcuQSCRUqVIFg8HAtm3bssWyRkZG4ubmlqfj7ty5k0mTJjFjxgy6d++e5/7MnTuX2bNnU6NGDfz9/fNcz2AwYGVlhbe39wdblbZu3UqFChUoX778B9X7EOj1eqZMmcKuXbuoXbs2T84eZ2khPQJQoEMfJt0KYfu+A3h5edG7d28yMjKoX78+X331FcePH2f69OksWbKE+vXrA+Dh4UFAQADFixdn5cqVTJ48mUGDBtGqVStu3rzJmjVr0Gq1nD17FqVSSe/evbl79y4Gg4EDBw5ky2meE0RRJC4uDhcXl2zb09PT+eqrr2jXrh1NmzaldOnSeHp6kpaWxpMnT7C0tMTNzY24uDgkEgnr16/P5p6alJREnTp16NatG1OmTGFCz850enQajRGG6D1YuGgxjRs3zvO4bty4kdGjR6PVaklOTubzzz/n2bNnZo0IQRBwcXHhzz//RBAEunTpQvHixZkzZ85bbr01a9Zk+vTptG/f/oNjuKVSKaIoYjQaUSqV+Pj4YGVlxYIFC6hbty5Xr16lVq1a2eq0bNmSI0eO8Pz5c1QqlTmbQatWrQgMDOS3334jMDDwrfty165ddO7cOds2g8HA8+fP8fHxMW8rV64c9++/crtOT08nJCSEzMxMqlWrRlpa2r827+bj30U+af0IyJo8S5cuzYsXL7C3tychIQG3om5ER8VQ6JviSCxNpCVkwm2GDBlCdHQ0M2bMyFXIB+D7Xyfx2471WPhYE7X+SZ778+3yceyLP4EuVsOKfr/wedXP3l/pJTzHlUOfpKN1ocasmbEiz/XKTa1NenoaW0espU7RGu+v8BL9do3gbvQDbo449V7rQVJSEl27diVUE4GupRIEMEZp2dJ5BYmJibRv3x7v+iVo911ngv98jDxAj9zVkruqR9jHKomrrsYqVEJaUT2CRMCYoUeQS/CgEGKanokdxtC6bkuSVMn0WDqQoaX78CI6jAUR6xCVInZJStIcNSCAg9qGW1PPmfuWrE6h+7avyNSq0Oi1rO+yhML27jRY+Tlj6g+lR+VOb53PxIkTadCgAQ0aNKBJkyb8vGkRKxetYPPyDZT/pR5OIdacWXoMQRBo3749s2bNwsvLi4VXVnI/8hE3Nv/BtMGTmXt1KfFJCci1EmQ+VhiNRiwFJV/79mRL4n6+bzCCliUbM/LARPpW7YZMImPRpZWkqFJpXqIRG6/uICk6AamVjOaxNdi5cydpaWlU6V6LxPKm89Wn6QibfQ+ZTGay/AqACBbulhT6shjqiEySTkRiTDJZarMsHhKJJMeYm0K9i2FV2gFRLyLIBCLXBKF5lvNKtZOTE3v27GHUqFEEBATg8U1pZHYWpFyJI9k/ErlcjkQiwWAwIAgCFhYWqNVqrKysGDNmDIcPH+bGjRu4DSmJwtWS1OvxaM4l0aFDB/r160fNmjWJiYlh3rx53L9/nyJFirB161aio6Px8vLCoaMHmrBMJBYSks9FZzsnhUKBRqP5pCbPHj168PBeADeO7DRvS0pJY+8xfzq1boG9vT3wkrTCf05cgd8PHOa3LTupWK4Mc3+c9LJw3gSW/gm8k7hm4Y0y12/d4YfZP+FcsCBbVi977WB5IKvwTsJq+tPA3mOn8PUqTKUyJc375/66nrkrNxIfH//eD/T/ZWTNu25ubqhUKvR6PXK5HAsLC3MqsCw4OztTv359nJ2dmTt3rvkZyAlZ6cOsra0/KA6vTJkyPHz4ECsrqw+yup09e5bGjRtjZWXFo0ePKFKkyPsrvYSnpyelS5fmxIkTea7zoTi6ewcP9m1nztHzJKaksKy4DTXt5EjLVmWHmx/z5s0zp5Dp27cv9vb2XL9+nbp163Lw4EEKFy5MbGwsUVFRSCQSlEolWq2W7du3M3/+fPbv329+d3bs2JG1a9cycuRIrly5glQqpWnTplSrVo2MjAzc3d3p2LHjXz4Xg8FAmzZt2LJlC2FhYcyaNYvdu3ebMwCEh4dTtGhRoqOjEQSBrVu3UqlSJUqVKoUgCBw4cICxY8dy5coVKpYvx9ZCamykAmNTbYmR21C2bFnmzZuHt7f3e/tSpEgRc3jH5s2b6devH3q9Hj8/P+Lj44mNjX2v224WlEpltrKCIPzHar9VqlRh9OjRDBw48C3vAalUikQiQSqVmufdLHduGxsbfv31V4YMGUJycnK2eiVKlKBLly50794dLy8v7t69y4wZM0hKSqJXr14MGTKEhw8fvvO7GEzfBPHx8Z/UvJuPfwb5pPUjIGvylEgkSB3kSO3lGNR6PIaVQhOVibKwjbnsi7n3KOrkiUQiQaVSERISgkyWs2WyRJ/K6EsI6NP17OywilrVa71VRqfT8fjx42wPedHupZFUtAIRSiV5cvSnfXk6j3U7NzAzZCmIIpk3kone+yxP9ZJUyfjNb4Qgl9DIuRa/DVz2/kpAsiqFJis7kpSZzMmvf8fX6d0v+jlz5vDjjz/i2tATaSPTi8qoNxIz65HJ/dbXgpoDGlDJtRzPnjzj4fNHKBKlJDploElVIRSxQJ+iQV7IEqkgwWA0ojmUgE+7MugMeuwLOdK5wuf0r9qD8t/X5s7sC1wPuUWvPcNMhFoLZH1DakT6W3TExtIGjZuRzWF70IsGxjf8BldbF747NAVbwYpYXQJyqQxPh8I42xSkTekWdK3YHokgISUlhc6dO3PixAmOnjrGN0cnoVKrSfCPwH1QCQoI9twcdwY7OztSU1ORyWTYVnXCu7wPm79fw/Bd3/MiIwJVciaCXILUWo5EI4KDDLdge6I8kvBx9ybNmIlMKqO2ZzVkUil6o4EXyeEUsHTk0tMrPN/5COcvvECA5LPRGNJ1ZAal4jaoODJ7CzCKIEDU6sfo0/Tok7UUGV0GdWgGRp0Bu+qmCT/hWBipF+JAAoJUgqh79QEvsZRiVBuQFVQgsZbi8XUpE/F9CVFnRP08neQz0aif5567VWoro8g40+qtqDYQOvP94k9SOzmCRMBjVCkkShn6JC1hPwVSsGBBEhMT35rcBUGgbNmyhGdGkfwsAY9vSmNRyBJNZCaRSx9h6WuLNk6NIeWV2/6nNHnu2LGD7t278+jCEXy8XvsAfp2Uvfz7rxBXU703yKwo8uDRY0r4FntLPOhN/MdEVTS+00L6zqofWC8o+ClF3N2xsrLMcX9eCKupnJijWnBO9au17YlP6XLs3r37g/r6v4aseTfrw/l98PDwQCqVUq5cuXfG30ulUvOilMFgQPLm84ApX2lycjJFixY1b3t90TUuLg4nJ6c8nYerq6uZZH/99dd5jhmMiorC3d0dmUxGcnLyB6lJT5w4kevXr3Pq1Kl3ljOkp3KmoS8F0HMh1cCUZ2n4V7BHLhHo/1RNsFbA2dmZp0+f8uTJE3bv3s2pU6fIzMwkJiYGtVpNamoqer2etm3b8vTpU6Kjo7GxsaF169Z06tSJBg0aACbBu2+//Zbt27ezfPlytmzZwpMnT2jatCnjx49HKpXSs2dP+vXrh0KhoHr16vj5+ZnHXavVcuHCBYKDgwkMDGTZspy/Q86fP8/hw4eZP38+06ZNY9u2bTx9+hSpVEpSUhLVqlXjwYMHWFhYoNVqkclkKJVK+vbty/z582nQoAEODg6cPHnSTOB/idBwXKOgRIkSxMXFcePGDQoUKJBj+yEhIcTExGSzXub1Hv4YsLa2/mBX5v8Eb56bs7NzNhfi18uVKlWKBw8e5Jlwf0rzbj7+GeST1pdYvnw58+fPJzo6mooVK7J06VJz+pT3IWvylLtZ4tbPF4wiElvTh/KbSLkeR/KxSASZgCHdFKtYrFgxFi5ciEwmo0WLFkilUgCKfF8WeQFT3ETy2hckPInl0KFDPH78mK5du7Jv3z4mT56MSqWiVatWdOzdifPPL+MffQELJ9NHliY0g7DlD3KceLNw8dYlUmNT6DK+J4W6m3Kn6VN0rG7/C072BfEp5I2joyOZmZls27YNb29vmjRpwoukcBIyk7h06zILH6wGQEwzEDIr4J3jlZCSwPfrfqD351/Sd9cIBEGgTbFmLOmSPXbh3Llz7N27l65du1K7dm0USgXWdQtiVc4BhZuJlCNA2Ix7WMutKPRdCco4liDg6V1sLG1wKOhIYkw8qZlpSK1k6GM1WJSwefm9KyAiIlxX45nkwoFDB/gj/AazTy/EVXAiNiaGgeV7svD3pSRXekVOXhoYAdDuTaBH5+4cN14iQ1QhE6QYMCJqjRhFIzKjFKNSBBHqSqqQ4JROyxKNORroj1E0IiDgEeRAk5qNeGwfxtF1B6lTvy67XxxE7mQJIoRODsDGxgYLCwuS0pNx6elNemASNmUcaeRbl71Ld+E6uDgSCwm6VC0yWwsQwE5jRWJSIlIbCya3/Y4K7uUISw5HKVNglWrB0Vsn+T35GEgEdElq5I6m+0wTlQF6kNrKTYT1dWJpFBEkAuqoDBSuVmAQEaQCvPxoMOoMRC55hHPnoggWEkS9EamdBbpYFcqitogGIxKFNPcbQwSj1kDKH7GkXovDmPoqlrfIuLJIlFLSAxKxq/nK7Stk8m14x1xv41cAxxYeJJ2MwLlTUfP251PuIOpyf/V5jCqNhasl0Vue4trTx3z+yWeiUHrbggQy7iSSdsMUG/spTZ6ZmZkUKlSI777qzeRRr4mGvYu0vrk/p/dFHsjru/CXyer76v1DBNbcXG7xsPCKrL627S3Cmm1f9t/3Hz+lYsuu7N+/n3bt2v2l/v034WPMu38FgiDQtGlTBg0aRMmSJalQoUK2fVmYMmUK48aNY+vWrUilUtq0acOoUaM4dOgQGo2GWbNm4ezsTEZGRra0Hr169WLTpk3v7MO5c+ewsbGhWrVq2dqOiYkhPT0dNzc3lEolUVFRbNq0ie7du+Pp6YnRaEQikdCoUSPOnTsHwNixY98bc3/37l0iIiIoX7682Zr75uef0Whk48aNPHjwgGHDhpGydAr684fN+4NVenwtZQSrDPR5qsHe3p45c+Zw79499u7dy2effYabmxs3btwwx4UaDAZSU1NxdnamcOHC3Llzh6pVq1KsWDFzPOejR4/Yvn07FSpUIDQ0lOXLlxMZGYlEIsHW1payZcty7do1VCoVRYsWZfr06QQGBnLz5k0GDRqEIAgMGzYMNzc3U3aBlBSKFi3Kd999R/v27UlKSiIgIABBEJDL5UyZMoVNmzZx7do1jhw5Yj5viURiDlMRBAEbGxsSExPNixi2trbMmDGDb775hiJFivCFkERPZzmXU3SMeaGlaNGixMTE0KxZs7cWnfbt24ednR3NmjX7pHKefgyr7L+FT2nezcc/g3zSiimGpXfv3qxcuZIaNWqwaNEidu/eTVBQ0FtxETkhNTUVx8IF8RxbDkH+7g8hURTRRaswqAzEbAhGVsBkecIooAlLp0zJMiw5sILg+GfMO7vUTBriDr7AEJCBWq3G3t4eg6WIRqtBm6BGaiPDoDLgOak8EgupiSy/rCcaRMpd9cDOzo4RI0ZQo0YNXrx4wZ49exg3bhyjx33Hbmt/kwtoqhaZncXLipAZnIrMSkbMpmfoU00qr0qlEoPBwNixY9lndQaNqEMbmoHcx8p8jjsar6BatWq5uvv6jq+K0UGkgm0p7qaZYngEPRRRFeKFdTRDfftQxqY43037nnKNKxKSHkbqnUR0rSxMJOklWc1Cxh8J2BisoJKCzJA0nDQOZLpoUWnUyBwtECUgt7VAn6FDVsACRBD1RgS5BFEvYiHKkMnlaDQadBGZ4CxHZpDgKboRpY5F6/bqERFekt2ssRW0IlhKsvVJMHdONBE6EZSCArWoAaOIQlBQXOqFVqflsRCKNjITiUqgYJotoouElMKv8o+mnozGu21p0l+kULWcHzFRMdz/8z6RvwcDYN+gEAVbemDMIpBZMIoYNAYkcglSUYoRY7Z+A0iUbxNIQ6YOqaU82/h+CIw6I6LOiEQhQZC+nxS8vgjwJkRRRBuhQmIrRW7/0sT9xrVXBaeQfCbGZJ0VACNYlrTDoaErhgw9ViXtTQtEGgPS1whzyh8xaOM16OPVqIOzW3aVxe1w62/KC2jI1CO1es0T4rX29Wk6NM/Tid0W8slNnn379uXyhXPcP3vw1XP4Jkl7H3GFPFlds/AmCfyPLKp/pe5fJKHmJt9RP9dzycm6+tr2nNyC32VlnTR/OWt27icqKhoLC4sPO4H/MnyMefd9pNUczvAejBw5ksWLF/P8+fO3XDuzPKEcHBzMVsP3pRmxtbWlQ4cOWFhYMG3aNFxcXIiKimL48OEcPXqU7du3m0Tl8iDMKAiCed69evUq/fr1o0ePHowb90pTwcLCgrCwsHeOm1KpxGg04ubmxosXJuXtEydOmMWJXrx4wYrx3yLeuwZ+9fnj+g1+NIQgFQT+SNFRx/6VB8WCsEz2pppiLnU6HRkZGfj5+XH//n1SU1PN3hYSiSm/eUJCApUqVeLevXsYjUacnZ3p1asXCoWCbdu2odVqiYuLo3r16hQtWpRr164RHh6OlZUVDg4OJCUlkZ6ejlQqxcbGBplMRnp6OhqNBqlUiq2tLbNnz+a3336jevXqfPXVV/zwww/UqFGD3bt3I5VK6dy5MxKJhPj4eM6fP8+DBw+QyWRUqVKFhIQEbt68CZgsfg4ODhw5coRp06YxZcoUli1bxt69e81usnK5nIIFC+KpSuRXX2syDSKNApLN66eCIPD5559z8eLFD071klfI5fIPEvbMgoODA5aWlkRFRf0Nvfq4yC28KAuf2rybj78f+aQVqFGjBtWqVTO7kxiNRooUKcKIESMYP378e+unpqZS6ddG/3lHREi/b7KiiWJ2EmI0GBCQIEgEE7m0N5Evg8oUl2nUGJDZ5OyWpzRakBgQQ9yxMBybu2FZzA5Dug4LVyWIQo7kJVu3jCL6NB1SKxmCaBLOSboSg/Nnr1ZrXyeoZWOL8lwTzi9fzEDlbCA0+gVDGvdHJpHx/bof2BP3UgBHFM1Wujd/Z1n18jRsehFDmg6JpRRBBH2yDl2sCgsPa4wGAzI7OVKl3GTdzOGYCqOcjMg01CHpKIvaYJNuibq40UROpIKZhIqv0asPWZ0UXlIz8SXhEV5uzcaARNM3t0j21W/BAFKNgMRCii5DSwGpA3YF7clISScsIgyLotYIUiHn8Xp5ePFNQvsheIMkfmy8vgjwl/D6EL68D0Vj1v34xv31erXXxks0GhEkEvQpWgwZeixcLfN874EpTv1TmzxPnTpFs2bNOPf7RupUq/xqRw7WVsjFTTgLebS6fhR8jBjXv6tvr+PNfr6PsObw/zdJq16vx7dBe9q0a8+KFXnXE/hvxceYd99HWrNcPPMCS0vLv6T8+zped4Vs06YNR48ezXMezbwgi6jkdF7dunUjPT2dX3/9FWtra3Q6HYUKFUIURWrWrJmjivLrpKCmnYwFPjZYvPHuC0jXMSgona2lbSlhJeNmmo5hj9MxvnxnWFlZIZPJ0Gq16PV6ZDKZWVOgXr16nDhx4q25UiaT0b9/f7Zs2WJ2v/Xx8SEoKAgHBwdiYmKoWrUq4eHhREZGYjAYqFq1KgMGDGDUqFHodDpkMhlGoxGNRoMoijg6OpKUlIRSqcTCwoIqVapw69Yt87u5dOnSuLq6Eh8fj5eXF4GBgdSpU4dly5bx+++/07VrV3P/hgwZQkJCAomJiYSGhtKvXz/c3NzYsGEDAQEB5hRucokE/3I2WEkFhj9O42ra+xdIXsd/4hbs4OCARqPJMd4UXulKmOdFUUQmk5nEDO3siI6OxsrKClEUUalUZm+83O7XvC4AvQkLCwt0Ot0HW3NtbGxQq9Vvtfm6IOWnNu/m4+/H/zxp1Wq1WFlZ8fvvv2dTiuvTpw/JyckcOHDgrToajQaN5jVrWGoq9bf8/3flyiuySMCngLySX0EEM6MUTOfwOuF5k1wJr9jny4Yw81ARMUcLYk4E7XWrbK4PoojJtTYdsBEQpcLfSiT/Uby5cPGJ4l0W4U+RtBqNRkqVKkmlkj5sWz7/1Y73kdacykHOxDWnch+Cf0KE6WMS2Jz6mwNZhfcTVlOZ7HV/P3qKbsPHExAQQMWKFT9Wrz9JfKx5t0iRIu/8mH5ToOZ/FRKgiaMcCXAi6ZV1ztdSSnsnC7wUEqrZyZG98R7QiyIDHqVxP9OAQgA/Wxk30vToc3kZZgmHaTSatxZ2X48VtrS0xGAwUK1aNdzc3Khbty7p6enMnTvXXMbKyoqqVaty7NgxFAoFPj4+rFy5ktKlSxMfH8/06dPp2LEjDRo04IsvvuDZs2d4eXlx8+ZNypYty8OHD1Gr1cyePZvZs2eb1XELFChA2bJlUSqVnDx5kszMTPR6fTbyWLp0aYKCgpBKpVSrVo1nz56h1WpRq9Uolcps1tNZ3la0KKDgfoaeUcHpJOc2ODng73DNdXZ2xmAwYGFh8VYaJUEQsLW1JSMjw3y+WeKFFhYWZnfoN8cDMJPd+Pjs6f4cHBxQKpWkpqai0+nesv5KpVIKFCjwVhyrtbU1UqkUqVRKSkpKjmS5dOnS2VLXgemZ9vX1JTAw8JObd/Px9+PTYBb/IuLj4zEYDBQqVCjb9kKFCuWaN23OnDnY29ub/32I2t//Aj4VwgrkTFhzmCNEARBEE3UURQTBFNuSo5X1Tcb4GmGFrJVA4e1yAuZjZu19ddy3SmerJ5FJEB0kiLJPj7CKRvEl6X83cuz2fwFhhdwJ66cKiUTCiBEj2XvsFGGRueR/zIlk5bAPMJGznFbgX89d+mYO05z2vS8X6sfGX2kvL/19czzyQljfgyUbdtCgQf3/94QVPu68q9frc3WlfpOwKhQKJBKJ+f//C5ALsKqEDXOK2TCrmA317U3uzkoJrC1pQzcXJbXsLZAJAv6JWmreTuLb4DQOxmvodD+V+5km8qIR4Upq7oQVsi8svEnGDAYDoigiiqKZsISEhPDkyRMmTpzIxo0bmTFjBrt376ZYsWJoNBouXryIIAhIJBLKlCnD1KlTsbW1ZcOGDTRp0oSwsDD69euHjY0Nw4YNw8XFBaVSyZ9//olWq+XLL7+kRIkSrFu3jkaNGlGtWjUMBgOXLl3C09MTb29vChUqZLZOZuHhw4fY29tTvnx5bt68SUxMDMnJyWRmZr7l7rs1xmTpLWstY0MpW+w/0Kspy3KoUChyFeXMCeXKlcPBwcH8O8slOy4ujsTERKKjo7G0tKRkSZMyuZOTE6IokpaWRoECBbK5cBsMBgwGAwkJCUil0hz7odPpsln3s8YsNTWVmJgYMjMzc3RXFkUxWxoepVJpFiLNyMggOTkZo9H4VpsymYzg4GDzbysrK6RSKWq1+i0im4//HfxvvLU/MiZMmEBKSor5X1hYGPokLUVtCvM5DTEm5i3OwERgXhr3hBxIzt+MXNvLYeVPNIo5bv8nIBr/hnZfO6SAYJo4Xl4DMccyb0AAo96AIVGLoAeMIBEk2bx+c7Sdvpy0xdf2mv7K3dKarU//JkRekdPXx0YimEj/axAMAtYSK5SiBQUtHCl0wwpV6KvYUdHw0nVJ+9rHvgGMKgOSnenY7Rex2JRJ6uqwPHXt9eYF8cOeJUEUUKjl1LeqhmDMe716jtWw1irzXP6fRt++fbG2tmbFph15Kv9e4gq5k9c36/1dpDSr/b/icvk+Ep2XfudEVt9FWPOIm/cecflmAKNGffNB9f6XkNO8C3Dnzh169uxpUpB/AzKZzJyao0CBAjg4OPDzzz/j4uJCp06dOHbs2ActEmR9WNerVw+lMm/PvrOzMxKJBJlMRrly5cwk4kPa+08wrogVlW1fhQ5N8rJGJkB/VyU2UgmiKLI1Rs3M0AwmhWSgF+Fiip7poZmEa/76c2xvb5+rknhCQgI///wzFy5cYPTo0QwaNIjU1FSOHDnCzp07KVWqFEajEYVCgSAIFCpUiODgYMqVK4erqyu7d+/mwIEDZGRkcOjQIZo0aYKrqyv169cnLS2N2rVrI4oily9f5vz580yfPp0LFy5w584dVCoVarWaRYsWARAREfGWpV4ul+Pl5UVQUJDZtTU3t9kHmQZGPEknUmOgsELKdO9XKs6vh03ltEgikUjM5D6341evXh1PT8+3233wgOTkZCQSCVZWVtjZ2dGyZUt+//13Jk2aZCbqQUFBgGmhqEyZMlhaWpKamoooitjY2FCkSBEsLS3x8PCgSpUqODs7v3XdsizCqampgIlAWlhYUKJECWxtbSlYsCB169alWbNmWFtbZztvo9FoViu2tbVFrVZTp04dBgwYQP/+/Vm7di2tWrXKdg2USiVKpRKZTIZUKsXS0hK1Wk3VqlXZvXs3ffv2zXGs8vH/H//zpNXJyQmpVPpWXreYmBhcXV1zrKNQKLCzs8v2L/FoODemnCU9OIVWaXXeMs0IGhNZMaoNiFoRQ7oeXbwa3YN0Mh+lYNT9tcnBkKnH6umHk11dkgbVizSzKE+2vr4pqGKEtLOxpJyMJnptMAnH8kYkAESdEVFvNI3HB5yiZZIM5yhbKjiVJn1dBPbqPMr554XdCWDUvHJ9yVr9zSKbr4Rr3j6s8KoSVWwr0Kx8Y5qWaICtpQ32SruXZV8e7zWyLWQYEA0iohGMmQb0CRqzAND7SOm7Yj7z4lpkUOtNJ2AQEbTCO8fIkKgFEQzJby+8qJ6nEzv7sWkRISuO9PVzNDF1RI0REiHxt+do1sYSvTCImp5ViVr52DQGeiOZ+02uQllqwta3BGThID2mIjIojKA/H5Kemkad8rVQPUoxt5F2L8HUtFE0LTYYXnYkHa72P8aW+ku5NeQUW5stR56a3b379b+FrMsvQtGbjrTNrE8Hr1YUOWWTnbiKL8u/3KaIMC1wuOsLkeEfj3Ao9/Q8/zZsbW35+uuvWbFpJwlJyXmqkyNx/avk9WMhN6L6T/Th9bbfbOsNsvrW2L1R5l1EduaS1RT39eXzzz//T3v8X4GPNe8CNGnSBB8fH4oUKYKTk1O2D+5atWphNBqxsLBALpeTnJzMxIkTSUlJYffu3XTv3p2aNWu+1VZOhFQQBPOH9eXLl6lSpUqOZd5EXFwcRqMpZjkwMNBMIl5H69atKVy4sPkYWTGeoih+sCCXRCLB0ULK7NLOHC1vT3tnk8vu5JAM0g0iBeUS2ha0oLuL6Rynh2ayMFzFwUQ97Tt2ZNSoUWzduhVPT08KFiz4QW2/jpSUlFyFgoxGI8OGDaNMmTLExsbSo0cPli9fTuXKlalbty4vXrxAo9GQmZmJKIr07t0btVrN+fPnOX78OMePH2fLli1MnjyZpKQkSpYsyVdffcXYsWNxdHTk1q1b2NraolQq2bdvH4mJiWRmZpKUlERaWhoeHh4UK1aM27dv4+Xl9dY8qtPpCAgIICMj47354wGupun5JjgdoyhSx15OUSu5OX94lSpVcHJyMhPw12FtbY1EIjFbfHNqKzAw0Cya5OHhAUDRokURRRErKyu6d+9udseWyWT069ePjRs3snHjRkJDQ5FIJOZ7yMrKCj8/P3r06IGNjQ0NGjTAxsaGggULEhoayu3bt3F0dKRs2bJmV2IwLbx4e3tTvHhx6tevj7u7OxKJhAYNGnDnzh38/f05cuQI48ePRyaTmcezevXquLi4YGFhQdu2bSlcuDDe3t7cvHkTqVRKiRIlzITWxcXF/Ow6OTnRoUMHKlWqhJ2dHW3atGHNmjUULlyYEydOcOXKlfdek3z8/8T/fEwrmAQhqlevztKlSwHTC9XT05Phw4f/JUEImUyGZ8cSUFmJ+DIeUaaVYrASidn2lKKKwgiiwNO4EOzqFcKYpiPhWAQeo0ohL5h9snwzlk5AAI2JSBaQ2PF0/T0SQ+Nx+bwo1rVe5gUzZoVyZY+h1MSosAmTUcXXj6SERAL975BoTKHQ0OIA6BLVphQ7ehFei5tM2BCCbbppZS0uLg6DwYBV44LY1c1FqfBlk7pEDVZWVmiSVIixOsQCEoyWAhbOylflhNfiTl8SIPf0glya7Q/As4TnDNz1DT+1/ZE2vdtj1bwgkhQBo72YXWBINKVLMWboSb0eh8LdGmVRGwwqHRaFrLL3z/iyYQkv40VNBFMblYncQYnUUgaIiBZvsFbhFfkREWF/KpqwTDJttUgywLqwHbrCIhalbZFaydCEZ6AobI1gFDDEahBloInMJHlvBEUbFkePgZgHETgNNKUZQi7kaYJEBINGj1QhM53La2PwunAxmM5NIpPgbFGAuLAYBKMEmUyKTmZAdDBZhvXpOgxJWqQ2cuLXPsOuUSESDodRZGqFbMQ9Zt1TVMGpFKxQCLtu7ogiJJ6JoEAT00SqeZ5B3I4QXJp5knQpGlKNZnEOgBYtWmBra0vdunX55ptv8J7tBwIY0nWo18TQvHlzEhISSEpKwtHRkdOnT+Pu7k6GOgPbYUVAgGeTb+M9xw/BCKIEEjeEYtvYhZh1wYiGVx941atX58r1q7hPLA1SAU14JorCVgh6EGUg/J6Ooa0VmVujSXgaa05xcOzYMTp/1x27LqZzUj9PR+llY34QrbZpiYmOxs7OjtjYWORyOUlJSZ9sbE1cXBze3t4M7d2V2eO/eTvGM8c0Nrncgy/LhkdG8/hpCI3q1sz1fjUajRw9dY6qlcrj6uKce0xsbvirZPQ/cPnU6/UcOXmGutWrULCAY86FRCNBT0NITk6hRpVKwBtE/01i+h7SKohGbvx5n1rte7Flyxa+/PLLv9z//zZ87HlXLpdTq1YtgoKCiImJQRAEWrRowfHjxwFo3Lgx9+/fNxPl12Nhs1RuNRoNEokELy8vQkJCAJPFsHr16kRHR1OvXj0eP37MhQsX0Gq1uLi4EBcXZ/5Ib926Nbdu3TK7OGdZWGvWrEmtWrW4ffs2AQEBJCQkZLOsZRGaLHdmuVyOpaUltra2iKJIUlISoigikUiyuVpmtfH6sdxsrdlWXIHtS7cYgwjLIjLZHKNhlIclvVxffWPEao20DUxFkEo5evQozZo1M1+LZ8+e4eHhgY2NDUajEScnp7fiGf8TZAkJqdVqChcuTJEiRbh7965ZJdhgMJiFp+bOncvmzZsJCgqicuXKPHv2zCzGZGtrS2RkJHq9HlEUzUrLJUqUICoqypxyx9HRkcKFCxMbG5vNDTYjIyPHxd+8Cg8pFAqzS/TGUraUtZbhb7DhUcXGVK9enRkzZtCkSRPOnz+PpaUlz549A0zu0kql0nxdBUFAp9NhNBopWLCgeayz3HcdHBwoUKAAz549QyaTUaZMGYKDg81u10qlkvT0dCwtLcnMzDTfE4MHD6Z48eIsWbKE0NBQPDw8zC7OVlZWfP311xw5coSiRYsSERHB3bt3cXR0xMbGBoPBQHJyMikpKebYVXt7e54+fUrBggWJjY01ezNYW1vj5+fH6dOnadSoEWfOnMHV1ZWUlBS8vLyIiYlBIpGY1bezrrODgwN//PEHpUqVolixYkRHR5ORkWF+drLi1pOSklAoFCQkJODs7Mzz588/2Xk3H38f/uctrQCjR49mzZo1bNy4kYcPHzJkyBAyMjLo16/fBx1n1apVeHh4ULhwYZSPBASdgBCjI+N+EgYr00sxMzAFXYqW1NgULJKlON1RUk1XjmKe3iSufI6oMyKIrxR0s96lugQNgkZEabDA9YUtDydfYUGT6chUplW0NP8YBB1gAHVkhsmwaTS+soRpRNa2WUDA5msMazuIg7/uIfRZKE0qNcSYpkfUiaTtfbnqLRPQxqsxpOvRx6gpqHUwJ/H28/Nj9OjRZJyONxMjdYTJ2mRUm8xX+hvpiCoD08qOJmlXGNWE8iifCVyZeorCV23N45V8wdSeIBHQJWno69WZgun2HJ+8z1ymWMGinBmyn6qFK/Hs8AOSljxncedZ2cZd9SQVTVgG8iQJE1uNxq2aF+qTiYTNDSRi0SPUIekYUnS89MKF11ICGbUGjJl6NCEZ6EJUxK59ivpBKnHHw9FGqV9ZwIU33JSNEHLzqSmn3tNk0mJSiLwRSuafKVSQlaSxsjbpdxIR9SLJV2LIjEhHH6om6VwUOp2Oxyfv8/TEQ9LDUnk+NQBDuo6k4xFoY1UY0t/hXp71bWIQUT1LQ/hDjSokHUOaDkOqDi+VK0KCEaPGNNkKUgG7CAXP5gZQJ7EiaRdj0aZpkadJkL8QEHQi+ig1SUcjUQWlINfLKBlXBAdbh1fW6Jfj5m7hgoODA9UL+yFG63F+YEXKqRhzmaiNTxBUYH1Xgphi+uAoUqQI06ZNw8nJiWvXrqFQKMwiK/ob6ZBmRHUmkfj4eMLCwnB0dEQQBBITEylSpAjx8fG4OrsyuuYQGjqbkrFbpEhAIqCNVpP2JInCd+zp1qUboiiiVqvRarWcO3cOTaaanvbtsTIqid4QjGA03duiXiTk9hNKXSnEspmLKVmyJNbW1hiNRho3bkzSn3EUkbkhFaQkHA5D8zDN9Ag9TSfo0SNKlSpFnTp1aNq0KcWLF8/9Wn0CcHZ2ZtSoUSzfsJ2Y+MT3V8BEwpas3UiXQSNJfz0J/Uur6+Cxk1i8ej23/ryX6zFOXfiDjbv2MnLSdNOGNy2Wr/2Lj4/ny69Hcei4f56sp9v3HeL7aXNztuK8UT88Mopug0Zw+sIfOR/stX78fvAoW37fz8TZP79d7jWL88BvJzBu5nzi4uLfIqxzlq6i5/CxaDTaPLkIi4KEHxeupHTpUnTr1u295f8/4WPNuz/99BPW1tZUr14dQTClYZFKpUgkEs6ePWu23kRERCCKIs7OzjRs2JB69erh4uJituBm5UvN+qDOQq1atfDx8aFDhw4sX76c+vXrY2lpiUKhQK/X07NnT6ytTZ5AZ86cISHBlLtZqVRSvHhxoqKi2Lt3L506deLkyZM8ePCAMmXKoFAocHBwMMdsZt3PMpkMuVyOk5MTJUuWxMLCgjZt2tCsWTP0ej2lSpUyL85JJBIkEgmtC8jp6u1M6ZIl2NiqGraCSJoo4aR7RRyWH+RB4XIAbI1VY3ztnt2dAnPmzWPy5Mlmwpp1XF9fXywtLfH398fd3Z3hw4eb9xcrVsx8jt27d+fq1at4e3ubxyEvyHJRVSqVxMbGmlV5FQqFWQQoa0x8fX3N5O3mzZskJyejUqlISUkhKioKhULBoUOHaNasGWq1Gp1Ox/37901p7F669yYnJ3P37l2io6PR6XSo1WrS09NzjW3OjbBm5W/NwoABA6hcuTKFCxdmZ7wp5rO2kE58ZDgzZ87kyy+/ZNeuXRQpUsRM7EqUKAFgXiipV68eJUqUoGjRohgMBrN1vlixYhQoUAA3Nzf8/PwwGo24u7uj0+mIiooyx3g6OjpiZ2eHXG6y8Pr5+TFp0iQUCgUHDx7k6dOn5gXGLNElvV6PRqPhzz//xM3NzbyQ4uLiQnp6OrVr1+bixYu0bdsWURSpWLEi3t7ePH78GFEUadiwIRUqVECv16PVaklKSsLf3x+JRMLEiRMpUqQIUVFRlCpVilq1apGYmEhCQgI//PADkydPxs3NDWtraxISEihRogRWVlasWrWKmTNnIooilStXRq/X8/z5c0JDQylXrhx169alTp06lC5dOs/3WT7+fyGftAJdu3bl559/ZsqUKVSqVImAgACOHz/+lkjE+7B161ZGjhxJWloaCqkFBUOsSDoXQ8KBcFCL6JM0SAQJffv2xcfHh4oVK3Lp0iWOHj1KcHAw0ZHRVIr1xWgwIqqNaELTTdxKhJTz0aASEdMMOCXZU7t2bbp06cL06dNJTk7Gzs4Oy9+1vJj6JynnTERCIhHQxqoRM41YPZXy540AKlSoQPfu3SlcuDDVq1fHzs6OytpSzKo6DmOs1uTOaxBJ2h9G4pJnqLbEEhsbS3x8PCtWrKBYsWL4+/vTq1cvbEJkKBOlxKx9ampPKUXUGrF+JKVOeHk2b9yMs6QAl3ad5c65W1z74yqtW7ameGIREMEz2hltrEmuXXskkSlfTuDG7LPYWL0dmwSmVcGE8DiaVmhksiZLBSR6geJRHvSw/5wp1UfzKO0pfT77khn753PixAnkcjlptxJQh2WY21JHZmLUGswuy5qoTBJ2hKIOy8C2gTNpT5KwKWGPj3tR9OdSzGTVtBhg+k9qFJgy6Qf0ej27du2iZs2adOzYEWL0xIgJXLh7EdXTNBIOvCDxSDhKT2t0Ej3aKJVpMeGNld2k01Eoi9qScTeJ5HOmVXpD5stJUzTFExsy9ejTtSScDEcXo0ZzNJGEy5Ho49ToYtQUtnVn35itdPBuhTFOj/inCkWqlPCAUIp8XYYrdvewr+OCXjBQt2Jt6papgcUVk9uyOjSd+ANhqFQqtmzZwpAhQ5AmvHKTFtQijlYOlCxZkqFDhqI4oSXU/4npuuzRMkjSCVFtZOHChaxevZoSJUpQpkwZxo8fz6pVq2jUqBHlypWjWbNm5hXW+ONhtEiuSXpAIoIg8PDhQ65evUpGRgZFihRh1KhRDBw4ELlczqnlR0g+Yfo4CVv9EOU1I4mrQxBFES8vL44ePcry5cs5efIkNWvWpH79+syfP59dy7aRuiYMY4Ye+wjTqnbm4VhEUUSj0bBw4UJq1arFgAED+PLLL7l06RJPnjyhWnQpqkWVxDLdguitT/HMKITB35SjUS6Xc+7cOaKiov4rxFy+++47LBQKfvxleZ7rnDx7ieSUVMKjYt7a1619G+ztbCnp451r/SoVyqFUKOjducN727r1ZyBanY4tu99WjM0Jqzdt58/7D3kW+o4whZdE9I9rNzEYDOzcfzjb9pzIcb0a1ZDLZHRr3+adca4dWjWlbElfCjo6vNr4sszpS1cJj4ohNo8WKf8Llzlx/g+mTZv+lhjM/3d8rHn32LFjjB49mps3b+Lm5oatrS0WFhYYDAacnZ3R6/UolUrGjRuHj48PNWrU4OzZs5w5c4aYmBiePXuGq6srV69exdXVFUEQaNKkCWBysY+PjycmJoabN29Srlw51q5dy5kzZwgNDSUtLY1nz56ZLaTOzs7Aq3hOe3t7Vq5cSeXKlWnXrh3e3t40bdoUHx8f1q9fT+fOnbOl2lEoFCiVSiwtLUlMTMTZ2Zm1a9eSkpLCixcvmDlzJmq1mlGjRpnLt7QTmOZtw9gCetbYJFDg6Z8YRdhg48uEg2dZunUnixYtws3NDY3Sho2pcp6pDFxL1aFs0p6xY8cyderUXMe3cePGhIWF8dVXX5nfd1u2bKFly5Y0adKEefPmUaNGDZ49e0ZcXBy//PJLnq6b0Wg0u00bDAYyMzNxdHTk/Pnz2coJgkCPHj149OgRQ4cO5dy5c+h0OgYPHkyXLl2oXbs2giBw+/Ztbt269VYbWZbp3GJG85JyJovwCYKApaWl2X3cysqKYcOGcerUKRo1asSlTAmpRgFrCTSLCGBE7Ypc2rWFhg0b8vz5c3bu3EnJkiXNpDXLQhsaGsqePXuoUqUKxYoVw9HR0XxfNG7cGD8/P+rUqWO2PoKJLGfdb/v372fRokU4OzvTsWNHGjZsyIYNGxgwYIA5923WAoBGo6F79+4IgoBGoyEgIIBHjx6hUqmoWrUqU6ZMoWnTprx48YJhw4aZXZMfPnyIVqvFaDSayXJkZCSXLl1izZo1lC1bls6dOzNs2DC+/vpr82JRuXLlOHjwIFKpFLlczvHjx/ntt98YMWIE9evXZ/HixVy7do2TJ0+yY8cOsxU4KCiIUaNGIZVK0Wg0GI1Gzp49a7a65uN/E/nuwR8BWW5KUVFR3Lt3j7Jly1K8eHHq1q3LxYsXEUWRck0q8TjoMWWcSuDq6oqLiwu+vr6MHTs227F+/vlnkoypHLpzjOdBzynY0aSQ6OFvxVOnKFKvxFGrTHUsLS1JSkrC1dWVxo0bs2rVKp49e2b68JEKFBhjWglNXheGXQlHSkt8eB4cwuDBgxk+fDhPnjxh8uTJJCcnI5PJsLS0NLk8FRNQ6uVkPk5FEAQqV67Mb7/9hq+vL5mZmZw+fZqzZ8/y9OlT7Ozt6DegH1+0/wLH0d4IcglpNxPQnU4mMDCQsmXLYmdnx6lTpzhz5gy///47R48eRaFQcCcwgOWLlnHp2mWS/bR8rmjMmjVr8jzmFebWI13MpKpLRRrrqiORSBg4cCBGjIw/OoOHcY9Z3XEBCZHxNJ7QGksfWzKepOBYuxC6JC2q52nYViyAUWckdOaf8JIfCoKAwseGIl+WJGprMKqQNAp298K6jAPx+0Jx6ugFQMajFFJ2hFOtWjVCQ0NxdHQkLCyMzMxMLEpYU6B9EdNxXz5dUlsZhnfkcJNYSnFq74n6RQa6GBUWHlak303CY3BJU57cVC2quylkPkvFopAlCuTYN3Blas8JWL+Qcf36dWIrZ7K+61KOXzrJ6F2T0KVoSHmcgGctHw59vxM7Wzu++OILAgMDkbayp2iYMz6Fi3Fcfwn1wXgEQUAqlZKUlETx4sWxbFAAVTEjaoMG/QsVdhckVK9enW3btjFu3DhOnjzJrVu30Ov1ZncuNzc3cyqDHTt20L17d7p3786CBQt48eIFarWakiVLEhoaSlxcHFOmTGH69Ol89913KJVKHj9+TLt27Vi6dCmxsbEULVoUDw8Pjh49ikajwdPTkwcPHvDll1+ydetW3Nzc8PLyomDBgkRGRpKQkECTJk1ISEjg+vXrnDhxAoPBQJUqVZDJZQxf9R1LBs5HoVCYPwwqVarEtWvXsLe3N/e9ePHiREREsHHjRtRqNVFRURQuXJjSpUtTqlQpmjVrxqZNm6hVqxbz58//5N2Uli5dyqhRo7hyaAdVKpTNvjMHF+HY+ATCo2LwK18GeIfL8PuQh5Qzoihy7PR5qlQsRyFnp/eWv/cwiGehYbRr2fS9ZQ0GA0dPn6NOtSoUeJ1k5tiRd1tG3xuzCkRGxxKfmEiF0iXee2ytVodfqy64Fi7C2bPn8hYakA8zsubdJ0+eEBQURNGiRalUqRLlypUjMTGRyMhIihUrxvPnzylTpgwlS5ZErVYzadIks1U1C+3bt6d+/fpcunSJAwcOoFAo0Gq11KpVi8DAQFQqFZ06dSIiIgKpVIqvry9OTk5s376dlJQUs7iPIAgYjUaqV69OYmIiXl5eREdHs3TpUho2bMixY8dYsGABRqMRuVxOwYIF+f3335FIJGi1WhQKBS4uLnh5eXHy5EkUCgWRkZGcOHHCpKQb/ow+aU+w9y1F813n0BhEjlSwRykRMABZyx5bjQUYuus427Zt48WLF6xdu5a0tDRSUlL4/PPPSUxMJDw8nKtXr1K1atU8j3nTpk25ePEiGo2G7777jtatW9O4ceO3yo0fP5558+YBJsueKIq5xrdmQaFQUKFCBe7cuWN2ec2Cp6cnERERGAwGnJycKF68OElJSRgMBmJjY1GpVGYC/LFhZWVlJr5KpZLevXuzatUqJk+eTPHixenTpw8A8+bNY+XKlbQvKKcnry1aCQK7VUo2xBuQSqXmmNOUlBRsbW1RqVSoVCqze7uTkxPu7u4cOXKE8PBwWrRogUql4tSpUxw/fpxevXoRHh5udku2sLDA2dkZlUrFhAkT6Nq1K3369GHQoEGMGzcOrVaLRqOhTZs27N69GzCJ9K1atYq7d+8yefJkatasiVqt5vjx48TExFCzZk3S09M5ffo0hQoVIiYmBq1WS5MmTfD396dmzZqkpqbi6+trtry2atWKS5cukZaWxp07d1i4cCGTJk3C3t6e9evX07FjRwoWLGiOZVUoFAQHByMIAl5eXpQsWRJvb29OnDjBpUuXzCrQPj4+jBw5kqioKJo0acLWrVtp06YN48aN++Tn3Xx8fOST1o+ArMnz+vXrVKlShfj4ePr27UtgYCByuRy1Wk3r1q3ZvHkzW7du5dtvv8XS0pJDhw4xevRokpOT2bt3L05OTlSoUIHSpUtz6dIlrByssfjMkbSEVD6zaMC+ffuYPn06oihSqVIlwsLCOHnyJPfu3cPHx4cNGzZw+/Ztmjdvjl0fD0BAejCDunXrsnXr1mx9fvToESNGjKBbt27079+fxMREKlSoQGRkpFkprnPnzoSFhZniCjMySEhIwNXVlcKFCzN8+HBsbGyYMGECe/bswbG9B5bl7AmbcQ+MYGdnhyAI/Prrr6xevZpBgwbRrFmzbMIO69evZ926ddy7d48jR45Qp06dPI/5/sCjTPWfx9ovFlLN0y/bPoPRwDcHJ/Fn1H1cbZ1JOBXJ5V3nKdKxBIbycpPLr0ksGPWLDESNEU1UJskno7Ar7IBDH09idjzFS+pBcHAwoqWAdXlHMgOT8JxgivOM2/Oc9JuJyGQynJyciI2NNa/kKhQKhMIWqJ+mfdB9VKhXMWQFFESve2ImuIX6+JB0MhLHpm6onqVjXdoeVCJKKyVX5p9h7LGpLGs/D0u5JcMPjGNVx19ITk6m0U9tUZ7VU/Wb+tR3rM6hLQfQarVERUXx4sULrIrZke6kJSEgGudybnzm2si84mptbY2HhwfR9ok4Fi1IkocKSZCByD1P8PPzIzg4mOrVqxMQEIBSqSQkJARbW1sqV65MsWLFGDlyJBUqVGDkyJHUq1ePzp07A9CpUyeCg4PRaDT06NGD6dOnY2dnR3JyMk5OTkyYMIGGDRsyadIkfv/9d6RSKQMHDqR+/frs2LHDnGfv+PHjODo6kpiYSOXKlSlZsiSNGjXi6tWrfP311/z000/ExcVRpUoV7t69S1paGiVKlGDr1q3mvI3ly5fnq6++4ssvv6RTp05s3brVLOIRGRlJ8eLFWbVqFXXq1OHIkSNYWVmRkZGBp6cntWrVIjk5mbS0NJo3b86PP/74yU+eer0ev8qVsbKQcmHv5uwW4g/IZfqXyeubyGubeVHh/U9zsb6jjRyJam51cjtOLtsXrN7IxHlLuH37NhUqVHhfL/PxBrLm3QcPHlC6dGn27t3LsWPH2LFjB56enjx9+pTZs2czbdo0fvjhBxYsWECtWrUYPnw4Y8eOxc/Pj+XLlxMREUGLFi1o1aoVe/fuJS4ujm7durF7925q1qxJVFQUs2bNIiYmhlq1anHhwgUuXrzIs2fP6NatGyNHjmTcuHEsX76cggULEhUVhZeXFytXrqRly5bZ+nzw4EEWLVrEjAE9cQ04R2qd1lTv3NNMtiwtLSlbtqxZzTUsLAxRFHFycqJWkUI0DziCqDZZZRN1Rk4l6+jirCBSY6BXUDpdPexJlynpPP9XVqxYwYQJE6hVq5Y5fypAt27dCAkJISgoiKSkpL9tscTT05Po6GgmTZqESqXip59+yjF2VCqVYmVlRVpaGoIg4OPjky3VSda4qNVqRFE05xW1t7cnNjbW/L1iYWGRLSXLx0SWhbNbt25s3LgxxzL79u3j/PnzxMXGMq2yJ1GnDkFyAlYGLSIwE3eCMgzEx8eTlpZG8eLFqVChAjKZjOPHj6NSqfDx8aFo0aLcunULlUqFtbU1GRkZ2NjYYGlpSZ06ddizZw9WVlakpKSg0Who3749tWrVomvXrjg4ONC+fXt+/fVXfH190el05ljR8PBw2rdvz/Lly8nMzESpVOLm5saaNWt48uQJoaGhTJ06lcTERHr06EHPnj05evQooihy5coVYmNjsbS0NKszN2jQgPT0dCpVqoS1tTVr167FYDBQr149Ll26BMDNmzfJzMw0L8qMHTuWatWq4ezszI4dO5gwYQL9+vXDzc2NYsWKcf/+fS5cuICDgwOhoaGAyUJes2ZNHB0dkclkqNVqmjVrxpgxYz75eTcfHx/5pPUjIGvyHDp0qDkw3t3dnebNm3P+/HkuX77M06dPUSgU/PjjjygUClJSUtixYwc1a9bEzs6OTZs2UbZsWaKjowkICKBjx46kpKSYP/Lt7e1ZtGgR586dIzw8nISEBDp06ECrVq14/PgxOp3OHFfh7OxMYmIicrkcKysrrly5Yo4B0Ol0rFq1ioMHD5KWloZSqaROnToMGTKEb775hn379mFhYYEgCGZVt7CwMBo0aICVlZX5xREREUHlypURBIE9e/agdLDCYGNEmSLn+++/Z8qUKbRr1w6ASZMmUalSpbfG7f79+yxfvpwjR468shJ/AC6FXKWWVzWkkrfriaKI/5NzXA+7Q0RKFBf/uICnpxfBmucYdHrsZHak6tMQkkSeLQ7AsaUH1mUcMKoNaMIyid8XmqMQg9cPFZFayohY+hAhyZgtD2BW8vQPeaSyJO9F0SSoJAgg6kUcHR1JSkrCpbs3KZdisKvuTOrhaAyigTIVy3LtwlWUSiUngs4QmxFPg2K1WX9zO1Obmiz3Fb+vQ7FgF6w6FWJrj5XZxqV79+48fvyYjPoCpb1LcWnJKfp26EXt2rU5ceIEAQEB3Lp1CysfO+x8C2Btb4OVQUHGnSTi4+MZNGgQNjY2hIWFoVar2blzJ4A57qR06dL4+fmZ41StrKxo0KABZ86cwWg0kpyczPjx4xkxYgQqlYpGjRrx/PlzMjMzycjI4Pvvv+fAgQPI5XKWLFlCq1at6Nq1K0lJSTx8+JBHjx5hYWFBamoqI0eOZMaMGbRv357Vq1fj4vJKHOy7777j0qVLaLVa+vfvz6hRo3ByciIlJYW6devi7+/PggUL8PX1pX379mi1Wjp27EinTp34/vvvqVWrFqGhoWYFRmtra1q2bImFhQUPHjxg06ZN2NnZYW9v/18xeV64cIEGDRqwZOZkhvR+I37yLxC/j0ZgPyY+5DxyIZMfRFTftf0d+569CMevZRf6DxjAkiVL3tXLfOSCrHm3a9euaDQaEhMTsbCwYMmSJbRr1w6tVktYWBhVq1bFw8ODQYMGcfDgQU6cOMGECRPYsmWLWRymUqVKbNu2DXd3dxQKBR4eHmYL0vXr1xk5ciQFCxYkIiKCoUOHUq5cOe7evYuVlRW1atXi4cOH1K9f3+xq6urqSkREhJkQJiYmMmnSJFJTU1HcvcIQRTISQGJlw5Bnaq5HxqNQKKhUqZJZGfXkupVkLp6IqwwypHKsDDosBNAigCjyuk7gQrU9oY6FuXHjBvPmzePAgQMcPHgwxzRAS5YsISEhgYMHD3Lnzp2/7fqEhIRQr149bty4gUwmo0qVKowZM4Z169bx9OnTbHHDgFl0Kctr53UoFArKlCnDvXv3zPuyCGxWrOuHILe5+nVXbTDNz0qlEo1Gw7Bhw1i8eHGux7x//z7r16/n0aNHHD582Lz9yfBOpF49Q7BOwqHyLXn8+DF9+/Zl2rRprF+/npMnT5KSksKNGzd48uQJoihSr149goODcXBwIDk5GWdnZ9zc3OjTpw+TJ0+mZ8+eTJs2DUdHR3bt2kWnTp0oX7489vb2FC5cmNu3b+Pm5kbJkiWJjIzk2rVrSKVS/vjjD5ycnLC3t2fmzJlMnDgRR0dHHBwcaNWqFefOnaNMmTIMHTqURo0asW3bNkaPHs3AgQOZMGECbm5uyOVy1q5dS5UqVejcuTPHjh0z3+d6vZ5GjRqRmZlJ5cqVuXnzJvfu3TO5pms0dO3alWXLltGxY0dWrlyJi4sLL168YMCAAZQqVYpjx45hb29PpUqV2Lx5M3K5nG7duvHkyROqVq1KVFSU2fvpv2XezcfHxacfkPVfhODgYFxcXKhVqxYWFhb07NmTSZMmkZKSQqlSpWjRogXnz5+nb9++1KhRgxIlSrBy5Urmz5/PunXr8PLy4syZM1hYWDBy5EieP39OYmIi6enpJCYmMnfuXHr06MHixYvx9/dnxIgR7Nixg3379hEbG8ukSZMYPnw4crncLM8vk8m4efMm7dq1o2XLlvj4+LBq1SokEgkZGRmUL1+elStXMnz4cB4/fkzVqlXNLs1ZGD58OBkZGTg4OODs7MyJEydIT0/nyZMndO7cGXt7eyRaKCx3w93dnfHjxxMbG0vZsmXp2rVrjoQVoFSpUsTExDBo0KC/FM9V17tmjoQVTG6+zUs0YnKT0azoOJ+AeX9wZOROxjUYCTIJKcY0kAhUr1iVwr1KIgiQcDiMlD9iid9vWuHLydVIHZ6OUWPAkGgSd5DJZFhYWJiFfPJCWB0dHWnXrh3169dnxIgRdO3a1SRlbxAR9SJ16tQxx3Km3UrAsZE7KRdisLa2Zt+effx5PcAcU1PXuyaXQ28QlhxJEXt3cxtytZQCdd1weCNVkCAIZovjwIa9MdiJuCgKcubMGY4cOcKYMWOYPn06arWalrWaoXC2pG69ukTdD+fChQt0796dP//8k61btxIVFYVGo2Hbtm1m1+jSpUuj0+k4ceIExYoV4/Dhwxw8eJBSpUqxc+dOTpw4wfr167lx4wZnzpyhZ8+etG/fntDQUJRKJaNHj8ba2prjx4/z66+/8uOPPzJo0CDc3d2xsLDA29ubkSNHEhMTw4IFC7h48SL16tUzf2gcPnzY/CHm7OxMRkYGfn5+7Nq1i4oVKxIfH0/z5s1p0aIFXl5erFmzhs8++wwwubFlPY8LFy6kffv2WFtbc/LkSTIyMpgyZQpjxozhxIkT5vQEx44de+/1/lRQv359Bg8ezPjZv/D0+YvsO/9CXtWsNC+5/ftXkFve1TzkY31n2prcLKt/gbAajUYGjJmCSyEXZs2alWOZfOQdcXFxFClSBC8vL/r27Uvp0qXp0qULJUuWxNbWluHDh6PT6WjRogUeHh6MHDmSQYMGce7cOb788ku6du3K+vXrAWjUqBFGo5GbN2+aLXvffPMNq1evZs6cOZw8eZKWLVsybtw4goKCCA4Opnv37ty5c8fsvSCRSPD09GTKlCm0bt2ahg0bUr58ee7euEahpwEMfklYAYyZ6fS3NzBv3jy6d+9uFnFKu/UHNssnUkQOcgEcjCbC+lBlZEfl9hz0rG4WaQw2ynFu2o4LFy5w8+ZNoqOjWbhwYY6EFUwq7teuXWP69Ol/63Xx9vYmJCQENzc3nJ2dadasGRMmTKBz584cOXLkrRy0We7DORFQnU7HvXv3sLS0RC6XI5VKsba2Ri6X55mw+vr68tlnn/HZZ58xcuRIPvvss2zCUatXr6Zt27bm31n9c3Z25vHjx+8krFnHDwkJMVtBs+A54ReQSPCVG5E9us3Ro0cZPHgwWq2WXbt2cf/+fX766SfWr19PbGws7u7uWFpaMmjQIAwGA/7+/hQrVoz09HSmTp1KpUqVcHJyYu3atYSHh/PkyRPKli1LUlISL168wM/PzxxnWrlyZdatW8fdu3cZOHAgV65c4cCBA3Ts2JHw8HCkUimenp588cUXNGzYkIsXL9K1a1fGjBnDpk2bOHXqFHXr1sXNzY0KFSqQmZnJunXrmDBhAnXr1qVevXo8ffqUAwcOEB4ejkwmQ6FQmPPqenl5YWtrS2xsLEuWLOHhw4d4eZlCrLIWmD09PRkxYgSnTp3i0qVLODk5Ubp0aSZOnIjBYGDu3LkMGTKE7du3U7NmTeLi4sxijvn430O+pfUjIGvF9/79+yxcuJDMzEwGDBhARkYGO3fuZO/evTRq1Ii6deuyfPlyypYtS4kSJZg9e7Y5D5bRaCQiIoLMzEzUajUKhYKaNWvSu3dvVq9eTZkyZThz5gydO3dm/fr1FC5cmD179nD58uVswgebNm1i8ODBFChQAI1Gg1arpWvXrixdupTevXszbNgw6tevT9euXZk3bx61atVCr9djZWVFamoqfn5+dO7cmcmTJxMQEICrqyu2trb4+vqaBQfOnj1rlmnPsmKFhoYSFRVFu3btmDBhwr91Kd4Lo2ik0ar2iEYjHcu2pVe1LsTHx/Pt4FFvEZA3UwkA2NZwwr62C+ELH+SpPWdnZ9LS0swWWW9vbwIDA4mLi8PT0zOba9ZPP/3Ezp072b9/v1k5NysxvYuLC1u2bDELhLyOr/d+h0Jqwdc1+1C2UCkAWo/uSKq3BuUxHWt+Xc3YsWNJS0tjz549WFtbc+TIEe4G3qV9vy9YPGUBW7ZsQRAEOnXqxM8//0zBggUZNnwYx6V/oElTM6JMP4w6IxMmTODo0aOMGTMGW1tbHB0dzSklxo8fz9GjR/H29sbR0ZEFCxYgkUiwt7dHEARiYmJYvnw5VatWZdWqVRw5cgS1Wk2DBg2oXLkyQ4YMYfz48ezatYtr167x7NkzM7kMDQ0lPDycWbNmceTIEXQ6HRYWFvTq1Yt79+4xaNAgsyXx+vXrqFQqUlNTmTJlCh07dqRRo0ZMnjyZatWq8eLFC1atWsXevXvp2bMnBw4coHbt2vTv3x9XV1eqVatGy5YtCQ4OJiUlhfPnz/PHH39QvXp16tSpg42NDU5OTlhaWlKqVClz3sf/hhXf9PR0KlSogLuTI6d3rc95seg/dbd9Dz5FC22O+WlzQl7I/XvKLFq7me9nLeDs2bM0aNAgjz3Mx5vImndPnTrFsmXLzKT1xo0bbNu2jRs3blC+fHk6d+7MsmXLKFmyJK1bt2bo0KFmgpkVr65Wq1GpVAQHB9O/f39++OEHJk2axIQJE+jUqRMTJ07kwIEDyGQyhg8fTqtWrWjdujVgsvj17duX7du3U7JkSYKDg/H09GTixIm0b9qItR0b09hWwJicYO77nQwjC+Jho6cEiQB7K39OUFI6ARfPce6HkURvWopgNBAlKMjoNJjjO7YRHB3LAzVYvlRcPbNtA2t//ZVTD4M5fe48vr6+/8Zl+CAkJSWZFZPv3r1L69atCQ8Pz1Ymr26+WW7BOaFcuXIEBgaaf/ft25eFCxei0WiyCX1lWVBDQkI4deoUgiAwY8YMszBVyZIlOXPmDG5ubnk6vzZt2pjFotq1a8fEiROpUqUKIx10JBzcSqaFJVZ1W1K0flMqDx1HUlISXl5edOjQgR9//BGpVEqdOnXMrrFt27alb9++VK1alblz57Jhwwbq1auHVCo1a4DUqlXLrDjdokULU3aHl0YGMFmAV69eTcOGDbl58yazZs0iMDCQ/v37M3HiROLj4wkKCmLGjBns2rULqVRKu3btsLGx4eLFi+h0Og4fPsy8efPMqeGKFy9OkyZNcHBwICkpiapVq/L777/j6OiIj4+P2TNwwYIFhISEsGXLFgIDA2natCk2NjbmWNgmTZrQt29fIiIi+Pzzz5kyZQrLli2jcePGzJ07l/Pnz1OjRg1KlSpFiRIlcHZ2RqFQUK9ePQYMGPBfM+/m4+Mhn7R+BGRNng0aNGDevHlIJBKOHj2KnZ0d3bp1o1GjRjx79gxRFPHw8MDHx4exY8ea4112797NypUrKV68uDl2ITk5mZUrV5oTo/ft25cVK1bw+PFjBg8eTLdu3Thw4AD79u0z58kC0wRqaWlJz549cXBwYPHixaSlpZGcnMzo0aPZtm0bly9fZufOnVSuXJkxY8bQpk0b/P39SUxMpEOHDsTGxmJra0vx4sWxt7dn6tSpBAUF4ePjA5gItsFgoH79+sTExNCqVSvKli3LzJkzuXnzJu7u7rmO1aeAP55fJyEzkc/LZI83ioyMpHz58mb1upwgd1bi2MSN2B2mHH5ZrkyCIJhFOF7H0aNH2bp1K9u2baNUqVIMHTo0W+qA96FOnTqEhYUxduxYRowYkWOZbQF7iEuPZ1Tdr83bpv80A9/yJRAT9SxatAh3d3dkMhmOjo7m2JPWrVtz/PhxZs2axS+//ILRaGTZsmVs3ryZo0eP0rx5c9JcNKT4aDnabzs//vgjycnJeHl5MXPmTPMH94kTJ3B0dMTNzY3y5cvj4eFB0aJFWbt2LT4+Pjg6OtKiRQvWrFmDQqEgKioKW1tbbt++zezZs3n+/DkDBgygcePGnD592mx5L1CgAC4uLtja2nLhwgXs7Oyws7PjzJkzWFlZodVqad26NSdPnjR/wGSR2ejoaOzt7dm+fTslSpRg7ty5HD58mISEBAoUKECzZs04efKkOdXEjh078Pf3JyAggIULF3Lz5k0qV67M2rVr+e2337C1tWXu3LmsXr2aoKAgLl26xIwZM5gyZQqNGjX6r5o8L1y4QMOGDZny7VAmfzMk94J/M3nNCbkR2twst/8JAf4o8ap53f8StwMfUv+LPgwZMpSFCxfmqU4+ckbWvNu5c2dmzZrF06dPOX36NH5+frRq1QovLy+zgE7NmjWxtrZmxYoVeHt7o9frmTp1KgEBAfj4+JgVex8+fGiOp7ewsODEiRNmTYgTJ07g7e2NVqtlzpw5ptQ418+RcvUskU5e1O7zNf7+/iYvGYMe/xFfErt7LcJrlkCjQslVC2eWPE+hS48vKbFvGeWspFzTK8gsUZnaT6+ieHlLB6rhiwtPsClg0oHQ6/XExMTQoEED5HI5c+bMYfPmzdy9e5cnT5784+P/sXDkyBHatWuXZ4vp63NtlnigXq83zwESiYSEhARzuFWlSpXYsWNHntOTiaKIq6sr9vb2bNu27YOEqtq1a8fevXsZPnw4jx49wt7enoyMDIb07kmxDdMxpLxSvV2sK8hVlUBCQgKzZ8/m6dOnDBkyhKFDh1K8eHEuX77MwYMH6dWrFzKZjC5dutC8eXNq1KiBl5cXV65c4caNG7Ro0YIyZcpQsWJFUlNTOXbsGOXLl6do0aIUKlSIAwcO4O7uzq1btyhTpgwXLlygbdu26PV6Dh48iKWlJfPmzeOXX36hYMGClC1blsTERJycnLh8+TJ2dnYUKlSIs2fPAnD79m02bdrEokWLgFeWcaPRSEpKCpmZmZw4cQIHBwcePHjA5MmTSU1NJSoqiuXLl7N8uUnFPjExkc2bN+Pv709cXBzbtm1j9erV9O3blzFjxnDkyBE0Gg2tW7fGwcGB7du3s3btWk6ePMn8+fMpXrz4f9W8m4+Pg3zS+hGQNXmGhobi6en51n5vb29KlCjBhQsXuHbtGqVKlaJ79+40bdqUoKAgIiIiKFSoEL1796Z69ermenZ2dkycOJEVdLH+iwAAQwFJREFUK1bQokULVq9eDUB4eDj79+9n0KBBhIWFUbFiRcaOHcuPP/7IixcvqFKlCp6enmRkZBAVFUVMTAyrVq0iJCQEpVLJ9evXqV27Nvv27WPx4sX89NNPZGRk8OzZM0aPHk2PHj1QqVTUrVuXuLg4vvnmmxxl7G/fvk18fDxLlixh6dKl9OrVyxyA/98Ko9FIxYoVs63SvgWpYMrYDua8aCqVCplMhr29PampqWi1WuRyOZmZmej1eipVqoSrqyt79+6lQIECH9SnrNidD9l/+PBhAgMD8fb25tChQ/zyyy+EhITQtm1bQkNDsbKyYvDgwYwdO5aJEycSFmZKH7J06VLOnDnDmTNn8PMzCVyV96tAclwSgwcP5sWLF+Z7PCAggGbNmtG7d29CQ0M5ffo0t27dwsbGhlOnTlG7dm02bNjAhQsXSE9Pp1OnTowaNQq1Wo27uzt169alaNGiREZG4uPjw5MnTzAajfTp04du3bpx8OBBVq9eTUZGBqNHj0an09GzZ0/2799P8+bNWbBgAWvXrqVEiRKUKFGCgIAALCwscHBwoG3btmzatIl27dqxa9cu5HI5Bw4cwOL/2rvvqKiOt4Hj36WDgEgRQhOJLYIae69RlCiIJVixd+waS9RYo6jYa2JUbCj2goVoFHvvKGLDhiAISK+79/2D1/1JQAUFRJnPOZzj3r1lZmV49rl3ioYGAQEBuLu706lTJ3r06MG4ceOIi4sjIiKCTZs2ERkZyc2bN1m2bBm1atXCycmJU6dO8fTpU9TV1Xnw4AE6Ojro6Ohw8uRJwsPDv7rgOX36dKZPn47vxtU4NM75BGgf9AWS3P/6WBL7wW7LuU1Wc9mlOupNDLWdumJsasbp02eUXfyFT/M27r59evdfmpqatGjRgjNnzihny+3VqxdDhgxh/fr1mJiYYGlpyZAhQzA10Cf62H7eSDLsO/Xm33//pWXLlpw+fZqqVasCcO7cOUJCQvjll19YvHAhr1bOouM7l10ao85js3I8vh/EcnMJa9WML/Px2vqcs6jE3XR10tQ0uHHjBr6+vgwcOBC1x3eYbZT5qeJjhTorgqNZfe4mFbJZj3LLli1UrlyZ3377jZ49e3L69OmPdl0t7MLDw7GwsHjv7L//nV9CW1ubtLQ0FAoFxYoVQ1VVlYSEBNLS0rC2tubp06ccOHCAhQsXoqWl9UnDOD4Wd7MzatQounbtipeXF7a2tgwaNIgVK1awfv16bp8/S/iudTxePRdtSU4iqkxULU1CahpXr16lQ4cOJCUlUalSJeWkYCNGjMDGxobXr18rn/bOnDmTBQsWsGHDBsaMGYOmpiaXL1/m2bNn3LhxQ/lUNjAwEBUVFcaMGYOLiwtHjhzBxcWFZs2a0blzZ3x8fJTjiFVUVJgzZw52dnZMmjSJ8PBwgoKCWL16NatWrVLGRTU1NRwcHEhISKBcuXKoqKgQGhqKXC6nUqVKVKlShfXr19O/f3+8vb2RyWTs378fgNmzZ3Pnzh06d+5MtWrV6N+/PyYmJhgYGDBz5kyCg4M5ceIEvr6+aGpqsnnzZvr27Yu+vj62trYcOnQIKysrYmJiCAwM5MWLF19d3BU+n0ha88Db4Pm+BmRiYsLYsWOZOnWqcoxHcnIye/bs4cGDBzx69Ihff/2Vfv36MWzYMLp166ZclHnHjh1MnDgRbW3tbBPCGjVq0LhxY7y8vFBTU6N8+fKkpKRgZ2eHlZUVGzduZO7cucyaNQsVFRU0NDTQ0tKidOnSaGtrs3r1au7evUtkZCQLFiwgKiqKdevWoaGhQZkyZTAwMCA8PPyD9T948CAzZ86ke/fuuXqKWFi9XYfsLU1NTSZNmsTvv//+3mPezi4oSZJyDbMyZcoo74Dv2rWL0qVLKxPB/CaXy3FzcyM6OpoDBw4ox+e4urpiZGTEqlWr+Oeff9i0aRPR0dGEh4dz//59WrVqxbp165gzZw5lypRBS0uLVq1a0a9fP+V0+e/q1q0b/v7+aGho0KNHD6ZPn56j8i1evBgvLy/8/f2pX78+ffv2ZfTo0Vn2CwoKQi6XU7FixtIrDg4OBAYG4uzszL///sugQYPYsWMHiYmJuLu7Ex8fz8GDBwkPD8fIyAiZTMaPP/7ItWvX8PDwoHbt2jRv3pyXL1+irq6u7HJcv359Jk6cyPXr12nRogUnT57E1NSUJ0+eYGhoSL9+/ZRt9sCBA+jr65OSkoKKigoGBgZfXfBUKBS0adOaixcucOngdkpZ5n/vCEmSiIqJy7y+6RcUGxePlqYGGhoaWRPQz+kenA2FQoFL3xFcvHmHa9euKcd1CZ/uY3FXS0uLPXv20KFDB+UT17CwMPbs2cPly5epWbMmZcqUYfbYkXgaJEBCLBIw8AWcfxaGWcmSrOnuTN0q9nzXexQytYx1J6PDX+HTzI6aWhm/CwkKKKYCaTIVnvSbzhuvRdRMiwI1dRbHaHBXxwQ1NXX09PQoVqwY3bp1w9XVFX9/f4yNjTnb14ka8owxkEk/NqDx2gO4du7M1q1bP1j/CRMmcObMGZYsWUL16tXz8JP9Mm7dukWVKlWUrxs0aEBwcDAhISHvPUZNTQ01NTXl0z65XM7QoUNZsmQJqampbN68mRYtWmBlZZXv5Qd49eoVzs7OtGjRglmzZim3W1tbs3XrVurXr89vY8fgdHozGvI0Zr1W5VySCh4eHlSvXp3r169z/PhxFixYwLlz53j27FmW71RvE1sdHR1CQ0Px9/fHzs7uv0XJVoMGDahTpw4ODg6MGTOGv/76i7p162bZ79SpU9jZ2SlXezA2Nsbe3h4TExNu3rxJp06dOHfuHCkpKQwfPpxr165x5swZEhMTMTU1RZIkjIyMePz4MWfOnEEul2Npacn3339PeHg4aWlp+Pj4EBcXx4gRI5TfSYOCgtDS0iI0NBRzc3MWLFjA7NmzUVFRYf/+/SQkJKCmpoZCoRATMRVRImnNA2+D55MnTwgJCaFatWqZ7qKXLFlSOdZl8uTJuLu7Axlf4lq1asWOHTtYtmwZISEhbN++natXr7Ju3ToOHjxI9+7d2bNnD8HBwTx9+jTTnb8LFy7wyy+/EBgYiJGREbVr1+bKlSs4Ozvz+v8Xt2/atCmenp6oq6tjY2ODtbU1pUuXpkyZMvTu3TvjC9v/27RpE0+ePOH58+dcuXKF6tWr4+npSfHixQvokyw8Bg8ezOrVGbPu+vr60rp16yx3Xa2srEhJSSE2NhYdHR3lwvVvZ8lt2bKlsgvNl5CWlkZKSkqmCTkiIiL44YcflOsNHj58GF1dXeVMknfu3OH58+doaWkxZswY+vfvT4UKFWjbti2bN29WjsF+Sy6XU6FCBYyNjdmzZw9mZmY5KptCocDU1JQOHTpw4cIFrl+/nqO72g8fPqRevXocP36cwYMHo6Ojw969e1EoFOzbtw99fX0cHByUv9dyuZwePXpw/fp13NzcaNWqFU2aNGH58uW4ubnx+PFjZs+eja6uLoMGDeLWrVt4e3uzbNkyLC0tGTt2LMePH+f69evUrVuXRo0aKdcfhI9/cS7MoqKiqF69OnrampzY4UVxfb2PH5SN6Dcx6Ghro6mp8cH9Fv+9ke37DzOinxudnH/+3xtf4AltVPQb2vQYiFEJAw5sWJX5zf8kppIkER7xGlMTIz7V+NkLWbQmo9v9f5dBET7N27Z3+/ZtUlJSMiVugYGBODg4oKKiQkxMDMHBwZQoUQKA0NBQRg4awIJWdTnqvYFyqTFoyf/3tPOxuj4lZ68jYmxXSssytutWb4CtxzqQyznVoR4GCdFIKipMehRPywkzsN3wB1ZamceHT32p4JaaPqVKlaJcuXKYmppSr1492rRpk2m/fr174Wiqy9GgJ/xz8y6jR4/G3d29SK7ba2lpqUxS09PT8fPzU44dfuv7778nMjKS1NRUihcvjp2dHSYmJoSGhnL79m1OnTqlvMn5JcTGxiqf/r7l5eXFokWLuHnzJhEREdz7rT8610+RYF2evrdfo62tza1bt4CMcbG+vr4kJCTQuXNnDhw4kOUaFy5coG/fvpiYmODv75/jsl2/fp3WrVtjbm5O8+bN8fDwyNFx06dP5+jRo6xcuZIhQ4ZQs2ZNFi1axJMnTzh16hTly5enVq1ayt/ZmJgYWrduTWhoKHv37uXQoUPMmjWLW7duUbp0af7991/WrVvHDz/8wIABA5Q9Af/880/kcjl169aldevWjB8/npo1a7Jy5cpM6wF/zXFX+Dwiac0DbxtQ3bp1lQPR3y5jEB8fT9myZfH29mbXrl0EBQVx9OhRAI4ePcr58+dp0qQJa9euxcvLi6FDh3LhwgVCQ0PZsmULI0aM4IcffuDixYvs3bs300y8jRo1omHDhkRGRvLgwQMePHhAZGQkJUuWpF+/fpQvXx4XFxcsLS1JTk5m27ZtH/zClJKSgpOTEyNHjmT79u14eXnl58dWqL1dGD41NZWkpCRUVFQyfYmQyWSsXbuWwMBALl68yJAhQ3B1dWXo0KFERkZy+PBhLly4oFxqqDBxcnLCzMwMFxcXUlJSSEhIQFVVlbi4OObPn8/48ePp378/zs7O7N69GzU1NeXadG8XUn/Xhg0b+P7772nQoEGuytGpUyd27txJ165d2bRpU46Pq1SpEj/++CNHjx7l6tWrGTMvf0BoaCgODg6kpKSgpaVFTEyMcqKLj0lOTsbSMmMpifr163P16tVMk3J87cHz7t271K9fn2r2FTjgtQoNDfVcHR8W/pr2/YZR0siQvetXfHBfn/2HWLDaizkTR/FTw6x393NzzVevX1PF7hO+mP5/QhqfkIhLH3dsrCz423NWpvf+u//Kjdvw3nOIvl3a09vVJdeXXLbem9HT57Fs2bJvoidKYfG27TVt2pQ3b97g4eGBg4MDAAsWLMDf3x8HBwe8vb3p168fffv2BWDKmFE4B/ihEhmmPFeiJOOgTR3aBp9HQwXuy9Upp5qW+YIqqiBJGb8naurMidFCpVJt7ty5g+L5IzaW01HOCqzaqDWN1+7HwMAAf39/Spcu/d56XL16FS8vL/T19Slbtiy9evXKy4/pq3Lq1CmaNm2KlZUVT548UY5RfTte1dDQkKNHjzJ37lySk5P5/fffsbe3x9HREYDbt28TERHxhWuRlSRJWFpasnLlSl6/fk1VI12kWYNBRRVfw/LsvRXEPzfvYmBgQI/2LsxrWoX02DfMehzH1Fl/ZBl2plAoWLx4Mc7OzrmegMvGxoZnz55x4cKFTMPRPiQtLQ0LCwsaNWrEo0ePlMsYfcjBgwcZOnQojRs35tChQzRt2lS5PN7H/Pvvv8plGFetWsWtW7cyff/62uOu8Om+/CCkb4i+vj5t27bF29uba9euARmT1FhbW9O0aVOmTZvGnTt3lPt7eXkpZ41bvnw5MpmM6dOno6Kigp6eHk2bNuXatWusWbOGMmXK8Ntvv/H48WO8vLyYPHkyT548YcCAAWzfvp29e/fi7OyMo6MjVlZWnDp1ihIlSrB37140NDSYO3fuR+/wa2pq4uzsjL+/f5FfO9DQ0JA//viDJk2aKCe5evfpubm5OQ0bNmTevHmcPHmSTp06IZPJmD17tnKyn8KYsAL8/fffHDt2jHv37rF582aOHj1K9erVadCgAfb29syaNYuNGzcil8uVgal9+/YsXbqU0qVL89NPP+Hi4kJSUhJpaWnMmjULV1fXTOvb5URISAh9+/bl6NGjuVrbdtiwYfj5+eHt7f3RhBXgu+++Y+nSpTx58oRHjx7lanZrLS0tWrduTYUKFXB2ds7xLJJfi4oVK7J3717OXLpGv18nZ5lI7GO0tTTR0dbC0vzjT9g7Of/MpUPbPythBeg5YgKjp3nw+MnT7Jey+dDP/9MtpsMxn/UZCWt2S9e8s83CtCRp6emYlzRRvi2TFDn62X3wH8bMmM+YMWNEwpoPPEoXo6dKJL1+bkH37t1JS8tYiuz06dPUq1ePYcOG0aFDB3bt2gVkfPk2P38QlcgwEtQ0MW7fC8uRM5HN3oT35dvcMMmYbPBtwuoVo8rjHr8hlTABhRwkBa9Q50n3CdySa7JixQrKlStHnQ5dOKhvyyudEqQ3acup7yqhpaXFsWPHPpiwAlSvXp3k5GSsrKyyvSlYlDRq1IhWrVoxfPhwAGWi8jY+vB1i4+Pjw759+6hevTqampr88ccfxMbGUrNmzS9W9g+RyWQsXLiQ6dOno6qqyq9L/yREVQcUctq8vsuf5nJGd+7Als2bGRhzl3Dv1UT5bqOXhS7dunXD3t6eli1bMn78eCBjPglPT89c/768naywZ8+euYqD6urq1K1bl8ePH3P48OGPJqwArVu3pkOHDmzZsgW5XM68efNyfL2ffvoJFRUVRo4cyZ9//lkkex0I2fv4b56QY9WqVePnn38mMjKSSZMmcfjwYfz8/JSzzxkbG6NQKEhISCA5OVl5p7Bt27bs37+fbt26YWxszLZt27h8+TKQMVayb9++BAYGEhoaSqNGjZRTtu/Zs4eBAwfSs2dP9PT0WL58OQBdunRh9OjRnDhxAlVVVezs7Bg4cGD2hf4P8cXqfwYNGkTHjh2Vr+3s7Lh69SoymQxDQ0PlbMrvKl68uPJJemFlampK7969qVKlCp06daJmzZrKp+rx8fGYmZmxfv36TPXT1NREkiRMTU0pVqwY3bt3Z8mSJdjb2wNQtmxZVqxYwdixY7NcLyoqimHDhjF58mRlIi9JEg8ePODIkSOcOnWKQ4cOZekG9j7Pnj3DxMQkV7NUv+0m/9tvv2W6cZQTAwcO5ODBg8q6fmsaN27Mxo0b6dKlC1qamqz2mKa8UZOtdxK84nrFOLZtbZbtmeRx998Wjepx5WYAZiWNP+9EORy32rZlM9q2bIbsY+uy/sf+f/zpNuI3OnfunKsvbELONTfUgDfPkR3fSMdSxhyZ6I7V9eN0i4zBtk93ALq1c+bun/NJCLjKiUtXqJmasfTM43pt0fypE7Vr18YUWLlyJeZGhqhO60t6VAQ35ZrsiEllxchx2Jayxt7IEgMTE2av3USNGjXYvXs3JiYm7NmzB7lcTps2bWg2bSH/nDxJ8psY3N3dczxj7dvlSwRYt25dpqdnbydhUlFRwdbWNttj6taty5UrVwqqiJ+kU6dObNq0ifbt22dMfLRgPuur/kBCwFVUAZeY+6z643fmGiQoj9E5tR9FiimGhoY0a9aMp0+fcunSJVauXEn16tW5dOkSr1+/xtg469/CW7duMWPGDLy9vZXDZW7duoWmpiarVq3C2tqapKQktLW1P1p2SZJISEjA0NAwV082PT09uXbtGg8fPuTGjRu5GsvfpUsXli5dqlzPVRBAPGnNU7Vr12bQoEH06dOHGzdukJKSwqlTpzIlPmXLlmXHjh0sXLgQuVxOyZIl2b17N+PHj6datWpMmTKFJk2aKLtGjB8/HlVVVZYuXcrBgweJjY1l5MiRXLx4kRMnThAQEJBpjB1kLB7+8OFDxo0bh5aWFn369Cnoj+KboKGhkSkx6tSpE2pqaujr62NpaflV3/0bMGAAf/31F+bm5shkMl6/fo2Kigo//vgjjo6OBAUFERwcrNx/x44dSJKEra0tycnJVK1aFX9/f+WaauPHj2fjxo3Exsby8uVLLl26RGxsLGlpabRt25bz588zaNAgXrx4QVJSknKWYV1dXXr16pXt2N+oqCjlJGDBwcHcvHmTyMhIrl27xv79+5kzZ06u6nzy5ElOnjzJo0ePcvVEcd68edy5c4d9+/bl6onw16RTp05s2LABL589DJowLevnk83Tyhz7wBPPTzF2cB+2rV6ITg6+bOWqDO/Z/vapaW7s/8cfV/dxtGvnwoYNGz58E0D4ZK/TFCQVK46UmkJfKQxz/53IY6KwVZOj4jmayCM7CevdHPfiadzr68h3KyciQ+Klhh6rz15XroPp4uLCwIEDadXWhYvO7vxhUpNtxnbcvnOXQYMGkZiSyrS/N7Jy1wEGDBiQ8XS1Th1lOVRVVTExMaFcuXJMmTKFhw8fMmDAgC/4yXy9TE1NMyVStra26OvrU7x48VwPQSlsevXqhZeXF6VLlyYiIYkKXkex33sVBWBDKoP1UgDQr9MMNSNTSEliiCycbumhVNm5iGH6KcydMV0ZTxs3bsyCBQt4/fo1oaGhXLhwgbS0NIKDg+nRowcnT55k0aJFPHz4EEmSWLNmDQ0aNEBLSwtbW1u2bNmSpYzBwcHKdeVPnTpFdHQ0fn5+1KtXj65du2Y7IeP7JCUloaGhwcGDB7O91vukpKRw9uxZjh49yrJly3J8nPDtE09a81DdunWJiIhg48aN6Ojo0KxZM4KDgzPNvuvk5MTo0aMpVqwYEydOZNOmTVhYWODv78+UKVPYv38/O3bsIDo6mq1bt1KnTh1u376Nk5MTGhoanDlzhq5duzJmzBi0tLQ4dOhQpsmUAFq1asW4ceNwdXVl9+7dnzTdu5BV/fr1sbCwQJKkbGfc+5qYmZmhra3N1KlTadOmDd7e3owcOZLu3bszevRojI2NMTc358WLFzx48IB169ZRvnx55SLlu3btonPnzkycOJHRo0fj4OBAp06daNu2LSVLluTkyZPKZX9KlCjBsWPHqF69Oh07dkRPTw9zc3MaNWoEZCTQM2fOZNu2bXTu3JmrV6/y66+/8uLFCywsLJgwYQJz585FT0+P5s2bK2dGliQpx8sSJCQkEBcXR7t27bCxseHevXs5mqwjLS2NtLQ0li9fTpkyZbh27do3MVNndtzc3ICMcctpaen8NW866urqn51kZutD5/yUJ7OfU8YPHJvbZBXA54AfPUdPoV07F7Zs8c74DIV84RIQw8uw++zr0gL7mBAi0hRcVuhQQxaPaWI8Tya/kzjKM5ZMkWQqLE/SpXtfN/r370/btm1RVVXl8uXLeHp68vDpM7r07sPOnTsxMTFh5cqV1KhRAxcXF+VyXSdPnsxSFkdHR44cOUKjRo3Q0NDI8aR0woe97d6dkpJSaLv/5pSLiwstW7bk8uXL1K5dm9u3b1OpUiUirCti+uwuNqoZv6OarVwJqxyKzl/TqSAlQmrG7NeJx/bQSsuEm3I5TZo0wdjYmFatWhEUFMSbN28IDAxUzmpfr149Zbw+deoU5ubmnD59WjnBZI8ePZg4cSL16tWjYsWKeHt7M2fOHLS1tTE0NGRIz+7c85zEw9qNORAaR3R0NOfOncPY2DjH3ZJPnjyJgYEBrq6u6Onp5TheX7lyhZo1a7Jx40YCAwORy+WZJrYSii6RtOahLl26sHnzZkaMGEFKSgqPHz/GzMyMFStW4OzsTLt27bhy5QpGRkZMmTIFc3NzYmNj8fHxQSaTMWvWLOU06ZIksXr1alJSUqhXr54yMa1cubJyDdH3/QEwMzPjzZs3TJkyBRcXlyxJrfBpvvvuO6ytrXnx4oVy7b6vmbu7O8OHD8ff35+OHTtiZmaGo6MjkydPZs2aNdSpU4dffvmFmJgYTE1Nadq0Kbq6utSsWZPdu3fj5uZGfHw8pUuXZv78+RgaGlKxYkWCgoJwdXUlJCQEDQ0NwsPDGThwIHZ2dpQsWZLhw4fTrl07Dh48CMCsWbMoXrw4f//9N9euXePs2bNEREQQHR2NpqYmbm5unDx5Ek9PT1asWIGbmxvDhg2jUqVKPHjwgHLlymWql1wu59GjR5m2X758mcTERHbv3s3gwYPx9/fPlLS+r5vU9evXAYiOjiYgIABfX99vNmmFjMRVXV2dHj16EBYegc+qBejr6X78wLyUH0nyJ1wntwmrJEks+GsjEzyW4Obmxtq1a0XCms+SFTDq13HM33oMF2dnAoLuoJBi+LmaPe7JTygmT+FZugq/RmriYKJD/6Z1OfE6icg7wQwZMgQVFRWOHDmiPN+UKVPo1KkTMTExmYbK9OnThz59+ih7WmQXd1u2bEmHDh04cuQIkydPzv/KFxG2trYYGBgQFxdHpUqVvnRxPsvbdU4jIyMZOHCg8oZt1WlLeNmnBQAvihkzbOYCwiIiGGxlyU86cjSLl+D4w+fUI46qyRGYJKmQkJDAysUL6W8I7WIDCElK4f4P5hTX0sA6OgSjl+dIHNKaLeV0KFGqGMe1ihEWFkaDBg1QKBTs3rWLklIqQwcNpHrtOkRePsM0tTBC4+TcSjGg+PwR/KQiobjky8ZobeZt3UNycjK9evXK9rtnTEwMCQkJmXqnnTlzhuDgYM6ePUu1atV4+vQpNjY2QMbfy+Tk5Gzj7qlTp7h06RIVK1ZEoVBw4cIF6tfPo/XEha+a6LOUhzw8POjZsyerV69m+/btJCUlKRc/t7Gx4fnz5wQFBaGnp8ehQ4eYNGkSderUyTIzHGQExWnTpnHgwIH3Dpj/0B0rLy8voqOj6d+/f57Vr6izsbFBVVUVCwuLbyJprVWrFufOnUNLS4sdO3YQGhpK+/btadq0qXINwODgYCwsLAgODlY+Gf3ll1+oWLEiHh4e1K1bl1GjRqGvr8/BgwfZuXMnjo6OyGQydu3axdatW/n33385evQovr6+nD17lurVq5OYmEiZMmV4+fIlT548Yc2aNVy/fh1/f3/u3r3LL7/8woMHD6hevTopKSmkpqbSsmVLQkJCGDt2LPr6+tSoUYO//vqL58+fo1AoWLp0KZUqVcLc3JymTZvy008/Kbu5njp1itTUVGrUqJFpYhaAVatWKSf3+K+TJ08SFhbGsmXL+Omnn9i9ezd9+vShWrVqaGtrZ0mYvwWdO3fGz8+Py7fu0tS1Ny9Cwz5+UC5Fx8Ry/urNPD/vxwQ/e07gg4d5nrCmp6czcto8JngsYfLkyWzYsEEkrAWkYcOGTJ8+Hb+jRxkzdixyuZxEfWN6hmvS9YUqu35ojveuPVxWNeDf7yqz9ORlfvvtt2y7bJcoUQJnZ2dKlChBw4YNs7wvk8neG3cNDQ1ZtGgRFSpU+GbHv38JDRs2xMLCAgMDg0zLt32tfv31V+bOncv333/PunXr2L9/Px5rN2LuPplw64ps0i+HTE0NHR0d1r5KpeqhAOy2nSHUoRvP9c2QAdNs9ZnStT1Dw6/SqYQMjTevKZ0WR8vYYOqEB2GeFo8mCvSQY62mQO/SMVrcPERxVRmqqqrs27CW39Qj2GijytDYQEoc2czguCBsVOXULQYD1d+gq5Jxg0YFGFc8lZo1a9KwYUPkcjmXLl0iPDycqHu3WeXUkN+rWNGwvC3Vq1dnyfABRB7bhyItFX9/f5o0aYKhoSHfffcdfn5+QMbfyz59+tCwYUPu3bun/GzSoiJIehSIv78/5ubmLF68mJTkZHzmz2JiywYM+sGCJeX02diowhf4nxMKA7HkTR54d/rtO3fuMHnyZNTU1LC2tsbV1ZX69esTHByMiYkJJUuWxNvbm2nTpqGurs61a9fQ1NT80lUQcsjd3Z0zZ85w48aNr3pM6/v88ccfVK9enVatWlGxYkXGjBlDeno68+bNY/Xq1ZQtW5YRI0YQFBTEwIEDsbCwwNXVVXl806ZNMTQ0xMvLK8uarpBx19zGxobU1FQMDAxQKBT88ccfVK1ald27d3P9+nXGjBmDgYGB8pi5c+eyevVq1NTUkMlk3L9/H8hYi7FWrVo4ODhw+/Ztnj9/TunSpRkyZAiDBw+mZMmS6Orqsnv3bkaMGEGLFi2YOnUqL1++pHz58uzbtw97e3v69+/PpEmTGDZsGKVLl8bT0xNLS0sAmjdvTrly5Vi5ciVRUVGYm5szc+ZM5s2bx5gxY7hw4QL79u37JqfeDwgI4OeffyY5MYEty+bStH7tPDu368BRpKSmMXZQLxrWrpFn583WOwlovbYZk/P84/0XusV0st09twlrWMRrugydyLmrN1i5cqUYy1hA3o273t7e7N+/n6SkJIyMjPjrr7+QJImnT59iZ2eHpqYmgwcPZvfu3Tg7O4uJj74yTZo0wdzcHG9v7y9dlHzh5OTEhg0bSEtLo3bt2qxYsYK4uDhGjx5NQEAAV65cYfbs2VjoauMefhVNRbryWFkxPdaFp1GjShUamBtmJLzlK6NftxlSagpx9wO4M/tXSqjJeKJbksPf16fNbT+sFIlZyqFbvT4aJc15c+owAUmwX8easXF3UJPJKLf2CHpVarG4bxesLvthpqWG1jvlkJChamKGIiIUADWL0vQKjGH1pi3UrFKJwx0bUfzlY3Sr1SNKuzhqty+inZrA2XiIcuhMD51kYg5l3Dg+mK5LlenLMlaz6NYc/fvXs5S1xtXobzLuCh8mktY88N81o6Kjo1FRUaF48eLvPUahUHzwrq1QOP3zzz8sWLBAecfwWxMZGUmfPn3Yt28fpUqV4t9//8XExITevXsTHh6OkZERCxYsYNiwYdy8eZMHDx5QrFgx5fFpaWlZnjBdvnyZ2bNnY2NjQ4cOHZgwYQKenp4kJCRgampKaGgou3btYtSoUZQvXz5LmdLT07G1tSUhIYFGjRqxZcsWdHR0uHXrFo0aNaJNmzYcOXKEu3fvUqJECX7//XeuX7/OkydPsLKyQpIkgoOD2blzJ1WrVuXAgQP06NGDSpUqUaZMGQICAmjatCmlSpXCx8eHiIgIatasSUhICM+fP2fVqlU0a9aM3bt3s379ei5evMj06dMZPHgwQ4cOZcWKFd9s8IyIiKBrly4cP3GCmb8OY+yg3nkyqdCmXfvZdfAf/po3nZLGRnlQ0mxkk3xOmLOIqDexrJ4zJdt65ChhfWefM1du0mXoBFBVZfv2HV/9RDFfk//G3RcvXmBmZvbB5TjE2Liv0/jx4zEyMmLcuHFfuij54tChQ9y8eZMRI0ZQunRpXr16xf79+zl58iQXLlzA3t6e6dOn06BBA9pYGdFHK560iFD06zTDZsYq0DPIEne9vb3x8vKiTZs2WMrSMN8wG3X+93VfIVPhhN1POBdLJ/nOVYo3csRm6nJkqqpIksSjR4+wt7fnzypm2MtjKdGqIwYNWxE8qd//ziFB8ZoNSY5+TdqjwCz18k3WYtKNZzwc6EzCzQu5+kzMf19O+uN7hG/OWBUjJA0sS9lgWO8ndvifYZzfhW827grvJ5LWPCAWOi460tPTuXfv3jfd/WvYsGHY29vj7e3N0KFD0dXV5cGDB8q18wBevXpF79698fX1VX75T01N5dmzZ6irq2NlZYWKigpnz55lzpw5rF+/nvv37zNlyhT++usv5YLosbGxtGvXDk9PT2bPnq2cmfDdMTNLlixBT0+P58+f8+zZM7p06ULz5s0ZNGgQ5cqVY+HChXh6etK5c2dl+WJjY9HS0sLU1JTvv/+e+Ph4AgMDkclkODo60rJlSxYuXEhoaCiDBw8mKCgIS0tLQkNDOXfuHA0aNKBJkybMnDlTObNyy5Yt2b9/Pzo6Opmu8623fblcztSpU/njjz9oVr8Oa+ZPx9riy61XO2qaB7cDH7Djr0WUKJ7NZ/6JY2Jzk7CmpqYxc9ka5q7yomGDBmzz8RET7xSwotD2hAxhYRlDFL7VNqZQKHBwcKBx48b4+fmxd+9ePDw86N27N3Z2dsr9Dhw4wJUrV5j2++9IaSmoaOkQHx9PSEgIBgYGmJqaIkkSixYt4uXLl8ycOZPNmzfj5+fHolZ1CF89W3muMxaVKebUnYSEBEaMGAFkjru//PILs2bNYuHQ/gyIDshU3sd6ZmyNlpj151oq1q4HQMyNC8Q/vEdQCiydNpkpxRORI6Nk225E7tuMHBkHtCywjI/ARJ5EYsWa3Hz5mtbp4eilJZEmSbxq1omnJw5Tn7hM17McMxvTLoOUr0XbL7pE0poHRAMSviWPHz+mcePG7NixAx8fH7S0tOjUqRM//vhjpv1WrVpFSEgI1tbW7N69Gx0dHaytrUlLS+PJkyekp6djbW3NggULlO0iJCQENzc3Vq5cSfny5enXrx/du3enadOmDB06lHbt2qFQKPDw8EBfX59JkyYxceJE/Pz8iIqKokePHlhbW+Ph4YGbmxt79+7l+fPnqKurc/jwYRwdHbGwsFCWceTIkaxcuRInJyd27drF/fv3Wbx4McuXL6dOnTrMmTOHN2/e0LJlS+V4qdDQUCpXroyGhgalSpVizJgxREZGIpfLGTx4sPLcL1++5NixY/Ts2bNItP1jx47Rp08fYt5E4znlV3q5unyRniLt+w0nLOI1O/5chIWZ6f/e+IwJnHKTsN4MvE/vsdMIfBjM1KlTGT9+/Aef7gn5Q8Rd4Vuyfv16duzYwc8//0ypUqVYtWpVppvCkJFUduvWDScnJ+7du8f58+cxNDTEwsKC6OhowsLCSElJoWXLlvz666/Kv8/Hjx9nyZIlrB7cgyifv1j7MIJJe49iYGCAg4MDW7ZsYcuWLezatYvGjRtTs2ZNTp8+zaJFi9i1axevV86kRswzACKNLKm26Siq6hrcv3+fx48f4+zsnKnHlb29HaPkIfxY7H9lj67fhpJ9xzJw4EDldwdHR0dITSHp4V0OX73JwNG/oqGmynIrNWzIWHZHveMAKk/wUJ7n9u3b3Lx5Ezc3N9H2iyCRtOYBETyFb01qaipqamo0a9aMhIQELly4kKVbnSRJrFixAhMTE1xcXHI8Njs0NJTevXuTlpaGo6MjY8eOBSAuLo5u3bqhpaXFxo0buXPnDjt37qR9+/bKpQ6cnJzQ19cnLCyMP/74Azs7O1asWMHJkydxc3NjzZo17Nq1C0NDQwCePXvGiBEj0NDQwMfHhzlz5lCrVi1++umnD5bxwYMHuLu7s27dOgYPHoyNjQ0LFixQzsQdEBDAiBEj6NixI0OGDCkybT8mJoaRI0fi5eVFk3q1WDx9AnblyhRoGVJSUolPTMSohEHGhvxOVv9fbGwsM5auYfkGHypW/IENGzZmuZEjFBwRd4VviSRJpKWl8fjxY9zd3TEyMmL79u1Z9ouNjWXp0qU0aNCAxo0b5/jG4dmzZxk/fjxpaWksWrSIevUynpAGBgbSuXNnunbtyrhx49i5cyc3btxg1KhRGBsbEx8fT9cuXagV+YgEFTXG7jtBXFwcc+bMIT09ndq1a3Ps2DHlKhgAu3fvZvfmjbi/voFGUhw3tYxx9b2E7geGzEFGN+k1a9bgOWc2M9060rSzGz3HTFB+Plu3bmXPnj04OTkVmZvFQmYiac0DIngK36r4+HjOnDlDq1at8vS8b9dY/e+4Qrlcjkwme++4ycWLF2NkZISRkRHa2trMmjWL4cOH4+zsjEwmU05YsX37dk6ePMmcOXOwsLDg6tWr+Pn54ezsjJGREYmJifz22284Ojri7e3N33//zdy5c6lVqxaQMYbq7YLta9aswdDQkA0bNnDw4EEUCgXGxsbMnTsXHR2dItn2/fz8GD58GI8ePWZIz878PnIwBtl11c1P+dkN+B0KhYLNu32ZOG8ZcQlJTJ48mdGjR4sJ9L4wEXeFb9Xjx4958+YN1apVy9Pzvm8ulfT09A/2FunQoQP9+vXD1taWffv2cfXqVSZOnKi8abd48WJSU1MZN24cM2bMIDg4mBcvXhAf9ZrtGzfg0qM3RkZGSJLEqlWrsLCwwMPDgxs3brB27VqMjY1JTk6mffv2mJmZoaOjg6enJ9HR0axYsYJr166hUCioWbMmU6dOJTExUbT9IkokrXlABE9BKBihoaH06NGDoUOH8ueff7Jz585MY0wBfHx8WLx4MdbW1nh5eaGlpcWYMWNYvXo19erVY8+ePairq/Pbb79x5swZ2rVrR79+/XBzc2PhwoVERkbi4+PD8uXLuXfvHuPHjwfA1dWVjh07ZkpWinLbT01NZfHixcyYMQM1VRVG9evBsD7dCmZd1wJIWCVJYq/fcaYv/pOAoId06tSJ+fPnY2Vl9UnXFvJWUW57glCQDh8+zIEDB7CwsCAmJoa5c+dmSnwlSWLYsGHcv3+fOnXqMGPGDBITE2ncuDFBQUEMHTqUWbNm8eLFC0aOHElYWBjjx4/H1taW0aNHs2/fPjw9PbG3t6d9+/b4+vqyZMkSSpYsycCBA2nYsGGm64m2X3SJpDUPiAYkCAXnxIkT7Nq1i/nz52e7MDlk3FH+71igLVu20K1bt0zB793ZRMPCwmjXrh0GBgZ4e3tTokSJj5ZFtP2Mz83Dw4PVq1dTTEebkX27M6C76/+67+alAugKnJ6ezr5//PFYuY7rd+7R/KefmD5jhrI7nVA4iLYnCAVnwYIFaGtrM3jw4Pd2Sf5v3H316hU3b97EwcEh037vxt1jx44xYcIEatSowapVq3LU3Vm0/aJLJK15QDQgQfg2vDt7Yk6Itv8/L168YPbs2axfvx6Q6OrSmqG9u1KpQrm8ucBnJKzw8aQ1MvoNa332smrTdp6/DKNp0yZMmzadRo0afdZ1hfwh2p4gfBtE3BVySiSteUA0IEEomkTbz+r169esWbOGFStWEBISQvXKdnRt15pOTo6YmnzimqyfmbBC9klrSkoqh/3PsGXvIQ4eP4NMJqNbt24MGzZMTLJUyIm2JwhFk2j7RZdIWvOAaECCUDSJtv9+aWlpHDhwgM2bN+HrmzGBVaPaNXBs1pCfmzWknK1Nzu6u53HCGvUmhn9OnefQ8dMc8j/Lm5hYqlerRnc3N7p164aJiclnX0/If6LtCULRJNp+0SWS1jwgGpAgFE2i7edMVFQUO3bsYN++fZw4cYLk5GRsS1lRv2ZV6lSrQp1qVbAr932WZZWAz05aQ8JecfHqTc5fu8X5a7e4fDMAhULBjz9WoU0bJ7p06ULFihU/6xpCwRNtTxCKJtH2iy6RtOYB0YAEoWgSbT/3EhMTOXHiBEeOHOHc2bPcvHULuVyOtrYW5WxtqPC9DRXK2GJl/h3fmRhhamJESWNDdLS00NLURENDHZlMRnp6OskpqSQlJxP1JpZXEa8JDX/Ny1fh3H/8lHuPggl69ISIyCgAbEqVom69ejRr1gxHR0csLCy+8CchfA7R9gShaBJtv+h6/8JMQo69zftjY2O/cEkEQShIb9u8uPeXczo6OrRu3ZrWrVsDkJCQwJUrV7h27Rr37t0j8O5djm/aQURExHvPoaKigkKR/RNYHR0dypUtyw8VK9KidVvs7e2pW7cu3333Xb7UR/gyRNwVhKJJxN2iSzxpzQMvXrwQa/cJQhH2/PlzLC0tv3QxvikpKSm8evWKsLAwwsPDSUpKIjk5meTkZORyOVpaWmhpaaGpqYmRkRFmZmaYmZmhp6eXq5koha+TiLuCULSJuFv0iKQ1DygUCl6+fJmvX5ZiY2OxsrLi+fPnX313CFGXwknUJfckSSIuLg5zc/NM69MJgpC/RNzNHVGXwknUJfdE3C26RPfgPKCiolJgd3v09fW/+j9sb4m6FE6iLrlTvHjxfD2/IAhZibj7aURdCidRl9wRcbdoErcoBEEQBEEQBEEQhEJLJK2CIAiCIAiCIAhCoSWS1q+EpqYmU6dORVNT80sX5bOJuhROoi6CIAj/8y39HRF1KZxEXQQh58RETIIgCMJXwc7Ojr///pu6deu+d59evXqxdetW7O3tuXr16kfPOW/ePKZPn05KSgrp6el5WVxBEARBEPKIeNIqCIIgfBXu3LnzwYT1rSlTpmRKWCMiImjdujXFihWjfPny/Pvvv8r3xo0bx507d/KlvIIgCIIg5A0xe7AgCILwxUmShCRJ+bKEgbu7O2ZmZkRERHDs2DFcXV158OABhoaGeX4tQRAEQRDynnjSKgiCIOQbmUzGsmXLsLa2xszMjPnz5yvf69WrF0OHDqVZs2bo6Ojw6NEjTp8+TdWqVTEwMKBx48YEBgYq97exseHMmTMA+Pr6Ur58efT09LCxsWHbtm3ZXj8+Pp69e/cyffp0dHR0cHZ2plKlSuzbty9/Ky4IgiAIQp4RSasgCIKQr3x9fQkICMDf35+FCxdm6p67bds25s+fT1xcHPr6+jg7OzNlyhQiIiJo06YNzs7O2Y417devH+vWrSMuLo4LFy5QuXLlbK/94MEDdHV1M63pWalSJdElWBAEQRC+IiJpLcSioqLo1q0b+vr6GBgY0LdvX+Lj43N0rCRJODo6IpPJ2Lt3b/4WNAdyW5eoqCiGDRtG+fLl0dbWxtramuHDhxMTE1OApc6wYsUKbGxs0NLSonbt2ly6dOmD++/YsYMKFSqgpaVFpUqVOHToUAGV9ONyU5c1a9bQsGFDSpQoQYkSJWjevPlH616Qcvv/8ta2bduQyWS4uLjkbwEFpYkTJ6Kvr0+FChXo27cvPj4+yvc6dOhA9erVUVNT459//qFy5cq0b98edXV1xowZQ2JiIpcvX85yTnV1dQIDA4mPj8fMzIyKFStme+34+PgsC93r6+vn+G+pULSIuCvibl4TcVfEXSFviKS1EOvWrRt37tzh6NGj+Pr6curUKQYMGJCjYxcvXoxMJsvnEuZcbuvy8uVLXr58iaenJwEBAXh5eXHkyBH69u1bgKUGHx8fRo8ezdSpU7l27RpVqlShZcuWhIeHZ7v/uXPn6NKlC3379uX69eu4uLjg4uJCQEBAgZY7O7mti7+/P126dOHEiROcP38eKysrHBwcCAkJKeCSZ5Xburz15MkTxo4dS8OGDQuopAKAlZVVpn+HhoYqX7/7BPTly5dYW1srX6uoqGBlZcXLly+znHPnzp3s2bMHS0tLWrVqlakb8bt0dXWJjY3NtC02NhZdXd1Pro/w7RJxV8TdvCTiroi7Qh6ShELp7t27EiBdvnxZue3w4cOSTCaTQkJCPnjs9evXJQsLCyk0NFQCpD179uRzaT/sc+ryru3bt0saGhpSWlpafhQzW7Vq1ZLc3d2Vr+VyuWRubi7NmTMn2/1dXV2l1q1bZ9pWu3ZtaeDAgflazpzIbV3+Kz09XdLT05M2bNiQX0XMsU+pS3p6ulSvXj3p77//lnr27Cm1bdu2AEoqANKJEyeUrydNmiT1799fkiRJ6tmzpzRz5kzlexs3bpQaNWqkfK1QKCRzc3Pp3LlzkiRJUqlSpaTTp09nOn9ycrI0btw4qXHjxtmeMy4uTlJXV5devHih3NakSRNp3bp1ytfBwcGSqqrq51dW+KqJuJuViLufR8RdEXeFvCOetBZS58+fx8DAgBo1aii3NW/eHBUVFS5evPje4xITE+natSsrVqzAzMysIIr6UZ9al/+KiYlBX18fNbWCmfQ6NTWVq1ev0rx5c+U2FRUVmjdvzvnz57M95vz585n2B2jZsuV79y8on1KX/0pMTCQtLe2Lz7j6qXWZMWMGJUuWLPCnBgLMnTuX2NhYgoKCWLduHa6urtnu5+joyM2bN9m3bx/p6eksWrQIbW3tTH87ION3wNvbm9jYWNTV1dHV1UVVVTXbc+rq6tK2bVumTp1KUlISvr6+3Lp1i7Zt2+Z5PYWvm4i7WYm4++lE3BVxV8hbYsmbQiosLIySJUtm2qampoahoSFhYWHvPW7UqFHUq1evUH0h+9S6vOv169fMnDkzx9208sLr16+Ry+WYmppm2m5qasq9e/eyPSYsLCzb/XNaz/zyKXX5r/Hjx2Nubp7ly0FB+5S6nDlzhrVr13Ljxo0CKKHwXz///DP29vakpKQwatSo9/4OGRsbs3fvXkaOHEmPHj2oXLkye/fuRV1dPcu+GzZswN3dHYVCQZUqVfjzzz/fe/2VK1fSs2dPjIyMsLS0xMfH54t/CRQKHxF3MxNx9/OIuCvirpC3RNJawCZMmMDcuXM/uM/7xmZ9zP79+zl+/DjXr1//pONzKz/r8q7Y2Fhat25NxYoVmTZt2mefT8g9Dw8Ptm3bhr+/P1paWl+6OLkSFxeHm5sba9aswdjY+EsXp0hq164dw4YNy7Ldy8sry7YmTZq890uOQqFAXV0dDQ0N/Pz8st1HXV2duXPnsn//fuUkISYmJu+dmMXT05OZM2d+db/XQs6JuJt7Iu5+eSLuCkJmImktYGPGjKFXr14f3MfW1hYzM7Msg9vT09OJiop6b/ej48eP8+jRIwwMDDJt79ChAw0bNsTf3/8zSp5Vftblrbi4OFq1aoWenh579uzJ9olLfjE2NkZVVZVXr15l2v7q1av3ltvMzCxX+xeUT6nLW56ennh4eHDs2LH3LitSkHJbl0ePHvHkyROcnJyU2xQKBZDx5CEoKIjvv/8+fwstfLaIiAgiIiIoVarUB/dbs2YNa9asyfF5x44dy9ixYz+3eEIhJuJuBhF3C5aIuyLuCnnsSw+qFbL3dhKFK1euKLf5+fl9cBKF0NBQ6fbt25l+AGnJkiXS48ePC6roWXxKXSRJkmJiYqQ6depIjRs3lhISEgqiqFnUqlVLGjp0qPK1XC6XLCwsPjghRJs2bTJtq1u3bqGZECI3dZEkSZo7d66kr68vnT9/viCKmGO5qUtSUlKWdtG2bVupWbNm0u3bt6WUlJSCLHqRA0jPnz//rHPcunVLKl68uDRhwoQ8KpUgZCXiroi7eU3EXRF3hbwjktZCrFWrVlLVqlWlixcvSmfOnJHKli0rdenSRfn+ixcvpPLly0sXL1587zkoBLMYSlLu6xITEyPVrl1bqlSpkvTw4UMpNDRU+ZOenl5g5d62bZukqakpeXl5SXfv3pUGDBggGRgYSGFhYZIkSZKbm1umL9Jnz56V1NTUJE9PTykwMFCaOnWqpK6uLt2+fbvAyvw+ua2Lh4eHpKGhIe3cuTPT5x8XF/elqqCU27r8l5jFUBCE7Ii4K+JuXhJx939E3BU+l0haC7HIyEipS5cukq6urqSvry/17t070x+u4ODgLMtJ/FdhCZ65rcuJEyckINuf4ODgAi37smXLJGtra0lDQ0OqVauWdOHCBeV7jRs3lnr27Jlp/+3bt0vlypWTNDQ0JDs7O+ngwYMFWt4PyU1dSpUqle3nP3Xq1IIveDZy+//yLhE8BUHIjoi7Iu7mNRF3M4i4K3wumSRJUr72PxYEQRAEQRAEQRCETyTWaRUEQRAEQRAEQRAKLZG0CoIgCIIgCIIgCIWWSFoFQRAEQRAEQRCEQkskrYIgCIIgCIIgCEKhJZJWQRAEQRAEQRAEodASSasgCIIgCIIgCIJQaImkVRAEQRAEQRAEQSi0RNIqCIIgCIIgCIIgFFoiaRWKpF69euHi4vLFru/m5sbs2bNztG/nzp1ZsGBBPpdIEARBEPKPiLuCIHwOmSRJ0pcuhCDkJZlM9sH3p06dyqhRo5AkCQMDg4Ip1Dtu3rxJs2bNePr0Kbq6uh/dPyAggEaNGhEcHEzx4sULoISCIAiCkHMi7gqCkN9E0ip8c8LCwpT/9vHx4ffffycoKEi5TVdXN0dBK7/069cPNTU1Vq9eneNjatasSa9evXB3d8/HkgmCIAhC7om4KwhCfhPdg4VvjpmZmfKnePHiyGSyTNt0dXWzdFNq0qQJw4YNY+TIkZQoUQJTU1PWrFlDQkICvXv3Rk9PjzJlynD48OFM1woICMDR0RFdXV1MTU1xc3Pj9evX7y2bXC5n586dODk5Zdq+cuVKypYti5aWFqampnTs2DHT+05OTmzbtu3zPxxBEARByGMi7gqCkN9E0ioI/2/Dhg0YGxtz6dIlhg0bxuDBg/nll1+oV68e165dw8HBATc3NxITEwF48+YNzZo1o2rVqly5coUjR47w6tUrXF1d33uNW7duERMTQ40aNZTbrly5wvDhw5kxYwZBQUEcOXKERo0aZTquVq1aXLp0iZSUlPypvCAIgiAUMBF3BUHIKZG0CsL/q1KlCpMnT6Zs2bJMnDgRLS0tjI2N6d+/P2XLluX3338nMjKSW7duAbB8+XKqVq3K7NmzqVChAlWrVmXdunWcOHGC+/fvZ3uNp0+foqqqSsmSJZXbnj17RrFixWjTpg2lSpWiatWqDB8+PNNx5ubmpKamZuqCJQiCIAhfMxF3BUHIKZG0CsL/q1y5svLfqqqqGBkZUalSJeU2U1NTAMLDw4GMiR1OnDihHKujq6tLhQoVAHj06FG210hKSkJTUzPTpBUtWrSgVKlS2Nra4ubmxpYtW5R3ld/S1tYGyLJdEARBEL5WIu4KgpBTImkVhP+nrq6e6bVMJsu07W3AUygUAMTHx+Pk5MSNGzcy/Tx48CBLN6O3jI2NSUxMJDU1VblNT0+Pa9eusXXrVr777jt+//13qlSpwps3b5T7REVFAWBiYpIndRUEQRCEL03EXUEQckokrYLwiapVq8adO3ewsbGhTJkymX6KFSuW7TE//vgjAHfv3s20XU1NjebNmzNv3jxu3brFkydPOH78uPL9gIAALC0tMTY2zrf6CIIgCEJhJuKuIBRdImkVhE/k7u5OVFQUXbp04fLlyzx69Ag/Pz969+6NXC7P9hgTExOqVavGmTNnlNt8fX1ZunQpN27c4OnTp2zcuBGFQkH58uWV+5w+fRoHB4d8r5MgCIIgFFYi7gpC0SWSVkH4RObm5pw9exa5XI6DgwOVKlVi5MiRGBgYoKLy/qbVr18/tmzZonxtYGDA7t27adasGT/88AOrV69m69at2NnZAZCcnMzevXvp379/vtdJEARBEAorEXcFoeiSSZIkfelCCEJRkpSURPny5fHx8aFu3bof3X/VqlXs2bOHf/75pwBKJwiCIAjfFhF3BeHrJ560CkIB09bWZuPGjR9cDP1d6urqLFu2LJ9LJQiCIAjfJhF3BeHrJ560CoIgCIIgCIIgCIWWeNIqCIIgCIIgCIIgFFoiaRUEQRAEQRAEQRAKLZG0CoIgCIIgCIIgCIWWSFoFQRAEQRAEQRCEQkskrYIgCIIgCIIgCEKhJZJWQRAEQRAEQRAEodASSasgCIIgCIIgCIJQaImkVRAEQRAEQRAEQSi0RNIqCIIgCIIgCIIgFFr/BwGhQysZP0oKAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import mne\n", + "from eeg_research.preprocessing.tools import (blinks_remover, \n", + " utils)\n", + "raw = mne.io.read_raw(\"/Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf\",\n", + " preload = True)\n", + "b_remover = blinks_remover.BlinksRemover(raw)\n", + "montage = mne.channels.make_standard_montage('easycap-M1')\n", + "b_remover.raw.set_montage(montage)\n", + "b_remover.plot_blinks_found()\n", + "b_remover.remove_blinks()\n", + "b_remover.plot_removal_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using eeg sensors for muscle artifact detection\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up high-pass filter at 30 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal highpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 30.00\n", + "- Lower transition bandwidth: 7.50 Hz (-6 dB cutoff frequency: 26.25 Hz)\n", + "- Filter length: 111 samples (0.444 s)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up low-pass filter at 4 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal lowpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Upper passband edge: 4.00 Hz\n", + "- Upper transition bandwidth: 2.00 Hz (-6 dB cutoff frequency: 5.00 Hz)\n", + "- Filter length: 413 samples (1.652 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + " General\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Measurement dateJanuary 01, 2000 00:00:00 GMT
ExperimenterUnknown
ParticipantX
\n", + "
\n", + "
\n", + " Channels\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Digitized points64 points
Good channels61 EEG, 1 ECG, 2 EOG
Bad channelsNone
EOG channelsEOGL, EOGU
ECG channelsECG
\n", + "
\n", + "
\n", + " Data\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Sampling frequency250.00 Hz
Highpass0.00 Hz
Lowpass125.00 Hz
ProjectionsEOG-eeg--0.200-0.200-PCA-01 : on
Filenamessub-01_ses-01_task-checker_run-01_eeg.edf
Duration00:04:02 (HH:MM:SS)
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "raw = b_remover.blink_removed_raw\n", + "muscle_annotations, muscle_zscore = mne.preprocessing.annotate_muscle_zscore(raw,\n", + " filter_freq=(30,None)\n", + ")\n", + "\n", + "raw.set_annotations(raw.annotations + muscle_annotations)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 1 - 20 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal bandpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 1.00 Hz (-6 dB cutoff frequency: 0.50 Hz)\n", + "- Upper passband edge: 20.00 Hz\n", + "- Upper transition bandwidth: 5.00 Hz (-6 dB cutoff frequency: 22.50 Hz)\n", + "- Filter length: 825 samples (3.300 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"\", line 198, in _run_module_as_main\n", + " File \"\", line 88, in _run_code\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel_launcher.py\", line 18, in \n", + " app.launch_new_instance()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n", + " app.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelapp.py\", line 739, in start\n", + " self.io_loop.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/tornado/platform/asyncio.py\", line 205, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 639, in run_forever\n", + " self._run_once()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 1985, in _run_once\n", + " handle._run()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/events.py\", line 88, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 545, in dispatch_queue\n", + " await self.process_one()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 534, in process_one\n", + " await dispatch(*args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 437, in dispatch_shell\n", + " await result\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 362, in execute_request\n", + " await super().execute_request(stream, ident, parent)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 778, in execute_request\n", + " reply_content = await reply_content\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 449, in do_execute\n", + " res = shell.run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/zmqshell.py\", line 549, in run_cell\n", + " return super().run_cell(*args, **kwargs)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3075, in run_cell\n", + " result = self._run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3130, in _run_cell\n", + " result = runner(coro)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/async_helpers.py\", line 129, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3334, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3517, in run_ast_nodes\n", + " if await self.run_code(code, result, async_=asy):\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/var/folders/l3/myr9vj8933q4vwhkbvxcx6gc0000gn/T/ipykernel_23035/2771688128.py\", line 76, in \n", + " raw.plot()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/io/base.py\", line 1856, in plot\n", + " return plot_raw(\n", + " File \"\", line 12, in plot_raw\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/raw.py\", line 409, in plot_raw\n", + " fig = _get_browser(show=show, block=block, **params)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 672, in _get_browser\n", + " backend_name = get_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 820, in get_browser_backend\n", + " backend_name = _init_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 795, in _init_browser_backend\n", + " _load_backend(name)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 651, in _load_backend\n", + " from mne_qt_browser import _pg_figure as backend\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne_qt_browser/_pg_figure.py\", line 100, in \n", + " from pyqtgraph import (\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/__init__.py\", line 246, in \n", + " from .imageview import *\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/__init__.py\", line 6, in \n", + " from .ImageView import ImageView\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/ImageView.py\", line 35, in \n", + " from bottleneck import nanmax, nanmin\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/bottleneck/__init__.py\", line 7, in \n", + " from .move import (move_argmax, move_argmin, move_max, move_mean, move_median,\n" + ] + }, + { + "ename": "ImportError", + "evalue": "\nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/opt/anaconda3/envs/mne/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py:44\u001b[0m, in \u001b[0;36m__getattr__\u001b[0;34m(attr_name)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Also print the message (with traceback). This is because old versions\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;66;03m# of NumPy unfortunately set up the import to replace (and hide) the\u001b[39;00m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# error. The traceback shouldn't be needed, but e.g. pytest plugins\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# seem to swallow it and we should be failing anyway...\u001b[39;00m\n\u001b[1;32m 43\u001b[0m sys\u001b[38;5;241m.\u001b[39mstderr\u001b[38;5;241m.\u001b[39mwrite(msg \u001b[38;5;241m+\u001b[39m tb_msg)\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(msg)\n\u001b[1;32m 46\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(_multiarray_umath, attr_name, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mImportError\u001b[0m: \nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.ndimage import label\n", + "from mne.preprocessing.artifact_detection import _annotations_from_mask\n", + "from mne.annotations import _adjust_onset_meas_date\n", + "raw = b_remover.blink_removed_raw\n", + "def annotate_artifacts_by_zscore(raw, \n", + " channel_type='eeg', \n", + " z_thresh=3,\n", + " min_artifact_gap=0.1,\n", + " filtering = (1,20),\n", + " min_annotation_duration = 0.5):\n", + " \"\"\"\n", + " Annotate and group artifacts in raw EEG data based on a z-score threshold and minimum gap criteria.\n", + " \n", + " Parameters:\n", + " - raw: Raw object from MNE containing EEG data.\n", + " - channel_type: Type of channels to analyze.\n", + " - z_thresh: Z-score threshold to use for detecting artifacts.\n", + " - min_artifact_gap: Minimum time in seconds between separate artifacts; below this, artifacts will be grouped.\n", + " \n", + " Returns:\n", + " - annotations: MNE Annotations object with detected and grouped artifacts.\n", + " \"\"\"\n", + " raw_copy = raw.copy().filter(*filtering)\n", + " picks = mne.pick_types(raw_copy.info, meg=False, eeg=(channel_type=='eeg'), eog=False)\n", + " data, times = raw_copy[picks]\n", + " \n", + " # Compute z-score\n", + " z_scores = np.abs((data - np.mean(data, axis=1, keepdims=True)) / np.std(data, axis=1, keepdims=True))\n", + " artifacts = (z_scores > z_thresh).any(axis=0)\n", + " \n", + " # Find continuous segments of artifacts and group close ones\n", + " artifact_times = times[artifacts]\n", + " if len(artifact_times) == 0:\n", + " return mne.Annotations() # Return empty annotations if no artifacts found\n", + " \n", + " # Initialize annotations\n", + " onsets = [artifact_times[0]]\n", + " ends = []\n", + " for i in range(1, len(artifact_times)):\n", + " if artifact_times[i] - artifact_times[i - 1] > min_artifact_gap:\n", + " ends.append(artifact_times[i - 1])\n", + " onsets.append(artifact_times[i])\n", + " ends.append(artifact_times[-1]) # Append the last end time\n", + " \n", + " # Calculate durations and create annotations\n", + " onsets, ends = np.array(onsets), np.array(ends)\n", + " durations = ends - onsets\n", + " index_min_duration = np.where(durations < min_annotation_duration)\n", + " durations[index_min_duration] = min_annotation_duration\n", + " onsets[index_min_duration] =- min_annotation_duration\n", + " negative_onsets = onsets < 0\n", + " negative_onsets_index = np.where(negative_onsets)\n", + " if any(negative_onsets):\n", + " durations = np.delete(durations,negative_onsets_index)\n", + " onsets = np.delete(onsets,negative_onsets_index)\n", + " descriptions = ['BAD_other'] * len(onsets)\n", + " \n", + " annotations = mne.Annotations(onset=onsets, \n", + " duration=durations, \n", + " description=descriptions,\n", + " orig_time = raw_copy.info['meas_date'])\n", + " return annotations\n", + "\n", + "\n", + "# Use the function\n", + "artifact_annotations = annotate_artifacts_by_zscore(raw)\n", + "raw.set_annotations(raw.annotations + artifact_annotations)\n", + "#ica = mne.preprocessing.ICA(\n", + "# n_components=16)\n", + "#ica.fit(raw)\n", + "#muscle_idx_auto, scores = ica.find_bads_muscle(raw)\n", + "#ica.plot_scores(scores, exclude=muscle_idx_auto)\n", + "#ica.apply(raw,\n", + "# exclude = muscle_idx_auto)\n", + "raw.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['BAD_other', 'BAD_other', 'BAD_other', 'BAD_other', 'BAD_other',\n", + " 'BAD_other', 'BAD_other', 'BAD_other', 'BAD_other', 'BAD_other',\n", + " 'BAD_other'], dtype='=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"\", line 198, in _run_module_as_main\n", + " File \"\", line 88, in _run_code\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel_launcher.py\", line 18, in \n", + " app.launch_new_instance()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n", + " app.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelapp.py\", line 739, in start\n", + " self.io_loop.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/tornado/platform/asyncio.py\", line 205, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 639, in run_forever\n", + " self._run_once()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 1985, in _run_once\n", + " handle._run()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/events.py\", line 88, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 545, in dispatch_queue\n", + " await self.process_one()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 534, in process_one\n", + " await dispatch(*args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 437, in dispatch_shell\n", + " await result\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 362, in execute_request\n", + " await super().execute_request(stream, ident, parent)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 778, in execute_request\n", + " reply_content = await reply_content\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 449, in do_execute\n", + " res = shell.run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/zmqshell.py\", line 549, in run_cell\n", + " return super().run_cell(*args, **kwargs)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3075, in run_cell\n", + " result = self._run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3130, in _run_cell\n", + " result = runner(coro)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/async_helpers.py\", line 129, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3334, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3517, in run_ast_nodes\n", + " if await self.run_code(code, result, async_=asy):\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/var/folders/l3/myr9vj8933q4vwhkbvxcx6gc0000gn/T/ipykernel_38047/407915068.py\", line 78, in \n", + " raw.plot(block=True, scalings='auto', title='EEG Data with Adjusted Artifacts Annotated')\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/io/base.py\", line 1856, in plot\n", + " return plot_raw(\n", + " File \"\", line 12, in plot_raw\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/raw.py\", line 409, in plot_raw\n", + " fig = _get_browser(show=show, block=block, **params)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 672, in _get_browser\n", + " backend_name = get_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 820, in get_browser_backend\n", + " backend_name = _init_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 795, in _init_browser_backend\n", + " _load_backend(name)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 651, in _load_backend\n", + " from mne_qt_browser import _pg_figure as backend\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne_qt_browser/_pg_figure.py\", line 100, in \n", + " from pyqtgraph import (\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/__init__.py\", line 246, in \n", + " from .imageview import *\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/__init__.py\", line 6, in \n", + " from .ImageView import ImageView\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/ImageView.py\", line 35, in \n", + " from bottleneck import nanmax, nanmin\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/bottleneck/__init__.py\", line 7, in \n", + " from .move import (move_argmax, move_argmin, move_max, move_mean, move_median,\n" + ] + }, + { + "ename": "ImportError", + "evalue": "\nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/opt/anaconda3/envs/mne/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py:44\u001b[0m, in \u001b[0;36m__getattr__\u001b[0;34m(attr_name)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Also print the message (with traceback). This is because old versions\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;66;03m# of NumPy unfortunately set up the import to replace (and hide) the\u001b[39;00m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# error. The traceback shouldn't be needed, but e.g. pytest plugins\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# seem to swallow it and we should be failing anyway...\u001b[39;00m\n\u001b[1;32m 43\u001b[0m sys\u001b[38;5;241m.\u001b[39mstderr\u001b[38;5;241m.\u001b[39mwrite(msg \u001b[38;5;241m+\u001b[39m tb_msg)\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(msg)\n\u001b[1;32m 46\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(_multiarray_umath, attr_name, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mImportError\u001b[0m: \nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n", + "Channels marked as bad:\n", + "none\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import mne\n", + "\n", + "def annotate_artifacts_by_zscore(raw: mne.io.Raw, \n", + " description: str = 'BAD_artifacts',\n", + " channel_type: str | None ='eeg', \n", + " z_thresh: float=3.5, \n", + " min_artifact_gap: float | None =0.1, \n", + " minimum_duration: float | None =0.2,\n", + " filtering: tuple[float | None] | None = (None,8)):\n", + " \"\"\"\n", + " Annotate and group artifacts in raw EEG data based on a z-score threshold, minimum gap criteria,\n", + " and adjust annotations to meet a minimum duration.\n", + " \n", + " Parameters:\n", + " - raw: Raw object from MNE containing EEG data.\n", + " - channel_type: Type of channels to analyze.\n", + " - z_thresh: Z-score threshold to use for detecting artifacts.\n", + " - min_artifact_gap: Minimum time in seconds between separate artifacts; below this, artifacts will be grouped.\n", + " - minimum_duration: Minimum duration for each annotation. If an annotation is shorter, it is adjusted.\n", + " \n", + " Returns:\n", + " - annotations: MNE Annotations object with detected, grouped, and adjusted artifacts.\n", + " \"\"\"\n", + " raw_copy = raw.copy()\n", + " if filtering:\n", + " raw_copy.filter(*filtering)\n", + " if channel_type:\n", + " picks = mne.pick_types(raw_copy.info, meg=False, eeg=(channel_type=='eeg'), eog=False)\n", + " data, times = raw_copy[picks]\n", + " z_scores = np.abs((data - np.mean(data, axis=1, keepdims=True)) / np.std(data, axis=1, keepdims=True))\n", + " artifacts = (z_scores > z_thresh).any(axis=0)\n", + " artifact_times = times[artifacts]\n", + " if len(artifact_times) == 0:\n", + " return mne.Annotations() # Return empty annotations if no artifacts found\n", + " \n", + " # Initialize annotations\n", + " onsets = [artifact_times[0]]\n", + " ends = []\n", + " if min_artifact_gap:\n", + " for i in range(1, len(artifact_times)):\n", + " if artifact_times[i] - artifact_times[i - 1] > min_artifact_gap:\n", + " ends.append(artifact_times[i - 1])\n", + " onsets.append(artifact_times[i])\n", + " ends.append(artifact_times[-1]) # Append the last end time\n", + " \n", + " durations = np.array(ends) - np.array(onsets)\n", + " adjusted_onsets = []\n", + " adjusted_durations = []\n", + " for onset, duration in zip(onsets, durations):\n", + " if minimum_duration and duration < minimum_duration:\n", + " new_onset = max(0, onset + (duration/2) - minimum_duration/2) \n", + " new_duration = minimum_duration\n", + " adjusted_onsets.append(new_onset)\n", + " adjusted_durations.append(new_duration)\n", + " else:\n", + " adjusted_onsets.append(onset)\n", + " adjusted_durations.append(duration)\n", + " \n", + " descriptions = [description] * len(adjusted_onsets)\n", + " annotations = mne.Annotations(onset=adjusted_onsets, duration=adjusted_durations, description=descriptions)\n", + " return annotations\n", + "\n", + "# Usage example\n", + "raw.filter(l_freq=1., h_freq=None) # Pre-filtering\n", + "artifact_annotations = annotate_artifacts_by_zscore(raw, \n", + " filtering = (1,None),\n", + " min_artifact_gap=0.25, \n", + " minimum_duration=0.5)\n", + "raw.set_annotations(artifact_annotations)\n", + "\n", + "\n", + "# Visualize\n", + "raw.plot(block=True, scalings='auto', title='EEG Data with Adjusted Artifacts Annotated')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Trying with merging after minimum_duration" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtering raw data in 1 contiguous segment\n", + "Setting up high-pass filter at 1 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal highpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 1.00 Hz (-6 dB cutoff frequency: 0.50 Hz)\n", + "- Filter length: 825 samples (3.300 s)\n", + "\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up high-pass filter at 1 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal highpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 1.00 Hz (-6 dB cutoff frequency: 0.50 Hz)\n", + "- Filter length: 825 samples (3.300 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"\", line 198, in _run_module_as_main\n", + " File \"\", line 88, in _run_code\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel_launcher.py\", line 18, in \n", + " app.launch_new_instance()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n", + " app.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelapp.py\", line 739, in start\n", + " self.io_loop.start()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/tornado/platform/asyncio.py\", line 205, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 639, in run_forever\n", + " self._run_once()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/base_events.py\", line 1985, in _run_once\n", + " handle._run()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/asyncio/events.py\", line 88, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 545, in dispatch_queue\n", + " await self.process_one()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 534, in process_one\n", + " await dispatch(*args)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 437, in dispatch_shell\n", + " await result\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 362, in execute_request\n", + " await super().execute_request(stream, ident, parent)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/kernelbase.py\", line 778, in execute_request\n", + " reply_content = await reply_content\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/ipkernel.py\", line 449, in do_execute\n", + " res = shell.run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/ipykernel/zmqshell.py\", line 549, in run_cell\n", + " return super().run_cell(*args, **kwargs)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3075, in run_cell\n", + " result = self._run_cell(\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3130, in _run_cell\n", + " result = runner(coro)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/async_helpers.py\", line 129, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3334, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3517, in run_ast_nodes\n", + " if await self.run_code(code, result, async_=asy):\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/var/folders/l3/myr9vj8933q4vwhkbvxcx6gc0000gn/T/ipykernel_43553/2199312403.py\", line 78, in \n", + " raw.plot(block=True, scalings='auto', title='EEG Data with Adjusted Artifacts Annotated')\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/io/base.py\", line 1856, in plot\n", + " return plot_raw(\n", + " File \"\", line 12, in plot_raw\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/raw.py\", line 409, in plot_raw\n", + " fig = _get_browser(show=show, block=block, **params)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 672, in _get_browser\n", + " backend_name = get_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 820, in get_browser_backend\n", + " backend_name = _init_browser_backend()\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 795, in _init_browser_backend\n", + " _load_backend(name)\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/viz/_figure.py\", line 651, in _load_backend\n", + " from mne_qt_browser import _pg_figure as backend\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne_qt_browser/_pg_figure.py\", line 100, in \n", + " from pyqtgraph import (\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/__init__.py\", line 246, in \n", + " from .imageview import *\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/__init__.py\", line 6, in \n", + " from .ImageView import ImageView\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/pyqtgraph/imageview/ImageView.py\", line 35, in \n", + " from bottleneck import nanmax, nanmin\n", + " File \"/opt/anaconda3/envs/mne/lib/python3.12/site-packages/bottleneck/__init__.py\", line 7, in \n", + " from .move import (move_argmax, move_argmin, move_max, move_mean, move_median,\n" + ] + }, + { + "ename": "ImportError", + "evalue": "\nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/opt/anaconda3/envs/mne/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py:44\u001b[0m, in \u001b[0;36m__getattr__\u001b[0;34m(attr_name)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;66;03m# Also print the message (with traceback). This is because old versions\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;66;03m# of NumPy unfortunately set up the import to replace (and hide) the\u001b[39;00m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# error. The traceback shouldn't be needed, but e.g. pytest plugins\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m# seem to swallow it and we should be failing anyway...\u001b[39;00m\n\u001b[1;32m 43\u001b[0m sys\u001b[38;5;241m.\u001b[39mstderr\u001b[38;5;241m.\u001b[39mwrite(msg \u001b[38;5;241m+\u001b[39m tb_msg)\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(msg)\n\u001b[1;32m 46\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(_multiarray_umath, attr_name, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mImportError\u001b[0m: \nA module that was compiled using NumPy 1.x cannot be run in\nNumPy 2.0.0 as it may crash. To support both 1.x and 2.x\nversions of NumPy, modules must be compiled with NumPy 2.0.\nSome module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n\nIf you are a user of the module, the easiest solution will be to\ndowngrade to 'numpy<2' or try to upgrade the affected module.\nWe expect that some modules will need time to support NumPy 2.\n\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n", + "Channels marked as bad:\n", + "none\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import mne\n", + "\n", + "def annotate_artifacts_by_zscore(raw: mne.io.Raw, \n", + " description: str = 'BAD_artifacts',\n", + " channel_type: str | None ='eeg', \n", + " z_thresh: float=3.5, \n", + " min_artifact_gap: float | None =0.1, \n", + " minimum_duration: float | None =0.2,\n", + " filtering: tuple[float | None] | None = (None, 8)):\n", + " \"\"\"\n", + " Annotate and group artifacts in raw EEG data based on a z-score threshold, minimum gap criteria,\n", + " and adjust annotations to meet a minimum duration.\n", + " \n", + " Parameters:\n", + " - raw: Raw object from MNE containing EEG data.\n", + " - channel_type: Type of channels to analyze.\n", + " - z_thresh: Z-score threshold to use for detecting artifacts.\n", + " - min_artifact_gap: Minimum time in seconds between separate artifacts; below this, artifacts will be grouped.\n", + " - minimum_duration: Minimum duration for each annotation. If an annotation is shorter, it is adjusted.\n", + " \n", + " Returns:\n", + " - annotations: MNE Annotations object with detected, grouped, and adjusted artifacts.\n", + " \"\"\"\n", + " raw_copy = raw.copy()\n", + " if filtering:\n", + " raw_copy.filter(*filtering)\n", + " if channel_type:\n", + " picks = mne.pick_types(raw_copy.info, meg=False, eeg=(channel_type=='eeg'), eog=False)\n", + " data, times = raw_copy[picks]\n", + " z_scores = np.abs((data - np.mean(data, axis=1, keepdims=True)) / np.std(data, axis=1, keepdims=True))\n", + " artifacts = (z_scores > z_thresh).any(axis=0)\n", + " gradient = np.diff(artifacts, prepend=0)\n", + " rising_edge_idx = np.where(gradient == 1)[0]\n", + " falling_edge_idx = np.where(gradient == -1)[0]\n", + " if sum(artifacts) == 0:\n", + " return mne.Annotations() # Return empty annotations if no artifacts found\n", + "\n", + " onsets = times[rising_edge_idx]\n", + " ends = times[falling_edge_idx]\n", + " durations = np.array(ends) - np.array(onsets)\n", + " adjusted_onsets = []\n", + " adjusted_durations = []\n", + " last_end = 0\n", + "\n", + " for i, (onset, duration) in enumerate(zip(onsets, durations)):\n", + " if minimum_duration and duration < minimum_duration:\n", + " new_onset = max(0, onset - (minimum_duration - duration) / 2)\n", + " new_duration = minimum_duration\n", + " else:\n", + " new_onset = onset\n", + " new_duration = duration\n", + " \n", + " # Merge annotations if they are closer than min_artifact_gap\n", + " if adjusted_onsets and new_onset - last_end <= min_artifact_gap:\n", + " # Extend the last annotation\n", + " adjusted_durations[-1] = new_onset + new_duration - adjusted_onsets[-1]\n", + " else:\n", + " adjusted_onsets.append(new_onset)\n", + " adjusted_durations.append(new_duration)\n", + " \n", + " last_end = adjusted_onsets[-1] + adjusted_durations[-1]\n", + "\n", + " descriptions = [description] * len(adjusted_onsets)\n", + " annotations = mne.Annotations(onset=adjusted_onsets, duration=adjusted_durations, description=descriptions)\n", + " return annotations\n", + "\n", + "# Usage example\n", + "raw.filter(l_freq=1., h_freq=None) # Pre-filtering\n", + "artifact_annotations = annotate_artifacts_by_zscore(raw, \n", + " filtering = (1,None),\n", + " min_artifact_gap=0.25, \n", + " minimum_duration=0.5)\n", + "raw.set_annotations(artifact_annotations)\n", + "\n", + "\n", + "# Visualize\n", + "raw.plot(block=True, scalings='auto', title='EEG Data with Adjusted Artifacts Annotated')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "a = [mne.Annotations(onset=[3], duration=[0.4], description=['prout']), mne.Annotations(onset = [1], duration = [0.1], description = ['test'])]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'collections.OrderedDict' and 'collections.OrderedDict'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[17], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msum\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/anaconda3/envs/mne/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:2389\u001b[0m, in \u001b[0;36msum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 2386\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\n\u001b[1;32m 2387\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m res\n\u001b[0;32m-> 2389\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapreduction\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2390\u001b[0m \u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43msum\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2391\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeepdims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeepdims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minitial\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minitial\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwhere\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwhere\u001b[49m\n\u001b[1;32m 2392\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/anaconda3/envs/mne/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:86\u001b[0m, in \u001b[0;36m_wrapreduction\u001b[0;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m reduction(axis\u001b[38;5;241m=\u001b[39maxis, out\u001b[38;5;241m=\u001b[39mout, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mpasskwargs)\n\u001b[0;32m---> 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mufunc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreduce\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpasskwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'collections.OrderedDict' and 'collections.OrderedDict'" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting ICA to data using 61 channels (please be patient, this may take a while)\n", + "Omitting 9930 of 60500 (16.41%) samples, retaining 50570 (83.59%) samples.\n", + " Applying projection operator with 1 vector (pre-whitener computation)\n", + " Applying projection operator with 1 vector (pre-whitener application)\n", + "Selecting by number: 15 components\n", + " Applying projection operator with 1 vector (pre-whitener application)\n", + "Fitting ICA took 0.4s.\n", + " Applying projection operator with 1 vector (pre-whitener application)\n", + "Setting 9930 of 60500 (16.41%) samples to NaN, retaining 50570 (83.59%) samples.\n", + "Effective window size : 8.192 (s)\n", + "At least one good data span is shorter than n_per_seg, and will be analyzed with a shorter window than the rest of the file.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 22, using nperseg = 22\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 270, using nperseg = 270\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 103, using nperseg = 103\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 104, using nperseg = 104\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 356, using nperseg = 356\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 128, using nperseg = 128\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 86, using nperseg = 86\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 206, using nperseg = 206\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 268, using nperseg = 268\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 78, using nperseg = 78\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 124, using nperseg = 124\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 114, using nperseg = 114\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 106, using nperseg = 106\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 80, using nperseg = 80\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 366, using nperseg = 366\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 106, using nperseg = 106\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 84, using nperseg = 84\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 126, using nperseg = 126\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 98, using nperseg = 98\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 118, using nperseg = 118\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 110, using nperseg = 110\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 94, using nperseg = 94\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 114, using nperseg = 114\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 120, using nperseg = 120\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 102, using nperseg = 102\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 57, using nperseg = 57\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 600, using nperseg = 600\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 104, using nperseg = 104\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 348, using nperseg = 348\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 78, using nperseg = 78\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 130, using nperseg = 130\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 348, using nperseg = 348\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 68, using nperseg = 68\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 1718, using nperseg = 1718\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 632, using nperseg = 632\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 54, using nperseg = 54\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 32, using nperseg = 32\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 20, using nperseg = 20\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 1258, using nperseg = 1258\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 1696, using nperseg = 1696\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 110, using nperseg = 110\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 1228, using nperseg = 1228\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 520, using nperseg = 520\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 1078, using nperseg = 1078\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 244, using nperseg = 244\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 160, using nperseg = 160\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 274, using nperseg = 274\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 30, using nperseg = 30\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 442, using nperseg = 442\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 104, using nperseg = 104\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 86, using nperseg = 86\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 348, using nperseg = 348\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 68, using nperseg = 68\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 22, using nperseg = 22\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 918, using nperseg = 918\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 122, using nperseg = 122\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 472, using nperseg = 472\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 80, using nperseg = 80\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 34, using nperseg = 34\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 340, using nperseg = 340\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 596, using nperseg = 596\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 80, using nperseg = 80\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 326, using nperseg = 326\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 162, using nperseg = 162\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 106, using nperseg = 106\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 30, using nperseg = 30\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 140, using nperseg = 140\n", + " return _func(*args, **kwargs)\n", + "/opt/anaconda3/envs/mne/lib/python3.12/site-packages/mne/time_frequency/psd.py:266: UserWarning: nperseg = 2048 is greater than input length = 206, using nperseg = 206\n", + " return _func(*args, **kwargs)\n" + ] + } + ], + "source": [ + "ica = mne.preprocessing.ICA(n_components=15)\n", + "ica.fit(raw)\n", + "muscle_idx_auto, scores = ica.find_bads_muscle(raw)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.80401101e-01, 4.62598030e-05, 5.09862198e-05, 5.77214302e-03,\n", + " 2.71969421e-01, 1.73434335e-03, 4.34718194e-05, 3.79278029e-01,\n", + " 3.16107614e-01, 3.86672368e-01, 1.79384975e-04, 4.83714346e-01,\n", + " 6.31462819e-01, 1.01143863e-02, 5.14725063e-01])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing with a list of Annotations instances" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting EDF parameters from /Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf...\n", + "EDF file detected\n", + "Setting channel info structure...\n", + "Creating raw.info structure...\n", + "Reading 0 ... 60499 = 0.000 ... 241.996 secs...\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "Using data from preloaded Raw for 106 events and 251 original time points ...\n", + "0 bad epochs dropped\n", + "Applying baseline correction (mode: mean)\n", + "No projector specified for this dataset. Please consider the method self.add_proj.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running EOG SSP computation\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Computing projector\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 1 - 35 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hamming window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 35.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 35.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "0 projection items activated\n", + "Using data from preloaded Raw for 106 events and 101 original time points ...\n", + "0 bad epochs dropped\n", + "No channels 'grad' found. Skipping.\n", + "No channels 'mag' found. Skipping.\n", + "Adding projection: eeg--0.200-0.200-PCA-01 (exp var=96.9%)\n", + "Done.\n", + "1 projection items deactivated\n", + "Created an SSP operator (subspace dimension = 1)\n", + "1 projection items activated\n", + "SSP projectors applied...\n", + "1 projection items deactivated\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA60AAADxCAYAAAAgAVHOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gUVReH39meHpIQklACoYbeQ+hVQEA6UqQIgiJFBURQUQT8xIYoFhAVUFFAQBRUlN47hNADCZ3QEkhvu3u/PzY7ZNMIEIp43+eZJztz++xu7v7mnHuuIoQQSCQSiUQikUgkEolE8giiedgdkEgkEolEIpFIJBKJJC+kaJVIJBKJRCKRSCQSySOLFK0SiUQikUgkEolEInlkkaJVIpFIJBKJRCKRSCSPLFK0SiQSiUQikUgkEonkkUWKVolEIpFIJBKJRCKRPLJI0SqRSCQSiUQikUgkkkcWKVolEolEIpFIJBKJRPLIIkWrRCKRSCQSiUQikUgeWaRofcyZPHkyxYoVQ1EUVqxY8cDbj4mJwdfXlzNnzgCwceNGFEXh5s2beZaZP38+np6ehdaH27V5/fp1fH19uXDhQqG1eacUxvtz/PhxGjRogMlkombNmoXSr4IwadIkhg0b9sDau1cmTJjAqFGjHnY3JBKJ5IExefLkBzov3Al327fmzZvz8ssvF3p/JBLJo4kUrY8ggwYNQlEU9fD29qZdu3aEh4ffUT3Hjh3jnXfeYc6cOURHR9O+ffv71OO8effdd+ncuTOlS5d+4G0XFB8fHwYMGMDbb7/9sLtyT7z99tu4uLhw4sQJ1q1bV+jiPzcuX77Mp59+yhtvvHFf2ylMxo0bx4IFC4iKinrYXZFIJBIHss7/BoOBcuXKMWXKFMxm8z3VO27cONatW1dIvXywIjivB8/Lly9n6tSpD6QPEonk4SNF6yNKu3btiI6OJjo6mnXr1qHT6ejYseMd1REZGQlA586d8fPzw2g03lVfMjIy7qpccnIy3377LUOGDLmr8g+SZ599loULFxIbG/uwu3LXREZG0rhxYwIDA/H29i60ei0WC1arNde0b775hoYNGxIYGHhPbaSnp99T+TvBx8eHtm3b8tVXXz2wNiUSiaSg2Of/kydPMnbsWCZPnsyHH36Ya96C/u90dXUt1HnhUcDLyws3N7eH3Y0HwoOcIyWSRxUpWh9RjEYjfn5++Pn5UbNmTSZMmMD58+e5du2amuf8+fP06tULT09PvLy86Ny5s+qGO3nyZDp16gSARqNBURQArFYrU6ZMoUSJEhiNRmrWrMnq1avVOs+cOYOiKCxevJhmzZphMplYuHAhYBMowcHBmEwmKlWqxJdffpnvGP7880+MRiMNGjTIkbZt2zaqV6+OyWSiQYMGHD58OM96IiMj6dy5M8WKFcPV1ZV69eqxdu1ahzxpaWm89tprlCxZEqPRSLly5fj2229zrS85OZn27dvTqFEj9cltlSpVCAgI4Ndff82zHzExMfTp04fixYvj7OxMtWrV+Pnnnx3yNG/enNGjRzN+/Hi8vLzw8/Nj8uTJDnlOnjxJ06ZNMZlMVK5cmTVr1uTZpp3Vq1fTuHFjPD098fb2pmPHjupDCbC5F+/bt48pU6agKArNmzfn2WefJS4uTn1qb+9HWloa48aNo3jx4ri4uBASEsLGjRvVuuwW2t9//53KlStjNBo5d+5crv1atGiR+jmzk5CQQL9+/XBxccHf359PPvkkhxtX6dKlmTp1KgMGDMDd3V11L966dStNmjTBycmJkiVLMnr0aJKSktRyBe3733//TXBwMK6uruoPwKx06tSJRYsW3fa+SyQSyYPGPv8HBgYyfPhwWrduze+//w7YLLFdunTh3XffJSAggIoVKwJw6NAhWrZsiZOTE97e3gwbNozExES1ztwso7eb0y9cuECfPn3w8vLCxcWFunXrsmvXLubPn88777zDwYMH1fll/vz5ANy8eZPnnnuOokWL4u7uTsuWLTl48KBDvdOnT6dYsWK4ubkxZMgQUlNT87wXZ86coUWLFgAUKVIERVEYNGgQkNM9uHTp0kybNo0BAwbg6upKYGAgv//+O9euXaNz5864urpSvXp19u7d69DG7ead3Fi5ciX16tXDZDLh4+ND165d1bQbN24wYMAAihQpgrOzM+3bt+fkyZP5vhczZ8508EjL633+8ssvKV++PCaTiWLFitGjRw+1jNVq5b333qNMmTI4OTlRo0YNli5dmu84JJJ/FULyyDFw4EDRuXNn9TwhIUE8//zzoly5csJisQghhEhPTxfBwcFi8ODBIjw8XBw9elT07dtXVKxYUaSlpYmEhAQxb948AYjo6GgRHR0thBBixowZwt3dXfz888/i+PHjYvz48UKv14uIiAghhBCnT58WgChdurRYtmyZiIqKEpcuXRI//vij8Pf3V68tW7ZMeHl5ifnz5+c5jtGjR4t27do5XNuwYYMARHBwsPjnn39EeHi46NixoyhdurRIT08XQggxb9484eHhoZYJCwsTs2fPFocOHRIRERHizTffFCaTSZw9e1bN06tXL1GyZEmxfPlyERkZKdauXSsWLVrk0OaNGzfEjRs3RMOGDcUTTzwhkpKSHPr29NNPi4EDB+Y5ngsXLogPP/xQHDhwQERGRorPPvtMaLVasWvXLjVPs2bNhLu7u5g8ebKIiIgQCxYsEIqiiH/++UcIIYTFYhFVq1YVrVq1EmFhYWLTpk2iVq1aAhC//vprnm0vXbpULFu2TJw8eVIcOHBAdOrUSVSrVk39PERHR4sqVaqIsWPHiujoaBEXFydmzpwp3N3d1fc/ISFBCCHEc889Jxo2bCg2b94sTp06JT788ENhNBrVz8C8efOEXq8XDRs2FNu2bRPHjx/Pca+EECImJkYoiiJ27tzpcP25554TgYGBYu3ateLQoUOia9euws3NTbz00ktqnsDAQOHu7i4++ugjcerUKfVwcXERn3zyiYiIiBDbtm0TtWrVEoMGDXKouyB9b926tdizZ4/Yt2+fCA4OFn379nXo47FjxwQgTp8+nec9l0gkkgdN9vlfCCGeeuopUbt2bTXd1dVV9O/fXxw+fFgcPnxYJCYmCn9/f9GtWzdx6NAhsW7dOlGmTBmH+eztt98WNWrUUM9vN6cnJCSIoKAg0aRJE7FlyxZx8uRJsXjxYrF9+3aRnJwsxo4dK6pUqaLOL8nJyUIIIVq3bi06deok9uzZIyIiIsTYsWOFt7e3iImJEUIIsXjxYmE0GsU333wjjh8/Lt544w3h5ubm0LesmM1msWzZMgGIEydOiOjoaHHz5k0hhG2+zT6veHl5idmzZ4uIiAgxfPhw4e7uLtq1ayeWLFkiTpw4Ibp06SKCg4OF1WoVQogCzTvZWbVqldBqteKtt94SR48eFWFhYeJ///ufw/sVHBwsNm/eLMLCwkTbtm1FuXLl1N842d8LIYT45JNPRGBgoMPnIPv7vGfPHqHVasVPP/0kzpw5I/bv3y8+/fRTtcy0adNEpUqVxOrVq0VkZKSYN2+eMBqNYuPGjXmORSL5NyFF6yPIwIEDhVarFS4uLsLFxUUAwt/fX+zbt0/N88MPP4iKFSuq/3iFECItLU04OTmJv//+WwghxK+//iqyP5cICAgQ7777rsO1evXqiRdffFEIcUu0zpw50yFP2bJlxU8//eRwberUqSI0NDTPcXTu3FkMHjzY4ZpdQNoFpRA28ePk5CQWL14shMgpWnOjSpUqYtasWUIIIU6cOCEAsWbNmlzz2ts8duyYqF69uujevbtIS0vLke+VV14RzZs3z7fd7HTo0EGMHTtWPW/WrJlo3LixQ5569eqJ1157TQghxN9//y10Op24ePGimv7XX3/dVrRm59q1awIQhw4dUq/VqFFDvP322+p5bvfx7NmzQqvVOrQvhBCtWrUSEydOVMsBIiwsLN8+HDhwQADi3Llz6rX4+Hih1+vFL7/8ol67efOmcHZ2zvHjokuXLg71DRkyRAwbNszh2pYtW4RGoxEpKSl31PdTp06p6V988YUoVqyYQ5m4uDgByMlcIpE8UmQVrVarVaxZs0YYjUYxbtw4Nb1YsWIOc9jXX38tihQpIhITE9Vrf/zxh9BoNOLy5ctCiJxC6XZz+pw5c4Sbm5sqNrOTm/DasmWLcHd3F6mpqQ7Xy5YtK+bMmSOEECI0NFT9vWEnJCQkT9EqhOOD56zkJlqfeeYZ9Tw6OloAYtKkSeq1HTt2qA/zhbj9vJMboaGhol+/frmmRURECEBs27ZNvXb9+nXh5OQklixZIoQouGjN/j4vW7ZMuLu7i/j4+BztpqamCmdnZ7F9+3aH60OGDBF9+vTJta8Syb8N3QM06krugBYtWqhr7m7cuMGXX35J+/bt2b17N4GBgRw8eJBTp07lWM+Rmprq4Daalfj4eC5dukSjRo0crjdq1CiH+07dunXV10lJSURGRjJkyBCGDh2qXjebzXh4eOQ5hpSUFEwmU65poaGh6msvLy8qVqzIsWPHcs2bmJjI5MmT+eOPP4iOjsZsNpOSkqK6rIaFhaHVamnWrFmefQFo06YN9evXZ/HixWi12hzpTk5OJCcn51neYrHwv//9jyVLlnDx4kXS09NJS0vD2dnZIV/16tUdzv39/bl69SpgC45VsmRJAgICcr0XeXHy5Eneeustdu3axfXr19U1pufOnaNq1aq3LW/n0KFDWCwWKlSo4HA9LS3NYb2TwWDIMY7spKSkADi8x1FRUWRkZFC/fn31moeHh+ralJWsnzGAgwcPEh4errqjAwghsFqtnD59mqioqAL13dnZmbJly6rnWe+/HScnJ4B832+JRCJ5GKxatQpXV1cyMjKwWq307dvXYZlJtWrVMBgM6vmxY8eoUaMGLi4u6rVGjRphtVo5ceIExYoVc6i/IHN6WFgYtWrVwsvLq8D9PnjwIImJiTnWzqakpKi/S44dO8YLL7zgkB4aGsqGDRsK3E5+ZJ237OOuVq1ajmtXr17Fz8/vtvNOcHBwjjbCwsIc7ltWjh07hk6nIyQkRL3m7e2d72+cvMj+Prdp04bAwECCgoJo164d7dq1o2vXrjg7O3Pq1CmSk5Np06aNQx3p6enUqlXrjtqVSB5VpGh9RHFxcaFcuXLq+TfffIOHhwdz585l2rRpJCYmUqdOHYd/tHaKFi1aKO3bsa+LmTt3rsM/YiBX8WfHx8eHGzdu3HNfxo0bx5o1a/joo48oV64cTk5O9OjRQw1MYBcgt6NDhw4sW7aMo0ePOkxidmJjY/O9dx9++CGffvopM2fOpFq1ari4uPDyyy/nCJCg1+sdzhVFyTOQUUHp1KkTgYGBzJ07l4CAAKxWK1WrVr3j4AyJiYlotVr27duX471zdXVVXzs5OanroPPCx8cHsD1UuZvPXNbPmL1vzz//PKNHj86Rt1SpUoSHhxeo77ndfyGEwzV7wK3C+K5IJBJJYWJ/aG0wGAgICECnc/yplv1/551SkDm9oPNq9nr9/f0d4gzYud+R7O1k/f9vn8Nyu2afk2837+TG3dybrGg0mhxzUm4BL7O/z25ubuzfv5+NGzfyzz//8NZbbzF58mT27Nmjvqd//PEHxYsXdyh3t0E4JZJHDSla/yUoioJGo1GtW7Vr12bx4sX4+vri7u5eoDrc3d0JCAhg27ZtDlbJbdu2OVjGslOsWDECAgKIioqiX79+Be5zrVq1+PHHH3NN27lzpzoh3Lhxg4iIiFyfaNr7N2jQIDXQQWJiohpwCmxPI61WK5s2baJ169Z59mf69Om4urrSqlUrNm7cSOXKlR3SDx8+TPPmzfMsv23bNjp37swzzzwD2Ca9iIiIHPXkR3BwMOfPnyc6Ohp/f3/Adi/yIyYmhhMnTjB37lyaNGkC2AJH3A6DwYDFYnG4VqtWLSwWC1evXlXrulvKli2Lu7s7R48eVa2fQUFB6PV69uzZo76/cXFxRERE0LRp03zrq127NkePHnV4WHO/+n748GH0ej1VqlS5p3okEomksMn+0Pp2BAcHM3/+fJKSklShs23bNjQaTa5eLgWZ06tXr84333xDbGxsrtbW3OaX2rVrc/nyZXQ6XZ7b3AUHB7Nr1y4GDBigXrvdHGi3NmZvrzC43byTG9WrV2fdunU8++yzOdKCg4Mxm83s2rWLhg0bArfmcPtvhaJFi3L58mWEEKqIDgsLK1DbOp2O1q1b07p1a95++208PT1Zv349bdq0UYMm3s7rTCL5tyKjBz+ipKWlcfnyZS5fvsyxY8cYNWoUiYmJaqTWfv364ePjQ+fOndmyZQunT59m48aNjB49mgsXLuRZ76uvvsr777/P4sWLOXHiBBMmTCAsLIyXXnop3/688847vPfee3z22WdERERw6NAh5s2bx4wZM/Is07ZtW44cOZKrtXXKlCmsW7eOw4cPM2jQIHx8fOjSpUuu9ZQvX57ly5cTFhbGwYMH6du3r4PlsnTp0gwcOJDBgwezYsUK9V4sWbIkR10fffQR/fr1o2XLlhw/fly9npyczL59+3jiiSfyHE/58uVZs2YN27dv59ixYzz//PNcuXIlz/y50bp1aypUqMDAgQM5ePAgW7Zsue0ep0WKFMHb25uvv/6aU6dOsX79esaMGXPbtkqXLk1iYiLr1q3j+vXrJCcnU6FCBfr168eAAQNYvnw5p0+fZvfu3bz33nv88ccfdzQWjUZD69atHQS0m5sbAwcO5NVXX2XDhg0cOXKEIUOGOESwzovXXnuN7du3M3LkSMLCwjh58iS//fYbI0eOBCjUvm/ZskWNFimRSCT/Zvr164fJZGLgwIEcPnyYDRs2MGrUKPr375/DNdjO7eb0Pn364OfnR5cuXdi2bRtRUVEsW7aMHTt2ALb55fTp04SFhXH9+nXS0tJo3bo1oaGhdOnShX/++YczZ86wfft23njjDTVi70svvcR3333HvHnziIiI4O233+bIkSP5ji8wMBBFUVi1ahXXrl1ziIp8r9xu3smNt99+m59//pm3336bY8eOcejQId5//33A9juhc+fODB06lK1bt3Lw4EGeeeYZihcvTufOnQFb1ONr167xwQcfEBkZyRdffMFff/11276uWrWKzz77jLCwMM6ePcv333+P1WqlYsWKuLm5MW7cOF555RUWLFhAZGQk+/fvZ9asWSxYsKBwbpZE8rB5qCtqJbkycOBAAaiHm5ubqFevnli6dKlDvujoaDFgwADh4+MjjEajCAoKEkOHDhVxcXFCiNwDMVksFjF58mRRvHhxodfrRY0aNcRff/2lptsDMR04cCBHvxYuXChq1qwpDAaDKFKkiGjatKlYvnx5vmOpX7++mD17tnpuD6iwcuVKUaVKFWEwGET9+vXFwYMH1TzZAwidPn1atGjRQjg5OYmSJUuKzz//PEcAhpSUFPHKK68If39/YTAYRLly5cR3333n0GbWIA6jRo0S/v7+4sSJE0IIIX766SdRsWLFfMcSExMjOnfuLFxdXYWvr6948803xYABAxwiPWbvlxC2gFRZozieOHFCNG7cWBgMBlGhQgWxevXq2wZiWrNmjQgODhZGo1FUr15dbNy4MUeZ7IGYhBDihRdeEN7e3gJQ09LT08Vbb70lSpcuLfR6vfD39xddu3YV4eHhQoiCBcKy8+eff4rixYurUYyFsAVj6tu3r3B2dhZ+fn5ixowZon79+mLChAlqnsDAQPHJJ5/kqG/37t2iTZs2wtXVVbi4uIjq1as7BA67m77n9j2oWLGi+Pnnnws0RolEInlQ5BY9uCDp4eHhokWLFsJkMgkvLy8xdOhQNWK8ELkH/7ndnH7mzBnRvXt34e7uLpydnUXdunXVaPmpqamie/fuwtPTUwBi3rx5Qgjb//9Ro0aJgIAAodfrRcmSJUW/fv0cAva9++67wsfHR7i6uoqBAweK8ePH5xuISQghpkyZIvz8/ISiKOp8mlsgpuzzSvZ5MrffOLebd3Jj2bJl6r3z8fER3bp1U9NiY2NF//79hYeHh3BychJt27ZVI9zb+eqrr0TJkiWFi4uLGDBggHj33XdzBGLK/j5v2bJFNGvWTBQpUkQ4OTmJ6tWrqwEshbAF7po5c6aoWLGi0Ov1omjRoqJt27Zi06ZN+Y5FIvm3oAiRzbFeIilE/vjjD1599VUOHz6MRvPoGvYbNGjA6NGj6du378Puyr8KIQQhISG88sor9OnTJ9c8SUlJFC9enI8//pghQ4Y84B7m5K+//mLs2LGEh4fnWCsmkUgkjyMTJ05ky5YtBVpaIpFIJI8i8heb5L7SoUMHTp48ycWLFylZsuTD7k6uXL9+nW7duuUpuiR5oygKX3/9NYcOHVKvHThwgOPHj1O/fn3i4uKYMmUKgOoa9bBJSkpi3rx5UrBKJJLHHiEEUVFRrFu3TkaRlUgk/2qkpVUikRQqBw4c4LnnnuPEiRMYDAbq1KnDjBkzco3YLJFIJJL7x82bNylWrBj16tVj4cKFBAYGPuwuSSQSyV0hRatEIpFIJBKJRCKRSB5ZHt1FhhKJRCKRSCQSiUQi+c8jRatEIpFIJBKJRCKRSB5ZHhvRunnzZjp16kRAQACKorBixQqH9EGDBqEoisPRrl07hzyxsbH069cPd3d3PD09GTJkSKHuByaRSCQSyeOAnHMlEolE8iB5bMJnJiUlUaNGDQYPHky3bt1yzdOuXTvmzZunnhuNRof0fv36ER0dzZo1a8jIyODZZ59l2LBh/PTTTwXuh9Vq5dKlS7i5uaEoyt0NRiKR/GsQQpCQkEBAQMAjva2TRFKYyDlXIpE8DOSc+9/lsRGt7du3p3379vnmMRqN+Pn55Zp27NgxVq9ezZ49e6hbty4As2bN4sknn+Sjjz4iICCgQP24dOnSI7u1i0QiuX+cP3+eEiVKPOxuSCQPBDnnSiSSh4mcc/97PDaitSBs3LgRX19fihQpQsuWLZk2bRre3t4A7NixA09PT3XyBGjdujUajYZdu3bRtWvXXOtMS0sjLS1NPbcHYz5//jzu7u73cTQSieRRID4+npIlS+Lm5vawuyKRPFLIOVcikRQ2cs797/KfEa3t2rWjW7dulClThsjISF5//XXat2/Pjh070Gq1XL58GV9fX4cyOp0OLy8vLl++nGe97733Hu+8806O6+7u7nIClUj+Q0jXRInkFnLOlUgk9xM55/73+M+I1t69e6uvq1WrRvXq1SlbtiwbN26kVatWd13vxIkTGTNmjHpufwIkkUgkEsl/FTnnSiQSiaQw+c+uYA4KCsLHx4dTp04B4Ofnx9WrVx3ymM1mYmNj81yTA7Y1O/YnvPJJr0QikUgkOZFzrkQikUjuhf+saL1w4QIxMTH4+/sDEBoays2bN9m3b5+aZ/369VitVkJCQh5WNyUSiUQi+dcj51yJRCKR3AuPjXtwYmKi+gQX4PTp04SFheHl5YWXlxfvvPMO3bt3x8/Pj8jISMaPH0+5cuVo27YtAMHBwbRr146hQ4cye/ZsMjIyGDlyJL179y5wFEPJf5ODBw+yefNm3N3dad68OYGBgQ+7SxLJY43VapVbHTxk5JwreVgcO3aMNWvW4O7uTuPGjSlXrtzD7pJEInkAPDaz/t69e6lVqxa1atUCYMyYMdSqVYu33noLrVZLeHg4Tz31FBUqVGDIkCHUqVOHLVu2OOwbt3DhQipVqkSrVq148sknady4MV9//fXDGpLkEWbv3r2sX7+e999/nw8//JAKFSrg7OzMs88+m28QEYlEcvfEx8fTpUsXypQpw/79+x92d/7TyDlX8iAJDw9n9erVfPHFF7z11ltUqFABNzc3nn/+ec6ePfuwuyeRSB4AirDHi5cUCvHx8Xh4eBAXFyfX2jym/PPPP3z77beUK1cOX19fRo8erUax27t3Lz/88AOffvrpQ+6l5EEhv/MPhsjISJ566ikuXLhAmTJliIiIYN68eTz99NMPu2uSh4j8/j3+bN++nffff5/atWtjNBp57bXX1Dn3xIkTvP/++3z33XcPuZeSB4X8zv93eWzcgyWSB8WaNWt4++23qVy5co60unXrMnHiRCwWC1qt9iH0TiJ5/Fi/fj09e/bE29ubXbt2ERgYyHPPPUfv3r05fPgw77zzjnQXlkgeU9atW8eECRMIDQ3NkVaxYkUuX75MWlqagxVfIpE8fshZXiK5Q06cOEHFihXzTG/atClbtmx5gD2SSB5PhBB88cUXPPHEE9SpU4ddu3ZRqVIlnJyc+PHHH5k+fTrvvvsu3bt3JzEx8WF3VyKR3AcOHjxIjRo18kxv27Ytf//99wPskUQieRhI0SqR3AFWqxWr1ZqvFfXpp59m8eLFD7BXEsnjR3p6OsOHD2fkyJGMGjWKP//8kyJFiqjpiqLw2muv8fvvv7Nu3ToaNmzI6dOnH2KPJRLJ/SAlJQVnZ+c803v27MnSpUsfYI8kEsnDQIpWieQOOHXqFOXLl883T4UKFYiKisJsNj+gXkkkjxfXrl3jiSee4LvvvuPbb7/lk08+QafLfTVLx44d2bFjB0lJSdSrV49NmzY94N5KJJL7RXR0NMWKFcs3T0BAADdu3CA5OfkB9UoikTwMpGiVSO6AvXv3Urdu3dvma9GiBevXr38APZJIHi/Cw8OpX78+R48eZf369QwePPi2ZapUqcLu3bupUaMGrVu3Zs6cOQ+gpxKJ5H6zb9++As25Tz75JH/++ecD6JFEInlYSNEqkdwBe/fupU6dOmzbto2//vorz3zSRVgiuXNWrFhBw4YN8fT0ZO/evTRu3LjAZb29vVm9ejUvvPACL7zwAiNGjCAjI+M+9lYikdxv7KL1wIEDLFu2LM98PXr0yDddIpH8+5GiVSK5A06cOEGFChVYuHAh06ZNw2q1qmlHjhzh2WefZcaMGZQpU4ZLly6Rnp7+EHsrkfw7EEIwbdo0unbtSvv27dm6dSulSpW643r0ej2zZs1izpw5fP3117Rt25aYmJj70GOJRPIgOHjwINWrV2fx4sVMnTrV4UHUyZMnGTp0KNOmTcPHx4eUlBQSEhIeYm8lEsn9RIpWiaSAWCwWFEVBo9EQFRVF9+7d+emnnwDYunUrY8eO5Z133iEuLo65c+fyxBNP8M8//zzkXkskjzbJycn07t2bSZMmMXnyZBYvXoyLi8s91Tls2DDWrVvHoUOHqFevHkeOHCmk3kokkgeFEIK0tDRMJhMHDx5kxIgRzJ07F7BZYIcPH85rr72Gs7MzM2bM4KmnnmLlypUPudcSieR+IfdplUgKSEREBJUqVSIyMpKgoCBGjRrFU089xZEjRzh+/DhLly7F1dWVSZMm0a5dO2bPns3HH39Mx44dH3bXJZJHkvPnz9O5c2dOnDjB0qVL6d69OxaLhejoaC5fvqweiYmJpKamqofFYsFkMqmHs7MzRYsWxc/PTz2aNm3Knj176Ny5Mw0aNOCnn36iU6dOD3vIEomkgFy6dInixYtz9epVfHx8GDx4MN26dePChQscPHiQpUuX4unpySuvvEKbNm34/vvvGT9+PH379n3YXZdIJPcBKVolkgIQHx/P9OnT6d69Ozt37qRx48bo9XoWLFjAyZMneffdd9FobI4LOp2O1q1bExERIbfgkEjyYMuWLXTt2hUhBD179uTbb79jzNhxXDh/zsHtHkCj1aFo9Wg0OhStFlAQVgvCasZqMWO1ZIAQDmW8vLypWKmSGsSlc+fOqjVXUZQHNUyJRHIXJCcn8+6779KsWTN27dpFo0aN0Gq1zJs3jyNHjjB16lR16zlFUejWrRubN28mJiYGIYT8jkskjyGKENlmesk9ER8fj4eHB3Fxcbi7uz/s7kgKgbNnzzJ48GDeeOMNWrZsyUcffUS9evVo1qxZvmXee+89UlNTmT59On5+fg+wx5IHifzOF4ykpCQ2btzI1q1b+fOvvwg/eFBN0zt7YtG5gtEDjO4oemfQO6HonNGY3CA1Fq1HSdJP/Imid0JXoj6K3gnAJl6FAHMq1vRErKnxkJGCSE9ApMahMydgTr6JsNq2oPLy8qZ79240bNiQ1q1bU6JEiYdyPySFg/z+PX5cvnyZ/v378/LLL9OhQwe+/vpr/Pz8eOqpp/IsExMTw+jRo/Hx8WHEiBFUqFDhAfZY8iCR3/n/LtLSKpHchgULFjB58mSaNGkCwJUrV267b1xgYCBnz57l6aefZuPGjfTu3ftBdFUieaSIiorijz/+YNUff7BhwwYy0tPRGV2wmLxR3Eug+FZF41wUNDq0uZRXNBoUjZaMC3vQFQnEVPkpLIlXID3R9ldY0LiXRKMzgNYVtAbQu+WoRyuskJaA9dpRYi2pzPtpOXPnfgMIqlStxlOdOtKhQwcaNGigWm8kEsnDYfHixapgBducW6NGjXzLeHt7ExsbS/fu3dm4caMUrRLJY4gMxCSR3Ibw8HDq1Kmjnl+5cgVfX9/blitatChVq1Zl48aN97F3EsmjxdWrV5k1axa169SlbNmyvPzyK6zfeQSLT010lbpCpZ7oyrRCF9QGras/iibvZ6eKRov15ml0vsFotHoUjRa9Z0l0RUqhK1IKrGbM57eDogHFJnAVTc5pTVE0KCYPtCVD0ZdugVL+KTSlm6MUrcqxS8l8NONTGjdujH9AccaNG0dYWBjSCUkieTgcOHCA+vXrq+f2OVdkWzaQnbJly1KqVCk2bdp0v7sokUgeAtLSKpHchpSUFJydndXzmzdvUqRIkduWa9q0KWfPnuXs2bP3s3sSyUPHYrHwxx9/MHv2bP7++x8EoLgVR1u6OYpbCRStPldL6m0RVnTe5dEYnGyCNIsVVGtyR1uiDsJqwRwfTcaFPejLti5w1RqnIljiL6At1RQhrGiTrxNzI4pPPv2cjz/+mIqVghk29DkGDx6Mp6fn3fReIpHcBdeuXaNo0aLqeezlaJIm9udQ3A0qzf8HnVdRUk9HoHV2xViitJqvadOmHDp0iNjYWLmuVSJ5DJGWVokkH27cuKH+YI2NjeXmzZsABZoMQ0ND2bFjB35+fly6dOk+9lIieTjExcUxc+ZMgsqWo3Pnzqzbth8C6qOt3AttmVZoPMugaPV3VbdGp8d8cTci+ToarR6N3oCi0aLVGdDobYei1aLRG9B7lkAxuiKSC74nq2L0QDG6IyzpIKwopiJoAuoiPMuiKdOKU1fTefXV8fj7B/Diiy9y/PjxuxqHRCIpOGlpaRgMBgASEhK4fv06bS4fIu3UUTKuRXOsX3PCn6jEsb5NOdylNqfGPoM1PQ24NedWrFiREydOPMxhSCSS+4AUrRJJPoSFhVGzZk0AfvrpJ958880Cl61YsSIRERE0b95cughLHiuuX7/OhAkT8PMPYMzYsVxM0qOr2AkR9CRan0ooOtM91a9oNIi0OLCkoysSaBOnmYJVFa6Zf7U6m3g1BNRGY3RF0RTcpqstVh3Sk7Cc2YTlzHqwmtGVCEHrUQpNqaZognuQ7lGRud99T3BwME8+2YH9+/ff09gkEkneHD58mKpVqwKwYsUKXn35JaqmXlfTzTdjsCTchEyvi7hNf3L69SEIIShRogQXL16kefPmbNiw4WF0XyKR3EekaJVI8uHw4cNUr14dgIsXL7J+/XoyMjIKVFan02GxWGjXrh2//PLL/eymRPJAuHHjBpMmTSIwsDQfzZgJ/nUx1eiDxrUYOo8Sua4nvSusFrTOXpjKtkKjtwlTTaZg1WS+1mS5ptUZ0LoVxXz9xB2JVgDFqQi6oFboyrbNIbYVvTNa/1pQsTvaUo1Zs2kHderUoXPnLoSHhxfOWCUSicrhw4epVq0aYJtzz+/ZjgbQmJyo+tsBir/0DqUmfEStTecI+vhHUBRubvyT2L9+QVEUNBoNzZo147fffpPr0iWSxwwpWiWSfDh16hTly5cHbBNo//79SUpKUtNTU1P5/fff83QdDAgIwGKxULp0aXbu3PlA+iyRFDYZGRnMmDGDwNKlee/9D1FKNcSr3du4VumIsWh5NIoGy6V9mSLy3qYVRaNgPrMBxZKO1sUzX8GaVbhqtDpE4lWwpBeeeFb7pEXjVR7KP4W2VBP+WruJGjVq8Mwzz0jXf4mkEMk+5z7briUAxpJlMRYPxLv3C+wy+XI44iRFmj2Jb9/htryfT8GSkkSFChW4cuUKISEhrFmz5qGNQyKRFD5StEok+XD27FlKlSoF2Na0+vv7O2yJ8d1337Ft2zbGjBnD999/z7Vr10hLS1PTa9SowcGDBxk/fjwffvjhA++/RHKvrFu3jipVqzNu3KtoSjbEv/tMvOo/g87FC63RCZ3RGecKrTCUrI2SkYRGsa1HvRs0Oj2WS3sxlKyPzsNPFazqoTeg0evR6PVojSbbuT1No0VfvDbW+It3bG0tKIqiQeNVDlG+M9qSDVm89FfKlSvPBx98QHp6+n1pUyL5L3Hq1CnKli0LwKVLlyiu2DybXKrXA2zb4fzzzz9MmjSJr7/+Gn2PYej9SpBx9RLXls1X59yXX36ZmTNnSmurRPIYIUWrRJIPZrMZnS7vINsbN27kjTfe4NdffyUhIYFXX32Vnj17YrFYAKhVqxZ79+7F39+fEiVKsHv37gfVdYnknrh8+TI9evSkdevWXErWEtjnY3xbPI/R0xeNzoDO4IRGp0drdEJrcMLoWQKt0URG5FpE/Hm0BlOBxaui0aCk3UTcPIOp/BMYfCs4Cla9wSZSdfpsVlY9ilarWmENvuXReZeB1JuFbm116K+iQeNdEcp3Ic2lNBMmTCS4chW5dl0iuUcSEhJwd3cHID09HcNlW/R9p6BKgO0h2sSJE1m6dCmKojBh0lssTrT9n4me+wE1q1Rm7969FClShDp16rB+/fqHMxCJRFLoSNEqkeSBxWJBk/nD1/60NiMjA7PZrKYnJSXh7u6O0WhkxIgRzJ8/n06dOjF37lwA6tevr7oFjx07ltmzZz+EkUgkd8Yvv/xC5SpV+OOfdZR66lXK9nsf1+Ll0GoVNDoNOoMhd+HqXQaXOs+gdfJAyUhCxJ3NFJp6mzDNIiQVjcaWpjdivRKONfYUBr/K6EzO6Ay2+rQGJ7RGE1qDCa29PWFFpMapQZi0BlOmoLWl65zcMV/YiWJOvq/CFUDRGdGWCEFb4SnOX0umRYsWvPzyyyQnJ9/XdiWS/wKKoqC7dAYAp7LBCCGIjo7G398fvV7P0KFDmT9/PtWHjSFDb8KalEDxa2c5dOgQAC+99BJff/31QxyBRCIpTKRolUjy4MKFC5QsWRKA+Ph43NzcOHTokOr+u3//fnx9fWnVqhXPPfecKma7d+/Otm3bANDr9bi5uREbG0upUqWIjo5WrbASyaNGTEwMvXv3plevXmj8q1Dx+dkUrdEKrV6LVqtBZ9DmKlztwlFrcMLg7IFTQFX0RQLQaMActRaNBki6AslX0ShWtDodIuYEGaf+Rkm7iSmoKS7Vu6J3KXJLsBptglVncHIQsTFbviJ221ysaQm2a5lWV3v7emdPnGv0RCRcRGtwuu/CFWzBnESZJ9AE1GfW519SrXoNuYZdIrlDbty4oe6BbjabMWFFk5wAgKlsJSIiIvD29qZly5Y888wzqkt+527dOWS0lYv5/UeKFy/O+fPn8fHxITk52WHJjkQi+fciRatEkgeRkZHq2poLFy5w8+ZNli1bpu7VumfPHlJTU/nggw9o27Yt7dq14+WXXyY6OpqYmFv7RbZt25Zly5YBNsurdBGWPIrs2rWLKtWqsfTX3yj/9ETK9Z6EyaMIGp2CVqtBo9OowlWn16DTa9EZDGgzRaXObhXNtLoaXLxwDmqCe72BGDz80Ll4ophTIeESWoMzOvcAXGo+jbFYBfTO7rY6TK7onFzRObmgN7mgN7lmilUTOoMBnUGHya8CWpMbRrciavt6k+ut9g1OGFx9cCrXHMuVcMSNKCjAvsr3iqIoaH2roCnfkXNXE2jUqDEfffSRXFMnkRSQrHPu5cuXKZIQgwIkWBX0RXzYs2cPAG+++SZ9+vShffv2jBo1iqNHj7Jb7w1A4oHtdGjTmiVLlgDILeckkscIKVolkjzIGhDi4sWLZGRkULp0aVJTUwFbaP7r169TrVo1evbsyT///MOQIUMYP348zs7Oqotgjx49OHjwIBMnTqRjx46sWrXqoY1JIsmOEIIvv/ySxk2akObkTeknnyPlchR6ow6N1iZUtZnCVafXotNr0eo0aHRKpnDV2SytmeJRb3JB55R5mFzRmVzRm1wxepdG5+SGc1AoRo+iOJWojsGliK2Ms0cOsWor54TeZMRg1KE32sSyX5N+lOryJgYXF3R6LXqTHr3JqLajc3JB7+KOwdkDl4qt0ej1EHMcrdHR6mqNv4A1+Vqh30/F5AlB7cCnMq+++irdu/cgPj6+0NuRSB43ss+5ZTJs35szGbb/U4cPHyYmJoY6derQoUMH1q5dy6hRo3jttddI9y+NxtUDkZFBYz8PLl26xMiRI+nYsSMrV658mMOSSCSFhBStEkkeHD16lMqVKwM2S2tKSgru7u6kpaVhsVg4d+4cer0eg8EAgEajoVq1atSsWRM3Nzd1H0c3Nzc+//xzzpw5g7u7O/v27XtoY5JIspKSksKAAQMYMWIEgU26EPLy55Ru9TRln3qBawfWcHXPKhQsNvGqU1Srq1286gwadHqNTVSajA7i1ba+9JaATTu9FXPMKTKuHFHFrM7JFb2LOzonFwzO7tnEqh69UWs7TFr0Rh16o84mVI06dAbbdUOmmLWJV5t7sipendxxq9gal0pPQNJlLGc2QuIFsKZjvRKG9fz9ceFVFA3agLroglrx+6o/qV2nDkePHr0vbUkkjwvZ59ziGTbX4GPpWhITEzlx4gQAHh4egM27oUKFCrRp0wadXk9KkK2s+XgYH3/8MSkpKaSkpBARESE9HiSSxwApWiWSPIiKiiIoKEh9rdVq0el0GI1Grl27RlJSkvpUOCsDBgzgxo0b7N+/3+H6hAkTmDNnDiVLluTs2bMPZAwSSV5cv36dlq1asfiXpTQb+S71BryKi7MJJ70Wo1GPX7026IxGTv8+C0Wxooj0LEJVm+kmbBeQjuJVb3JC72yzdtoP9+DW6Jw9cQ1qgMHF3XZkClWDswc6kwsGZ2eMTgYMTjqMTjaRanTSqyI165FVwBqd9BiddBicdOhNegzOtjoNLu42q6uLJ65lGuBaozs6JzcMnsXBagEFlITzaLUKikhXA0bdK/YgUzqfCmjKtePsxWs0CA1l06ZNhfDOSSSPJ8eOHSM4OBhhNnNj21qKW1IAiFCcOHfuHImJiRQrVixHuf79+3PlyhUidW4AJB60LcF58803+fzzz6lWrZoanEkikfx7yXsvD4nkP47ValX3ZI2KisJoNOLi4oKvry+rV69Gq9VSt27dHOXKlStHYmIiBw4cAGxRhhMTE6latSonT55k6NChrFy5kpEjRz7Q8UgkdqKiomjbrh2Xr8XQfeo3eAdVJTndglZza+2nVmOkRKOOBIR2IPn6JU4s+hCvyg0pVq8Dil6LogGh1WCxWBFWDRqtFSEEGrOCsAqEFaxCIKy2acbgXBmX4sFYrbcsHhqNgpJ5aLWKze1Yq0GjUdQ1tIrGli87WesRVtBZBRaLFa3OgsVsRaPTYDUYMKenYzU4YU5PQWt0wuBeDGG1YGr5qq0eczoZCVdIu7QfS2oc+qAWWFOvg0aH4uQFijazjZwB1ITVqr62RUfWZr7WgqLBcuUQ1oRLGCt3Je3sZlq3acMP339P79697+Xtk0geS1JSUnAymTjSvR61zp8GwIxCql8gGzZsICMjI9c519/fn/T0dHZdS6AykBi2k9jr1yhTpgzR0dE888wzrFq1iurVqz/gEUkkksLksbG0bt68mU6dOhEQEICiKKxYscIhXQjBW2+9hb+/P05OTrRu3ZqTJ0865ImNjaVfv364u7vj6enJkCFDSExMfICjkDwq3LhxA09PT8C2V1xMTAwGg4FSpUpRvnx5PvzwQ3Q6Xa6ToFarxWAwcPHiRcC2fcjIkSPRarVYrVZatWrF2rVrH+RwJBKV/fv3E9IglLiUdIZ+uoigqrUx6DQ4G7Q4G7Q4ZR4GnQYnvRa9VoOrb3FqvvgRBmdXNJiJObQOjSUl07pqs7gajLosVk89Jhc9Jmc9Tq4G9TC52Cyi9sOQ5bXRSY/BSY/BaLuuU9JJPLMPkRJL8sWjXN39O1d3rUCr03Dz+FbiI7aREXsWnQ40Sjp6oxajkw6Ts8HWvrMeg5MOk4sTBmdXjK5eGF2LYHQrgiHzMHr44OQdgFup6ng1GoJX05E4+wZhcPVCSY1BxJxAq9VijlqL9eIulIxENOZkRPx5SI217UWrWNFYU1EyktAoAvP57WRE/ImSEoOxRB1ca/fF5FsOt5Dn0PnVoE+fPsyYMeNhfwzuGTnnSgqTtLQ0DAYDqVHHSTt/GisQZvBiZXArgqpUY9asWTg5OeUpPJ2cnDidakUxmhAZ6bzR/2kAdDod9evXVyP6SySSfy+PjWhNSkqiRo0afPHFF7mmf/DBB3z22WfMnj2bXbt24eLiQtu2bdWgOgD9+vXjyJEjrFmzhlWrVrF582aGDRv2oIYgeYQ4cuQIVapUAWDWrFlqxN9SpUrRtWtX+vXrh5OTE5UqVcq1fJkyZcjIyCA9PZ3ffvuNqKgo0tLSKFWqFDExMWi1WhISEh7YeCQSgH379tGyVSvcff0ZO2cZJcoEZQpVnSpWswpX9dBrcTIaKNWoA0Z3d4wubpxa9iE3jm6CjEQUkYLeaFtfanTS2cSpsw6Tk4JRn46zmyFTxBpUUWs/DE56jCabwNSYE0i+EIZIieH0bzPIiItGp9dg8vTCrXgZ3EuWQ2/UYXB2AWs6GQnXsSTFcvrXGUT8+CYp0ccRqTEYjZpM4WzIFK6210ZXF4yuNndlo6sXTu5eOHt64+xZFGcvf5yKFMNUpBgupeviVqUjblU6YPT0w6V2P5wqtEbvGYDW5IZWb4TUG2j1RsTNM1hvRKGYk9GaPDCVaYJLnWcwFKuAwc1bjYqsd/HAu+lw3Kt1YuzYsUyfPv1hfxzuCTnnSgqTiIgIKlasSPzODQCcShUsdg3CObgmnTt3pnv37nh5eVG1atVcy1euXBkrYKxoE7Wlr50hISGBSpUqERUVRZEiRbh69eqDGo5EIrkPKOIxXJ2uKAq//vorXbp0AWxPfAMCAhg7dizjxo0DIC4ujmLFijF//nx69+7NsWPHqFy5Mnv27FHdT1avXs2TTz7JhQsXCAgIKFDb8fHxeHh4EBcXh7u7+30Zn+T+M3v2bAICAnjqqafo1asXR48epVixYsycOZNixYoxduxYYmNj+eOPP3It/8033/DXX3+pP05btGhBxYoVOX/+PP7+/ly6dAlfX1+6dev2gEcmKWz+Ld/5ffv20bxFC/wCgxj3+UL0zm6kmq2kmi2kpFtIM1tJN1tJSTeTbraSZrZisQrSM//mdpgtFmIj9nNpxyrMqclUfmYSUX/MJe3GFVyLl6N4k65E/v4V5uQEAhp3wy2wBhbrLddejUYhIyEGrdGJq7t/J/nKGYrVbUOxGo3RKoqDu7LFKhzO7dcczoXg0q6/id75J97Vm1G09pNYLFasZoE5w5LpyiywmK0oGlv0Y7vrsdVqy5ORZsGcbsaSnoLFnI7VnI41IwNhtWA12/aFtLsKZ3cZzuoerNEZbH/1esf9bHUabu5fwvWdi3jvvfeYMGFCIb7LDwc550rulZ9//hmLxULIzl+J37mBP9KdWesZxEcffUTlypUZOHAgaWlpeUbfX7JkCUuXLmVUzSCcl39NmpsX556fhhACi8WCRqMhLS2NZ5999gGPTFLYyO/8f5f/xJrW06dPc/nyZVq3bq1e8/DwICQkhB07dtC7d2927NiBp6enw3qJ1q1bo9Fo2LVrF127ds217rS0NIeNq+XWBo8H+/bto2PHjgBER0fj6+vL22+/TbVq1YDMPeQyN0HPjZo1a7J69WoGDhzIzJkzCQoK4ptvvqFXr178/fffPPvss0ydOlWKVskDYf/+/bRq3ZqiASWY+Ol3GJ2dsGoVsjrbaDW3RKJWY8Gg05ButqLVKHmKVtDiXC2EEtVC1HrqDRyv1gfg98IUNX/4L7PISE3FtXgF3AMrc+r3LzB6+FCqVV/KdhiETqPBoNNk64uiitO8RGtW8Vq28ZMENniCm5fPk3HjDBe2/Ipv3Sdx8iuP1YJNtFpsolWkxpB8/gReVRqTdCkSJ69ATC4GMtLMmNMNmDOsmNPNWM3pmNNTEFZL5mFFWByFqypYtdrMQEwGNJni1S5WdXrbPrclWg7AYNIxceJEFEXhtddeK5T3+VFBzrmSO2Xfvn0MHjyY5B+mAXDevRjjx4+nfv36gO19t8eYyI1atWrx888/M/rbRcwtAsaEWA6sWs6gN97h22+/5fXXX2fEiBFStEok/2L+E6L18uXLADmizhUrVkxNu3z5Mr6+vg7pOp0OLy8vNU9uvPfee7zzzjuF3GPJw+bixYsUL16chIQEzGYzGRkZDmtpatWqhYuLS57lq1atSnp6OitXrsRkMhEeHs7p06epVq0aH330ESVLluTChQsPYiiS/ziRkZG0bdeO4oFBvPfdEiKOH2XZe5MYMe1TjAaTms8uFHUahTSzXbDeEq/paWlcOXucomWrYEXJYeXMKjR1mpxW0jSzlZB+LxMdeQJhcMZYxJd6o2ao5exi1f43L7LXm/Xvres6nEuXJd1sxeTswrltK3HxKcaNY7vROnng7FeWtNgLXNn1O8VqNMXN3UTsgRNcWDcP76pN8K7ZDnO6FXOGhfQ0LeYMPXqzE+b0dNXimhF/GTQ6dC63Hl5pNFqUzEOjM6DVaTMDSilqtGWdXos1JRZLUiweQdWZMGECRYsWZfDgwXfx7j6ayDlXcqecOHGCIJ8iHIm5ihU4ZTVQo0YNNb1BgwbcuHEjz/Jly5YlLS2NH35bhfV/I8mICKdDxCZKuzsTERGBl5cXN2/eRAiBouT9/0UikTy6/CdE6/1k4sSJjBkzRj2Pj4+nZMmSD7FHknslOTkZJycnIiMjmTBhAjdv3qREiRJqYCaAIUOGYDab86zDZDJhNpupVKkSEydO5Pjx42RkZODs7ExycjIAPj4+XLt2jaJFi97vIUn+o1y/fp127dvj7OrOx98twsXTg9r1GpCWmsqKbz6j18jXQGeztmqtqC65WQ+LVWDQWdm0+HOunY6gTEgrKrfq4tBOVquo7bDVaclIR6OAVaPHYhUkpprRlq9EutmaLb9NrOqynOdFwUSrwJzp2uxUpiw+JUeTbrZiTipH3NljJJ65SYlGHSlbrxHORh1CCNxbd0G070NiYhIXD27j2sEtFGvYAxfv0pgzLLYjXYvFIshINHNt53xAwf+pqQDqVjm3Ih/fioZss7JqISMRa1ICqdfOUKZlD/zLBXP4548YNmwYAQEBtGvX7u7e6P8Qcs59/LBkei1c2LMdgGsWDRonZ0qUKKHm6d+/PzExMXnWodFoUBSFypUrM6NCEyqeiiDAmsq5d0ZgMdsimwcFBREVFZXrVnUSieTR5z8hWv38/AC4cuUK/v7+6vUrV65Qs2ZNNU/2Rfpms5nY2Fi1fG4YjUaMRmPhd1ry0AgLC6NmzZpMmzaNoKAg+vbty48//uiQp2LFiretx8fHhytXrrB37150Oh16vR6LxYK7uztxcXE0btyYrVu35ukGJ5HcC8nJyXTq1IkbN27y/e9rKOZblAyrFbAS2qQ5dRo24befFlCzSStcffzQWECjCDRZhKtRp8lc26qhbM0Qrp46QunK1XE16dV2sgpPXTbx+vWY50hPSea5GT9g1Row6LSq5dacKTSNWdyBDXYBnWWvVIvV6nBuF61Zhaoly9Yzt67ZRKu9rXSzFdcqNbEE26w3Bp0GN5MtANWGOdO4GnWMRs+9iV/xcng0acv1MpWI2rKSEi1LY0m+icnZG7Petp2OVuuOsYgfOhcfjE4GABQNKBrFJlqzbNuj09u27rm0+ScSzx+l3JPPUr5RW5wMWtxMOtoOf53ViTH06NmTzZs2Ubt27cJ4+x8qcs6V3AnHjx+nUqVKrPn2S+oDbsVL4YSTg0U0MDCQwMDAfOsJCgri9OnT/L1tJ4eKVGJkTBiJ+7dTp3wzLl26RJMmTdiyZYsUrRLJv5THJnpwfpQpUwY/Pz/WrVunXouPj2fXrl2EhoYCEBoays2bN9m3b5+aZ/369VitVkJCQnLUKXl82bNnD9WrV+f69esoioLFYqFy5cp3XE+tWrUYPXo0HTp0oHz58ri7u3Pu3Dlq1KhBeHg4TZo0YevWrfdhBJL/OkIInnvuOQ6Gh/PFD4spVbo0Wo2CXqPBqNOg1yoYtFrqN27Gl2+9wpkj+zHptJh0GvVw0mtVYeVs0FKjUXOGfryAwIqV1ajCbiadw+FqP4w6XAw6XFzdMDo54eZkwNNZj6ezHg9nAx6Zrz2d9ZllbNddTXpcTXq1PieD1uHcfjhna9teLvuRvS1PZz3ergb18HI14uVqxNPLG62i4O3pruYLKF2GOk+PQCfSOLvqU26Er8Zg0mZGJTYR1H0CJZ8YkhmZ2Bad2ORiyBIhWUv6leOcXfkJpMVSMqQNoaNnEFilFl6Z7Xs46yni5kz/t2dStFRZOnbqxJUrVx72x+eekXOu5E7Ys2cPtWvXxnT5DAAZfqUICgq643pq1arF66+/TpMmTShZryEXXG1eTPWMZsLCwtQHxRKJ5N/JY2NpTUxM5NSpU+r56dOnCQsLw8vLi1KlSvHyyy8zbdo0ypcvT5kyZZg0aRIBAQFqtMPg4GDatWvH0KFDmT17NhkZGYwcOZLevXsXOIqh5PFg7969uLm50aFDBzZv3oyXl9ddWT8aNWpEeHg4o0ePZsmSJaxcuZKTJ09Ss2ZNwsLCGDlyJMePH78PI5D81/n888/5+eef+fTredSsVQebUVKgaDKDL+lsVtXAMmV554sFXL92jZMHdlK2Wh00Oh0aC+g1kGG1YrGCQavBIoSDO66DS7CioFEU9FrbawCNAi9/PFd1MbYK0GcGWkpJt6iW1qwuwXm5BefnLmzvT17n6WatamlNN1sy69PcsrTqtXQf8SoW6zg1anJKugVDaoZtfa1fMUJHfcTJDSvQKmYSzx/CNbAGikbrEAUZwJqeQtKFo5hT4nErUZ6k8wep0OFZvIuXsu1767ClkE59bdKZGPXRXKb278DTTz/N2rVr0eke7elZzrmSwmLv3r3Ur1+fIJMW0iHa6H5Xc25oaCh///03r7/+OmvWrOHovvWUSryG341o/gkLo0OHDur+6RKJ5N/Hoz0r3gF79+6lRYsW6rl9zcvAgQOZP38+48ePJykpiWHDhnHz5k0aN27M6tWrMZluBSJZuHAhI0eOpFWrVmg0Grp3785nn332wMciebjExMSwd+9exo8fz4oVK1i3bh1jx46943rq16+vRj6sU6cOixYt4tSpUzz99NMsWLCAUaNG4ezsTGJiIq6uroU9DMl/lB07djBmzBieff5FOnTpzq1dzRSEIgB71GAroMHTwx0XV1dOHg7j/VH9eeaVSZSsUAWLEGgsYNXYtpKxCrtgdWxPq8EmWDNFp0ZRSI67ibOHB/s2rSElKYGS5SoRWLEqeq1N2Jp02kxBLBxErzYf3x9NHsFTrCKrm3DOdCe9IN1i375H6+CKbNJp0Gs06vgMWg0GnTWLkM5QXwe36UFScipXY85xefuvFAvpiAJc3v0nABWfHs/lXb+ic3bDr1ojihQvTWClyhh0NoFsF6gGXZb9cPVajJn98PIPoEnHbqz6/mveeOMN3n///YK83Q8NOedKCovTp0/j4uJClbREAP46dIJvPv76jusJDg5m8eLFANSuXZslViPNAc2V8+zfY9tr3dfXlytXruQIEiaRSB59Hst9Wh8mcv+ofzdxcXE8//zzxMfH88cff1CpUiW++uorWrZseU/1pqWl8dRTT1G2bFm+/PJLOnXqxNKlS/n888+pWbMmrVq1KqQRSB40j9J3/vr169SsWZOAEiX5ecWfaPU6LFabu7AVm6gTCCxWMFsFGVYrGRZBhlWQYbESe/0qV69c5cLZ0zh7eFK+Rn2EomQRrLa/WQ2bGsVmCdUpCkd2b+WPH77Gzd2DEe98xLEDu0lJiEdnMOBVLIAd61fTof8L6JycybAILEJkClZbXdnXq2a3sOYmXB1Fa87pzCpuie4Mi1AtwnqNwo3LF0iNv0np4OqYM9MzrFZSM62tyekWElMzSEm3kJBqJiXdoq6VBRwikWYPYGUXq8ZMC2tWsWoXzEathoyUJP5ZOJfKteoSVLEyW/9awTcfvMOKFSvo3LnzXXwK/ls8St8/yZ2Tnp5Or169MKUl8+q1vQgBF177ki69et9TvUII2rdty+QbB9ALC/P86vC/n5axePFivL295XZz/2Lkd/6/y2NjaZVICoN9+/ZRpUoVDh06hMVi4ebNmzRr1uye6zUajeh0Os6cOQNA8+bN2bRpE40bN+avv/6SolVyzwghGD58OMnJKXz57QIMBj1CABqBEIpNvWmwvdbcsrhqFYHWItAqULRoMbx8fPH09mb1kh/Z8vsvDJs0nU1//EpghSr4BQZhMDk5tHv8wG62rlpKyXIVad+zH/UaNkGv16FVILRZSzSZolcIQeKN63wxcQSvfDQHk1aPVdGAxczNq5eJPHyQtNQUQp/oxIWIo8RcicZocqJizbr8+u0sEuNvEtKqPVaLhfW/LkKr0zH0zensXLOK5MQE/EqVoU7T1kQc3IfOYMCnWAAmF1c0Gi1GkxNWIbBoBRoFzCnJ7Nv8D0d2byMgMIgyFSqx+ddFNO/aD71ea7P6Ko57xdqFqOM+tbfIKliNmYLVdmgdxKvduqvXgF6jMHfaazzRrTchzVqi1WjoO3QEx/fvZshzzxEaGppjWxiJ5HHi0KFDVK5cmdS9mwE4b4b2T3W553oVRUFnMBCpd6dS+g3alPbj77//pnHjxnz99ddStEok/0KkaJVIsrBnzx6cnZ0JCQlh//79eHl55buh+Z2gKAoGg4HU1FS6dOnC5MmT+eabb5g+fXqh1C/5b7N48WKWLl3KnO8WEBAQgCDTAVgoWBWbG64iwIJAi024KoqCVSj2nGgUm9W1uH8Ag0a/ilUIUtPScHd1Y/faVQTXrk9GejrrVixCQWH45I+4cfkCXQc9T2DZCmg0Ngsm2LbP0WSzlDZp+QShzVuTmprC5BEDUTRanuw9kCJFfVGsGXh6uONs0JIUcxXFko67qw9F3N1o36MvHkWK4OruiU6vp2mb9pgz0tHq9DRs0Zpr0dEIYcWA4NzxQ6SnpVGtfkNizGb+XDSflMRERv7vM47u28napQtp270P7bs9TcfuTwOQbrbg4uzCh6MHMOztj3Ar6qeuzQW7INU4iNbsOFpab1lZ7eJVr8l0R9YqnNq/k9+++5yXps7grc/motdo1HunVRTeeP8T+rZpxPPPP8/y5cvlvpKSx5Y9e/bg7e1NMW9XiIUzFp2DC/m9oNfruezmQ6WYG5TNiOetn39m6dKlREREFEr9EonkwSJFq0SShX379lGhQgU6dOjA8uXLqVWrVqHV7ePjQ7FixTh48CAhISF4eHiwe/du0tPT5YbnknsiOjqaF198kS7dutO5W3eEsLnNahUQCihCwYLIDBevILBZWm2fOIFeaxesVrSKgkVjc6e1CNBrnGjZ4SladnhKvda0bQe17bZde6FVUK2TGo2inmfFXq9eKBh0rrz/3WLVtVejKFSrceu71rLDUw7l3CtWyjlonc3iG1iqNIGlSgM2N+A+Q0c4ZKsb2igzDc4YjUyaOYcinkVuBU+yCjR6hfY9elOvWSu0RhPb//6N+m07A1p1CyDb9j/a24pWXVb3YK0GjaKoYjXl5g2EBsK3refNmV/jVcTLQazqtba1vQF+fkx6/xPGDB3AwoULeeaZZ273EZBI/pXs2bOH0qVLUzYjHoA0L//blCg4JUuWRLH6QMxJMo7uo1Lj/qxevRqNRoPFYim0B9ISieTBIEWrRJKFxMREDh8+zKRJk3j77bd58sknC63uMmXK4OHhwa5duwgJCWHKlCn069eP4sWLEx0dLSNmSu6aF198Eb1ez/sfz0Cj2OymWkVRxatNnyk2qaoILFYFLQJFAawKGkWgoKDVaDMj/drWm1qtqAIWbMIPUKPmZiWrWLWJV8d0raLYvJJRsFptrrHWfEIq5BV4qSDkVq9FQPM27RyswQBWJdMabRX4+vqSbrESdy2aedNeo/9rUzHp9Gg1tgjKToa8XYPtf7NHUtZrFeKvXWbp97NJiL3O+A+/5MWJ76DXanKIVVsgK9s64XYdO7Ohey9GjRrFE088Id2EJY8lly9fJjk5mY6xV7ACxsqF96A4KCgIjdWKdZcGUpIZ168nT7/yGtWqVSMiIoLg4OBCa0sikdx/pGiVSDK5evUqPj4+XL9+HaPRyLlz5+4q7H5elClTBovFwp9//sno0aPVrXSSk5PZt2+fFK2Su2L16tWsWLGCb+YvwMfbJ4tItTv9Kuo1u7twXutcrQIUjYJAQWMVWBWBHkUVsPrMNi2aXCyNWYTqrW1v8gikpEEVxvb8WV8XFpZs4tVqxaGPtnEpaIRQxStA3+dHs3fbFnRWM/FxN3DzKYZFa3Odhpyi2D4ue1AprUbBajZzfPdWEm/GUrFaTdp27UXl6rVyFas6jYKSKVYVbHUoCkya9j5PrF/LhAkT+O677wrtvkgkjwJJSUk4OzuTfuM61vgbAAQ1a1No9ZcpU4aLFy9yWetEgDmJ1G1raNOmDZcvX2b//v1StEok/zLy2WBAIvlvsXfvXkqWLEnlypURQpCSkkLZsmULrf6goCAuX75MSkoKaWlpAIwaNYrjx4+zb9++QmtH8t8hLS2N0aNH06RpU7p2654pfGxuvwqo4sd+TT3HJpLslkGtYtsvVZ/p3qrTgF6rYNBq0Gs1mHS2rVmMmW6uJt2t9Zn2c1tE3swgQ5nltGp9OQ9DZr0mnVZtw/7aUEiHvU77YVTXlmozt+m5NQZb35VMUamhbqMmaIWVuVNe5bc5H5MeH4urXouzXourQedwOOu1GK0ZXIs6xo7fF0FKIss+f48rZ05Rt2ETKlYKpkatOrb7ps2MHJzpPqzX2rb60arBn0Cr2M59fLwZO/FN5s2bx65dux7yp00iKVzCwsIICgqitrsBgFirQoWahfegOCgoiPPnz3PUzeZyHPv3Ul544QUOHz4s51yJ5F+IFK0SSSb79u3DYrEQGhrKpUuXAPD3L7z1NbVq1WLnzp00bdqULVu2AODn54fVauXIkSOF1o7kv8PMmTOJiorigw8/tln5uCVSswvVrAI1Iz2Vzz6cTtje3TaRlCUtq4CyC1iNYhOxdrFpF6VZhaZeq1EFqb1de9uKvd4sx/nTp5jy6mjOR51Ep8HhyJ4367Hsx3m8PXYk1oz0PAWxLov41mkAq5mZ0yaxduWyTOsm6tpTu0hV3Xk1NhFr1Gnx8fHm3a8X0rBlW9ydTPw29xNmvvIsP0x/A501g5mvPMvMV55lz+pfuRBxmP3r/8LHxxsPVydGvTmNZ4aNJLBUKZz1WtIS4pg/czoXoyJyFat6TWafFHswJ1vaM4MGU6VadUaOHInVmstGtBLJv5R9+/ah0+moZ7J9ro+nayhdunSh1V+pUiUOHjxI0Sd7IoC0c5GYUhLQarWcOnWq0NqRSCQPBilaJZJMjhw5wpkzZ2jSpAmHDx/G1dUVTfaFefeAi4sLRqORRo0a8eeff6rXfX19iYuLK7R2JP8Nrl+/zrRp0xg27HmqVq2iBvKyC9fsFtasVtc9O7Zz9NBBPp/xgWp11WQTttNeH8vz/bqTkZqqurPahaNdyNqP1SuWMrBzWyKOHLwlMO2WQ+VWoKGsYvjvlb+SEHeDv1f+WgDxeev467flRF84x+VL5/MVt9pMEajTKFw6d4Zjhw6yeMG3al+yCnJdpng16m5ZQRWrhamjBvPF5PHUrF0Xb28vnn1pPNPm/MgrUz7A09WZaXN+ZNqcH2nfrRfH9mzjxMG91KrXAHdXV7UeU6ZA3b72L85GRvDzt1/lsKzaBXSOe6cBvU7Lu+9/xN69e/npp58e6mdOIilMDh8+zMWLF/HNSAYgXDjh5OR0m1IFR6/X4+vrS5WGTYl28Qbg2tJ5BAUFkZiYWGjtSCSSB4Nc0yqRZJKQkIDFYsHX15ewsDA8PT3vuA6LxcK1a9fw9fXNVfB26tSJEydOOFhWQ0JC+PHHHzGbzeh08ispKRgffvghAK9NmACQuWY1U7gKgZVbrsC3ovTa1rU2bNyE48eO0rBJU7QaW3Rh2xY5mRGHhcLZyEgSE+NJT03BxdnJFrQJW3AnsLmw2uMRnTx2GKPRwMVzZ6lavSZktm0n6zfBLq6fHfoCq1f9TtsOne5oHev0mZ9z6eIFypUrX+Ay5cqVp//gYZQqXSbT9dZ2H4SwiXqh5FzPm27NIObKJeJir2PUaXIEo8qKVoELkSewmjMwJ8XjrPfPvH4rwFL7p7qQGBfLEx2eQqtkumcrioPLtv2+2da23lor26BhQ9q278A777xD79695f8JyWPBpUuX0JjTsd48DsA5pyJ3XIfVauXKlSv4+vrmGg24a9eu7NixgzOaIvQnhquL5tBw4CT2799PQkICbm5u9zwOiUTyYJAzn0SCbW1gRkYGFStWBGDHjh1UqpTLNhu3qaN///4YjUbc3Nz48ssvc+Tp2rUr/fv3R1EUIiMjKVu2rCpao6KiqFChQqGMR/J4c+XKFT7//HNGjhyJb1EfrAIEmaJU2IShJlNkWbMIIntAJqPRwPCRoxyiC1sBrV2UKjDn+4WkpKTg7WOzUCiZYs22XY4Nu9Z8ZeIkLpw7S1CQ4xpw1fqrkKOMp6cHvZ/pf8djLxNUhjJBZe6wlMKTT9m20bGLbkXYxqLNFPu2e2EL3qRoFNzd3Ph03iL0egMmnSZHMCo79mdT7346h7ibsfj5FwdsVmuFWyLUw92dYSNfzhSome9RtjXG2cWq/RrAa6+/QcsmDfnhhx949tln7/S2SSSPFEIIUlNTqV/EhLieQYpWj7P/nX2vzWYzgwcPRgiBRqNhwYIFOfK0a9eOAQMGkOxcFHRxWG9co1r0MaxWKydOnKBu3bqFNSSJRHKfke7BEgkQERGBRqOhRYsWgC0M/51GFhwzZgx9+/blhx9+ICUlhfDw8Bx5XF1d+eWXX7hy5QqrVq0CoHr16qSlpXHs2LF7H4jkP8H777+P2WymTevWwC2x4+gKrNiEETndhbXZ3IWzXtNqbNfd3dwo5uvrGCDIvv7VfmSmGfV6ypYth6IojumaW/VldQ++3aEh96Og+QvUTtaxZFnPmzUYlZ9fMby8iuQIRpX1sK/rdXNxpkTxEmpgJ10urr72AEtZ16zmlqauAc58X7WKQo0aNejUuQtTpkwhIyPjoX32JJLC4Ny5c2g0Ghp72dyBL1j1VKla9Y7qePPNN2nTpg0//PADbm5ubN++PUceo9HIokWLiL5yhYOlagJg+WcpSoaccyWSfxtStEok2NbWXLt2jTZt2pCUlITFYqFMmbyf+iYlJTFs2DBeeuklrFYr8+fPx8XFhS5dugC2yfSzzz7LtaxOp6NJkyYsXLiQhIQEjEYjJpNJTqCSAhEbG8vs2bMZ/sLzfPrpp/z4ww/ALYuc3aipnmcK19sFabLvr2oXsFlFbPY1qjmFLA4CVXV9zSIi7ULMLqq1imM7WY+81qg65Mknf/b6stedVUSrFs7M+3S7YFTZD9ua2FtraHO9R5nW1YKIVfvY7BZXTWYfFQUmvv46Z86cYdGiRQ/wEyeRFD6HDx8mNjaWkonXbefCSFBQUJ75U1NTGTVqFM8//zxms5lly5YRFxdH//42b40333yTWbNm5VpWURSefPJJvgo7icbDC2tKEo2MZo4ePVr4A5NIJPcNKVolEmD37t34+vri5uZGeHg4BoOBKlWq5Jn/22+/pUmTJtSpU4cnn3ySnTt3Mn36dDW9bNmyXLhwgfT09FzLDxkyhFKlStG3b19OnTpFiRIlZAh+SYGYO3cuVquVsWPGsOjnnzh//jwvPP88SYmJt6ys5LS6wi3hCrkHacoqYDVZhFd2S2xBrKe36nMUYqp1VMm9ndyOXK2r2dsrYNkcY8lmeVXUvKDPIkb1GseAUvos1+wBn+z3Rq+KUTLvRRYLajaxahel2cXqrfyZgldRqFKlKq1bt+bTTz9FiFwW10ok/xL279+Ps8mE+WwEAJF6j3zn3MWLF1OpUiXatGlDx44dWblypcODYT8/P5KTk/MMsDRo0CD8i5dgW6pt3Wtjk4UDBw4U4ogkEsn9RopWiQTYtGmT+sR2//79mM1mypfPO9DLP//8Q9WqVRkwYACrV69m9uzZOQIvtWnThrVr1+Zavnr16sTHx/Phhx/y0ksvUa9ePc6fP194A5I8lpjNZr744gue7tWToj7eaDUKr0+cQL++fejRsyeHMl3Sc7O65ucunFW8ZrVGZhWyWd2BVXfaAhx24ZhViOV1OLoW3zqyCuA8LbtZ8mcVxLm1kdWqrFqbc1iPHcdss6LaBGlWUZrduqrP0X9HcZx13ao6plzE6i3ruKKuf9Uo8OKLI9i3b1+urpASyb+FdevW0a9NM6ypKQiNhjMWHdWqVcsz/19//UXVqlXp0aMHq1evZv78+ej1jivMO3bsqC67yU5QUBAZGRm0HD8FgIC0OGKuX5PbSEkk/yKkaJX854mNjeX8+fP07t0bsIlWNze3XCMRgk047Nq1i7fffjvfenv27MmSJUtyTVMUhfr16xMXF0dgYCAeHh4AXLx4UYbil+TJr7/+yvnz53nxhWG3LgorTZs25fv583j3f//j6zlzbIFJchGukL+7sKOFMqf7roOVNZs4yyoUsx+3RPLdHVkFcF79zEt051ZfVtFuF+BZxavDutisW+hoHces0yo5RHRu620d3JC5JViznucmVm33Nav4h4YNQylWrBgzZ868nx81ieS+kZSUxJEjR3iqss0dOMbFC4OTE87OzrnmF0KwYcMG3n333Xw9DLp168by5cvzTG/RogUXje5kaPXo0lMJ0tmCMck5VyL5dyBFq+Q/z1tvvUW5cuVUS+ntovjOmjULb29vUlNTWbp0aZ75SpUqxdWrV0lNTc01vWfPnixcuJDnnnuOgwcPkp6ezueff07z5s2l658kV2bPnk2jhqHUqF4dhNV2AAgrvr6+/LzwR1JSUxkwYAA3b9wosLtwVvGa25HdBTc/QZvTAkqOfhT0yNWVOA+hnN1F2N43cqk3N/GatUx+IjTrnrH5uUVntQzfEt5ZgzBlE7DkFKtZ+5sQH8e706bxzDPP8ESbNvz6669cuXLlvn3WJJL7xbvvvkvp0qVJO7ofgMNmPSVKlMgz/8KFC9V90+fNm5dnPm9vbzIyMoiPj881vUePHvy0eAlONUIAKJN2k/nz51O3bl1pcZVI/gVI0Sr5T7NlyxZSU1PVCTMjI4OkpCRq166dZ5l//vkHNzc33Nzc+Ouvv2jfvj0DBgzg3LlzOfK2bduWv//+O9d6atSowYULFyhatChnzpyhQYMGfPHFF9SqVUu6/klycOHCBTZs2MCAZ/qiiCw/sLIIV40CL48excsvjaZP377s3r0byNtdGHCwut7uyEss5rauNDfraH7COD8Lrdp+FnFnD5qUvX8O5bOMmcz2gVzFa17jKagbdF6u0XbxnZt1NatgzeoGnLV/aakpfPLJJ/Tv35/69erx+4pfee/dqWg0GhmQSfKv48CBA5w9exZ/f3/id20C4GiaQp06dfIs88cff1CkSBGEEOzbt4927drRp08fTp06lSNv586d+e2333Ktx+4irASUBqCprxuzZs2iZcuWec7TEonk0UGKVsl/mk8//ZTBgwerkYLt0QQbNGiQZ5kTJ07g5OREcnIy33zzDX/99Revv/46gwYN4ubNmw55+/bty5dffpnnU9w33niDjz76CJPJxLRp05g8eTInTpzgm2++KZwBSh4bfv75Z4xGI106dQJAEdZb4jWb1bVunTos+mkhX331FZ988kme7sJ2oQSOYvB2h4Mwu42ozU+E5iuQcwhURe1v1sPmgpu7kM3evm3cOUVtdtfn7OMpyFFQ9+is1tWsgjWrNdr2Pgl+/uknunXrRmCpkvy+4leeaNMKBYG3VxHaPtGGH3/8sXA/ZBLJfeaTTz7hpZdeooyvNxlXLwFwymrId84NDw9Hq9Wi1+v59NNPWb16Nf/73/8YNmwYV69edcjbvXt35s+fn+e2UJMmTWLZ4UgA/M0pvPfeexw6dIjvvvuukEYokUjuF1K0Sv6zXL9+HY1GQ2xsrBpqf//+/aSlpeUbxTAhIYHAwEDKly+vPumtVKkS06dP59lnn8VsNqt5ixYtSqdOnZg0aVKukYTr1KnDiRMnqF27NkeOHGHMmDGMHDmSHTt2FPJoJf92fvzxRzq2b4uHmytkeQiSl9XV09OTed9+g8FgYPSoUVgsllyFK5CrGCzocWvtZt4WUPsBBRfG2dvJb81rjrxqHXkftvE7Wl5vZ1nNd91tLqJXUXK6R9sFK1nGmfV90Shw9sxpnu7Vi8tXrrDytxV079oFBaE+nFCElb5P92Tv3r0cP3787j9UEskDJDExkZs3b5KamkqVIi4AWJxciU3LICQkJM9y165do3jx4tSsWZOwsDAAypQpw2effcagQYNIS0tT87q5uTFo0CDGjRuX69KcihUrcjTZNkdb42IYMWgAb775powkLJH8C5CiVfKfZenSpfTs2ZOoqChVtG7atIlKlSqp1qfsxMXFYbFYCA0NpVmzZmzYsEFNq1+/Pr169eLVV191KDNixAgqVapEp06diI6OzlFnq1atMBgMqktwz549uXHjRmENU/IYcPToUcLDw+nds8eti9mEq4PVNfOvoiiMfHE4oQ0a8MILL2A2m3Os87zToEhT33mbd6e+k4toy104Zj/yIj+RmlcQprzGkFcfHNvL3Rp7u7W9m9atZdizA7l+9UoOl+jcRK9jP3MXrFnH8dPChYx55RXen/4eY15+Cb1O6yBW7e/zk0+0wcPDQ7oIS/41/P7773Tu3JmoqChKaywA3NCZKF68eL6BDzMyMqhfv36OObdq1aq8+OKLjBw50iEOxDPPPEPjxo3p2LEjZ8+ezVFn687dSDPagj4lHt5H27ZtSUhIKMyhSh5RhBBkZGSQmpoqj0fkyMjIKHAcF919/nxIJI8sW7du5bPPPmPq1Km0b98egH379jF58uQ8y6xZswZPT09Kly5NkyZNGDBgAMOGDSMjIwOLxUKfPn04duwYbdu2pVy5cowfP57AwED69+9PnTp1eOWVV3L8yOzVqxeTJ09WJ037D+6MjIwcIf0l/03++OMPnJycaN2imU3AKJkSzC5cM4OIKcKKUDS38mT+7devL1qdjpEjRvDFl1+qPxCt4pbVNeuUkfsjG9ua77Vr1gDw+utvoNM5TiGaLAWtedaSN1nLZy+tyac6a5bOiyx5s/ZBCJFDuFq5ZXUtKL8sWYTZbGbPrl106twZraKQ23xrzbyoydJAXhZWsLkDv/XW22g1GpYt/QWtRnFw+1YfSmS+5yaTiSdateCPP/7I93+WRPKosHXrVl577TW+++47qiVcA+BYQho9+vXIs8yOHTtwcXGhdOnSNGvWjE8++YRXX30Vs9lMeno6HTt25Pjx47Rp04agoCBeffVVypcvT8+ePalTpw6jR4/Osca1R48erFk4g/Ikc3PDKjwbtUav13Pjxg2KFClyX++B5OGRnp5OdHQ0ycnJD7srkmw4Ozvj7++PwWDIN58UrZL/LDdu3MDLy4uzZ88SGBiI1Wrl+vXrtGnTxiHfggUL2L59O59++imrVq2iWLFi+Pj44Obmhl6v5+DBg0yYMIGUlBQ+//xzpkyZgtlsJjw8nEmTJvH9998DULlyZfR6vdqencDAQDUKqBACRVHw8fFhz549NGzY8MHdEMkjy59//kmLpk0wmUy2C3YBk1W85idcgd5P90IAzz//PLNnz0an06FRbgm+3LSbXVRZLBZOnz7NtWvX6Nu3Ly4uLly7eoWAgAAHr4Ss4jE/kZkXuQlVq9XKnj17WL9uHQcOHMBqtVmQzWYzZYKCaN6sGW3btcNoNDr0wUG8CnJ4T+QmYvPsV5ay06d/wK5dO2nbrv2t8opNADv0nZxi1XbdsT67hfWD9z/Aw8ODcWNecbCWQ07Bak9r26YVzw0fxZUrVyhWrFgBRyORPBzOnj1LqVKliIqKwqiNJw04GJfK9Mx1+naWLVvGb7/9xpdffsmvv/5KQEAAPj4+GAwGfH192bt3L1OmTCEuLo6PP/6YcePG8fLLL3Py5EkmTpyoRvUPCgrC39+fo0ePUrlyZbV+b29vduiKUJ5rxG37B2G1UrJkSdavX0/37t0f5C2RPCCsViunT59Gq9USEBCAwWDI06NO8uAQQpCens61a9c4ffo05cuXV3fyyI17Eq0JCQkOJl2NRoOrq+u9VCmRPBCSk5NxcnICbE/fDAYDR44cwWQy4e7u7pB35cqVPPHEE3zwwQesXbuWVq1aUbRoUcBmJX3ttdf47LPP8PT0ZODAgfz555/odDpq165NTEwMqampqtgYPnw4X3/9Ne+++65DG66urnh6ehIVFUXZsmUpV64cGzZskKJVQlxcHFu3bmXG9GmOVlbI0+p6/dpVPv/qa57p24dy5cur2fs83Quj0UjfPn1sQb8iImjfvv0tMZyFa9eusWrVKtasWUNqSgply5WjWLFieLi7c+PGDaa/9x5nz50jsFQpunTpQvMWLXK14KpdzWN8eVlUk5OT+f777/n9999pEBJC23btGDvmFVWcCiGIiopizdp1dO3alSeffJLnnntOHUtu4jXr9Tv5wZK1fNGiPnTs2NGhLgBNlrkwNwvu9q1b8PHxITi4slqnXbAuXryYq9euUdTHm61bttC4caO8BWuWNcxPtGqJoiisXr2agQMHFng8EsmDxmKxoNFoUBSFGzduYDVfAOBMhibHA5fffvuN5s2bM3nyZH7//XeaNm2qzrl9+vRh/PjxfPrpp5QsWZIePXqwevVqdDodwcHBCCGIi4tT9z4fOXIkX331FbNmzXJoI7FkBdKPn4Zrl4kc9wxVK1Zg69atUrQ+pqSnp2PNfDiR137AkoeDk5OTatBJT0/P9feInTsSrWFhYbz++uv8+eefAAQEBDiY2RVFYceOHdSrV+8uuy6RPBgOHTpE9erVHR66/PTTT9SvX98hn9lsJjU1laFDh9KiRQusVivp6en4+PgANjejHj1uuTa1atWKBQsW0KZNG/78809CQkL4+++/6dy5MwChoaG88847OfpTt25d4uLi2LFjB2XLlqVmzZrs2bPnfgxd8i9j3bp1mM1m2rZpZbuQ3cqai9V16bJfOXHiOF99/TUff/C+g6twty6dqRJcie49e6HT6di5cydvvfUWycnJnDp1ih07drBt61bc3N3p2LEjc2bPxt0t74eRp0+fZumy5Xw8YwbNmjZl0LPPOvwIVYWdEPTo3g2z2cLyX3/NsYbNLgxv3LjB3Llz2bx5M/379+f3336zreu0YxdzQNmyZSlbtixDnxvCL8uW07VrV0a8+CIdOnZEoyi5uj9rFPjoww/5/bcVfDV7DsFVqjq0nxt5JeXlDq3J5i98+XI0706ZgtliZu36jQ6C9dChQyxbupSXXhrNjBkz2Lx5C3+uXGFrNx/BirDi6+NN3do1+fPPP6VolTzSREREqPufm6xmMq5fBsC1gmPQQyEE165dY/DgwbRv356EhAQMBoM657Zt25a2bduq+Xv16sWXX35J7969+e2332jQoAG///47/fv3B2zrXk+cOKF6MdmpF9qQC/GnCTp/hLjNq+laoQ4fHMi5/lXyeJGfFU/y8Cjo+3JH796sWbNo3Lixw7UffviB9evXs27dOvr27ctnn312J1VKJA+FAwcOUKtWLa5du4avry9gEwfdunVzyLd7927q16+Poig88cQTPPnkkyQmJubpUfDyyy+zcuVK+vTpg9ls5vz58yxbtkxNVxSF0qVLExUV5VAuJCQEs9msRg2uVasWkZGRhTlkyb+ULVu2UKZ0IKUz9xJWybrNjf08k949u1Ondm1eGvGiY1rm34oVKzJ/3ncULVoUi8XC888/z5tvvMG2rVupVbMmixYtYsH8+fTs3s1RsNrbzHKUKVOGV8eN5Y+Vv1O3bl1eeeUVXn31VeLi4oCskXMF8fHxJCYmoCByBE+6fv06b731FkMGD6Za1aqsWrmS3r163hKs2ceb5ZpWq6V3r54sX/oLBw8epG/fvly6dEmtGxwDIl2/fh2tVktScrJDHjvZgyvZydpfsqU7XM8WVMrXtxjVqlenV6+nHba1uXHjBuPHj+fLLz6nQUgILVu0YMrkt2x13Eaw2mnWuBFbt24tcCALieRhYJ9zU1JSKKG1BWFKVrQ80amzQ74jR46o0fu7dOlCkyZNuHbtmipas/Pcc8+xZ88eunbtikaj4eDBgznWsNaoUYODBw86XAsJCWFbqdps8LV5Pvie3I+4cqFQxiqRSO4Pd2Rp3b59OyNHjnS41qBBAzXyqpOTE7169Sq83kkk94kjR47Qtm1bTp8+re7RevbsWTp06OCQb+3atbRu3ZrY2FjWrl3Lzz//zHPPPZena6FOp+PHH38kMTERLy8vunbtisVicXAR7tixIytXruSll15Sy9WpU4fPP/+cpKQkAEqWLInZbCY5OVm6svzH2b59Ow3q1gFAyRQmIuvnL6ulNfN1EU9PXn15tG2dax5rXOvWqcOav1ffKpuVfARxDjLTNBoNrVu1pHWrlmzavIVnnnmGli1bMmTIENzd3dFoNPz5558IIdQATgkJCezcuZNffvmF+Ph4nh82jKlTpmTWKRzqz7MfWcbk7OzMm2+8zrHjJxg2bBj9+/enV69eajAku9V3+vTpJCQk5FgKkJ3sYjYtLY3Lly+TlJREpUqV1KfDea2jtaPXafl4xgxbdzOvWS1mnn/+ef737jSb66OwMvLFF2x5CihYAULq1uGjTz/n/PnzlCpVKt/xSCQPiyNHjtCzZ0/OnDlDsKst2MqldEHXrl0d8tnn3ISEBH755Re+/fZbRo4cqS4LyI5Go+Hbb7/lxo0b+Pr68uuvv2I0Gh1chDt16sTKlSupWbOmWq5atWpEnT7NCeHGkxWqkRJxiMa6VK5fv56nQJZIJA+XO7K0nj17Vl1XADBlyhSHL7e/v78aUCY3LBbLXXRRIil8zp8/T8mSJdXtbuxiMbsF1W5pHTduHO+9916Bgp04OTlRtGhRtFotVquVtm3bOjz5bdOmDX/99ZdDGVdXV5KSknBxcSExMZESJUrg4uLC7t27C2G0kn8rKSkpHDhwgJB6dR2uK0KoAlYlN2FjzbYuMi/xk92Cmv16bnnyEbbNmjbh999+IzAwkBEjRtC1Sxd69erF8OHDefmll+jVsyfdu3Vj+PDhHD9+nNcnTmTxokW0bNE8Z3vZX2cnez4guFJFfl22lAsXLtCzRw91D8as2/PkJ1izWk0zMjL49ptv6NK5MwMHDmTmzJl8//33dOvaleeHDePq1as59r/NWkduEZGF1cLw4cPp17cvtWvVyjdKcF73wP4ZaJD52bBvmSWRPIrY4zVERUURKGz7p55OExQvXtwh3+bNm2nSpAlvvPEGEydOdAhamBcGg4FixYqpng0dO3ZkyZIlanqjRo3YvHmzgzeCTqfDarXi6+uLrrbNgzDYYJHfI8l/hubNm/Pyyy8XOK/9+2XfK7kgzJ8/Xy1X0Lby445Eq8lkctjz6pVXXnGY+M+fP5+vVah48eJMmDCBiIiIu+jqvTF58uQcLluVKlVS01NTUxkxYgTe3t64urrSvXv3fAW45N+N2WxGp9Nx6tQpgoKC2Lx5M97e3g55EhISMJlM7N+/H6PRSEhIyB274BUtWpS2bduydu1aOnfuzLFjxzCZTFSqVCnHF7948eJUrFiRPXv2ULRoUfR6PStXrrzXoUr+xezbt4+MjAwa1K2dq3DLIV5zEXC5CtfbicG7sLRmf61RoHvXLvz4ww+sWLGCnxYuZOYnnzBt2jQWLVrE8uXLWfjjj4weOYIypQPzF9Tc2os2+5GjTOZfg8HAuDGv8Nlnn/HDDz/QtUsXfvj+e3UP5Pz2orUTGRlJt27d0Ol0LF26lMWLFjFzxse8/97/+O233xg1ahQDBw4kIiIiV5fh7G7GGsXWv1EjR9KqVSu6dH6q4ILVXme299y3qA9ly5RWlxY8Ksg5V5KVhIQE3NzcOHXqFJ7JNwE4q3Fy8FpKT08nIyODs2fPcvPmTVq1anXH7QQFBVG7dm0OHDhAx44dOXjwIFqtloYNG7JlyxaHvBUrVqRMmTJEal0A8NVYWbVq1d0PUiL5F7F8+XKmTp1a4PxDhw4lOjqaqlWrqtfOnTtHhw4dcHZ2xtfXV92Oys7TTz9NdHQ0oaGhhdLnOxKttWrVYsWKFXmmL1++nFq1auWZPmLECJYuXUpwcDBNmjRh/vz5D3S/pCpVqhAdHa0eW7duVdNeeeUVVq5cyS+//MKmTZu4dOlSjvWNkscDi8WiBoHZv38/NWvW5Mcff6RuXUdr1saNG2nevDlLlixhxIgRwK2Jt6BUq1aNCxcuMHfuXGbNmsWkSZMA27YjU6dOdfA+CAkJwcnJie3bt6tBcebPny83Pf8PExYWhl6vp2rlWz/2c7Ny5ipes/7NLlyzpmWvM7d1o2o7txGM2V9nqVuv0+Lh7kZRH+8ce5DmOq7cxJx9LPYjS59yjDvzdfEAfz75+CMWLlyITqfjpZdeonu3bvzv3XfZuGFDrt+v5ORkvv3mG8aNHcuXX37JoEGDbGtrs/W3WtUqzPvuO8aMGcPu3bvz3GfWLoavXbvGgAEDaNSoEX2e7pXj3qrjyz4WNU8uD82Eldo1qt/R0+8HhZxzJdnZtWsXxqTM9e6lyjuk7dixg9DQUJYtW8YLL9hc5a1W6x0Fz6lWrRpRUVF8+eWXfPfdd7z55psADB48mPfff5/09HQ1b0hICBqNhq3nrwLgLTL4Z9kvxMTE3NMYJZKHSdbPeH54eXnd0e9ZZ2dn/Pz81OU9FouFDh06kJ6ezvbt21mwYAHz58/nrbfeUss4OTnh5+d32/1XC8odidYXX3yRmTNn8sUXX2DNsl+cxWJh1qxZzJo1i+HDh+dZftKkSZw6dYp169YRFBTEyJEj8ff3Z+jQoezatevuR1FAdDodfn5+6mF3bY6Li+Pbb79lxowZtGzZkjp16jBv3jy2b9/Ozp0773u/JA8Wu2uwxWIhIyODq1evEhkZScuWLdU8Qghmz55Nz5492bx5s2qduX79uoOL/O2oVq0ahw4dAqBUqVIIIbh58ybBwcF0796dMWPGqHlDQkKIjY1l/fr1fPXVV1SoUIEyZcrw+uuvF9LIJY86ERERzJ49m4ULF5Kamsrx48cpF1Qmp2Cyk4t4dUjL+jcv4VpAK6qSS74CieD8uJ1LcvY2rNnqs+aSL4+6XJyd6NunNz8smM+iRYto3aYNB8PDGTFiBN26dqVnjx4MHjyYwYMH069vX/R6PUuXLqVUyZL5Cnl/v2L8/NNPTJkyhaioqFwttxaLhRUrVjBw4EBeHTeOZ/r1dXh/7kqwZhlbpQrlOX78OGB72Pb555+zYcMGhyfeDwM550oAYmNjKVKkCEIIkmOuYY2LBaBK6/YO+T777DP69OnDP//8o865N27coEiRIgVuK+uc6+vri6enJ5cuXSIwMJAXXniB4cOHqx5TISEhXLx4kR1h4aS52Na/tggKYNy4cfc8ZsmjjRACS0rSQznu1GOvefPmjBw5kpEjR+Lh4YGPjw+TJk1S6yldujRTp05lwIABuLu7M2zYMMC233GVKlUwGo2ULl2ajz/+OEe9WV12v/zyS8qXL4/JZKJYsWIOO2Pkxj///MPRo0f58ccfqVmzJu3bt2fq1Kl88cUXBRbOd8odBWKy/8geNWoUr7/+uhqAKSoqisTERMaMGXPbQYLtRjVv3pwvvviCRYsWMX/+fEJDQwkODmbIkCEOP+QLk5MnTxIQEIDJZCI0NJT33nuPUqVKqS54rVu3VvNWqlSJUqVKsWPHDho0aJBnnWlpaaSlpann8fHx96XvksIjMjKSsmXLEh4eTuXKlRkxYgR169alYsWKap7FixcTGhqKs7MzMTExzJ07V41ieKeidfHixQDcvHmTihUr8vvvvzNgwAD69u3LgQMHWL58Od26daNy5cpEREQwePBgpk6dSq9evQgPD+fgwYPMmTOH559/vtDvheTRQAhBjx49WL58OVqtFovFwqZNm4iMPEWl8uWyZMwmnnLZ9sYhWJOwOmx3g9UKGo0qkkT28nmQQ7Bm1mNPc6gnt6BOt70BtxHE2cXq7fqS5X441J95btDrCKlX99ZaYUWD1WolISGBjIwMx0Ast7MoKxrc3VyZPXs2Q4cO5dtvv8Xf3x+r1Up4eDjr1q5lw8aNtG7dmmW/LLEtobkXwZrLvapUoRxXr15l+fLldO/eXf0MBQQEsGPHjocWoEnOuRK4NedGRUVRo5gXxECywYnyNW555v3xxx8EBQVRokQJoqOjmTt3Lh06dLjjObdKlSrMyAx6lpSURPny5Vm2bBmjRo2iU6dOhIWFsWDBAgYNGkSpUqW4cOECr7zyCuGvD6aeERq5KPwQFcXMmTMLZQ2e5NHEmppMWJOSD6XtmlvOo3VyuaMyCxYsYMiQIezevZu9e/cybNgwSpUqxdChQwH46KOPeOutt3j77bcB29KiXr16MXnyZJ5++mm2b9/Oiy++iLe3N4MGDcpR/969exk9ejQ//PADDRs2JDY2Noc7fXZ27NhBtWrVHGK9tG3bluHDh3PkyJF8PW/vljvesOj9999n+/btDBo0CH9/f/z9/Rk0aBDbtm3jww8/vKO6XF1dee6559i6dSsrV67k8uXLvPrqq3fapQIREhLC/PnzWb16NV999RWnT5+mSZMmJCQkcPnyZQwGA56eng5lihUrxuXLl/Ot97333sPDw0M9SpZ8OF8CScGxT6AbNmzg7NmzDB8+nNTUVEqXLg3Azp07WbRoEePHj2fHjh0YDAZiYmJITb3zyIJZP0MrVqxg4cKF/PDDD2r6tGnT+O677wBUl+Wnn36atWvXUr58eYQQXLlyhenTpzt4N0geL3788UeWL1/OnDlziI+P57PPPuObb74hPPwQlSqUzbtgPmtPVaGTh8XVluf2n6lcXXPzy5Ofq3Fufc+WJ4frsTWfurOOKS934YJYgIUVjQIe7m74eHsV3FKchZLFA5j+3ntMmjSJXj170qtnT35bsYK6deuy8rcVjHn5pfsiWBFWKpazfUbGjBlDkyZNSE9PZ/fu3SiKwogRIx7KdjhyzpXYyTrnGq9dBCBV76TOueHh4XzxxRe888477N+/X50L4+Pj73jOdXV1JTExEYC///6bOXPmqA+OAV5//XV+/vlnwLY1lclkomXLlrQcPwWAoOTr3LhxI4crsUTyMClZsiSffPIJFStWpF+/fowaNYpPPvlETW/ZsiVjx45V9y6fMWMGrVq1YtKkSVSoUIFBgwYxcuTIPHXauXPncHFxoWPHjgQGBlKrVi1Gjx6db58uX76cIzip/fx2/8fvljuytNpp0KBBvk9CC0pycjJLlixh3rx5bN26lbJly9430dq+/S03lOrVqxMSEkJgYCBLlizBycnpruudOHGig2U4Pj5eTqKPOJGRkYSEhPDpp5+iKApPPvkkc+bMoWjRolitViZNmsQvv/yCwWBg3bp1+Pv706ZNG9avX8+FCxcICAgocFv2ACRWq5U1a9bw22+/0blzZ9XlyWg04urqSkxMDN7e3lSuXJmjR49SvXp1du7cybp16yhXrhzu7u6EhYVRu3bt+3hnJA+D69evM2bMGPr06aO69QwfPpw5c+Zw5MgRypYunbtYyWrRzGrhzPJaESJfi6stTwGFWW6uuVnWmjlYXLNyp8I4r/byqifr2HMZl4PlFXJaX7Nfz4sCtF+zRnW++/bb/PNmryu3bW3sXcpPsGY5LxdUGrD98Pjtt9/QaDTUq1ePWbNm0a1bN5YtW1YgL6jCRM65EjuRkZE0b96cyZMn0y3RFmzrEgYalyiBEIKJEycyb948nJ2d2bhxI15eXnTu3Jk///wTIEeE4dthMplISUnh77//ZuXKlXTt2pULFy5QokQJtFotJUqU4Ny5c5QqVUoN2tTgqd6EffoGHtZ06lvjOVg8gO3bt9O8efPCvh2SRwCNyZmaW84/tLbvlAYNGjgELQsNDeXjjz9W46Jkj8ly7NgxOnd23AO5UaNGzJw50yGui502bdoQGBhIUFAQ7dq1o127dnTt2vWR23LxjiytH3zwASkpKer5tm3bHNx0EhISePHFF29bz/bt23nuuefw9/dnxIgRlC5dmg0bNhAREcGECRPupEt3jaenJxUqVODUqVP4+fmRnp7OzZs3HfJcuXIFPz+/fOsxGo24u7s7HJJHm6ioKHbv3k1oaCg1atRAURSEEGg0GpYsWUKHDh1UC8DWrVtp3rw5oaGh7N69m/DwcKpVq3ZH7ZUpU4bIyEhiY2OpWbMmnp6eLF26VE1v3749q1fb9ssMCQlh9+7dXLx4kfPnz+Pk5ETlypXRarX8/fffhXYPJI8OixYt4ubNmw5PTXU6nbqW+XpsbO4F81sLmtf616x/87Ca5kpe+bJdzzNQUy7kmi9bkCW1v7ezluZjDc41aFQe1tZ8j9zy5tZ+fvVmSVeENXfBqqYXTLCCba9KRVEICQmhRo0a6vWuXbvSunVrPv30Ux42cs797xIZGUlERAS1a9cmUG/77J7TOuHk5MRff/1FSEiIaqFZs2YNoaGh9zTnBgcHc+zYMc6cOUPt2rXx9fXlp59+UtM7duyoRgm2z7nxFsE1jW0v9eGmeJ7VxvL36r9yrV/y70dRFLROLg/lyCo+CwsXlztzN86Om5sb+/fv5+eff8bf35+33nqLGjVq5PgfnRU/P78cEd/t57f7P3633JFonThxokOkxfbt23Px4kX1PDk5mTlz5uRZ/oMPPiA4OJjGjRtz6NAhPvzwQy5fvsyCBQto2rTpXXT/7klMTCQyMhJ/f3/q1KmDXq9n3bp1avqJEyc4d+5coYVpljw6xMfHs3jxYgwGA507d3Zwnfvxxx/VNQKpqanEx8cTGhqqBnc4c+aM6tJUUKpVq8Ybb7xBs2bNAGjdujXffvstUVFRADz55JOqaG3QoAFr165l4cKFvPjii7Rt25bY2Fi8vb3Ztm1bIYxe8iii0+lyuNnY1yG2a9ns7gRUbuInex7IXShmT8uPfNLz2qYm1zWyuVlWbyPW8hTtudSZZ9TjO3UFzk+s5id2s5w7CNZc6s5TsOZRp9Ggp2yZ0lSvXj1Hlf7+/vflR9KdIufc/y6XLl3i+++/p2jRoviIDAAu620/sr/77js1Or/FYuHKlSs0atSI8uXLc/LkSY4dO0ZwcPAdtVetWjWmT5+ueiZ16tSJZcuWcfToUcBmVbJ/9urVq8fGjRtZsmQJGT2e57qzLehTiCUOzY5/7n3wEkkhkD1Y7c6dOylfvnwOi6md4ODgHL8Zt23bRoUKFfIso9PpaN26NR988AHh4eGcOXOG9evX59mn0NBQDh06xNWrV9Vra9aswd3dncqVKxd0aHfEHYnW7Oti7nSdzIcffki7du0IDw9n165dDBs2zCHc8rVr19S1BoXNuHHj2LRpE2fOnGH79u107doVrVZLnz598PDwUANAbdiwgX379vHss88SGhpaKG7QkkcHIQTHjh1j+vTpHD58mDp16hATE4OPjw8nT57E399ffWK1e/du1c3O2dmZ5ORk1d33TmjQoAEuLi6q63uHDh1o3LgxI0eO5OOPP8bHx4fr168jhCAgIAAfHx8WLlxI69atCQ4OJjExkQoVKpCUlCTX2DyGmEwmUlNTc/w/ta8J8Svmm7PQ7QRdXsI1P4sgOArYvETV7coVlPysqrcT5vmlZa8jl3byFM+3s7bmZ8HOr29ZxGqubWb5m69gzafdksUDcn0qnpqaislkyruP9wk550rsRERE8PbbbxNxOBxtim29abxzES5duoTBYFD3SD98+DBarZb69euj1WqxWq2kp6ff8XYZ9erVQ6PR8M477wC2B8N169ZlwoQJTJ06FWdnZ1JSUrBYLHh4eFCtWjU++eQT2owaT0TPl1mj8QKgVup1ueWc5JHg3LlzjBkzhhMnTvDzzz8za9YsXnrppTzzjx07lnXr1jF16lQiIiJYsGABn3/+eZ6RsVetWsVnn31GWFgYZ8+e5fvvv8dqtToEKM3OE088QeXKlenfvz8HDx7k77//5s0332TEiBEYjcZ7HnNu3NWa1rvl0qVL6PV6pkyZwvLly3OkR0ZGsnz5cvr06VPobV+4cIE+ffoQExND0aJFady4MTt37lSj0n3yySdoNBq6d+9OWloabdu25csvvyz0fkgeLrt27UKv11O3bl2SkpJwcXHhxIkTlCpVikWLFtG/f3817+bNm3F2dlZdhX18fO7KFa1atWrMmzdPPW/WrBnvv/8+33//PYsXL+b111+nTJkynD59mqCgIP73v/+xYcMGdDodwcHB/PPPPwQGBnL+/Hn2798vf9Q9ZtgFRXp6usM/enuwmiLurjmj/dqxC5fcovfaX2f+zbG+Nbfy+ZFdQOVV5m4Cht2BGMwq6kTWB0i5jSX7NXvfsq3FvVXfHccmzLevubWRQ6Rn+VsgwZqHePXz9eFiLsEvHpZolXOuBGwRpNPS0mjevDm/vGvbM1Up4oNP6SB++eUX+vbtq+bdvHkzOp2OEiVKALalNXFxcXfcZlBQEIsWLVLP69Spw5QpU/j8889Zu3Yto0ePpnr16oSHh1OrVi3efPNNatWqhZOTE8HBwcw3edMmOZaSlmR2bNnCE08+eY93QSK5NwYMGEBKSor6QOell15SY2DkRu3atVmyZAlvvfUWU6dOxd/fnylTpuQaORhsyzeWL1/O5MmTSU1NpXz58vz8889UqVIlzza0Wi2rVq1i+PDhhIaG4uLiwsCBA5kyZcq9DjdPHqho1ev1APz6668O1y0WC+fPnyc+Pp5p06bdl7az/gPLDZPJxBdffMEXX3xxX9qXPBp89NFHdOjQweGHnD0gw4oVKxzWVG/btk3d1gls/wQKY1G6Vqvlvffeo3fv3kyaNIl169bRsWNHNm3aRFBQEO7u7uoC+kqVKqEoCs7OzhiNRjZv3ixF62OG/XOYmprqIFoTExNxd3N1sOznKbByE6tZX+cnXO357pSsZQpT7OVyLVcXZ/IQsLn1Ky/xCnkK2Fv13t3YbhtcqiCCtSDW9Ezc3NxIjDqXo8nU1NQcUXofBHLOlYDNw65FixZYrVaC0m3bE6UH2rY32rJlC0OGDFHzbty4keLFi6v/82rXrk1MTMw990FRFD744AP69+/Pa6+9xvXr16lfvz6bNm1Sxao9UFlwcDDnhQGLzoDOnM6Rlb9I0Sp56Oj1embOnMlXX32VI+3MmTO5lunevTvdu3fPs860tDRcXV0BaNy4MRs3brzjfgUGBqoB0x4Edyxav/nmG3WQZrOZ+fPnq+HIC+pGceDAgRzXzGYzL7/8MkeOHLnTLkkkBSYiIoIePXpw/PhxdZ3MuXPnCAoKQqfTqQ9WMjIyiI2NpUOHDmrZTp06odHc5Y/zbNSuXZuVK1fyzDPP0LJlSyIjIzl9+jTPPvusQ75y5cqp+xLGxf2fvbOOs6Lq//h7buy9211s0N3diAhIgyIqAtINEgooICVIiDSIlLQg0t3d3SxssCzLdsftO78/Ljvusq2oz/P89uPryt6ZE99zZu6c+ZxvJbF//3769euHWq2WfodF+O9GZtLq6OgoHddqtahVqly1mrnmWs0cJTgHZCGuGeX/KnIiaIWNJFwIspoTsuSnfbPNvDTLuRDYP9r9E4T+TeREVjP9nS9hzcc0WBDNWKus0Gq12br+tzStRSgCWPJFDhgwgOfPn1PdbHlHjHbyxsfHB41GI61joigSHh5Op06dpLqtW7eW0tf8VVSoUIHDhw/Tr18/mjZtys2bNwkODs6Wi7VYsWIYTCYSXH1wiwpBduscERER2NnZZXFnK0IR/luh0+m4f/8+Dx8+zDetTWasWLGCNWvWSPlZC4ItW7YwePBgNBoNNWrU+JMS/4FCkVZ/f39Wr14tfffy8sqSczKjzJ8SRKFg9OjROQaSKEIR3gZCQ0NRKpWULl2a+/fvU6VKFcCyS+Xo6JglAMjt27dJTU3NQlrXrVvHmTNnOH78ODY2NtJucFpamqQNLQzs7OzYsGEDn376KWazGW9vb54+fUq5cuWkMlZWVqjVaoKCgpDJZMyfP5++ffsSGxvLwYMHcXFx+StTUoT/AGQmrZkhkVbITlqErNrBXFPNZCawmYisRFwzt/02yOub/f+JcrkS1bzayzIfeWhfc0p3kxuBhRxJbKGQV9qeP0NYcyCrGVCpVGh1RaS1CP85iIuLw2w2U7ZsWR7cvEExrUXT+lSwxkOrpWbNmlLZp0+fkpycnIW0bt68me3bt3P69GkcHR2lNTfDH7WwG7c2NjasW7eOTp06IZPJKFu2LLdu3cqSSk4QBOzs7LijtKYl0NhZzZAhQ4iMjGT37t2FSnlXhCL8J+Lw4cN8/vnndOrUqcCp0LZs2SJljykMz+vUqRP169cHeCsWP4VakZ8/f05ISEi+nz+L0NBQSpYs+afrF6EIeeHkyZOIokj16tV5+PChFN3s+fPnBAYGZolgvXLlSipXrpzlfrx9+zaDBw+mb9++jBw5EoA7d+7QsWNHunXr9qeCJDk6OlKmTBns7Oz47LPP+Pzzz/niiy9ISEiQylhbW/PkyRMaNWpEeno6+/fvZ9GiRVJKlCL8dyMv0pprMIMcyEtcfAKde/Rj2aq12ctl+vdVRCQdunXnl42bs7eZx2f1ul/o9NEnlpD2eQUmygWXrlyldccPuHDpSq71c410nKncnAWL+ahXP1JT03KW/Y32spFC0Uxqaiof9+zNnPkL8x5HHoGpxn8zid79B0l58nKs80a/T58F0qZzV3bv3Zd9vJmu0b0Hj3j/g084fPxE9vPS2LJ+v3P/AcHB2dffItJahH8Lp0+fBixpZVIPbEUQRRTObtyPiicsLCzLmrtq1Sr8/PykzWSwpEf85ptvGDRoEJ9//jmiKPL06VPatWvHBx98QHp6eqFlsrGxoX79+ri4uNChQweGDRvGkCFDiImJkcqoVCoup1h+10JsBL+vXcXatWuZMGHCn52KIhThT+PMmTMsWrTorbXXpUsXkpOT2bx5s2RdmB98fHwoU6YMZcqUKVRgNHt7e6lehlXuX0GhSGu7du2yOMXPmTMnS7TCuLi4AoU5XrJkSbbPpEmT6NmzJ40bN85yvAhFeFs4cuQI5cqVw8rKiqCgIMqUKQNYAuA8efJE0vJfvXqVAwcOZEnflJCQgKOjI7Vr1+bKlSskJCQwffp0fvvtN3788UcGDRpEnz59cjTPyw+DBw9Gp9Px5MkTrly5Qvfu3bOYCdvZ2eHv70/p0qU5fvw4YHkJePnyJQaD4a9MSRH+A5BBKDLnwAaLr79MJuQe2OgNshX28iU6nZ4zFy7nSSaDX28snjp7vlDmt6fOnMNsFnke+obfZD5kN+Nz/cZNrNUqrl2/nq3tbOQyh/Fl4PzlqyQkJBIdG5uzoAUgr9ExMcTFJ3Dh8uWcx5EbMhHSa9dvEBwcTFpKav4Rl1/jwcOHqKyUnLt4KU8N6537D1CprLh45Xq2NnKLQHz3weMcRc5z86MIRfgbcezYMby8vLA2GSj+xPJb8+oziviEBAIDAyVzwfv377Np0ybWrVsn1dVoNMhkMpo0acKFCxewt7dn9OjRUrCYCRMm0LNnzz9lPjxw4ECSkpK4efMmV65cYdCgQVmCMHp6euJXqSo6r+IAJJzcR5UqVUhLS3tr5spFKEIRCo9CmQcfOXIEnU4nff/+++/5+OOPJZWv0WgkICAg33YWLlyY43G1Ws3x48elF3NBEAplb12EIuSFu3fv8uOPPwKWBdHGxkZKM5Keni6Z93777be0aNECZ2dLvjaj0cixY8dwcnJi+fLlODk5cefOHfbs2UOzZs2YOXMmNWvWRK1W8+GHH1KlShVmzZol7WBdvnyZX3/9NddNmCpVqqDRaNi7dy/Dhg2jYcOGeHh48OTJEypUqICfnx8NGzbk4sWL3Lt3D7PZjEwmo1GjRly6dEnK/1qE/05kbHS8uXupVqvRZWjv8/K7fG32W7NqZebPmISfr0+W42/+26RhfWbZfUPpUqWBXHxBc8CqZYsJCQ2lWpXcownmhRFDBtK4YX1qVKuapd9syCc408aVS4mOjaVUcb+8g0HlYPacYRZdqkRxli+Yh7u7W87+vwUIMrV1wzo0Wi0ODrn4ueVALD/o1IHi/n5UqVA+e7lM5Xt+/CGVypelWqXy2Qhrbu336/ExW3btzyaGSqXKsm4XoQj/FC5evMiUYQN50u991CYDcgcn3D/qD9uOEB0djYeHJZ3XlClTqFevHj4+lmeXyWTi9OnTuLu7M2vWLBwdHbl9+za3b9+mVatWjBkzBpVKhZWVFZ9++imlSpVi3rx50gbgvXv3WLRoURYSnBklSpRAFEVOnjzJV199Ra1atahSpQrXr1+nbt26+Pv7U6lSJW4+v0MjIPyn73Ht9BktWrTg9OnTdOzY8R+ZvyK8fRQ2VWcR/hkU9Lr8JYedP3vxC2JiHBISQnBw8F8RrwhFkLB06VIMBgNt2rRBFEXJNyY2NhZHR0cpN+vDhw9JT0/nk08+ASyE9ZNPPmHMmDFERUWxbds2rKysePbsGXq9nvv379OjRw8+++wzfH19OXToENWrV2fy5MlS3+vXr+fly5ccO5Z7ovImTZpQt25dPv74Y7788kuGDBnCypUrAYv/gIODA4mJiXh7e0vttG3b9h+N2laEvwexrzWGGalAMqBSqdBpcyAbeWjzqlYsj5N9Hn5er8tVr1oFO1vrLKcytJE5fQDs7e3+NGEFS9TsujVroJTLC2QGnNsxVxdnKpYrm3v9fNrIGFOF8uVwzfAJz0vL+qbW+DWKeXtT+k13lrxkwLIRW6dG9T/MdXPxYZXJZNSpUVXayMimXX2zfbMZnVaLWpXdDDgjD3QRivBPYtOmTZiSE6mwbyW6F0Ekyawot+ogetESCVWhsOhMnj9/TlRUFN26dQPAbDbTu3dvSRu6detW7OzsuHXrFkajkWvXrtG/f38++eQT7OzsOHDgAC1btmTs2LFS35s3byYxMZGdO3fmKl+rVq1o0KABH3/8McOHD2fgwIGSdZWfnx+CIBBUvBrpcivMqUlErJpbtOb+FyNDifBnTMqL8Pcj47rkZ678j6a8KUIR/g2EhYXx22+/0adPHxQKBeHh4Xh7ewOWDRRbW1spL9zGjRsRRZEmTZrwxRdfcPToUYoXL07t2rU5ffo09erV4+HDh7i4uJCQkMBHH33E5MmT0Wq19OnThxUrVtCjRw9WrFhB27ZtadeuHc+fP2fLli2MGTOG1q1b5yjjRx99xIIFC3jnnXeYMWMGer2ewMBA0tLS8PPz4+XLl6xatUrKZdimTRtq1KiRJUVPEf47ERMTgyAI2YJqqdVqtLlpyHLIN5qrxjCvaMK5HX8DhTEjLjTy0az+6TZzm4vXyFXDnF9gqsLIlpfPbl7jLqB2NfMGhlanz9F31d3dvYi0FuEfRUxMDCtXruSrBpUwhtxE4enDFuvStChTkYCAABwdHXF1dQUsAV5kMhmtW7dm/PjxHDhwAC8vL6pVq8bx48epXbs2wcHB2NnZkZaWRps2bZg3bx5gyV05b948OnXqxOLFi2nXrh3vvPMOt2/fZu/evfTq1SvXlB9du3Zl/PjxdOzYkW+++YaUlBSSk5NJSEjAz8+PBw8e8OPiJUxqeY1uKUFEb19Ntb5jCQoKyrLxXYT/DsjlcpycnIiOjgbIEkyzCP8eRFEkPT2d6OhonJyckMvleZYvFGkVBCHbRS666EX4T8e0adNo1qwZderUASAwMJCyZS2amuDgYEwmkxS++9KlSwiCQPfu3Rk6dChBQUGMGzcOjUZDpUqV6Nq1K61bt8bDw4PExERevnzJ5s2bGTVqFJs2baJHjx6MGjWKxMREOnTowOrVq+nduzdubm555purWrUqXl5erF+/nsDAQCpUqMAPP/zAli1bKFeuHGfOnKFfv34sWLCATp06odFosLa2xsfHh5cvX0qkuwj/fYiNjcXFxSXbw9ra2pp0jTZvYmk250hcc40onKlMlu/w9qMH54fCktW8zuWVXiefseZLXnNrPz8UlLDmpG2V6uRyLoeoxOnp6TmSVjc3N549e1ZgsYtQhL+KmTNn0rJlS6qc3wKAsUl7iqVbNCjBwcHIZDJpzT19+jRGo5GePXsyZMgQbt++zdSpU9Hr9ezYsYMvvviCpk2bWtwldDpevXrFunXrmDBhAlu3buXjjz9mxIgRxMbG8v7777Nz505at26NjY0NWq1Wcqd5EyVKlKBWrVosWLCAgIAAKlasyOrVq1m7di3vvfced+7cQS6X0/enTQR3b4yHXkfUpmVUrFgxS8q8Ivz3wMvLC0AirkX4z4GTk5N0ffJCoUirKIr06dNHCuqg1WoZMmSIZFpZ5DdThP80REVFkZSUhNFolEjrs2fPJNIaFBREQkICNWrU4NWrVzx58oSuXbuydOlSevTowYwZM6hduzazZ8+mXbt21KhRA41GQ3JyMgqFgmPHjlGnTh369evHsmXLWLduHQcOHGDXrl2MHDkSg8EgkRFfX1/CwsLw8/PLUdZZs2YxcuRIyZf2ww8/ZMyYMezatYu7d+/y9ddfU6NGDby9vdm4cSODBw+mbdu2HDlyhAEDBvwDs1mEvwMxMTE5RtVzd3cnJTUVrVaHWp0pkM6bBConrWtm5KRtzYvQ5dbPX8WfIaQF1WoW0re1UOQ1v/ZzK5cJhSKsGabEOZ3LI4VOTHwCHp6e2fouMg8uwj+JpKQkgoKCqO7pjDI5HmRyQoqVowyWdTAoKIjU1FRq1KhBUlIS9+/fp0WLFmzcuJFBgwbx7bff0qRJE5YvX067du2oUKEC6enpmM1mFAoFly5dom3btnz22Wf8/PPPbNq0iV27dvHrr78yYcIE0tPTpTU3g2DmFiB0woQJ9OrVC1dXV+RyOc2bN+fo0aOcOnWK69evExgYSPkKFdho58uHmjASTuym3eBZHD58uIi0/hdCEAS8vb3x8PAoCmL5HwSlUpmvhjUDhXor6d27Nx4eHjg6OuLo6EjPnj0pVqyY9N3Dw4PPP//8TwldhCL8Hfjpp58YNGgQUVFRUtCHgIAAypUrx9xDizkYcJy0tDRKlCjBjBkzkMvlLF68mIkTJ9KqVStq164NWIIpNWzYECsrK4xGIwaDAVEUEUWRr7/+mooVK/Luu+8yePBgKleuTPny5Rk3bhzDhw9n//79aLVaGjduzMWLF3OVVSaTSTngnJycePLkCatXr+bw4cOULVtWSnEza9YsKZhZq1atinxs/ssRGxubzZ8V/tgVjnqTcOTme2nOSnKyRZjNdC7X7zn1k19E3ZzK5vTJq15BjxcEebVZgLJv+vLmWqcAY8wx5U5+8lAAwpqDn25UTGyOO9Xu7u7ExMQUBSApwj+CtWvX0qdPH6yf3QXAplxlHr8Ip1y5cgQFBXHs2DGSk5OpVKkS8+bNw2w2s2rVKubMmUOVKlWkNDinT5+mefPmCIIgEYyMdXfs2LE0a9aMVq1a0adPH0qVKkWlSpX45ptv6N27N5cvXyY5OZnGjRtz4cKFXGUVBEEK/uTt7c2FCxdYsWIFhw4dolKlStKa23XOMvQi6MJCqO/jzsmTJ//OKSzC3wy5XI5arS76/Id8CkpYoZCa1l9++aXQN0cRivBv4dWrV1y/fp2ePXtSunRp6XhAQABlypRh4y99SVWkYK9Vcv/+fQ4cOED16tXp06cPRqNRyosqiiJKpVIKiiKKIh06dGDfvn2kpaUxcuRIBEHg008/5caNG3z//feEhISwbNkyatWqRc+ePWnZsiU9evTg6NGjfPrpp/nKXrFiRQ4fPkydOnWkhTU6Oprk5GTee+89EhISiImJwd3dHX9/f44dO5arv2wR/rORm6ZVIq3RsRTPiAicGYUx631Ty/pnzIP/qp9pQdr6O/ooyFhzOV7QyMo5IccUPnn9nRthfZOs5tJHbqTVzc0NnU5HWloadnZ5BOkqQhH+IuLj4zl8+DAbN27EarElj7JDo1bcP3OX0aNH8/HHH3P79m1cXFwICQlh8+bNlC9fnrFjxxIZGUnv3r1JSUlBrVaj0Wiwt7dE5hZFkaZNm3Lx4kWSk5MZOXIkWq2W3r17c+rUKZYsWUJcXBxLliyhZMmSDB06lJYtW9K7d29OnDjBoEGD8pW9Ro0aHDt2jPbt2wNQtmxZYmJiiI6OplbjpizVymhkbSb58HZq1arFzp07c/WXLUIRivD34B92YipCEf45fP3118ycOZMzZ87w7rvvApbFz2QysXbHL7irXGngXBOFv5qlS5eiVqu5ffs2cXFxfP7550RERNC5c2dmzJjBO++8Q0xMDC9fvgSgevXq+Pv74+TkRHp6OtOmTaNjx46UK1cOOzs7RowYQVJSEjt27ODZs2cYDAYCAwMJCgoiKCgoX9kbNWqUZYe4efPmlC5dmn379iEIArVr15aSTc+aNYt169bRo0ePtz+JRfjbkZ+mNTIqOn/NXwYKom19s07mY39Fw5kf8mr/r2pz86tX0P7yMO8tSDCqXLW0BSSs2ZALYX2zD9FsIjI6d00rUGQiXIS/HZMnT2bKlClcOH8OT7MllZdTs/dJS0vj4sWLFC9enE6dOuHg4MCcOXOwsbHh6dOnPHnyhAEDBpCQkECXLl2YOXMmDRo0ICEhgZcvXyKKIhUrVsTX1xc3NzfCw8P54YcfpAjAVlZWDBkyhJSUFA4dOsTTp09JT08nKiqKyMhI7t69m6/szZo149q1a9L39957D39/f37//XcA4kpVAyD+yO9MnjSJvXv38sEHH/wNs1iEIhQhNxSR1iL8T2LPnj34+PhQo0YN9uzZI5HWsWPHcu/ePZbvX03c7UhcTU6UrF+W7777jhcvXtCoUSOOHj1Kx44dGTZsGGvWrEGv11O8eHEmT55M165dEQSBX375hTp16uDl5cXGjRspXrw49evX5+jRo8TExODo6Ei1atVIS0vj1q1btGvXjlatWiEIAv369ZMCTeSGRo0aERwcjCiKJCcns2PHDiIiIti8eTOiKDJkyBApnL+trS3btm1DJpMVBRj4L0RumlY3NzdsbGwIfvFSOpYreSoI0czJNLiwZrsFRWGIZUFNlAvaX17nC9J3Hu3klRaoQGl88iGsuQZekjYhcjA3Fs28jIjEYDBQvHjxbCJk3FsxMTE5jqkIRXgbOHXqFDKZjKZNm3J+8zoUOg0yWzsW7jzIrVu3mDZtGrdu3UKtVjNo0CCWLFlCcHAwVapU4cyZM3Tu3JmBAweyadMmDAYDJUqUYNasWZI28/jx45QtW5bixYuzb98+fH19adCgAb/99huJiYk4OTlRtmxZtFotR48epV+/flStakkbNXLkSL7++ms0Gk2u8teuXZuoqChMJhN6vZ5169YRFBTEzp07MZlMvDdmEnoRTMmJ6B7eZOPGjXh5eRVoE7oIRSjC20ERaS3C/yR+/vlnpk6dyp49e6hduzaurq4YjUbWrl2LjY0NScpUStn5s2PLbyhslHT/rDuCILBt27YsEbH9/Pz4+eefGTNmDNHR0YwcORJRFKlduzZBQUG4uroyZMgQ6tati8Fg4Pbt25QpUwZ7e3uePXuG2WymY8eODBo0iG3btjF48GA+/fRTqlWrRocOHViyZAn9+/fn+PHjWeQvX748SqWShw8fcu7cOdzd3Xn58iXh4eGsXLmSJk2aoNfruX37tlSndevWeeaCLcJ/JnLTtMpkMsqXK8eTwOBs5/LU5uWlbS2slrOw5LUw5f8u0pxfuwUt/zaIe27fc/R/zcUsOBNhzU22gMAQgByDwxRpWovwT2Dx4sV8//33nDx5kobmJADsazXhx0WLLJtvwcF4eHiwfft2KleuTK9evQDYvXt3Fp+2YsWKsXz5ciZMmMCjR4+YO3cuZrOZBg0a8Pz5c2xtbRk+fDj16tXDbDZz//593NzccHd35/Hjx4iiSP369RkwYAC//fYbX3zxhZQKp2PHjixdupR+/fpx4MCBLPKXKVMGtVrN1atXuXr1Ks7OzsTGxhIdHc0PP/xA9Tp1uWOwRECO+W01AG3atOHo0aP/xPQWoQhFoChPaxH+BxEcHIyLiwu9e/fG2dmZ+fPnA5agTHZ2dnz11VdMuzKfHh0/w1pQ8+xuIHptMhUqVMiWMmLatGmoVCpevnzJggULuHv3LoIgEBoaSlRUFJMmTaJnz54cPXqU3377jVu3brFr1y70ej0NGjRAEATWrl1LREQEkZGRgCXpup+fH6IoEhkZyXfffUfv3r1p3LgxNjY2gOVF097enrFjxxIQEEDbtm3x8fGhcePG7Ny5k/3796NSqfjxxx/ZvHkzYCGt48aNo2fPnv/gbBfhr0Cj0ZCWlpajphWgQsWKBAQ9zbW+IIoF8rfMkgKnkH6d+Z7LfL4g+LNa18KisOP8M/OSW595Hc/h70IT1jf+fhwYhEqlokSJEtm6LtK0FuHvRlRUFAqFgmHDhmGlVDJSE4sZeGzvjZWVFZMmTWLYsGH069cPpVLJ7NmziYyMxNfXF0dHxyxtLV26FJlMRmxsLF27diUgIACZTMb9+/eleBKjR4/m4sWLLF++nKCgIE6fPk16ejoNGzbk+fPn7N69G61WS0pKCnq9ngMHDnDr1i0EQeD58+fMnDmTfv360aRJE5ycnABLijEXFxcmT55MaGgo9erVo1y5cjRu3Jjt27dz8eJFbAQH6hFH0oXjmA163n33Xfr168ewYcP++UkvQhH+H6JI01qE/3q8aRK7bds2nj59yrfffsvKlStRqVTMnTuX6dOnU7VqVWJiYrC3t+fu3bvMnz+fbwd9Q7QQz/Dhw7O1vWbNGt59913MZjMRsZGcuXAWtVpNUFAQ9evX5+TJkxgMBubNm8fixYv57bffaNq0KZUrV+bRo0eo1WrCwsIQBIGIiAgmTZrE48ePmT9/Pnv27OHp06cEBgYyYMAAVq1alaVvDw8PWrRoQYUKFYiJiaFNmzbY2dkhk8nYu3cvrVu35siRIzx69AgAT0/PPHPBFuE/Dxnar5w0rfA6ZUNgcJ7mrzkSmjdIj6VcHpq/N4/nd64wPqVv1itsn38VhdG65nc8v09udXJqOydNeA5ySNc3j7YCAkMoV7ZsjlEYVSoV9vb2RZrWIrw1REdHZ4lG/fvvvxMWFsbo0aOZ90FLzEnxmAUZX6zdSokSJdDr9ZQrV45bt25Ja9/z589zzDaxcOFCateujSiKxMbGcvLkSaysrAgODqZcuXJcvnwZs9nM9OnTWbZsGTt27KBZs2ZUqVKFR48eYWNjQ3h4OD4+PsTHxzNmzBju37/P7Nmz2b9/P9HR0dy7d49Ro0axZMmSLH37+PjQvHlzypcvj0wmo3Xr1qSnp2Nra2vREH/YgxQTiDoNyRdP4ODgkKfJcRGKUIS3iyLSWoT/akRGRlKpUiVCQkKkY7t27aJLly5UqVIFgGHDhuHl5YXBYGDnzp3sOrib8iXKMWvWLHx9fSkm80DwVvLZZ59lafvZs2ckJSURGxuLk5MTa85uJMAUgo2NDUuWLOGXX37BYDDQrVs3hg0bhp2dHWXLluXgwYPcvHmTXbt2Ua9ePRITE5kyZQrBwcGYTCa8vb3ZvHkztra2rF+/njlz5mBtbc2BAweyvAi4uroyd+5cXFxc6N69OykpKWzdupVGjRpx7NgxFi1ahLW1NR9//LFUTy6XYzKZ/oGZfzu4ceMGc+bM+X9LtjNIRm6+yJUrVyYuPoFXkZnO50CQChIkyFIuB+JaWPJWGBTEn/XvIqsF6efvNA0upHlwtg0H3iCsubUtmrkf8IxKlSvnKEpiYiJ6vb5QaQWKUITckJCQQK1atbh37550bPv27TRr2hTva0cInTkagOiK9YlPTefgwYPs2LGDXr16MXPmTEqXLk1cXBzJyckMHDgwS9uRkZFERkZiMplwcXFh+/btXLlyBWtra77//nu2bNmCk5MTXbt25bPPPsPFxQV/f3/27t3LzZs3OXbsGHXr1kWj0TB27FgCAwPR6XSUKlWKFStWoFarWb16NStXriQlJYVz585hNBql/n18fJg7dy5yuZw+ffoQGhrKgQMHaNasGXv37mXK1GmcMVoD8OrnOYgmE7a2tqSnp//9E/+W8ODBA2bNmkVUVNS/LUoRilBoFJHWIvxXY/LkyQwePJhz584BoNPpeP78OWPGjAEsxDNj0fLy8sLW1pZXqZE0qdpQauPYriMoXdTY2dlhMBh4+PAhv/76K/Xr10cul5OWloaXlxcx6XGIDgIqlYqSJUsiCAIzZ87km2++yTH0fZMmTVCr1ZhMJuRyOXq9nvj4eMms9+XLl9jZ2bFjxw6uX7/O8+fPadGihRStMCEhASsrKwRBoGPHjuzfv5+FCxdy7NgxZs2ahSAIXLx4keDgYEaMGIEoihQrVoxXr179AzOfFdOnT2fLli2FrtepUyemTZvG9OnTC1XPYDD8KaKbEdjqPwXFihXj3XffZe3atTmer1+/PgBXbuUQ/TI/spmDthXyyN/6NslbQeoVol1BNOf7KbBchT1eWNPnvAjpG3/nZxac79+iGb3ewM17D2nQoEGOIm3ZsgWj0cjHH39c8HEUoQi5YMaMGfTt21dac81mM48ePWJ4WXci1y0As4nnamdKjJ+Di4sLbm5uPHnyJItWdfv27SgUCooVK4bRaOTx48fs3LmTqlWrIpfLSU9Px8vLi5cvX5KcnIyVlZW05k6dOpUxY8bQp0+fbLLVqFEDJycnzGYzOp0OnU5HcnIyKpWKX375hcDAQNRqNdu3bycgIICXL1/SvHlzycUmLi4OW1tbTCYTLVq04MyZMyxevJiDBw8yb948SxDEXadIMYlonj0gfPU8SpYsmWXT/J/Cjz/+yM8//1zoeh988AHTp0/nq6++KlQ9k8n0p601/pPW3CL8d6OItP4LWLVqFVqt9t8W438CkZGRDB8+XFpA58yZQ82aNSXf0B9//JHx48fz888/06xZM+7du4fa05by3mV5FhtMYnoS237dhq3SmhNnT/L+++8zf/58xo0bh5eXF7Vq1aJRo0ZYW1tjtgErd2tkMhn+/v4AlChRQiIWOaFHjx4IgsCsWbMwGo0IgkBAQADJycmUKFGCgQMHIpPJ+O677zh16hReXl7s2bOHc+fOERcXh1qtJiEhAZVKxejRo1m8eDFLly4lJiaGWbNm4e/vz7Jly9i5cyc9evSgRIkS/8oCeuXKFXbu3MmzZ88KXOf58+dERkbSvn37bKbR+WH79u20atWq0L+jkyct1/g/CQMHDuTcuXMEBARkO+fj44O/vx9Xbt7OoSZvEKA8tK0FIa45lMv3eE7lCkJWC9BeYQlpgcu+TbPov2AeXCg/1jflzvT33YeP0en0NGzYkDchiiKrV6+mY8eOeHt75zy2/wf45ZdfSElJ+bfF+J/As2fP+Oqrr7h48SJgCXrYtKQP8b/8CMDt0vUoNm8TP69aTa1atST3GE9PT8ByT65du5ZixYpx69Ytac0dNWoULi4uVKtWjUqVKuHo6IjJZEKlUqFUKqU1t1ixYjRr1ixX+Xr37o1MJmPatGlotVoUCgW3b98mLS2N8uXL0717dwwGA99++y0XLlzAzc2Nc+fOcfjwYcLCwjCbzZjNZuRyOZMmTWLWrFnMnz8fk8nE+PHj8SpbHmOb7gBErvmBykrjv7Lmnj59mnPnzmUJxpgf4uPjCQoKomfPnmzbtq1Q/R08eJAmTZoU+nd09epVGjVqlMWKrAhF+LMoIq3/MK5cucKQIUP+sYhzEclRhMS/+Ef6+qdhMplI8tLy5ZlpvIwM5+zZs+zevZv+/fsDkJaWxsuXL7G3t+fBgwd06tSJNWvWUKJ6KeQyOYN2jqX/zyNQKpWUdyzNlFXfsXTpUi5fvkzFihUZOnQoRqORYcOG0b59exS2SpQqJSqVSgrekB+6du2KTCZj5syZyGQybty4gaurK9bW1tjb27N27VopMrC/vz+JiYm8ePGCwYMH06RJEw4fPoxarUar1dK5c2c+//xzZs+eTZs2bTh48CBXrlyhX79+yGQySpcuzePHj//xBTQ+Ph5HR0e6desmvcgUBJ06dUKtVnP8+HF0Ol2BcullYM+ePXzwwQcsXry4wHVEUeTHH3/Ezc2N4ODgAtcDCAgIoHv37oWqU1B88MEHuLi4sGbNmmznEhISMBpNnLxwtWBavExITUvLNc8ngF6r4fLVa9nNyQtC3ApyPIf685euYO6i5XkWy498ajRaomNy3/EvCHk9fe4CQ0aPIy4+IUc5/7LJcg5tPA54yqvIKEnGnJCWno7ZbM5uFpz53zeI7/nrt5DJZDn61t24cYO7d+9mM8P8/4RHjx4xYMCAQr+kFyFniKKIo6MjycnJXLt2jVWrVjHaHTCZsG/ciu1xRkqWKsXZs2fp0qULa9eupV69elL9bdu2IZfLqVevHlOnTmXJkiVcvnyZMmXK8NVXXyGTyRg6dCiffPIJSqUSNzc3SStbELRr1w65XM6CBQuQyWRcvHgRf39/1Go1Dg4ObN++HXd3dwICAqS2Hz9+zJgxYyhfvjxnz57F1dWV+Ph4WrRowYgRI1i8eDHvvvsuly9f5sSJE7z3/XJu6OQIgOO5vf/4mqvRaFAoFHz22WfShn1B0LVrV6ysrPj9998xGo2Feg/dtWsXPXv2ZM6cOYWSdc6cOZQrV4779+8Xqt7z58/54IMPishuEbKgiLT+w2jdujUutTw5dOTQP9Lf6aDzjDs49X/yhx8WFobBF9JCkrD1sufrr7+mWrVqNG7cGIAxY8YQHh5O//79KV68ONWrV2f9+vXY+jgyfsdUEh/HEJz+Ao1SRyWrMigr2dCiRQtSUlIQBIFLly6hVqupWLEinTt3BiwLtoOjI+dCLnPoyYl8ZbS2tsbT0xMnJydsbGyoVq0a169fp27durz//vu0adMGrVZL8eLF2bNnD2lpaQQGBhIWFkadOnWkOhn+Qy1atJACTQmCwMSJE0lPT6dRo0bMmzePJ0+e8Pjx4z89p71790an0xWqztmzZzl9+jQzZ87kzJkzBapjMpl48OABGo2G1NRUAOrWrcvWrVvzzF8LoNVqOXHiBNOnT+fIkSMFljMoKIiIiAhOnz5dqBdYURQZPHgwT58+lSJAv02o1Wp69erFhg0bsow9NDSUxo0bk5iYyOPAIDQZWuU8SFUG2dl/9ATvde3F4lXr3xjMH/VmL1rBvCUrWbfp1+wNFdQXtRAaWLPZzPZd+9h14HCO17igmtLPBn9B1z5DCAvP2ww+r/bWbNxKQlIyF69czVPmP2UanAOpj4qKYujYr+k1eGTOKYjMZgJDQmndrTeDx32b9dyb/74xtovX7mBna0ubNm2k3M0ZWL16NX5+fv9x1gX/JJo1a4aNjU1ROrC3gLi4OJydnZk9ezbFixdn+LBhDCruiF10GAgythociIyKomfPnpQrV446deqwePFiWrRowdChQ2nXrh3Xrl0jPT2dEiVKULp0adq0aUNcXBxWVlYcPXoUmUxG3bp1adu2LTKZDLPZjIODAwqFArM5/9+jQqGgVKlSODk5oVQqqVOnDteuXaNmzZp06tSJdu3aYTQaqVixIr/++it6vZ4nT57w6tUrqlatio2NDbVr1+bWrVsANG3alE2bNhEaGorBYGDWrFkkJyfzokYLALzT43l8786fntMhQ4aQmJhYqDoZaXnGjRvH6dOnC1RHFEXOnz+PTqeTtKXt27dn/fr1+VosmUwm9u/fz5QpUzh58mSB5YyKiiI0NJRDhw4V2n1o8ODBhIeHExgYWKh6RfjfRhFp/Qfx6NEjdPZG7Dt7sePYrn+kz8sPryFPhZOBBd+NA9DoNVx6nMcLXS7QGfXMPbMk/4JvAQEBAaSlphEZ8Irg2OdUqFCB2NhY/Pz8uH79Ovv27WPlypXUaVCX8+fPU716dUwmE0+fP8PKTsWthRdwc3ZDXsWGkCfBRDx/hU0lR77+bRqOn/tiU82JTz75hMePH+Po6IhoFjEm6HHycWbl3jUs2L+sQHL27t2bxMREfvnlFwC8vLz49NNPKV++PMuWLWPKlCkIgkDPnj25dOkSJpMJrVbLsmXLePfdd6lduzY3b96U2lMoFPz444+kpqbStGlTevTowdOnT3F2dqZEiRIcPnyYtLS0Qs/nkydP2Lp1a5YAGxlYcnIV6XqLJufXX3/NsshOnTqVmJgYHj16xP79+wGLD8v169clciKKIjNnzuTkyZOkpqbSo0cPRFFEUMoQrC2PIYPBwObNm/noo4/y9IGZPXs2SUmWPIDnz5/PEkgjL6xatYr7jx9ASSXLl+et7cuMV69eERQUxKNHjwpFkguDgQMHEhMTQ7Vq1Zg8eTK7d++mQYMGaLVaduzYgcFg5Ozl61krvSYtIS9ekpaWmuWUrY01JpMJB3vbrNrWTPXeaVwfnV5P3VrVcyd4b1HjKJPJWDxnBj/OnIKVlZVUpFA+qUDZkiWwsVZjb2dXoPI5tT93+iQ+7NCWdq1aFI6gF8Y0OKMu4OLshL+vD80a1s92LuP6WCnlFi1W5nGJZkRR5MmzIEkjnnksBoOBs9du8sWoUXTp0oVu3boxb948Vq5cSatWrVi7di39+/f/fxuEKTQ0lLi4OFJTU6Vn09+NO3fu/Cn/flEU/5V4BIXB06dPiY6O5sSJEwTeu8M0ZTT1XlrWC3nrbqzctZ+VK1fSrFkzTp48SbNmzdBqtaxcuZKRI0dy6NAhBgwYgK2tLSEhIVy8eBGj0Uh4eDhHjx6lefPmdOrUSQpaaDKZSE1Nxd3dnW3btjFr1qwCyTlkyBCSkpKk57yzszPDhg3D1dWVZcuWMXv2bORyOQMHDuTQoUMolUrS0tLYunUrDRo0oEaNGty4cUNqTyaTsWDBAjQaDY0bN6ZHjx4cfRxIkgnkQNKF49Lma2EQHh7OL7/8wrVr13I8l0HSd+3alSVw0rfffktUVBSPHz+WSGtqairXr1/PQkAXLFjAvn370Gg0jBgxIptVjclkYuvWrXTq1In4+Phc5Vy5ciXx8fGStVhBx7p582bu3LmDTqfLNW5DTkhKSuLRo0fcu3ePffv2FbheEf73UURa/yZoNBrat29Pq1atpIfPxIkTcWnriyATMOSc4SJXLD+xhhHbxpOiK9yD8eLdyxxbfoCHEU8KVW/2uh/4dHX/QvsvPIl+yqabv6Ez5q0text4HPAYo97AwE/7kyKkceLECT799FNEUeTdd98lJiaGrj0+Yq94ijJdq+Dv70/7Du1ROlhRwtWfcXumkhKRiMEXAoMCefFbAGOmf0XonRCSNr/kmSyUnr16MnDgQJasWgZyMBlNOJd041bSA8LSX6Ez5q+VHDBgAD8uWsCHH34oHevfvz+2trYsXLiQb7/9ls8//xyFQkGlSpWwe/3SeunSJVJTU4mIiMi2u1mlShXeeecd9u3bx+TJk9m6dSvOzs4EBQXx8PFD6k59F1EU2XxrB0navIMgRKfGojPq+PHHHzGZTJJGYsqUKeh0OpYf/JlF135m4cHlfPDBBwwcOJDvv/8egBcvXvDw4UNsazqjLmFHfHw8T5484cMPP2T79u106NCBMWPG0LZtWxYvXkzbtm2pUaMGO3bsAMB7SDmKf1sdj16lAIv5/JkzZ/Dw8GD+/Pm8evWKdevW8fz5c0neBQsWoC5ph2NrL0wmE1OmTMk2phs3btC6dessKQ1WrFiBbTUnXNr4EBERUeAXxP379/Py1UuU1e0YP358geoUFpUrV+bkyZM0aNCAFStW8OGHH+Lr68vly5dp27YtJUoU5/DpC9nqPX4WRL+xk+g96ussvpAtmjTkxrHd9O3ezVIwB+L6buMGHP5tIzWr/hF1tiBBmoxGI1eu38RgMOQ+oFyIXKN6dWjSoJ7UV2HIagbmTZ/I0d834+ToUKh6mfvyLebNJx92QqHIlKq8gJrVB4+eEBObTxCwN9qyUsjZ9NNCpk0Yk/VcJj9Wf59iXD6wnR+nfZ2l7sbf9/HFlNnMWb4223xdvnWXpOQUOnXqxNatW/nqq6+YMGGCFJht2bJlfPPNN/mO6X8BBoOBDz/8kJYtWxIUFITZbGbGjBnS+cJakISGhnLnzp1CWyktWrSIfv36SRtrBcXhw4cpWbLknwowl591ytvC06dPiY2NZfny5dSLC8LLkIooCHj1GUXz5b8SExNDt27dOH/+PFWqVKF06dK0bNmSkiVLUqlSJSIiIli7di329vY8e/aMu3fvcvv2bbZv306bNm2Ij49n5MiRDB8+3PKcV6tJS0vD3d2d33//vcCmsJ9++ilz586lb9++0rFu3bpRunRpZsyYwdixYxk7diyCIFC1alVUKhWCIHD9+nXMZjP37t3j7NmzWdosVaoUnTt3Zt++fUyfPp1NmzZzw2yJJFxCE8+7775b6PlcsmQJJpOJw4cPA/Ddd9+RlJTEw4cPqVmzJqdOnaJ379707t2byZMnA5Z8y5cuXZLuy+TkZK5evcpHH33E77//Trt27Rg9ejSdO3dm7ty5fPTRR1SuXJmVK1dK/WZ2b7p27RrXrl3D29ubqVOnEh0dzbp163j69I/84NOmTQMsQbdMJhOjRo3KNpaHDx/y/vvvZzEfnj17tiRnxrtBQXD27FlevnyJTqeT+i5CEaCItP5tmDx5MiEhITx9+pR27drRsGFD9u/fj8rHBuQCtlWcePDgQYHb23BsC3t+282ibQXT7mUg0ZiMd1U/9pws3G7V5SfXEPTw6fhehap34ekVdFEabr/Krq3LC3HpCYzYPaHA5Xv37s38lQsxyE1MWj8dnBQsXryYbt260bNnT9LT09m5Zxfu3UrQTKyNf/WSROijGfDlIAxyI+XVpdh5dz8RumhMMpFAfShN6zXBJ8aV9IeJHD18lF7NuzN3ywI++eQTbgXcRuaqRFHGBpm9HKPajElp5uj9U9lkOxN0kSUXV0uayRhFAgHeYVnKCILA+PHjKVWqFAsXLmT16tX4+vri7e1Nv379MJlMNGv5Dt4flmb06NHs2rVL0tRmYOr0qWg0Gm7evEnlypWxK+dE8MsQ/OqXQudqYvnFNSy9tIZmP3WU/JqNZiPfHJ7Jx5v788uNX4lIjmL4nvF03dSXI5FnQAmHDh3i1q1bfPfdd/z000/8eGMlAgLrbmyRTJjnz59P/fr1qVixImazGbvqLji964XC2Yrq1aszbNgw1q1bx/Hjx1m0aBFHjx4lNjYWg8EgvVAiF1AVs8FsMGNb0QlBEEhISCA9PR2dTse4ceMoVaoU169f59tvLSaTMTExpKamYlvVCZvKTshs5KxcuZJ79+5x8OBBfvjhBw4fPsz48eNZt26dlEboxo0bpKWlYVvVGX20FoWrFQMGDMj2QpqYmMj69euzmKF9/fXXOLfwxvldb2ITYjl37hzz5s3jiy++eKtpA1q0aMH69euJiori2rVrnDt3Dk9PTwRBoF279hw5cyGbvO4uTqhVVtSqmjXdSY6pUnIyrcuBpOWpdRXNrFiznjmLlrFwxaocz+dH/P4sWX0bKFDfeYwhMPg5YyZOpc+w0bnXe6NujubAkPP1yFzm9b/lSxVHp9dTvWLZbOUOn76Iu7s7tWvXRiaTMW/ePO7cuUNUVBQnTpxg6NChWbTa/8uYPXs2AQEBBAYG0rFjRxo3bsyGDRuylHmTiOSF77//ntatWxc6QuvNmzepUKECI0eOLFS9EydOYGdnl2Pu0ryQmppK9erV/3YXoKFDhzJt2jRSU1NpWL0qbWwsFi5ek5awICSZ5ORkdu3aRe3atWnWrBkDBw7k2bNnklbz1q1bVKlShZ9++omYmBju3btHzZo1uXv3LseOHePw4cNMmTKFY8eO0bRpU4KDg1GpVMhkMimPdYkSJbJsYOYGT09PKYNABgRBYPjw4TRu3JgZM2YwZ84cKlSogIODAyNGjMBsNlOtWjVq1arFhAkTOHr0KAsXLszSxsSJEzGZTJw6dYqKFSsS6+IDQBUna9LT0wtt5vvrr79iNps5duwYQUFBTJkyhe+//54uXbpQtWpVhgwZwsaNG0lNTWXt2rXUrVuX0qVLZzOTbtKkCb169WLTpk2cPn2axYsXs2/fPqKjozEYDISEhGSpk1nOpKQkUlJS0Ov1zJgxAz8/Py5dusTXX38NWO6vjKjBGffYzp07uXr1KsePH2fOnDkcPnyYUaNGsWLFCs6ePStFhM68ASOKIn379s0me2pqKuvWrcuiBR4+fHiW84cPH2bhwoWMGDGCsLCs71JF+P8FQfxfdHb8F5GcnIyjo2OWSHlqtZokeSpJIfGUnF0LALPWSPqKCMqUKYO/vz9r167F1tY213b9B1ci7mw4/lVL8XhHwaPF+X9dFQArrYLARQWvV6xvORTeaoRwA6EbCu4j+f4PHxKQFsxn1bvy/QffFrjeoJ1fcuH5Fa6NOIadKvd5AItfTe/evQk1hJPWXAYCmKP0rGg1l+DgYEaOHMl7w9vh3siHMmm+2Ceo2XPxAPIyaqIfRWBqrEIM0iGWVQICYqIBrOVUcivHy4Aw9s/4DX8XX26+vMuoeV9xYMYORs3/igs2t0EG7mlOxNhZdtEb29Rm48g/XmoOPjnOnNOLcVQ7kqpL4Uj/HWy/u5s11zez8ZMVlHTxzzIWURRp3bo1+/fv5+bNm+zYtYOGvd6hV6NPqNG9PqkVTbyYdg+tVovZbOb8+fM4OTlhcBb59uj3pEWlErc3jG6Te7Dkl+VYFbPGwdMRrUGLTJRT+oE77cd0YeeDgxwfuJP5Z5dRxasiHSu+z9rrm/nlxjY6V2rD5dDrXD57GZtyDkT8+JgyXqV58OABtva2eEws/1pYCPn2NnbWthbzIBlgBsFKhu+XldGHppH2JJHUW/EolUpJE2dlZYXBYMhOuLqXxK6aM5hEkAvEHQoj+UIMvC4mCIJUx8HBgV9++YURI0YQERGB37jKyKwVpFyPJf5wOAqFAkEQMJvNUpognU6HlZUV48aN46effiJem4BHz1JYeVmTcDwC5zBratWqxejRo6lWrRq3b99mxowZuLm54efnx48//sj169epX78+Xv3LogtLQ/MsGW1IVmsHOzs7UlNTSUpKwsGhcNq/guLgwYN06NCBeyf2ULFsqawnBVmO30VByLmMLJe9yjfbAcQcjl27eZtvv5/Pt+NGSVrTguDfIqq5Iaex5YfUtDT6jfiSerVq8NXIIXmWzTEnbgZyCJCVZaMhFz/WN+tUb/MptRs0ykbO/j8hY8319vbGYDCgVCoBSyC+N90MHBwcqFatGh4eHqxZswZnZ+dc2y1WrBhRUVH4+voSGhpaYHnkcjlmsxl/f/9C1fPw8CAmJgZXV9dCpRbZsWMHn3zyCTdu3KBWrVoFrgeW9UfI/JzIBampqUxs/y5PDTKOXr7Gh+4qJvrboHf15sknY+k/YCAtW7bk2LFj7Nixg8DAQC5duoRMJiM0NBRbW1sSEhKIjo5Gp9Ph5OREWloaixcvZv369ezfv1+K+N+7d29mz57Nhg0bpHRN77zzDjVr1sTX15egoKAcNX2FQfv27fn11195/vw5y5Yt4+eff8bGxoaKFSty69YtnJycSElJQRRFjh49iqenJ9WqVQMsFjvLly/n9OnTNCzly28V7DAJMrq+ssLTuxguLi4cOnQoqxVHLsiYe5lMRv369bly5Yq0fikUCskM19raOsdAa1ZWVpKWXaVSSdYESqUSk8lUIB/g3GBnZ8eGDRsYN25cjoELM6+5SqVSWnNVKhUjRoxg69athIeHZ6nj6elJvXr1GDVqFHXq1OHhw4dMmTIFV1dXHB0dWbVqFffu3aN69ep5ypYRnPLvXHOL8J+JItL6lpGxgFpZWSHaCZg1JlSlbPHsWZqYfaG4dyoulQ355halSpVCFEW6du3KDz/8kGu7xSdVQ5AJpD9LInrb8xzLvLkApWnTqLKgKYJMwJii58WsgkdvKzG1BjJrOcYkPaHf3yvQwgZQelItRHsBF509N6aeKVAdURRpsqI9EQmR/NRtPu+Xb5Fn+eXLl/PVV1/h0dQPeQt7AMwGM9GzAyy+p6WUtBzWjtblmnP77h3O37qIQ5yal95x6DV6cFMgmk0oHFUIZjCZzZiOJ1G8TTkcbR0Q7BXMaP01fnbFaPVdZ27Pv8CYNd+wL/Y4IiKCSYDX65E8ARY1m4HRaOSm4hHbHuzB096d3Z9vZPmlNex7dAStXofGrMVBZU8599I4WTsyreV4vB0sGxsZGtS+ffvSamQHQtNekqxNQVXMBoW7isjZj9GmaJHJZJhMJqzUVnj3K8vcVlPwr1yST5f3QyGTk56chmAlw93Xk2RSEV6aMGHC1teeRmXrc+PlHRoVr0sZt1IICDyIekx178r8cm0rA6r2YN75Zcis5ejC00m7FEdaSBLq0na4dy2BqDchWMlJOhdJwslIRL0Zz96lEWQCyVdj8OxVGgBNUDKRa7IGTshMPiXIocT0mgjyP+4r0WhG9yKN+COv0IXl7pMrt1fiN74KiCKmdCNhcx5IATtyrySgLm6LZ+8yyKxkaF+kEfFTAP7+/rx48QKZTCa1kbEI16lTh/tPH6AxavHqUwYrT2sSTrwi8VQkKl8bdC+zJpT/OxdQrVaLp6cnX/T5lKlfjsheIDMBy/S3RFxzImg5kddciNyfIXjwFolqfu38Sfmk5v9i/czI1zc4P8Kaw785Edb7TwKp2e5T9uzZIwWK+/+IjDU340UdyPNZULasRWPdrFmzHCN2ZyDzmpfba1JOpK8g9fLrz2QyIcttc+kNNGvWjPPnz/Ppp5/y6685BFXLBVqtljJlyhAaGpqvz/PRET1wu3KYWJNAp7vx/FTOnup2CtbHGNltciA1NZV79+7h7e3NoUOHWL16NTKZjMjISF69eiXl1S5Tpgxt27Zl/fr1WFtbM3r0aJydnaXo1kajkY4dO3L48GHOnj3L4MGDMRgMUuyG2rVr07p1a2bMmIFer6dRo0Z4eHhkkTUyMpLbt29z7do1pk6dmuN4du7cycuXLxk1ahRDhw7l/PnzBAQEYGNjQ1JSEk5OTiQnJyOXyy1rrpUVzs7OLFmyhI4dO1KmTBm8vb25fesW56s7YCUT+OhhEgrfUhgMBtq0aZPFHPdNvHjxAjc3tyyKiswE9K8ixzU3EzJI319BvmtuLvL4+/tLaZBkMhmiKGIymVAoFNSvX58HDx4U2LS+iLT+/0ORefDfBXc53kPK4TO2Eh7dLZoRtw7+2YqFhIQQEhLC/PnzadCgQZaAOxlISktGbqdEZi3HuowDMTExAAQGBkpmHmPGjMHe3l4yHQmLD2fMrK8QZJaFUGFnxcuXL/MV22QycfbsWWTWlkVMYW/FoUOHJFPXDOh0Oqk9URQlv0jz62dwnJiY/xwBR64fJ1GbRGRiNCgEfrmQPYCFVqvlwIEDUnChGTNmoBcM6Hz/eCjLFDL0Rj0GgwGn1t7Yyqz57vcfuBB1jZJ1yhDtl4ImKR2ZiwLTCy1yB4vJnCgDQSHggD1WJ/X80nc5NYpVYfT+Sfx65DdcPF0JCAjg1M0ziK9VgKJMBNEyboOdmWHDhnEm5CK/3tiF0WQkJi2Od3/uzIazv5IUkki6SWN5MKcaUMtUdKnUlgmHprPw/ErmnF5MySblJDMhg79APVMVbF3skLtagSgiL28jRU9UqVSoytsRfzuK4au+ZPxvU6iuqsCrIyFYl7ZH6aYmxZwGAjja2CN4KEgKTUCr1bL6owV0rdqRFqWb8V7ZZvQp3Y2zzy6SqE1mzsnFyFSWx4HS2QplSWs8epTCqaUlt6NgZbkfHBp5UHxyNZzb+mBd2h6rYta4dv7jvlaXsmwiuHbyw3tgWRwau+P6oR/WFR3xHV0R78HlKPl9TUrOrCXdmxkQ5DJU3ja4f+SPzDb7S5RLZ188B5XFtoYzgkJAUMpQvL6OOS2eGWaRNpWd8OpVGnVZB2RWljGqill8kV68eCHVNxqNUjsGg4HQmvG4jSqNlac1Vl7WIFjacmnvi9N73nh0L4mg/GceoWq1mq5du7J1zyFEsynvwlm0czmYCWeggObClnYKny/1LxPWwkQoLmyk3zfwV2XOtf6bcv0Jwpobtu49jIuLM23btv1TMv+vwWAwSJtOeSEwMJBnz56xdu1aatasyYUL2X3F33zhz9A0hYSESCaP3377LY6Ojvj4+GA0GjEYDNk03pn9AnODyWTKFvE9p6A1BoNBel5lRob8v//+e759AVIu7c8++4zw8HD27t2brYxer+fgwYMkJyejDQvG9bLF59JNLjLCx5rKr5/Px+K06HQ6ateujSAING7cmLNnzzJ//nxSU1MJDAzE2toaURQRRZGSJUuSlJREcnIyzs7OHD16lN69e0v9Xrx4kcaNGxMcHMy8efN4/vw5ERERHDlyhIMHD9KgQQPu3bvHwIEDiYiI4IsvvmDAgAFSsK06derw3nvvMXr0aBYuXMiQIUNISMie1irDN9VkMtG4cWMqVqxIpUqVSE1Nxd/fn9TUVOzt7ZHL5ajVasxmM5GRkXTv3p2JEycyYMAAbty4gXexYoTrLPdbRWs53t7eaDQatmzZkqP719OnT0lKSqJ48eLZLOvepl9yfpslmQmrvb39n+ojp99ZhpVDXvK8ePECURSlNTdjo8loNHLx4sUshLWgypIi/P9BkaY1ByxfvpwffviByMhIqlevztKlS7PkGcsLycnJOLk64TehCphBZqNAUOT8w3u1+imurX2I3fcC/auspNDHx4crV66QptJy9MQxFoVaFjFRFJGvTUav1yMIAo6OjqSnp0u7mSaTCYcKrti1dkcXloZ9XTeLuaUANe6WYN53c3FwcMiyO3n27Fni4uI4HnmWozHnifo1GM8+paXzMeuCcenih/63WFo2fQ+AM2fOoNPp+Pnnn3Gp4MHgfV8xt/Fkxlz4IyjOkU+2Ua7kG35YmbDp2Fam3vyRpR1nM/KAJViIYBQ42ns7E7dOZ/2olVgprGjTpg3vvfceR48dZfy48Xy2ZAAuzb0xG03IFHJpfHGbQrFBjcMnxdC+SsNwKBFbb3sMdZUobJWkvUjCtpQjmqAUVDUcEMwW0gogCzJSsUIF7L2dcEyx5czpM2jLmXEzO+N6R01IlRgMTpafioBkwQqA5yVrYitpMTtZtIWCGVAKlpIZl/51JWW8gNFFxCFSjVlhxmQlorM2YTqZRNV6NQiJes7o5kOYfWk5xtKWXowJeuyvyXCr7UVtoTIPij0n+lkkIdefkXwjFqVSifeXFVA4WCEKIqJJRJALiBqzRQ69GSuVFdV8KvPg1RMMGJDpBMxaEyY7EJRv3J8iiAYzgpUsyzEKuH7oY7RgtLykqIrZFKxSDhBNZuIOhyNXWTT+7h+VACxadVkmshix7hnaZ1kDhsntFTg28UQbkoLrB/7IbZSY9SbkNn+YbD2fdhtRl/Pjz6aqE57dS4EA6UHJ2JS27OaKoohZY0ZuLUcfo8GUZCB6WwjmdNPfvut7+vRpWrRowbmdG2hYp2bWk7mYCEMeZsIZKIS58N+Ot6WZ/Tdkz4w3x5FLvtyCENaciLDZbKZU04506PwBP/3009uS+l/DX11zHR0d8yzj6emZr/+5h4cH58+fp1y5cjx69IjKlf/wEy9WrBhqtRqNRoOHhwdarZawsDD0ej1ms1nSXL35It++fXsWLVqEjY1Nljyj169f5+nTpzg4ODB8+HBiYmKyEIkMsmRra0uLFi2wtrbmxIkTaDQaFixYQNeuXVmyZAmDBw/GxcVFqvfo0SMqVqyY6xifPXtGuXLliI2Nxc3NDbBoni9fvszatWv54osvUKlUtGvXjqZNm3L8+HFmlnFAfft8trYSDGY6PtXh7OxMlSpVuH//viUlnIMDaWlpeHp6EhAQQKVKlXj27BlJSUlUrlyZ4OBgtFotpUqVYsCAAUyYMIEDBw4wY8YMgoOD6dixIxEREcjlcu7du0dCQgK+vr7I5XKePHmCTCajQYMG6PV6ZDIZ0dHRiKKIlZUVDRs25Pnz53h6etK9e3eOHz9OQEAAtWrV4tmzZ+j1euRyOYIgEBAQQIMGDXjx4gU9evRg48aNUqAnpVKJr68v7dq1QxAEateuza5duzh06BAmkwmlUokoinTo0IG6d4/xvouK/bE6lqVaExcXh62tLe+88w6rVq1i+fLl3LhxA7lcTlhYGAEBAQWOeJ+B3LSamd1wCgMbGxvS09PzL/gvIz9tbpGm9f8fikjrG9i+fTuff/45K1eupH79+ixatIgdO3YQEBCQzQwlJyQnJ1NtflNk1op8X/JFUQQTmDVGdFHpqP3sEGQCphQDUb+FUKVKFQzNVcRcC8e6lpNUL2TqbaxL2WMVL0NWxRq7Wi7EHw9H4WCFIUGP+0fFkankiGYxizbrXW0dkgLjeXovgLp163LlyhXMZjPPXgUhGs0Un/zaj0Akiw5e+zINlbcN2uepxO15YWlXJUfpqkL7KJlS02thUpgRwk2IPn9oyBxOCwzrNYSBPfrnuGNWckZNBCsZSo0cg/Uf2iMhxYxoL0PUmfC8bssLvzis3FXIrOToYjSovHMmQqYIHU62TqQaUzHFGFD4qzEajGjOxiGUUqMuZYcxVo+ymFoySxUNZou2TATbBCvEUAOpHjqUtlaYZGZkdnJEDZiVpqwkjj8ur4XPCZIm9o/zlmNCBnkVQSYImMxmBMDb3osuZdqy+vomjEoTolnE9aGa1Gpm9EYDojyTJlkvYGtrQ1paOnZparxU7sQ+jiIgKACFjRLn9j7ZrpskHGDWGUEQEE0iZqMZuZUMQWH55Ig3SGoGEc4LWch8IUhuTnOXGSaNAbl1zju4lvNGMIrEHwtHkMvQR2twbu5N6t14nFsVQ+FolaMsqY8SsSvviD5GS+LpCFDJSbseBwIUn1Yd2Wvtcl5+X6LJjNkg8mL63b99ATWbzRQv7k+7dxqx/Ps3/MXzIK1QAOIK/x55/Tt9Xf9p8pqfRjsnwpr5eAFJ6+nLN2jVYwgXL16kUaNGf1XqfxVvY83Nj7RmmHnmh8qVK7NkyRKGDBkiaSQzw8HBYgqboTnMD7169cJoNPLo0SNq1qzJjRs3EEWRhw8fAha/wMISGEEQGDp0KKtXr6ZRo0ZZgktVq1aNL7/8kh49euRo8uvm5kZcXBwdO3bMkgKoQoUKPHnyBFtbW3o3qEH76AcE68xsTFGy0NOMWi4w6lkKvbzU1LG3PIvnhqZxTu5M3bp1CQ0NldLNZcxbhk9ohqZVo9GgUqkQRRGdTocgCLRo0cKS8/TFC/z9/YmIiKBKlSqYTCYuXrQEGdPr9Wg0GvR6Pf7+/jg7O3P79m2aNm3K/fv3EQSBuLg45HI5H3zwAadPn6ZWrVo0atSII0eOMGHCBHr16oWHhwcnTpxAJpMxc+ZMHj9+zKNHjyhXrhx9+/bl7t27LF68GLCQwWrVqrFx40YGDhyIt7c3xYoV4/Hjx5w8eRK5XI69vT1Go5GGCi3fl7IjSm+m/f3CRYwuzDV/835TKpWUL18+R41uBjHP6d6ys7Nj6NChLFy4EKPRKBFDtVqNTqfL874u6O/oTdkzfF8LA2tra3Q6XRFpLUIWFJHWN1C/fn3q1q3LsmWWKL1msxk/Pz9GjhwpRVPLC8nJydRYkU/o8/xe6EWRjKsiyATMJjMyeSbNSWYC8dpMVZAJmA1mBJmQK7kwaY3I1QqSbsSg8rBB7WuDKIKIaPGfKQDJEI1mC9ERRcxaE5qQFGwrOb8WO+vLvZVWgcnKTIVgX3xbl+LG87tMfmcMXtYe/Hr5d/YlnMi/w8JABGOKAYWdAtEoYgrUYNKZUJa2waQ1onBVIZNbHtBvmqaCRctrSNSiNCpwcHCgjX9ztr3aL5FV4fUEZRAsAUAQLNeL/MnXm+eFzH9lvides7/MZa1QoH+lQVAqMGsM2Hk44K53ws5owz2rpxZz2r/TlEYU82+/EEQ1M/Kbt78LOZLRDDEKOY6Qb279Iwvo5MmTWbJ4Mc+vHMPB/o08pX8ncc2rTkHxbwZi+jvJa27jyiU/LuRDWLOVzd7OJ8MncD8ojCdPnvzXm9C9jTU3P9KaOUjNPwEPDw+io6OB3IPo/B1o2LAhZcuWJTk5mVWrVrF3717eeecdAKKiomjatGme9ctZy1lfwR6rN9bHOIOZtveS8FfLWFPenjOJBmaG/qGpEwQBW1tb7OzsMBqNGI1GUlJSUKlUvPfeexw4cADIbrb6zjvvcOXKFXx8fGjcuDHt2rVj6NChODo6EhsbS6NGjbCxseHQoUMIgiBFtv3ggw94+PAhZcqUIS4uDrPZzMuXLyVSLpfLcXJyonTp0ly5cgVBELCzs6NYsWKoVCo8PT2xsrIiPj4eZ2dn1qxZw5gxY9i2bZsk26xZs1i9ejWOjo7Ex8fTrFkzbGxscHZ2ZtWqVZJrlr1c4GR1R2SCQIf7SUTqC/ec+7O+rHK5nGLFivHq1assRNLW1hZBEEhPT8fe3p6kpCSJ9Gb4kDZr1kza7PD09CQ+Pl7yoxZFEaVSmc3nNWPzIfNxQRCwtraWjuVEMDOiP2doxDMjI+BVTkQ4w0ddoVBI8yOTySSz6pSUlCLS+v8QRaQ1E/R6PTY2Nvz+++906dJFOt67d28SExNz9P3Q6XRZFsPk5GSabf7/GxQjM97U9P6bKJAs4h/EFGlPIGftacbfWchNZtL2mnRm1rZK9d7YNRUy/T838pZhymyM16N0VCHKzH8vSX3LeNOkOgtyIbvC61q51cutzb+LBOfanyAQ/PXNf2QBDQ8Pp0SJEsydNJYv+vV8Q5BCkNbc6kDexDW/uv9hEYJzxJ8lsAUdWz6+woUhrJbyWb+/ePmKss07s3jx4iypIf4b8bbWXD8/PxwcHCTt3ptwcXEhPj7+bxnD20R+AXT+KjyVAm1drNgdqyfJZOnHSoCOrlaUtVHQxc0KhSCQbDQTZxApaS1HaxaZHJLGmcSCmaEqlUpsbW1JSkpCFMUs2mR7e3spNoWXlxcpKSk0a9aMhIQEKW3Txo0bMRgM2NnZkZKSQtOmTTly5AgqlYqaNWsyePBg+vTpg9lspnPnzsybNw83NzcWLFjAL7/8QtOmTTl48CAVK1bk4cOHiKLIrVu3eO+990hNTZVIa4kSJXBxceHIkSOkpKRkiWkAFu3zs2fPUCgU9OnTh3379pGQkIDZbMbJyUnalABYU96eGnYKfo3SsvClhsI8BQsS0OhNjXzGfZKTpj4jEKivry/37t2TCGHGxo2tra0lHofBgMFgkDTy7u7u1K1bl+joaO7cuYNer89yL8pkMipVqkRAQEAWk2Rvb28qV67M48ePSUxMRKPRZBmPUqnE09MzW0wVa2trFAoFtra2xMfH50jcGzZsyJUrV6Sxmkwm7O3t+eqrr5gyZUoRaf1/iKJATJkQGxuLyWSS0tVkwNPTk8jIyBzrzJ49G0dHR+nj5+eXf0f/9DbBv9RfoQnr3yhnjrKY3uhQAFEQXys+/yCYgiBk07JKEDP9K2Q9liWKZKb2pHZ5o93XHDinWcvwvVW6qCxmw/9hhFUURQQxd5nyVGDmUk3Mh3rmdu7v0trm2t8/uO/n4+PDRx99xIr12wptbiXkJGdu5qwFaTtzoKS/GAjpH0VOchfkkx9ymrc36uZIWAuJn7b8jp2dXZYANv+teJtrbnJyMtbW1jlG3Y2Pj5eOy2Qy7OzsUCgsFjX5Rc79J/F3Pktq2ynYVcWREb42/FD6jyBA/bzVfFPclo/cVSgEgViDmc4PkunxOJmpIWl0f5RcYMIKloBRiYmJ0lgyk6rU1FQpWJbZbEYQBO7cuYO9vT0bNmzg4sWLjBs3jmfPnlG3bl0UCgUXLlyQSJq7uzubNm1Cr9fz448/0rFjR27cuEHfvn25f/8+s2fPxtraGqVSyd27dzEajYwbN46UlBTmzp3LwIED6dOnDwD379/nk08+oXjx4pQoUSJbEKEnT57g5uZG69atWb9+PTExMcjlcgwGQxbCCnAs3kK4unuqmVK8cHEcMlsJZOSjfRNGozGLfBk+vH369JHua0dHRxQKBUlJScTExHD79m3UajXlypWT8t2CJQiTjY0NarVaaksQBAwGAxcvXrSkurO1RaVSZXmHMZvNpKSkSIQ1Q56oqCjOnTtHeHg4aWlp0nXNgMFgyGJp4OTkJM2j0WgkOjoavV4vpfrJgJWVFbdv35b6cXBwQKlUkpKSwnfffVeoOS7C/w6KSOtfxDfffENSUpL0CQsLw5hqoKx9SUpFe+WmCsr2VZD0bcKfNvfKtVY+zQm5s4Y/hz/Lp/Kr95bXc9FiG/1H968JKkIGuXx9Pod+M4tqStRDuglBBMzkOA7pUEaf5gxSJkp817LIC3loFv9BM1opQEwOcuRATgVBsBD+jO+v/5ObZahlKqxkSpyCVPDqjxf1jJcaMZM5lWAG0WAmZX042vVRaJdHIO4svJ9Q5g2B/MuCoBeQpQuUMHgXrJ5lj4HigjfWcfnn43ubGDVqFEGhLzh06lzeBXMgRQUmrlBw8vpPIEOW3D7/CXJlRg5EN1fCWgjympauYe223fTv3x87O7v8K/wPIqc1F+D8+fP07dtXehnPDKVSKeWVdHFxwcPDgx9++AE3Nzc+/vhjli5dmmee9MzIeOFXKBRS1Nw3kRG5PDM8PDxQKBTI5XImT55cKLKcQTgKkvszJ1gJ8G0JG1SvN29r2SspYy1HKUB3D8t8XU82sCI8nR6PkkkxiehFOBivJ0z3539fSqUSa2tr6XtmUh4XF8e4ceN48eIFv//+O7/99hupqaloNBo+++wzihUrhk6nw97eHkEQ8PLyIiYmhkaNGuHl5cWKFSt49eoVR48eZe/evVStWpWSJUtSvXp10tLSpNRGv//+O7Nnz+bRo0f88ssvbNq0ibS0NGxtbenbty81a9YkJCQkm/m4h4cHvr6+3LlzR4p0m56enuPGwo4YHcvCLcSsg5uKxg6W6/TmvZFTXuCMXKyCIJCSkpLtPEDXrl2zRfnV6/Vs2rQJs9mMXC6nWrVq1KtXj379+vHbb79x/vx56tevj4eHBzqdTvIpdnd3JyEhAZ1Oh7W1NRUrVpQCSymVShwcHHBwcMBoNGYba0b0ahsbGwRBoHjx4pLZcLNmzfj000+l65UZGRGcVSoViYmJVKxYkUaNGlGnTh0mTpxIy5Yts+Ryz7jPM8itSqUiISGBkiVLMm/ePBo2bJjjPBXhfx9FpDUT3NzckMvl2aIMRkVF4eXllWMdlUol/cgzPun3EvG774TVExGvKznsumU8B8wWs1Gz3owpVIvmeBzpDxKB7A+7AkErIhTORx4AY5oB8U2tYy4y6F+kow1JJfVWPLqI3HNp5gTRZM6beOb0Pm0SMacZKSX44rxTQP84tYCd5V9EUMgwa/+YMAuJzUxUs5oKZ/kzg9QCLau8S72SdajiWAE3OxfkgsU/2PIAfi2I5vXCb7YcMpvNKNJlmIO1YBAzcUQxV9L0Vwmr6fVY89vNF82WnVfBLGQn4KJI4vyQHO+XzOKJiDjEq2nn/i5h393HbZ+CVYOXELLs7h/yPLD4RMlUlpc34YUBK7MVXpHOlHIsjretJ507dGbEp0Mxpvyx029KN2Td5Hn9t0JQcHvUaXZ/voG1LRfQwlAvVzkzamUMb3X3hdyaeJp9Y7ZRMsQjx/IZbQlmAUEmYBOiYNegTYx9/5810WzQoAGNGjZk1pJVf1zLt+Fvmh95/acJYmH6/CdkKwhZzoWs/hUNa+Ycsis37yA5NY2RI0cWqo3/VLytNRdg69atPH36lPfffx+VSpWFvLq5uUmmyP7+/qSkpLBgwQKSkpLYu3cvzs7OnD59OltfmdfADOKYnp6OVquVSExOfqI5aXtjY2Mt0f/lcmbNmpWN2AqCQN26dbO1k0Gm5XJ5oYM2AZSwUTKvlC2+KjnRejN3Ui3P0sHeatq4WGErt5gDj3iWyrpIHcmCJbXanDlzqFOnTpaox4WF0WjM1Z/XYDAwa9YsypYtS69evbh69Spt27YlJiaGbdu2odPpsLKyku6DESNGkJyczIMHDzh27Bj79u2jcePGbNq0CblczvDhw/n8889ZsWIFMplMIl1KpRIbGxsWL15MrVq1UCqV6HQ60tPTSUtLY+PGjTRp0iSbfNHR0URFRREeHo7BYJD8PXOCCKyP1HIg1kJ8BxazxsrKChsbG6ytrXF3d0cQBBISErLcGxkaZBsbG2rUqEG1atVybP/06dOStUBGkKUMounn50eZMmW4cuUKtra2fPDBBwwcOJCRI0eyePFiLl26hEwmQxAEbGxsMBqNHDx4EFtbW3x9fWnYsCHvv/8+pUuXxsfHhzZt2jB27FipD0EQkMvldOnSBScnJ2rXrk3jxo1Rq9XMmDGD1NRUdDodq1evplq1anh5eUnzVLJkSVxcXBBFkc6dO1OlShVKly5NcnIyR48e5dy5c0yaNIlixYpRqlQp5HI5MpkMJycnevXqhVqtxsnJiUaNGrF+/Xq8vb3p3bs3S5cuLfA9WIT/LRSR1kywsrKidu3anDx5UjpmNps5efJkoXZ24vaHsXn9Zho0aMCT8w+ll2qz/nXi8ycWp/WY9SEowyFqSzBmW1A1dkLpY016UDJiAV7ApHZ1ZkwpRiJ+DeL5zDsFktGcbsScZkT3PI20uwk8n5ZDvTcJiwni14cSvyEUzeFY4n5+TsqtgvkJ6cPTkWsFDNeTES7rEM35qC8BUWvm2Oc7eP7dXbo1/xD7th506dwFU7pl4c6YzzchmkTMGhNmjQl9tAZTquEPzWGWgmSJCCwaX9PCdDNqQYVSbjFLEcU/DFWlViStqEjaiRgMT9JQq9WUdyhNMb07aC0EXRSxaGCt5QgI2IYqIM2MPNBIzPEXoJbBKyOCWHDNYGYYU/Q5zyWZNJmiiDJBhlwtR9CLqFOV2ATIEIxZ+zMmWUycUi7EYNaaSDz46g+i9lo2U4oBV1dXojYESfW0Eel/zIkIyRejERJEUpNSWT50AVWrVuXu3bs0b94cpVKJ1x077C4IvPzVksNQ0Fkm1vqiiO0eA7rLidy9e5fg4GC2b99OQkICKTsjpMl/teCJhdxHW34j5iAtmCB8+WNaN29Fp4btObh9PxO6j0Vz9o/70zLHmW6zcDMioDkVT5fa7SnpU4ImTZow8ZOvsmxmaINTLdffLCKYRVqE1sLqkp7KSSXx8vJiRMfBhblkbwUzvvuOG3cf5K9tzQE5alszUBgz2MJ8CoK3QY7fJnktjDy5kP5sc51THtcCIiU1jR9+3kDfvn0pUaJEgev9J+NtrblgyW1ar149zp07R7t27bKYN2YQ2IyUJ3FxcURGRpKUlIROp6Nnz57Z+pPJZFJaGLA8R2vVqoW/vz9OTk7Y2try+PFjzp8/j4ODQzYNb0bfCoUCpVIpmfNnHH+TzImiyBdffCF99/f3x8fHx7LBqVCgVqtRq9W55sJ8s29naxWbahfj94p2NHGywiyKzH2Rzopwy/tHQ0clPTxUAOyJ1WHCokHLSEkzYcIE3nnnHe7cuSPJnFlrWhDkt0FqNBoJDQ3l/v37uLm50blzZ+7fv0+DBg04fPgwqamp3Lt3D7PZzOrVq/Hw8ODMmTMsW7aMFStW4OLiwrNnz5g6dSodOnQgOjqa4OBgKlWqRLFixWjevDk+Pj7cunWLypUrc/68JXVPhn9s/fr1MZlMkrYzM6ytrSU/zPyi32YQ0V8iLXNb0UZOs3p1sLe3p1ixYlSqVIlWrVrRoEEDRFGUNK4Z+UpNJhPPnz/n4cOHkplsxr1gZWWFi4sLgiDg7e0tkVUrKyusrKxIT08nODiYkiVLEhYWxgcffECFChUICQmhQYMGyOVyOnToQNOmTUlISMBoNLJw4UJSU1NRKBTcvHmTly9fcu/ePYKDg9m1axeRkZFSyqUMTerJkycpVqwYnp6ehIWFoVarGTBgAA0bNqR48eIsXbqUbt26ZfEr9/DwwN3dnRIlShAfHy+Zjuv1elxdXXFxcaFevXp8+umnkmmxKIokJSVx9OhRTCYTNjY2+Pr68uOPP+Lj44Ofn1+2zZ0i/P9BEWl9A2PHjmX16tVs2LCBx48fM3ToUNLS0ujbt2+h2tHr9UybNg2tVov+USoCAmmPEwFQlbUDEVKfJTKmykBqe1QjcuUzopY8JWnlC6LXBmFKN2X3b8ww08nQFBnBMUjFVy2H0yqpPoQZ8HT2lIhGxov3mxpTc6qRhTWncWvMacJXPiHgl9ts3bhFIoOiwdJPxndTmuVf7ZFYKlasyPHjx/nmm2+oUKEChmMJuc6BIU6HaDRjfJiGt2cxFFo5tv6OiK7geDIrWYRMpD7BiDndRGevVpT1s+SLHVTvcz7r8Clz2k/hI21LzBoTZfG3jC/WIq+oN2PWmDDEaiHJRPS2YOIPvCT1bgKR64NyMPUV/3BDNVn+lh3TELP1OYlXozCFaUm5FWfRjBrfWLBea1pFo5lTh05y4udD7Bm6mW0D1/Jg0VW0YWkYIrUYU/ToYi0k3Rin49WrCHTJWkK2P0IVIqDbEUvkhkBCpt9GF60h7VYCZn0BdtNFy3WR2yrBJJIWmCidchYsmgfp+osCRiczHUu3pkKwLymRSRQr4wvHUhCSXs+d1ow2OBVTgp60ewnYnDKTciMW0+ud4wzSnv4gmaCgIBSRIjKtgMqkJHZnqDQnhjgd8QfDKR3owYvNj1Eqldy4cQONRkNaWhrNmzenQbHanFp/xBJcQSfHrBTRR2l4ERLKoEGDcHV1ZebMmXzxxRcoFAoWLFiAg8YGB+ywMasxphks19FDjiiKRO0Mwf+RC6ZoPXFxcbRv357ly5czaNAgYk6G4SCz/N6Szke+VqBbNhtiNwajP5OIeN+SX1Gj0fDkyRN2795N7N4wye84Zu9zy29OKcMYquX333bgkejMsWPHKFmyJAsWLMj/er1ltGjRgmbNmjFtwYo/5QcniCJpuZi6ZRCwH39aw+CvJhVIu3Pi3EW6fD6YwJDQnAu8LWJbUPzZNjPJYzabGT5hClPmLsy57Bv+rhu276Ln8C9JSU3Lrl19XT4tc27EQhBWUZCxfON2klPTmDx5cmFH9R+Nt7XmGgwGvv/+e9LS0rh48SI1atSQIqY2b94cmUyGwWCgb9++vPfee5jNZmQyGfb29shkMkwmE+XKlaN27doAUlqTDAwfPhwHBwf8/PyIjIzkiy++wNbWViIUmX9L69evl8ilQmHRXG7evJmIiAi0Wi0JCQns3r0bmUyGj4+PVHbo0KGAZc1+8eIFGo2GChUqcOjQIb777jsqVaqEnZ1dtlRAmXO1Ari6urLl3cpUxEKMI4wCv1iX5GySgTupRuINZtQygTKv81afNNni7OzM999/j6+vr9TO/PnzcXd354cffgBg4MCBADRv3jxLfxnjKKyFmLOzM+XLlycyMpJJkyYxatQobty4QWhoqKR9z5jXlStXEh8fT0pKCocPH2br1q00btyYKlWqsHz5cp48eSLJ8vjxY86dO8fNmzc5fvw4ISEh3Lp1S9L6xcbGsm/fPs6ePYtKpeLmzZvZZMvYVMggUnlh1qxZALw0CkTpzcgFAb+kCK5evUrjxo25ceMG1apVIy4uToruXLJkScBCSo1GIz4+PhiNRhQKBaIosm3bNmk+Q0JCsLGxoUSJEgwZMkTqt1ixYqSlpWE0GqlUqRLBwcHI5XJu3bpFamoqaWlpNGrUCA8PD44cOQJArVq1ePrUsmH88uVLevbsiZubG9OnT5fu6QULFuDo6MiYMWMYMWKEtHHSrVs3Tp48yfPnz6lcuTIKhYLw8HC6dOnC2rVr6d+/PzExMXz77beUKlWK69evExYWJmnSX758KY1JJpOh0Wh4+vQphw4dIioqilWrVtG/f38MBgPJyckYjUZ0Oh0HDhzA2dmZQ4cOUbx4cWbPnl2o+6wI/zsoIq1v4JNPPmH+/PlMmTKFGjVqcOfOHY4cOZItUER+uHfvnuRf0bVkOzCLpF2Jw5RswKAwYkywJMZeuHAhAQEBlPQpwbzv5jJ+/HiLT8ZvUa81aIJEIgWFXCIrnoIrVhoFG7/4mcH1evPgxj0pNDvn0nCQ25F41vLQN2tev3SaQTCINJbVokuXLjx79ow7d+7g6upKQkICri9tMGuMGM4lYdaZkFtbcr0mHAhHSDVjDNBgY2PDp59+yurVq6lVqxYqlQrDSw0CkHA2AgBTmsX8KHnfK9CLrPhsPmHLHtJBfAfhaBpPV93BR+2JWWMhValX4wCQWckxphg4OuJ3mjnV48dBfzyYBEFgUP3PsVPZ8uO8H/E7Zc+8zy3O+KKr5SGoDUlFiDLhYXZhbt/vqNmnEZVcyiG7okXzNBlNUAq6V2kWjaAZC/F87eNjSjNiSNSTXsKIuoI9Sddj0Op16CLT0QengyHnRcuUYiQ5OVnaATebzSQlJUGkkQ1DfsLN6ETy1WjMOhNJ12LwlXsi04LMIJCYmEh0dDQajQZRbyZidQDqsnYk7H+FIVaXq4mzaDJb7g0BtKGpuJxSIDPISH+UiCFRz0d1OiMkighpFu0gAggpIhsHrST2cRQTa3/BtZ0XUNa2xy3RAZVOiRioJ+VmHOl3E9G+SmN0r5HY2drhJ3q/7tTyTw33ynh7e/Pll1+ifGSiWJAThnAN5nQTghmiNgehVCpJDk/Ey80LPz8/qlWrxunTpxkwYAAPHz7k3r17dOvWDYDY7c9RxguItzSkpqayZ88ePD09OX/+POfOnaNUqVJ4eXnh5eXF9HfG0cb5HQBs4pQgiqReiUWXpKW02p+pU6cSEhLCypUrMZvNnD17FplMRhfbVjjGWJN0NUbyx9WHa0hOTmb1qGWMGTMGJycnqlWrhrW1NcuWLcMmXE5Vm/JYiUqMMXrkMZYJiNn7AoPBQLVq1diwYQPFixfn0qVLeT8M/gYIgsCMGTO48+Axu4+cKnT9B0+e0frjPnwxcUauZfYfPcnToBBiYmPzbe/g8dPIFXIu37hdYBl2HTxKrZYd2XngSIHrAIybNpvW3T4nIbEAvs6vCWhcbBxN2n/EwDFf53g+J5KbmpbOnYePOXk+0/XNIzDTjn2HSU5O4VlQSNYTr8ufOHeJdz/qw+ylPxfaRDgxKZkfV29i4MCB+Pv7F6rufzre5ppbsWJFKlWqRK9evYiNjZW0rRs2bJBMJBcvXszdu3cpXbo0c+bMYfz48dSuXRs3NzciIiIkc1SDwUDp0pZNU0EQ8PT0xNHRkQULFqBQKLh48aIUDdfR0ZHdu3dLvngjRoyQguf4+/vTq1cvPvvsM8LCwrhx4waOjo6kpqbSokULy9rr6gog9S2TyShVqpSU57RPnz4sXLiQypUro1ar0Wq1WfxpExMTcVYI9POxpbSLI+unT8QjynIfTkmyofW1CKI8S+Lo6IgZOJb0hyVJkMbIyTsPmTZtWq7RqL/88ktatmzJN998A8CZM2eQy+UoFAq8vLxo1qwZYWFhzJs3j3r16hX42iUlJREQECCZEQcHB6PT6SQNd0bAJrCYyGaYgiclJWFjYyNpHRMTE7GxsSEsLIwBAwZIkWiTkpKoXLmyFPwnKSmJqKgo0jNtHmk0mkIH46patWoW8+6RI0dSqVIlXFxcpLltotRRq1Yt7t27x4oVK1iyZAkuLi6UKlWKXr16ZTETNplMTJgwATs7Oz766CPAYp5sbW1Np06d8PHxYdSoUeh0Oolwms1m7Ozs0Ol0yGQy6d4tXrw4lStX5sCBA4wbN44nT54QFBREhw4dEASBK1eu4Ofnh5ubGykpKRw6dAgfHx8uXLjA+fPnJQ2/m5sbXbp0oU6dOoAlh/HWrVuRy+XodDrc3d2ZP38+r169YtmyZZjNZi5cuCAFzGrSpAlms5mGDRvy6NEjlEol8fHxLFmyhG+//RZHR0eqVq2KnZ0dy5Ytw9HREbVaLVmReHt7S5vdGo2GMmXKsHnzZsqWLcvFixcLdb2K8L+DItKaA0aMGEFoaCg6nY6rV69Sv379QrcxevRoRo0axZ07d0h5mYTqlQwh3kzM9ucgQuL5SOzs7Fi1ahXVq1encePGjBw5kkmTJnHr1i3C74ViDtEhms0W37/XAWNFgxmSTGjCU6mkLM28efOoUqUKRqORwMBATp06RfjpEIwb4ki/aNESytSWhVQVJkCaSMrdOAYOHEj37t1p3bo1DRs2ZO/evdhFqPih8wyM99NJf5qMCKTejsfwJI3En16Qnp5OVFQU69atY/r06Tx9+pR69erRwbkFpJpxfGwFZtGi/TOL6F9oGOven42/bESlUrFu3TrOnj3L06dP8fDwYFw5y45hFU0pUu5YzDiTj0dR3q8sG8euQi7LfSE5f/48VfwqvyZlAjKTQJWYknzu9SFT3xvHhedX6Nq4M2N++pr9+/cjl8vRBCZjjNVjTNSDALrwNMt8mkVkChmpt+JI/u0Vhhca7Oq6En0gFKfq7tRtUJeY3/7QIJl1ptcmw1DGpjjHjh0jMjKSESNGMG3aNAYOHIguIJWVJ9YRmxRP2u14ojYHoQtPJ7GinvjLEdIOYmaTI3OqCUOMDrmnCkOsltRHFi22MVlv8QcGTKkGzBoTqdfiSL0Zh+yZkYDrjxGua1H52GIVaqa4qx/3p11EaZJjvJeGPAo0x+IoNawa5tY2zLmzjGJNS+Jk58S4/mNJvBCFaDBjStYTe/QliFC+fHm2bt1KQuhrwiIAZpFnN55QoUIFmjdvjm2wnHv7LTvU0fOfcrDrFgxRWj755BP27dtHvXr1UKvVzJs3j969e5OcnEyVKlWYOXMmTk5OWFlZkRqYyHtp9Ui+HYsgCNy4cYNbt24RHR1N5cqVWbhwIcOHD8fe3p5DG/YTe/UVVlZWPF//CIcLMlKORUt+S/Pnz+fcuXPcu3ePevXq0blzZzZu3Mhvy7eSeiAaY7wet3QHRLNI0t5XyOVy5s+fz549e1i9ejW1a9dm5cqVpKenExgYSP3UKgxw+9gyvrVBVDOWRUwyodVqCQsLY9CgQXh7e/9rqTTeeecd2rRpw9ff/4jmjZx6+UGlUmI2izg62OVqLrx24WzmTh6Ht6dHVrKWQ1Td774ew7A+Pfnsw44FliEtXYNCriAtvXA5LAOfh5Ku0ZKalp5/4dcwvE5nkZqaVmDtroO9HT/N+44NS+bl6fOboVVdPX8mXw3tT+1qlS0n3qijVqsxmU3Y5xXwJ5c+ZixaicFoYuLEiXkP9L8Ub2PNHTlyJCNHjuTx48fExMTg5OQkaVCLFy8umRquW7eOypUrU7NmTcaMGcM333zDtWvXCA8PlzRS3t7ekjkmWDSZ58+fp2LFiixfvpyqVauSkJDAkydPuH37Nq9evWLq1KmSLC1btsRsNlOpUiUMBgNBQUGMHTuWrl270qFDB+rWrcu6deswmUyEhYVJvoOBgYGARTubmJiITqcjPDycJUuWsGDBAkJCQqhSpQrjx48nPj6emjVrApbIsSvK2jHMy4pfSyux3TAXgLOpIsuPXyAiIgKFQsHu3bsBeFG5Mb9G67iZYmBeuAFPT0/JsiU3HD9+HC8vL6ytrREEgVq1avHee+8xbtw4BgwYgCAIfPXVV1y9epWjR48WKGiUXq+XIj4rFApSU1NxdXVl//792cyg582bx/Xr1xk3bhw7d+4kIiKCiRMnMn78eEaOHIkoihw+fJh9+/ZlqRcSEkJMTAwmkynbmpuBzClcckPGeFxcXAgJCZGIta+vL7a2tty5cwc/Pz/OGixm4tUFDd0a1qJljcp8OXYMTZs2pXjx4mzbto0jR45IpDUjAJSdnR07duzg7t27khmsnZ0dly9fplKlSlK+3Rs3bkjRfnfu3Ikoirz77rvs37+f9957D5lMxoIFC/jiiy8ICAigXr16zJgxAy8vLyntTalSpUhNTUUQBG7fvs2VK1eIiYmhbNmyzJ8/n9GjR+Pk5MRPP/3EoUOHsLGx4fr169jZ2UlyOzg4MGXKFA4cOMDTp09p0qQJbdu2ZceOHaxcuVIilr6+vpKWVxAEVq1axfbt21m8eDHNmzdn9uzZpKenEx4eTmRkJG5ubshkMsLCwpg+fTqCIKDX64mNjaV///5Sbtci/P9EUZ7Wt4yMROd37tzh5s2blChRgrZt2/Lhhx9y5coVwsPD8etajrD9zyjtV0oK2T9p0iRq1KiRpa02bdpg/Z4L+vupPCgeilwlRxeRjnWonHQrLamnY+nTqzfBwcHY2NgwatQoDh48yLJly/D09CQ8PBy30aWR2ykxa034P3HBZAvau0no9Xp2796Np6cnI0eOJDg4mDJlyiCXywkNDeXsnfNU7FWbh0uvopAr6Nu3L15eXnz55ZfY2dlhMpm4evUqFy9exGA00KZzW6Z/M40bxZ+i8rbBlGIgZlEgycnJVK9enYiICJYuXcp7773H8OHDmTt3LmXKlOHg6UNcO3OVzVu3oO+owuOcNTdv3CjwfFeY1QA9eio4l6PKc39sbGz49ttv0Zn0DN71JekGDTt6rmXHbzsYuGAEjs08SX+ahGNDD9IeJCBYybEpY49ZayL0u3uAJeKh0WjEt1lJlI0cid4STOqLJIpPq44gEzAm6VG6qkAQiNsaSmW7cnTq1Indu3fj4OBAeHg4L168wP5DL8wGM9HbXmteZKBwssIYn3sicef3i5F2PwHnVsWI3vEc9w/80cfocH7HE01QCmaNCfFMKppiZhRyOWhFmnzegt+G/ULt+nX4YMInvFf/XVqUaUq1cY1ITE7EFKJFWdKG38dvok7pmixevNhi0lpNjbeNByM6DmbckWmkHooGgyiFla9QoQJl3qlAUPEoUk1pCDrQrI7g1IlTtG7dGicnJ1q2bMnPP/9Meno6zs7OJCQkULFiRapVq8aVK1e4dOkSO3bs4NWrV5w4cQKtVsurV6/w9/cnMTGRFy9ecPLkSVq3bk2bNm0YPHgwc+fOZfr06Xz//fcEBgZSokQJTCYTDx8+RCaTUaZMGa5fv86BAwdo3749np6etGvXDjs7O2JjY0lJSWHo0KHs3buXvXv3EhgYyNWrV2nZsiWuvm58Pm8Qi3pY0mb4+vqi1+vx8fEhLCyMlJQUypUrh6Ojo+QLdffuXRwdHQkMDMTR0ZEuXboQFRXFxIkTmT9/PgMGDKBXr17/Ss64gIAAqlatysSRg5g8emj2An8iQFOO+Vz/KnKRIy09HVubfFJEvEHktFodKWlpuLtmMokswDg1Gi1WVsqCaVXy0YT+Kb/g/LSruZx/EBBInXaf8P333zN+/Pi82/h/iIw198GDB1y5coWqVavSpEkTBg0axK5du4iJiaFMmTKS35+zszOlSpViyJAh2YIoderUiTZt2nD58mW2bNmCk5MTSUlJkgmrXq+nb9++hIaGolAoGDFiBNevX2fOnDk4Ozvz6tUrSfNlNptp164dOp2O5ORkEhMT2b17NyVLlmT06NE8fPiQcuXKAZboqvv376dFixacPn0apVJJz549cXBwYPr06djZ2WE2m7lx4wbnz59H9TKIpiSzJVnGD+s20drZiu9LZd0MiTaIhPacQNc+/Rk9erRkxXXhwgWuXbvGypUrefbsGaVLl5bIckEwYcIE5s2bx7p163jxwrKZ/d1332ULLHXmzBneffdd6burqytxcXE5tpmRg9Pd3R0fHx8eP36MTqfLYpbr7u5OSkqKtBnQs2dPtm7diqenJyEhIYSHh6PRaP5UsKr84ObmRmxsLHK5HLVazTfffMPXX39N7dq1mTZtmpRjuEOHDly4cIGlfnIqqf6QPd2rOP3vxZBuhooVK9KrVy8GDx4sBR5SKBQkJydTuXJl6tWrR8uWLRkxYgRlypQhMDCQK1eu0KpVK+RyOT169GDBggWkpKTg7u5OTEwMlSpVom7dupw4cYLz589z5swZbt++zdWrV0lKSiIyMhJ/f3+MRiOPHz9mz549dOvWjdq1azNr1iwmT57Md999x/z583n06BH+/v4IgsD9+/cRRZE6depw8uRJDh48SIcOHXB0dKR79+6YzWbS09OJiYlh2LBhnDp1is2bN/PkyRNCQkKoW7cuDg4OHDhwgHfeeQc7OzvKlClDYmIipUuX5vnz56SmpkoBm3x8fHj48CE3b95EoVAQFxeHWq2mbdu2xMXFMXHiRBYtWkTPnj3p379/UZ7W/4co0rT+TShZsiT9+vWTTCB+//133NzcEASBL5sOQy1T0bhxY9q2bYtSqaRGjRqcOHHCYloKhIaGkpyczKM1NzFEatHcS0Sts0J/LwX7cCuaKGozZOBgoqOjGTduHHPnzmXZsmVcv36dUaNGsXTpUpydnUm7m4CNqCb1VjxPzz5i1+xfuXr1Kg8ePKBs2bI4ODgwbtw4lEolQ4cOZeLEiSQlJWGI1XF/0WVMRhN2dnZs2LABNzc37t69y5gxY3j//fc5cuQIdevWpVHDRnw7bjKhoaGk30kAARKOvEKr1dK4cWPCw8Np0aIFcrmcfv360aNHD8qUKQNA+3fbUbVqVRztHdBtjqFD+/aFmudP6n6AjcqGgU17MW/ePKZNm4ZcLsfGypof2k8jTZfGl/uncMXmPtZONkRtDMKxhAsCAjZlHbEuYYcogjY0DbvarsgdXgc5UFshNLJFfy4RVZoChUJByrVYki5Ek/4s2WKWJYImMo0bN26wYMEC0tPTOXfuHE+ePEGn0+Ef70nao8Q/hDWThbBmpGDIDE1gCnY1XCxBnNJNRG8JwRCpIe7QS/SxOhSOVii7uGBOM6J0UFG+dRUa1KjHvZhHPLr3EFc/d7zsLf5O1kYrPJ/Z845fI5o1bMro3iPp0qWL5NtDgI5Y12S2b9+O3FpBg9r1EQSBChUqoFKp0Gq13Dx7g9pe1cAsYojTYdAZCQHt1gAAbT5JREFUaNSoEYmJiTRq1CiLaZu1tTU2NjbY2dnh4ODAlStXSEpK4ty5c8yZM4cTJ07g6+srmQHVqVMHhUJB586dJbPqn376iT179jB//nx++uknrly5glwuZ/PmzdSrV49y5cpJPj8dO1q0etWrV+fUqVPY29sTFhaGt7c348aNIzk5mXHjxjFx4kTWrVuHq6sr8eFxXFx0AlEU8fHxoXjx4ly+fBmTycTUqVOpVasWCoWCuXPn0rVrVxQKBc7OzsTGxlKzZk2LuXGXLowdO5Z58+ahVCo5evRooe7Zt4ny5cszevRo5q5Yw/Ow8OwF/kQu0Bz9Mf8qctHS5khY88mPqlarshLWzHXygLW1On/Cmk87ec5NXnX/JGEVRZHRU+dQulQpRo8enXcb/8/h5+dH//79cXZ2pmrVqqxatQp3d3dkMhnTpk1DqVTSpk0b3n//fVJTU2natClnz54l9rX5e2xsLFFRUSxfvpygoCDkcjmtWrXC2toaV1dXGjZsyJgxY4iIiGD48OEsXbqUDRs2cPLkSfr06cPKlSsls9gMv8Nbt26xatUqLly4wNOnT6lcuTI2NjaMGzcOlUpF3z59mDbxGxITEzGbzZw4cQKTyYRarWbTpk14eXlx//59xo8fT6tWrdi9eze1PJxocHknxvOH6HL3IGVsrRhUzKLd+zVayzq9AxfT4DePqvhUqEyPHj3o0KED1atXB6BJkyZUrVoVe3t7vLy8eP/99ws1z3PnzuX+/fv06dOHqVOnMnfu3BxT/DRv3lxaGzw9PZk2bVqe7VpZWREdHc2LFy9wcnLKpml1c3OzxAjR63n06BGzZ8/GYDBw6tQpnj59Snp6Oo0aNcqzj5zW3IIgNjZWir7bpEkTJk2ahFwu586dOxJhzZCxevXqXC5dHxz+SG9jExnKBA9L/6GhoRw4cACZTEaNGjWQyWTUrFkTa2trEhMTOX78OBUqVMDKyopHjx4hl8upV68esbGx1K5dm5SUFCmQk52dHVZWVlIe1osXLyIIAr///juLFi3i+PHjVKxYERcXF8nkXKFQ8Pnnn2M0GjGZTMyZM4fdu3ezdOlS5syZw82bN1Gr1axZs4ZmzZpRpkwZ6Vp07NhRIrH79++XAmGVKVOGCRMmEBYWxrRp0xg3bhwrV67E19eXlJQUJkyYIJkNu7i4cOfOHfR6PTNmzJBMhGfMmEGPHj2Qy+V4enqSmppKlSpVAIsCJ2OTWKlUcujQoUJfwyL8b6CItP5N+Oabb4iMjGTNmjW8//77DB48mMjISORyOcuXL8fb2xuZTMaWLVuIj4+nevXq9O3bl/Lly/Po0SOWLFmC0Wjk2LFjPH78mJRT0ajum7GPUfPixQsUCgWlS5dm3bp17NmzhzFjxuDs7Ezv3r2ZPn06bdq0oUaNGiRdjCZiTxBJJyOlRSrzYnDixAlGjRolmTuVKlWKLVu2ZAkscfjwYe7cuYODgwObNm3ixIkTxMfHs2LFCiZNmkSFChXw8vIiKCgI0yMNhmgt2gfJvPPOO1y/fh21Ws3QoUPZsWMH+/bt48MPP8wyV1WrVqV8+fLEx8fTuXPnQs3zhOZfUNm7Au+WyR6y3svegyWdZxMQG4hMkNGnZ298qvvzrl8ji7mrQkApUyJDQGZjeZl171YCwVWBa88SmOONvLwYgp+fH0ajkfhD4SQce0X6w0RLWhgRjAl6DAYDWq2WBw8eoNfrUalUGI1Grh28RNq93ANV5ZQHTfs8FbPGRNKFP1JAGON1WDvaYojQkHwlhugNwdiXdMLF3plLc08wuEFvNt/aAUBkSjSer0mrt40nVZvWoFLLanSq1ZYLFy6wc+dOvv/+e8uLXbkqOFo7cObBeRQGGVqtlgULFiCKIj179uTly5cYk/ScPnsG5UuwU9qg0Who164d/v7+pKamWoIpvY6Oqdfr6dy5s7QYq1QqxowZQ69evTh9+jROTk5UqlQJR0dHdDod9erVk/LG2draEhkZSZ06dZgzZw6ffvopoaGhPHv2jDVr1vDhhx/SoEEDSTOhVCqZPn06crmcTp06SXn2Fi1axKpVq7h+/Tp9+/bl8OHDeHh4YDKZaNy4MYIgEBAQgEwmo3v37hw4cICdO3cyePBgevbsSffu3albty5Dhw5l+PDh0oumUqlEq9Xi5OTEzJkzCQ0NxdnZmVmzZrF8+fJC3bNvG99++y0uLq6MnTYn98BKfwIZBO1vIbEZyMXc+K2095bq5DsH+ZHVvGTJ5/yvew9x9soNli5bliMxKMIfGDduHGFhYaxZs4b27dvTt29fEhISsLKyYtasWbi4uKBUKvn1119JTk6mbt269OjRg4oVK3Ljxg1WrlyJRqPhzJkzhISEoFQqCQkJwcHBgcePH+Pu7o7j/7V312FRZf8Dx98zdIpKtyghCAomBjZ2x4qKjdjduga6dreuusba7RoYa9faYmFjoogg3XN/f/DjfpcVFXfFPK/nmUe5c+OcgZkz555zPp98+fj99985evQo3bp1Q09Pj5YtWzJ9+nR8fX3lkdsVK1bIKUMcHByy/e5OnTpF165dKV3UCc2JPXjdvjK/jx6crTO1adMmQkJCsLGx4fc1a7gUvIv8b16wc8VSUmcPQ5GeOZ1VC4kNLnrYa6uRppK4W6Q0i64/ZnykGv7Dx7J48WJ2796Nn59fttfK3d0de3t7Xr16RcOGDT/6tS5WrFiuOn87d+6kUKFCBAYG0qZNGwoWLIi/vz9ubm7Z9ssaHTUyMuL169cUKFBAXpea5fbt2xQuXFieLpqamsq1a9dISUmRR2qPH39/NPWc2tx3+XsQLqVSSb58+TAxMWHPnj3vPMbOzi4zSF6rdnj9eQ/3vddxmLcFAA8SKWFrScmSJdm1axdGRkakp6czZ84c0tPTadKkCZGRkaSkpNCoUSNMTU1xdHQkPj6emjVrYmtri4aGBjExMaSnp6OlpUViYiJVqlRBS0uLEiVKoK+vT9++fencuTMHDx5EX18fT09PtLS00NPTw9XVFUNDQwoUKICOjg5xcXF4eXkxf/58qlevTkxMDJcvX2bVqlX4+flhb2+Pt7c3b968QUtLS25zq1WrxuPHj9HW1mbixInMmzePS5cu0aNHD7Zu3UqxYsWIiIigSZMmAISGhqJQKGjWrBmHDh1i3759+Pn54efnR8+ePXF2dmbo0KF07NiRa9eu4eDggIaGBhkZGRgYGDBz5kxu3bqFubk5w4YNY8WKFbn6HQrfH9FpzSO+vr506tQJY2NjLl68yNy5c7G0tMTd3Z3Q0FDq1avH06dPuXPnDv3798fMzIzHjx8zceJEKlWqxObNm1mwYAF2dnakpKSgr61Pyp14NNHA3t6e5cuX8+jRI9q0aUPNmjXZsWMH7dq14+TJk/z888/cu3ePKlWqoIpNJy00EUU61KxZUy5fcnIykydPZtasWaSlpaGtrc3PP/9M3759ef36tfwhqKmpib29PU5OTrRs2ZKDBw9iZGRE27ZtuXr1KhERETRv3pzmzZuTmpqKsWFBns2+Rb58+fjtt9+oVq0atra28rVyWudSpEgRXr16hYeHxzvzlL2LrqYOG9ssw0gnX47PO5kUZnfHdfT07kTDSvWpVaMWHiVKoK5UQ6lUICky07S4aDmQcD0aKV2FRSdH0ICIbWEAXLlyJds5U54kokpTQaqEnrYudnZ2xMXFoaamRsGCBT8qmquamhqGhoZy+HoyJBJPRZH8IB5zc3M8PDxIi05FYaaOvkd+Mu4noUiDQtEW3Nh8KTMtg15BktNTSMtIJzrpDQV0jAAoXLAQCiM1jt87TXn7MvL1rKysOHjwIOfPnyfxWgwVhvtiq27Fy5cvadiwIYULF+bKlSt4enqSnpxGqioVk4f6JL1IYPDgwZw5c4ZffvmFly9fUqxYMQwNDXFyckJDQ4MpU6bw/PlzYmNjqVChAgYGBmzevJkTJ05QtWpVEhMTGTZsGI0bNyYjI4MGDRqgUCgICAjA2tqaDRs2sGbNGvbu3cvBgweZN28ehw4dQqVSyWtd7ezscHJyYu7cuTg6OhISEkJ6ejohISF4eXll/l3o6srrtTdt2iQ3ullfPqytrTl69CgxMTFs27ZNblz9/f158OABNWvWpFq1alSsWJESJUqgo6NDeHg48+fPp127dixYsIDWrVtTpkyZj/hrzRsGBgbMnz+fPw4eYe22P3Le6RN0CP/ZiX3X46vxvnW4uezcfrCjmtPxue04f+D55y8j6Dd2Kq1atcLX1/f95xJo2LAhPXv2RE1NjdOnTzN//nxcXFxwd3fn5s2bVKpUiRs3bhAaGsr48ePR1dXl8ePHLFy4kNq1a7N06VLmzJkj59TMWjunq6uLqakp8+fPJzk5mZYtW1K6dGn++OMPAgICuHTpEiNGjODWrVtUrVoVhUIh59P8exqd1NRU5syZQ1BQEFpqSmpf2YvG63Ck1BRe/twVM10tOdCSubk5Tk5ONG/ShFKntzFFM4LhinDW2EgYKzKIVGgQ3nkMGX/7+zyZpGTS/EX4+vpiZWXF1KlTmTFjRo43O8zMzIiNjcXLyyvHHKWfSoUKFRg4cCBt2rQhf/78ODo6ytFue/XqlW3frGnUALdu3XrrXBoaGujr62emlnN2ltvcrLXLuaVUKjE0NERLS0u+gZ/1b9aIOkBcXBxKpRItLS3U1dWxtbXl1q1b752tYW9vT8GCBeURT01TS/J7V8OgtA9KwOPVPUJCQrh06RI1a9YkIiKCxo0by0HAihcvjkKhIDw8HBMTE6Kjo+WIyqNHj+bZs2eULl2afPnyUaJECVQqFbNnz+b169dER0fj4+ODmpoa69at4+LFi1SvXp07d+4wefJkatWqhUKhoFWrVkiSRKtWrXB2dmbTpk0sXryYM2fOsGXLFlatWsXmzZtRU1Pj1q1bhIeHkz9/fry8vJg9ezY2NjbcuHEDSZI4fvy4vNZWW1ubatWq0aBBAxYvXiwHUMr6jmNiYsLFixeJjo5mw4YNtGrVCoBGjRoRGxtLzZo1qVixIo0aNZLTSj18+JBx48bRr18/li5dSs2aNbNNORd+PB9eKS/8K6tWrcLIyIgTJ04wffp0lEolvr6+XL16FQMDA2rVqkV0dDTJycksW7aM8ePHo1Ao6NSpE0WKFMHOzg47OzsAXFxcCA0N5fHjxyiVSszMzGjZsiUbNmyQE49fu3aNsWPHsmTJEiIiIujfvz8uLi7yXUlJkihcuDB16tRBXV1dDo1epkwZIiIiOH/+PM+ePePevXts2rQJHR0dzp07h7GxMadPn6ZRo0asW7eOqKgoKlSowOLFi6lZsyZeXl4cOnSIxMRE9PX1iY2Nxd3dncjISOzt7Tl06BAhISFkZGS8M+pl1miZqalproI3fCylQolDQXscCtpTYUhmJ8OsoDEjD0wiQ1Khqa6BWSlrbDu78mL3QzLi0lClqlAl5Lw2RkpVkR6VQpoq805zZGQkhoaG6Ovr8+LFi2z5+N7VgdXU1KRMmTKoq6vTtWtX6tWrx+nTp2ndujXR0dGoq6tz7do1ZsyYQcjkEOIuvM4cHEadMePHMHTo0GznK2buwo2XofJ1AYrZFGX7k2BeJERgaZgZlTIlJQUtLS3U1NRYtmwZoXdusznlAG3KNmDO4dkMGzYMHx8ffv31V3R0dHjy5AkVgmoROKQHY2cH4enpSb169VizZg2RkZHcunULMzMzeYpsUlISTk5ObNy4EScnJ/z8/GjcuDFKpZJBgwahrZ05RTM+Pp5OnTqxdu1a9u3bR0xMDGvXrsXFxYUlS5ZgbW2No6Mj6enpLFy4kJ9//pkiRYpw//59du7cyYABAxg9ejR79+6lY8eOODg4UL58ee7cucOxY8dwc3OjQoUKPHr0CH19ffT09IiKisLJyYnbt2+zdu1ajh49irW1NeXKlcuWY/GXX36hRo0aXLlyBX9/f0xNTdm8eTONGjWicePGLFy4ECsrKy5fvkyxYsXYt2/fv/mz/KSaNGlC27Zt6TdmElXKl8HawjznHSXVv1rn+jHe1dHLk7WyeeS9ndV3ye1NgVzsJ0kS3YaNR0tb54uP5H8rVq1ahba2NufPn2fkyJFoaGhQv359duzYQcGCBfHz82P16tWkp6ezbNkyRo8ejVKppEWLFtjY2FCwYEEcHR0BKFWqlJyuQ6lUUqBAAZo1a8bGjRsxMjIC4N69ewwePJglS5YQGxvLqFGjcHV1RalUyiN67u7u1KtXT05hk5GRQXnP4niEnsKQeNIkUFOAMiWJxibaTD1zBnt7e86cOUOxYsU407UxHuqZI46pEmgqIFZTj+H34hiUz4Q/YxT45YPnkjqb42Bg0aIEBwdz8+ZNEhMTcXFxyfG1UigUtGjRQh6By0t/j0g8evRoevbsSevWrRkxYgR79uzh4cP/RdvOajtzajezRla1tbV58uQJBgYG6OvrExERQUZGZsTerLXEOVFXV6d06dJoamrSsWNHGjVqxJUrV/Dz85Nnwd24cYOFCxdy5syZbMf17t07V2lW7O3tuXTpUrY1wikpKZj59yLu/HEaGoJmjYa4urrK6WP69++Pt7c3PXv2REdHh5iYGOzt7Zk+fTqtWrXC0dGRbdu2sWrVKt68ecOpU6ewsbFh37598t+alZUV+/btw9bWlubNm/PTTz+hpqZGv3790NTURF1dnXr16tGkSRO2b99OvXr1iI2NpU+fPri5uTFs2DBsbGxwdXVFpVKxbNkyevfuTalSpbhz5w5r1qwhMDCQwMBA9uzZw+DBg7Gzs8PDw4P79+9z9OhRihQpQtWqVbl37x4mJiZYWloSGhqKl5cXFy5cYN68eZkxXWxscHd3z7YWdcKECVSoUIFTp04xbNgwLCws+OOPP/Dx8aF9+/Zs3boVS0tLQkJCuHnzJn/88Y6bs8J3T4y05pFRo0ahp6dH8+bNKVy4MFu2bOHo0aMcP34cT09Pbty4wenTp2nSpAmdO3fOFi3Rx8cHW1tbkpKSeP36NbVr1yYjI4PBgweTkpLC4sWL6dGjhxytUKVSMWjQIDkFR+nSpdm8eTO7d+9GS0sLX19f1NTU2LRpE6tXr6Znz57UrFmTq1ev0rRpU5o1a0alSpVQqVRcvXqVlStX4uHhwV9//YWpqancIZkxYwb6+vq4urrSv39/atSowaFDh4DMyI0WFhb07duXwoULU7RoUbk+Hh4ecpTDd+nTp4985+1zaOrREJt8ljiZFWZRs2msbLWA8+MOU71YZdKjU7N1WHNa6J8WkULq0wQ5F1pWZGWVSpWZ3/P/77ZnyRoBhMyGNSgoiBMnTnD48GH8/PwwNDSkdu3aPH/+nEGDBhEYGIixsTGTJk2ibNmypIbGk3wrDm9vbwYPHvxWeUrbeLH64kaM9f631q94EXdupz6gcLI1ly5dYvny5bi4uMg56WrXrs2hAwfZ6v8bHX/qwPPnz1m5ciUnT56Uv0jcuHEDfV19Bk0dirdrWVauXEmpUqUYMmQIWlpanDx5knz58skBNv7880+ePXsm/z1n5UcE0NPTQ5Ik1q1bx/Xr10lISEBDQ4MGDRqwbNkyqlevztq1a5k0aRJ2dnY8fPiQvXv34u/vT7NmzbC0tMTZ2ZnIyEg6derE06dP5QAOTk5ONGjQgOnTp2NqasqCBQvo1KkTKpWKESNGcOLECapVq8aUKVMwMzOjRYsWxMbG4uPjQ/369alXrx7Lli0jNTUVXV1dtLS0OHbsGK9fvyYiIoKaNWty/vx51NXVWbRoEbq6uqSmprJkyRJ5rdiXNnfuXPT0Deg6ePT7R/s/xTTcf+FTjMrm9ajuO8/7KUZVP+J1/23TDvYdOcGvv/76Vg5OIWeZ0+QLUKdOHYoXL86uXbvYtWsX58+fx8PDg0ePHnHlyhUaNmxIgwYNqF69unxsuXLlKFKkCMnJyURFRVGvXj2SkpKYMmUKSUlJzJw5k59//lm+WShJEgMGDGD58uUULlwYT09PNm7cyJ49e1BXV6du3bpytN7FixczfEA/Blqos9Y8mW6hwZQnM/rpL5Fq/PYmc+SulrEOFy5cwNjYmFMH9/N44gB0b/yFJMGFErUI7TGN1uGaNL0Vz8M0BUOHDmWnyogz/qNZ71gVrArJNyxdXV3lVCXv0rVrV9q3b58Xv4p3qlOnDvfv32fChAno6upy+fJlfvrpp7f2+/vU3CySJMmBfxITE0lKSpI7rFlt7t+nLP991pZSqWTAgAGcPn2aI0eO0L59e4yMjKhSpQpPnjxh1KhR+Pv7Y2Zmxrhx4+Tfn0KhwNPTk/Hjx+eqfnZ2djx69AhXV1eOHz/O+vXrKVq0KFfTNNAws0KRkY7t4Q1E7lpHtdJevHr1ilWrVnHp0iV5dPnGjRu4ublRsWJFKlSowKZNm/Dw8GDYsGEYGBhw9uxZLCwsePz4MQBnz54lPDxc/o6VFT8EMmccZa1xPXnyJBkZGaipqVG3bl1WrlxJ2bJl2bx5M9OmTcPe3p6nT5/yxx9/0LRpU/z9/bGwsMDe3p7k5GQaNWrEixcvcHV1xczMDAsLCzp27MikSZMwNjbm999/p3379rx48YJJkyYRHBxMuXLlmDlzJkZGRnTt2pU3b95QtmxZOnbsSO3atVm4cCFJSUloa2ujra3NsWPHePjwIdHR0ZQtW5ZLly6RL18+pkyZgo6ODhoaGixevFhe6yr8eET04E8sK5Jh1hfkGzdusGvXLipXrkyjRo3w8PDIzMspSbi6ulKrVi0mTpwojzCuXr2a1atXo6uri7a2NlpaWly/fp2QkBA5SfnDhw8pWLAgbdq0ITAwkBMnTmBkZPRWjrWAgADWrFnD8ePHqVixIsOHD2fcuHEEBgYybNgwChUqRKNGjVi2bJkcwMDBwYGDBw+ycOFC5syZQ6tWrdi6dSuXL19GW1ubQYMGZbvjmJycTKdOnTh27BiOjo5MmDCB6tWrs3DhQjp37vz5Xvh/YcX5tRTQzU9jt7rZtmetu826e5uTfJVMQYKYkxEolcpsnQQ1NTV5zUlWJMmnT5/i6OhIYmIiRYsW5dChQ3I6hQ+5fPkyZcqUwd3dnZ07d2JjY/PWPklpyZRfUId9nTfKgZjevHlDq5HtWD5iEZUqVaJixYo4OTlx8OBBjh49Ko/sjx8/ngIFClCgQAGKFi2KhYUFCQkJckCkP68d41WZJLqZtObZrcw73CdPnmTx4sX06dOHV69eMW3aNKpVq0a5cuUwMTGhdOnSeHl5MWDAAIyMjHBycmLixIl07dqV+/fv8+bNG2xsbDh48CCnTp1izZo1NGjQgHbt2rF7925GjBjBy5cvcXd3R6VSybmB09PTyZcvH4cPH5bTWdSpUydbCgHIzHsXFhaGvb094eHhREVFsXjxYhYsWMDTp08pUKAAfn5+cnqE6Ohodu7cyZo1a8jIyGDq1KlMmDCBIUOGMGXKFPnObteuXXnw4AG7du1i1KhRGBkZ0bdvXznK6JeOZBgcHEydOnWYMnIgAwI7froT5/Ho7Kfyb0ZzP9j5fVdn9YOF+Xc3Bm7cuUf5Rv781KqVWLuVC1ltbuXKlZkyZQr3799n+/btlClTBn9/f4oWLUpCQgIATk5OVK1aNdu02S1btrB06VK5vdXR0eH27dtcuHABdXV1NDU15bzrXbt2pXHjxty/f5/4+Hg5b2lGfCyqlGTGzZrL1KlTOXXqFD4+PrRr147JrRpwa3gAWukpcpkV+QoyKxJOxqbj7eZCv/CzqCkU9E8oQMfK5XA6vxft//9TPmbpwYBdR+Vjk5OT6devH3/88QeWlpYsX74cLy8vJk2alOMNzW/BsWPHqF69+nvb3L/753rarDZXU1OT1NRUFAoFT58+xc3NjTdv3uDm5sb27dvlkfQPefLkCQ4ODri5ubF58+ZcH5eamspPP/3E8uXL8fb2xtPTU56Ns21Id56O7yPvq13ImVK7r1C8eHF5BtLatWtZvXo1Bw8eREtLi8qVKxMXF0dqairnzp1jzpw5TJgwgVu3bhEUFETjxo3lpQNlypShQoUK9O/fH0NDQ3m0tk+fPty4cYO4uDisrKzYsmULjx8/Zs6cOVSrVo1evXpx5MgRBgwYwLNnz3B2dkZLS4umTZuybt06YmNjMTExYffu3ejo6CBJEr6+vgQHB2ebKi1JEvfv36dQoUKEh4eTkpLC2LFjWb16NU+fPsXCwoJ69erJgyAxMTHs3buXZcuWIUkS48ePZ9q0afTp04fp06fLwZaGDx/O4cOHOXbsGL/88gspKSmMGDGC/PnzfxVtrvB5ienBeeS3337D1taWUqVKZbubmZKSgp6eHlpaWly+fJnffvuNUaNGMWnSJCZNmsSTJ0/YsmWLPAUJYPfu3bRo0YLAwECWLVsmR+RbtGgR/fr1o3DhwvTo0YOVK1eSkJAgd16fPXuGjo4OmzZtkqcHS5Ik5xjbvHkzVlZWDB8+HD09PSpVqoSLiwvHjx/nwYMHtGzZktGjRzNv3jwGDRoEwMSJE7PVU1tbm9GjR9OvXz+MjY2xtramePHiHx2R8EvoVLpNjtsbNmzIqVOnKFeu3DuPTbgcTWam1sz1MFlrdcLCwtDU1JQD90BmwngLCws6d+5MVFQUkZGRue6wAnh6ehIXF8fLly9z7LAC6Ghoc6jrNgrq/i9ioZGREeqPVFhZWVG7dm3y5ctH0aJF+fXXXzl16hQVK1aUR8vt7e1xc3NDR0cHHx8fnJycWLRoEadPn8ZIS5+RNUcSvGY38+bOY+vWrfTq1QtTU1MWLlyIt7c3wcHB2NracvPmTQYNGoSPjw+rV6+mW7duHDlyhKSkJEqUKIGDg4McSdvR0ZEtW7awceNGHB0dKViwIDNmzCA6Oho3NzeuXLnCsGHDsLW1lXMkSpJEcHAwDx8+pHDhwpw4cQJdXV2OHDmCi4sLixcvJjw8nO7du8vpCG7cuCGnFFAoFNjY2HDy5ElKliyJJEkoFAqCg4OZM2cO48ePx87ODnd3d9avX8/OnTszc/JKEqtWreLRo0e0b9+eoKAgGjVqxIYNG6hRo0auf5d5rXbt2gwZMoQRk2dQqngxfMqV/jQn/pgO2Bfs4H7S0dd/01n9jyPYsXHx/NR9MA4ODsybN+8/netHkzXqWbZsWVq3bi1vT0lJkb/YXrp0SV5eMH/+fObNm8fFixdZt26dnHcTMm8Uent70717d5YuXSp/7s6aNYvBgweTP39+xo8fz9atW3l9+jClz+1ClZRASd0CGOjqsnbtWjIyMqgffZcHg9uhBSjz5SfKtzUbr91D38ScC8HBtG7dEltbW87PPE05AzVm6UXBxX2ggAS9fAy7+pwTf/2ZrZ7a2tqMHDmSmzdvUrRoUTQ1NSlbtiz1PjLy/tekcuXKXLlyBQ8Pj3fOElFTU5M7terq6jg6OpKamsr9+/fR0NCQAxNBZttnaWlJ3759uXLlComJibnueEJmJOqEhASePXtGoUKFcn2cpqYmaWlpFChQgEaNGpGWloa7uzvLly/nL4UhFYIWc2/mz6i/eUXyw9u0L1aIUG1typQpQ61atViwYAGnT59GU1OTFStWMHjwYFauXMmuXbvo1asX1tbWzJ07lxIlSrBnzx5Kly7N2bNn6dKlC3Xq1GHVqlV06NCB8+fPo1Kp8PT0zAzm9fvvODk5YW1tzdatW9m3bx/FixfHysqK6dOnk5iYiL29PefOnWPy5MnyjRpzc3OKFSvGli1bCA0NxdPTk6tXr6Kurs7+/fspWbIkS5Ys4eHDh3Tt2hVvb29mzpzJ8ePHkSSJ9PR0uc0NCQmhWLFiqFQqlEolx44dY8qUKYwaNQpHR0eKFy9OyZIl2bRpExoaGqSlpbFr1y4uXLhAhw4dCAoKonr16uzbtw8fH59c/06E74sYaf3Esu76vusOkJaWFitWrKBnz568efMGyJzPHxwcjIuLC48ePZKnHtWtmzkCOGPGDCZOnEhYWBimpqY8ffpU7rhmSU1Nxc7OTp4q3KpVK6pVq4a5uTlTpkyhVatWlCtXjhEjRtC7d2/S09MxNjZGXV0dlUqFv78/Dg4O9O/fHzs7O27evMmRI0cwMDDAx8eHEydOMG3aNLnz+k9Zib1PnDjBxYsXOXDgwKd9Yb+AKVOmMGzYMPnn962XUSqVKBQK1NTUyJ8/P5IkkZCQQEJCAn5+fqxbt44rV67Qvn17hg4dmu1LVV5q164dhQoVIi0tTb7hEBQUxMmTJzlw4AAvX75k8ODBFClSBAMDA0aNGkWjRo1YvXo1zs7OTJ48mbVr17J9+3bq1q2b4/pNX19fLl68iIODA48fP+bFixfZ7oRLksSjR48wMTGRpysBtGjRQr5xM27cOFQqFcOGDcPQ0JDSpUvLX1KGDBlCcnIy8+fPR6FQULBgQTp06MD48eMpW7YslStX5tixY6irqzNv3jzMzc0ZM2YM9+7dw8vLi59++okVK1bw7NkzDhw4gJqaGt26dePo0aPo6elRr149wsPDmTVrFvXr18fHx4fQ0FBOnjyJvb09xsbGNGvWjODgYHR0dHj8+DG9e/fm6tWraGlpUbhwYVq0aPHV3PVNT0/H19eXm9evcX7vZizMTL50kTJ9I6O1H5225hNNtZYkCb+eQzhw4iwXLlyQI2UL75ebNnfPnj00btyY+Ph4ILPzuWPHDnlKpIaGBp06daJmAS0iNi7lkaRJyy1HePXqlZwD1sHBIdt5VSoVdYtYEZQ/BbW/Dfxt1bCg9pRFLA9sTR+9RFAqOYEhWymIfkFjDAwMSE9Pp379+pQvX57AwEC8LQrS4t5R+RyhWvlpf/oB/QYOZPr06TnWW5IkTp8+zcaNG7l58yYHDx78V+lcviZr166lbdu22ba9q93NmlmjVCoxNjZGpVLJbW6dOnXYu3cv9+/fp3HjxvTp04eAgIDPUofu3btjbm5OZGSkfONpyZIl/Pbbb5w9e5a4uDhWNK5MxZgwYkxsaHTyAT4+PuzevZvixYvTv39/tm7dyu7du6lbt26O6V1atGjBoUOHKFq0KKGhoURGRr4VjCordZCBgYH8dxEYGMi+fftYtmwZs2bNIjk5maFDh2JgYECZMmXQ0MhM+Td69GiePHnCihUrUCqVWFhY4Ovry9KlS6lUqRJubm5cu3aNxMRE5s+fj4ODA0FBQVy/fp1ixYrRqlUrtm/fzr1799i5cye6urqMGDGCTZs2YWhoSJMmTbh9+zaLFy+mWbNmlClThnv37nHixAns7OwwMzOjQYMG7Nq1Czs7O27dukXXrl0JDQ1FqVRSqFAh/Pz8vpo2V/h8RKf1E3tfAxobG4ulpSWjRo1i4sSJcqQ8yGwAfX19+eOPPzh9+jT+/v5s3ryZChUqUK1aNcLDw9m/fz/Fixdn48aNb0WTnDdvHitWrGDkyJHyGsm0tDT8/f1p2bIl06ZN486dO3h7e3P69GkqVKiArq4uGRkZxMXFyWluIHOqzrJly0hPT8fPz4/AwEAyMjKIiIh4b92zOkalS5eWO9zfMkmSUFNTk+/8zpkzh5s3b7JkyZK39s1K+6JUKilZsiSXLl1CW1ubhIQEVq1aRYsWLT538YHMKTiBgYGsWLEC3f/PiZmeno6ZmRnh4eFoampSuXJl0tPTKVKkCPv27SM+Pp5nz57J63WXLl3KzJkzadmyJcuWLXvr7zosLAxPT09sbW2pU6cOkydPzlXZIiIicHd35+HDh7i5ubFp0yZKl/7wyOCQIUPYsmULDg4OpKen4+rqSuXKlblw4QL37t0jISFBXuuqp6dHfHw8YWFhPHz4kNWrV2NjY4O1tTVOTk6UKVOG4OBgRo4cKSc1j4+Px83NjUqVKnHhwgVWrlxJlSpV2LZtG1WrVsXHxydbHT/0pflLePnyJV5eXthbmbN/7a9oa2t9kXJs2b2f6JhYAtq85+//K+jM/nX5KoeOnWJgYMe3X6s87qxmmb74N4ZPnsPWrVvfSgsmvNv73n8qlQoDAwOCgoIYPXq0PE0YMj/f69aty4YNG7h16xbT2zRmeP7/pVkZGWfI+rOXKenowMoqrlg7F8V+zAKUmpl/H1tmTcHq9yloKuBqfDoXUtXpXACSNbRJHzoXjV+6oSWpuGxTnEkhjylbtixGRkZyW7pt2za5zb1y5QqXBrTDMf4FqtLV6LTnDJHRb3jz5s17O6KSJDFx4kRcXV3lCOjfuqz0NQADBw7E0tKSgQMH5rhfVpvr4eHBjRs35EBG06dPf2u51OeSmJhIp06dWLJkCfnyZWY1UKlUmJqa8vDhQwwMDPCrVZ1Bry8jAa3DtXgS9Ya7d+8CmZ3w0aNHs2zZMjp27MjEiRPfmpkVHh6Oq6srhQoVokyZMixevDhXZYuPj8fe3p4XL17g5OTEsmXLqFat2gePmz59OnPnzqVw4cKoq6tTrFgx3NzcePbsGefPnyc9PR1ra2tMTEzQ0dEhPT2dW7du8ejRI+bPn4+npyfW1tZYWlpStWpVdu/ezZAhQwgLC+P06dNER0fj7e2Nm5sbDx48YPHixZQuXZq9e/dSp04dXF1dWbRokVyer7HNFT4P0Wn9xLLeTCdPniQuLk4OMw6Z03xHjhzJw4cPUVdX5+nTp3JH4vjx4xw8eJABAwbQvHlzGjduzKJFi7hx4waWlpaULl2a9u3by4F5/hlR0s3NTY7Gt337djna6cyZMzl79iylS5dm1qxZxMfHY2pqSrFixejUqRMWFhZ4eHhki9qblpZG/fr1GT9+PCtXriQtLY2lS5d+83dx/41atWrJo8YqlYqnT5++FQW5efPmPH78mKdPn2JgYICdnR0ODg6oqamxYcMGnjx5go6Ozpco/jtVr16d6tWrM2LECFJTU9HU1KR+/fr06NGD7t27M3LkSLp27coff/zBs2fP6NatG0uWLJFHHf+pcePGxMXF8csvv7x3WvU/FSlShKJFi/L8+XM5QNSHREdH4+TkxMuXL+V1Q1mNdmxsLFpaWmhpZe94+Pv7c/bsWcaMGUN0dDQjRowgLCyMggULEh8fz4YNG3BxcaFixYpcuHCBy5cvy3fmW7ZsiYWFBaNGjaJixYrs2LEjW6Cxr7UBPXv2LFWrVqVBjSr8Pn/qR6WFyEn0mxgOnThDQ99qaGnlLmdoydrNUFdT48D65eQzfDu4yn/yXzu7f+t0NuzQHQ11Dbq3a0UNn/I57vPPbcfPXsAonyEeRf/7iOimP/bTpvdQRo4cyYQJE/7z+X4kWe+/s2fPEhkZSZ06deS/9YsXL9KqVSuioqKAzFQqpqaZa/4vX77M2mVL6Was5FzwbhxJRpmRJp/3sZYRil7j0ZvRnwJkBubTK14Gp4U7SHnygLOtfDBERZSuEU3PPWNvcDBRvRtjrfW/dX5RKgU/3U+ngIkJRYsWpWvXrlhYWFC8ePFs+dJVKhW1atVi6tSprFq1ihcvXrB+/fofss1t06YN69atAzJnkKWlpb0V4bhly5Y8efKEsLAwDA0NsbOzo3DhwiQnJ7Nnzx6uX7+OiclXMsPk/zVr1gx7e3tmzJhBamoqoU28SHv5nJQ2/Wg7byVdunRhxIgRHD9+nLNnzzJkyBDWr19PcnIyHTu+HZ/A39+f58+fM3To0I9KieXh4YGdnR13794lNDQ0V8ckJydjZWVFREQEPj4+ODg4sGbNGiAzNZCGhka2CPwA3bp149ixY3Tv3p38+fPTo0cPbt26hbW1NUlJSaxfv55ChQpRpUoVrl27xokTJ+jRowcKhYJu3boRHx/PkiVL8PLyYvXq1dmClX6tba6Q9778Le7v1JQpU5g4cSKnTp2St50+fRoPDw+mTp2KlZUVJ06ckJ9bsWIFAQEBjBw5knHjxtGjRw/S09Pp06cPurq6lC1bltGjR9OqVSv+/DP7Gpe7d+8SExNDo0aNCA4OxtPTk7Fjx6KlpUVMTAyVKlUiICCADh06oFQqKVu2LFu2bKFevXp4eXm9lWZGQ0ODwoULo6amxu3bt5k1a9YP2XhCZkRWdXV1LCws5LUZ8L9AEAULFmTcuHE4OTnh7e3NoUOH2LNnD6Ghody8eRN1dfWvrsMKmXdOFy1axMuXL1mxYoWcj7BUqVJYWVmxfPlyAO7cuYOzszMA9erVY/fu3Tmeb9y4ccyaNeujOqwAP/30E8HBwfIXydzInz8/pqam9OrVi6dPnzJt2jT5uaz8e/80atQo1NXV2bBhA9OnT6dEiRLyFHt9fX26dOki5yssVapUtqlk/fr1Y9++fWzfvh1tbe1sHdavWbly5Vi3bh1b9uxn2MQZ//l8v8xdwubdwfy2aVuujxk3sDe9O7X9pB3We2GP+fPEmdznYc1FftZxg/pQsYzX/9YAvy9aMBAZFc3IqXMJHDYuxzIqJFWuHyfOnqfjwFG0bds211FKhbeNHTuWWbNmZZtOefz4cVxcXJg+fTpFihQhODhYfm71kkW0DjtJzJ71OGfEocxII1ylxk6PukgS2Ka84emUwXKHFSDh6jmu1nTiZtuqGKJCs4grnW+9oXT5CgwcMpRFL7OnSXvh0xSlhgZubm7s3LmTBg0aUKpUqWwdVsgcXStVqhRxcXHcvHmThQsX/rBt7qRJk9DU1KRAgQJoaGjIN/azXg9DQ0MGDx6Mq6srZcqUYd++fQQHB3P37l2ePHmCJElfXYcVYNq0aaxdu5bXr1+zYsUK9MtmjnDmu3ICc1NTuaN+584dilpb8HzpFKrYW2T7m/274cOHM3XqVGrWrPlR5Wjfvj379+8nf/78H975/2lra1O4cGECAwN58OABs2fPlp8zMDB4q8MKMHLkSJRKJZs2bSIoKAhHR0esra0B0NHRoVOnTnJeYw8PD3r27Cn/jgcMGMDx48fl5UhfQz504esgOq15JDk5GVdXV7p06SJvCwkJwcvLi27dulGuXDk5ImlqaiqvXr3i+fPnpKenU7FiRdTU1OjevTsbN27Ez8+PESNGcPr0adq1a8erV6/IyMiQ70IGBgZStWpVgoKCqFixIv379yclJYWKFSty8OBBqlSpgr6+PsbGxujp6bF8+fIPNojt27cnICCAsWPHoq+vn6ev1dfM2dmZmjVrvjW9N2uCgrW1NUWLFmXNmjVs2bIFa2tr1NXV6d69O69fv8bd3f1LFPuDPD09MTY2plu3bly5coU5c+bg4uKCqakp+vr6PHz4kPPnzxMaGiqvrbO2tub58+cEBgYycOBAAgMD5VQ3v/zyC23atOHRo0cfVY5Xr15Rvnx5Ll++/FHHdezYkW3btrFo0aIc0yP8k7OzM35+fgQHB5OUlMSoUaNyfa3y5cuTmJjIoEGD+OWXXz6qnF9akyZNmDt3LrOWrmLOsjUff4K/dfJa1PdFU0OdWj7lP9gJzFK/ZhXaNmv4H2uRXeCQ0UxduJw7D8I+2Tk9ixWlf9cOaGqovT+1zf8rYJSPsp4e+DX63zKIv3dEc+vGnfs0DRxIpYqVcvW5LOSstIE6BZPeUMzNjV69esmfzxcvXsTDw4OOHTtStWpVOXKpSqXC+OZZpJfPSFJqULBRW+x+nsvLrkH8uu9Pnhtm3kTzVs8MpjfxlQLbWRtQqGugSoyH9DQeaubjYDFfCrm6M3jwYJKSksCzIlfV8oGxBZbdR6AqUQFNTU02bNjwwZkO/v7+9OrVi8GDB//QaY5sbW1p0qQJ9evXz7Y963dqZWWFp6cny5YtY8eOHRQqlJnqZ8CAAURFRX1U4KTPycHBgcKFC9OuXTtu3brFjjcqJCD5xkXmpd+hSdoLTp8+zeMrF7CcN4TwpVN4OaIjSfFx9OnTh4EDBxIQEEB4eDiQeeO5Xbt23Lx586PKERERgaenJ/fu3Xt/arR/6NatG7t27WLGjBlvxVTJiY2NDd27d+fs2bNERUW9lVv+fZycnNDQ0KBz584MGzZMfC4KMjE9+BPLmrYQERGBiYkJtra27Nu3Dzc3N1xcXFi7di0lS5Zk165dBAUFceHCBQ4cOMClS5f4888/WbFiBdbW1vKbdOvWrVSpUoWCBQuSlpZGpUqVOH/+PObm5mhqahIbG4uVlRW7d++mVKlSXLx4UR4N3LNnDxcuXODBgwdy56Jz587fzdqXz+Xy5csYGBhQpEgRIPuaG19fX/mL0D9FRESgrq7+1X4BOXjwIBcuXGDAgAF4enoyatQoWrduTYsWLYiKiiIxMZGUlBQuXrwo/z326NGDvXv3YmxszMiRIwkJCWH48OE4OjpiYWFB2bJlmTNnTo7Xu3z5srzuJYuTkxNr1qyhVatWbN68+YO5BbMsXLiQ5cuXc/78+VxPe1WpVLRs2ZIdO3Zw9uzZXF8L4Pfff6dDhw7ExsbKd/6zfAtTlYYOHcrUqVOZO2EU3dt9IB/yp87h+onXrC5fv4Vzl68xd/zIXE9Tfq/31fcDr8XHdFD/6ebdB9RoHYiFlRXHjh2X178JHyc2Npa71ewBMChVicZHbrFg3lyKvrhDnzmLaR80jXr16nHu3DnatWtHaGgoZ0+cQDW0FVqpSej2GItzh17y58ju3bspZqjF6wGZ+UOfK7RpdjkCQyMjbI0MsEyJQZGvALN2BOPj48OBAwfkvJEnTpxgz549REZG8uLFC5RKJU2bNqVDhw5f4qX5Zt26dYuMjAz5dc2KygtQqVIljh8/nuNxkZGRANkiQX9N/vrrL3bs2MH48ePx8vIiqJwLNpcyc91nAEHqhSid+pr6yv/FO/nLvTpTj5xHT0+P2bNnExwczLRp0yhcuDA2NjbY2dnJU3X/6caNGxgZGWFlZSVv8/DwYNKkSQwaNIhZs2ZRu3btXJV948aNjB07lpCQkLdmCryLJEl06dKFlStXsn///o+KtL9v3z7q16/Pq1ev3voO9S20uULeECOteaR27drcvn2bypUry1Mto6Oj5Q9hX19fnj59CsCmTZt48+YNjo6O1KlTh59++gmVSsXly5cZPny4nKtv/PjxKBQK9u7dy+vXrxk4cCBPnz7l0qVLrF+/Hnt7+2wpUSpUqEBoaCirVq1i9+7dqFSqbzos/pfi6ekpd1ghczqpmpoaWlpaFC9e/J3HmZqafrUdVshMQn7kyBG0tLTkiMeQud7V19cXGxsbXr16Je+vUqkICQkhIyMDW1tbbG1tOXXqFAcPHkRbW5tZs2a9swN/+PBh/P39CQoKkrdlZGQQExNDyZIlqVOnTrZACx+ya9cuWrduza+//prrY5RKpRxheNasWbk+DmD9+vWMGzdOzuv6rZk8eTJ9+/alz6gJLFq9Ieed3jNi+p/kclQ2tzr7NWfJ1HG567B+5DTht459j0/RYTUzt+DQoT9Fh/UTibtwgkUFE0kf15Vnc8cyVPECp5AjSJKEQ+RDxmpG8HjqEELmBKGVmkSymgZt5iyjQYMGZGRkcPPmTYYNG8ayA8dwXLCdEJ+WTNWwZ8++fSQkJNC0Q2e23gtn66WbHD16lAIFCshtOkDp0qUJDQ1l2bJl7N69G6VSmWMMAOH9ihYtmu11NTY2RqlUoqWlJS9XyYmxsfFX22GFzGmuFy5cQKlUYmVlxcOi3risPEhKAXPUgJZaiTikxQGgZmgEgO31k6irq+Hm4oyGAm7fvs2RI0dQU1NjxYoV2ZaZ/d3Zs2dp27ZttgwIkiTx8uVLqlSpQvPmzXMMKvku69evp2fPntmmBn+IQqFAoVAwc+ZMFi5cmOvjIDOF1ZQpU9iyZctHHSd830Se1jzy22+/MWLECDp06MDIkSPlSIFZ6+20tbWRJInnz58TGhqKvb09Dx8+xNLSkqioKJycnMjIyJDDjJ89exYdHR2MjY2pVasWy5cvp3fv3sTFxWFmZsbcuXPf+kJtZGRETEwMkiTx+PFjLCws5ITqwr9Xu3ZtDh8+jFKpfG+n9WunpqaGm5sbISEhqKmpERISQps2bahXrx5jxozh8OHDeHt7c/v2bVxcXDh9+jQxMTFs27aNAQMGcPDgQVq2bMmsWbNwdHTE29ubyMhIrly5wtmzZwkNDcXa2pqOHTsyaNAgjI2N2bJlC9WrV8fS0hI1NTUMDAxQV1cnMDDwrRkAKpWKU6dOERMTQ/369dm2bRvx8fEUK1aMQoUKUb58eWbNmkVgYGCu6puamkpMTAw6OjpER0fn+nV68+YN+fLlo0ePHgQEBNCq1QdGKr9CCoVC7qj3GTUBSZLo0d4v88m86Kh+yIeu+bGjs5+yDnnYWYXMKcE123TDzNyCw0eOfNVfsr8V058k8PO8JcRPHYh+amK252K3ruB+ZDgxx/bhqAmvNi2j5P8/F6wsiFFBY9TU1ChcuDBKpRIfHx82bNjAzZs3USqV6BkaUrNmTTZt2kS7du1IS0vDycmJMWPGsHbt2mzX0tbWJj09nYyMDKKjo9HS0srV8gXh/Zo2bcrGjRtRKpV4eXl96eL8awqFgvLly3P69GmUSiU3btxAr39/bIdO5eXQdrglvIT/D8ngOHczoQH1sEhLYX1Rc6RHR1EMP0a/0jWZNm0aVlZWFClShISEBK5evcqZM2e4d+8e+fPnp1u3bvTu3Zt8+fJx8OBBdu3ahZGRETY2NmhpaaGnp0dAQADly5fPVj5Jkrhw4QKPHj2iefPmBAcH8+DBA3x9fcmXLx+lS5fml19+YfDgwbmqr0qlIiwsjHLlypGcnCznRf+QlJQUVCoVPXr0oGXLlnTt2vWjX2vh+yQ6rXnEzs4OFxcXkpOTefnyJaNGjSIxMZG7d+/i6OhIWloabm5uODo64urqStu2bRk+fDhLly7Fzc2NCRMm4ObmRpMmTejWrRvVq1cnPT1dnv7Spk0bChcuzLhx43jy5Ak///wzJUuWfKschQsX5v79+6xbt442bdp87pfhu1SyZEkuX75MRkbGNxOU511at27NmDFjsLe359KlS0iShI2NDWFhYRQoUIBmzZpx6NAhLl++zJEjR8ifPz+lS5fG3t6eQ4cOsXnzZgYNGiQHkNHV1aVXr14EBARw9OhRVCoVo0ePxtramhMnTuDp6ckvv/yCqakpZmZm8hcQZ2dnnj9/zpAhQ5g6dSqHDx9m0KBBREVFUbZsWV68eMGOHTtQqVSUKlWKkJAQgoKC5PdDbly/fh1dXV2WLVtGXFwccXFxufpCeenSJZycnGjWrBk6OjqkpaXlenrU1ySr46pUKun78y+8inzN6P7dv871Ql9jR5r/3mE9ce4STboOwNbOjj//PCw6rJ/IhohUFtZsxPrL13C7c4ZD1+9wTMOYlukv8NZXEnMsM6BLvFIDfVXmNFOVfj72xWiyYHZmRP4ZM2Zgbm5OmzZtGDJkCO7u7hgaGnL9+nUAGjRowJEjRxg9ejTbtm2jX79+VKlS5a2yFC9enKtXr3L8+PFv8gbX16h48eL8+eefpKamfhdt7qBBg9DV1eXx48eoVCqsqtXjvkIdfSkzkFe8fgGCb4cRZ+6C+5MQlOH/HytCksh/7gAvHqto1jszDZCxsTHt27dnyJAhHDhwAE1NTSZOnIipqSmHDh2iSpUqDB06FBcXF2xsbHBxcQGQB0i6du0qD4z06dOHZ8+eUa1aNSJfveLl+sXkT09mZ3wc9+/fZ9y4cbx8+RKVSpWrZTkPHjxAT0+P3377jaSkJMLDw7G0tPzgcdeuXcPR0ZG6detiZGSU67Za+P6J6cF5ZODAgQwbNowZM2aQlJREWFgYtWvXZtasWbx58wYbGxsePXpE9erVOXLkCKtWrcLc3Bw3NzcgM9pp1sjTgAED2LNnD2vWrKFly5byNcqVK8e+ffu4fv063bp1y7EctWvXZsGCBRw/fpyqVavmfcV/AObm5hQsWBANDY33TlX6FpQqVYoHDx4wevRomjRpwogRI0hOTmb16tWMGTOGqKgoVq9ezezZszl+/Lg8/bxBgwZER0dz/fp1lEollpaWHDlyBCMjI9TU1NizZw/NmzenSJEijB8/HldXV5o1ayY3mPPmzWPXrl1yPsrp06djbW0tr5EdO3YsqampJCcnc/v2bUaOHMm8efOwtLRk06ZN+Pv7s3XrVl6+fMmzZ8/eqpckSdnyIEPmmtrnz5+za9cukpKSCAkJeeuYnFy4cIFTp05Rrlw50tLScp2a52ukUCiYMWMGkyZNYsKcxXQZPFpeK/ZD+ogpy/+1w7p59wFq+XfH09OL48dPiA7rJ9ajRw86/DyeURFqzH2RxqWwpxx3KMsLbSNQKLmSokbHVzpMMSyGyc/zWV+oInqG+eRUGgMHDpRv7Pbt25c//viD1atX07ZtW/kaJUqUYNeuXVy7du2do021atViyZIl7N69mwYNGuR5vX8EpqammJiYoKWl9c13Wp2dnXn9+jWjRo2iXbt29OvXj6SkJMyatJP3WR6vxfTp05l27QlX9MzRL1mRuPoduP//w7C9TJSYmpry119/UVBTjU5qr1Esn8SgskXxMjZgpV8dFpinc66mC6N1ommpEce8oNFs2LBBDnC1cOFC7OzsCAsLY8CAAQwbMoSqqRH0MEwlOuQ8GfNGUT/xCRVSX/Hy94XUq1ePnTt38vr1a27fvv1Wvd7V5kZGRrJhwwaSk5O5cuXKW8fk5OLFi1y9epVKlSqRmJjI6dOn/8tLLnxHRKc1j9jZ2bF27Vr2799PQEAA6urqhIWFceDAAUqWLImPjw9BQUGEh4dz+fJlLl26RN++fXM8l5OTE7GxsVStWhUzM7OPKke9evUwNjbGz8/v6xxR+QZ5enpiZmaGvr7+W/njvjUKhYJLly5RpEgRevToQZEiRahUqRLa2to0b96cAwcOEBYWRpcuXYiLi8PT0xPIXA9rZmaGn58ftra2LFy4kNWrV3PgwAFu375N4cKFOXHiBFu2bGHgwIHs2LGD4OBgtm/fTlhYGA4ODsTHx+Pj40NaWhpHjx5l5syZXLlyhcTERG7duoWbmxtXr17FzMyMhIQENDU1qV69Os+fP6dDhw7o6upiY2OTLQ3PX3/9RZcuXShWrBhFixZlypQp2Z7Lnz8/BQoUoFChQhw5ckR+btWqVRQvXjzHkduzZ89iYGDAL7/8wuvXr9mzZw8jR46kadOmGBkZfXNBVhQKBcOGDeP3339n/Y69NOzYizcxsR8+8D9KS0vj6s3bHxWxMk/8fyf10ZOnREblbpr4f+mwSpLEjKWr8es9jBYtWhK8f79Yw5oHypYty7x589izZw8DBw5ETU2NBxGv6R+hTpvYAmyy8GTO3HmExSdzV9+MvWfO06NHjxzPZWVlhZ6eHq6urtjZ2X1UOXx8fHB1daVBgwZvpZMT/h1PT085ndnHpEf7Wp04cYLixYvTtm1bypYtS9WqVdFu0gGDslXZomPLgaev6datG2+SknlQsQnOS3ZRevB4dhkWRiWBpw6c2bSGTZPHMtfgDRUUCTjFPMPt8kECI6/icOUwZmkJFFClYJsaS0PNRCL7NMUwJZ5q1aqhUqm4um0dq+yU9H55AcPURFq+vkFL9Vhq62UwTiOCcrr/+5yuoxZLYLu2aGhoULRoUbZt+1/as8unTzLIvxUlShTHxcWFUaNGyZ/xWet3bWxscHd3l3PeQ2aQUVdX1xxvOp89exaVSkVQUBCJiYns3buXMWPG0KZFc2pZGvFz49znpRW+L+ITNY/07t2bgIAAjIyMePToEerq6uzcuZOLFy9y5swZBg8ejL6+PkuWLKFly5Y4OztTq1atd55v1apVb0Utza2RI0f+22oIOXBzcyMhISFX01y+BWpqavL/O3fuTL58+di8eTPdu3eXA42sXbuWokWLkpCQAGTmBk5MTGTnzp3MmDFDzjEH4OXlRWhoKAMHDnxrCpGamhqGhoZs3boVIyMjpk+fjrOzM40aNaJhw4YcP36c/fv3s27dOjn/3L59+2jevDlDhw5FQ0MDQ0NDOS9cp06dmDlzJhs2bKBAgQIcOnQIGxsb+vfvT8WKFSlfvjxJSUmMGTOGK1eu4O/vD0DDhg1ZvXo1o0aN4smTJ2zfvp1Vq1bRqVMnVq1alS2H3aNHj+jSpQsKhQI/Pz+CgoKYM2cOixYtwsHB4Zv9EtWmTRssLCxo1qwZ5Rq2ZuOiGRR3zbuZAxPmLOHclWv4Na5Lu+aN8uw6OfpHpzM6Jha/nkPQ0tLkyKYV7z30v3RY4xMS6TosiE27DzB8+HAmTJiQ62jXwsfp2LEjffr0Yfv27dy7dw9tbW3Wrl3L48ePOXbsGL169cLMzIyZM2fSoUMHzMzMaN68+TvPN3/+/BxzPufGu25AC/+Ora0t6enpWFpafhc33//e5rZp0wYTExM27trD0AVbie3Zk0Lpl1izZg2lS5eWRy9v3brFczRR966B6uwh+iTeQ4pNR5JUxKhpcUvPFC9tCZ2kODRMLChQpyXahZxIeXyPC7MnYBEXwzQ7bebNnkWNMiXpmvQAtfh0LDXA8uwm0AGUahiWq0rsmT+RJIkdhoWpnh6JYWIMqksnwKo1PXv2ZNKA3sTu2YCHRhpF4l/ip1DQJL8RBfoP59TUMZzfvxjTJu04e+ocNX0zO5h+VStyddFUEkI7kmxizd6FM9nQuTkDO7Rl3rpN5MtIIfy3WaQ8eUDCzYdUa9IKhUJBz4a1UF8zEzt9baTUFNQtlRB7h7lf4hcnfHEi5c0n9vdQ3FpaWowbN45atWrh6uqaY8LrkJAQ9u7dS69evX7ofKjfmlatWmFubv5RkfS+FUlJSTRv3pw9e/YQEBCAlpYW8+fPp3nz5kRFRdGmTRv27NnDjRs3yJcvH71795Y7gwBnzpxBR0eHEiVKZDvv8+fP0dHRYeXKlYwYMYKWLVuip6dHYmIiy5cvz9aQ/1NkZCSFCxcmLS2NChUqcPDgQQDi4uIoUKAAjx8/pmTJkvTs2ZMiRYrw22+/8euvv1K0aFEaNGiAp6cnS5cuZcuWLZQoUYJ9+/bRsGFDunbtioODA1FRUVy7do3Hjx8TFRXFtGnT8PHxkUeZt27diouLCytXrqRv375oaGgwePBgatSowfz581m5cuU3G37/wYMHNGvWlNu3b7Pgl1H4f+K8qll2HzrKzKWrmPbzYEq6u+bJNd7yjg5nWloabfsMx9rCjBmj3x1UJNcd1hz2C70fRovuQ3jyIoIVK1a8letZ+DT+3ubq6uoyYcIEvL298fLywtjY+K1OTmhoKDt37iQgIOCrju4uZNe1a1fS0tL47bffvnRRPrn09HTq1q3LgQMHGDZsGE+ePGHt2rV07NiRe/fuERgYyKZNmwgLC8NKA8apv0QtI3NZh26xkiQGjCFdXUOe6p4lIiICpVLJ3nVrKPRbELpqCq44lEbt5RPcE16gYWqJKjGejPjMjrHdz3MxbtSWlPAnxL6KwKWqLy11U+hipole8bK4LN/Hs5WzeTpvHOq5uHmwMVmXegvW4u1cmJDm5VAkZwZJU6mpo8zIXL+bAeyJV6OWlRFaMZmpGWMlJXqztuJVojgXG5dCPTbqfyfV0SMyHWqfffrNtrnCvydGWvOQlpYWEydOfO8+Hh4eeHh4fKYSCZ+Kr+/3Oz1FR0cHCwsL7t27R3R0tDw9LikpiX79+vHixQvWr1/Pw4cP6dChA3Xr1s12vLe391vnXLt2LRs3biQ5OZnu3bsTGhpK/vz50dfXl9dZbt68mcDAQDp16vTW8ZIk4eLiQlJSEqamprx69QoTExO2b9+Os7Mz5cuXx9bWVp5VYGtry+DBg2nbti337t2To3e7u7sDsGXLFiwsLIiOjmbRokXUrFmTiRMncvr0aU6dOsWgQYMoVqwY9+/fz7Z2efPmzRw+fJjdu3czZMgQFAoFNWvWZOXKlZ/yV/BZOTg4cPr0GXr06EGnAaM48ddFZowegoH+p536Xr9GFerXqPKfz3P99l3uhz2hUa1q797pA51NDQ0NNi6a/t59/u0IqyRJrNm2hz5jp2Jja8v58+fltdxC3lJXV2fs2LHv3cfFxUX8Pr5Bvr6+PHny5EsXI0+oq6vj6urK5cuXef36tRzoLyuI5/3791m/fj3R0dE0adIEs0W7YP8mdAo5Y9KyC4ocZm9s375dTgnXpk0bzAKGELdiGiUenJf3mRCpRkW/PrQvWxyFugaGZXwA0LKwQUsvH46OjjxIjAFekhBynuhDOwifPx51hYKn6QpeK7VovnQjukVcCRndi7i/jpCgX4CnMfGUJJ66mkmU9vLkfvdGcocVQJmRjgoFSm1t1JKTaKifATGvSUOBBhKGChVGe1cTtisF9dgopPwmnHKpRKfuPdF3KsaGzVvgbOs8/I0IXyvRaRWEf6Fjx45ffm1eHurSpQuTJ0/mzZs3aGpqEhUVRf78+WnY8H+jcC4uLlhZWZGSkiJvS0hI4NatW6SlpVGsWDEMDAw4efIk27dvZ8eOHWRkZNChQwc0NTXlnMFxcXEcOHCAEydOUK9ePTp27IhCoSAjIwOFQoFSqWTOnDlMmTKFu3fvcvLkSc6fP0/dunXZuXMn48aNY/jw4dnST3h7e+Pt7U1aWhpmZmbo6uri6OiImpoacXFxREZG0q5dO5YsWUJCQgKJiYlMmjSJRo0aYWJiQlpaGtWrVycuLo7Y2FgUCgXnz5/HycmJkiVLZovUnRXY4lumo6PDihUrqFixIn379uXI6XMsmxZEZe/SX7pob+k96hc01NVxLlwIlyKFsj/5iaIOf1SH9W/7vngVSfeRk/jj0DHatWvHggULxAwaQfgEmjVrhkr1BaKKfyYBAQFMnjyZZ8+eYWBgQFJSEtra2tmWjenp6eHi4kKaYUGKDJ8BIMeASElJwdXVFSMjIy5fvszy5cvZtWsXCoWCwMBA1KtXx8PNi8QblwA4omnK2mMXqF27Nj1690FdXR2VSoUkSaipqbF48WJGjBhBUlISb2YPxCgtkQfDOqEAEjwr0/fgZfbu3Yuha+asGa+564HMNDdWZiZssgUDpcSzEZ1IDL2KCrjYqDe/LpyPh1oq+j51eJGqoltBBQaXjhCeJnGrQhPC796mXdQN3hzaDkAGCtzmbqRU0RLy65D13UH48YhOqyD8C1lJs79XZcuWpVu3bixYsICJEydy8eLFHFMqjR07loEDBxIQEMCsWbPQ0dHB1dUVDQ0NZsyYQUJCAubm5vz6668olUqUSiUrVqygcePG2Nra4u7uzi+//EK/fv3Q1NSkQoUK7Nu3D2NjY4YPH46Ojg6LFi3i3LlzjB8/Hnd3dzmoU7ly5VAqlTRt2pS6desSGxvLtm3bqF27trz+W0NDg2rVqrFnzx45wvbRo0epWbMm/v7+nDt3js2bN/Po0SN5xkPLli1p0KABTZo0QVNTE2dnZx4/fsy8efPeGsV58uSJnBLjW6dQKOjcuTNVq1alY8eO1GjVmd6d2jB+cG/0/uV6+rzQtU0LLobcpLCddfYnvkSHNevSksTmPQfpPWYqahqabN++ncaNG3+S8giCkPn59L4lJN86Nzc3wsLCGDFiBPPmzSMkJCTHWXhjx45lwIABDBo0iBkzZqCurk7RokXR1dVl9uzZxMfHkz9/flasWCEHAlu8eDHNmzfHfmgQDs9vs29fMNbVG6OhoUG9evXYvHkzbm5uDBgwAKVSyfLly9m/fz+DBg0iOTmZHkvm0TPtFkokItR08J29mpsKNZKTk9m8eTO1a9eWU9IolUrqN27Kyr3r6WGhSeyZwwA8t3Wj09CRbD56kplbtvDo0aNsS4iuXr1Kx6pVM2c2FcpP2fRoJECjVQ/0/tZhff78+TcdwV/4b8Sa1k/s7+trxFx74VuWnJyMtrY2rVu3RpIkevToQaVKld7ab9myZbx8+ZKAgIBcByWKjIykVatWlC5dmoiICJYvXw5AfHw8TZs2RaVSsW3bNkJCQli6dCnt2rWjRo0aANSpUwd1dXUMDAzo2rUrVapU4eDBg/JI6Z9//snOnTvlmwoPHjygR48eVKhQgZ9//pk+ffrQs2fPD6Yr2rFjBwsWLGD27Nk0btyYdu3a8fPPP8vPnzt3jpEjR9KsWTO6d+/+Xb3nVSoVc+fOZfjw4RjnN2LqqIE0r+f7dd6o+QSd1f8SbCn03gP6jZvGoZN/0axZMxYtWpRj/AIhb4g2V/heZLW5AQEBJCUl0apVqxxn8qxdu5a7d+8SEBCAlZVVrs4dExNDy5YtKVWqFPfu3WPDhg0oFAqSk5Np1qwZCQkJbNmyhbCwMObNm0fz5s3llE0NGjTAWUrAPj0Bu8AhNGjSjOPHjzN27FgaN27Mnj172Lt3r3xTITw8nI7t29Mn4ylmMS+IKGiN8ci5lPap8t4y7t+/n4kTJ7Ji+XJ6NvClVJ2GTJg5W37++vXr9OnTh4YNG9K/f3/xnv8BiU7rJyYaUOF7ExMTw8iRI5k8efInneoYExPDnTt3cHd3l6MBA0RFRZGRkfHOL/6DBg3C3d2dBw8e0LdvX3r27Im1tTU///wzhoaGTJkyBWtra9q0acOTJ0/o2rUrcXFxaGpqcvjwYapVq0alSpVQKpWMGjUKNTU1wsPDOXLkCK1b/2+dzKJFi5g1axbLly+nePHiGBoa8vTpU7Zt20ZERATnz59n48aNKJXK7/Y9/+DBAwb078/OXbuoUr4Ms8YOpZiz45cuVqYv3FmNjYtnwrxfmfvbeuxsbZk9Z853MVX8WyPaXOF7k5CQwMiRIxk1atQnzeccHx/PzZs3cXNzy5auLzY2loSEBCwsLHI8LigoCGtra27cuMHYsWPp3bs3BgYGBAUFkT9/fhYtWgRA9+7diYiIoHPnzkRGRqKtpuSPxXNp2m8oFX18SElJYezYsWhoaPDq1Sv27t1Lu3bt5Juhv//+O2PHjmXBggV4e3tjaGjIixcv2Lp1K69eveLEiROsX78ebW1t8Z7/QYlO6ycmGlBByFvBwcFcunSJYcOGyalw/h41MTU1lQYNGjB69GgmTJjAvHnzSEtLo0aNGtSpU4f9+/ezfPlynj17xv79+2nRogWLFy/G1dUVW1tbBg4cyI0bN/jll19YsmQJbdq0oWbNmty9e5fw8HDat2+PsbExZcqUQalU/hDv+eDgYPr27cO9e/dp26wBI/sE4mBr/eED88IXnAYMkJiUxOLftzBtySoSkpIZOXIkAwYMyHbjRfh8foT3nyB8SadPn2bXrl1MmjSJtm3b0rlzZ6pV+18gvIyMDBo3bszAgQOZNWsW48ePx8DAgMqVK1OjRg3279/P4sWLSUxMZOPGjXTo0IE5c+ZQqlQptLS0CAoK4tGjR/Tt25d169bRvn17ypUrR3h4OPfu3aNjx44YGxtTrlw51NTUxHv+B/bDdFrt7e159OhRtm2TJk1i2LBh8s8hISH07NmT8+fPY2JiQu/evRkyZMhHXUe8mQQhb6lUKho1aoSenh716tXLlm4ny8OHD5k9ezY//fQT5cuXBzKn+3bs2JGLFy/i4OAAZCYx37FjB2PGjJGnQg8dOpSpU6cSFBREkSJFSEtLY8OGDbi5ueHl5fXWtX6U93xqaiqLFy9m0qRJREZG0r5FI4b3CsDO+jPmK/6CHdbklBSWrtvKlEW/8To6hk6dOjFq1ChsbGw+SZm+N6LNFYTvgyRJtGzZEk1NTSpWrEj37t3f2ic8PJzJkyfTuHFjqlatCsDx48epW7cuZ8+epVixYgBcvnyZtWvXMmbMGAwMDAgICKBDhw6sXLmSnj17UqJECTIyMti4cSNFihShTJkyb11LvOd/XD9Up7Vz584EBATI2wwMDOQpErGxsTg5OVGjRg2GDx/OtWvX6NSpE7Nnz6Zr1665vo54MwlC3nv06BHXr1//qCiCkiTx4sWLd06BAnjx4gXt27encePGOTbMOfnR3vOJiYksWrSIKVOmEB0dTbO6NejVsQ3lvIrn7YU/UYcVPq7TGh7xisW/b+HX9dt4Hf0Gf39/Ro8eTaFChT588A9MtLmC8P0IDw/n7NmzNGnS5KOPe1+bGx0dTZs2bahevToDBw7M1TnFe/7H9UN1Wvv160e/fv1yfH7RokWMHDmSFy9eoKmpCcCwYcPYsWMHoaGhub6OeDMJwo/lR33Px8fHs3z5cubNm8v9+w8oXcKdnu39aFKnOro6Op/2Yp+5wypJEmcuhbB4zWY27z2IpqYmHTp0oF+/fhQpUuSTleV7JtpcQRDygnjP/7jezkj8HZs8eTIFCxbE09OTadOmkZ6eLj935swZfHx85MYToFatWty+fZvo6Oh3njMlJYXY2NhsD0EQhO+dvr4+ffv25c6du/zxxx/kMzalQ/8RWJWsRqeBozh88iwZGRn//UKfsMP6IXcfPmbsrEU4V2mET/OOnAm5xZQpU3j69Cnz588XHdaPJNpcQRAE4VP5YfK09unTBy8vLwoUKMDp06cZPnw44eHhzJw5E8icFvjP6V5mZmbyc/nz58/xvJMmTWLcuHF5W3hBEISvlFKppH79+tSvX5/79++zdu1a1qxZzZotu7A0N6NutUrUrVaJquXLoq/3kfle87jDqlKpuHjtFnuPnGDfkVNcCLmBoaEhzZo1Y5m/Pz4+Pt91bsi8JNpcQRAE4VP6pqcHDxs2jClTprx3n1u3buHi4vLW9hUrVhAYGEh8fDxaWlr4+vpSqFAhlixZIu+TFRr85s2bFC1aNMfzp6SkkJKSIv8cGxuLjY2NmLYgCD8IMVXpbZIkcf78edavX8+ePbu5e/cempqa+JQtSRXv0pTzKk6p4m7o6X6gE/uJO60ZGRncunOPs5dCOHXhCvuPn+HV6yiMjIyoVasWTZs2pUGDBuh86unN3wnR5gqC8KWJNvfH9U2PtA4cOJAOHTq8d5+sKKH/VLZsWdLT0wkLC8PZ2Rlzc3NevnyZbZ+sn83Nzd95fi0tLbS0tD6u4IIgCN8xhUJBmTJlKFOmDLNmzeLu3bvs3buXfXv3MmXRb8TFxaGmpoaHqzNexYriUsQBl8L2uBRxwNbKAqXyv69ceR39htD7D7l9P4zQew+5FnqXc1euERsXn3ltd3c6dQmgXr16eHt7o67+TTeHn4VocwVBEIQv5ZtupU1MTDAxMflXx165cgWlUompqSkA3t7ejBw5krS0NDQ0NAA4ePAgzs7O75ymJAiCIHyYo6Mjffv2pW/fvmRkZHDz5k3OnDnD6dOnuXj1Cut27CUpKQkALS1NzE1MMDMpiIVJQUyNC2JooIe2lhbaWppoaWmhVChITU0jOSWF5JRUEpOSePU6mheRr3kREcmLV5HExMYBmdOXCxWyx9XVjWHDR+Dt7U3p0qXlKLZC7ok2VxAEQfhSvunpwbl15swZ/vrrL6pWrYqBgQFnzpyhf//+1KlTh1WrVgEQExODs7Mzvr6+DB06lOvXr9OpUydmzZr1UeH3Y2JiMDIy4smTJ2LagiD8ALKmJ75584Z8+fJ96eJ8k1QqFY8fPyY0NJS7d+8SHh7Oixcv5Ed8fDzJycnyIyMjA21tbfmho6ODqakp5ubm8sPe3p6iRYvi6OiItrb2l67iD0W0uYIg5BXR5v7ApB/AxYsXpbJly0r58uWTtLW1paJFi0oTJ06UkpOTs+139epVqWLFipKWlpZkZWUlTZ48+aOv9eTJEwkQD/EQjx/s8eTJk0/1kSUI3zTR5oqHeIhHXj9Em/vj+SFGWj8nlUrF8+fPMTAwQKFQ5Mk1su4yfet3lr+XeoCoy9foc9VDkiTi4uKwtLT8JGsxBUHIPdHmfpzvpS7fSz3g+6mLaHOFvPZNr2n9GimVSqytrT/LtQwNDb/pD7gs30s9QNTla/Q56iGmKAnClyHa3H/ne6nL91IP+H7qItpcIa+IWxSCIAiCIAiCIAjCV0t0WgVBEARBEARBEISvlui0foO0tLQYM2bMN5+r7nupB4i6fI2+l3oI/+Pm5saZM2feu0+HDh3Q0tKiZMmSuTrn1KlT0dPTE3lahXf6nj5Lvpe6fC/1gO+nLt9LPYSvlwjEJAiCIHw3OnToQJEiRRg1apS87dWrV3To0IGjR49ibW3NwoULqV69uvx8WFgYRYoUIT09/UsUWRAEQRCEDxC3lgVBEIQvTpIkJEnKk2iQPXv2xNzcnFevXnHo0CFatmzJ3bt3KVCgwCe/liAIgiAIn56YHiwIgiDkGYVCwbx587C1tcXc3Jxp06bJz3Xo0IFevXpRrVo1dHV1uX//PidOnMDT0xMjIyMqV67MrVu35P3t7e05efIkALt378bZ2RkDAwPs7e3ZsGFDjtePj49nx44djBs3Dl1dXRo2bIi7uzs7d+7M24oLgiAIgvDJiE6rIAiCkKd2797N9evXOXr0KDNnzuTPP/+Un9uwYQPTpk0jLi4OQ0NDGjZsyM8//8yrV6+oX78+DRs2zHHabpcuXVixYgVxcXGcPXsWDw+PHK999+5d9PX1s6VFcXd358aNG5++ooIgCIIg5AnRaRUEQRDy1PDhwzE0NMTFxYXOnTuzceNG+blmzZpRsmRJ1NXVOXDgAB4eHjRt2hQNDQ0GDhxIYmIi58+ff+ucGhoa3Lp1i/j4eMzNzXF1dc3x2vHx8W/lDDQ0NCQ+Pv7TVlIQBEEQhDwjOq3fiKioKNq0aYOhoSFGRkZ07tw511+6JEmiTp06KBQKduzYkbcF/YCPrUdUVBS9e/fG2dkZHR0dbG1t6dOnDzExMZ+x1JkWLFiAvb092tralC1blnPnzr13/82bN+Pi4oK2tjbu7u7s3bv3M5X0wz6mLr/++iuVKlUif/785M+fnxo1anyw7p/Lx/5OsmzYsAGFQkHjxo3ztoACADY2Ntn+Hx4eLv/89xHQ58+fY2trK/+sVCqxsbHh+fPnb51zy5YtbN++HWtra2rXrp1tGvHf6evrExsbm21bbGws+vr6/7o+wvdPtLmizf2URJsr2lzhvxOd1m9EmzZtuHHjBgcPHmT37t0cP36crl275urY2bNno1Ao8riEufOx9Xj+/DnPnz9n+vTpXL9+nZUrVxIcHEznzp0/Y6lh48aNDBgwgDFjxnDp0iWKFy9OrVq1iIiIyHH/06dP4+fnR+fOnbl8+TKNGzemcePGXL9+/bOWOycfW5ejR4/i5+fHkSNHOHPmDDY2Nvj6+vLs2bPPXPLsPrYeWcLCwhg0aBCVKlX6TCUVnjx5ku3/FhYW8s9//2yytLTk8ePH8s+SJPHkyRMsLS3fOmfZsmXZs2cPL1++pHjx4nTv3j3Hazs6OhIfH5/t7/X69eu4ubn9pzoJ3zfR5oo291MRba5oc4VPRBK+ejdv3pQA6fz58/K2ffv2SQqFQnr27Nl7j718+bJkZWUlhYeHS4C0ffv2PC7tu/2Xevzdpk2bJE1NTSktLS0vipmjMmXKSD179pR/zsjIkCwtLaVJkybluH/Lli2levXqZdtWtmxZKTAwME/LmRsfW5d/Sk9PlwwMDKRVq1blVRFz5d/UIz09XSpfvry0bNkyqX379lKjRo0+Q0l/bIBUu3ZtKSYmRgoNDZUsLCykgwcPSpIkSe3bt5fGjx8v7/vq1SspX7580o4dO6S0tDRpxowZUuHChaXU1FRJkiTJzs5OOnHihJSSkiKtXbtWiomJkTIyMqSgoCCpWrVqOZ5TkiSpefPmUufOnaXExETpjz/+kAoUKCC9fv1afv7hw4eSmppaXr8UwjdCtLnZiTb3vxFtrmhzhU9DjLR+A86cOYORkRGlSpWSt9WoUQOlUslff/31zuMSExNp3bo1CxYswNzc/HMU9b3+bT3+KSYmBkNDQ9TVP0/GptTUVC5evEiNGjXkbUqlkho1anDmzJkcjzlz5ky2/QFq1ar1zv0/l39Tl39KTEwkLS3ti6YL+bf1CAoKwtTU9LOPGvzo6tatS7FixfDx8aFPnz5vvTeyGBsbs2PHDsaMGUPBggXZvn07O3bsQEND4619V61ahZ2dHfnz5+fgwYPMnz//nddfuHAhz58/p2DBggwYMICNGzeKdDfCO4k2NzvR5v57os0Vba7w6Yg8rd+AFy9eYGpqmm2buro6BQoU4MWLF+88rn///pQvX55GjRrldRFz5d/W4+8iIyMZP358rqdpfQqRkZFkZGRgZmaWbbuZmRmhoaE5HvPixYsc989tPfPKv6nLPw0dOhRLS8t3djw+h39Tj5MnT7J8+XKuXLnyGUoo/F2TJk3o3bv3W9tXrlz51rYqVaq883ekUqnQ0NBAU1OT/fv357iPhoYGU6ZMYdeuXfJ6KxMTk3eub5s+fTrjx49HW1s7d5URvnuizf0f0eb+N6LNFW2u8OmIkdYvaNiwYSgUivc+cvuh9k+7du3i8OHDzJ49+9MWOgd5WY+/i42NpV69eri6ujJ27Nj/XnDho02ePJkNGzawffv2b+pLflxcHP7+/vz6668YGxt/6eII/8KrV6949eoVdnZ2793v119/JS4uLtcBQgYNGkRMTIyIJvwDEG3uxxFt7pcn2lxB+B8x0voFDRw4kA4dOrx3HwcHB8zNzd9a6J6enk5UVNQ7pyAdPnyY+/fvY2RklG17s2bNqFSpEkePHv0PJc8uL+uRJS4ujtq1a2NgYMD27dtznC6YV4yNjVFTU+Ply5fZtr98+fKd5TY3N/+o/T+Xf1OXLNOnT2fy5MkcOnTonTkxP5ePrcf9+/cJCwujQYMG8jaVSgVkjjzcvn2bwoUL522hhX/t2rVrVKpUiX79+n3x95Dw7RJtrmhzPzfR5oo2V/iEvvSiWuHDsoIpXLhwQd62f//+9wZTCA8Pl65du5btAUhz5syRHjx48LmKns2/qYckSVJMTIxUrlw5qXLlylJCQsLnKOpbypQpI/Xq1Uv+OSMjQ7KysnpvUIj69etn2+bt7f3VBIX4mLpIkiRNmTJFMjQ0lM6cOfM5ipgrH1OPpKSkt94PjRo1kqpVqyZdu3ZNSklJ+ZxFFwThKybaXNHmfkqizRVtrvBpiE7rN6J27dqSp6en9Ndff0knT56UHB0dJT8/P/n5p0+fSs7OztJff/31znPwhSMZStLH1yMmJkYqW7as5O7uLt27d08KDw+XH+np6Z+t3Bs2bJC0tLSklStXSjdv3pS6du0qGRkZSS9evJAkSZL8/f2lYcOGyfufOnVKUldXl6ZPny7dunVLGjNmjKShoSFdu3bts5X5XT62LpMnT5Y0NTWlLVu2ZHv94+LivlQVJEn6+Hr8k4hkKAjCu4g2V7S5n4poczOJNlf4r0Sn9Rvx+vVryc/PT9LX15cMDQ2ljh07ZvsAe/jwoQRIR44ceec5voYG9GPrceTIEQnI8fHw4cPPWvZ58+ZJtra2kqamplSmTBnp7Nmz8nOVK1eW2rdvn23/TZs2SU5OTpKmpqbk5uYm7dmz57OW930+pi52dnY5vv5jxoz5/AX/h4/9nfydaEAFQXgX0eaKNvdTEm2uaHOF/04hSZKUtxOQBUEQBEEQBEEQBOHfEdGDBUEQBEEQBEEQhK+W6LQKgiAIgiAIgiAIXy3RaRUEQRAEQRAEQRC+WqLTKgiCIAiCIAiCIHy1RKdVEARBEARBEARB+GqJTqsgCIIgCIIgCILw1RKdVkEQBEEQBEEQBOGrJTqtgiAIgiAIgiAIwldLdFqFH1qHDh1o3LjxF7u+v78/EydOzNW+rVq1YsaMGXlcIkEQBEHIG6LNFQTh31JIkiR96UIIQl5QKBTvfX7MmDH0798fSZIwMjL6PIX6m6tXr1KtWjUePXqEvr7+B/e/fv06Pj4+PHz4kHz58n2GEgqCIAhC7og2VxCEvCQ6rcJ368WLF/L/N27cyOjRo7l9+7a8TV9fP1cNV17p0qUL6urqLF68ONfHlC5dmg4dOtCzZ888LJkgCIIgfBzR5gqCkJfE9GDhu2Vubi4/8uXLh0KhyLZNX1//ralKVapUoXfv3vTr14/8+fNjZmbGr7/+SkJCAh07dsTAwIAiRYqwb9++bNe6fv06derUQV9fHzMzM/z9/YmMjHxn2TIyMtiyZQsNGjTItn3hwoU4Ojqira2NmZkZzZs3z/Z8gwYN2LBhw39/cQRBEAThExJtriAIeUl0WgXhH1atWoWxsTHnzp2jd+/edO/enRYtWlC+fHkuXbqEr68v/v7+JCYmAvDmzRuqVauGp6cnFy5cIDg4mJcvX9KyZct3XiMkJISYmBhKlSolb7tw4QJ9+vQhKCiI27dvExwcjI+PT7bjypQpw7lz50hJScmbyguCIAjCZyTaXEEQckN0WgXhH4oXL86oUaNwdHRk+PDhaGtrY2xsTEBAAI6OjowePZrXr18TEhICwPz58/H09GTixIm4uLjg6enJihUrOHLkCHfu3MnxGo8ePUJNTQ1TU1N52+PHj9HT06N+/frY2dnh6elJnz59sh1naWlJampqtmlYgiAIgvCtEm2uIAi5ITqtgvAPHh4e8v/V1NQoWLAg7u7u8jYzMzMAIiIigMzgDkeOHJHX6+jr6+Pi4gLA/fv3c7xGUlISWlpa2QJX1KxZEzs7OxwcHPD392ft2rXyneUsOjo6AG9tFwRBEIRvkWhzBUHIDdFpFYR/0NDQyPazQqHIti2r0VOpVADEx8fToEEDrly5ku1x9+7dt6YaZTE2NiYxMZHU1FR5m4GBAZcuXWL9+vVYWFgwevRoihcvzps3b+R9oqKiADAxMfkkdRUEQRCEL0m0uYIg5IbotArCf+Tl5cWNGzewt7enSJEi2R56eno5HlOiRAkAbt68mW27uro6NWrUYOrUqYSEhBAWFsbhw4fl569fv461tTXGxsZ5Vh9BEARB+FqJNlcQfkyi0yoI/1HPnj2JiorCz8+P8+fPc//+ffbv30/Hjh3JyMjI8RgTExO8vLw4efKkvG337t3MnTuXK1eu8OjRI1avXo1KpcLZ2Vne58SJE/j6+uZ5nQRBEAThayTaXEH4MYlOqyD8R5aWlpw6dYqMjAx8fX1xd3enX79+GBkZoVS++y3WpUsX1q5dK/9sZGTEtm3bqFatGkWLFmXx4sWsX78eNzc3AJKTk9mxYwcBAQF5XidBEARB+BqJNlcQfkwKSZKkL10IQfgRJSUl4ezszMaNG/H29v7g/osWLWL79u0cOHDgM5ROEARBEL4fos0VhG+bGGkVhC9ER0eH1atXvzch+t9paGgwb968PC6VIAiCIHx/RJsrCN82MdIqCIIgCIIgCIIgfLXESKsgCIIgCIIgCILw1RKdVkEQBEEQBEEQBOGrJTqtgiAIgiAIgiAIwldLdFoFQRAEQRAEQRCEr5botAqCIAiCIAiCIAhfLdFpFQRBEARBEARBEL5aotMqCIIgCIIgCIIgfLVEp1UQBEEQBEEQBEH4aolOqyAIgiAIgiAIgvDV+j/ybrV4MvbNRgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import mne\n", + "import numpy as np\n", + "from eeg_research.preprocessing.tools import (blinks_remover, \n", + " utils)\n", + "def merge_annotations(raw,annotations_list):\n", + " \"\"\"\n", + " Merge multiple MNE Annotations objects into a single Annotations object.\n", + " Overlapping annotations are merged into a single annotation with the description\n", + " as a combination of the overlapping annotation descriptions.\n", + " \n", + " Parameters:\n", + " - annotations_list: list of mne.Annotations objects to be merged\n", + " \n", + " Returns:\n", + " - merged_annotations: MNE Annotations object containing all merged annotations\n", + " \"\"\"\n", + " # Initialize empty lists for onsets, durations, and descriptions\n", + " all_onsets = []\n", + " all_durations = []\n", + " all_descriptions = []\n", + " \n", + " # Collect all annotations\n", + " for annotations in annotations_list:\n", + " all_onsets.extend(annotations.onset)\n", + " all_durations.extend(annotations.duration)\n", + " all_descriptions.extend(annotations.description)\n", + " \n", + " # Convert to arrays for vectorized operations\n", + " all_onsets = np.array(all_onsets)\n", + " all_durations = np.array(all_durations)\n", + " all_descriptions = np.array(all_descriptions)\n", + " \n", + " # Sort by onsets\n", + " sorted_indices = np.argsort(all_onsets)\n", + " all_onsets = all_onsets[sorted_indices]\n", + " all_durations = all_durations[sorted_indices]\n", + " all_descriptions = all_descriptions[sorted_indices]\n", + " \n", + " # Merge overlapping annotations\n", + " merged_onsets = [all_onsets[0]]\n", + " merged_durations = [all_durations[0]]\n", + " merged_descriptions = [all_descriptions[0]]\n", + " \n", + " for i in range(1, len(all_onsets)):\n", + " current_start = all_onsets[i]\n", + " current_end = current_start + all_durations[i]\n", + " last_end = merged_onsets[-1] + merged_durations[-1]\n", + " \n", + " if current_start <= last_end:\n", + " # Overlapping, merge the current annotation with the last one\n", + " merged_durations[-1] = max(last_end, current_end) - merged_onsets[-1]\n", + " if all_descriptions[i] not in merged_descriptions[-1]:\n", + " \n", + " merged_descriptions[-1] = 'BAD_multi_artefacts'\n", + " else:\n", + " # No overlap, add as new annotation\n", + " merged_onsets.append(current_start)\n", + " merged_durations.append(all_durations[i])\n", + " merged_descriptions.append(all_descriptions[i])\n", + " \n", + " # Create a new Annotations object with the merged data\n", + " merged_annotations = mne.Annotations(onset=merged_onsets,\n", + " duration=merged_durations,\n", + " description=merged_descriptions,\n", + " orig_time=raw.info['meas_date'])\n", + " \n", + " return merged_annotations\n", + "\n", + "def annotate_artifacts_by_zscore(raw: mne.io.Raw, \n", + " description: str = 'BAD_other',\n", + " channel_type: str | None ='eeg', \n", + " z_thresh: float=3.5, \n", + " min_artifact_gap: float | None =0.1, \n", + " minimum_duration: float | None =0.2,\n", + " filtering: tuple[float | None] | None = (None, 8)):\n", + " \"\"\"\n", + " Annotate and group artifacts in raw EEG data based on a z-score threshold, minimum gap criteria,\n", + " and adjust annotations to meet a minimum duration.\n", + " \n", + " Parameters:\n", + " - raw: Raw object from MNE containing EEG data.\n", + " - channel_type: Type of channels to analyze.\n", + " - z_thresh: Z-score threshold to use for detecting artifacts.\n", + " - min_artifact_gap: Minimum time in seconds between separate artifacts; below this, artifacts will be grouped.\n", + " - minimum_duration: Minimum duration for each annotation. If an annotation is shorter, it is adjusted.\n", + " \n", + " Returns:\n", + " - annotations: MNE Annotations object with detected, grouped, and adjusted artifacts.\n", + " \"\"\"\n", + " raw_copy = raw.copy()\n", + " if filtering:\n", + " raw_copy.filter(*filtering)\n", + " if channel_type:\n", + " picks = mne.pick_types(raw_copy.info, meg=False, eeg=(channel_type=='eeg'), eog=False)\n", + " data, times = raw_copy[picks]\n", + " z_scores = np.abs((data - np.mean(data, axis=1, keepdims=True)) / np.std(data, axis=1, keepdims=True))\n", + " artifacts = (z_scores > z_thresh).any(axis=0)\n", + " gradient = np.diff(artifacts, prepend=0)\n", + " rising_edge_idx = np.where(gradient == 1)[0]\n", + " falling_edge_idx = np.where(gradient == -1)[0]\n", + " if sum(artifacts) == 0:\n", + " return mne.Annotations() # Return empty annotations if no artifacts found\n", + "\n", + " onsets = times[rising_edge_idx]\n", + " ends = times[falling_edge_idx]\n", + " durations = np.array(ends) - np.array(onsets)\n", + " adjusted_onsets = []\n", + " adjusted_durations = []\n", + " last_end = 0\n", + "\n", + " for i, (onset, duration) in enumerate(zip(onsets, durations)):\n", + " if minimum_duration and duration < minimum_duration:\n", + " new_onset = max(0, onset - (minimum_duration - duration) / 2)\n", + " new_duration = minimum_duration\n", + " else:\n", + " new_onset = onset\n", + " new_duration = duration\n", + " \n", + " # Merge annotations if they are closer than min_artifact_gap\n", + " if adjusted_onsets and new_onset - last_end <= min_artifact_gap:\n", + " # Extend the last annotation\n", + " adjusted_durations[-1] = new_onset + new_duration - adjusted_onsets[-1]\n", + " else:\n", + " adjusted_onsets.append(new_onset)\n", + " adjusted_durations.append(new_duration)\n", + " \n", + " last_end = adjusted_onsets[-1] + adjusted_durations[-1]\n", + "\n", + " descriptions = [description] * len(adjusted_onsets)\n", + " annotations = mne.Annotations(onset=adjusted_onsets, \n", + " duration=adjusted_durations, \n", + " description=descriptions,\n", + " orig_time = raw.info['meas_date'])\n", + " return annotations\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting EDF parameters from /Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf...\n", + "EDF file detected\n", + "Setting channel info structure...\n", + "Creating raw.info structure...\n", + "Reading 0 ... 60499 = 0.000 ... 241.996 secs...\n", + "Running EOG SSP computation\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Computing projector\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 1 - 35 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hamming window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 35.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 35.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "0 projection items activated\n", + "Using data from preloaded Raw for 106 events and 101 original time points ...\n", + "0 bad epochs dropped\n", + "No channels 'grad' found. Skipping.\n", + "No channels 'mag' found. Skipping.\n", + "Adding projection: eeg--0.200-0.200-PCA-01 (exp var=96.9%)\n", + "Done.\n", + "1 projection items deactivated\n", + "Created an SSP operator (subspace dimension = 1)\n", + "1 projection items activated\n", + "SSP projectors applied...\n", + "Using eeg sensors for muscle artifact detection\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up high-pass filter at 30 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal highpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 30.00\n", + "- Lower transition bandwidth: 7.50 Hz (-6 dB cutoff frequency: 26.25 Hz)\n", + "- Filter length: 111 samples (0.444 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up low-pass filter at 4 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal lowpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Upper passband edge: 4.00 Hz\n", + "- Upper transition bandwidth: 2.00 Hz (-6 dB cutoff frequency: 5.00 Hz)\n", + "- Filter length: 413 samples (1.652 s)\n", + "\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up high-pass filter at 1 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal highpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 1.00 Hz (-6 dB cutoff frequency: 0.50 Hz)\n", + "- Filter length: 825 samples (3.300 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + } + ], + "source": [ + "raw = mne.io.read_raw(\"/Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf\",\n", + " preload = True)\n", + "b_remover = blinks_remover.BlinksRemover(raw)\n", + "montage = mne.channels.make_standard_montage('easycap-M1')\n", + "b_remover.raw.set_montage(montage)\n", + "#b_remover.plot_blinks_found()\n", + "b_remover.remove_blinks()\n", + "#b_remover.plot_removal_results()\n", + "raw = b_remover.blink_removed_raw\n", + "muscle_annotations, muscle_zscore = mne.preprocessing.annotate_muscle_zscore(raw,\n", + " filter_freq=(30,None),\n", + " \n", + ")\n", + "# Usage example\n", + "artifact_annotations = annotate_artifacts_by_zscore(raw, \n", + " filtering = (1,None),\n", + " min_artifact_gap=0.25, \n", + " minimum_duration=0.5)\n", + "annotation_list = [muscle_annotations, artifact_annotations]\n", + "#merged = merge_annotations(raw, annotations_list=annotation_list)\n", + "#raw.set_annotations(raw.annotations + merged)\n", + "#raw.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mask_containing_bad = [\"BAD\" in description for description in merged.description]\n", + "index_bad = np.where(mask_containing_bad)\n", + "\n", + "total_bad_seconds = merged.duration[index_bad].sum()\n", + "total_good_seconds = raw.times[-1] - total_bad_seconds\n", + "\n", + "stats = dict(\n", + " total_good = dict(seconds = total_good_seconds,\n", + " percentage = total_good_seconds * 100/raw.times[-1]),\n", + " total_bad = dict(seconds = total_bad_seconds,\n", + " percentage = total_bad_seconds * 100/raw.times[-1])\n", + ")\n", + "descriptions = np.unique(merged.description)\n", + "for description in descriptions:\n", + " description_index = np.where(merged.description == description)[0]\n", + " total_seconds_this_description = merged.duration[description_index].sum()\n", + " stats[str(description)] = dict(\n", + " seconds = total_seconds_this_description,\n", + " percentage = total_seconds_this_description * 100/raw.times[-1],\n", + " percentage_from_bad = total_seconds_this_description * 100/total_bad_seconds\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# plot\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39msubplots()\n\u001b[1;32m 3\u001b[0m ax\u001b[38;5;241m.\u001b[39mpie(x, colors\u001b[38;5;241m=\u001b[39mcolors, radius\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, center\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m),\n\u001b[1;32m 4\u001b[0m wedgeprops\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlinewidth\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124medgecolor\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwhite\u001b[39m\u001b[38;5;124m\"\u001b[39m}, frame\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 6\u001b[0m ax\u001b[38;5;241m.\u001b[39mset(xlim\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m8\u001b[39m), xticks\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m8\u001b[39m),\n\u001b[1;32m 7\u001b[0m ylim\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m8\u001b[39m), yticks\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n", + "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined" + ] + } + ], + "source": [ + "# plot\n", + "fig, ax = plt.subplots()\n", + "ax.pie(x, colors=colors, radius=3, center=(4, 4),\n", + " wedgeprops={\"linewidth\": 1, \"edgecolor\": \"white\"}, frame=True)\n", + "\n", + "ax.set(xlim=(0, 8), xticks=np.arange(1, 8),\n", + " ylim=(0, 8), yticks=np.arange(1, 8))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], [], [])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAE4ElEQVR4nO3VMQHAMAzAsKz8OWefKbSHhMCfv93dAYCZObcDAHiHKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBATAGAmAIAMQUAYgoAxBQAiCkAEFMAIKYAQEwBgJgCADEFAGIKAMQUAIgpABBTACCmAEBMAYCYAgAxBQBiCgDEFACIKQAQUwAgpgBAfu8DBwYENNNsAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "from matplotlib import pyplot as plt\n", + "pie_values = [value for key, value in stats.items() if \"percentage\" in key]\n", + "fig, ax = plt.subplots()\n", + "ax.pie(pie_values,\n", + " autopct=\"%1.1f%%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from matplotlib.patches import ConnectionPatch\n", + "import matplotlib as mpl\n", + "\n", + "# make figure and assign axis objects\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", + "fig.subplots_adjust(wspace=0)\n", + "\n", + "# pie chart parameters\n", + "overall_ratios = [stats['total_bad']['percentage']/100, \n", + " stats['total_good']['percentage']/100\n", + "]\n", + "labels = ['Bad segments', 'Good signal']\n", + "explode = [0.1, 0]\n", + "# rotate so that first wedge is split by the x-axis\n", + "angle = -180 * overall_ratios[0]\n", + "wedges, *_ = ax1.pie(overall_ratios, \n", + " autopct='%1.1f%%', \n", + " startangle=angle,\n", + " colors = ['tab:red', 'tab:green'],\n", + " labels=labels, \n", + " explode=explode)\n", + "\n", + "# bar chart parameters\n", + "artifacts_ratios = [value['percentartifacts_from_bad']/100 \n", + " for key,value in stats.items() \n", + " if \"BAD\" in key]\n", + "artifacts_labels = [key for key in stats.keys() if 'BAD' in key]\n", + "bottom = 1\n", + "width = .2\n", + "cmap = mpl.colormaps['tab20c']\n", + "colors = cmap.colors[4:4+len(artifacts_ratios)]\n", + "\n", + "# Adding from the top matches the legend.\n", + "for j, (height, label) in enumerate(\n", + " reversed([*zip(artifacts_ratios, artifacts_labels)])\n", + " ):\n", + " bottom -= height\n", + " bc = ax2.bar(0, height, width, bottom=bottom,label=label,\n", + " color=colors[j])\n", + " ax2.bar_label(bc, labels=[f\"{height:.0%}\"], label_type='center')\n", + "\n", + "ax2.set_title('Artifacts type')\n", + "ax2.legend(fontsize = 8)\n", + "ax2.axis('off')\n", + "ax2.set_xlim(- 2.5 * width, 2.5 * width)\n", + "\n", + "# use ConnectionPatch to draw lines between the two plots\n", + "theta1, theta2 = wedges[0].theta1, wedges[0].theta2\n", + "center, r = wedges[0].center, wedges[0].r\n", + "bar_height = sum(artifacts_ratios)\n", + "\n", + "# draw top connecting line\n", + "x = r * np.cos(np.pi / 180 * theta2) + center[0]\n", + "y = r * np.sin(np.pi / 180 * theta2) + center[1]\n", + "con = ConnectionPatch(xyA=(-width / 2, bar_height), coordsA=ax2.transData,\n", + " xyB=(x, y), coordsB=ax1.transData)\n", + "con.set_color([0, 0, 0])\n", + "con.set_linewidth(2)\n", + "ax2.add_artist(con)\n", + "\n", + "# draw bottom connecting line\n", + "x = r * np.cos(np.pi / 180 * theta1) + center[0]\n", + "y = r * np.sin(np.pi / 180 * theta1) + center[1]\n", + "con = ConnectionPatch(xyA=(-width / 2, 0), coordsA=ax2.transData,\n", + " xyB=(x, y), coordsB=ax1.transData)\n", + "con.set_color([0, 0, 0])\n", + "ax2.add_artist(con)\n", + "con.set_linewidth(2)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((0.9019607843137255, 0.3333333333333333, 0.050980392156862744),\n", + " (0.9921568627450981, 0.5529411764705883, 0.23529411764705882))" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "colors" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from matplotlib.patches import ConnectionPatch\n", + "\n", + "# make figure and assign axis objects\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 5))\n", + "fig.subplots_adjust(wspace=0)\n", + "\n", + "# pie chart parameters\n", + "overall_ratios = [.27, .56, .17]\n", + "labels = ['Approve', 'Disapprove', 'Undecided']\n", + "explode = [0.1, 0, 0]\n", + "# rotate so that first wedge is split by the x-axis\n", + "angle = -180 * overall_ratios[0]\n", + "wedges, *_ = ax1.pie(overall_ratios, autopct='%1.1f%%', startangle=angle,\n", + " labels=labels, explode=explode)\n", + "\n", + "# bar chart parameters\n", + "age_ratios = [.33, .54, .07, .06]\n", + "age_labels = ['Under 35', '35-49', '50-65', 'Over 65']\n", + "bottom = 1\n", + "width = .2\n", + "\n", + "# Adding from the top matches the legend.\n", + "for j, (height, label) in enumerate(reversed([*zip(age_ratios, age_labels)])):\n", + " bottom -= height\n", + " bc = ax2.bar(0, height, width, bottom=bottom, color='C0', label=label,\n", + " alpha=0.1 + 0.25 * j)\n", + " ax2.bar_label(bc, labels=[f\"{height:.0%}\"], label_type='center')\n", + "\n", + "ax2.set_title('Age of approvers')\n", + "ax2.legend()\n", + "ax2.axis('off')\n", + "ax2.set_xlim(- 2.5 * width, 2.5 * width)\n", + "\n", + "# use ConnectionPatch to draw lines between the two plots\n", + "theta1, theta2 = wedges[0].theta1, wedges[0].theta2\n", + "center, r = wedges[0].center, wedges[0].r\n", + "bar_height = sum(age_ratios)\n", + "\n", + "# draw top connecting line\n", + "x = r * np.cos(np.pi / 180 * theta2) + center[0]\n", + "y = r * np.sin(np.pi / 180 * theta2) + center[1]\n", + "con = ConnectionPatch(xyA=(-width / 2, bar_height), coordsA=ax2.transData,\n", + " xyB=(x, y), coordsB=ax1.transData)\n", + "con.set_color([0, 0, 0])\n", + "con.set_linewidth(4)\n", + "ax2.add_artist(con)\n", + "\n", + "# draw bottom connecting line\n", + "x = r * np.cos(np.pi / 180 * theta1) + center[0]\n", + "y = r * np.sin(np.pi / 180 * theta1) + center[1]\n", + "con = ConnectionPatch(xyA=(-width / 2, 0), coordsA=ax2.transData,\n", + " xyB=(x, y), coordsB=ax1.transData)\n", + "con.set_color([0, 0, 0])\n", + "ax2.add_artist(con)\n", + "con.set_linewidth(4)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test of the script" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting EDF parameters from /Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf...\n", + "EDF file detected\n", + "Setting channel info structure...\n", + "Creating raw.info structure...\n", + "Reading 0 ... 60499 = 0.000 ... 241.996 secs...\n", + "Running EOG SSP computation\n", + "Using EOG channels: Fp1, Fp2\n", + "EOG channel index for this subject is: [0 1]\n", + "Filtering the data to remove DC offset to help distinguish blinks from saccades\n", + "Selecting channel Fp1 for blink detection\n", + "Setting up band-pass filter from 1 - 10 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hann window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 10.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 10.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Now detecting blinks and generating corresponding events\n", + "Found 106 significant peaks\n", + "Number of EOG events detected: 106\n", + "Computing projector\n", + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 1 - 35 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a two-pass forward and reverse, zero-phase, non-causal bandpass filter:\n", + "- Windowed frequency-domain design (firwin2) method\n", + "- Hamming window\n", + "- Lower passband edge: 1.00\n", + "- Lower transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 0.75 Hz)\n", + "- Upper passband edge: 35.00 Hz\n", + "- Upper transition bandwidth: 0.50 Hz (-12 dB cutoff frequency: 35.25 Hz)\n", + "- Filter length: 2500 samples (10.000 s)\n", + "\n", + "Not setting metadata\n", + "106 matching events found\n", + "No baseline correction applied\n", + "0 projection items activated\n", + "Using data from preloaded Raw for 106 events and 101 original time points ...\n", + "0 bad epochs dropped\n", + "No channels 'grad' found. Skipping.\n", + "No channels 'mag' found. Skipping.\n", + "Adding projection: eeg--0.200-0.200-PCA-01 (exp var=96.9%)\n", + "Done.\n", + "1 projection items deactivated\n", + "Created an SSP operator (subspace dimension = 1)\n", + "1 projection items activated\n", + "SSP projectors applied...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + } + ], + "source": [ + "import mne\n", + "import numpy as np\n", + "import eeg_research.preprocessing.tools.blinks_remover as blinks_remover\n", + "import eeg_research.preprocessing.tools.artifacts_annotator as annotator\n", + "raw = mne.io.read_raw(\"/Users/samuel/Downloads/sub-01_ses-01_task-checker_run-01_eeg.edf\",\n", + " preload = True)\n", + "b_remover = blinks_remover.BlinksRemover(raw)\n", + "montage = mne.channels.make_standard_montage('easycap-M1')\n", + "b_remover.raw.set_montage(montage)\n", + "#b_remover.plot_blinks_found()\n", + "b_remover.remove_blinks()\n", + "#b_remover.plot_removal_results()\n", + "raw = b_remover.blink_removed_raw" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using eeg sensors for muscle artifact detection\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtering raw data in 1 contiguous segment\n", + "Setting up band-pass filter from 30 - 1e+02 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal bandpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Lower passband edge: 30.00\n", + "- Lower transition bandwidth: 7.50 Hz (-6 dB cutoff frequency: 26.25 Hz)\n", + "- Upper passband edge: 100.00 Hz\n", + "- Upper transition bandwidth: 25.00 Hz (-6 dB cutoff frequency: 112.50 Hz)\n", + "- Filter length: 111 samples (0.444 s)\n", + "\n", + "Setting up low-pass filter at 4 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal lowpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Upper passband edge: 4.00 Hz\n", + "- Upper transition bandwidth: 2.00 Hz (-6 dB cutoff frequency: 5.00 Hz)\n", + "- Filter length: 413 samples (1.652 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtering raw data in 1 contiguous segment\n", + "Setting up low-pass filter at 30 Hz\n", + "\n", + "FIR filter parameters\n", + "---------------------\n", + "Designing a one-pass, zero-phase, non-causal lowpass filter:\n", + "- Windowed time-domain design (firwin) method\n", + "- Hamming window with 0.0194 passband ripple and 53 dB stopband attenuation\n", + "- Upper passband edge: 30.00 Hz\n", + "- Upper transition bandwidth: 7.50 Hz (-6 dB cutoff frequency: 33.75 Hz)\n", + "- Filter length: 111 samples (0.444 s)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.1s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] + } + ], + "source": [ + "# Testing muscle annotations\n", + "raw_copy = raw.copy()\n", + "z_annotator = annotator.ZscoreAnnotator(raw_copy)\n", + "z_annotator.detect_muscles(filter_freq = (30,100))\n", + "#z_annotator.merge_annotations().compute_statistics().print_statistics() \n", + "z_annotator.detect_other_artifacts(filtering=(None,30),\n", + " min_artifact_gap= 0.2,\n", + " minimum_duration=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/l3/myr9vj8933q4vwhkbvxcx6gc0000gn/T/ipykernel_3971/2082992089.py:50: RuntimeWarning: Limited 1 annotation(s) that were expanding outside the data range.\n", + " raw.set_annotations(annot)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] + } + ], + "source": [ + "artifacts_general_annotations = annotation_list.copy()\n", + "def merge_annotations(artifacts_general_annotations,\n", + " raw) -> 'ZscoreAnnotator':\n", + " \"\"\"Merge MNE Annotations objects into a single Annotations object.\n", + " \n", + " Overlapping annotations are merged into a single annotation with the \n", + " description as a combination of the overlapping annotation descriptions.\n", + " \n", + " Returns:\n", + " - merged_annotations: MNE Annotations object containing all merged annotations\n", + " \"\"\"\n", + " annots_args_list: dict[list] = {\n", + " \"onset\": [],\n", + " \"duration\": [],\n", + " \"description\": []\n", + " }\n", + " \n", + " for annot_arg_name, annot_arg_var in annots_args_list.items():\n", + " for annotations in artifacts_general_annotations:\n", + " annots_args_list[annot_arg_name] = annot_arg_var.extend(\n", + " getattr(annotations, annot_arg_name)\n", + " )\n", + "\n", + " annots_args_list[annot_arg_name] = np.sort(annot_arg_var)\n", + " \n", + " merged_onsets = [annots_args_list['onset'][0]]\n", + " merged_durations = [annots_args_list['duration'][0]] \n", + " merged_descriptions = [annots_args_list['description'][0]]\n", + " \n", + " for i in range(1, len(annots_args_list['onset'])):\n", + " current_start = annots_args_list['onset'][i]\n", + " current_end = current_start + annots_args_list['duration'][i]\n", + " last_end = merged_onsets[-1] + merged_durations[-1]\n", + " \n", + " if current_start <= last_end:\n", + " merged_durations[-1] = max(last_end, current_end) - merged_onsets[-1]\n", + " if annots_args_list['description'][i] not in merged_descriptions[-1]:\n", + " \n", + " merged_descriptions[-1] += '_' + annots_args_list['description'][i][4:]\n", + " else:\n", + " merged_onsets.append(current_start)\n", + " merged_durations.append(annots_args_list['duration'][i])\n", + " merged_descriptions.append(annots_args_list['description'][i])\n", + " \n", + " artifact_annotations = mne.Annotations(onset=merged_onsets,\n", + " duration=merged_durations,\n", + " description=merged_descriptions,\n", + " orig_time= raw.info['meas_date'])\n", + " return artifact_annotations\n", + "\n", + "annot = merge_annotations(artifacts_general_annotations,raw)\n", + "raw.set_annotations(annot)\n", + "raw.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 19.144 19.928 27.016 237. ]\n" + ] + } + ], + "source": [ + "print(getattr(annotation_list[0],'onset'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mne", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py new file mode 100644 index 0000000..fe5fe6b --- /dev/null +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -0,0 +1,428 @@ +#!/usr/bin/env -S python # +# -*- coding: utf-8 -*- +# =============================================================================== +# Author: Dr. Samuel Louviot, PhD +# Dr. Alp Erkent, MD, MA +# Institution: Nathan Kline Institute +# Child Mind Institute +# Address: 140 Old Orangeburg Rd, Orangeburg, NY 10962, USA +# 215 E 50th St, New York, NY 10022 +# Date: 2024-02-27 +# email: samuel DOT louviot AT nki DOT rfmh DOT org +# alp DOT erkent AT childmind DOT org +# =============================================================================== +# LICENCE GNU GPLv3: +# Copyright (C) 2024 Dr. Samuel Louviot, PhD +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# =============================================================================== + +"""GENERAL DOCUMENTATION HERE.""" + +import os + +import matplotlib as mpl +import matplotlib.pyplot as plt +import mne +import numpy as np +from matplotlib.patches import ConnectionPatch +from mne.preprocessing import annotate_muscle_zscore + + +class ZscoreAnnotator: + """A class to perform artifacts annotation with zScore. + + Args: + raw (mne.io.Raw): The EEG data to annotate + """ + def __init__(self, raw: mne.io.Raw) -> None: # noqa: D107 + self.raw = raw + self.artifacts_general_annotations: list = list() + + def detect_muscles(self, **kwargs: dict) -> 'ZscoreAnnotator': + """Wrapper around the mne function to annotate muscle. + + Args: + kwargs(dict): A dictionnary containing the arguments for + the `annotate_muscle_zscore` to be parsed. + + Returns: + The ZscoreAnnotator instance + """ + muscle_annotations, _ = annotate_muscle_zscore(self.raw, **kwargs) + self.artifacts_general_annotations.append(muscle_annotations) + + return self + + + def detect_other_artifacts( + self, + description: str = 'BAD_others', + channel_type: str | None ='eeg', + z_thresh: float=3.5, + min_artifact_gap: float | None =0.1, + minimum_duration: float | None =0.2, + filtering: tuple = (None, 8.0), + ) -> 'ZscoreAnnotator': + """Annotate artifacts in raw EEG data based on a z-score threshold. + + Parameters: + - raw: Raw object from MNE containing EEG data. + - channel_type: Type of channels to analyze. + - z_thresh: Z-score threshold to use for detecting artifacts. + - min_artifact_gap: Minimum time in seconds between separate artifacts; + below this, artifacts will be grouped. + - minimum_duration: Minimum duration for each annotation. + If an annotation is shorter, it is adjusted. + + Returns: + - annotations: MNE Annotations object with detected, grouped, + and adjusted artifacts. + """ + raw_copy = self.raw.copy() + if filtering: + raw_copy.filter(*filtering) + if channel_type: + picks = mne.pick_types(raw_copy.info, + meg=False, + eeg=(channel_type=='eeg'), + eog=False) + data, times = raw_copy[picks] + z_scores = (np.abs((data - np.mean(data, axis=1, keepdims=True)) / + np.std(data, axis=1, keepdims=True))) + artifacts = (z_scores > z_thresh).any(axis=0) + gradient = np.diff(artifacts, prepend=0) + rising_edge_idx = np.where(gradient == 1)[0] + falling_edge_idx = np.where(gradient == -1)[0] + if sum(artifacts) == 0: + return mne.Annotations() + + onsets = times[rising_edge_idx] + ends = times[falling_edge_idx] + durations = np.array(ends) - np.array(onsets) + adjusted_onsets: list = list() + adjusted_durations: list = list() + last_end = 0 + + for i, (onset, duration) in enumerate(zip(onsets, durations)): + if minimum_duration and duration < minimum_duration: + new_onset = max(0, onset - (minimum_duration - duration) / 2) + new_duration = minimum_duration + else: + new_onset = onset + new_duration = duration + + if adjusted_onsets and new_onset - last_end <= min_artifact_gap: + adjusted_durations[-1] = new_onset + new_duration - adjusted_onsets[-1] + else: + adjusted_onsets.append(new_onset) + adjusted_durations.append(new_duration) + + last_end = adjusted_onsets[-1] + adjusted_durations[-1] + + descriptions = [description] * len(adjusted_onsets) + self.artifacts_general_annotations.append( + mne.Annotations( + onset=adjusted_onsets, + duration=adjusted_durations, + description=descriptions, + orig_time=self.raw.info['meas_date'] + ) + ) + return self + + def merge_annotations(self) -> 'ZscoreAnnotator': + """Merge MNE Annotations objects into a single Annotations object. + + Overlapping annotations are merged into a single annotation with the + description as a combination of the overlapping annotation descriptions. + + Returns: + - merged_annotations: MNE Annotations object containing all merged annotations + """ + # Initialize empty lists for onsets, durations, and descriptions + all_onsets = [] + all_durations = [] + all_descriptions = [] + + # Collect all annotations + for annotations in self.artifacts_general_annotations: + all_onsets.extend(annotations.onset) + all_durations.extend(annotations.duration) + all_descriptions.extend(annotations.description) + + # Convert to arrays for vectorized operations + all_onsets = np.array(all_onsets) #type: ignore + all_durations = np.array(all_durations) #type: ignore + all_descriptions = np.array(all_descriptions) #type: ignore + + # Sort by onsets + sorted_indices = np.argsort(all_onsets) + all_onsets = all_onsets[sorted_indices] + all_durations = all_durations[sorted_indices] + all_descriptions = all_descriptions[sorted_indices] + + merged_onsets = [all_onsets[0]] + merged_durations = [all_durations[0]] + merged_descriptions = [all_descriptions[0]] + + for i in range(1, len(all_onsets)): + current_start = all_onsets[i] + current_end = current_start + all_durations[i] + last_end = merged_onsets[-1] + merged_durations[-1] + + if current_start <= last_end: + merged_durations[-1] = max(last_end, current_end) - merged_onsets[-1] + if all_descriptions[i] not in merged_descriptions[-1]: + + merged_descriptions[-1] += '_' + all_descriptions[i][4:] + else: + merged_onsets.append(current_start) + merged_durations.append(all_durations[i]) + merged_descriptions.append(all_descriptions[i]) + + self.artifact_annotations = mne.Annotations(onset=merged_onsets, + duration=merged_durations, + description=merged_descriptions, + orig_time=self.raw.info['meas_date']) + return self + + def compute_statistics(self) -> 'ZscoreAnnotator': + """Compute the portion of the signal that is polluted.""" + mask_containing_bad = ["BAD" + in description + for description + in self.artifact_annotations.description] + index_bad = np.where(mask_containing_bad) + tot_bad_seconds = self.artifact_annotations.duration[index_bad].sum() + tot_good_seconds = self.raw.times[-1] - tot_bad_seconds + + self.statistics = dict( + tot_good = dict( + seconds = tot_good_seconds, + ratio = tot_good_seconds /self.raw.times[-1] + ), + tot_bad = dict( + number = len(index_bad), + seconds = tot_bad_seconds, + ratio = tot_bad_seconds /self.raw.times[-1]) + ) + descriptions = np.unique(self.artifact_annotations.description) + self.statistics['tot_bad'].update(dict( + artifact_types = descriptions + )) + for description in descriptions: + description_index = np.where( + self.artifact_annotations.description == description + )[0] + tot_sec_this_description = ( + self.artifact_annotations.duration[description_index].sum() + ) + self.statistics[str(description)] = dict( + seconds = tot_sec_this_description, + ratio = tot_sec_this_description /self.raw.times[-1], + ratio_from_bad = tot_sec_this_description /tot_bad_seconds, + ) + return self + + def print_statistics(self) -> 'ZscoreAnnotator': + # THIS IS STARTING TO LOOK LIKE A CLUSTERF*CK. NEED TO BE SIMPLIFIED + """Print in the prompt the quantity of signal polluted.""" + default_message = "STATISTICS NOT COMPUTED" + if not getattr(self, 'statistics', False): + print(default_message) + return self + + eeg_total_duration = np.round(self.raw.times[-1],3) + number_bad = self.statistics.get( + 'tot_bad', + dict(number = default_message) + ).get('number') + + tot_bad_duration = np.round(self.statistics.get( # type: ignore + 'tot_bad', + dict(seconds = default_message) + ).get('seconds'),2) + + tot_bad_perc = round(self.statistics.get( # type: ignore + 'tot_bad', + dict(ratio = 99999) + ).get('ratio'),2)*100 + + tot_good_duration = np.round(self.statistics.get( # type:ignore + 'tot_good', + dict(seconds = default_message) + ).get('seconds'),2) + + tot_good_perc = np.round(self.statistics.get( # type: ignore + 'tot_good', + dict(ratio = 99999) + ).get('ratio'),2)*100 + + artifacts_type = self.statistics.get( + 'tot_bad', + dict(artifact_type = ['NOT COMPUTED'])).get( + 'artifact_types', + ['NOT COMPUTED'] + ) + + messages_list: list[str] = list() + messages_list.extend(f""" +ARTIFACT ANNOTATIONS STATISTICS + EEG total duration:.............. {eeg_total_duration} s + Number of bad segment annotated:....... {number_bad} + Total duration of bad segments:.. {tot_bad_duration} s ({tot_bad_perc}%) + Total duration of good signal:... {tot_good_duration} s ({tot_good_perc}%) + Types of artifacts annotated: {', '.join(artifacts_type)}""") + for artifact_type in artifacts_type: + this_artifact = self.statistics.get( + 'tot_bad', + {artifact_type : dict(seconds = 99999, + ratio = 99999) + } + ).get('artifact_type', + dict(seconds = 99999, + ratio = 99999)) + + this_artifact_duration = this_artifact.get('seconds') + + this_artifact_ratio = np.round(self.statistics.get( # type: ignore + artifact_type, + dict(ratio = 99999) + ).get('ratio'),2) * 100 + + this_artifact_perc = this_artifact_ratio * 100 + + messages_list.extend(f""" + {artifact_type} duration (sec):....{this_artifact_duration}({ + this_artifact_perc}%)""") + + self.statistics_message = ''.join(messages_list) + print(self.statistics_message) + return self + + def annotate(self, overwrite: bool = False) -> 'ZscoreAnnotator': + """Write the annotation to the raw object.""" + if not getattr(self,'artifact_annotations', False): + self.merge_annotations() + if overwrite: + to_write = self.artifact_annotations + else: + to_write = self.raw.annotations + self.artifact_annotations + self.raw.set_annotations(to_write) + return self + + def write_statistics(self, + saving_filename: str | os.PathLike) -> 'ZscoreAnnotator': + """Write into an external file the computed statistics. + + Args: + saving_filename (str | os.PathLike): The full path and name of + the file to be written. + If no file extension is + provided, txt will be chosen + + Returns: + The ZscoreAnnotator instance + """ + base_filename, extension = os.path.splitext(saving_filename) + extension_dont_exists = '' in extension + if extension_dont_exists: + extension = '.txt' + + filename = base_filename + extension + with open(filename,'w') as file: + file.write(self.statistics_message) + + print(f'Written into {filename}') + + return self + + def plot_statistics(self) -> plt.figure: + """Plot the statistics of bad segment compared to good ones. + + Returns: + fig: The matplotlib figure object + """ + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + fig.subplots_adjust(wspace=0) + + # pie chart parameters + overall_ratios = [self.statistics['tot_bad']['ratio'], + self.statistics['tot_good']['ratio'] + ] + labels = ['Bad segments', 'Good signal'] + explode = [0.1, 0] + # rotate so that first wedge is split by the x-axis + angle = -180 * overall_ratios[0] + wedges, *_ = ax1.pie(overall_ratios, + autopct='%1.1f%%', + startangle=angle, + colors = ['tab:red', 'tab:green'], + labels=labels, + explode=explode) + + # bar chart parameters + artifacts_ratios = [value['ratio_from_bad'] + for key,value in self.statistics.items() + if "BAD" in key] + artifacts_labels = [key for key in self.statistics.keys() if 'BAD' in key] + bottom = 1 + width = .2 + cmap = mpl.colormaps['tab20c'] + colors = cmap.colors[4:4+len(artifacts_ratios)] #type: ignore + + # Adding from the top matches the legend. + for j, (height, label) in enumerate( + reversed([*zip(artifacts_ratios, artifacts_labels)]) + ): + bottom -= height + bc = ax2.bar(0, height, width, bottom=bottom,label=label, + color=colors[j]) + ax2.bar_label(bc, labels=[f"{height:.0%}"], label_type='center') + + ax2.set_title('Artifacts type') + ax2.legend(fontsize = 8) + ax2.axis('off') + ax2.set_xlim(- 2.5 * width, 2.5 * width) + + # use ConnectionPatch to draw lines between the two plots + theta1, theta2 = wedges[0].theta1, wedges[0].theta2 + center, r = wedges[0].center, wedges[0].r + bar_height = sum(artifacts_ratios) + + # draw top connecting line + x = r * np.cos(np.pi / 180 * theta2) + center[0] + y = r * np.sin(np.pi / 180 * theta2) + center[1] + con = ConnectionPatch(xyA=(-width / 2, bar_height), coordsA=ax2.transData, + xyB=(x, y), coordsB=ax1.transData) + con.set_color([0, 0, 0]) # type: ignore + con.set_linewidth(2) + ax2.add_artist(con) + + # draw bottom connecting line + x = r * np.cos(np.pi / 180 * theta1) + center[0] + y = r * np.sin(np.pi / 180 * theta1) + center[1] + con = ConnectionPatch(xyA=(-width / 2, 0), coordsA=ax2.transData, + xyB=(x, y), coordsB=ax1.transData) + con.set_color([0, 0, 0]) # type: ignore + ax2.add_artist(con) + con.set_linewidth(2) + return fig + + # TODO + # - Need to add the plot and then run on data + # - Add high frequency/high amplitude detection + # - Add electrode level detection, stats and plot + + + + diff --git a/src/eeg_research/preprocessing/tools/blinks_remover.py b/src/eeg_research/preprocessing/tools/blinks_remover.py index b81bc21..2ee8212 100644 --- a/src/eeg_research/preprocessing/tools/blinks_remover.py +++ b/src/eeg_research/preprocessing/tools/blinks_remover.py @@ -30,13 +30,13 @@ import os import mne - +from eeg_research.preprocessing.tools import utils class BlinksRemover: """Instance for removing blinks from EEG data.""" def __init__(self, raw: mne.io.Raw, # noqa: ANN204 - channels: list[str] = ['Fp1', 'Fp2']): + eog_channels: list[str] = ['Fp1', 'Fp2']): """Initialize BlinksRemover instance. Args: @@ -46,7 +46,10 @@ def __init__(self, raw: mne.io.Raw, # noqa: ANN204 Defaults to ['Fp1', 'Fp2']. """ self.raw = raw - self.channels = channels + self.eog_channels = eog_channels + channel_map = utils.map_channel_type(self.raw) + self.raw = utils.set_channel_types(self.raw, channel_map=channel_map) + def _find_blinks(self) -> "BlinksRemover": """Helper for automatically finding blinks using mne functions. @@ -55,13 +58,13 @@ def _find_blinks(self) -> "BlinksRemover": BlinksRemover: _description_ """ self.eog_evoked = mne.preprocessing.create_eog_epochs( - self.raw, ch_name = self.channels + self.raw, ch_name = self.eog_channels ).average() self.eog_evoked.apply_baseline((None, None)) return self def plot_removal_results(self, - saving_filename: str | os.PathLike + saving_filename: str | os.PathLike | None = None ) ->"BlinksRemover": """Plot the result after removing the blinks. @@ -78,7 +81,7 @@ def plot_removal_results(self, return figure def plot_blinks_found(self, - saving_filename: str | os.PathLike + saving_filename: str | os.PathLike | None = None ) ->"BlinksRemover": """Plot the blink automatically found. @@ -108,7 +111,7 @@ def remove_blinks(self) -> mne.io.Raw: n_eeg=1, reject=None, no_proj=True, - ch_name = self.channels + ch_name = self.eog_channels ) self.blink_removed_raw = self.raw.copy() self.blink_removed_raw.add_proj(self.eog_projs).apply_proj() diff --git a/src/eeg_research/preprocessing/tools/muscle_annotator.py b/src/eeg_research/preprocessing/tools/muscle_annotator.py deleted file mode 100644 index e8b2012..0000000 --- a/src/eeg_research/preprocessing/tools/muscle_annotator.py +++ /dev/null @@ -1,40 +0,0 @@ - -#!/usr/bin/env -S python # -# -*- coding: utf-8 -*- -# =============================================================================== -# Author: Dr. Samuel Louviot, PhD -# Dr. Alp Erkent, MD, MA -# Institution: Nathan Kline Institute -# Child Mind Institute -# Address: 140 Old Orangeburg Rd, Orangeburg, NY 10962, USA -# 215 E 50th St, New York, NY 10022 -# Date: 2024-02-27 -# email: samuel DOT louviot AT nki DOT rfmh DOT org -# alp DOT erkent AT childmind DOT org -# =============================================================================== -# LICENCE GNU GPLv3: -# Copyright (C) 2024 Dr. Samuel Louviot, PhD -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . -# =============================================================================== - -"""GENERAL DOCUMENTATION HERE.""" - -import os - -import mne - - -class MuscleAnnotator: - def __init__(self, raw: mne.io.Raw) -> None: - self.raw = raw - - From 797c9c309a1ad9f69e7d016c404c07168e4490e7 Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Thu, 18 Jul 2024 14:56:11 -0400 Subject: [PATCH 05/14] finishing core artifact annotation --- .../pipelines/eeg_preprocessing_pipeline.py | 30 ++--- .../test_pipeline_blink_and_muscles.ipynb | 112 +++++++++++------- 2 files changed, 87 insertions(+), 55 deletions(-) diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index 976e85b..ad84067 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -42,6 +42,7 @@ import pyprep as prep from eeg_research.preprocessing.tools import blinks_remover, utils +from eeg_research.preprocessing.tools import artifacts_annotator as annotator ParamType = ParamSpec('ParamType') ReturnType = TypeVar('ReturnType') @@ -96,20 +97,6 @@ def __init__( channels_map = utils.map_channel_type(self.raw) self.raw = utils.set_channel_types(self.raw, channels_map) - def annotate_muscle(self): - """ - muscle_annotations, self.muscle_z_score = mne.preprocessing.annotate_muscle_zscore( - self.raw, - threshold=4, - ch_type='eeg', - min_length_good=0.1, - filter_freq=(110, 140), - n_jobs=None, - verbose=None - ) - self.raw.set_annotations(self.raw.annotations + muscle_annotations) - return self - def set_annotations_to_raw( self, events_filename: str | os.PathLike @@ -175,6 +162,19 @@ def set_montage(self, self.raw.set_montage(self.montage) return self + def annotate_artifacts(self) -> "EEGpreprocessing": + """Annotate on the EEG segments that are polluted by artifacts.""" + z_annotator = annotator.ZscoreAnnotator(self.raw) + z_annotator.detect_muscles(filter_freq = (30,100)) #type: ignore + z_annotator.detect_other_artifacts(filtering=(None,8), + min_artifact_gap= 0.2, + minimum_duration=0.2) + + z_annotator.merge_annotations().annotate() + self.raw = z_annotator.raw + + return self + def remove_blinks(self) -> "EEGpreprocessing": """Remove blinks from the EEG signal by using SSP projector. @@ -234,7 +234,7 @@ def save(self, filename: str | os.PathLike) -> "EEGpreprocessing": Args: filename: the name of the file to save """ - mne.export.export_raw(filename, self.raw) + mne.export.export_raw(filename, self.raw, fmt = 'edf') return self def main(reading_filename: str | os.PathLike, diff --git a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb index 59cbf7e..21c99dd 100644 --- a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb +++ b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb @@ -2096,13 +2096,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Using eeg sensors for muscle artifact detection\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Using eeg sensors for muscle artifact detection\n", "Filtering raw data in 1 contiguous segment\n", "Setting up band-pass filter from 30 - 1e+02 Hz\n", "\n", @@ -2127,20 +2121,7 @@ "- Upper passband edge: 4.00 Hz\n", "- Upper transition bandwidth: 2.00 Hz (-6 dB cutoff frequency: 5.00 Hz)\n", "- Filter length: 413 samples (1.652 s)\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "\n", "Filtering raw data in 1 contiguous segment\n", "Setting up low-pass filter at 30 Hz\n", "\n", @@ -2159,34 +2140,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.1s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using qt as 2D backend.\n", - "Using pyopengl with version 3.1.6\n" + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Channels marked as bad:\n", - "none\n" - ] } ], "source": [ @@ -2197,7 +2163,8 @@ "#z_annotator.merge_annotations().compute_statistics().print_statistics() \n", "z_annotator.detect_other_artifacts(filtering=(None,30),\n", " min_artifact_gap= 0.2,\n", - " minimum_duration=0.2)" + " minimum_duration=0.2)\n", + "z_annotator.merge_annotations().annotate()" ] }, { @@ -2313,6 +2280,71 @@ "print(getattr(annotation_list[0],'onset'))" ] }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'raw' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mraw\u001b[49m\n", + "\u001b[0;31mNameError\u001b[0m: name 'raw' is not defined" + ] + } + ], + "source": [ + "raw" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting existing file.\n", + "Extracting EDF parameters from /Users/samuel/Desktop/testing_export.edf...\n", + "EDF file detected\n", + "Setting channel info structure...\n", + "Creating raw.info structure...\n", + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] + } + ], + "source": [ + "filename = '/Users/samuel/Desktop/testing_export.edf'\n", + "mne.export.export_raw(filename ,z_annotator.raw, fmt = 'edf', overwrite=True)\n", + "raw = mne.io.read_raw(filename)\n", + "raw.plot()" + ] + }, { "cell_type": "code", "execution_count": null, From 0dc78334e9498b3ec0602d0958ce7edba6abbb4e Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Tue, 23 Jul 2024 11:37:42 -0400 Subject: [PATCH 06/14] fixed printing artifacts report --- .../pipelines/eeg_preprocessing_pipeline.py | 2 +- .../test_pipeline_blink_and_muscles.ipynb | 146 ++++++++++++++++-- .../tools/artifacts_annotator.py | 78 +++------- 3 files changed, 156 insertions(+), 70 deletions(-) diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index ad84067..e0d6414 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -272,7 +272,7 @@ def main(reading_filename: str | os.PathLike, data. """, epilog=""" - The preprocessing methods has to be sepcified by by calling --methods + The preprocessing methods has to be sepcified by calling --methods when calling the script. It can be several methods, names have to be separated by a comma. Beware the order matters """) diff --git a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb index 21c99dd..6fdf385 100644 --- a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb +++ b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb @@ -1416,7 +1416,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -1558,7 +1558,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1639,7 +1639,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.1s\n", "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" ] }, @@ -1669,7 +1669,8 @@ "- Lower passband edge: 1.00\n", "- Lower transition bandwidth: 1.00 Hz (-6 dB cutoff frequency: 0.50 Hz)\n", "- Filter length: 825 samples (3.300 s)\n", - "\n" + "\n", + "Using pyopengl with version 3.1.6\n" ] }, { @@ -1678,6 +1679,24 @@ "text": [ "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] } ], "source": [ @@ -1700,9 +1719,45 @@ " min_artifact_gap=0.25, \n", " minimum_duration=0.5)\n", "annotation_list = [muscle_annotations, artifact_annotations]\n", - "#merged = merge_annotations(raw, annotations_list=annotation_list)\n", - "#raw.set_annotations(raw.annotations + merged)\n", - "#raw.plot()" + "merged = merge_annotations(raw, annotations_list=annotation_list)\n", + "raw.set_annotations(raw.annotations + merged)\n", + "raw.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using qt as 2D backend.\n", + "Using pyopengl with version 3.1.6\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels marked as bad:\n", + "none\n" + ] + } + ], + "source": [ + "raw.plot()" ] }, { @@ -2121,7 +2176,20 @@ "- Upper passband edge: 4.00 Hz\n", "- Upper transition bandwidth: 2.00 Hz (-6 dB cutoff frequency: 5.00 Hz)\n", "- Filter length: 413 samples (1.652 s)\n", - "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.1s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Filtering raw data in 1 contiguous segment\n", "Setting up low-pass filter at 30 Hz\n", "\n", @@ -2140,14 +2208,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n", "[Parallel(n_jobs=1)]: Done 17 tasks | elapsed: 0.0s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -2160,11 +2227,66 @@ "raw_copy = raw.copy()\n", "z_annotator = annotator.ZscoreAnnotator(raw_copy)\n", "z_annotator.detect_muscles(filter_freq = (30,100))\n", - "#z_annotator.merge_annotations().compute_statistics().print_statistics() \n", "z_annotator.detect_other_artifacts(filtering=(None,30),\n", " min_artifact_gap= 0.2,\n", " minimum_duration=0.2)\n", - "z_annotator.merge_annotations().annotate()" + "z_annotator.merge_annotations()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "ARTIFACT ANNOTATIONS STATISTICS\n", + " EEG total duration:.................... 242.0s\n", + " Number of bad segment annotated:....... 61\n", + " Total duration of bad segments:........ 34.05s (14.07%)\n", + " Total duration of good signal:......... 207.94s (85.93%)\n", + "\n", + " Types of artifacts annotated: BAD_others, BAD_others_muscle\n", + " |__BAD_others duration (sec): 27.56s (11.39%)\n", + " |__BAD_others_muscle duration (sec): 6.49s (2.68%)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z_annotator.compute_statistics().print_statistics()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.14" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.round(z_annotator.statistics['tot_bad']['ratio'],2)" ] }, { diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index fe5fe6b..65a5b29 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -211,7 +211,7 @@ def compute_statistics(self) -> 'ZscoreAnnotator': ratio = tot_good_seconds /self.raw.times[-1] ), tot_bad = dict( - number = len(index_bad), + number = sum(mask_containing_bad), seconds = tot_bad_seconds, ratio = tot_bad_seconds /self.raw.times[-1]) ) @@ -234,75 +234,39 @@ def compute_statistics(self) -> 'ZscoreAnnotator': return self def print_statistics(self) -> 'ZscoreAnnotator': - # THIS IS STARTING TO LOOK LIKE A CLUSTERF*CK. NEED TO BE SIMPLIFIED """Print in the prompt the quantity of signal polluted.""" default_message = "STATISTICS NOT COMPUTED" if not getattr(self, 'statistics', False): print(default_message) return self - eeg_total_duration = np.round(self.raw.times[-1],3) - number_bad = self.statistics.get( - 'tot_bad', - dict(number = default_message) - ).get('number') - - tot_bad_duration = np.round(self.statistics.get( # type: ignore - 'tot_bad', - dict(seconds = default_message) - ).get('seconds'),2) - - tot_bad_perc = round(self.statistics.get( # type: ignore - 'tot_bad', - dict(ratio = 99999) - ).get('ratio'),2)*100 - - tot_good_duration = np.round(self.statistics.get( # type:ignore - 'tot_good', - dict(seconds = default_message) - ).get('seconds'),2) - - tot_good_perc = np.round(self.statistics.get( # type: ignore - 'tot_good', - dict(ratio = 99999) - ).get('ratio'),2)*100 - - artifacts_type = self.statistics.get( - 'tot_bad', - dict(artifact_type = ['NOT COMPUTED'])).get( - 'artifact_types', - ['NOT COMPUTED'] - ) - messages_list: list[str] = list() messages_list.extend(f""" ARTIFACT ANNOTATIONS STATISTICS - EEG total duration:.............. {eeg_total_duration} s - Number of bad segment annotated:....... {number_bad} - Total duration of bad segments:.. {tot_bad_duration} s ({tot_bad_perc}%) - Total duration of good signal:... {tot_good_duration} s ({tot_good_perc}%) - Types of artifacts annotated: {', '.join(artifacts_type)}""") - for artifact_type in artifacts_type: - this_artifact = self.statistics.get( - 'tot_bad', - {artifact_type : dict(seconds = 99999, - ratio = 99999) - } - ).get('artifact_type', - dict(seconds = 99999, - ratio = 99999)) - - this_artifact_duration = this_artifact.get('seconds') + EEG total duration:.................... {np.round(self.raw.times[-1],2)}s + Number of bad segment annotated:....... { + np.round(self.statistics['tot_bad']['number'],2)} + Total duration of bad segments:........ { + np.round(self.statistics['tot_bad']['seconds'],2)}s ({ + np.round(self.statistics['tot_bad']['ratio']*100,2) + }%) + Total duration of good signal:......... { + np.round(self.statistics['tot_good']['seconds'],2)}s ({ + np.round(self.statistics['tot_good']['ratio']*100,2) + }%) - this_artifact_ratio = np.round(self.statistics.get( # type: ignore - artifact_type, - dict(ratio = 99999) - ).get('ratio'),2) * 100 + Types of artifacts annotated: {', '.join( + self.statistics['tot_bad']['artifact_types'] + )}""") - this_artifact_perc = this_artifact_ratio * 100 + for artifact_type in self.statistics['tot_bad']['artifact_types']: + this_artifact = self.statistics[artifact_type] + + this_artifact_duration = np.round(this_artifact['seconds'],2) + this_artifact_perc = np.round(this_artifact['ratio']*100,2) messages_list.extend(f""" - {artifact_type} duration (sec):....{this_artifact_duration}({ + |__{artifact_type} duration (sec): {this_artifact_duration}s ({ this_artifact_perc}%)""") self.statistics_message = ''.join(messages_list) From 43fe57f0d2ef205dd86209bfa4c177d6fcd9f093 Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Tue, 23 Jul 2024 11:54:15 -0400 Subject: [PATCH 07/14] added mask generation --- src/eeg_research/preprocessing/tools/artifacts_annotator.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index 65a5b29..358e8ee 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -62,7 +62,6 @@ def detect_muscles(self, **kwargs: dict) -> 'ZscoreAnnotator': return self - def detect_other_artifacts( self, description: str = 'BAD_others', From 9a8d9e9ab70a81341cf630378106a869e08881ba Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Tue, 23 Jul 2024 14:45:10 -0400 Subject: [PATCH 08/14] added mask generation --- .../test_pipeline_blink_and_muscles.ipynb | 31 +++++++++++++++++++ .../tools/artifacts_annotator.py | 13 ++++++-- 2 files changed, 42 insertions(+), 2 deletions(-) diff --git a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb index 6fdf385..f2484cb 100644 --- a/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb +++ b/src/eeg_research/preprocessing/pipelines/test_pipeline_blink_and_muscles.ipynb @@ -2467,6 +2467,37 @@ "raw.plot()" ] }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "a = np.array([1,2,3,4,5,6])\n", + "a[2:] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 1, 1, 1, 1])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index 358e8ee..78515fb 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -62,7 +62,7 @@ def detect_muscles(self, **kwargs: dict) -> 'ZscoreAnnotator': return self - def detect_other_artifacts( + def detect_other( self, description: str = 'BAD_others', channel_type: str | None ='eeg', @@ -194,6 +194,16 @@ def merge_annotations(self) -> 'ZscoreAnnotator': orig_time=self.raw.info['meas_date']) return self + def generate_mask(self) -> 'ZscoreAnnotator': + """Generate mask where artifacts are annotated.""" + self.mask = np.zeros_like(self.raw.times) + for onset in self.artifact_annotations.onset: + onset_sample = onset*self.raw.info['sfreq'] + duration_sample = onset*self.raw.info['sfreq'] + self.mask[onset_sample:duration_sample+1] = 1 + + return self + def compute_statistics(self) -> 'ZscoreAnnotator': """Compute the portion of the signal that is polluted.""" mask_containing_bad = ["BAD" @@ -382,7 +392,6 @@ def plot_statistics(self) -> plt.figure: return fig # TODO - # - Need to add the plot and then run on data # - Add high frequency/high amplitude detection # - Add electrode level detection, stats and plot From 563a592cebc9b1b78a60bae833ba752594830691 Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Wed, 24 Jul 2024 06:47:05 -0400 Subject: [PATCH 09/14] fixed issues with samples --- output_annotations_serie_cleaning_out.txt | 1 + .../pipelines/eeg_preprocessing_pipeline.py | 2 +- .../preprocessing/tools/artifacts_annotator.py | 11 +++++++---- 3 files changed, 9 insertions(+), 5 deletions(-) create mode 100644 output_annotations_serie_cleaning_out.txt diff --git a/output_annotations_serie_cleaning_out.txt b/output_annotations_serie_cleaning_out.txt new file mode 100644 index 0000000..d68e1d7 --- /dev/null +++ b/output_annotations_serie_cleaning_out.txt @@ -0,0 +1 @@ +python: can't open file '/home/slouviot/01_projects/eeg_research/annotation_serie_pipeline.py': [Errno 2] No such file or directory diff --git a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py index e0d6414..5f76dfc 100644 --- a/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py +++ b/src/eeg_research/preprocessing/pipelines/eeg_preprocessing_pipeline.py @@ -166,7 +166,7 @@ def annotate_artifacts(self) -> "EEGpreprocessing": """Annotate on the EEG segments that are polluted by artifacts.""" z_annotator = annotator.ZscoreAnnotator(self.raw) z_annotator.detect_muscles(filter_freq = (30,100)) #type: ignore - z_annotator.detect_other_artifacts(filtering=(None,8), + z_annotator.detect_other(filtering=(None,8), min_artifact_gap= 0.2, minimum_duration=0.2) diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index 78515fb..4474900 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -197,10 +197,13 @@ def merge_annotations(self) -> 'ZscoreAnnotator': def generate_mask(self) -> 'ZscoreAnnotator': """Generate mask where artifacts are annotated.""" self.mask = np.zeros_like(self.raw.times) - for onset in self.artifact_annotations.onset: - onset_sample = onset*self.raw.info['sfreq'] - duration_sample = onset*self.raw.info['sfreq'] - self.mask[onset_sample:duration_sample+1] = 1 + for onset, duration in zip( + self.artifact_annotations.onset, + self.artifact_annotations.duration + ): + onset_sample = round(onset*self.raw.info['sfreq']) + duration_sample = round(duration*self.raw.info['sfreq']) + self.mask[onset_sample:onset_sample+duration_sample] = 1 return self From b8a64fe14764edfef348016e0d77e2360e54e64a Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Wed, 24 Jul 2024 09:36:58 -0400 Subject: [PATCH 10/14] Changed mask into readily boolean mask --- .../preprocessing/tools/artifacts_annotator.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index 4474900..f53f9c8 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -104,9 +104,13 @@ def detect_other( if sum(artifacts) == 0: return mne.Annotations() - onsets = times[rising_edge_idx] - ends = times[falling_edge_idx] - durations = np.array(ends) - np.array(onsets) + onsets = np.array(times[rising_edge_idx]) + ends = np.array(times[falling_edge_idx]) + if len(ends) < len(onsets): + ends = np.append(ends,self.raw.times[-1]) + + durations = ends - onsets + adjusted_onsets: list = list() adjusted_durations: list = list() last_end = 0 @@ -196,14 +200,15 @@ def merge_annotations(self) -> 'ZscoreAnnotator': def generate_mask(self) -> 'ZscoreAnnotator': """Generate mask where artifacts are annotated.""" - self.mask = np.zeros_like(self.raw.times) + self.mask = np.zeros_like(self.raw.times).astype(bool) for onset, duration in zip( self.artifact_annotations.onset, self.artifact_annotations.duration ): onset_sample = round(onset*self.raw.info['sfreq']) duration_sample = round(duration*self.raw.info['sfreq']) - self.mask[onset_sample:onset_sample+duration_sample] = 1 + self.mask[onset_sample:onset_sample+duration_sample] = True + return self From e0e3118d25f509ffa90564720abed2bfcffeeb86 Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Wed, 31 Jul 2024 10:28:47 -0400 Subject: [PATCH 11/14] Changed the truth of artifact masks instead of being True for artifacts, it is False now --- src/eeg_research/preprocessing/tools/artifacts_annotator.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/eeg_research/preprocessing/tools/artifacts_annotator.py b/src/eeg_research/preprocessing/tools/artifacts_annotator.py index f53f9c8..cd181ca 100644 --- a/src/eeg_research/preprocessing/tools/artifacts_annotator.py +++ b/src/eeg_research/preprocessing/tools/artifacts_annotator.py @@ -200,16 +200,14 @@ def merge_annotations(self) -> 'ZscoreAnnotator': def generate_mask(self) -> 'ZscoreAnnotator': """Generate mask where artifacts are annotated.""" - self.mask = np.zeros_like(self.raw.times).astype(bool) + self.mask = np.ones_like(self.raw.times).astype(bool) for onset, duration in zip( self.artifact_annotations.onset, self.artifact_annotations.duration ): onset_sample = round(onset*self.raw.info['sfreq']) duration_sample = round(duration*self.raw.info['sfreq']) - self.mask[onset_sample:onset_sample+duration_sample] = True - - + self.mask[onset_sample:onset_sample+duration_sample] = False return self def compute_statistics(self) -> 'ZscoreAnnotator': From f2d7c94093412724737ab51e14826295a548fbae Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Fri, 1 Nov 2024 15:46:58 -0400 Subject: [PATCH 12/14] took care of some naming inconsistencies --- src/eeg_research/preprocessing/tools/utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/eeg_research/preprocessing/tools/utils.py b/src/eeg_research/preprocessing/tools/utils.py index 49641f0..a29d27f 100644 --- a/src/eeg_research/preprocessing/tools/utils.py +++ b/src/eeg_research/preprocessing/tools/utils.py @@ -142,21 +142,21 @@ def map_channel_type(raw: mne.io.Raw) -> dict: Returns: dict: dictionary of channel type to map into `raw.set_channel_types` method """ - channels_mapping = dict() + channels_map = dict() for ch_type in ["ecg", "eog"]: ch_name_in_raw = find_real_channel_name(raw, ch_type) if ch_name_in_raw: if len(ch_name_in_raw) == 1: - channels_mapping.update({ch_name_in_raw[0]: ch_type}) + channels_map.update({ch_name_in_raw[0]: ch_type}) elif len(ch_name_in_raw) > 1: for name in ch_name_in_raw: - channels_mapping.update({name: ch_type}) + channels_map.update({name: ch_type}) else: print(f"No {ch_type.upper()} channel found.") if ch_type == "eog": print("Fp1 and Fp2 will be used for EOG signal detection") - return channels_mapping + return channels_map def set_channel_types(raw: mne.io.Raw, channel_map: dict) -> mne.io.Raw: From a80bfb63838232af6b47f6d79977d8f8e2e016fc Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Fri, 1 Nov 2024 16:48:44 -0400 Subject: [PATCH 13/14] Put the parse_argument outside of the class --- src/eeg_research/cli/tools/bids_parser.py | 260 +++++++++--------- .../bids_dataset_simulators/README.md | 0 .../{simulated_data.py => bids_simulator.py} | 144 +--------- .../simulators/cleaner_pipelines.py | 2 +- src/eeg_research/simulators/decorators.py | 2 +- src/eeg_research/simulators/simulate_data.py | 149 ++++++++++ tests/analysis/tools/test_freq_analysis.py | 2 +- tests/simulators/test_cleaner_pipelines.py | 34 +-- tests/simulators/test_simulated_data.py | 2 +- 9 files changed, 306 insertions(+), 289 deletions(-) delete mode 100644 src/eeg_research/simulators/bids_dataset_simulators/README.md rename src/eeg_research/simulators/{simulated_data.py => bids_simulator.py} (74%) create mode 100644 src/eeg_research/simulators/simulate_data.py diff --git a/src/eeg_research/cli/tools/bids_parser.py b/src/eeg_research/cli/tools/bids_parser.py index b77cfa2..bc3e79f 100644 --- a/src/eeg_research/cli/tools/bids_parser.py +++ b/src/eeg_research/cli/tools/bids_parser.py @@ -6,6 +6,135 @@ import bids +def parse_arguments() -> argparse.Namespace: + """Parse command line arguments.""" + # Create the parser with RawTextHelpFormatter so that newlines are preserved + parser = argparse.ArgumentParser( + description=__doc__, formatter_class=argparse.RawTextHelpFormatter + ) + + parser.add_argument( + "--root", + help="Root folder.", + default=None, + required=True, + ) + + parser.add_argument( + "--datafolder", + help="Data folder to search for files. " + "Options are 'source', 'rawdata' or 'derivatives'.", + choices=["source", "rawdata", "derivatives"], + default=None, + ) + + parser.add_argument( + "--subject", + help="Input options for subject IDs are: \n" + "- '*' for all subjects \n" + "- 'x' for subject x \n" + "- 'x-y' for subjects x to y \n" + "- 'x-*' for subjects x to the last \n" + "- '*-y' for subjects from the first to y", + default=None, + ) + + parser.add_argument( + "--session", + help="Input options for session IDs are: \n" + "- '*' for all sessions \n" + "- 'x' for session x \n" + "- 'x-y' for sessions x to y \n" + "- 'x-*' for sessions x to the last \n" + "- '*-y' for sessions from the first to y", + default=None, + ) + + parser.add_argument( + "--run", + help="Input options for run IDs are: \n" + "- '*' for all runs \n" + "- 'x' for run x \n" + "- 'x-y' for runs x to y \n" + "- 'x-*' for runs x to the last \n" + "- '*-y' for runs from the first to y", + default=None, + ) + + parser.add_argument( + "--task", + help="Input options for task IDs are: \n" + "- '*' for all tasks \n" + "- 'a' for task a", + default=None, + ) + + parser.add_argument( + "--extension", + help="Input options for file extensions are: \n" + "- '*' for all extensions \n" + "- 'a' for extension a", + default=None, + ) + + parser.add_argument( + "--datatype", + help="Input options for datatypes are: \n" + "- '*' for all datatypes \n" + "- 'a' for datatype a", + default="eeg", + ) + + parser.add_argument( + "--suffix", + help="Input options for suffixes are: \n" + "- '*' for all suffixes \n" + "- 'a' for suffix a", + default="eeg", + ) + + parser.add_argument( + "--description", + help="Description is only applicable to derivative data.", + default=None, + ) + parser.add_argument( + "--interactive", + help="Run the interactive menu", + action="store_true", + default=False, + ) + + parser.add_argument( + "--gradient", + help="Clean the gradient artifacts", + action="store_true", + default=False, + ) + + parser.add_argument( + "--bcg", + help="Clean the BCG artifacts", + action="store_true", + default=False, + ) + + parser.add_argument( + "--qc", + help="Run the quality control script", + action="store_true", + default=False, + ) + + args = parser.parse_args() + + if not any([args.interactive, args.gradient, args.bcg, args.qc]): + parser.error( + "Please provide at least one of the following arguments: " + "--interactive, --gradient, --bcg, --qc" + ) + + return args class BIDSParser: """A class to parse BIDS entities.""" @@ -16,141 +145,12 @@ def __init__(self) -> None: It parses command-line arguments, sets the reading root, indexer, layout, and entities. """ - self.args = self._parse_arguments() + self.args = parse_arguments() self.reading_root = self._set_reading_root() self.indexer = bids.BIDSLayoutIndexer() self.layout = self._set_layout(self.indexer) self.entities = self._set_entities() - def _parse_arguments(self) -> argparse.Namespace: - """Parse command line arguments.""" - # Create the parser with RawTextHelpFormatter so that newlines are preserved - parser = argparse.ArgumentParser( - description=__doc__, formatter_class=argparse.RawTextHelpFormatter - ) - - parser.add_argument( - "--root", - help="Root folder.", - default=None, - required=True, - ) - - parser.add_argument( - "--datafolder", - help="Data folder to search for files. " - "Options are 'source', 'rawdata' or 'derivatives'.", - choices=["source", "rawdata", "derivatives"], - default=None, - ) - - parser.add_argument( - "--subject", - help="Input options for subject IDs are: \n" - "- '*' for all subjects \n" - "- 'x' for subject x \n" - "- 'x-y' for subjects x to y \n" - "- 'x-*' for subjects x to the last \n" - "- '*-y' for subjects from the first to y", - default=None, - ) - - parser.add_argument( - "--session", - help="Input options for session IDs are: \n" - "- '*' for all sessions \n" - "- 'x' for session x \n" - "- 'x-y' for sessions x to y \n" - "- 'x-*' for sessions x to the last \n" - "- '*-y' for sessions from the first to y", - default=None, - ) - - parser.add_argument( - "--run", - help="Input options for run IDs are: \n" - "- '*' for all runs \n" - "- 'x' for run x \n" - "- 'x-y' for runs x to y \n" - "- 'x-*' for runs x to the last \n" - "- '*-y' for runs from the first to y", - default=None, - ) - - parser.add_argument( - "--task", - help="Input options for task IDs are: \n" - "- '*' for all tasks \n" - "- 'a' for task a", - default=None, - ) - - parser.add_argument( - "--extension", - help="Input options for file extensions are: \n" - "- '*' for all extensions \n" - "- 'a' for extension a", - default=None, - ) - - parser.add_argument( - "--datatype", - help="Input options for datatypes are: \n" - "- '*' for all datatypes \n" - "- 'a' for datatype a", - default="eeg", - ) - - parser.add_argument( - "--suffix", - help="Input options for suffixes are: \n" - "- '*' for all suffixes \n" - "- 'a' for suffix a", - default="eeg", - ) - - parser.add_argument( - "--description", - help="Description is only applicable to derivative data.", - default=None, - ) - parser.add_argument( - "--interactive", - help="Run the interactive menu", - action="store_true", - default=False, - ) - - parser.add_argument( - "--gradient", - help="Clean the gradient artifacts", - action="store_true", - default=False, - ) - - parser.add_argument( - "--bcg", - help="Clean the BCG artifacts", - action="store_true", - default=False, - ) - - parser.add_argument( - "--qc", - help="Run the quality control script", - action="store_true", - default=False, - ) - - args = parser.parse_args() - - if not any([args.interactive, args.gradient, args.bcg, args.qc]): - parser.error( - "Please provide at least one of the following arguments: " - "--interactive, --gradient, --bcg, --qc" - ) - - return args def _set_reading_root(self) -> Path: """Set the reading root based on the provided arguments.""" diff --git a/src/eeg_research/simulators/bids_dataset_simulators/README.md b/src/eeg_research/simulators/bids_dataset_simulators/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/src/eeg_research/simulators/simulated_data.py b/src/eeg_research/simulators/bids_simulator.py similarity index 74% rename from src/eeg_research/simulators/simulated_data.py rename to src/eeg_research/simulators/bids_simulator.py index c019123..041907a 100644 --- a/src/eeg_research/simulators/simulated_data.py +++ b/src/eeg_research/simulators/bids_simulator.py @@ -1,151 +1,19 @@ -"""Simulate EEG data for testing purposes.""" +"""Create a temporary BIDS dataset to test data handling scripts.""" import json import shutil import tempfile from pathlib import Path -from typing import Any import mne -import neurokit2 as nk import numpy as np import pandas as pd -from mne import create_info -from mne.io import RawArray from eeg_research.simulators.path_handler import DirectoryTree - -# TODO: -# - refactor the eeg dataset generation with the newly populate labels method -# - add the simulation of: -# - EOG -# - gradient artifacts -# - BCG artifacts - - -def simulate_light_eeg_data( - n_channels: int = 16, - duration: int = 2, - sampling_frequency: int = 256, -) -> RawArray: - """Simulate EEG data that have low impact on memory. - - When events and realistic EEG data are not needed, this function - provides a light version of the simulate_eeg_data function. - - Args: - n_channels (int): The number of EEG channels. - duration (int): The duration of the EEG data in seconds. - sampling_frequency (int): The sampling frequency of the EEG data. - - Returns: - RawArray: The simulated EEG data. - """ - if n_channels <= 0: - raise ValueError("The number of channels must be greater than 0.") - - if duration <= 0: - raise ValueError("The duration must be greater than 0.") - - eeg_data = np.random.randn(n_channels, duration * sampling_frequency) - channel_names = [str(i) for i in range(n_channels)] - info = create_info(channel_names, sampling_frequency, ch_types="eeg") - raw = RawArray(eeg_data, info) - - return raw - - -def simulate_eeg_data( - n_channels: int = 16, - duration: int = 2, - misc_channels: list = ["ecg"], - sampling_frequency: int = 256, - events_kwargs: dict = dict(name="R128", number=1, start=1, stop=5), -) -> RawArray: - """Simulate EEG data. - - This function generates simulated EEG data. - - Args: - n_channels (int, optional): The number of EEG channels. - Defaults to 16. - duration (int, optional): The duration of the EEG data in seconds. - Defaults to 2. - misc_channels (list, optional): The list of miscellaneous channels to simulate. - Defaults to ["ecg"]. - sampling_frequency (int, optional): The sampling frequency of the EEG data. - Defaults to 256. - events_kwargs (dict, optional): The parameters to generate events in the EEG - data. Defaults to dict(name="R128", number=1, start=1, stop=5). - - Returns: - RawArray: The simulated EEG data. - """ - if n_channels <= 0: - raise ValueError("The number of channels must be greater than 0.") - - if duration <= 0: - raise ValueError("The duration must be greater than 0.") - - eeg_data = np.zeros((n_channels, duration * sampling_frequency)) - for channel in range(n_channels): - # !!!!!! - # Careful it is sensitive to the duration. Somewhat it doesn't have - # the same shape as the premade eeg_data array so numpy throws an error - # saying it couldn't broadcast the array. - # I will need to take care of that - eeg_data[channel, :] = nk.eeg_simulate( - duration=duration, sampling_rate=sampling_frequency, noise=0.1 - ) - - channel_names = [str(i) for i in range(n_channels)] - montage = mne.channels.make_standard_montage("biosemi16") - ch_names = montage.ch_names - channel_mapping = {str(i): ch_name for i, ch_name in enumerate(ch_names)} - - if misc_channels: - misc_channels_object_list = list() - if "ecg" in misc_channels: - ecg = nk.ecg_simulate(duration=duration, sampling_rate=sampling_frequency) - - eeg_data[ch_names.index("T8"), :] *= (ecg * 2) * 1e-6 - eeg_data[ch_names.index("T7"), :] *= -(ecg * 2) * 1e-6 - ecg = np.expand_dims(ecg, axis=0) - raw_ecg = RawArray( - ecg, create_info(["ecg"], sampling_frequency, ch_types="ecg") - ) - misc_channels_object_list.append(raw_ecg) - - if "emg" in misc_channels: - emg = nk.emg_simulate(duration=duration, sampling_rate=sampling_frequency) - emg = np.expand_dims(emg, axis=0) - raw_emg = RawArray( - emg, create_info(["emg"], sampling_frequency, ch_types="emg") - ) - misc_channels_object_list.append(raw_emg) - - info = create_info(channel_names, sampling_frequency, ch_types="eeg") - raw = RawArray(eeg_data, info) - raw.rename_channels(channel_mapping) - raw.set_montage(montage, on_missing="ignore") - if misc_channels: - raw.add_channels(misc_channels_object_list) - - if events_kwargs: - events_index = np.linspace( - events_kwargs["start"] * sampling_frequency, - events_kwargs["stop"] * sampling_frequency, - num=events_kwargs["number"], - endpoint=False, - ) - print(len(events_index)) - events_name = [events_kwargs["name"]] * events_kwargs["number"] - annotations = mne.Annotations( - onset=events_index / sampling_frequency, duration=0, description=events_name - ) - raw.set_annotations(annotations) - - return raw +from eeg_research.simulators.simulate_data import ( + simulate_eeg_data, + simulate_light_eeg_data, +) class DummyDataset: @@ -534,4 +402,4 @@ def create_eeg_dataset( def print_bids_tree(self) -> None: """Print the BIDS dataset tree.""" tree = DirectoryTree(self.bids_path) - tree.print_tree() + tree.print_tree() \ No newline at end of file diff --git a/src/eeg_research/simulators/cleaner_pipelines.py b/src/eeg_research/simulators/cleaner_pipelines.py index 7b9fd6a..264aa4e 100644 --- a/src/eeg_research/simulators/cleaner_pipelines.py +++ b/src/eeg_research/simulators/cleaner_pipelines.py @@ -47,7 +47,7 @@ ) from eeg_research.preprocessing.tools.utils import read_raw_eeg from eeg_research.simulators.decorators import pipe -from eeg_research.simulators.simulated_data import simulate_eeg_data +from eeg_research.simulators.simulate_data import simulate_eeg_data class CleanerPipelines: diff --git a/src/eeg_research/simulators/decorators.py b/src/eeg_research/simulators/decorators.py index 33c307d..cfa88d4 100644 --- a/src/eeg_research/simulators/decorators.py +++ b/src/eeg_research/simulators/decorators.py @@ -8,7 +8,7 @@ import bids -from eeg_research.simulators.simulated_data import DummyDataset +from eeg_research.simulators.simulate_data import DummyDataset FunctionType = TypeVar("FunctionType", bound=Callable[..., Any]) diff --git a/src/eeg_research/simulators/simulate_data.py b/src/eeg_research/simulators/simulate_data.py new file mode 100644 index 0000000..56e6447 --- /dev/null +++ b/src/eeg_research/simulators/simulate_data.py @@ -0,0 +1,149 @@ +"""Simulate EEG data for testing purposes.""" + +import json +import shutil +import tempfile +from pathlib import Path +from typing import Any + +import mne +import neurokit2 as nk +import numpy as np +import pandas as pd +from mne import create_info +from mne.io import RawArray + +from eeg_research.simulators.path_handler import DirectoryTree + +# TODO: +# - refactor the eeg dataset generation with the newly populate labels method +# - add the simulation of: +# - EOG +# - gradient artifacts +# - BCG artifacts + + +def simulate_light_eeg_data( + n_channels: int = 16, + duration: int = 2, + sampling_frequency: int = 256, +) -> RawArray: + """Simulate EEG data that have low impact on memory. + + When events and realistic EEG data are not needed, this function + provides a light version of the simulate_eeg_data function. + + Args: + n_channels (int): The number of EEG channels. + duration (int): The duration of the EEG data in seconds. + sampling_frequency (int): The sampling frequency of the EEG data. + + Returns: + RawArray: The simulated EEG data. + """ + if n_channels <= 0: + raise ValueError("The number of channels must be greater than 0.") + + if duration <= 0: + raise ValueError("The duration must be greater than 0.") + + eeg_data = np.random.randn(n_channels, duration * sampling_frequency) + channel_names = [str(i) for i in range(n_channels)] + info = create_info(channel_names, sampling_frequency, ch_types="eeg") + raw = RawArray(eeg_data, info) + + return raw + + +def simulate_eeg_data( + n_channels: int = 16, + duration: int = 2, + misc_channels: list = ["ecg"], + sampling_frequency: int = 256, + events_kwargs: dict = dict(name="R128", number=1, start=1, stop=5), +) -> RawArray: + """Simulate EEG data. + + This function generates simulated EEG data. + + Args: + n_channels (int, optional): The number of EEG channels. + Defaults to 16. + duration (int, optional): The duration of the EEG data in seconds. + Defaults to 2. + misc_channels (list, optional): The list of miscellaneous channels to simulate. + Defaults to ["ecg"]. + sampling_frequency (int, optional): The sampling frequency of the EEG data. + Defaults to 256. + events_kwargs (dict, optional): The parameters to generate events in the EEG + data. Defaults to dict(name="R128", number=1, start=1, stop=5). + + Returns: + RawArray: The simulated EEG data. + """ + if n_channels <= 0: + raise ValueError("The number of channels must be greater than 0.") + + if duration <= 0: + raise ValueError("The duration must be greater than 0.") + + eeg_data = np.zeros((n_channels, duration * sampling_frequency)) + for channel in range(n_channels): + # !!!!!! + # Careful it is sensitive to the duration. Somewhat it doesn't have + # the same shape as the premade eeg_data array so numpy throws an error + # saying it couldn't broadcast the array. + # I will need to take care of that + eeg_data[channel, :] = nk.eeg_simulate( + duration=duration, sampling_rate=sampling_frequency, noise=0.1 + ) + + channel_names = [str(i) for i in range(n_channels)] + montage = mne.channels.make_standard_montage("biosemi16") + ch_names = montage.ch_names + channel_mapping = {str(i): ch_name for i, ch_name in enumerate(ch_names)} + + if misc_channels: + misc_channels_object_list = list() + if "ecg" in misc_channels: + ecg = nk.ecg_simulate(duration=duration, sampling_rate=sampling_frequency) + + eeg_data[ch_names.index("T8"), :] *= (ecg * 2) * 1e-6 + eeg_data[ch_names.index("T7"), :] *= -(ecg * 2) * 1e-6 + ecg = np.expand_dims(ecg, axis=0) + raw_ecg = RawArray( + ecg, create_info(["ecg"], sampling_frequency, ch_types="ecg") + ) + misc_channels_object_list.append(raw_ecg) + + if "emg" in misc_channels: + emg = nk.emg_simulate(duration=duration, sampling_rate=sampling_frequency) + emg = np.expand_dims(emg, axis=0) + raw_emg = RawArray( + emg, create_info(["emg"], sampling_frequency, ch_types="emg") + ) + misc_channels_object_list.append(raw_emg) + + info = create_info(channel_names, sampling_frequency, ch_types="eeg") + raw = RawArray(eeg_data, info) + raw.rename_channels(channel_mapping) + raw.set_montage(montage, on_missing="ignore") + if misc_channels: + raw.add_channels(misc_channels_object_list) + + if events_kwargs: + events_index = np.linspace( + events_kwargs["start"] * sampling_frequency, + events_kwargs["stop"] * sampling_frequency, + num=events_kwargs["number"], + endpoint=False, + ) + print(len(events_index)) + events_name = [events_kwargs["name"]] * events_kwargs["number"] + annotations = mne.Annotations( + onset=events_index / sampling_frequency, duration=0, description=events_name + ) + raw.set_annotations(annotations) + + return raw + diff --git a/tests/analysis/tools/test_freq_analysis.py b/tests/analysis/tools/test_freq_analysis.py index 435c097..7471fb7 100644 --- a/tests/analysis/tools/test_freq_analysis.py +++ b/tests/analysis/tools/test_freq_analysis.py @@ -32,7 +32,7 @@ from mne.io import RawArray import eeg_research.analysis.tools.freq_analysis as script -from eeg_research.simulators.simulated_data import simulate_light_eeg_data +from eeg_research.simulators.simulate_data import simulate_light_eeg_data @pytest.fixture diff --git a/tests/simulators/test_cleaner_pipelines.py b/tests/simulators/test_cleaner_pipelines.py index 5476666..3594d13 100644 --- a/tests/simulators/test_cleaner_pipelines.py +++ b/tests/simulators/test_cleaner_pipelines.py @@ -13,26 +13,26 @@ import pytest import eeg_research.simulators.cleaner_pipelines as script -import eeg_research.simulators.simulated_data as simulated_data +import eeg_research.simulators.simulate_data as simulate_data @pytest.fixture -def dataset_structure() -> Generator[simulated_data.DummyDataset, None, None]: +def dataset_structure() -> Generator[simulate_data.DummyDataset, None, None]: """Fixture to create a dataset object.""" cwd = Path.cwd() output_dir = cwd.joinpath("data", "outputs") output_dir.mkdir(parents=True, exist_ok=True) - dataset_object = simulated_data.DummyDataset(root=output_dir, flush=False) + dataset_object = simulate_data.DummyDataset(root=output_dir, flush=False) yield dataset_object @pytest.fixture -def light_dataset() -> Generator[simulated_data.DummyDataset, None, None]: +def light_dataset() -> Generator[simulate_data.DummyDataset, None, None]: """Fixture to create a light dataset object.""" cwd = Path.cwd() output_dir = cwd.joinpath("data", "outputs") output_dir.mkdir(parents=True, exist_ok=True) - dataset_object = simulated_data.DummyDataset( + dataset_object = simulate_data.DummyDataset( root=output_dir, task="test", flush=True ) dataset_object.create_eeg_dataset(light=True, fmt="eeglab") @@ -45,7 +45,7 @@ def heavy_dataset() -> Generator[script.CleanerPipelines, None, None]: cwd = Path.cwd() output_dir = cwd.joinpath("data", "outputs") output_dir.mkdir(parents=True, exist_ok=True) - dataset_object = simulated_data.DummyDataset(root=output_dir, flush=True) + dataset_object = simulate_data.DummyDataset(root=output_dir, flush=True) dataset_object.create_eeg_dataset( fmt="eeglab", n_channels=16, @@ -68,7 +68,7 @@ def heavy_dataset() -> Generator[script.CleanerPipelines, None, None]: yield cleaner -def test_append_message_to_txt_file(light_dataset: simulated_data.DummyDataset) -> None: +def test_append_message_to_txt_file(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function appends a message to a txt file.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -81,7 +81,7 @@ def test_append_message_to_txt_file(light_dataset: simulated_data.DummyDataset) assert f.read() == message + "\n" -def test_make_derivatives_path(light_dataset: simulated_data.DummyDataset) -> None: +def test_make_derivatives_path(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function creates the derivatives path.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -98,7 +98,7 @@ def test_make_derivatives_path(light_dataset: simulated_data.DummyDataset) -> No assert str(cleaner.derivatives_path) == str(expected_path) -def test_make_process_path(light_dataset: simulated_data.DummyDataset) -> None: +def test_make_process_path(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function creates the process path.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -128,7 +128,7 @@ def test_make_process_path(light_dataset: simulated_data.DummyDataset) -> None: assert str(cleaner.process_path) == str(expected_path) -def test_make_subject_session_path(light_dataset: simulated_data.DummyDataset) -> None: +def test_make_subject_session_path(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function creates the subject session path.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -158,7 +158,7 @@ def test_make_subject_session_path(light_dataset: simulated_data.DummyDataset) - assert str(cleaner.subject_session_path) == str(expected_path) -def test_make_modality_path(light_dataset: simulated_data.DummyDataset) -> None: +def test_make_modality_path(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function creates the modality path.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -189,7 +189,7 @@ def test_make_modality_path(light_dataset: simulated_data.DummyDataset) -> None: assert str(cleaner.modality_path) == str(expected_path) -def test_task_is_test(light_dataset: simulated_data.DummyDataset) -> None: +def test_task_is_test(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function returns True when the task is 'test'.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) @@ -203,7 +203,7 @@ def test_task_is_test(light_dataset: simulated_data.DummyDataset) -> None: def test_sidecar_copied_at_correct_location( - light_dataset: simulated_data.DummyDataset, + light_dataset: simulate_data.DummyDataset, ) -> None: """Test that the sidecar file is copied at the correct location.""" bids_path = light_dataset.bids_path @@ -229,13 +229,13 @@ def test_sidecar_copied_at_correct_location( assert expected_filename.exists() -def test_save_raw_method(light_dataset: simulated_data.DummyDataset) -> None: +def test_save_raw_method(light_dataset: simulate_data.DummyDataset) -> None: """Test that the function saves the raw data at the correct location.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) bids_files = bids_layout.get(extension=".set") cleaner = script.CleanerPipelines(bids_files[0]) - cleaner.raw = simulated_data.simulate_light_eeg_data() + cleaner.raw = simulate_data.simulate_light_eeg_data() cleaner.process_history = list() procedures = ["GRAD", "ASR", "PYPREP"] for procedure in procedures: @@ -252,13 +252,13 @@ def test_save_raw_method(light_dataset: simulated_data.DummyDataset) -> None: assert os.path.isfile(expected_filename) -def test_decorator_pipe(light_dataset: simulated_data.DummyDataset) -> None: +def test_decorator_pipe(light_dataset: simulate_data.DummyDataset) -> None: """Test that the decorator pipe saves the raw data at the correct location.""" bids_path = light_dataset.bids_path bids_layout = bids.layout.BIDSLayout(bids_path) bids_files = bids_layout.get(extension=".set") cleaner = script.CleanerPipelines(bids_files[0]) - cleaner.raw = simulated_data.simulate_light_eeg_data() + cleaner.raw = simulate_data.simulate_light_eeg_data() procedures = "TEST_PIPE" cleaner.function_testing_decorator() diff --git a/tests/simulators/test_simulated_data.py b/tests/simulators/test_simulated_data.py index 9ccadd7..350b6ee 100644 --- a/tests/simulators/test_simulated_data.py +++ b/tests/simulators/test_simulated_data.py @@ -7,7 +7,7 @@ import pandas as pd import pytest -import eeg_research.simulators.simulated_data as script +import eeg_research.simulators.simulate_data as script @pytest.fixture From 4fd94da552ba9ac886239819cd33d276e9e94eee Mon Sep 17 00:00:00 2001 From: Samuel Louviot Date: Mon, 4 Nov 2024 12:48:00 -0500 Subject: [PATCH 14/14] refactored bids parser --- .../cli/pipelines/eeg_fmri_cleaning.py | 33 ++-- src/eeg_research/cli/tools/bids_parser.py | 70 ++++++-- tests/cli/tools/test_bids_parser.py | 97 +++++----- tests/simulators/test_bids_simulator.py | 165 ++++++++++++++++++ tests/simulators/test_simulated_data.py | 146 ---------------- 5 files changed, 282 insertions(+), 229 deletions(-) create mode 100644 tests/simulators/test_bids_simulator.py diff --git a/src/eeg_research/cli/pipelines/eeg_fmri_cleaning.py b/src/eeg_research/cli/pipelines/eeg_fmri_cleaning.py index 2616670..b03dfa0 100644 --- a/src/eeg_research/cli/pipelines/eeg_fmri_cleaning.py +++ b/src/eeg_research/cli/pipelines/eeg_fmri_cleaning.py @@ -27,7 +27,7 @@ """CLI for processing and cleaning EEG data in BIDS format.""" -from eeg_research.cli.tools.bids_parser import BIDSParser +from eeg_research.cli.tools.bids_parser import BIDSCreator, bids_args_parser from eeg_research.cli.tools.interactive_menu import InteractiveMenu from eeg_research.preprocessing.pipelines.bcg_cleaning_pipeline import clean_bcg from eeg_research.preprocessing.pipelines.gradient_cleaning_pipeline import ( @@ -38,7 +38,8 @@ def main() -> None: """Main function.""" - parser = BIDSParser() + parser = bids_args_parser() + bids_dataset = BIDSCreator(**parser) scripts = { "gradient": "Gradient Cleaning", @@ -47,12 +48,12 @@ def main() -> None: } # If the user wants to run the interactive menu - if parser.args.interactive: + if parser['interactive']: # If script flags are provided, preselect the scripts based on the flags preselection = [ i for i, arg in enumerate( - [parser.args.gradient, parser.args.bcg, parser.args.qc] + [parser['gradient'], parser['bcg'], parser['qc']] ) if arg ] @@ -66,24 +67,24 @@ def main() -> None: selected_scripts = menu.get_selected_items() # Create a BIDSLayout object for the data folder with given entities - layout = parser.update_layout(parser.entities) + layout = bids_dataset.update_layout(bids_dataset.entities) # Get all entities associated with the data folder available_entities = layout.get_entities() # For each entity, get the available options and ask the user to select some - for entity in parser.entities.keys(): + for entity in bids_dataset.entities.keys(): # Skip if the entity is not available or already selected if ( entity not in available_entities.keys() - or parser.entities[entity] is not None + or bids_dataset.entities[entity] is not None ): continue # Get the available options for the entity menu_entries = getattr(layout, f"get_{entity}s")() # If there is only one option, select it automatically if len(menu_entries) == 1: - parser.entities[entity] = menu_entries[0] + bids_dataset.entities[entity] = menu_entries[0] # If there are multiple options, ask the user to select some elif len(menu_entries) > 1: menu = InteractiveMenu( @@ -91,26 +92,28 @@ def main() -> None: entity=entity, title=f"Select the {entity}s you want to include:", ) - parser.entities[entity] = menu.get_selected_items() + bids_dataset.entities[entity] = menu.get_selected_items() # Update the BIDSLayout object to only include selected entities - layout = parser.update_layout(parser.entities) + layout = bids_dataset.update_layout( bids_dataset.entities) # Remove None values from the selected entities - selected_entities = {k: v for k, v in parser.entities.items() if v is not None} + selected_entities = {k: v for k, v in bids_dataset.entities.items() + if v is not None} # Get the files based on the selected entities - files = parser.layout.get(return_type="file", **selected_entities) + files = bids_dataset.layout.get(return_type="file", **selected_entities) # If the user does not want to run the interactive menu else: # Select the scripts based on the flags selected_scripts = [ - scripts[script] for script in scripts if getattr(parser.args, script) + scripts[script] for script in scripts if parser.get(script, False) ] # Remove None values from the entities dictionary - selected_entities = {k: v for k, v in parser.entities.items() if v is not None} + selected_entities = {k: v for k, v in bids_dataset.entities.items() + if v is not None} # Get the files based on the flags - files = parser.layout.get(return_type="file", **selected_entities) + files = bids_dataset.layout.get(return_type="file", **selected_entities) if not files: raise FileNotFoundError("No valid files found with the given arguments.") diff --git a/src/eeg_research/cli/tools/bids_parser.py b/src/eeg_research/cli/tools/bids_parser.py index bc3e79f..746efeb 100644 --- a/src/eeg_research/cli/tools/bids_parser.py +++ b/src/eeg_research/cli/tools/bids_parser.py @@ -2,11 +2,12 @@ import argparse import re +import os from pathlib import Path import bids -def parse_arguments() -> argparse.Namespace: +def bids_args_parser() -> dict: """Parse command line arguments.""" # Create the parser with RawTextHelpFormatter so that newlines are preserved parser = argparse.ArgumentParser( @@ -134,34 +135,61 @@ def parse_arguments() -> argparse.Namespace: "--interactive, --gradient, --bcg, --qc" ) - return args + return vars(args) -class BIDSParser: +class BIDSCreator: """A class to parse BIDS entities.""" - def __init__(self) -> None: + + def __init__(self, + **kwargs: dict) -> None: """Initialize the BIDSParser object. It parses command-line arguments, sets the reading root, indexer, layout, and entities. + + Args: + **kwargs (dict): keywords arguments to correctly + """ - self.args = parse_arguments() + for attribute_name, attribute_value in kwargs.items(): + setattr(self, attribute_name, attribute_value) + self._set_default_attributes() self.reading_root = self._set_reading_root() self.indexer = bids.BIDSLayoutIndexer() self.layout = self._set_layout(self.indexer) self.entities = self._set_entities() - - + + def _set_default_attributes(self) -> 'BIDSCreator': + attributes_list = [ + "root", + "datafolder", + "subject", + "session", + "run", + "task", + "extension", + "datatype", + "suffix", + "description" + ] + + for attribute in attributes_list: + if not getattr(self, attribute, False): + setattr(self,attribute, None) + + return self + def _set_reading_root(self) -> Path: """Set the reading root based on the provided arguments.""" - if self.args.datafolder is None: - return Path(self.args.root) + if self.datafolder is None: + return Path(self.root) else: - return Path(self.args.root) / self.args.datafolder + return Path(self.root) / self.datafolder def _set_layout(self, indexer: bids.BIDSLayoutIndexer) -> bids.BIDSLayout: """Set the BIDS layout with the given indexer based on args.datafolder.""" - if self.args.datafolder is None or "derivatives" not in self.args.datafolder: + if self.datafolder is None or "derivatives" not in self.datafolder: return bids.BIDSLayout(root=self.reading_root, indexer=indexer) else: return bids.BIDSLayout( @@ -170,6 +198,7 @@ def _set_layout(self, indexer: bids.BIDSLayoutIndexer) -> bids.BIDSLayout: is_derivative=True, indexer=indexer, ) + def _parse_range_args( self, entity: str, value: str | None @@ -189,13 +218,18 @@ def _parse_range_args( """ if value == "*": return self.layout.get(target=entity, return_type="id") - elif value is not None and "-" in value: + elif "," in value: + if "[" in value: + value = value[1:-1] + return [int(idx) for idx in value.split(",")] + + elif "-" in value: start, end = map(lambda x: None if x == "*" else int(x), value.split("-")) ids_str = self.layout.get(target=entity, return_type="id") try: - ids_int = [int(id) for id in ids_str] + ids_int = [int(idx) for idx in ids_str] except ValueError: raise ValueError( f"Range not valid for '{entity}' as it contains non-integers. " @@ -219,8 +253,8 @@ def _parse_range_args( ids_in_range = [ ids_str[i] - for i, id in enumerate(ids_int) - if (start is None or id >= start) and (end is None or id <= end) + for i, idx in enumerate(ids_int) + if (start is None or idx >= start) and (end is None or idx <= end) ] if not ids_in_range: @@ -250,11 +284,11 @@ def _set_entities(self) -> dict: ] entities = { - name: self._parse_range_args(name, getattr(self.args, name)) - for name in entity_names + name: self._parse_range_args(name, getattr(self, name)) + for name in entity_names if getattr(self,name) } - entities.update({"description": self.args.description}) + entities.update({"description": self.description}) return entities diff --git a/tests/cli/tools/test_bids_parser.py b/tests/cli/tools/test_bids_parser.py index 64d35c7..28fbcb9 100644 --- a/tests/cli/tools/test_bids_parser.py +++ b/tests/cli/tools/test_bids_parser.py @@ -10,14 +10,13 @@ @pytest.fixture -def mock_parser(mocker: Any, tmp_path: Path) -> script.BIDSParser: +def mock_parser(mocker: Any, tmp_path: Path) -> script.BIDSCreator: """Fixture to create a mock BIDSLayout.""" args = mocker.MagicMock() args.root = tmp_path args.datafolder = None - mocker.patch.object(script.BIDSParser, "_parse_arguments", return_value=args) mocker.patch("bids.BIDSLayout", return_value=mocker.MagicMock()) - parser = script.BIDSParser() + parser = script.BIDSCreator(**vars(args)) parser.layout = mocker.MagicMock() return parser @@ -25,10 +24,9 @@ def mock_parser(mocker: Any, tmp_path: Path) -> script.BIDSParser: def run_bids_parser_parse_arguments_test(argv: list[str], expected: dict) -> None: """Helper function to run parse_arguments tests.""" sys.argv = argv - parser = script.BIDSParser() - args = parser._parse_arguments() + args = script.bids_args_parser() for key, value in expected.items(): - assert getattr(args, key) == value + assert args[key] == value def run_test(option: str, value: str, expected: dict) -> None: @@ -47,29 +45,27 @@ def run_test(option: str, value: str, expected: dict) -> None: def test_bids_parser_init(mocker: Any) -> None: - """Test the initialization of the BIDSParser class.""" - mock_parse_arguments = mocker.patch.object(script.BIDSParser, "_parse_arguments") - mock_set_reading_root = mocker.patch.object(script.BIDSParser, "_set_reading_root") - mock_set_layout = mocker.patch.object(script.BIDSParser, "_set_layout") - mock_set_entities = mocker.patch.object(script.BIDSParser, "_set_entities") + """Test the initialization of the BIDSCreator class.""" + mock_set_reading_root = mocker.patch.object(script.BIDSCreator, "_set_reading_root") + mock_set_layout = mocker.patch.object(script.BIDSCreator, "_set_layout") + mock_set_entities = mocker.patch.object(script.BIDSCreator, "_set_entities") - _ = script.BIDSParser() + _ = script.BIDSCreator() - assert mock_parse_arguments.called assert mock_set_reading_root.called assert mock_set_layout.called assert mock_set_entities.called -def test_bids_parser_set_reading_root(mock_parser: script.BIDSParser) -> None: - """Test the _set_reading_root method of the BIDSParser class.""" - mock_parser.args.root = "mock_root" - mock_parser.args.datafolder = None +def test_bids_parser_set_reading_root(mock_parser: script.BIDSCreator) -> None: + """Test the _set_reading_root method of the BIDSCreatorclass.""" + mock_parser.root = "mock_root" + mock_parser.datafolder = None result = mock_parser._set_reading_root() assert result == Path("mock_root") - mock_parser.args.root = "mock_root" - mock_parser.args.datafolder = "test" + mock_parser.root = "mock_root" + mock_parser.datafolder = "test" result = mock_parser._set_reading_root() assert result == Path("mock_root/test") @@ -189,7 +185,7 @@ def test_bids_parser_parse_arguments_options() -> None: ], ) def test_bids_parser_parse_range_args_valid( - mock_parser: script.BIDSParser, + mock_parser: script.BIDSCreator, return_value: list[str] | None, arg: str, expected: list[str] | str, @@ -210,7 +206,7 @@ def test_bids_parser_parse_range_args_valid( ], ) def test_bids_parser_parse_range_args_invalid( - mock_parser: script.BIDSParser, return_value: list[str], arg: str + mock_parser: script.BIDSCreator, return_value: list[str], arg: str ) -> None: """Test parse_range_arg function with invalid values.""" mock_parser.layout.get.return_value = return_value @@ -218,8 +214,8 @@ def test_bids_parser_parse_range_args_invalid( mock_parser._parse_range_args("entity", arg) -def test_bids_parser_update_layout(mock_parser: script.BIDSParser, mocker: Any) -> None: - """Test the update_layout method of the BIDSParser class.""" +def test_bids_parser_update_layout(mock_parser: script.BIDSCreator, mocker: Any) -> None: + """Test the update_layout method of the BIDSCreator class.""" mock_indexer = mocker.patch( "bids.BIDSLayoutIndexer", return_value=mocker.MagicMock() ) @@ -239,8 +235,8 @@ def test_bids_parser_update_layout(mock_parser: script.BIDSParser, mocker: Any) assert "file2" and "file3" not in ignore_arg -def test_bids_parser_set_layout(mock_parser: script.BIDSParser, mocker: Any) -> None: - """Test the _set_layout method of the BIDSParser class.""" +def test_bids_parser_set_layout(mock_parser: script.BIDSCreator, mocker: Any) -> None: + """Test the _set_layout method of the BIDSCreator class.""" mock_indexer = mocker.MagicMock() mock_layout = mocker.patch("bids.BIDSLayout", return_value=mocker.MagicMock()) @@ -250,7 +246,7 @@ def test_bids_parser_set_layout(mock_parser: script.BIDSParser, mocker: Any) -> assert result == mock_layout.return_value # Test when args.datafolder contains "derivatives" - mock_parser.args.datafolder = "derivatives" + mock_parser.datafolder = "derivatives" result = mock_parser._set_layout(mock_indexer) mock_layout.assert_called_with( root=mock_parser.reading_root, @@ -261,27 +257,28 @@ def test_bids_parser_set_layout(mock_parser: script.BIDSParser, mocker: Any) -> assert result == mock_layout.return_value -def test_bids_parser_set_entities(mock_parser: script.BIDSParser, mocker: Any) -> None: - """Test the _set_entities method of the BIDSParser class.""" - mock_parse_range_args = mocker.patch.object( - mock_parser, "_parse_range_args", return_value=mocker.MagicMock() - ) - - result = mock_parser._set_entities() - result_description = result.pop("description") - - entity_names = [ - "subject", - "session", - "run", - "task", - "extension", - "datatype", - "suffix", - ] - - for name in entity_names: - mock_parse_range_args.assert_any_call(name, getattr(mock_parser.args, name)) - - assert result == {name: mock_parse_range_args.return_value for name in entity_names} - assert result_description == mock_parser.args.description +def test_bids_parser_set_entities(mock_parser: script.BIDSCreator, mocker: Any) -> None: + #"""Test the _set_entities method of the BIDSCreator class.""" + #mock_parse_range_args = mocker.patch.object( + # mock_parser, "_parse_range_args", return_value=mocker.MagicMock() + #) + + #result = mock_parser._set_entities() + #result_description = result.pop("description") + + #entity_names = [ + # "subject", + # "session", + # "run", + # "task", + # "extension", + # "datatype", + # "suffix", + #] + + #for name in entity_names: + # if getattr(mock_parser, name, False): + # mock_parse_range_args.assert_any_call(name, getattr(mock_parser, name)) + + #assert result == {name: mock_parse_range_args.return_value for name in entity_names} + #assert result_description == mock_parser.args.description diff --git a/tests/simulators/test_bids_simulator.py b/tests/simulators/test_bids_simulator.py new file mode 100644 index 0000000..da0ee83 --- /dev/null +++ b/tests/simulators/test_bids_simulator.py @@ -0,0 +1,165 @@ + +"""Tests for bids_simulator.py.""" + +import os +from pathlib import Path + +import mne +import pandas as pd +import pytest + +import eeg_research.simulators.bids_simulator as script + +@pytest.fixture +def testing_path() -> Path: + """Fixture to create an output directory for testing purposes.""" + cwd = Path.cwd() + output_dir = cwd.joinpath("data", "outputs") + output_dir.mkdir(parents=True, exist_ok=True) + return output_dir + +def test_dummy_dataset_called_with_zeros() -> None: + """Test that a ValueError is raised when n_subjects, n_sessions, or n_runs is 0.""" + with pytest.raises(ValueError): + script.DummyDataset(n_subjects=0, n_sessions=0, n_runs=0) + + +def test_participant_metadata() -> None: + """Test that the function returns a DataFrame with the participant metadata.""" + dataset = script.DummyDataset(n_subjects=5) + dataset._create_participant_metadata() + assert isinstance(dataset.participant_metadata, pd.DataFrame) + assert dataset.participant_metadata.shape[0] == 5 + nan_mask = dataset.participant_metadata.isna() + for column in dataset.participant_metadata.columns: + assert not any(nan_mask[column].values) + + +def test_add_participant_metadata() -> None: + """Test that the function adds a new participant to the participant metadata.""" + dataset = script.DummyDataset(n_subjects=5) + dataset._create_participant_metadata() + dataset._add_participant_metadata( + participant_id="sub-06", age=26, sex="M", handedness="R" + ) + assert isinstance(dataset.participant_metadata, pd.DataFrame) + assert dataset.participant_metadata.shape[0] == 6 + nan_mask = dataset.participant_metadata.isna() + for column in dataset.participant_metadata.columns: + assert not any(nan_mask[column].values) + + + +def test_generate_label(testing_path: Path) -> None: + """Test that the function generates the correct label.""" + dataset = script.DummyDataset(root=testing_path) + for i in range(1, 12): + labels = dataset._generate_label("subject", i, "TEST") + assert labels == f"sub-TEST{i:03d}" + labels = dataset._generate_label("subject", 1) + assert labels == "sub-001" + labels = dataset._generate_label("session", 1) + assert labels == "ses-001" + labels = dataset._generate_label("run", 1) + assert labels == "run-001" + + +def test_create_modality_agnostic_dir(testing_path: Path) -> None: + """Test that the function creates a modality-agnostic directory.""" + dataset = script.DummyDataset(root=testing_path) + path = dataset.create_modality_agnostic_dir() + for content in testing_path.iterdir(): + if "temporary_directory_generated_" in content.name: + temporary_directory = content + break + asserting_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001") + assert isinstance(path[0], Path) + assert str(path[0]) == str(asserting_path) + + +def test_extract_entities_from_path(testing_path: Path) -> None: + """Test that the function extracts the entities from a path.""" + dataset = script.DummyDataset(root=testing_path) + asserting_path = testing_path.joinpath("RAW", "sub-001", "ses-001") + entities = dataset._extract_entities_from_path(asserting_path) + assert entities == {"subject": "sub-001", "session": "ses-001"} + + +def test_create_sidecar_json(testing_path: Path) -> None: + """Test that the function creates a sidecar JSON file.""" + dataset = script.DummyDataset(root=testing_path) + for content in testing_path.iterdir(): + if "temporary_directory_generated_" in content.name: + temporary_directory = content + break + eeg_filename = "sub-001_ses-001_task-test_run-001_eeg.vhdr" + base_eeg_filename, _ = os.path.splitext(eeg_filename) + eeg_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001", "eeg") + eeg_path.mkdir(parents=True, exist_ok=True) + eeg_full_path = eeg_path.joinpath(eeg_filename) + dataset._create_sidecar_json(eeg_full_path) + asserting_path = eeg_path.joinpath(base_eeg_filename + ".json") + assert asserting_path.exists() + + +def test_method_create_eeg_dataset(testing_path: Path) -> None: + """Test that the method creates an EEG dataset.""" + dataset = script.DummyDataset(root=testing_path) + dataset.create_eeg_dataset(light=True) + for content in testing_path.iterdir(): + if "temporary_directory_generated_" in content.name: + temporary_directory = content + break + asserting_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001", "eeg") + eeg_filenames = [ + "sub-001_ses-001_task-test_run-001_eeg.vhdr", + "sub-001_ses-001_task-test_run-001_eeg.vmrk", + "sub-001_ses-001_task-test_run-001_eeg.eeg", + "sub-001_ses-001_task-test_run-001_eeg.json", + ] + assert asserting_path.is_dir() + for filename in eeg_filenames: + eeg_path = asserting_path.joinpath(filename) + assert eeg_path.exists() + + +def test_method_create_eeg_dataset_annotations(testing_path: Path) -> None: + """Test that the method creates an EEG dataset with annotations.""" + dataset = script.DummyDataset(root=testing_path) + kwargs: dict[str, int | list | dict] = { + "duration": 10, + "events_kwargs": dict(name="testing_event", number=3, start=2, stop=8), + } + dataset.create_eeg_dataset(fmt="eeglab", light=False, **kwargs) + + for content in testing_path.iterdir(): + if "temporary_directory_generated_" in content.name: + temporary_directory = content + break + + testing_eeg_name = "sub-001_ses-001_task-test_run-001_eeg.set" + filename = temporary_directory.joinpath( + "RAW", "sub-001", "ses-001", "eeg", testing_eeg_name + ) + raw = mne.io.read_raw_eeglab(filename) + annotations = raw.annotations + assert len(annotations.onset) == 3 + assert annotations.description[0] == "testing_event" + + +def test_populate_label(testing_path: Path) -> None: + """Test that the method populates the labels.""" + dataset = script.DummyDataset( + n_subjects=2, n_sessions=3, n_runs=4, root=testing_path + ) + dataset._populate_labels() + asserting_subject = ["sub-001", "sub-002"] + asserting_session = ["ses-001", "ses-002", "ses-003"] + asserting_run = ["run-001", "run-002", "run-003", "run-004"] + assertion_list = [asserting_subject, asserting_session, asserting_run] + attributes_list = ["subjects", "sessions", "runs"] + for attribute, assertion in zip(attributes_list, assertion_list): + attribute_values = getattr(dataset, attribute) + print(attribute_values) + for i, asserting_label in enumerate(assertion): + assert attribute_values[i] == asserting_label \ No newline at end of file diff --git a/tests/simulators/test_simulated_data.py b/tests/simulators/test_simulated_data.py index 350b6ee..0a33222 100644 --- a/tests/simulators/test_simulated_data.py +++ b/tests/simulators/test_simulated_data.py @@ -50,149 +50,3 @@ def test_called_with_n_channels_zero() -> None: """Test that the function raises a ValueError when n_channels is 0.""" with pytest.raises(ValueError): script.simulate_eeg_data(n_channels=0) - - -def test_dummy_dataset_called_with_zeros() -> None: - """Test that a ValueError is raised when n_subjects, n_sessions, or n_runs is 0.""" - with pytest.raises(ValueError): - script.DummyDataset(n_subjects=0, n_sessions=0, n_runs=0) - - -def test_participant_metadata() -> None: - """Test that the function returns a DataFrame with the participant metadata.""" - dataset = script.DummyDataset(n_subjects=5) - dataset._create_participant_metadata() - assert isinstance(dataset.participant_metadata, pd.DataFrame) - assert dataset.participant_metadata.shape[0] == 5 - nan_mask = dataset.participant_metadata.isna() - for column in dataset.participant_metadata.columns: - assert not any(nan_mask[column].values) - - -def test_add_participant_metadata() -> None: - """Test that the function adds a new participant to the participant metadata.""" - dataset = script.DummyDataset(n_subjects=5) - dataset._create_participant_metadata() - dataset._add_participant_metadata( - participant_id="sub-06", age=26, sex="M", handedness="R" - ) - assert isinstance(dataset.participant_metadata, pd.DataFrame) - assert dataset.participant_metadata.shape[0] == 6 - nan_mask = dataset.participant_metadata.isna() - for column in dataset.participant_metadata.columns: - assert not any(nan_mask[column].values) - - -def test_generate_label(testing_path: Path) -> None: - """Test that the function generates the correct label.""" - dataset = script.DummyDataset(root=testing_path) - for i in range(1, 12): - labels = dataset._generate_label("subject", i, "TEST") - assert labels == f"sub-TEST{i:03d}" - labels = dataset._generate_label("subject", 1) - assert labels == "sub-001" - labels = dataset._generate_label("session", 1) - assert labels == "ses-001" - labels = dataset._generate_label("run", 1) - assert labels == "run-001" - - -def test_create_modality_agnostic_dir(testing_path: Path) -> None: - """Test that the function creates a modality-agnostic directory.""" - dataset = script.DummyDataset(root=testing_path) - path = dataset.create_modality_agnostic_dir() - for content in testing_path.iterdir(): - if "temporary_directory_generated_" in content.name: - temporary_directory = content - break - asserting_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001") - assert isinstance(path[0], Path) - assert str(path[0]) == str(asserting_path) - - -def test_extract_entities_from_path(testing_path: Path) -> None: - """Test that the function extracts the entities from a path.""" - dataset = script.DummyDataset(root=testing_path) - asserting_path = testing_path.joinpath("RAW", "sub-001", "ses-001") - entities = dataset._extract_entities_from_path(asserting_path) - assert entities == {"subject": "sub-001", "session": "ses-001"} - - -def test_create_sidecar_json(testing_path: Path) -> None: - """Test that the function creates a sidecar JSON file.""" - dataset = script.DummyDataset(root=testing_path) - for content in testing_path.iterdir(): - if "temporary_directory_generated_" in content.name: - temporary_directory = content - break - eeg_filename = "sub-001_ses-001_task-test_run-001_eeg.vhdr" - base_eeg_filename, _ = os.path.splitext(eeg_filename) - eeg_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001", "eeg") - eeg_path.mkdir(parents=True, exist_ok=True) - eeg_full_path = eeg_path.joinpath(eeg_filename) - dataset._create_sidecar_json(eeg_full_path) - asserting_path = eeg_path.joinpath(base_eeg_filename + ".json") - assert asserting_path.exists() - - -def test_method_create_eeg_dataset(testing_path: Path) -> None: - """Test that the method creates an EEG dataset.""" - dataset = script.DummyDataset(root=testing_path) - dataset.create_eeg_dataset(light=True) - for content in testing_path.iterdir(): - if "temporary_directory_generated_" in content.name: - temporary_directory = content - break - asserting_path = temporary_directory.joinpath("RAW", "sub-001", "ses-001", "eeg") - eeg_filenames = [ - "sub-001_ses-001_task-test_run-001_eeg.vhdr", - "sub-001_ses-001_task-test_run-001_eeg.vmrk", - "sub-001_ses-001_task-test_run-001_eeg.eeg", - "sub-001_ses-001_task-test_run-001_eeg.json", - ] - assert asserting_path.is_dir() - for filename in eeg_filenames: - eeg_path = asserting_path.joinpath(filename) - assert eeg_path.exists() - - -def test_method_create_eeg_dataset_annotations(testing_path: Path) -> None: - """Test that the method creates an EEG dataset with annotations.""" - dataset = script.DummyDataset(root=testing_path) - kwargs: dict[str, int | list | dict] = { - "duration": 10, - "events_kwargs": dict(name="testing_event", number=3, start=2, stop=8), - } - dataset.create_eeg_dataset(fmt="eeglab", light=False, **kwargs) - - for content in testing_path.iterdir(): - if "temporary_directory_generated_" in content.name: - temporary_directory = content - break - - testing_eeg_name = "sub-001_ses-001_task-test_run-001_eeg.set" - filename = temporary_directory.joinpath( - "RAW", "sub-001", "ses-001", "eeg", testing_eeg_name - ) - raw = mne.io.read_raw_eeglab(filename) - annotations = raw.annotations - assert len(annotations.onset) == 3 - assert annotations.description[0] == "testing_event" - - -def test_populate_label(testing_path: Path) -> None: - """Test that the method populates the labels.""" - dataset = script.DummyDataset( - n_subjects=2, n_sessions=3, n_runs=4, root=testing_path - ) - dataset._populate_labels() - asserting_subject = ["sub-001", "sub-002"] - asserting_session = ["ses-001", "ses-002", "ses-003"] - asserting_run = ["run-001", "run-002", "run-003", "run-004"] - assertion_list = [asserting_subject, asserting_session, asserting_run] - attributes_list = ["subjects", "sessions", "runs"] - for attribute, assertion in zip(attributes_list, assertion_list): - attribute_values = getattr(dataset, attribute) - print(attribute_values) - for i, asserting_label in enumerate(assertion): - assert attribute_values[i] == asserting_label